Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

74 files changed, 12648 insertions, 4957 deletions

diff --git a/drivers/media/video/gspca/Kconfig b/drivers/media/video/gspca/Kconfig
index 23db0c29f68c..34ae2c299799 100644
--- a/drivers/media/video/gspca/Kconfig
+++ b/drivers/media/video/gspca/Kconfig
@@ -77,6 +77,24 @@ config USB_GSPCA_JEILINJ
           To compile this driver as a module, choose M here: the
           module will be called gspca_jeilinj.
 
+config USB_GSPCA_KINECT
+        tristate "Kinect sensor device USB Camera Driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for the Microsoft Kinect sensor device.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_kinect.
+
+config USB_GSPCA_KONICA
+        tristate "Konica USB Camera V4L2 driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for cameras based on the Konica chip.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_konica.
+
 config USB_GSPCA_MARS
         tristate "Mars USB Camera Driver"
         depends on VIDEO_V4L2 && USB_GSPCA
@@ -95,6 +113,15 @@ config USB_GSPCA_MR97310A
           To compile this driver as a module, choose M here: the
           module will be called gspca_mr97310a.
 
+config USB_GSPCA_NW80X
+        tristate "Divio based (NW80x) USB Camera Driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for cameras based on the NW80x chips.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_nw80x.
+
 config USB_GSPCA_OV519
         tristate "OV51x / OVFX2 / W996xCF USB Camera Driver"
         depends on VIDEO_V4L2 && USB_GSPCA
@@ -337,6 +364,25 @@ config USB_GSPCA_VC032X
           To compile this driver as a module, choose M here: the
           module will be called gspca_vc032x.
 
+config USB_GSPCA_VICAM
+        tristate "ViCam USB Camera Driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for the 3com homeconnect camera
+          (vicam).
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_vicam.
+
+config USB_GSPCA_XIRLINK_CIT
+        tristate "Xirlink C-It USB Camera Driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for Xirlink C-It bases cameras.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_xirlink_cit.
+
 config USB_GSPCA_ZC3XX
         tristate "ZC3XX USB Camera Driver"
         depends on VIDEO_V4L2 && USB_GSPCA
diff --git a/drivers/media/video/gspca/Makefile b/drivers/media/video/gspca/Makefile
index f6616db0b7f8..802fbe1bff4a 100644
--- a/drivers/media/video/gspca/Makefile
+++ b/drivers/media/video/gspca/Makefile
@@ -5,8 +5,11 @@ 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
+obj-$(CONFIG_USB_GSPCA_KINECT)   += gspca_kinect.o
+obj-$(CONFIG_USB_GSPCA_KONICA)   += gspca_konica.o
 obj-$(CONFIG_USB_GSPCA_MARS)     += gspca_mars.o
 obj-$(CONFIG_USB_GSPCA_MR97310A) += gspca_mr97310a.o
+obj-$(CONFIG_USB_GSPCA_NW80X)    += gspca_nw80x.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
@@ -33,6 +36,8 @@ obj-$(CONFIG_USB_GSPCA_STV0680)  += gspca_stv0680.o
 obj-$(CONFIG_USB_GSPCA_T613)     += gspca_t613.o
 obj-$(CONFIG_USB_GSPCA_TV8532)   += gspca_tv8532.o
 obj-$(CONFIG_USB_GSPCA_VC032X)   += gspca_vc032x.o
+obj-$(CONFIG_USB_GSPCA_VICAM)    += gspca_vicam.o
+obj-$(CONFIG_USB_GSPCA_XIRLINK_CIT) += gspca_xirlink_cit.o
 obj-$(CONFIG_USB_GSPCA_ZC3XX)    += gspca_zc3xx.o
 
 gspca_main-objs     := gspca.o
@@ -42,8 +47,11 @@ gspca_cpia1-objs    := cpia1.o
 gspca_etoms-objs    := etoms.o
 gspca_finepix-objs  := finepix.o
 gspca_jeilinj-objs  := jeilinj.o
+gspca_kinect-objs   := kinect.o
+gspca_konica-objs   := konica.o
 gspca_mars-objs     := mars.o
 gspca_mr97310a-objs := mr97310a.o
+gspca_nw80x-objs    := nw80x.o
 gspca_ov519-objs    := ov519.o
 gspca_ov534-objs    := ov534.o
 gspca_ov534_9-objs  := ov534_9.o
@@ -70,6 +78,8 @@ gspca_sunplus-objs  := sunplus.o
 gspca_t613-objs     := t613.o
 gspca_tv8532-objs   := tv8532.o
 gspca_vc032x-objs   := vc032x.o
+gspca_vicam-objs    := vicam.o
+gspca_xirlink_cit-objs := xirlink_cit.o
 gspca_zc3xx-objs    := zc3xx.o
 
 obj-$(CONFIG_USB_M5602)   += m5602/
diff --git a/drivers/media/video/gspca/autogain_functions.h b/drivers/media/video/gspca/autogain_functions.h
new file mode 100644
index 000000000000..46777eee678b
--- /dev/null
+++ b/drivers/media/video/gspca/autogain_functions.h
@@ -0,0 +1,179 @@
+/*
+ * Functions for auto gain.
+ *
+ * Copyright (C) 2010-2011 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
+ */
+
+/* auto gain and exposure algorithm based on the knee algorithm described here:
+   http://ytse.tricolour.net/docs/LowLightOptimization.html
+
+   Returns 0 if no changes were made, 1 if the gain and or exposure settings
+   where changed. */
+static inline int auto_gain_n_exposure(
+                        struct gspca_dev *gspca_dev,
+                        int avg_lum,
+                        int desired_avg_lum,
+                        int deadzone,
+                        int gain_knee,
+                        int exposure_knee)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int i, steps, gain, orig_gain, exposure, orig_exposure;
+        int retval = 0;
+
+        orig_gain = gain = sd->ctrls[GAIN].val;
+        orig_exposure = exposure = sd->ctrls[EXPOSURE].val;
+
+        /* 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 = abs(desired_avg_lum - avg_lum) / deadzone;
+
+        PDEBUG(D_FRAM, "autogain: lum: %d, desired: %d, steps: %d",
+                avg_lum, desired_avg_lum, steps);
+
+        for (i = 0; i < steps; i++) {
+                if (avg_lum > desired_avg_lum) {
+                        if (gain > gain_knee)
+                                gain--;
+                        else if (exposure > exposure_knee)
+                                exposure--;
+                        else if (gain > sd->ctrls[GAIN].def)
+                                gain--;
+                        else if (exposure > sd->ctrls[EXPOSURE].min)
+                                exposure--;
+                        else if (gain > sd->ctrls[GAIN].min)
+                                gain--;
+                        else
+                                break;
+                } else {
+                        if (gain < sd->ctrls[GAIN].def)
+                                gain++;
+                        else if (exposure < exposure_knee)
+                                exposure++;
+                        else if (gain < gain_knee)
+                                gain++;
+                        else if (exposure < sd->ctrls[EXPOSURE].max)
+                                exposure++;
+                        else if (gain < sd->ctrls[GAIN].max)
+                                gain++;
+                        else
+                                break;
+                }
+        }
+
+        if (gain != orig_gain) {
+                sd->ctrls[GAIN].val = gain;
+                setgain(gspca_dev);
+                retval = 1;
+        }
+        if (exposure != orig_exposure) {
+                sd->ctrls[EXPOSURE].val = exposure;
+                setexposure(gspca_dev);
+                retval = 1;
+        }
+
+        if (retval)
+                PDEBUG(D_FRAM, "autogain: changed gain: %d, expo: %d",
+                        gain, exposure);
+        return retval;
+}
+
+/* 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 inline int coarse_grained_expo_autogain(
+                        struct gspca_dev *gspca_dev,
+                        int avg_lum,
+                        int desired_avg_lum,
+                        int deadzone)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int steps, gain, orig_gain, exposure, orig_exposure;
+        int gain_low, gain_high;
+        int retval = 0;
+
+        orig_gain = gain = sd->ctrls[GAIN].val;
+        orig_exposure = exposure = sd->ctrls[EXPOSURE].val;
+
+        gain_low = (sd->ctrls[GAIN].max - sd->ctrls[GAIN].min) / 5 * 2;
+        gain_low += sd->ctrls[GAIN].min;
+        gain_high = (sd->ctrls[GAIN].max - sd->ctrls[GAIN].min) / 5 * 4;
+        gain_high += sd->ctrls[GAIN].min;
+
+        /* 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 &&
+            exposure < sd->ctrls[EXPOSURE].max) {
+                gain = gain_high;
+                sd->exp_too_low_cnt++;
+                sd->exp_too_high_cnt = 0;
+        } else if ((gain + steps) < gain_low &&
+                   exposure > sd->ctrls[EXPOSURE].min) {
+                gain = gain_low;
+                sd->exp_too_high_cnt++;
+                sd->exp_too_low_cnt = 0;
+        } else {
+                gain += steps;
+                if (gain > sd->ctrls[GAIN].max)
+                        gain = sd->ctrls[GAIN].max;
+                else if (gain < sd->ctrls[GAIN].min)
+                        gain = sd->ctrls[GAIN].min;
+                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) {
+                sd->ctrls[GAIN].val = gain;
+                setgain(gspca_dev);
+                retval = 1;
+        }
+        if (exposure != orig_exposure) {
+                sd->ctrls[EXPOSURE].val = exposure;
+                setexposure(gspca_dev);
+                retval = 1;
+        }
+
+        if (retval)
+                PDEBUG(D_FRAM, "autogain: changed gain: %d, expo: %d",
+                        gain, exposure);
+        return retval;
+}
diff --git a/drivers/media/video/gspca/benq.c b/drivers/media/video/gspca/benq.c
index fce8d9492641..a09c4709d613 100644
--- a/drivers/media/video/gspca/benq.c
+++ b/drivers/media/video/gspca/benq.c
@@ -62,7 +62,7 @@ static void reg_w(struct gspca_dev *gspca_dev,
                         0,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w err %d", ret);
+                err("reg_w err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -152,7 +152,8 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
         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);
+        usb_set_interface(gspca_dev->dev, gspca_dev->iface,
+                                        gspca_dev->nbalt - 1);
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
@@ -180,7 +181,7 @@ static void sd_isoc_irq(struct urb *urb)
                 if (gspca_dev->frozen)
                         return;
 #endif
-                PDEBUG(D_ERR|D_PACK, "urb status: %d", urb->status);
+                err("urb status: %d", urb->status);
                 return;
         }
 
@@ -208,8 +209,7 @@ static void sd_isoc_irq(struct urb *urb)
                 if (st == 0)
                         st = urb->iso_frame_desc[i].status;
                 if (st) {
-                        PDEBUG(D_ERR,
-                                "ISOC data error: [%d] status=%d",
+                        err("ISOC data error: [%d] status=%d",
                                 i, st);
                         gspca_dev->last_packet_type = DISCARD_PACKET;
                         continue;
@@ -256,10 +256,10 @@ static void sd_isoc_irq(struct urb *urb)
         /* 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);
+                err("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);
+                err("usb_submit_urb() ret %d", st);
 }
 
 /* sub-driver description */
@@ -276,7 +276,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x04a5, 0x3035)},
         {}
 };
@@ -304,18 +304,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        info("deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/coarse_expo_autogain.h b/drivers/media/video/gspca/coarse_expo_autogain.h
deleted file mode 100644
index 1cb9d941eaf6..000000000000
--- a/drivers/media/video/gspca/coarse_expo_autogain.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * 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 d6a75772f3f8..8b398493f96b 100644
--- a/drivers/media/video/gspca/conex.c
+++ b/drivers/media/video/gspca/conex.c
@@ -687,7 +687,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev)
         reg_w_val(gspca_dev, 0x00c0, 0x00);
         reg_r(gspca_dev, 0x0001, 1);
         length = 8;
-        switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
+        switch (gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv) {
         case 0:
                 for (i = 0; i < 27; i++) {
                         if (i == 26)
@@ -901,7 +901,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
-static void setbrightness(struct gspca_dev*gspca_dev)
+static void setbrightness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         __u8 regE5cbx[] = { 0x88, 0x00, 0xd4, 0x01, 0x88, 0x01, 0x01, 0x01 };
@@ -924,7 +924,7 @@ static void setbrightness(struct gspca_dev*gspca_dev)
         reg_w_val(gspca_dev, 0x0070, reg70);
 }
 
-static void setcontrast(struct gspca_dev*gspca_dev)
+static void setcontrast(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         __u8 regE5acx[] = { 0x88, 0x0a, 0x0c, 0x01 };   /* seem MSB */
@@ -1040,14 +1040,14 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const struct usb_device_id device_table[] __devinitconst = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0572, 0x0041)},
         {}
 };
 MODULE_DEVICE_TABLE(usb, device_table);
 
 /* -- device connect -- */
-static int __devinit sd_probe(struct usb_interface *intf,
+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),
@@ -1068,17 +1068,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/cpia1.c b/drivers/media/video/gspca/cpia1.c
index 3747a1dcff54..f2a9451eea19 100644
--- a/drivers/media/video/gspca/cpia1.c
+++ b/drivers/media/video/gspca/cpia1.c
@@ -1,7 +1,7 @@
 /*
  * cpia CPiA (1) gspca driver
  *
- * Copyright (C) 2010 Hans de Goede <hdgoede@redhat.com>
+ * Copyright (C) 2010-2011 Hans de Goede <hdegoede@redhat.com>
  *
  * This module is adapted from the in kernel v4l1 cpia driver which is :
  *
@@ -28,16 +28,17 @@
 
 #define MODULE_NAME "cpia1"
 
+#include <linux/input.h>
 #include "gspca.h"
 
-MODULE_AUTHOR("Hans de Goede <hdgoede@redhat.com>");
+MODULE_AUTHOR("Hans de Goede <hdegoede@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_IN         0xc0
 #define DATA_OUT        0x40
 #define VIDEOSIZE_QCIF  0       /* 176x144 */
 #define VIDEOSIZE_CIF   1       /* 352x288 */
@@ -373,9 +374,14 @@ 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 int sd_setilluminator1(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getilluminator1(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setilluminator2(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getilluminator2(struct gspca_dev *gspca_dev, __s32 *val);
 
 static const struct ctrl sd_ctrls[] = {
         {
+#define BRIGHTNESS_IDX 0
             {
                 .id      = V4L2_CID_BRIGHTNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -390,6 +396,7 @@ static const struct ctrl sd_ctrls[] = {
             .set = sd_setbrightness,
             .get = sd_getbrightness,
         },
+#define CONTRAST_IDX 1
         {
             {
                 .id      = V4L2_CID_CONTRAST,
@@ -404,6 +411,7 @@ static const struct ctrl sd_ctrls[] = {
             .set = sd_setcontrast,
             .get = sd_getcontrast,
         },
+#define SATURATION_IDX 2
         {
             {
                 .id      = V4L2_CID_SATURATION,
@@ -418,6 +426,7 @@ static const struct ctrl sd_ctrls[] = {
             .set = sd_setsaturation,
             .get = sd_getsaturation,
         },
+#define POWER_LINE_FREQUENCY_IDX 3
         {
                 {
                         .id      = V4L2_CID_POWER_LINE_FREQUENCY,
@@ -432,6 +441,37 @@ static const struct ctrl sd_ctrls[] = {
                 .set = sd_setfreq,
                 .get = sd_getfreq,
         },
+#define ILLUMINATORS_1_IDX 4
+        {
+                {
+                        .id      = V4L2_CID_ILLUMINATORS_1,
+                        .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name    = "Illuminator 1",
+                        .minimum = 0,
+                        .maximum = 1,
+                        .step    = 1,
+#define ILLUMINATORS_1_DEF 0
+                        .default_value = ILLUMINATORS_1_DEF,
+                },
+                .set = sd_setilluminator1,
+                .get = sd_getilluminator1,
+        },
+#define ILLUMINATORS_2_IDX 5
+        {
+                {
+                        .id      = V4L2_CID_ILLUMINATORS_2,
+                        .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name    = "Illuminator 2",
+                        .minimum = 0,
+                        .maximum = 1,
+                        .step    = 1,
+#define ILLUMINATORS_2_DEF 0
+                        .default_value = ILLUMINATORS_2_DEF,
+                },
+                .set = sd_setilluminator2,
+                .get = sd_getilluminator2,
+        },
+#define COMP_TARGET_IDX 6
         {
                 {
 #define V4L2_CID_COMP_TARGET V4L2_CID_PRIVATE_BASE
@@ -510,7 +550,7 @@ retry:
                               gspca_dev->usb_buf, databytes, 1000);
 
         if (ret < 0)
-                PDEBUG(D_ERR, "usb_control_msg %02x, error %d", command[1],
+                err("usb_control_msg %02x, error %d", command[1],
                        ret);
 
         if (ret == -EPIPE && retries > 0) {
@@ -614,16 +654,21 @@ static int do_command(struct gspca_dev *gspca_dev, u16 command,
                 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);
+                a = ((gspca_dev->usb_buf[1] & 0x02) == 0);
+                if (a != sd->params.qx3.button) {
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+                        input_report_key(gspca_dev->input_dev, KEY_CAMERA, a);
+                        input_sync(gspca_dev->input_dev);
+#endif
+                        sd->params.qx3.button = a;
+                }
                 if (sd->params.qx3.button) {
                         /* button pressed - unlock the latch */
                         do_command(gspca_dev, CPIA_COMMAND_WriteMCPort,
-                                   3, 0xDF, 0xDF, 0);
+                                   3, 0xdf, 0xdf, 0);
                         do_command(gspca_dev, CPIA_COMMAND_WriteMCPort,
-                                   3, 0xFF, 0xFF, 0);
+                                   3, 0xff, 0xff, 0);
                 }
 
                 /* test whether microscope is cradled */
@@ -790,7 +835,7 @@ static int goto_low_power(struct gspca_dev *gspca_dev)
         if (ret)
                 return ret;
 
-        do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
+        ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
         if (ret)
                 return ret;
 
@@ -1059,7 +1104,6 @@ static int command_resume(struct gspca_dev *gspca_dev)
                           0, sd->params.streamStartLine, 0, 0);
 }
 
-#if 0 /* Currently unused */
 static int command_setlights(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -1072,14 +1116,13 @@ static int command_setlights(struct gspca_dev *gspca_dev)
         p2 = (sd->params.qx3.toplight == 0) << 3;
 
         ret = do_command(gspca_dev, CPIA_COMMAND_WriteVCReg,
-                         0x90, 0x8F, 0x50, 0);
+                         0x90, 0x8f, 0x50, 0);
         if (ret)
                 return ret;
 
         return do_command(gspca_dev, CPIA_COMMAND_WriteMCPort, 2, 0,
-                          p1 | p2 | 0xE0, 0);
+                          p1 | p2 | 0xe0, 0);
 }
-#endif
 
 static int set_flicker(struct gspca_dev *gspca_dev, int on, int apply)
 {
@@ -1219,7 +1262,7 @@ static int set_flicker(struct gspca_dev *gspca_dev, int on, int apply)
 static void monitor_exposure(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        u8 exp_acc, bcomp, gain, coarseL, cmd[8];
+        u8 exp_acc, bcomp, cmd[8];
         int ret, light_exp, dark_exp, very_dark_exp;
         int old_exposure, new_exposure, framerate;
         int setfps = 0, setexp = 0, setflicker = 0;
@@ -1236,13 +1279,11 @@ static void monitor_exposure(struct gspca_dev *gspca_dev)
         cmd[7] = 0;
         ret = cpia_usb_transferCmd(gspca_dev, cmd);
         if (ret) {
-                PDEBUG(D_ERR, "ReadVPRegs(30,4,9,8) - failed: %d", ret);
+                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;
@@ -1363,7 +1404,7 @@ static void monitor_exposure(struct gspca_dev *gspca_dev)
                 if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
                      sd->exposure_status == EXPOSURE_DARK) &&
                     sd->exposure_count >= DARK_TIME * framerate &&
-                    sd->params.sensorFps.divisor < 3) {
+                    sd->params.sensorFps.divisor < 2) {
 
                         /* dark for too long */
                         ++sd->params.sensorFps.divisor;
@@ -1419,7 +1460,7 @@ static void monitor_exposure(struct gspca_dev *gspca_dev)
                 if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
                      sd->exposure_status == EXPOSURE_DARK) &&
                     sd->exposure_count >= DARK_TIME * framerate &&
-                    sd->params.sensorFps.divisor < 3) {
+                    sd->params.sensorFps.divisor < 2) {
 
                         /* dark for too long */
                         ++sd->params.sensorFps.divisor;
@@ -1701,6 +1742,8 @@ static int sd_start(struct gspca_dev *gspca_dev)
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
+        struct sd *sd = (struct sd *) gspca_dev;
+
         command_pause(gspca_dev);
 
         /* save camera state for later open (developers guide ch 3.5.3) */
@@ -1711,6 +1754,17 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
 
         /* Update the camera status */
         do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
+
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+        /* If the last button state is pressed, release it now! */
+        if (sd->params.qx3.button) {
+                /* The camera latch will hold the pressed state until we reset
+                   the latch, so we do not reset sd->params.qx3.button now, to
+                   avoid a false keypress being reported the next sd_start */
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                input_sync(gspca_dev->input_dev);
+        }
+#endif
 }
 
 /* this function is called at probe and resume time */
@@ -1726,6 +1780,14 @@ static int sd_init(struct gspca_dev *gspca_dev)
         if (ret)
                 return ret;
 
+        /* Ensure the QX3 illuminators' states are restored upon resume,
+           or disable the illuminator controls, if this isn't a QX3 */
+        if (sd->params.qx3.qx3_detected)
+                command_setlights(gspca_dev);
+        else
+                gspca_dev->ctrl_dis |=
+                        ((1 << ILLUMINATORS_1_IDX) | (1 << ILLUMINATORS_2_IDX));
+
         sd_stopN(gspca_dev);
 
         PDEBUG(D_PROBE, "CPIA Version:             %d.%02d (%d.%d)",
@@ -1805,8 +1867,7 @@ static void sd_dq_callback(struct gspca_dev *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);
+        do_command(gspca_dev, CPIA_COMMAND_ReadMCPorts, 0, 0, 0, 0);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
@@ -1929,6 +1990,72 @@ static int sd_getcomptarget(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
+static int sd_setilluminator(struct gspca_dev *gspca_dev, __s32 val, int n)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int ret;
+
+        if (!sd->params.qx3.qx3_detected)
+                return -EINVAL;
+
+        switch (n) {
+        case 1:
+                sd->params.qx3.bottomlight = val ? 1 : 0;
+                break;
+        case 2:
+                sd->params.qx3.toplight = val ? 1 : 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = command_setlights(gspca_dev);
+        if (ret && ret != -EINVAL)
+                ret = -EBUSY;
+
+        return ret;
+}
+
+static int sd_setilluminator1(struct gspca_dev *gspca_dev, __s32 val)
+{
+        return sd_setilluminator(gspca_dev, val, 1);
+}
+
+static int sd_setilluminator2(struct gspca_dev *gspca_dev, __s32 val)
+{
+        return sd_setilluminator(gspca_dev, val, 2);
+}
+
+static int sd_getilluminator(struct gspca_dev *gspca_dev, __s32 *val, int n)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (!sd->params.qx3.qx3_detected)
+                return -EINVAL;
+
+        switch (n) {
+        case 1:
+                *val = sd->params.qx3.bottomlight;
+                break;
+        case 2:
+                *val = sd->params.qx3.toplight;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int sd_getilluminator1(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        return sd_getilluminator(gspca_dev, val, 1);
+}
+
+static int sd_getilluminator2(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        return sd_getilluminator(gspca_dev, val, 2);
+}
+
 static int sd_querymenu(struct gspca_dev *gspca_dev,
                         struct v4l2_querymenu *menu)
 {
@@ -1972,10 +2099,13 @@ static const struct sd_desc sd_desc = {
         .dq_callback = sd_dq_callback,
         .pkt_scan = sd_pkt_scan,
         .querymenu = sd_querymenu,
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+        .other_input = 1,
+#endif
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0553, 0x0002)},
         {USB_DEVICE(0x0813, 0x0001)},
         {}
@@ -2004,17 +2134,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c
index ecd4d743d2bc..4b2c483fce6f 100644
--- a/drivers/media/video/gspca/etoms.c
+++ b/drivers/media/video/gspca/etoms.c
@@ -710,9 +710,9 @@ static void Et_setgainG(struct gspca_dev *gspca_dev, __u8 gain)
 }
 
 #define BLIMIT(bright) \
-        (__u8)((bright > 0x1f)?0x1f:((bright < 4)?3:bright))
+        (u8)((bright > 0x1f) ? 0x1f : ((bright < 4) ? 3 : bright))
 #define LIMIT(color) \
-        (unsigned char)((color > 0xff)?0xff:((color < 0)?0:color))
+        (u8)((color > 0xff) ? 0xff : ((color < 0) ? 0 : color))
 
 static void do_autogain(struct gspca_dev *gspca_dev)
 {
@@ -864,7 +864,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const struct usb_device_id device_table[] __devinitconst = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x102c, 0x6151), .driver_info = SENSOR_PAS106},
 #if !defined CONFIG_USB_ET61X251 && !defined CONFIG_USB_ET61X251_MODULE
         {USB_DEVICE(0x102c, 0x6251), .driver_info = SENSOR_TAS5130CXX},
@@ -875,7 +875,7 @@ static const struct usb_device_id device_table[] __devinitconst = {
 MODULE_DEVICE_TABLE(usb, device_table);
 
 /* -- device connect -- */
-static int __devinit sd_probe(struct usb_interface *intf,
+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),
@@ -896,18 +896,12 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/finepix.c b/drivers/media/video/gspca/finepix.c
index 5d90e7448579..987b4b69d7ab 100644
--- a/drivers/media/video/gspca/finepix.c
+++ b/drivers/media/video/gspca/finepix.c
@@ -182,7 +182,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
         /* Init the device */
         ret = command(gspca_dev, 0);
         if (ret < 0) {
-                PDEBUG(D_STREAM, "init failed %d", ret);
+                err("init failed %d", ret);
                 return ret;
         }
 
@@ -194,14 +194,14 @@ static int sd_start(struct gspca_dev *gspca_dev)
                         FPIX_MAX_TRANSFER, &len,
                         FPIX_TIMEOUT);
         if (ret < 0) {
-                PDEBUG(D_STREAM, "usb_bulk_msg failed %d", ret);
+                err("usb_bulk_msg failed %d", ret);
                 return ret;
         }
 
         /* Request a frame, but don't read it */
         ret = command(gspca_dev, 1);
         if (ret < 0) {
-                PDEBUG(D_STREAM, "frame request failed %d", ret);
+                err("frame request failed %d", ret);
                 return ret;
         }
 
@@ -229,7 +229,7 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
 }
 
 /* Table of supported USB devices */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x04cb, 0x0104)},
         {USB_DEVICE(0x04cb, 0x0109)},
         {USB_DEVICE(0x04cb, 0x010b)},
@@ -291,19 +291,12 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/gl860/gl860-mi1320.c b/drivers/media/video/gspca/gl860/gl860-mi1320.c
index c276a7debdec..b57160e04866 100644
--- a/drivers/media/video/gspca/gl860/gl860-mi1320.c
+++ b/drivers/media/video/gspca/gl860/gl860-mi1320.c
@@ -201,7 +201,7 @@ void mi1320_init_settings(struct gspca_dev *gspca_dev)
         sd->vmax.backlight  =  2;
         sd->vmax.brightness =  8;
         sd->vmax.sharpness  =  7;
-        sd->vmax.contrast   =  0; /* 10 but not working with tihs driver */
+        sd->vmax.contrast   =  0; /* 10 but not working with this driver */
         sd->vmax.gamma      = 40;
         sd->vmax.hue        =  5 + 1;
         sd->vmax.saturation =  8;
diff --git a/drivers/media/video/gspca/gl860/gl860-mi2020.c b/drivers/media/video/gspca/gl860/gl860-mi2020.c
index 57782e011c9e..2edda6b7d653 100644
--- a/drivers/media/video/gspca/gl860/gl860-mi2020.c
+++ b/drivers/media/video/gspca/gl860/gl860-mi2020.c
@@ -69,15 +69,15 @@ static u8 dat_multi5[] = { 0x8c, 0xa1, 0x03 };
 static u8 dat_multi6[] = { 0x90, 0x00, 0x05 };
 
 static struct validx tbl_init_at_startup[] = {
-        {0x0000, 0x0000}, {0x0010, 0x0010}, {0x0008, 0x00c0}, {0x0001,0x00c1},
+        {0x0000, 0x0000}, {0x0010, 0x0010}, {0x0008, 0x00c0}, {0x0001, 0x00c1},
         {0x0001, 0x00c2}, {0x0020, 0x0006}, {0x006a, 0x000d},
         {53, 0xffff},
         {0x0040, 0x0000}, {0x0063, 0x0006},
 };
 
 static struct validx tbl_common_0B[] = {
-        {0x0002, 0x0004}, {0x006a, 0x0007}, {0x00ef, 0x0006}, {0x006a,0x000d},
-        {0x0000, 0x00c0}, {0x0010, 0x0010}, {0x0003, 0x00c1}, {0x0042,0x00c2},
+        {0x0002, 0x0004}, {0x006a, 0x0007}, {0x00ef, 0x0006}, {0x006a, 0x000d},
+        {0x0000, 0x00c0}, {0x0010, 0x0010}, {0x0003, 0x00c1}, {0x0042, 0x00c2},
         {0x0004, 0x00d8}, {0x0000, 0x0058}, {0x0041, 0x0000},
 };
 
diff --git a/drivers/media/video/gspca/gl860/gl860.c b/drivers/media/video/gspca/gl860/gl860.c
index e86eb8b4aedc..e8e071aa212f 100644
--- a/drivers/media/video/gspca/gl860/gl860.c
+++ b/drivers/media/video/gspca/gl860/gl860.c
@@ -488,7 +488,7 @@ static void sd_callback(struct gspca_dev *gspca_dev)
 
 /*=================== USB driver structure initialisation ==================*/
 
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x05e3, 0x0503)},
         {USB_DEVICE(0x05e3, 0xf191)},
         {}
@@ -499,21 +499,8 @@ MODULE_DEVICE_TABLE(usb, device_table);
 static int sd_probe(struct usb_interface *intf,
                                 const struct usb_device_id *id)
 {
-        struct gspca_dev *gspca_dev;
-        s32 ret;
-
-        ret = gspca_dev_probe(intf, id,
+        return gspca_dev_probe(intf, id,
                         &sd_desc_mi1320, sizeof(struct sd), THIS_MODULE);
-
-        if (ret >= 0) {
-                gspca_dev = usb_get_intfdata(intf);
-
-                PDEBUG(D_PROBE,
-                        "Camera is now controlling video device %s",
-                        video_device_node_name(&gspca_dev->vdev));
-        }
-
-        return ret;
 }
 
 static void sd_disconnect(struct usb_interface *intf)
@@ -540,15 +527,12 @@ static int __init sd_mod_init(void)
 
         if (usb_register(&sd_driver) < 0)
                 return -1;
-        PDEBUG(D_PROBE, "driver registered");
-
         return 0;
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "driver deregistered");
 }
 
 module_init(sd_mod_init);
@@ -588,8 +572,7 @@ int gl860_RTx(struct gspca_dev *gspca_dev,
         }
 
         if (r < 0)
-                PDEBUG(D_ERR,
-                        "ctrl transfer failed %4d "
+                err("ctrl transfer failed %4d "
                         "[p%02x r%d v%04x i%04x len%d]",
                         r, pref, req, val, index, len);
         else if (len > 1 && r < len)
diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c
index 78abc1c1f9d5..08ce9948d99b 100644
--- a/drivers/media/video/gspca/gspca.c
+++ b/drivers/media/video/gspca/gspca.c
@@ -1,7 +1,7 @@
 /*
  * Main USB camera driver
  *
- * Copyright (C) 2008-2010 Jean-François Moine <http://moinejf.free.fr>
+ * Copyright (C) 2008-2011 Jean-François 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>
@@ -55,7 +55,7 @@ MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
 MODULE_DESCRIPTION("GSPCA USB Camera Driver");
 MODULE_LICENSE("GPL");
 
-#define DRIVER_VERSION_NUMBER   KERNEL_VERSION(2, 10, 0)
+#define DRIVER_VERSION_NUMBER   KERNEL_VERSION(2, 13, 0)
 
 #ifdef GSPCA_DEBUG
 int gspca_debug = D_ERR | D_PROBE;
@@ -148,7 +148,7 @@ static void int_irq(struct urb *urb)
         if (ret == 0) {
                 ret = usb_submit_urb(urb, GFP_ATOMIC);
                 if (ret < 0)
-                        PDEBUG(D_ERR, "Resubmit URB failed with error %i", ret);
+                        err("Resubmit URB failed with error %i", ret);
         }
 }
 
@@ -177,8 +177,8 @@ static int gspca_input_connect(struct gspca_dev *dev)
 
                 err = input_register_device(input_dev);
                 if (err) {
-                        PDEBUG(D_ERR, "Input device registration failed "
-                                "with error %i", err);
+                        err("Input device registration failed with error %i",
+                                err);
                         input_dev->dev.parent = NULL;
                         input_free_device(input_dev);
                 } else {
@@ -224,12 +224,12 @@ static int alloc_and_submit_int_urb(struct gspca_dev *gspca_dev,
                 buffer, buffer_len,
                 int_irq, (void *)gspca_dev, interval);
         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        gspca_dev->int_urb = urb;
         ret = usb_submit_urb(urb, GFP_KERNEL);
         if (ret < 0) {
                 PDEBUG(D_ERR, "submit int URB failed with error %i", ret);
                 goto error_submit;
         }
+        gspca_dev->int_urb = urb;
         return ret;
 
 error_submit:
@@ -318,22 +318,21 @@ static void fill_frame(struct gspca_dev *gspca_dev,
         }
         pkt_scan = gspca_dev->sd_desc->pkt_scan;
         for (i = 0; i < urb->number_of_packets; i++) {
+                len = urb->iso_frame_desc[i].actual_length;
 
                 /* check the packet status and length */
-                len = urb->iso_frame_desc[i].actual_length;
-                if (len == 0) {
-                        if (gspca_dev->empty_packet == 0)
-                                gspca_dev->empty_packet = 1;
-                        continue;
-                }
                 st = urb->iso_frame_desc[i].status;
                 if (st) {
-                        PDEBUG(D_ERR,
-                                "ISOC data error: [%d] len=%d, status=%d",
+                        err("ISOC data error: [%d] len=%d, status=%d",
                                 i, len, st);
                         gspca_dev->last_packet_type = DISCARD_PACKET;
                         continue;
                 }
+                if (len == 0) {
+                        if (gspca_dev->empty_packet == 0)
+                                gspca_dev->empty_packet = 1;
+                        continue;
+                }
 
                 /* let the packet be analyzed by the subdriver */
                 PDEBUG(D_PACK, "packet [%d] o:%d l:%d",
@@ -347,7 +346,7 @@ resubmit:
         /* resubmit the URB */
         st = usb_submit_urb(urb, GFP_ATOMIC);
         if (st < 0)
-                PDEBUG(D_ERR|D_PACK, "usb_submit_urb() ret %d", st);
+                err("usb_submit_urb() ret %d", st);
 }
 
 /*
@@ -401,7 +400,7 @@ resubmit:
         if (gspca_dev->cam.bulk_nurbs != 0) {
                 st = usb_submit_urb(urb, GFP_ATOMIC);
                 if (st < 0)
-                        PDEBUG(D_ERR|D_PACK, "usb_submit_urb() ret %d", st);
+                        err("usb_submit_urb() ret %d", st);
         }
 }
 
@@ -415,7 +414,6 @@ resubmit:
  *      - 0 or many INTER_PACKETs
  *      - one LAST_PACKET
  * DISCARD_PACKET invalidates the whole frame.
- * On LAST_PACKET, a new frame is returned.
  */
 void gspca_frame_add(struct gspca_dev *gspca_dev,
                         enum gspca_packet_type packet_type,
@@ -433,12 +431,13 @@ void gspca_frame_add(struct gspca_dev *gspca_dev,
                 /* if there are no queued buffer, discard the whole frame */
                 if (i == atomic_read(&gspca_dev->fr_q)) {
                         gspca_dev->last_packet_type = DISCARD_PACKET;
+                        gspca_dev->sequence++;
                         return;
                 }
                 j = gspca_dev->fr_queue[i];
                 frame = &gspca_dev->frame[j];
                 frame->v4l2_buf.timestamp = ktime_to_timeval(ktime_get());
-                frame->v4l2_buf.sequence = ++gspca_dev->sequence;
+                frame->v4l2_buf.sequence = gspca_dev->sequence++;
                 gspca_dev->image = frame->data;
                 gspca_dev->image_len = 0;
         } else {
@@ -508,8 +507,8 @@ static int gspca_is_compressed(__u32 format)
         return 0;
 }
 
-static int frame_alloc(struct gspca_dev *gspca_dev,
-                        unsigned int count)
+static int frame_alloc(struct gspca_dev *gspca_dev, struct file *file,
+                        enum v4l2_memory memory, unsigned int count)
 {
         struct gspca_frame *frame;
         unsigned int frsz;
@@ -519,7 +518,6 @@ static int frame_alloc(struct gspca_dev *gspca_dev,
         frsz = gspca_dev->cam.cam_mode[i].sizeimage;
         PDEBUG(D_STREAM, "frame alloc frsz: %d", frsz);
         frsz = PAGE_ALIGN(frsz);
-        gspca_dev->frsz = frsz;
         if (count >= GSPCA_MAX_FRAMES)
                 count = GSPCA_MAX_FRAMES - 1;
         gspca_dev->frbuf = vmalloc_32(frsz * count);
@@ -527,6 +525,9 @@ static int frame_alloc(struct gspca_dev *gspca_dev,
                 err("frame alloc failed");
                 return -ENOMEM;
         }
+        gspca_dev->capt_file = file;
+        gspca_dev->memory = memory;
+        gspca_dev->frsz = frsz;
         gspca_dev->nframes = count;
         for (i = 0; i < count; i++) {
                 frame = &gspca_dev->frame[i];
@@ -535,7 +536,7 @@ static int frame_alloc(struct gspca_dev *gspca_dev,
                 frame->v4l2_buf.flags = 0;
                 frame->v4l2_buf.field = V4L2_FIELD_NONE;
                 frame->v4l2_buf.length = frsz;
-                frame->v4l2_buf.memory = gspca_dev->memory;
+                frame->v4l2_buf.memory = memory;
                 frame->v4l2_buf.sequence = 0;
                 frame->data = gspca_dev->frbuf + i * frsz;
                 frame->v4l2_buf.m.offset = i * frsz;
@@ -558,6 +559,9 @@ static void frame_free(struct gspca_dev *gspca_dev)
                         gspca_dev->frame[i].data = NULL;
         }
         gspca_dev->nframes = 0;
+        gspca_dev->frsz = 0;
+        gspca_dev->capt_file = NULL;
+        gspca_dev->memory = GSPCA_MEMORY_NO;
 }
 
 static void destroy_urbs(struct gspca_dev *gspca_dev)
@@ -590,7 +594,7 @@ static int gspca_set_alt0(struct gspca_dev *gspca_dev)
                 return 0;
         ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0);
         if (ret < 0)
-                PDEBUG(D_ERR|D_STREAM, "set alt 0 err %d", ret);
+                err("set alt 0 err %d", ret);
         return ret;
 }
 
@@ -626,7 +630,8 @@ static struct usb_host_endpoint *alt_xfer(struct usb_host_interface *alt,
                 ep = &alt->endpoint[i];
                 attr = ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
                 if (attr == xfer
-                    && ep->desc.wMaxPacketSize != 0)
+                    && ep->desc.wMaxPacketSize != 0
+                    && usb_endpoint_dir_in(&ep->desc))
                         return ep;
         }
         return NULL;
@@ -652,16 +657,12 @@ static struct usb_host_endpoint *get_ep(struct gspca_dev *gspca_dev)
                                    : USB_ENDPOINT_XFER_ISOC;
         i = gspca_dev->alt;                     /* previous alt setting */
         if (gspca_dev->cam.reverse_alts) {
-                if (gspca_dev->audio)
-                        i++;
                 while (++i < gspca_dev->nbalt) {
                         ep = alt_xfer(&intf->altsetting[i], xfer);
                         if (ep)
                                 break;
                 }
         } else {
-                if (gspca_dev->audio)
-                        i--;
                 while (--i >= 0) {
                         ep = alt_xfer(&intf->altsetting[i], xfer);
                         if (ep)
@@ -676,13 +677,11 @@ 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);
                         ep = NULL;
                 }
-                gspca_input_create_urb(gspca_dev);
         }
         return ep;
 }
@@ -759,7 +758,7 @@ static int create_urbs(struct gspca_dev *gspca_dev,
                         }
                 } else {                /* bulk */
                         urb->pipe = usb_rcvbulkpipe(gspca_dev->dev,
-                                                ep->desc.bEndpointAddress),
+                                                ep->desc.bEndpointAddress);
                         urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
                         urb->complete = bulk_irq;
                 }
@@ -781,7 +780,7 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
 
         if (!gspca_dev->present) {
                 ret = -ENODEV;
-                goto out;
+                goto unlock;
         }
 
         /* reset the streaming variables */
@@ -802,8 +801,10 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
         if (gspca_dev->sd_desc->isoc_init) {
                 ret = gspca_dev->sd_desc->isoc_init(gspca_dev);
                 if (ret < 0)
-                        goto out;
+                        goto unlock;
         }
+
+        gspca_input_destroy_urb(gspca_dev);
         ep = get_ep(gspca_dev);
         if (ep == NULL) {
                 ret = -EIO;
@@ -850,14 +851,13 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
                         break;
                 gspca_stream_off(gspca_dev);
                 if (ret != -ENOSPC) {
-                        PDEBUG(D_ERR|D_STREAM,
-                                "usb_submit_urb alt %d err %d",
+                        err("usb_submit_urb alt %d err %d",
                                 gspca_dev->alt, ret);
                         goto out;
                 }
 
                 /* the bandwidth is not wide enough
-                 * negociate or try a lower alternate setting */
+                 * negotiate or try a lower alternate setting */
                 PDEBUG(D_ERR|D_STREAM,
                         "bandwidth not wide enough - trying again");
                 msleep(20);     /* wait for kill complete */
@@ -874,12 +874,15 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
                 }
         }
 out:
+        gspca_input_create_urb(gspca_dev);
+unlock:
         mutex_unlock(&gspca_dev->usb_lock);
         return ret;
 }
 
 static void gspca_set_default_mode(struct gspca_dev *gspca_dev)
 {
+        struct gspca_ctrl *ctrl;
         int i;
 
         i = gspca_dev->cam.nmodes - 1;  /* take the highest mode */
@@ -887,6 +890,16 @@ static void gspca_set_default_mode(struct gspca_dev *gspca_dev)
         gspca_dev->width = gspca_dev->cam.cam_mode[i].width;
         gspca_dev->height = gspca_dev->cam.cam_mode[i].height;
         gspca_dev->pixfmt = gspca_dev->cam.cam_mode[i].pixelformat;
+
+        /* set the current control values to their default values
+         * which may have changed in sd_init() */
+        ctrl = gspca_dev->cam.ctrls;
+        if (ctrl != NULL) {
+                for (i = 0;
+                     i < gspca_dev->sd_desc->nctrls;
+                     i++, ctrl++)
+                        ctrl->val = ctrl->def;
+        }
 }
 
 static int wxh_to_mode(struct gspca_dev *gspca_dev,
@@ -1202,29 +1215,15 @@ static void gspca_release(struct video_device *vfd)
 static int dev_open(struct file *file)
 {
         struct gspca_dev *gspca_dev;
-        int ret;
 
         PDEBUG(D_STREAM, "[%s] open", current->comm);
         gspca_dev = (struct gspca_dev *) video_devdata(file);
-        if (mutex_lock_interruptible(&gspca_dev->queue_lock))
-                return -ERESTARTSYS;
-        if (!gspca_dev->present) {
-                ret = -ENODEV;
-                goto out;
-        }
-
-        if (gspca_dev->users > 4) {     /* (arbitrary value) */
-                ret = -EBUSY;
-                goto out;
-        }
+        if (!gspca_dev->present)
+                return -ENODEV;
 
         /* protect the subdriver against rmmod */
-        if (!try_module_get(gspca_dev->module)) {
-                ret = -ENODEV;
-                goto out;
-        }
-
-        gspca_dev->users++;
+        if (!try_module_get(gspca_dev->module))
+                return -ENODEV;
 
         file->private_data = gspca_dev;
 #ifdef GSPCA_DEBUG
@@ -1236,14 +1235,7 @@ static int dev_open(struct file *file)
                 gspca_dev->vdev.debug &= ~(V4L2_DEBUG_IOCTL
                                         | V4L2_DEBUG_IOCTL_ARG);
 #endif
-        ret = 0;
-out:
-        mutex_unlock(&gspca_dev->queue_lock);
-        if (ret != 0)
-                PDEBUG(D_ERR|D_STREAM, "open failed err %d", ret);
-        else
-                PDEBUG(D_STREAM, "open done");
-        return ret;
+        return 0;
 }
 
 static int dev_close(struct file *file)
@@ -1253,7 +1245,6 @@ static int dev_close(struct file *file)
         PDEBUG(D_STREAM, "[%s] close", current->comm);
         if (mutex_lock_interruptible(&gspca_dev->queue_lock))
                 return -ERESTARTSYS;
-        gspca_dev->users--;
 
         /* if the file did the capture, free the streaming resources */
         if (gspca_dev->capt_file == file) {
@@ -1264,8 +1255,6 @@ static int dev_close(struct file *file)
                         mutex_unlock(&gspca_dev->usb_lock);
                 }
                 frame_free(gspca_dev);
-                gspca_dev->capt_file = NULL;
-                gspca_dev->memory = GSPCA_MEMORY_NO;
         }
         file->private_data = NULL;
         module_put(gspca_dev->module);
@@ -1289,17 +1278,19 @@ static int vidioc_querycap(struct file *file, void  *priv,
                 ret = -ENODEV;
                 goto out;
         }
-        strncpy(cap->driver, gspca_dev->sd_desc->name, sizeof cap->driver);
+        strncpy((char *) cap->driver, gspca_dev->sd_desc->name,
+                        sizeof cap->driver);
         if (gspca_dev->dev->product != NULL) {
-                strncpy(cap->card, gspca_dev->dev->product,
+                strncpy((char *) cap->card, gspca_dev->dev->product,
                         sizeof cap->card);
         } else {
-                snprintf(cap->card, sizeof cap->card,
+                snprintf((char *) cap->card, sizeof cap->card,
                         "USB Camera (%04x:%04x)",
                         le16_to_cpu(gspca_dev->dev->descriptor.idVendor),
                         le16_to_cpu(gspca_dev->dev->descriptor.idProduct));
         }
-        usb_make_path(gspca_dev->dev, cap->bus_info, sizeof(cap->bus_info));
+        usb_make_path(gspca_dev->dev, (char *) cap->bus_info,
+                        sizeof(cap->bus_info));
         cap->version = DRIVER_VERSION_NUMBER;
         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE
                           | V4L2_CAP_STREAMING
@@ -1310,7 +1301,7 @@ out:
         return ret;
 }
 
-static const struct ctrl *get_ctrl(struct gspca_dev *gspca_dev,
+static int get_ctrl(struct gspca_dev *gspca_dev,
                                    int id)
 {
         const struct ctrl *ctrls;
@@ -1322,9 +1313,9 @@ static const struct ctrl *get_ctrl(struct gspca_dev *gspca_dev,
                 if (gspca_dev->ctrl_dis & (1 << i))
                         continue;
                 if (id == ctrls->qctrl.id)
-                        return ctrls;
+                        return i;
         }
-        return NULL;
+        return -1;
 }
 
 static int vidioc_queryctrl(struct file *file, void *priv,
@@ -1332,34 +1323,40 @@ static int vidioc_queryctrl(struct file *file, void *priv,
 {
         struct gspca_dev *gspca_dev = priv;
         const struct ctrl *ctrls;
-        int i;
+        struct gspca_ctrl *gspca_ctrl;
+        int i, idx;
         u32 id;
 
-        ctrls = NULL;
         id = q_ctrl->id;
         if (id & V4L2_CTRL_FLAG_NEXT_CTRL) {
                 id &= V4L2_CTRL_ID_MASK;
                 id++;
+                idx = -1;
                 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 < id)
                                 continue;
-                        if (ctrls && gspca_dev->sd_desc->ctrls[i].qctrl.id
-                                            > ctrls->qctrl.id)
+                        if (idx >= 0
+                         && gspca_dev->sd_desc->ctrls[i].qctrl.id
+                                    > gspca_dev->sd_desc->ctrls[idx].qctrl.id)
                                 continue;
-                        ctrls = &gspca_dev->sd_desc->ctrls[i];
+                        idx = i;
                 }
-                if (ctrls == NULL)
-                        return -EINVAL;
         } else {
-                ctrls = get_ctrl(gspca_dev, id);
-                if (ctrls == NULL)
-                        return -EINVAL;
-                i = ctrls - gspca_dev->sd_desc->ctrls;
+                idx = get_ctrl(gspca_dev, id);
         }
-        memcpy(q_ctrl, ctrls, sizeof *q_ctrl);
-        if (gspca_dev->ctrl_inac & (1 << i))
+        if (idx < 0)
+                return -EINVAL;
+        ctrls = &gspca_dev->sd_desc->ctrls[idx];
+        memcpy(q_ctrl, &ctrls->qctrl, sizeof *q_ctrl);
+        if (gspca_dev->cam.ctrls != NULL) {
+                gspca_ctrl = &gspca_dev->cam.ctrls[idx];
+                q_ctrl->default_value = gspca_ctrl->def;
+                q_ctrl->minimum = gspca_ctrl->min;
+                q_ctrl->maximum = gspca_ctrl->max;
+        }
+        if (gspca_dev->ctrl_inac & (1 << idx))
                 q_ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
         return 0;
 }
@@ -1369,23 +1366,46 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
 {
         struct gspca_dev *gspca_dev = priv;
         const struct ctrl *ctrls;
-        int ret;
+        struct gspca_ctrl *gspca_ctrl;
+        int idx, ret;
 
-        ctrls = get_ctrl(gspca_dev, ctrl->id);
-        if (ctrls == NULL)
+        idx = get_ctrl(gspca_dev, ctrl->id);
+        if (idx < 0)
                 return -EINVAL;
-
-        if (ctrl->value < ctrls->qctrl.minimum
-            || ctrl->value > ctrls->qctrl.maximum)
-                return -ERANGE;
+        if (gspca_dev->ctrl_inac & (1 << idx))
+                return -EINVAL;
+        ctrls = &gspca_dev->sd_desc->ctrls[idx];
+        if (gspca_dev->cam.ctrls != NULL) {
+                gspca_ctrl = &gspca_dev->cam.ctrls[idx];
+                if (ctrl->value < gspca_ctrl->min
+                    || ctrl->value > gspca_ctrl->max)
+                        return -ERANGE;
+        } else {
+                gspca_ctrl = NULL;
+                if (ctrl->value < ctrls->qctrl.minimum
+                    || ctrl->value > ctrls->qctrl.maximum)
+                        return -ERANGE;
+        }
         PDEBUG(D_CONF, "set ctrl [%08x] = %d", ctrl->id, ctrl->value);
         if (mutex_lock_interruptible(&gspca_dev->usb_lock))
                 return -ERESTARTSYS;
+        if (!gspca_dev->present) {
+                ret = -ENODEV;
+                goto out;
+        }
         gspca_dev->usb_err = 0;
-        if (gspca_dev->present)
+        if (ctrls->set != NULL) {
                 ret = ctrls->set(gspca_dev, ctrl->value);
-        else
-                ret = -ENODEV;
+                goto out;
+        }
+        if (gspca_ctrl != NULL) {
+                gspca_ctrl->val = ctrl->value;
+                if (ctrls->set_control != NULL
+                 && gspca_dev->streaming)
+                        ctrls->set_control(gspca_dev);
+        }
+        ret = gspca_dev->usb_err;
+out:
         mutex_unlock(&gspca_dev->usb_lock);
         return ret;
 }
@@ -1395,19 +1415,28 @@ static int vidioc_g_ctrl(struct file *file, void *priv,
 {
         struct gspca_dev *gspca_dev = priv;
         const struct ctrl *ctrls;
-        int ret;
+        int idx, ret;
 
-        ctrls = get_ctrl(gspca_dev, ctrl->id);
-        if (ctrls == NULL)
+        idx = get_ctrl(gspca_dev, ctrl->id);
+        if (idx < 0)
                 return -EINVAL;
+        ctrls = &gspca_dev->sd_desc->ctrls[idx];
 
         if (mutex_lock_interruptible(&gspca_dev->usb_lock))
                 return -ERESTARTSYS;
+        if (!gspca_dev->present) {
+                ret = -ENODEV;
+                goto out;
+        }
         gspca_dev->usb_err = 0;
-        if (gspca_dev->present)
+        if (ctrls->get != NULL) {
                 ret = ctrls->get(gspca_dev, &ctrl->value);
-        else
-                ret = -ENODEV;
+                goto out;
+        }
+        if (gspca_dev->cam.ctrls != NULL)
+                ctrl->value = gspca_dev->cam.ctrls[idx].val;
+        ret = 0;
+out:
         mutex_unlock(&gspca_dev->usb_lock);
         return ret;
 }
@@ -1468,6 +1497,7 @@ static int vidioc_reqbufs(struct file *file, void *priv,
                 return -ERESTARTSYS;
 
         if (gspca_dev->memory != GSPCA_MEMORY_NO
+            && gspca_dev->memory != GSPCA_MEMORY_READ
             && gspca_dev->memory != rb->memory) {
                 ret = -EBUSY;
                 goto out;
@@ -1495,20 +1525,21 @@ static int vidioc_reqbufs(struct file *file, void *priv,
                 gspca_dev->usb_err = 0;
                 gspca_stream_off(gspca_dev);
                 mutex_unlock(&gspca_dev->usb_lock);
+
+                /* Don't restart the stream when switching from read
+                 * to mmap mode */
+                if (gspca_dev->memory == GSPCA_MEMORY_READ)
+                        streaming = 0;
         }
 
         /* free the previous allocated buffers, if any */
-        if (gspca_dev->nframes != 0) {
+        if (gspca_dev->nframes != 0)
                 frame_free(gspca_dev);
-                gspca_dev->capt_file = NULL;
-        }
         if (rb->count == 0)                     /* unrequest */
                 goto out;
-        gspca_dev->memory = rb->memory;
-        ret = frame_alloc(gspca_dev, rb->count);
+        ret = frame_alloc(gspca_dev, file, rb->memory, rb->count);
         if (ret == 0) {
                 rb->count = gspca_dev->nframes;
-                gspca_dev->capt_file = file;
                 if (streaming)
                         ret = gspca_init_transfer(gspca_dev);
         }
@@ -1582,11 +1613,15 @@ static int vidioc_streamoff(struct file *file, void *priv,
 
         if (buf_type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
-        if (!gspca_dev->streaming)
-                return 0;
+
         if (mutex_lock_interruptible(&gspca_dev->queue_lock))
                 return -ERESTARTSYS;
 
+        if (!gspca_dev->streaming) {
+                ret = 0;
+                goto out;
+        }
+
         /* check the capture file */
         if (gspca_dev->capt_file != file) {
                 ret = -EBUSY;
@@ -1601,6 +1636,8 @@ static int vidioc_streamoff(struct file *file, void *priv,
         gspca_dev->usb_err = 0;
         gspca_stream_off(gspca_dev);
         mutex_unlock(&gspca_dev->usb_lock);
+        /* In case another thread is waiting in dqbuf */
+        wake_up_interruptible(&gspca_dev->wq);
 
         /* empty the transfer queues */
         atomic_set(&gspca_dev->fr_q, 0);
@@ -1662,12 +1699,13 @@ static int vidioc_g_parm(struct file *filp, void *priv,
 
                 if (mutex_lock_interruptible(&gspca_dev->usb_lock))
                         return -ERESTARTSYS;
-                gspca_dev->usb_err = 0;
-                if (gspca_dev->present)
-                        ret = gspca_dev->sd_desc->get_streamparm(gspca_dev,
-                                                                 parm);
-                else
+                if (gspca_dev->present) {
+                        gspca_dev->usb_err = 0;
+                        gspca_dev->sd_desc->get_streamparm(gspca_dev, parm);
+                        ret = gspca_dev->usb_err;
+                } else {
                         ret = -ENODEV;
+                }
                 mutex_unlock(&gspca_dev->usb_lock);
                 return ret;
         }
@@ -1692,12 +1730,13 @@ static int vidioc_s_parm(struct file *filp, void *priv,
 
                 if (mutex_lock_interruptible(&gspca_dev->usb_lock))
                         return -ERESTARTSYS;
-                gspca_dev->usb_err = 0;
-                if (gspca_dev->present)
-                        ret = gspca_dev->sd_desc->set_streamparm(gspca_dev,
-                                                                 parm);
-                else
+                if (gspca_dev->present) {
+                        gspca_dev->usb_err = 0;
+                        gspca_dev->sd_desc->set_streamparm(gspca_dev, parm);
+                        ret = gspca_dev->usb_err;
+                } else {
                         ret = -ENODEV;
+                }
                 mutex_unlock(&gspca_dev->usb_lock);
                 return ret;
         }
@@ -1777,33 +1816,77 @@ out:
         return ret;
 }
 
+static int frame_ready_nolock(struct gspca_dev *gspca_dev, struct file *file,
+                                enum v4l2_memory memory)
+{
+        if (!gspca_dev->present)
+                return -ENODEV;
+        if (gspca_dev->capt_file != file || gspca_dev->memory != memory ||
+                        !gspca_dev->streaming)
+                return -EINVAL;
+
+        /* check if a frame is ready */
+        return gspca_dev->fr_o != atomic_read(&gspca_dev->fr_i);
+}
+
+static int frame_ready(struct gspca_dev *gspca_dev, struct file *file,
+                        enum v4l2_memory memory)
+{
+        int ret;
+
+        if (mutex_lock_interruptible(&gspca_dev->queue_lock))
+                return -ERESTARTSYS;
+        ret = frame_ready_nolock(gspca_dev, file, memory);
+        mutex_unlock(&gspca_dev->queue_lock);
+        return ret;
+}
+
 /*
- * wait for a video frame
+ * dequeue a video buffer
  *
- * If a frame is ready, its index is returned.
+ * If nonblock_ing is false, block until a buffer is available.
  */
-static int frame_wait(struct gspca_dev *gspca_dev,
-                        int nonblock_ing)
+static int vidioc_dqbuf(struct file *file, void *priv,
+                        struct v4l2_buffer *v4l2_buf)
 {
-        int i, ret;
+        struct gspca_dev *gspca_dev = priv;
+        struct gspca_frame *frame;
+        int i, j, ret;
 
-        /* check if a frame is ready */
-        i = gspca_dev->fr_o;
-        if (i == atomic_read(&gspca_dev->fr_i)) {
-                if (nonblock_ing)
+        PDEBUG(D_FRAM, "dqbuf");
+
+        if (mutex_lock_interruptible(&gspca_dev->queue_lock))
+                return -ERESTARTSYS;
+
+        for (;;) {
+                ret = frame_ready_nolock(gspca_dev, file, v4l2_buf->memory);
+                if (ret < 0)
+                        goto out;
+                if (ret > 0)
+                        break;
+
+                mutex_unlock(&gspca_dev->queue_lock);
+
+                if (file->f_flags & O_NONBLOCK)
                         return -EAGAIN;
 
                 /* wait till a frame is ready */
                 ret = wait_event_interruptible_timeout(gspca_dev->wq,
-                        i != atomic_read(&gspca_dev->fr_i) ||
-                        !gspca_dev->streaming || !gspca_dev->present,
+                        frame_ready(gspca_dev, file, v4l2_buf->memory),
                         msecs_to_jiffies(3000));
                 if (ret < 0)
                         return ret;
-                if (ret == 0 || !gspca_dev->streaming || !gspca_dev->present)
+                if (ret == 0)
                         return -EIO;
+
+                if (mutex_lock_interruptible(&gspca_dev->queue_lock))
+                        return -ERESTARTSYS;
         }
 
+        i = gspca_dev->fr_o;
+        j = gspca_dev->fr_queue[i];
+        frame = &gspca_dev->frame[j];
+
         gspca_dev->fr_o = (i + 1) % GSPCA_MAX_FRAMES;
 
         if (gspca_dev->sd_desc->dq_callback) {
@@ -1813,46 +1896,12 @@ static int frame_wait(struct gspca_dev *gspca_dev,
                         gspca_dev->sd_desc->dq_callback(gspca_dev);
                 mutex_unlock(&gspca_dev->usb_lock);
         }
-        return gspca_dev->fr_queue[i];
-}
-
-/*
- * dequeue a video buffer
- *
- * If nonblock_ing is false, block until a buffer is available.
- */
-static int vidioc_dqbuf(struct file *file, void *priv,
-                        struct v4l2_buffer *v4l2_buf)
-{
-        struct gspca_dev *gspca_dev = priv;
-        struct gspca_frame *frame;
-        int i, ret;
 
-        PDEBUG(D_FRAM, "dqbuf");
-        if (v4l2_buf->memory != gspca_dev->memory)
-                return -EINVAL;
-
-        if (!gspca_dev->present)
-                return -ENODEV;
-
-        /* if not streaming, be sure the application will not loop forever */
-        if (!(file->f_flags & O_NONBLOCK)
-            && !gspca_dev->streaming && gspca_dev->users == 1)
-                return -EINVAL;
-
-        /* only the capturing file may dequeue */
-        if (gspca_dev->capt_file != file)
-                return -EINVAL;
-
-        /* only one dequeue / read at a time */
-        if (mutex_lock_interruptible(&gspca_dev->read_lock))
-                return -ERESTARTSYS;
+        frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE;
+        memcpy(v4l2_buf, &frame->v4l2_buf, sizeof *v4l2_buf);
+        PDEBUG(D_FRAM, "dqbuf %d", j);
+        ret = 0;
 
-        ret = frame_wait(gspca_dev, file->f_flags & O_NONBLOCK);
-        if (ret < 0)
-                goto out;
-        i = ret;                                /* frame index */
-        frame = &gspca_dev->frame[i];
         if (gspca_dev->memory == V4L2_MEMORY_USERPTR) {
                 if (copy_to_user((__u8 __user *) frame->v4l2_buf.m.userptr,
                                  frame->data,
@@ -1860,15 +1909,10 @@ static int vidioc_dqbuf(struct file *file, void *priv,
                         PDEBUG(D_ERR|D_STREAM,
                                 "dqbuf cp to user failed");
                         ret = -EFAULT;
-                        goto out;
                 }
         }
-        frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE;
-        memcpy(v4l2_buf, &frame->v4l2_buf, sizeof *v4l2_buf);
-        PDEBUG(D_FRAM, "dqbuf %d", i);
-        ret = 0;
 out:
-        mutex_unlock(&gspca_dev->read_lock);
+        mutex_unlock(&gspca_dev->queue_lock);
         return ret;
 }
 
@@ -1983,9 +2027,7 @@ static unsigned int dev_poll(struct file *file, poll_table *wait)
         poll_wait(file, &gspca_dev->wq, wait);
 
         /* if reqbufs is not done, the user would use read() */
-        if (gspca_dev->nframes == 0) {
-                if (gspca_dev->memory != GSPCA_MEMORY_NO)
-                        return POLLERR;         /* not the 1st time */
+        if (gspca_dev->memory == GSPCA_MEMORY_NO) {
                 ret = read_alloc(gspca_dev, file);
                 if (ret != 0)
                         return POLLERR;
@@ -2017,18 +2059,10 @@ static ssize_t dev_read(struct file *file, char __user *data,
         PDEBUG(D_FRAM, "read (%zd)", count);
         if (!gspca_dev->present)
                 return -ENODEV;
-        switch (gspca_dev->memory) {
-        case GSPCA_MEMORY_NO:                   /* first time */
+        if (gspca_dev->memory == GSPCA_MEMORY_NO) { /* first time ? */
                 ret = read_alloc(gspca_dev, file);
                 if (ret != 0)
                         return ret;
-                break;
-        case GSPCA_MEMORY_READ:
-                if (gspca_dev->capt_file == file)
-                        break;
-                /* fall thru */
-        default:
-                return -EINVAL;
         }
 
         /* get a frame */
@@ -2120,13 +2154,29 @@ static const struct v4l2_ioctl_ops dev_ioctl_ops = {
         .vidioc_g_chip_ident    = vidioc_g_chip_ident,
 };
 
-static struct video_device gspca_template = {
+static const struct video_device gspca_template = {
         .name = "gspca main driver",
         .fops = &dev_fops,
         .ioctl_ops = &dev_ioctl_ops,
         .release = gspca_release,
 };
 
+/* initialize the controls */
+static void ctrls_init(struct gspca_dev *gspca_dev)
+{
+        struct gspca_ctrl *ctrl;
+        int i;
+
+        for (i = 0, ctrl = gspca_dev->cam.ctrls;
+             i < gspca_dev->sd_desc->nctrls;
+             i++, ctrl++) {
+                ctrl->def = gspca_dev->sd_desc->ctrls[i].qctrl.default_value;
+                ctrl->val = ctrl->def;
+                ctrl->min = gspca_dev->sd_desc->ctrls[i].qctrl.minimum;
+                ctrl->max = gspca_dev->sd_desc->ctrls[i].qctrl.maximum;
+        }
+}
+
 /*
  * probe and create a new gspca device
  *
@@ -2188,6 +2238,8 @@ int gspca_dev_probe2(struct usb_interface *intf,
         ret = sd_desc->config(gspca_dev, id);
         if (ret < 0)
                 goto out;
+        if (gspca_dev->cam.ctrls != NULL)
+                ctrls_init(gspca_dev);
         ret = sd_desc->init(gspca_dev);
         if (ret < 0)
                 goto out;
@@ -2198,7 +2250,6 @@ int gspca_dev_probe2(struct usb_interface *intf,
                 goto out;
 
         mutex_init(&gspca_dev->usb_lock);
-        mutex_init(&gspca_dev->read_lock);
         mutex_init(&gspca_dev->queue_lock);
         init_waitqueue_head(&gspca_dev->wq);
 
@@ -2243,7 +2294,7 @@ int gspca_dev_probe(struct usb_interface *intf,
 
         /* we don't handle multi-config cameras */
         if (dev->descriptor.bNumConfigurations != 1) {
-                PDEBUG(D_ERR, "%04x:%04x too many config",
+                err("%04x:%04x too many config",
                                 id->idVendor, id->idProduct);
                 return -ENODEV;
         }
@@ -2273,12 +2324,11 @@ void gspca_disconnect(struct usb_interface *intf)
         PDEBUG(D_PROBE, "%s disconnect",
                 video_device_node_name(&gspca_dev->vdev));
         mutex_lock(&gspca_dev->usb_lock);
+
         gspca_dev->present = 0;
+        wake_up_interruptible(&gspca_dev->wq);
 
-        if (gspca_dev->streaming) {
-                destroy_urbs(gspca_dev);
-                wake_up_interruptible(&gspca_dev->wq);
-        }
+        destroy_urbs(gspca_dev);
 
 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         gspca_input_destroy_urb(gspca_dev);
@@ -2296,7 +2346,7 @@ void gspca_disconnect(struct usb_interface *intf)
         usb_set_intfdata(intf, NULL);
 
         /* release the device */
-        /* (this will call gspca_release() immediatly or on last close) */
+        /* (this will call gspca_release() immediately or on last close) */
         video_unregister_device(&gspca_dev->vdev);
 
 /*      PDEBUG(D_PROBE, "disconnect complete"); */
@@ -2428,7 +2478,7 @@ EXPORT_SYMBOL(gspca_auto_gain_n_exposure);
 /* -- module insert / remove -- */
 static int __init gspca_init(void)
 {
-        info("main v%d.%d.%d registered",
+        info("v%d.%d.%d registered",
                 (DRIVER_VERSION_NUMBER >> 16) & 0xff,
                 (DRIVER_VERSION_NUMBER >> 8) & 0xff,
                 DRIVER_VERSION_NUMBER & 0xff);
@@ -2436,7 +2486,6 @@ static int __init gspca_init(void)
 }
 static void __exit gspca_exit(void)
 {
-        info("main deregistered");
 }
 
 module_init(gspca_init);
@@ -2446,6 +2495,6 @@ module_exit(gspca_exit);
 module_param_named(debug, gspca_debug, int, 0644);
 MODULE_PARM_DESC(debug,
                 "Debug (bit) 0x01:error 0x02:probe 0x04:config"
-                " 0x08:stream 0x10:frame 0x20:packet 0x40:USBin 0x80:USBout"
+                " 0x08:stream 0x10:frame 0x20:packet"
                 " 0x0100: v4l2");
 #endif
diff --git a/drivers/media/video/gspca/gspca.h b/drivers/media/video/gspca/gspca.h
index b749c36d9f7e..49e2fcbe81fb 100644
--- a/drivers/media/video/gspca/gspca.h
+++ b/drivers/media/video/gspca/gspca.h
@@ -9,7 +9,7 @@
 #include <linux/mutex.h>
 
 /* compilation option */
-#define GSPCA_DEBUG 1
+/*#define GSPCA_DEBUG 1*/
 
 #ifdef GSPCA_DEBUG
 /* GSPCA our debug messages */
@@ -25,8 +25,8 @@ extern int gspca_debug;
 #define D_STREAM 0x08
 #define D_FRAM 0x10
 #define D_PACK 0x20
-#define D_USBI 0x40
-#define D_USBO 0x80
+#define D_USBI 0x00
+#define D_USBO 0x00
 #define D_V4L2 0x0100
 #else
 #define PDEBUG(level, fmt, args...)
@@ -52,11 +52,20 @@ struct framerates {
         int nrates;
 };
 
+/* control definition */
+struct gspca_ctrl {
+        s16 val;        /* current value */
+        s16 def;        /* default value */
+        s16 min, max;   /* minimum and maximum values */
+};
+
 /* device information - set at probe time */
 struct cam {
         const struct v4l2_pix_format *cam_mode; /* size nmodes */
-        const struct framerates *mode_framerates; /* must have size nmode,
+        const struct framerates *mode_framerates; /* must have size nmodes,
                                                    * just like cam_mode */
+        struct gspca_ctrl *ctrls;       /* control table - size nctrls */
+                                        /* may be NULL */
         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 */
@@ -84,7 +93,7 @@ typedef int (*cam_reg_op) (struct gspca_dev *,
                                 struct v4l2_dbg_register *);
 typedef int (*cam_ident_op) (struct gspca_dev *,
                                 struct v4l2_dbg_chip_ident *);
-typedef int (*cam_streamparm_op) (struct gspca_dev *,
+typedef void (*cam_streamparm_op) (struct gspca_dev *,
                                   struct v4l2_streamparm *);
 typedef int (*cam_qmnu_op) (struct gspca_dev *,
                         struct v4l2_querymenu *);
@@ -99,6 +108,7 @@ struct ctrl {
         struct v4l2_queryctrl qctrl;
         int (*set)(struct gspca_dev *, __s32);
         int (*get)(struct gspca_dev *, __s32 *);
+        cam_v_op set_control;
 };
 
 /* subdriver description */
@@ -106,7 +116,7 @@ struct sd_desc {
 /* information */
         const char *name;       /* sub-driver name */
 /* controls */
-        const struct ctrl *ctrls;
+        const struct ctrl *ctrls;       /* static control definition */
         int nctrls;
 /* mandatory operations */
         cam_cf_op config;       /* called on probe */
@@ -195,14 +205,12 @@ struct gspca_dev {
 
         wait_queue_head_t wq;           /* wait queue */
         struct mutex usb_lock;          /* usb exchange protection */
-        struct mutex read_lock;         /* read protection */
         struct mutex queue_lock;        /* ISOC queue protection */
         int usb_err;                    /* USB error - protected by usb_lock */
         u16 pkt_size;                   /* ISOC packet size */
 #ifdef CONFIG_PM
         char frozen;                    /* suspend - resume */
 #endif
-        char users;                     /* number of opens */
         char present;                   /* device connected */
         char nbufread;                  /* number of buffers for read() */
         char memory;                    /* memory type (V4L2_MEMORY_xxx) */
diff --git a/drivers/media/video/gspca/jeilinj.c b/drivers/media/video/gspca/jeilinj.c
index 12d9cf4caba2..1bd9c4b542dd 100644
--- a/drivers/media/video/gspca/jeilinj.c
+++ b/drivers/media/video/gspca/jeilinj.c
@@ -6,6 +6,9 @@
  *
  * Copyright (C) 2009 Theodore Kilgore
  *
+ * Sportscam DV15 support and control settings are
+ * Copyright (C) 2011 Patrice Chotard
+ *
  * 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
@@ -23,7 +26,6 @@
 
 #define MODULE_NAME "jeilinj"
 
-#include <linux/workqueue.h>
 #include <linux/slab.h>
 #include "gspca.h"
 #include "jpeg.h"
@@ -34,29 +36,51 @@ MODULE_LICENSE("GPL");
 
 /* Default timeouts, in ms */
 #define JEILINJ_CMD_TIMEOUT 500
+#define JEILINJ_CMD_DELAY 160
 #define JEILINJ_DATA_TIMEOUT 1000
 
 /* Maximum transfer size to use. */
 #define JEILINJ_MAX_TRANSFER 0x200
-
 #define FRAME_HEADER_LEN 0x10
+#define FRAME_START 0xFFFFFFFF
+
+enum {
+        SAKAR_57379,
+        SPORTSCAM_DV15,
+};
+
+#define CAMQUALITY_MIN 0        /* highest cam quality */
+#define CAMQUALITY_MAX 97       /* lowest cam quality  */
+
+enum e_ctrl {
+        LIGHTFREQ,
+        AUTOGAIN,
+        RED,
+        GREEN,
+        BLUE,
+        NCTRLS          /* number of controls */
+};
 
 /* Structure to hold all of our device specific stuff */
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
+        struct gspca_ctrl ctrls[NCTRLS];
+        int blocks_left;
         const struct v4l2_pix_format *cap_mode;
         /* Driver stuff */
-        struct work_struct work_struct;
-        struct workqueue_struct *work_thread;
+        u8 type;
         u8 quality;                              /* image quality */
-        u8 jpegqual;                            /* webcam quality */
+#define QUALITY_MIN 35
+#define QUALITY_MAX 85
+#define QUALITY_DEF 85
         u8 jpeg_hdr[JPEG_HDR_SZ];
 };
 
-        struct jlj_command {
-                unsigned char instruction[2];
-                unsigned char ack_wanted;
-        };
+struct jlj_command {
+        unsigned char instruction[2];
+        unsigned char ack_wanted;
+        unsigned char delay;
+};
 
 /* AFAICT these cameras will only do 320x240. */
 static struct v4l2_pix_format jlj_mode[] = {
@@ -64,6 +88,11 @@ static struct v4l2_pix_format jlj_mode[] = {
                 .bytesperline = 320,
                 .sizeimage = 320 * 240,
                 .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 0},
+        { 640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480,
+                .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 0}
 };
 
@@ -73,180 +102,295 @@ static struct v4l2_pix_format jlj_mode[] = {
  */
 
 /* All commands are two bytes only */
-static int jlj_write2(struct gspca_dev *gspca_dev, unsigned char *command)
+static void jlj_write2(struct gspca_dev *gspca_dev, unsigned char *command)
 {
         int retval;
 
+        if (gspca_dev->usb_err < 0)
+                return;
         memcpy(gspca_dev->usb_buf, command, 2);
         retval = usb_bulk_msg(gspca_dev->dev,
                         usb_sndbulkpipe(gspca_dev->dev, 3),
                         gspca_dev->usb_buf, 2, NULL, 500);
-        if (retval < 0)
-                PDEBUG(D_ERR, "command write [%02x] error %d",
+        if (retval < 0) {
+                err("command write [%02x] error %d",
                                 gspca_dev->usb_buf[0], retval);
-        return retval;
+                gspca_dev->usb_err = retval;
+        }
 }
 
 /* Responses are one byte only */
-static int jlj_read1(struct gspca_dev *gspca_dev, unsigned char response)
+static void jlj_read1(struct gspca_dev *gspca_dev, unsigned char response)
 {
         int retval;
 
+        if (gspca_dev->usb_err < 0)
+                return;
         retval = usb_bulk_msg(gspca_dev->dev,
         usb_rcvbulkpipe(gspca_dev->dev, 0x84),
                                 gspca_dev->usb_buf, 1, NULL, 500);
         response = gspca_dev->usb_buf[0];
-        if (retval < 0)
-                PDEBUG(D_ERR, "read command [%02x] error %d",
+        if (retval < 0) {
+                err("read command [%02x] error %d",
                                 gspca_dev->usb_buf[0], retval);
-        return retval;
+                gspca_dev->usb_err = retval;
+        }
 }
 
-static int jlj_start(struct gspca_dev *gspca_dev)
+static void setfreq(struct gspca_dev *gspca_dev)
 {
-        int i;
-        int retval = -1;
-        u8 response = 0xff;
-        struct jlj_command start_commands[] = {
-                {{0x71, 0x81}, 0},
-                {{0x70, 0x05}, 0},
-                {{0x95, 0x70}, 1},
-                {{0x71, 0x81}, 0},
-                {{0x70, 0x04}, 0},
-                {{0x95, 0x70}, 1},
-                {{0x71, 0x00}, 0},
-                {{0x70, 0x08}, 0},
-                {{0x95, 0x70}, 1},
-                {{0x94, 0x02}, 0},
-                {{0xde, 0x24}, 0},
-                {{0x94, 0x02}, 0},
-                {{0xdd, 0xf0}, 0},
-                {{0x94, 0x02}, 0},
-                {{0xe3, 0x2c}, 0},
-                {{0x94, 0x02}, 0},
-                {{0xe4, 0x00}, 0},
-                {{0x94, 0x02}, 0},
-                {{0xe5, 0x00}, 0},
-                {{0x94, 0x02}, 0},
-                {{0xe6, 0x2c}, 0},
-                {{0x94, 0x03}, 0},
-                {{0xaa, 0x00}, 0},
-                {{0x71, 0x1e}, 0},
-                {{0x70, 0x06}, 0},
-                {{0x71, 0x80}, 0},
-                {{0x70, 0x07}, 0}
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 freq_commands[][2] = {
+                {0x71, 0x80},
+                {0x70, 0x07}
         };
-        for (i = 0; i < ARRAY_SIZE(start_commands); i++) {
-                retval = jlj_write2(gspca_dev, start_commands[i].instruction);
-                if (retval < 0)
-                        return retval;
-                if (start_commands[i].ack_wanted)
-                        retval = jlj_read1(gspca_dev, response);
-                if (retval < 0)
-                        return retval;
-        }
-        PDEBUG(D_ERR, "jlj_start retval is %d", retval);
-        return retval;
+
+        freq_commands[0][1] |= (sd->ctrls[LIGHTFREQ].val >> 1);
+
+        jlj_write2(gspca_dev, freq_commands[0]);
+        jlj_write2(gspca_dev, freq_commands[1]);
+}
+
+static void setcamquality(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 quality_commands[][2] = {
+                {0x71, 0x1E},
+                {0x70, 0x06}
+        };
+        u8 camquality;
+
+        /* adapt camera quality from jpeg quality */
+        camquality = ((QUALITY_MAX - sd->quality) * CAMQUALITY_MAX)
+                / (QUALITY_MAX - QUALITY_MIN);
+        quality_commands[0][1] += camquality;
+
+        jlj_write2(gspca_dev, quality_commands[0]);
+        jlj_write2(gspca_dev, quality_commands[1]);
+}
+
+static void setautogain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 autogain_commands[][2] = {
+                {0x94, 0x02},
+                {0xcf, 0x00}
+        };
+
+        autogain_commands[1][1] = (sd->ctrls[AUTOGAIN].val << 4);
+
+        jlj_write2(gspca_dev, autogain_commands[0]);
+        jlj_write2(gspca_dev, autogain_commands[1]);
+}
+
+static void setred(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 setred_commands[][2] = {
+                {0x94, 0x02},
+                {0xe6, 0x00}
+        };
+
+        setred_commands[1][1] = sd->ctrls[RED].val;
+
+        jlj_write2(gspca_dev, setred_commands[0]);
+        jlj_write2(gspca_dev, setred_commands[1]);
 }
 
-static int jlj_stop(struct gspca_dev *gspca_dev)
+static void setgreen(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 setgreen_commands[][2] = {
+                {0x94, 0x02},
+                {0xe7, 0x00}
+        };
+
+        setgreen_commands[1][1] = sd->ctrls[GREEN].val;
+
+        jlj_write2(gspca_dev, setgreen_commands[0]);
+        jlj_write2(gspca_dev, setgreen_commands[1]);
+}
+
+static void setblue(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 setblue_commands[][2] = {
+                {0x94, 0x02},
+                {0xe9, 0x00}
+        };
+
+        setblue_commands[1][1] = sd->ctrls[BLUE].val;
+
+        jlj_write2(gspca_dev, setblue_commands[0]);
+        jlj_write2(gspca_dev, setblue_commands[1]);
+}
+
+static const struct ctrl sd_ctrls[NCTRLS] = {
+[LIGHTFREQ] = {
+            {
+                .id      = V4L2_CID_POWER_LINE_FREQUENCY,
+                .type    = V4L2_CTRL_TYPE_MENU,
+                .name    = "Light frequency filter",
+                .minimum = V4L2_CID_POWER_LINE_FREQUENCY_DISABLED, /* 1 */
+                .maximum = V4L2_CID_POWER_LINE_FREQUENCY_60HZ, /* 2 */
+                .step    = 1,
+                .default_value = V4L2_CID_POWER_LINE_FREQUENCY_60HZ,
+            },
+            .set_control = setfreq
+        },
+[AUTOGAIN] = {
+            {
+                .id = V4L2_CID_AUTOGAIN,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Automatic Gain (and Exposure)",
+                .minimum = 0,
+                .maximum = 3,
+                .step = 1,
+#define AUTOGAIN_DEF 0
+                .default_value = AUTOGAIN_DEF,
+           },
+           .set_control = setautogain
+        },
+[RED] = {
+            {
+                .id = V4L2_CID_RED_BALANCE,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "red balance",
+                .minimum = 0,
+                .maximum = 3,
+                .step = 1,
+#define RED_BALANCE_DEF 2
+                .default_value = RED_BALANCE_DEF,
+           },
+           .set_control = setred
+        },
+
+[GREEN] = {
+            {
+                .id = V4L2_CID_GAIN,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "green balance",
+                .minimum = 0,
+                .maximum = 3,
+                .step = 1,
+#define GREEN_BALANCE_DEF 2
+                .default_value = GREEN_BALANCE_DEF,
+           },
+           .set_control = setgreen
+        },
+[BLUE] = {
+            {
+                .id = V4L2_CID_BLUE_BALANCE,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "blue balance",
+                .minimum = 0,
+                .maximum = 3,
+                .step = 1,
+#define BLUE_BALANCE_DEF 2
+                .default_value = BLUE_BALANCE_DEF,
+           },
+           .set_control = setblue
+        },
+};
+
+static int jlj_start(struct gspca_dev *gspca_dev)
 {
         int i;
-        int retval;
-        struct jlj_command stop_commands[] = {
-                {{0x71, 0x00}, 0},
-                {{0x70, 0x09}, 0},
-                {{0x71, 0x80}, 0},
-                {{0x70, 0x05}, 0}
+        int start_commands_size;
+        u8 response = 0xff;
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct jlj_command start_commands[] = {
+                {{0x71, 0x81}, 0, 0},
+                {{0x70, 0x05}, 0, JEILINJ_CMD_DELAY},
+                {{0x95, 0x70}, 1, 0},
+                {{0x71, 0x81 - gspca_dev->curr_mode}, 0, 0},
+                {{0x70, 0x04}, 0, JEILINJ_CMD_DELAY},
+                {{0x95, 0x70}, 1, 0},
+                {{0x71, 0x00}, 0, 0},   /* start streaming ??*/
+                {{0x70, 0x08}, 0, JEILINJ_CMD_DELAY},
+                {{0x95, 0x70}, 1, 0},
+#define SPORTSCAM_DV15_CMD_SIZE 9
+                {{0x94, 0x02}, 0, 0},
+                {{0xde, 0x24}, 0, 0},
+                {{0x94, 0x02}, 0, 0},
+                {{0xdd, 0xf0}, 0, 0},
+                {{0x94, 0x02}, 0, 0},
+                {{0xe3, 0x2c}, 0, 0},
+                {{0x94, 0x02}, 0, 0},
+                {{0xe4, 0x00}, 0, 0},
+                {{0x94, 0x02}, 0, 0},
+                {{0xe5, 0x00}, 0, 0},
+                {{0x94, 0x02}, 0, 0},
+                {{0xe6, 0x2c}, 0, 0},
+                {{0x94, 0x03}, 0, 0},
+                {{0xaa, 0x00}, 0, 0}
         };
-        for (i = 0; i < ARRAY_SIZE(stop_commands); i++) {
-                retval = jlj_write2(gspca_dev, stop_commands[i].instruction);
-                if (retval < 0)
-                        return retval;
+
+        sd->blocks_left = 0;
+        /* Under Windows, USB spy shows that only the 9 first start
+         * commands are used for SPORTSCAM_DV15 webcam
+         */
+        if (sd->type == SPORTSCAM_DV15)
+                start_commands_size = SPORTSCAM_DV15_CMD_SIZE;
+        else
+                start_commands_size = ARRAY_SIZE(start_commands);
+
+        for (i = 0; i < start_commands_size; i++) {
+                jlj_write2(gspca_dev, start_commands[i].instruction);
+                if (start_commands[i].delay)
+                        msleep(start_commands[i].delay);
+                if (start_commands[i].ack_wanted)
+                        jlj_read1(gspca_dev, response);
         }
-        return retval;
+        setcamquality(gspca_dev);
+        msleep(2);
+        setfreq(gspca_dev);
+        if (gspca_dev->usb_err < 0)
+                PDEBUG(D_ERR, "Start streaming command failed");
+        return gspca_dev->usb_err;
 }
 
-/* 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
- * threads attempting to use the camera's USB interface the gspca usb_lock is
- * used when performing the one USB control operation inside the workqueue,
- * which tells the camera to close the stream. In practice the only thing
- * which needs to be protected against is the usb_set_interface call that
- * gspca makes during stream_off. Otherwise the camera doesn't provide any
- * controls that the user could try to change.
- */
-
-static void jlj_dostream(struct work_struct *work)
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data, int len)
 {
-        struct sd *dev = container_of(work, struct sd, work_struct);
-        struct gspca_dev *gspca_dev = &dev->gspca_dev;
-        int blocks_left; /* 0x200-sized blocks remaining in current frame. */
-        int size_in_blocks;
-        int act_len;
+        struct sd *sd = (struct sd *) gspca_dev;
         int packet_type;
-        int ret;
-        u8 *buffer;
+        u32 header_marker;
 
-        buffer = kmalloc(JEILINJ_MAX_TRANSFER, GFP_KERNEL | GFP_DMA);
-        if (!buffer) {
-                PDEBUG(D_ERR, "Couldn't allocate USB buffer");
-                goto quit_stream;
+        PDEBUG(D_STREAM, "Got %d bytes out of %d for Block 0",
+                        len, JEILINJ_MAX_TRANSFER);
+        if (len != JEILINJ_MAX_TRANSFER) {
+                PDEBUG(D_PACK, "bad length");
+                goto discard;
         }
-        while (gspca_dev->present && gspca_dev->streaming) {
-                /*
-                 * Now request data block 0. Line 0 reports the size
-                 * to download, in blocks of size 0x200, and also tells the
-                 * "actual" data size, in bytes, which seems best to ignore.
-                 */
-                ret = usb_bulk_msg(gspca_dev->dev,
-                                usb_rcvbulkpipe(gspca_dev->dev, 0x82),
-                                buffer, JEILINJ_MAX_TRANSFER, &act_len,
-                                JEILINJ_DATA_TIMEOUT);
-                PDEBUG(D_STREAM,
-                        "Got %d bytes out of %d for Block 0",
-                        act_len, JEILINJ_MAX_TRANSFER);
-                if (ret < 0 || act_len < FRAME_HEADER_LEN)
-                        goto quit_stream;
-                size_in_blocks = buffer[0x0a];
-                blocks_left = buffer[0x0a] - 1;
-                PDEBUG(D_STREAM, "blocks_left = 0x%x", blocks_left);
-
+        /* check if it's start of frame */
+        header_marker = ((u32 *)data)[0];
+        if (header_marker == FRAME_START) {
+                sd->blocks_left = data[0x0a] - 1;
+                PDEBUG(D_STREAM, "blocks_left = 0x%x", sd->blocks_left);
                 /* Start a new frame, and add the JPEG header, first thing */
                 gspca_frame_add(gspca_dev, FIRST_PACKET,
-                                dev->jpeg_hdr, JPEG_HDR_SZ);
+                                sd->jpeg_hdr, JPEG_HDR_SZ);
                 /* Toss line 0 of data block 0, keep the rest. */
                 gspca_frame_add(gspca_dev, INTER_PACKET,
-                                buffer + FRAME_HEADER_LEN,
+                                data + FRAME_HEADER_LEN,
                                 JEILINJ_MAX_TRANSFER - FRAME_HEADER_LEN);
-
-                while (blocks_left > 0) {
-                        if (!gspca_dev->present)
-                                goto quit_stream;
-                        ret = usb_bulk_msg(gspca_dev->dev,
-                                usb_rcvbulkpipe(gspca_dev->dev, 0x82),
-                                buffer, JEILINJ_MAX_TRANSFER, &act_len,
-                                JEILINJ_DATA_TIMEOUT);
-                        if (ret < 0 || act_len < JEILINJ_MAX_TRANSFER)
-                                goto quit_stream;
-                        PDEBUG(D_STREAM,
-                                "%d blocks remaining for frame", blocks_left);
-                        blocks_left -= 1;
-                        if (blocks_left == 0)
-                                packet_type = LAST_PACKET;
-                        else
-                                packet_type = INTER_PACKET;
-                        gspca_frame_add(gspca_dev, packet_type,
-                                        buffer, JEILINJ_MAX_TRANSFER);
-                }
-        }
-quit_stream:
-        mutex_lock(&gspca_dev->usb_lock);
-        if (gspca_dev->present)
-                jlj_stop(gspca_dev);
-        mutex_unlock(&gspca_dev->usb_lock);
-        kfree(buffer);
+        } else if (sd->blocks_left > 0) {
+                PDEBUG(D_STREAM, "%d blocks remaining for frame",
+                                sd->blocks_left);
+                sd->blocks_left -= 1;
+                if (sd->blocks_left == 0)
+                        packet_type = LAST_PACKET;
+                else
+                        packet_type = INTER_PACKET;
+                gspca_frame_add(gspca_dev, packet_type,
+                                data, JEILINJ_MAX_TRANSFER);
+        } else
+                goto discard;
+        return;
+discard:
+        /* Discard data until a new frame starts. */
+        gspca_dev->last_packet_type = DISCARD_PACKET;
 }
 
 /* This function is called at probe time just before sd_init */
@@ -256,78 +400,169 @@ static int sd_config(struct gspca_dev *gspca_dev,
         struct cam *cam = &gspca_dev->cam;
         struct sd *dev  = (struct sd *) gspca_dev;
 
-        dev->quality  = 85;
-        dev->jpegqual = 85;
+        dev->type = id->driver_info;
+        gspca_dev->cam.ctrls = dev->ctrls;
+        dev->quality = QUALITY_DEF;
+        dev->ctrls[LIGHTFREQ].def = V4L2_CID_POWER_LINE_FREQUENCY_60HZ;
+        dev->ctrls[RED].def = RED_BALANCE_DEF;
+        dev->ctrls[GREEN].def = GREEN_BALANCE_DEF;
+        dev->ctrls[BLUE].def = BLUE_BALANCE_DEF;
         PDEBUG(D_PROBE,
                 "JEILINJ camera detected"
                 " (vid/pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
         cam->cam_mode = jlj_mode;
-        cam->nmodes = 1;
+        cam->nmodes = ARRAY_SIZE(jlj_mode);
         cam->bulk = 1;
-        /* We don't use the buffer gspca allocates so make it small. */
-        cam->bulk_size = 32;
-        INIT_WORK(&dev->work_struct, jlj_dostream);
+        cam->bulk_nurbs = 1;
+        cam->bulk_size = JEILINJ_MAX_TRANSFER;
         return 0;
 }
 
-/* called on streamoff with alt==0 and on disconnect */
-/* the usb_lock is held at entry - restore on exit */
-static void sd_stop0(struct gspca_dev *gspca_dev)
+static void sd_stopN(struct gspca_dev *gspca_dev)
 {
-        struct sd *dev = (struct sd *) gspca_dev;
+        int i;
+        u8 *buf;
+        u8 stop_commands[][2] = {
+                {0x71, 0x00},
+                {0x70, 0x09},
+                {0x71, 0x80},
+                {0x70, 0x05}
+        };
+
+        for (;;) {
+                /* get the image remaining blocks */
+                usb_bulk_msg(gspca_dev->dev,
+                                gspca_dev->urb[0]->pipe,
+                                gspca_dev->urb[0]->transfer_buffer,
+                                JEILINJ_MAX_TRANSFER, NULL,
+                                JEILINJ_DATA_TIMEOUT);
+
+                /* search for 0xff 0xd9  (EOF for JPEG) */
+                i = 0;
+                buf = gspca_dev->urb[0]->transfer_buffer;
+                while ((i < (JEILINJ_MAX_TRANSFER - 1)) &&
+                        ((buf[i] != 0xff) || (buf[i+1] != 0xd9)))
+                        i++;
+
+                if (i != (JEILINJ_MAX_TRANSFER - 1))
+                        /* last remaining block found */
+                        break;
+                }
 
-        /* wait for the work queue to terminate */
-        mutex_unlock(&gspca_dev->usb_lock);
-        /* This waits for jlj_dostream to finish */
-        destroy_workqueue(dev->work_thread);
-        dev->work_thread = NULL;
-        mutex_lock(&gspca_dev->usb_lock);
+        for (i = 0; i < ARRAY_SIZE(stop_commands); i++)
+                jlj_write2(gspca_dev, stop_commands[i]);
 }
 
 /* this function is called at probe and resume time */
 static int sd_init(struct gspca_dev *gspca_dev)
 {
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 /* Set up for getting frames. */
 static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *dev = (struct sd *) gspca_dev;
-        int ret;
 
         /* create the JPEG header */
         jpeg_define(dev->jpeg_hdr, gspca_dev->height, gspca_dev->width,
                         0x21);          /* JPEG 422 */
         jpeg_set_qual(dev->jpeg_hdr, dev->quality);
-        PDEBUG(D_STREAM, "Start streaming at 320x240");
-        ret = jlj_start(gspca_dev);
-        if (ret < 0) {
-                PDEBUG(D_ERR, "Start streaming command failed");
-                return ret;
-        }
-        /* Start the workqueue function to do the streaming */
-        dev->work_thread = create_singlethread_workqueue(MODULE_NAME);
-        queue_work(dev->work_thread, &dev->work_struct);
-
-        return 0;
+        PDEBUG(D_STREAM, "Start streaming at %dx%d",
+                gspca_dev->height, gspca_dev->width);
+        jlj_start(gspca_dev);
+        return gspca_dev->usb_err;
 }
 
 /* Table of supported USB devices */
-static const __devinitdata struct usb_device_id device_table[] = {
-        {USB_DEVICE(0x0979, 0x0280)},
+static const struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x0979, 0x0280), .driver_info = SAKAR_57379},
+        {USB_DEVICE(0x0979, 0x0270), .driver_info = SPORTSCAM_DV15},
         {}
 };
 
 MODULE_DEVICE_TABLE(usb, device_table);
 
+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, "disable");
+                        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;
+}
+
+static int sd_set_jcomp(struct gspca_dev *gspca_dev,
+                        struct v4l2_jpegcompression *jcomp)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (jcomp->quality < QUALITY_MIN)
+                sd->quality = QUALITY_MIN;
+        else if (jcomp->quality > QUALITY_MAX)
+                sd->quality = QUALITY_MAX;
+        else
+                sd->quality = jcomp->quality;
+        if (gspca_dev->streaming) {
+                jpeg_set_qual(sd->jpeg_hdr, sd->quality);
+                setcamquality(gspca_dev);
+        }
+        return 0;
+}
+
+static int sd_get_jcomp(struct gspca_dev *gspca_dev,
+                        struct v4l2_jpegcompression *jcomp)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        memset(jcomp, 0, sizeof *jcomp);
+        jcomp->quality = sd->quality;
+        jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
+                        | V4L2_JPEG_MARKER_DQT;
+        return 0;
+}
+
+
 /* sub-driver description */
-static const struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc_sakar_57379 = {
         .name   = MODULE_NAME,
         .config = sd_config,
         .init   = sd_init,
         .start  = sd_start,
-        .stop0  = sd_stop0,
+        .stopN  = sd_stopN,
+        .pkt_scan = sd_pkt_scan,
+};
+
+/* sub-driver description */
+static const struct sd_desc sd_desc_sportscam_dv15 = {
+        .name   = MODULE_NAME,
+        .config = sd_config,
+        .init   = sd_init,
+        .start  = sd_start,
+        .stopN  = sd_stopN,
+        .pkt_scan = sd_pkt_scan,
+        .ctrls = sd_ctrls,
+        .nctrls = ARRAY_SIZE(sd_ctrls),
+        .querymenu = sd_querymenu,
+        .get_jcomp = sd_get_jcomp,
+        .set_jcomp = sd_set_jcomp,
+};
+
+static const struct sd_desc *sd_desc[2] = {
+        &sd_desc_sakar_57379,
+        &sd_desc_sportscam_dv15
 };
 
 /* -- device connect -- */
@@ -335,7 +570,7 @@ static int sd_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
         return gspca_dev_probe(intf, id,
-                        &sd_desc,
+                        sd_desc[id->driver_info],
                         sizeof(struct sd),
                         THIS_MODULE);
 }
@@ -354,19 +589,12 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/jpeg.h b/drivers/media/video/gspca/jpeg.h
index de63c36806c0..ab54910418b4 100644
--- a/drivers/media/video/gspca/jpeg.h
+++ b/drivers/media/video/gspca/jpeg.h
@@ -141,9 +141,9 @@ static void jpeg_define(u8 *jpeg_hdr,
         memcpy(jpeg_hdr, jpeg_head, sizeof jpeg_head);
 #ifndef CONEX_CAM
         jpeg_hdr[JPEG_HEIGHT_OFFSET + 0] = height >> 8;
-        jpeg_hdr[JPEG_HEIGHT_OFFSET + 1] = height & 0xff;
+        jpeg_hdr[JPEG_HEIGHT_OFFSET + 1] = height;
         jpeg_hdr[JPEG_HEIGHT_OFFSET + 2] = width >> 8;
-        jpeg_hdr[JPEG_HEIGHT_OFFSET + 3] = width & 0xff;
+        jpeg_hdr[JPEG_HEIGHT_OFFSET + 3] = width;
         jpeg_hdr[JPEG_HEIGHT_OFFSET + 6] = samplesY;
 #endif
 }
diff --git a/drivers/media/video/gspca/kinect.c b/drivers/media/video/gspca/kinect.c
new file mode 100644
index 000000000000..26fc206f095e
--- /dev/null
+++ b/drivers/media/video/gspca/kinect.c
@@ -0,0 +1,429 @@
+/*
+ * kinect sensor device camera, gspca driver
+ *
+ * Copyright (C) 2011  Antonio Ospite <ospite@studenti.unina.it>
+ *
+ * Based on the OpenKinect project and libfreenect
+ * http://openkinect.org/wiki/Init_Analysis
+ *
+ * Special thanks to Steven Toth and kernellabs.com for sponsoring a Kinect
+ * sensor device which I tested the driver on.
+ *
+ * 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 "kinect"
+
+#include "gspca.h"
+
+#define CTRL_TIMEOUT 500
+
+MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
+MODULE_DESCRIPTION("GSPCA/Kinect Sensor Device USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+#ifdef GSPCA_DEBUG
+int gspca_debug = D_ERR | D_PROBE | D_CONF | D_STREAM | D_FRAM | D_PACK |
+        D_USBI | D_USBO | D_V4L2;
+#endif
+
+struct pkt_hdr {
+        uint8_t magic[2];
+        uint8_t pad;
+        uint8_t flag;
+        uint8_t unk1;
+        uint8_t seq;
+        uint8_t unk2;
+        uint8_t unk3;
+        uint32_t timestamp;
+};
+
+struct cam_hdr {
+        uint8_t magic[2];
+        uint16_t len;
+        uint16_t cmd;
+        uint16_t tag;
+};
+
+/* specific webcam descriptor */
+struct sd {
+        struct gspca_dev gspca_dev; /* !! must be the first item */
+        uint16_t cam_tag;           /* a sequence number for packets */
+        uint8_t stream_flag;        /* to identify different stream types */
+        uint8_t obuf[0x400];        /* output buffer for control commands */
+        uint8_t ibuf[0x200];        /* input buffer for control commands */
+};
+
+/* V4L2 controls supported by the driver */
+/* controls prototypes here */
+
+static const struct ctrl sd_ctrls[] = {
+};
+
+#define MODE_640x480   0x0001
+#define MODE_640x488   0x0002
+#define MODE_1280x1024 0x0004
+
+#define FORMAT_BAYER   0x0010
+#define FORMAT_UYVY    0x0020
+#define FORMAT_Y10B    0x0040
+
+#define FPS_HIGH       0x0100
+
+static const struct v4l2_pix_format video_camera_mode[] = {
+        {640, 480, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
+         .bytesperline = 640,
+         .sizeimage = 640 * 480,
+         .colorspace = V4L2_COLORSPACE_SRGB,
+         .priv = MODE_640x480 | FORMAT_BAYER | FPS_HIGH},
+        {640, 480, V4L2_PIX_FMT_UYVY, V4L2_FIELD_NONE,
+         .bytesperline = 640 * 2,
+         .sizeimage = 640 * 480 * 2,
+         .colorspace = V4L2_COLORSPACE_SRGB,
+         .priv = MODE_640x480 | FORMAT_UYVY},
+        {1280, 1024, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
+         .bytesperline = 1280,
+         .sizeimage = 1280 * 1024,
+         .colorspace = V4L2_COLORSPACE_SRGB,
+         .priv = MODE_1280x1024 | FORMAT_BAYER},
+        {640, 488, V4L2_PIX_FMT_Y10BPACK, V4L2_FIELD_NONE,
+         .bytesperline = 640 * 10 / 8,
+         .sizeimage =  640 * 488 * 10 / 8,
+         .colorspace = V4L2_COLORSPACE_SRGB,
+         .priv = MODE_640x488 | FORMAT_Y10B | FPS_HIGH},
+        {1280, 1024, V4L2_PIX_FMT_Y10BPACK, V4L2_FIELD_NONE,
+         .bytesperline = 1280 * 10 / 8,
+         .sizeimage =  1280 * 1024 * 10 / 8,
+         .colorspace = V4L2_COLORSPACE_SRGB,
+         .priv = MODE_1280x1024 | FORMAT_Y10B},
+};
+
+static int kinect_write(struct usb_device *udev, uint8_t *data,
+                        uint16_t wLength)
+{
+        return usb_control_msg(udev,
+                              usb_sndctrlpipe(udev, 0),
+                              0x00,
+                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                              0, 0, data, wLength, CTRL_TIMEOUT);
+}
+
+static int kinect_read(struct usb_device *udev, uint8_t *data, uint16_t wLength)
+{
+        return usb_control_msg(udev,
+                              usb_rcvctrlpipe(udev, 0),
+                              0x00,
+                              USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                              0, 0, data, wLength, CTRL_TIMEOUT);
+}
+
+static int send_cmd(struct gspca_dev *gspca_dev, uint16_t cmd, void *cmdbuf,
+                unsigned int cmd_len, void *replybuf, unsigned int reply_len)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct usb_device *udev = gspca_dev->dev;
+        int res, actual_len;
+        uint8_t *obuf = sd->obuf;
+        uint8_t *ibuf = sd->ibuf;
+        struct cam_hdr *chdr = (void *)obuf;
+        struct cam_hdr *rhdr = (void *)ibuf;
+
+        if (cmd_len & 1 || cmd_len > (0x400 - sizeof(*chdr))) {
+                err("send_cmd: Invalid command length (0x%x)", cmd_len);
+                return -1;
+        }
+
+        chdr->magic[0] = 0x47;
+        chdr->magic[1] = 0x4d;
+        chdr->cmd = cpu_to_le16(cmd);
+        chdr->tag = cpu_to_le16(sd->cam_tag);
+        chdr->len = cpu_to_le16(cmd_len / 2);
+
+        memcpy(obuf+sizeof(*chdr), cmdbuf, cmd_len);
+
+        res = kinect_write(udev, obuf, cmd_len + sizeof(*chdr));
+        PDEBUG(D_USBO, "Control cmd=%04x tag=%04x len=%04x: %d", cmd,
+                sd->cam_tag, cmd_len, res);
+        if (res < 0) {
+                err("send_cmd: Output control transfer failed (%d)", res);
+                return res;
+        }
+
+        do {
+                actual_len = kinect_read(udev, ibuf, 0x200);
+        } while (actual_len == 0);
+        PDEBUG(D_USBO, "Control reply: %d", res);
+        if (actual_len < sizeof(*rhdr)) {
+                err("send_cmd: Input control transfer failed (%d)", res);
+                return res;
+        }
+        actual_len -= sizeof(*rhdr);
+
+        if (rhdr->magic[0] != 0x52 || rhdr->magic[1] != 0x42) {
+                err("send_cmd: Bad magic %02x %02x", rhdr->magic[0],
+                        rhdr->magic[1]);
+                return -1;
+        }
+        if (rhdr->cmd != chdr->cmd) {
+                err("send_cmd: Bad cmd %02x != %02x", rhdr->cmd, chdr->cmd);
+                return -1;
+        }
+        if (rhdr->tag != chdr->tag) {
+                err("send_cmd: Bad tag %04x != %04x", rhdr->tag, chdr->tag);
+                return -1;
+        }
+        if (cpu_to_le16(rhdr->len) != (actual_len/2)) {
+                err("send_cmd: Bad len %04x != %04x",
+                                cpu_to_le16(rhdr->len), (int)(actual_len/2));
+                return -1;
+        }
+
+        if (actual_len > reply_len) {
+                warn("send_cmd: Data buffer is %d bytes long, but got %d bytes",
+                                reply_len, actual_len);
+                memcpy(replybuf, ibuf+sizeof(*rhdr), reply_len);
+        } else {
+                memcpy(replybuf, ibuf+sizeof(*rhdr), actual_len);
+        }
+
+        sd->cam_tag++;
+
+        return actual_len;
+}
+
+static int write_register(struct gspca_dev *gspca_dev, uint16_t reg,
+                        uint16_t data)
+{
+        uint16_t reply[2];
+        uint16_t cmd[2];
+        int res;
+
+        cmd[0] = cpu_to_le16(reg);
+        cmd[1] = cpu_to_le16(data);
+
+        PDEBUG(D_USBO, "Write Reg 0x%04x <= 0x%02x", reg, data);
+        res = send_cmd(gspca_dev, 0x03, cmd, 4, reply, 4);
+        if (res < 0)
+                return res;
+        if (res != 2) {
+                warn("send_cmd returned %d [%04x %04x], 0000 expected",
+                                res, reply[0], reply[1]);
+        }
+        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;
+
+        sd->cam_tag = 0;
+
+        /* Only video stream is supported for now,
+         * which has stream flag = 0x80 */
+        sd->stream_flag = 0x80;
+
+        cam = &gspca_dev->cam;
+
+        cam->cam_mode = video_camera_mode;
+        cam->nmodes = ARRAY_SIZE(video_camera_mode);
+
+#if 0
+        /* Setting those values is not needed for video stream */
+        cam->npkt = 15;
+        gspca_dev->pkt_size = 960 * 2;
+#endif
+
+        return 0;
+}
+
+/* this function is called at probe and resume time */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+        PDEBUG(D_PROBE, "Kinect Camera device.");
+
+        return 0;
+}
+
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        int mode;
+        uint8_t fmt_reg, fmt_val;
+        uint8_t res_reg, res_val;
+        uint8_t fps_reg, fps_val;
+        uint8_t mode_val;
+
+        mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
+
+        if (mode & FORMAT_Y10B) {
+                fmt_reg = 0x19;
+                res_reg = 0x1a;
+                fps_reg = 0x1b;
+                mode_val = 0x03;
+        } else {
+                fmt_reg = 0x0c;
+                res_reg = 0x0d;
+                fps_reg = 0x0e;
+                mode_val = 0x01;
+        }
+
+        /* format */
+        if (mode & FORMAT_UYVY)
+                fmt_val = 0x05;
+        else
+                fmt_val = 0x00;
+
+        if (mode & MODE_1280x1024)
+                res_val = 0x02;
+        else
+                res_val = 0x01;
+
+        if (mode & FPS_HIGH)
+                fps_val = 0x1e;
+        else
+                fps_val = 0x0f;
+
+
+        /* turn off IR-reset function */
+        write_register(gspca_dev, 0x105, 0x00);
+
+        /* Reset video stream */
+        write_register(gspca_dev, 0x05, 0x00);
+
+        /* Due to some ridiculous condition in the firmware, we have to start
+         * and stop the depth stream before the camera will hand us 1280x1024
+         * IR.  This is a stupid workaround, but we've yet to find a better
+         * solution.
+         *
+         * Thanks to Drew Fisher for figuring this out.
+         */
+        if (mode & (FORMAT_Y10B | MODE_1280x1024)) {
+                write_register(gspca_dev, 0x13, 0x01);
+                write_register(gspca_dev, 0x14, 0x1e);
+                write_register(gspca_dev, 0x06, 0x02);
+                write_register(gspca_dev, 0x06, 0x00);
+        }
+
+        write_register(gspca_dev, fmt_reg, fmt_val);
+        write_register(gspca_dev, res_reg, res_val);
+        write_register(gspca_dev, fps_reg, fps_val);
+
+        /* Start video stream */
+        write_register(gspca_dev, 0x05, mode_val);
+
+        /* disable Hflip */
+        write_register(gspca_dev, 0x47, 0x00);
+
+        return 0;
+}
+
+static void sd_stopN(struct gspca_dev *gspca_dev)
+{
+        /* reset video stream */
+        write_register(gspca_dev, 0x05, 0x00);
+}
+
+static void sd_pkt_scan(struct gspca_dev *gspca_dev, u8 *__data, int len)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        struct pkt_hdr *hdr = (void *)__data;
+        uint8_t *data = __data + sizeof(*hdr);
+        int datalen = len - sizeof(*hdr);
+
+        uint8_t sof = sd->stream_flag | 1;
+        uint8_t mof = sd->stream_flag | 2;
+        uint8_t eof = sd->stream_flag | 5;
+
+        if (len < 12)
+                return;
+
+        if (hdr->magic[0] != 'R' || hdr->magic[1] != 'B') {
+                warn("[Stream %02x] Invalid magic %02x%02x", sd->stream_flag,
+                                hdr->magic[0], hdr->magic[1]);
+                return;
+        }
+
+        if (hdr->flag == sof)
+                gspca_frame_add(gspca_dev, FIRST_PACKET, data, datalen);
+
+        else if (hdr->flag == mof)
+                gspca_frame_add(gspca_dev, INTER_PACKET, data, datalen);
+
+        else if (hdr->flag == eof)
+                gspca_frame_add(gspca_dev, LAST_PACKET, data, datalen);
+
+        else
+                warn("Packet type not recognized...");
+}
+
+/* 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,
+        .get_streamparm = sd_get_streamparm,
+        .set_streamparm = sd_set_streamparm,
+        */
+};
+
+/* -- module initialisation -- */
+static const struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x045e, 0x02ae)},
+        {}
+};
+
+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)
+{
+        return usb_register(&sd_driver);
+}
+
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
diff --git a/drivers/media/video/gspca/konica.c b/drivers/media/video/gspca/konica.c
new file mode 100644
index 000000000000..5964691c0e95
--- /dev/null
+++ b/drivers/media/video/gspca/konica.c
@@ -0,0 +1,646 @@
+/*
+ * Driver for USB webcams based on Konica chipset. This
+ * chipset is used in Intel YC76 camera.
+ *
+ * Copyright (C) 2010 Hans de Goede <hdegoede@redhat.com>
+ *
+ * Based on the usbvideo v4l1 konicawc driver which is:
+ *
+ * Copyright (C) 2002 Simon Evans <spse@secret.org.uk>
+ *
+ * The code for making gspca work with a webcam with 2 isoc endpoints was
+ * taken from the benq gspca subdriver which is:
+ *
+ * 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 "konica"
+
+#include <linux/input.h>
+#include "gspca.h"
+
+MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
+MODULE_DESCRIPTION("Konica chipset USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+#define WHITEBAL_REG   0x01
+#define BRIGHTNESS_REG 0x02
+#define SHARPNESS_REG  0x03
+#define CONTRAST_REG   0x04
+#define SATURATION_REG 0x05
+
+/* specific webcam descriptor */
+struct sd {
+        struct gspca_dev gspca_dev;     /* !! must be the first item */
+        struct urb *last_data_urb;
+        u8 snapshot_pressed;
+        u8 brightness;
+        u8 contrast;
+        u8 saturation;
+        u8 whitebal;
+        u8 sharpness;
+};
+
+/* 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_setwhitebal(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getwhitebal(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 const struct ctrl sd_ctrls[] = {
+#define SD_BRIGHTNESS 0
+        {
+            {
+                .id      = V4L2_CID_BRIGHTNESS,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Brightness",
+                .minimum = 0,
+                .maximum = 9,
+                .step = 1,
+#define BRIGHTNESS_DEFAULT 4
+                .default_value = BRIGHTNESS_DEFAULT,
+                .flags = 0,
+            },
+            .set = sd_setbrightness,
+            .get = sd_getbrightness,
+        },
+#define SD_CONTRAST 1
+        {
+            {
+                .id = V4L2_CID_CONTRAST,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Contrast",
+                .minimum = 0,
+                .maximum = 9,
+                .step = 4,
+#define CONTRAST_DEFAULT 10
+                .default_value = CONTRAST_DEFAULT,
+                .flags = 0,
+            },
+            .set = sd_setcontrast,
+            .get = sd_getcontrast,
+        },
+#define SD_SATURATION 2
+        {
+            {
+                .id     = V4L2_CID_SATURATION,
+                .type   = V4L2_CTRL_TYPE_INTEGER,
+                .name   = "Saturation",
+                .minimum = 0,
+                .maximum = 9,
+                .step   = 1,
+#define SATURATION_DEFAULT 4
+                .default_value = SATURATION_DEFAULT,
+                .flags = 0,
+            },
+            .set = sd_setsaturation,
+            .get = sd_getsaturation,
+        },
+#define SD_WHITEBAL 3
+        {
+            {
+                .id = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "White Balance",
+                .minimum = 0,
+                .maximum = 33,
+                .step = 1,
+#define WHITEBAL_DEFAULT 25
+                .default_value = WHITEBAL_DEFAULT,
+                .flags = 0,
+            },
+            .set = sd_setwhitebal,
+            .get = sd_getwhitebal,
+        },
+#define SD_SHARPNESS 4
+        {
+            {
+                .id = V4L2_CID_SHARPNESS,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Sharpness",
+                .minimum = 0,
+                .maximum = 9,
+                .step = 1,
+#define SHARPNESS_DEFAULT 4
+                .default_value = SHARPNESS_DEFAULT,
+                .flags = 0,
+            },
+            .set = sd_setsharpness,
+            .get = sd_getsharpness,
+        },
+};
+
+/* .priv is what goes to register 8 for this mode, known working values:
+   0x00 -> 176x144, cropped
+   0x01 -> 176x144, cropped
+   0x02 -> 176x144, cropped
+   0x03 -> 176x144, cropped
+   0x04 -> 176x144, binned
+   0x05 -> 320x240
+   0x06 -> 320x240
+   0x07 -> 160x120, cropped
+   0x08 -> 160x120, cropped
+   0x09 -> 160x120, binned (note has 136 lines)
+   0x0a -> 160x120, binned (note has 136 lines)
+   0x0b -> 160x120, cropped
+*/
+static const struct v4l2_pix_format vga_mode[] = {
+        {160, 120, V4L2_PIX_FMT_KONICA420, V4L2_FIELD_NONE,
+                .bytesperline = 160,
+                .sizeimage = 160 * 136 * 3 / 2 + 960,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0x0a},
+        {176, 144, V4L2_PIX_FMT_KONICA420, V4L2_FIELD_NONE,
+                .bytesperline = 176,
+                .sizeimage = 176 * 144 * 3 / 2 + 960,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0x04},
+        {320, 240, V4L2_PIX_FMT_KONICA420, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 3 / 2 + 960,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0x05},
+};
+
+static void sd_isoc_irq(struct urb *urb);
+
+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,
+                        1000);
+        if (ret < 0) {
+                err("reg_w err %d", ret);
+                gspca_dev->usb_err = ret;
+        }
+}
+
+static void reg_r(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_rcvctrlpipe(dev, 0),
+                        0x03,
+                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                        value,
+                        index,
+                        gspca_dev->usb_buf,
+                        2,
+                        1000);
+        if (ret < 0) {
+                err("reg_w err %d", ret);
+                gspca_dev->usb_err = ret;
+        }
+}
+
+static void konica_stream_on(struct gspca_dev *gspca_dev)
+{
+        reg_w(gspca_dev, 1, 0x0b);
+}
+
+static void konica_stream_off(struct gspca_dev *gspca_dev)
+{
+        reg_w(gspca_dev, 0, 0x0b);
+}
+
+/* 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;
+
+        gspca_dev->cam.cam_mode = vga_mode;
+        gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
+        gspca_dev->cam.no_urb_create = 1;
+        /* The highest alt setting has an isoc packetsize of 0, so we
+           don't want to use it */
+        gspca_dev->nbalt--;
+
+        sd->brightness  = BRIGHTNESS_DEFAULT;
+        sd->contrast    = CONTRAST_DEFAULT;
+        sd->saturation  = SATURATION_DEFAULT;
+        sd->whitebal    = WHITEBAL_DEFAULT;
+        sd->sharpness   = SHARPNESS_DEFAULT;
+
+        return 0;
+}
+
+/* this function is called at probe and resume time */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+        /* HDG not sure if these 2 reads are needed */
+        reg_r(gspca_dev, 0, 0x10);
+        PDEBUG(D_PROBE, "Reg 0x10 reads: %02x %02x",
+               gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]);
+        reg_r(gspca_dev, 0, 0x10);
+        PDEBUG(D_PROBE, "Reg 0x10 reads: %02x %02x",
+               gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]);
+        reg_w(gspca_dev, 0, 0x0d);
+
+        return 0;
+}
+
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct urb *urb;
+        int i, n, packet_size;
+        struct usb_host_interface *alt;
+        struct usb_interface *intf;
+
+        intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
+        alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
+        if (!alt) {
+                err("Couldn't get altsetting");
+                return -EIO;
+        }
+
+        packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
+
+        reg_w(gspca_dev, sd->brightness, BRIGHTNESS_REG);
+        reg_w(gspca_dev, sd->whitebal, WHITEBAL_REG);
+        reg_w(gspca_dev, sd->contrast, CONTRAST_REG);
+        reg_w(gspca_dev, sd->saturation, SATURATION_REG);
+        reg_w(gspca_dev, sd->sharpness, SHARPNESS_REG);
+
+        n = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
+        reg_w(gspca_dev, n, 0x08);
+
+        konica_stream_on(gspca_dev);
+
+        if (gspca_dev->usb_err)
+                return gspca_dev->usb_err;
+
+        /* 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_NPKT 32
+        for (n = 0; n < 4; n++) {
+                i = n & 1 ? 0 : 1;
+                packet_size =
+                        le16_to_cpu(alt->endpoint[i].desc.wMaxPacketSize);
+                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_alloc_coherent(gspca_dev->dev,
+                                                packet_size * 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 = packet_size * SD_NPKT;
+                urb->pipe = usb_rcvisocpipe(gspca_dev->dev,
+                                        n & 1 ? 0x81 : 0x82);
+                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 = packet_size;
+                        urb->iso_frame_desc[i].offset = packet_size * i;
+                }
+        }
+
+        return 0;
+}
+
+static void sd_stopN(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        konica_stream_off(gspca_dev);
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+        /* Don't keep the button in the pressed state "forever" if it was
+           pressed when streaming is stopped */
+        if (sd->snapshot_pressed) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                input_sync(gspca_dev->input_dev);
+                sd->snapshot_pressed = 0;
+        }
+#endif
+}
+
+/* reception of an URB */
+static void sd_isoc_irq(struct urb *urb)
+{
+        struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct urb *data_urb, *status_urb;
+        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, "urb status: %d", urb->status);
+                st = usb_submit_urb(urb, GFP_ATOMIC);
+                if (st < 0)
+                        err("resubmit urb error %d", st);
+                return;
+        }
+
+        /* if this is a data URB (ep 0x82), wait */
+        if (urb->transfer_buffer_length > 32) {
+                sd->last_data_urb = urb;
+                return;
+        }
+
+        status_urb = urb;
+        data_urb   = sd->last_data_urb;
+        sd->last_data_urb = NULL;
+
+        if (!data_urb || data_urb->start_frame != status_urb->start_frame) {
+                PDEBUG(D_ERR|D_PACK, "lost sync on frames");
+                goto resubmit;
+        }
+
+        if (data_urb->number_of_packets != status_urb->number_of_packets) {
+                PDEBUG(D_ERR|D_PACK,
+                       "no packets does not match, data: %d, status: %d",
+                       data_urb->number_of_packets,
+                       status_urb->number_of_packets);
+                goto resubmit;
+        }
+
+        for (i = 0; i < status_urb->number_of_packets; i++) {
+                if (data_urb->iso_frame_desc[i].status ||
+                    status_urb->iso_frame_desc[i].status) {
+                        PDEBUG(D_ERR|D_PACK,
+                               "pkt %d data-status %d, status-status %d", i,
+                               data_urb->iso_frame_desc[i].status,
+                               status_urb->iso_frame_desc[i].status);
+                        gspca_dev->last_packet_type = DISCARD_PACKET;
+                        continue;
+                }
+
+                if (status_urb->iso_frame_desc[i].actual_length != 1) {
+                        PDEBUG(D_ERR|D_PACK,
+                               "bad status packet length %d",
+                               status_urb->iso_frame_desc[i].actual_length);
+                        gspca_dev->last_packet_type = DISCARD_PACKET;
+                        continue;
+                }
+
+                st = *((u8 *)status_urb->transfer_buffer
+                                + status_urb->iso_frame_desc[i].offset);
+
+                data = (u8 *)data_urb->transfer_buffer
+                                + data_urb->iso_frame_desc[i].offset;
+
+                /* st: 0x80-0xff: frame start with frame number (ie 0-7f)
+                 * otherwise:
+                 * bit 0 0: keep packet
+                 *       1: drop packet (padding data)
+                 *
+                 * bit 4 0 button not clicked
+                 *       1 button clicked
+                 * button is used to `take a picture' (in software)
+                 */
+                if (st & 0x80) {
+                        gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
+                        gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
+                } else {
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+                        u8 button_state = st & 0x40 ? 1 : 0;
+                        if (sd->snapshot_pressed != button_state) {
+                                input_report_key(gspca_dev->input_dev,
+                                                 KEY_CAMERA,
+                                                 button_state);
+                                input_sync(gspca_dev->input_dev);
+                                sd->snapshot_pressed = button_state;
+                        }
+#endif
+                        if (st & 0x01)
+                                continue;
+                }
+                gspca_frame_add(gspca_dev, INTER_PACKET, data,
+                                data_urb->iso_frame_desc[i].actual_length);
+        }
+
+resubmit:
+        if (data_urb) {
+                st = usb_submit_urb(data_urb, GFP_ATOMIC);
+                if (st < 0)
+                        PDEBUG(D_ERR|D_PACK,
+                               "usb_submit_urb(data_urb) ret %d", st);
+        }
+        st = usb_submit_urb(status_urb, GFP_ATOMIC);
+        if (st < 0)
+                err("usb_submit_urb(status_urb) ret %d", st);
+}
+
+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) {
+                konica_stream_off(gspca_dev);
+                reg_w(gspca_dev, sd->brightness, BRIGHTNESS_REG);
+                konica_stream_on(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) {
+                konica_stream_off(gspca_dev);
+                reg_w(gspca_dev, sd->contrast, CONTRAST_REG);
+                konica_stream_on(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_setsaturation(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->saturation = val;
+        if (gspca_dev->streaming) {
+                konica_stream_off(gspca_dev);
+                reg_w(gspca_dev, sd->saturation, SATURATION_REG);
+                konica_stream_on(gspca_dev);
+        }
+        return 0;
+}
+
+static int sd_getsaturation(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->saturation;
+
+        return 0;
+}
+
+static int sd_setwhitebal(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->whitebal = val;
+        if (gspca_dev->streaming) {
+                konica_stream_off(gspca_dev);
+                reg_w(gspca_dev, sd->whitebal, WHITEBAL_REG);
+                konica_stream_on(gspca_dev);
+        }
+        return 0;
+}
+
+static int sd_getwhitebal(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->whitebal;
+
+        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) {
+                konica_stream_off(gspca_dev);
+                reg_w(gspca_dev, sd->sharpness, SHARPNESS_REG);
+                konica_stream_on(gspca_dev);
+        }
+        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;
+}
+
+/* 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,
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+        .other_input = 1,
+#endif
+};
+
+/* -- module initialisation -- */
+static const struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x04c8, 0x0720)}, /* Intel YC 76 */
+        {}
+};
+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)
+{
+        return usb_register(&sd_driver);
+}
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
diff --git a/drivers/media/video/gspca/m5602/m5602_core.c b/drivers/media/video/gspca/m5602/m5602_core.c
index b073d66acd04..a7722b1aef9b 100644
--- a/drivers/media/video/gspca/m5602/m5602_core.c
+++ b/drivers/media/video/gspca/m5602/m5602_core.c
@@ -28,7 +28,7 @@ int force_sensor;
 static int dump_bridge;
 int dump_sensor;
 
-static const __devinitdata struct usb_device_id m5602_table[] = {
+static const struct usb_device_id m5602_table[] = {
         {USB_DEVICE(0x0402, 0x5602)},
         {}
 };
@@ -406,18 +406,12 @@ static struct usb_driver sd_driver = {
 /* -- module insert / remove -- */
 static int __init mod_m5602_init(void)
 {
-        int ret;
-        ret = usb_register(&sd_driver);
-        if (ret < 0)
-                return ret;
-        PDEBUG(D_PROBE, "registered");
-        return 0;
+        return usb_register(&sd_driver);
 }
 
 static void __exit mod_m5602_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(mod_m5602_init);
diff --git a/drivers/media/video/gspca/m5602/m5602_mt9m111.c b/drivers/media/video/gspca/m5602/m5602_mt9m111.c
index c0722fa64606..0d605a52b924 100644
--- a/drivers/media/video/gspca/m5602/m5602_mt9m111.c
+++ b/drivers/media/video/gspca/m5602/m5602_mt9m111.c
@@ -109,14 +109,14 @@ static const struct ctrl mt9m111_ctrls[] = {
 #define GREEN_BALANCE_IDX 4
         {
                 {
-                        .id             = M5602_V4L2_CID_GREEN_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_INTEGER,
-                        .name           = "green balance",
-                        .minimum        = 0x00,
-                        .maximum        = 0x7ff,
-                        .step           = 0x1,
-                        .default_value  = MT9M111_GREEN_GAIN_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .id             = M5602_V4L2_CID_GREEN_BALANCE,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "green balance",
+                        .minimum        = 0x00,
+                        .maximum        = 0x7ff,
+                        .step           = 0x1,
+                        .default_value  = MT9M111_GREEN_GAIN_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = mt9m111_set_green_balance,
                 .get = mt9m111_get_green_balance
@@ -124,14 +124,14 @@ static const struct ctrl mt9m111_ctrls[] = {
 #define BLUE_BALANCE_IDX 5
         {
                 {
-                        .id             = V4L2_CID_BLUE_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_INTEGER,
-                        .name           = "blue balance",
-                        .minimum        = 0x00,
-                        .maximum        = 0x7ff,
-                        .step           = 0x1,
-                        .default_value  = MT9M111_BLUE_GAIN_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .id             = V4L2_CID_BLUE_BALANCE,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "blue balance",
+                        .minimum        = 0x00,
+                        .maximum        = 0x7ff,
+                        .step           = 0x1,
+                        .default_value  = MT9M111_BLUE_GAIN_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = mt9m111_set_blue_balance,
                 .get = mt9m111_get_blue_balance
@@ -139,14 +139,14 @@ static const struct ctrl mt9m111_ctrls[] = {
 #define RED_BALANCE_IDX 5
         {
                 {
-                        .id             = V4L2_CID_RED_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_INTEGER,
-                        .name           = "red balance",
-                        .minimum        = 0x00,
-                        .maximum        = 0x7ff,
-                        .step           = 0x1,
-                        .default_value  = MT9M111_RED_GAIN_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .id             = V4L2_CID_RED_BALANCE,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "red balance",
+                        .minimum        = 0x00,
+                        .maximum        = 0x7ff,
+                        .step           = 0x1,
+                        .default_value  = MT9M111_RED_GAIN_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = mt9m111_set_red_balance,
                 .get = mt9m111_get_red_balance
diff --git a/drivers/media/video/gspca/m5602/m5602_mt9m111.h b/drivers/media/video/gspca/m5602/m5602_mt9m111.h
index b3de77823091..b1f0c492036a 100644
--- a/drivers/media/video/gspca/m5602/m5602_mt9m111.h
+++ b/drivers/media/video/gspca/m5602/m5602_mt9m111.h
@@ -70,7 +70,7 @@
 #define MT9M111_COLORPIPE                       0x01
 #define MT9M111_CAMERA_CONTROL                  0x02
 
-#define MT9M111_RESET                           (1 << 0)
+#define MT9M111_RESET                           (1 << 0)
 #define MT9M111_RESTART                         (1 << 1)
 #define MT9M111_ANALOG_STANDBY                  (1 << 2)
 #define MT9M111_CHIP_ENABLE                     (1 << 3)
@@ -97,7 +97,7 @@
 #define MT9M111_2D_DEFECT_CORRECTION_ENABLE     (1 << 0)
 
 #define INITIAL_MAX_GAIN                        64
-#define MT9M111_DEFAULT_GAIN                    283
+#define MT9M111_DEFAULT_GAIN                    283
 #define MT9M111_GREEN_GAIN_DEFAULT              0x20
 #define MT9M111_BLUE_GAIN_DEFAULT               0x20
 #define MT9M111_RED_GAIN_DEFAULT                0x20
@@ -125,8 +125,7 @@ static const struct m5602_sensor mt9m111 = {
         .start = mt9m111_start,
 };
 
-static const unsigned char preinit_mt9m111[][4] =
-{
+static const unsigned char preinit_mt9m111[][4] = {
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02, 0x00},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00, 0x00},
@@ -165,8 +164,7 @@ static const unsigned char preinit_mt9m111[][4] =
         {BRIDGE, M5602_XB_I2C_CLK_DIV, 0x0a, 0x00}
 };
 
-static const unsigned char init_mt9m111[][4] =
-{
+static const unsigned char init_mt9m111[][4] = {
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02, 0x00},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00, 0x00},
@@ -257,8 +255,7 @@ static const unsigned char init_mt9m111[][4] =
         {SENSOR, MT9M111_SC_SHUTTER_WIDTH, 0x01, 0x90},
 };
 
-static const unsigned char start_mt9m111[][4] =
-{
+static const unsigned char start_mt9m111[][4] = {
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x06, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0, 0x00},
         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0, 0x00},
@@ -271,5 +268,4 @@ static const unsigned char start_mt9m111[][4] =
         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00, 0x00},
         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00, 0x00},
 };
-
 #endif
diff --git a/drivers/media/video/gspca/m5602/m5602_ov7660.c b/drivers/media/video/gspca/m5602/m5602_ov7660.c
index 62c1cbf06666..b12f60464b3b 100644
--- a/drivers/media/video/gspca/m5602/m5602_ov7660.c
+++ b/drivers/media/video/gspca/m5602/m5602_ov7660.c
@@ -54,13 +54,13 @@ static const struct ctrl ov7660_ctrls[] = {
 #define AUTO_WHITE_BALANCE_IDX 4
         {
                 {
-                        .id             = V4L2_CID_AUTO_WHITE_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "auto white balance",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 1
+                        .id             = V4L2_CID_AUTO_WHITE_BALANCE,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto white balance",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 1
                 },
                 .set = ov7660_set_auto_white_balance,
                 .get = ov7660_get_auto_white_balance
@@ -68,13 +68,13 @@ static const struct ctrl ov7660_ctrls[] = {
 #define AUTO_GAIN_CTRL_IDX 5
         {
                 {
-                        .id             = V4L2_CID_AUTOGAIN,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "auto gain control",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 1
+                        .id             = V4L2_CID_AUTOGAIN,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto gain control",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 1
                 },
                 .set = ov7660_set_auto_gain,
                 .get = ov7660_get_auto_gain
@@ -82,13 +82,13 @@ static const struct ctrl ov7660_ctrls[] = {
 #define AUTO_EXPOSURE_IDX 6
         {
                 {
-                        .id             = V4L2_CID_EXPOSURE_AUTO,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "auto exposure",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 1
+                        .id             = V4L2_CID_EXPOSURE_AUTO,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto exposure",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 1
                 },
                 .set = ov7660_set_auto_exposure,
                 .get = ov7660_get_auto_exposure
@@ -96,13 +96,13 @@ static const struct ctrl ov7660_ctrls[] = {
 #define HFLIP_IDX 7
         {
                 {
-                        .id             = V4L2_CID_HFLIP,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "horizontal flip",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 0
+                        .id             = V4L2_CID_HFLIP,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "horizontal flip",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0
                 },
                 .set = ov7660_set_hflip,
                 .get = ov7660_get_hflip
@@ -110,13 +110,13 @@ static const struct ctrl ov7660_ctrls[] = {
 #define VFLIP_IDX 8
         {
                 {
-                        .id             = V4L2_CID_VFLIP,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "vertical flip",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 0
+                        .id             = V4L2_CID_VFLIP,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "vertical flip",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0
                 },
                 .set = ov7660_set_vflip,
                 .get = ov7660_get_vflip
diff --git a/drivers/media/video/gspca/m5602/m5602_ov7660.h b/drivers/media/video/gspca/m5602/m5602_ov7660.h
index 4d9dcf29da2e..2efd607987ec 100644
--- a/drivers/media/video/gspca/m5602/m5602_ov7660.h
+++ b/drivers/media/video/gspca/m5602/m5602_ov7660.h
@@ -80,7 +80,7 @@
 
 #define OV7660_DEFAULT_GAIN             0x0e
 #define OV7660_DEFAULT_RED_GAIN         0x80
-#define OV7660_DEFAULT_BLUE_GAIN        0x80
+#define OV7660_DEFAULT_BLUE_GAIN        0x80
 #define OV7660_DEFAULT_SATURATION       0x00
 #define OV7660_DEFAULT_EXPOSURE         0x20
 
@@ -105,8 +105,7 @@ static const struct m5602_sensor ov7660 = {
         .disconnect = ov7660_disconnect,
 };
 
-static const unsigned char preinit_ov7660[][4] =
-{
+static const unsigned char preinit_ov7660[][4] = {
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0},
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
@@ -140,8 +139,7 @@ static const unsigned char preinit_ov7660[][4] =
         {BRIDGE, M5602_XB_GPIO_EN_L, 0x00}
 };
 
-static const unsigned char init_ov7660[][4] =
-{
+static const unsigned char init_ov7660[][4] = {
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0},
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
@@ -259,5 +257,4 @@ static const unsigned char init_ov7660[][4] =
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 };
-
 #endif
diff --git a/drivers/media/video/gspca/m5602/m5602_ov9650.c b/drivers/media/video/gspca/m5602/m5602_ov9650.c
index 069ba0044f8b..703d48670a24 100644
--- a/drivers/media/video/gspca/m5602/m5602_ov9650.c
+++ b/drivers/media/video/gspca/m5602/m5602_ov9650.c
@@ -121,8 +121,8 @@ static const struct ctrl ov9650_ctrls[] = {
                         .minimum        = 0x00,
                         .maximum        = 0x1ff,
                         .step           = 0x4,
-                        .default_value  = EXPOSURE_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .default_value  = EXPOSURE_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = ov9650_set_exposure,
                 .get = ov9650_get_exposure
@@ -146,13 +146,13 @@ static const struct ctrl ov9650_ctrls[] = {
         {
                 {
                         .id             = V4L2_CID_RED_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_INTEGER,
-                        .name           = "red balance",
-                        .minimum        = 0x00,
-                        .maximum        = 0xff,
-                        .step           = 0x1,
-                        .default_value  = RED_GAIN_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "red balance",
+                        .minimum        = 0x00,
+                        .maximum        = 0xff,
+                        .step           = 0x1,
+                        .default_value  = RED_GAIN_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = ov9650_set_red_balance,
                 .get = ov9650_get_red_balance
@@ -161,13 +161,13 @@ static const struct ctrl ov9650_ctrls[] = {
         {
                 {
                         .id             = V4L2_CID_BLUE_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_INTEGER,
-                        .name           = "blue balance",
-                        .minimum        = 0x00,
-                        .maximum        = 0xff,
-                        .step           = 0x1,
-                        .default_value  = BLUE_GAIN_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "blue balance",
+                        .minimum        = 0x00,
+                        .maximum        = 0xff,
+                        .step           = 0x1,
+                        .default_value  = BLUE_GAIN_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = ov9650_set_blue_balance,
                 .get = ov9650_get_blue_balance
@@ -175,13 +175,13 @@ static const struct ctrl ov9650_ctrls[] = {
 #define HFLIP_IDX 4
         {
                 {
-                        .id             = V4L2_CID_HFLIP,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "horizontal flip",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 0
+                        .id             = V4L2_CID_HFLIP,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "horizontal flip",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0
                 },
                 .set = ov9650_set_hflip,
                 .get = ov9650_get_hflip
@@ -189,13 +189,13 @@ static const struct ctrl ov9650_ctrls[] = {
 #define VFLIP_IDX 5
         {
                 {
-                        .id             = V4L2_CID_VFLIP,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "vertical flip",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 0
+                        .id             = V4L2_CID_VFLIP,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "vertical flip",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0
                 },
                 .set = ov9650_set_vflip,
                 .get = ov9650_get_vflip
@@ -203,13 +203,13 @@ static const struct ctrl ov9650_ctrls[] = {
 #define AUTO_WHITE_BALANCE_IDX 6
         {
                 {
-                        .id             = V4L2_CID_AUTO_WHITE_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "auto white balance",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 1
+                        .id             = V4L2_CID_AUTO_WHITE_BALANCE,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto white balance",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 1
                 },
                 .set = ov9650_set_auto_white_balance,
                 .get = ov9650_get_auto_white_balance
@@ -217,13 +217,13 @@ static const struct ctrl ov9650_ctrls[] = {
 #define AUTO_GAIN_CTRL_IDX 7
         {
                 {
-                        .id             = V4L2_CID_AUTOGAIN,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "auto gain control",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 1
+                        .id             = V4L2_CID_AUTOGAIN,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto gain control",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 1
                 },
                 .set = ov9650_set_auto_gain,
                 .get = ov9650_get_auto_gain
@@ -231,13 +231,13 @@ static const struct ctrl ov9650_ctrls[] = {
 #define AUTO_EXPOSURE_IDX 8
         {
                 {
-                        .id             = V4L2_CID_EXPOSURE_AUTO,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "auto exposure",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 1
+                        .id             = V4L2_CID_EXPOSURE_AUTO,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto exposure",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 1
                 },
                 .set = ov9650_set_auto_exposure,
                 .get = ov9650_get_auto_exposure
@@ -624,7 +624,7 @@ static int ov9650_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 
         /* Mask away all uninteresting bits */
         i2c_data = ((val & 0x0300) >> 2) |
-                        (i2c_data & 0x3F);
+                        (i2c_data & 0x3f);
         err = m5602_write_sensor(sd, OV9650_VREF, &i2c_data, 1);
         if (err < 0)
                 return err;
diff --git a/drivers/media/video/gspca/m5602/m5602_ov9650.h b/drivers/media/video/gspca/m5602/m5602_ov9650.h
index c98c40d69e05..da9a129b739d 100644
--- a/drivers/media/video/gspca/m5602/m5602_ov9650.h
+++ b/drivers/media/video/gspca/m5602/m5602_ov9650.h
@@ -110,7 +110,7 @@
 
 #define OV9650_VARIOPIXEL               (1 << 2)
 #define OV9650_SYSTEM_CLK_SEL           (1 << 7)
-#define OV9650_SLAM_MODE                (1 << 4)
+#define OV9650_SLAM_MODE                (1 << 4)
 
 #define OV9650_QVGA_VARIOPIXEL          (1 << 7)
 
@@ -154,8 +154,7 @@ static const struct m5602_sensor ov9650 = {
         .disconnect = ov9650_disconnect,
 };
 
-static const unsigned char preinit_ov9650[][3] =
-{
+static const unsigned char preinit_ov9650[][3] = {
         /* [INITCAM] */
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0},
@@ -180,8 +179,7 @@ static const unsigned char preinit_ov9650[][3] =
         {SENSOR, OV9650_OFON, 0x40}
 };
 
-static const unsigned char init_ov9650[][3] =
-{
+static const unsigned char init_ov9650[][3] = {
         /* [INITCAM] */
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0},
@@ -297,8 +295,7 @@ static const unsigned char init_ov9650[][3] =
         {SENSOR, OV9650_COM2, OV9650_SOFT_SLEEP | OV9650_OUTPUT_DRIVE_2X},
 };
 
-static const unsigned char res_init_ov9650[][3] =
-{
+static const unsigned char res_init_ov9650[][3] = {
         {SENSOR, OV9650_COM2, OV9650_OUTPUT_DRIVE_2X},
 
         {BRIDGE, M5602_XB_LINE_OF_FRAME_H, 0x82},
@@ -307,5 +304,4 @@ static const unsigned char res_init_ov9650[][3] =
         {BRIDGE, M5602_XB_PIX_OF_LINE_L, 0x00},
         {BRIDGE, M5602_XB_SIG_INI, 0x01}
 };
-
 #endif
diff --git a/drivers/media/video/gspca/m5602/m5602_po1030.c b/drivers/media/video/gspca/m5602/m5602_po1030.c
index 925b87d66f40..1febd34c2f05 100644
--- a/drivers/media/video/gspca/m5602/m5602_po1030.c
+++ b/drivers/media/video/gspca/m5602/m5602_po1030.c
@@ -58,14 +58,14 @@ static const struct ctrl po1030_ctrls[] = {
 #define GAIN_IDX 0
         {
                 {
-                        .id             = V4L2_CID_GAIN,
-                        .type           = V4L2_CTRL_TYPE_INTEGER,
-                        .name           = "gain",
-                        .minimum        = 0x00,
-                        .maximum        = 0x4f,
-                        .step           = 0x1,
-                        .default_value  = PO1030_GLOBAL_GAIN_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .id             = V4L2_CID_GAIN,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "gain",
+                        .minimum        = 0x00,
+                        .maximum        = 0x4f,
+                        .step           = 0x1,
+                        .default_value  = PO1030_GLOBAL_GAIN_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = po1030_set_gain,
                 .get = po1030_get_gain
@@ -73,14 +73,14 @@ static const struct ctrl po1030_ctrls[] = {
 #define EXPOSURE_IDX 1
         {
                 {
-                        .id             = V4L2_CID_EXPOSURE,
-                        .type           = V4L2_CTRL_TYPE_INTEGER,
-                        .name           = "exposure",
-                        .minimum        = 0x00,
-                        .maximum        = 0x02ff,
-                        .step           = 0x1,
-                        .default_value  = PO1030_EXPOSURE_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .id             = V4L2_CID_EXPOSURE,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "exposure",
+                        .minimum        = 0x00,
+                        .maximum        = 0x02ff,
+                        .step           = 0x1,
+                        .default_value  = PO1030_EXPOSURE_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = po1030_set_exposure,
                 .get = po1030_get_exposure
@@ -88,14 +88,14 @@ static const struct ctrl po1030_ctrls[] = {
 #define RED_BALANCE_IDX 2
         {
                 {
-                        .id             = V4L2_CID_RED_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_INTEGER,
-                        .name           = "red balance",
-                        .minimum        = 0x00,
-                        .maximum        = 0xff,
-                        .step           = 0x1,
-                        .default_value  = PO1030_RED_GAIN_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .id             = V4L2_CID_RED_BALANCE,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "red balance",
+                        .minimum        = 0x00,
+                        .maximum        = 0xff,
+                        .step           = 0x1,
+                        .default_value  = PO1030_RED_GAIN_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = po1030_set_red_balance,
                 .get = po1030_get_red_balance
@@ -103,14 +103,14 @@ static const struct ctrl po1030_ctrls[] = {
 #define BLUE_BALANCE_IDX 3
         {
                 {
-                        .id             = V4L2_CID_BLUE_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_INTEGER,
-                        .name           = "blue balance",
-                        .minimum        = 0x00,
-                        .maximum        = 0xff,
-                        .step           = 0x1,
-                        .default_value  = PO1030_BLUE_GAIN_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .id             = V4L2_CID_BLUE_BALANCE,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "blue balance",
+                        .minimum        = 0x00,
+                        .maximum        = 0xff,
+                        .step           = 0x1,
+                        .default_value  = PO1030_BLUE_GAIN_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = po1030_set_blue_balance,
                 .get = po1030_get_blue_balance
@@ -118,13 +118,13 @@ static const struct ctrl po1030_ctrls[] = {
 #define HFLIP_IDX 4
         {
                 {
-                        .id             = V4L2_CID_HFLIP,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "horizontal flip",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 0,
+                        .id             = V4L2_CID_HFLIP,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "horizontal flip",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0,
                 },
                 .set = po1030_set_hflip,
                 .get = po1030_get_hflip
@@ -132,13 +132,13 @@ static const struct ctrl po1030_ctrls[] = {
 #define VFLIP_IDX 5
         {
                 {
-                        .id             = V4L2_CID_VFLIP,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "vertical flip",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 0,
+                        .id             = V4L2_CID_VFLIP,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "vertical flip",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0,
                 },
                 .set = po1030_set_vflip,
                 .get = po1030_get_vflip
@@ -146,13 +146,13 @@ static const struct ctrl po1030_ctrls[] = {
 #define AUTO_WHITE_BALANCE_IDX 6
         {
                 {
-                        .id             = V4L2_CID_AUTO_WHITE_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "auto white balance",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 0,
+                        .id             = V4L2_CID_AUTO_WHITE_BALANCE,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto white balance",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0,
                 },
                 .set = po1030_set_auto_white_balance,
                 .get = po1030_get_auto_white_balance
@@ -160,13 +160,13 @@ static const struct ctrl po1030_ctrls[] = {
 #define AUTO_EXPOSURE_IDX 7
         {
                 {
-                        .id             = V4L2_CID_EXPOSURE_AUTO,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "auto exposure",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 0,
+                        .id             = V4L2_CID_EXPOSURE_AUTO,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto exposure",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0,
                 },
                 .set = po1030_set_auto_exposure,
                 .get = po1030_get_auto_exposure
@@ -174,14 +174,14 @@ static const struct ctrl po1030_ctrls[] = {
 #define GREEN_BALANCE_IDX 8
         {
                 {
-                        .id             = M5602_V4L2_CID_GREEN_BALANCE,
-                        .type           = V4L2_CTRL_TYPE_INTEGER,
-                        .name           = "green balance",
-                        .minimum        = 0x00,
-                        .maximum        = 0xff,
-                        .step           = 0x1,
-                        .default_value  = PO1030_GREEN_GAIN_DEFAULT,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .id             = M5602_V4L2_CID_GREEN_BALANCE,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "green balance",
+                        .minimum        = 0x00,
+                        .maximum        = 0xff,
+                        .step           = 0x1,
+                        .default_value  = PO1030_GREEN_GAIN_DEFAULT,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = po1030_set_green_balance,
                 .get = po1030_get_green_balance
diff --git a/drivers/media/video/gspca/m5602/m5602_po1030.h b/drivers/media/video/gspca/m5602/m5602_po1030.h
index 1ea380b2bbe7..338359596398 100644
--- a/drivers/media/video/gspca/m5602/m5602_po1030.h
+++ b/drivers/media/video/gspca/m5602/m5602_po1030.h
@@ -139,9 +139,9 @@
 
 #define PO1030_GLOBAL_GAIN_DEFAULT      0x12
 #define PO1030_EXPOSURE_DEFAULT         0x0085
-#define PO1030_BLUE_GAIN_DEFAULT        0x36
-#define PO1030_RED_GAIN_DEFAULT         0x36
-#define PO1030_GREEN_GAIN_DEFAULT       0x40
+#define PO1030_BLUE_GAIN_DEFAULT        0x36
+#define PO1030_RED_GAIN_DEFAULT         0x36
+#define PO1030_GREEN_GAIN_DEFAULT       0x40
 
 /*****************************************************************************/
 
@@ -166,8 +166,7 @@ static const struct m5602_sensor po1030 = {
         .disconnect = po1030_disconnect,
 };
 
-static const unsigned char preinit_po1030[][3] =
-{
+static const unsigned char preinit_po1030[][3] = {
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0},
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
@@ -193,8 +192,7 @@ static const unsigned char preinit_po1030[][3] =
         {BRIDGE, M5602_XB_GPIO_DAT, 0x00}
 };
 
-static const unsigned char init_po1030[][3] =
-{
+static const unsigned char init_po1030[][3] = {
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0},
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
@@ -271,5 +269,4 @@ static const unsigned char init_po1030[][3] =
         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
         {BRIDGE, M5602_XB_GPIO_EN_L, 0x00},
 };
-
 #endif
diff --git a/drivers/media/video/gspca/m5602/m5602_s5k4aa.c b/drivers/media/video/gspca/m5602/m5602_s5k4aa.c
index da0a38c78708..d27280be9852 100644
--- a/drivers/media/video/gspca/m5602/m5602_s5k4aa.c
+++ b/drivers/media/video/gspca/m5602/m5602_s5k4aa.c
@@ -143,13 +143,13 @@ static const struct ctrl s5k4aa_ctrls[] = {
 #define VFLIP_IDX 0
         {
                 {
-                        .id             = V4L2_CID_VFLIP,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "vertical flip",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 0
+                        .id             = V4L2_CID_VFLIP,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "vertical flip",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0
                 },
                 .set = s5k4aa_set_vflip,
                 .get = s5k4aa_get_vflip
@@ -157,13 +157,13 @@ static const struct ctrl s5k4aa_ctrls[] = {
 #define HFLIP_IDX 1
         {
                 {
-                        .id             = V4L2_CID_HFLIP,
-                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name           = "horizontal flip",
-                        .minimum        = 0,
-                        .maximum        = 1,
-                        .step           = 1,
-                        .default_value  = 0
+                        .id             = V4L2_CID_HFLIP,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "horizontal flip",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0
                 },
                 .set = s5k4aa_set_hflip,
                 .get = s5k4aa_get_hflip
diff --git a/drivers/media/video/gspca/m5602/m5602_s5k4aa.h b/drivers/media/video/gspca/m5602/m5602_s5k4aa.h
index 4440da4e7f0f..8cc7a3f6da72 100644
--- a/drivers/media/video/gspca/m5602/m5602_s5k4aa.h
+++ b/drivers/media/video/gspca/m5602/m5602_s5k4aa.h
@@ -83,8 +83,7 @@ static const struct m5602_sensor s5k4aa = {
         .disconnect = s5k4aa_disconnect,
 };
 
-static const unsigned char preinit_s5k4aa[][4] =
-{
+static const unsigned char preinit_s5k4aa[][4] = {
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02, 0x00},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00, 0x00},
@@ -127,8 +126,7 @@ static const unsigned char preinit_s5k4aa[][4] =
         {SENSOR, S5K4AA_PAGE_MAP, 0x00, 0x00}
 };
 
-static const unsigned char init_s5k4aa[][4] =
-{
+static const unsigned char init_s5k4aa[][4] = {
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02, 0x00},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00, 0x00},
@@ -179,8 +177,7 @@ static const unsigned char init_s5k4aa[][4] =
         {SENSOR, 0x37, 0x00, 0x00},
 };
 
-static const unsigned char VGA_s5k4aa[][4] =
-{
+static const unsigned char VGA_s5k4aa[][4] = {
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x06, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0, 0x00},
         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0, 0x00},
@@ -235,8 +232,7 @@ static const unsigned char VGA_s5k4aa[][4] =
         {SENSOR, 0x02, 0x0e, 0x00},
 };
 
-static const unsigned char SXGA_s5k4aa[][4] =
-{
+static const unsigned char SXGA_s5k4aa[][4] = {
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x06, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0, 0x00},
         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0, 0x00},
@@ -284,6 +280,4 @@ static const unsigned char SXGA_s5k4aa[][4] =
         {SENSOR, S5K4AA_PAGE_MAP, 0x02, 0x00},
         {SENSOR, 0x02, 0x0e, 0x00},
 };
-
-
 #endif
diff --git a/drivers/media/video/gspca/m5602/m5602_s5k83a.h b/drivers/media/video/gspca/m5602/m5602_s5k83a.h
index 7814b078acde..80a63a236e24 100644
--- a/drivers/media/video/gspca/m5602/m5602_s5k83a.h
+++ b/drivers/media/video/gspca/m5602/m5602_s5k83a.h
@@ -35,7 +35,7 @@
 #define S5K83A_MAXIMUM_EXPOSURE         0x3c
 #define S5K83A_FLIP_MASK                0x10
 #define S5K83A_GPIO_LED_MASK            0x10
-#define S5K83A_GPIO_ROTATION_MASK       0x40
+#define S5K83A_GPIO_ROTATION_MASK       0x40
 
 /*****************************************************************************/
 
@@ -67,8 +67,7 @@ struct s5k83a_priv {
         s32 *settings;
 };
 
-static const unsigned char preinit_s5k83a[][4] =
-{
+static const unsigned char preinit_s5k83a[][4] = {
         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02, 0x00},
         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00, 0x00},
@@ -108,8 +107,7 @@ static const unsigned char preinit_s5k83a[][4] =
 /* This could probably be considerably shortened.
    I don't have the hardware to experiment with it, patches welcome
 */
-static const unsigned char init_s5k83a[][4] =
-{
+static const unsigned char init_s5k83a[][4] = {
         /* The following sequence is useless after a clean boot
            but is necessary after resume from suspend */
         {BRIDGE, M5602_XB_GPIO_DIR, 0x1d, 0x00},
@@ -166,8 +164,7 @@ static const unsigned char init_s5k83a[][4] =
         {SENSOR, 0x00, 0x06, 0x00},
 };
 
-static const unsigned char start_s5k83a[][4] =
-{
+static const unsigned char start_s5k83a[][4] = {
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x06, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0, 0x00},
         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0, 0x00},
@@ -193,5 +190,4 @@ static const unsigned char start_s5k83a[][4] =
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0, 0x00},
 };
-
 #endif
diff --git a/drivers/media/video/gspca/mars.c b/drivers/media/video/gspca/mars.c
index 031f7195ce0d..0196209a948a 100644
--- a/drivers/media/video/gspca/mars.c
+++ b/drivers/media/video/gspca/mars.c
@@ -28,14 +28,23 @@ MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
 MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver");
 MODULE_LICENSE("GPL");
 
+/* controls */
+enum e_ctrl {
+        BRIGHTNESS,
+        COLORS,
+        GAMMA,
+        SHARPNESS,
+        ILLUM_TOP,
+        ILLUM_BOT,
+        NCTRLS          /* number of controls */
+};
+
 /* specific webcam descriptor */
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
 
-        u8 brightness;
-        u8 colors;
-        u8 gamma;
-        u8 sharpness;
+        struct gspca_ctrl ctrls[NCTRLS];
+
         u8 quality;
 #define QUALITY_MIN 40
 #define QUALITY_MAX 70
@@ -45,17 +54,15 @@ 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_setcolors(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
-static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
-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 const struct ctrl sd_ctrls[] = {
-        {
+static void setbrightness(struct gspca_dev *gspca_dev);
+static void setcolors(struct gspca_dev *gspca_dev);
+static void setgamma(struct gspca_dev *gspca_dev);
+static void setsharpness(struct gspca_dev *gspca_dev);
+static int sd_setilluminator1(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_setilluminator2(struct gspca_dev *gspca_dev, __s32 val);
+
+static const struct ctrl sd_ctrls[NCTRLS] = {
+[BRIGHTNESS] = {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -63,13 +70,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 30,
                 .step    = 1,
-#define BRIGHTNESS_DEF 15
-                .default_value = BRIGHTNESS_DEF,
+                .default_value = 15,
             },
-            .set = sd_setbrightness,
-            .get = sd_getbrightness,
+            .set_control = setbrightness
         },
-        {
+[COLORS] = {
             {
                 .id      = V4L2_CID_SATURATION,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -77,13 +82,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 1,
                 .maximum = 255,
                 .step    = 1,
-#define COLOR_DEF 200
-                .default_value = COLOR_DEF,
+                .default_value = 200,
             },
-            .set = sd_setcolors,
-            .get = sd_getcolors,
+            .set_control = setcolors
         },
-        {
+[GAMMA] = {
             {
                 .id      = V4L2_CID_GAMMA,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -91,13 +94,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 3,
                 .step    = 1,
-#define GAMMA_DEF 1
-                .default_value = GAMMA_DEF,
+                .default_value = 1,
             },
-            .set = sd_setgamma,
-            .get = sd_getgamma,
+            .set_control = setgamma
         },
-        {
+[SHARPNESS] = {
             {
                 .id      = V4L2_CID_SHARPNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -105,11 +106,35 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 2,
                 .step    = 1,
-#define SHARPNESS_DEF 1
-                .default_value = SHARPNESS_DEF,
+                .default_value = 1,
+            },
+            .set_control = setsharpness
+        },
+[ILLUM_TOP] = {
+            {
+                .id      = V4L2_CID_ILLUMINATORS_1,
+                .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                .name    = "Top illuminator",
+                .minimum = 0,
+                .maximum = 1,
+                .step    = 1,
+                .default_value = 0,
+                .flags = V4L2_CTRL_FLAG_UPDATE,
+            },
+            .set = sd_setilluminator1
+        },
+[ILLUM_BOT] = {
+            {
+                .id      = V4L2_CID_ILLUMINATORS_2,
+                .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                .name    = "Bottom illuminator",
+                .minimum = 0,
+                .maximum = 1,
+                .step    = 1,
+                .default_value = 0,
+                .flags = V4L2_CTRL_FLAG_UPDATE,
             },
-            .set = sd_setsharpness,
-            .get = sd_getsharpness,
+            .set = sd_setilluminator2
         },
 };
 
@@ -138,21 +163,25 @@ static const __u8 mi_data[0x20] = {
 };
 
 /* write <len> bytes from gspca_dev->usb_buf */
-static int reg_w(struct gspca_dev *gspca_dev,
+static void reg_w(struct gspca_dev *gspca_dev,
                  int len)
 {
         int alen, ret;
 
+        if (gspca_dev->usb_err < 0)
+                return;
+
         ret = usb_bulk_msg(gspca_dev->dev,
                         usb_sndbulkpipe(gspca_dev->dev, 4),
                         gspca_dev->usb_buf,
                         len,
                         &alen,
                         500);   /* timeout in milliseconds */
-        if (ret < 0)
-                PDEBUG(D_ERR, "reg write [%02x] error %d",
+        if (ret < 0) {
+                err("reg write [%02x] error %d",
                         gspca_dev->usb_buf[0], ret);
-        return ret;
+                gspca_dev->usb_err = ret;
+        }
 }
 
 static void mi_w(struct gspca_dev *gspca_dev,
@@ -167,6 +196,59 @@ static void mi_w(struct gspca_dev *gspca_dev,
         reg_w(gspca_dev, 4);
 }
 
+static void setbrightness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        gspca_dev->usb_buf[0] = 0x61;
+        gspca_dev->usb_buf[1] = sd->ctrls[BRIGHTNESS].val;
+        reg_w(gspca_dev, 2);
+}
+
+static void setcolors(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s16 val;
+
+        val = sd->ctrls[COLORS].val;
+        gspca_dev->usb_buf[0] = 0x5f;
+        gspca_dev->usb_buf[1] = val << 3;
+        gspca_dev->usb_buf[2] = ((val >> 2) & 0xf8) | 0x04;
+        reg_w(gspca_dev, 3);
+}
+
+static void setgamma(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        gspca_dev->usb_buf[0] = 0x06;
+        gspca_dev->usb_buf[1] = sd->ctrls[GAMMA].val * 0x40;
+        reg_w(gspca_dev, 2);
+}
+
+static void setsharpness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        gspca_dev->usb_buf[0] = 0x67;
+        gspca_dev->usb_buf[1] = sd->ctrls[SHARPNESS].val * 4 + 3;
+        reg_w(gspca_dev, 2);
+}
+
+static void setilluminators(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        gspca_dev->usb_buf[0] = 0x22;
+        if (sd->ctrls[ILLUM_TOP].val)
+                gspca_dev->usb_buf[1] = 0x76;
+        else if (sd->ctrls[ILLUM_BOT].val)
+                gspca_dev->usb_buf[1] = 0x7a;
+        else
+                gspca_dev->usb_buf[1] = 0x7e;
+        reg_w(gspca_dev, 2);
+}
+
 /* this function is called at probe time */
 static int sd_config(struct gspca_dev *gspca_dev,
                         const struct usb_device_id *id)
@@ -177,10 +259,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
         cam = &gspca_dev->cam;
         cam->cam_mode = vga_mode;
         cam->nmodes = ARRAY_SIZE(vga_mode);
-        sd->brightness = BRIGHTNESS_DEF;
-        sd->colors = COLOR_DEF;
-        sd->gamma = GAMMA_DEF;
-        sd->sharpness = SHARPNESS_DEF;
+        cam->ctrls = sd->ctrls;
         sd->quality = QUALITY_DEF;
         gspca_dev->nbalt = 9;           /* use the altsetting 08 */
         return 0;
@@ -189,13 +268,13 @@ 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)
 {
+        gspca_dev->ctrl_inac = (1 << ILLUM_TOP) | (1 << ILLUM_BOT);
         return 0;
 }
 
 static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int err_code;
         u8 *data;
         int i;
 
@@ -208,9 +287,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
 
         data[0] = 0x01;         /* address */
         data[1] = 0x01;
-        err_code = reg_w(gspca_dev, 2);
-        if (err_code < 0)
-                return err_code;
+        reg_w(gspca_dev, 2);
 
         /*
            Initialize the MR97113 chip register
@@ -223,7 +300,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
         data[5] = 0x30;         /* reg 4, MI, PAS5101 :
                                  *      0x30 for 24mhz , 0x28 for 12mhz */
         data[6] = 0x02;         /* reg 5, H start - was 0x04 */
-        data[7] = sd->gamma * 0x40;     /* reg 0x06: gamma */
+        data[7] = sd->ctrls[GAMMA].val * 0x40;  /* reg 0x06: gamma */
         data[8] = 0x01;         /* reg 7, V start - was 0x03 */
 /*      if (h_size == 320 ) */
 /*              data[9]= 0x56;   * reg 8, 24MHz, 2:1 scale down */
@@ -232,16 +309,12 @@ static int sd_start(struct gspca_dev *gspca_dev)
 /*jfm: from win trace*/
         data[10] = 0x18;
 
-        err_code = reg_w(gspca_dev, 11);
-        if (err_code < 0)
-                return err_code;
+        reg_w(gspca_dev, 11);
 
         data[0] = 0x23;         /* address */
         data[1] = 0x09;         /* reg 35, append frame header */
 
-        err_code = reg_w(gspca_dev, 2);
-        if (err_code < 0)
-                return err_code;
+        reg_w(gspca_dev, 2);
 
         data[0] = 0x3c;         /* address */
 /*      if (gspca_dev->width == 1280) */
@@ -250,9 +323,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
 /*      else */
         data[1] = 50;           /* 50 reg 60, pc-cam frame size
                                  *      (unit: 4KB) 200KB */
-        err_code = reg_w(gspca_dev, 2);
-        if (err_code < 0)
-                return err_code;
+        reg_w(gspca_dev, 2);
 
         /* auto dark-gain */
         data[0] = 0x5e;         /* address */
@@ -261,57 +332,57 @@ static int sd_start(struct gspca_dev *gspca_dev)
                                 /* reg 0x5f/0x60 (LE) = saturation */
                                 /* h (60): xxxx x100
                                  * l (5f): xxxx x000 */
-        data[2] = sd->colors << 3;
-        data[3] = ((sd->colors >> 2) & 0xf8) | 0x04;
-        data[4] = sd->brightness; /* reg 0x61 = brightness */
+        data[2] = sd->ctrls[COLORS].val << 3;
+        data[3] = ((sd->ctrls[COLORS].val >> 2) & 0xf8) | 0x04;
+        data[4] = sd->ctrls[BRIGHTNESS].val; /* reg 0x61 = brightness */
         data[5] = 0x00;
 
-        err_code = reg_w(gspca_dev, 6);
-        if (err_code < 0)
-                return err_code;
+        reg_w(gspca_dev, 6);
 
         data[0] = 0x67;
 /*jfm: from win trace*/
-        data[1] = sd->sharpness * 4 + 3;
+        data[1] = sd->ctrls[SHARPNESS].val * 4 + 3;
         data[2] = 0x14;
-        err_code = reg_w(gspca_dev, 3);
-        if (err_code < 0)
-                return err_code;
+        reg_w(gspca_dev, 3);
 
         data[0] = 0x69;
         data[1] = 0x2f;
         data[2] = 0x28;
         data[3] = 0x42;
-        err_code = reg_w(gspca_dev, 4);
-        if (err_code < 0)
-                return err_code;
+        reg_w(gspca_dev, 4);
 
         data[0] = 0x63;
         data[1] = 0x07;
-        err_code = reg_w(gspca_dev, 2);
+        reg_w(gspca_dev, 2);
 /*jfm: win trace - many writes here to reg 0x64*/
-        if (err_code < 0)
-                return err_code;
 
         /* initialize the MI sensor */
         for (i = 0; i < sizeof mi_data; i++)
                 mi_w(gspca_dev, i + 1, mi_data[i]);
 
         data[0] = 0x00;
-        data[1] = 0x4d;         /* ISOC transfering enable... */
+        data[1] = 0x4d;         /* ISOC transferring enable... */
         reg_w(gspca_dev, 2);
-        return 0;
+
+        gspca_dev->ctrl_inac = 0; /* activate the illuminator controls */
+        return gspca_dev->usb_err;
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
-        int result;
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        gspca_dev->ctrl_inac = (1 << ILLUM_TOP) | (1 << ILLUM_BOT);
+        if (sd->ctrls[ILLUM_TOP].val || sd->ctrls[ILLUM_BOT].val) {
+                sd->ctrls[ILLUM_TOP].val = 0;
+                sd->ctrls[ILLUM_BOT].val = 0;
+                setilluminators(gspca_dev);
+                msleep(20);
+        }
 
         gspca_dev->usb_buf[0] = 1;
         gspca_dev->usb_buf[1] = 0;
-        result = reg_w(gspca_dev, 2);
-        if (result < 0)
-                PDEBUG(D_ERR, "Camera Stop failed");
+        reg_w(gspca_dev, 2);
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
@@ -352,91 +423,28 @@ 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) {
-                gspca_dev->usb_buf[0] = 0x61;
-                gspca_dev->usb_buf[1] = val;
-                reg_w(gspca_dev, 2);
-        }
-        return 0;
-}
-
-static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
+static int sd_setilluminator1(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        *val = sd->brightness;
-        return 0;
+        /* only one illuminator may be on */
+        sd->ctrls[ILLUM_TOP].val = val;
+        if (val)
+                sd->ctrls[ILLUM_BOT].val = 0;
+        setilluminators(gspca_dev);
+        return gspca_dev->usb_err;
 }
 
-static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
+static int sd_setilluminator2(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        sd->colors = val;
-        if (gspca_dev->streaming) {
-
-                /* see sd_start */
-                gspca_dev->usb_buf[0] = 0x5f;
-                gspca_dev->usb_buf[1] = sd->colors << 3;
-                gspca_dev->usb_buf[2] = ((sd->colors >> 2) & 0xf8) | 0x04;
-                reg_w(gspca_dev, 3);
-        }
-        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_setgamma(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->gamma = val;
-        if (gspca_dev->streaming) {
-                gspca_dev->usb_buf[0] = 0x06;
-                gspca_dev->usb_buf[1] = val * 0x40;
-                reg_w(gspca_dev, 2);
-        }
-        return 0;
-}
-
-static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->gamma;
-        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) {
-                gspca_dev->usb_buf[0] = 0x67;
-                gspca_dev->usb_buf[1] = val * 4 + 3;
-                reg_w(gspca_dev, 2);
-        }
-        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;
+        /* only one illuminator may be on */
+        sd->ctrls[ILLUM_BOT].val = val;
+        if (val)
+                sd->ctrls[ILLUM_TOP].val = 0;
+        setilluminators(gspca_dev);
+        return gspca_dev->usb_err;
 }
 
 static int sd_set_jcomp(struct gspca_dev *gspca_dev,
@@ -471,7 +479,7 @@ static int sd_get_jcomp(struct gspca_dev *gspca_dev,
 static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
         .ctrls = sd_ctrls,
-        .nctrls = ARRAY_SIZE(sd_ctrls),
+        .nctrls = NCTRLS,
         .config = sd_config,
         .init = sd_init,
         .start = sd_start,
@@ -482,7 +490,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x093a, 0x050f)},
         {}
 };
@@ -510,18 +518,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/mr97310a.c b/drivers/media/video/gspca/mr97310a.c
index 33744e724eaa..97e507967434 100644
--- a/drivers/media/video/gspca/mr97310a.c
+++ b/drivers/media/video/gspca/mr97310a.c
@@ -9,14 +9,14 @@
  * is Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
  *
  * Support for the control settings for the CIF cameras is
- * Copyright (C) 2009 Hans de Goede <hdgoede@redhat.com> and
+ * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com> and
  * Thomas Kaiser <thomas@kaiser-linux.li>
  *
  * Support for the control settings for the VGA cameras is
  * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
  *
  * Several previously unsupported cameras are owned and have been tested by
- * Hans de Goede <hdgoede@redhat.com> and
+ * Hans de Goede <hdegoede@redhat.com> and
  * Thomas Kaiser <thomas@kaiser-linux.li> and
  * Theodore Kilgore <kilgota@auburn.edu> and
  * Edmond Rodriguez <erodrig_97@yahoo.com> and
@@ -267,7 +267,7 @@ static int mr_write(struct gspca_dev *gspca_dev, int len)
                           usb_sndbulkpipe(gspca_dev->dev, 4),
                           gspca_dev->usb_buf, len, NULL, 500);
         if (rc < 0)
-                PDEBUG(D_ERR, "reg write [%02x] error %d",
+                err("reg write [%02x] error %d",
                        gspca_dev->usb_buf[0], rc);
         return rc;
 }
@@ -281,7 +281,7 @@ static int mr_read(struct gspca_dev *gspca_dev, int len)
                           usb_rcvbulkpipe(gspca_dev->dev, 3),
                           gspca_dev->usb_buf, len, NULL, 500);
         if (rc < 0)
-                PDEBUG(D_ERR, "reg read [%02x] error %d",
+                err("reg read [%02x] error %d",
                        gspca_dev->usb_buf[0], rc);
         return rc;
 }
@@ -469,7 +469,7 @@ static void lcd_stop(struct gspca_dev *gspca_dev)
 static int isoc_enable(struct gspca_dev *gspca_dev)
 {
         gspca_dev->usb_buf[0] = 0x00;
-        gspca_dev->usb_buf[1] = 0x4d;  /* ISOC transfering enable... */
+        gspca_dev->usb_buf[1] = 0x4d;  /* ISOC transferring enable... */
         return mr_write(gspca_dev, 2);
 }
 
@@ -540,7 +540,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
                         sd->sensor_type = 1;
                         break;
                 default:
-                        PDEBUG(D_ERR, "Unknown CIF Sensor id : %02x",
+                        err("Unknown CIF Sensor id : %02x",
                                gspca_dev->usb_buf[1]);
                         return -ENODEV;
                 }
@@ -575,10 +575,10 @@ static int sd_config(struct gspca_dev *gspca_dev,
                         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",
+                        err("Unknown VGA Sensor id Byte 0: %02x",
                                         gspca_dev->usb_buf[0]);
-                        PDEBUG(D_ERR, "Defaults assumed, may not work");
-                        PDEBUG(D_ERR, "Please report this");
+                        err("Defaults assumed, may not work");
+                        err("Please report this");
                 }
                 /* Sakar Digital color needs to be adjusted. */
                 if ((gspca_dev->usb_buf[0] == 0x03) &&
@@ -595,12 +595,10 @@ static int sd_config(struct gspca_dev *gspca_dev,
                                 /* Nothing to do here. */
                                 break;
                         default:
-                                PDEBUG(D_ERR,
-                                        "Unknown VGA Sensor id Byte 1: %02x",
+                                err("Unknown VGA Sensor id Byte 1: %02x",
                                         gspca_dev->usb_buf[1]);
-                                PDEBUG(D_ERR,
-                                        "Defaults assumed, may not work");
-                                PDEBUG(D_ERR, "Please report this");
+                                err("Defaults assumed, may not work");
+                                err("Please report this");
                         }
                 }
                 PDEBUG(D_PROBE, "MR97310A VGA camera detected, sensor: %d",
@@ -675,7 +673,7 @@ static int start_cif_cam(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         __u8 *data = gspca_dev->usb_buf;
         int err_code;
-        const __u8 startup_string[] = {
+        static const __u8 startup_string[] = {
                 0x00,
                 0x0d,
                 0x01,
@@ -721,7 +719,7 @@ static int start_cif_cam(struct gspca_dev *gspca_dev)
                 return err_code;
 
         if (!sd->sensor_type) {
-                const struct sensor_w_data cif_sensor0_init_data[] = {
+                static const struct sensor_w_data cif_sensor0_init_data[] = {
                         {0x02, 0x00, {0x03, 0x5a, 0xb5, 0x01,
                                       0x0f, 0x14, 0x0f, 0x10}, 8},
                         {0x0c, 0x00, {0x04, 0x01, 0x01, 0x00, 0x1f}, 5},
@@ -742,7 +740,7 @@ static int start_cif_cam(struct gspca_dev *gspca_dev)
                 err_code = sensor_write_regs(gspca_dev, cif_sensor0_init_data,
                                          ARRAY_SIZE(cif_sensor0_init_data));
         } else {        /* sd->sensor_type = 1 */
-                const struct sensor_w_data cif_sensor1_init_data[] = {
+                static const struct sensor_w_data cif_sensor1_init_data[] = {
                         /* Reg 3,4, 7,8 get set by the controls */
                         {0x02, 0x00, {0x10}, 1},
                         {0x05, 0x01, {0x22}, 1}, /* 5/6 also seen as 65h/32h */
@@ -777,8 +775,9 @@ static int start_vga_cam(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         __u8 *data = gspca_dev->usb_buf;
         int err_code;
-        const __u8 startup_string[] = {0x00, 0x0d, 0x01, 0x00, 0x00, 0x2b,
-                                       0x00, 0x00, 0x00, 0x50, 0xc0};
+        static const __u8 startup_string[] =
+                {0x00, 0x0d, 0x01, 0x00, 0x00, 0x2b, 0x00, 0x00,
+                 0x00, 0x50, 0xc0};
         /* What some of these mean is explained in start_cif_cam(), above */
 
         memcpy(data, startup_string, 11);
@@ -830,7 +829,7 @@ static int start_vga_cam(struct gspca_dev *gspca_dev)
                 return err_code;
 
         if (!sd->sensor_type) {
-                const struct sensor_w_data vga_sensor0_init_data[] = {
+                static const struct sensor_w_data vga_sensor0_init_data[] = {
                         {0x01, 0x00, {0x0c, 0x00, 0x04}, 3},
                         {0x14, 0x00, {0x01, 0xe4, 0x02, 0x84}, 4},
                         {0x20, 0x00, {0x00, 0x80, 0x00, 0x08}, 4},
@@ -841,20 +840,20 @@ 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 if (sd->sensor_type == 1) {
-                const struct sensor_w_data color_adj[] = {
+                static const struct sensor_w_data color_adj[] = {
                         {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
                                 /* adjusted blue, green, red gain correct
                                    too much blue from the Sakar Digital */
                                 0x05, 0x01, 0x04}, 8}
                 };
 
-                const struct sensor_w_data color_no_adj[] = {
+                static const struct sensor_w_data color_no_adj[] = {
                         {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
                                 /* default blue, green, red gain settings */
                                 0x07, 0x00, 0x01}, 8}
                 };
 
-                const struct sensor_w_data vga_sensor1_init_data[] = {
+                static const struct sensor_w_data vga_sensor1_init_data[] = {
                         {0x11, 0x04, {0x01}, 1},
                         {0x0a, 0x00, {0x00, 0x01, 0x00, 0x00, 0x01,
                         /* These settings may be better for some cameras */
@@ -879,7 +878,7 @@ 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[] = {
+                static const struct sensor_w_data vga_sensor2_init_data[] = {
 
                         {0x01, 0x00, {0x48}, 1},
                         {0x02, 0x00, {0x22}, 1},
@@ -976,7 +975,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
         u8 val;
         u8 sign_reg = 7;  /* This reg and the next one used on CIF cams. */
         u8 value_reg = 8; /* VGA cams seem to use regs 0x0b and 0x0c */
-        const u8 quick_clix_table[] =
+        static const u8 quick_clix_table[] =
         /*        0  1  2   3  4  5  6  7  8  9  10  11  12  13  14  15 */
                 { 0, 4, 8, 12, 1, 2, 3, 5, 6, 9,  7, 10, 13, 11, 14, 15};
         /*
@@ -1230,7 +1229,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x08ca, 0x0110)},   /* Trust Spyc@m 100 */
         {USB_DEVICE(0x08ca, 0x0111)},   /* Aiptek Pencam VGA+ */
         {USB_DEVICE(0x093a, 0x010f)},   /* All other known MR97310A VGA cams */
@@ -1261,18 +1260,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/nw80x.c b/drivers/media/video/gspca/nw80x.c
new file mode 100644
index 000000000000..8e754fd4dc5e
--- /dev/null
+++ b/drivers/media/video/gspca/nw80x.c
@@ -0,0 +1,2145 @@
+/*
+ * DivIO nw80x subdriver
+ *
+ * Copyright (C) 2011 Jean-François Moine (http://moinejf.free.fr)
+ * Copyright (C) 2003 Sylvain Munaut <tnt@246tNt.com>
+ *                      Kjell Claesson <keyson@users.sourceforge.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
+ * 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 "nw80x"
+
+#include "gspca.h"
+
+MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
+MODULE_DESCRIPTION("NW80x USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+static int webcam;
+
+/* controls */
+enum e_ctrl {
+        GAIN,
+        EXPOSURE,
+        AUTOGAIN,
+        NCTRLS          /* number of controls */
+};
+
+#define AUTOGAIN_DEF 1
+
+/* specific webcam descriptor */
+struct sd {
+        struct gspca_dev gspca_dev;     /* !! must be the first item */
+
+        struct gspca_ctrl ctrls[NCTRLS];
+
+        u32 ae_res;
+        s8 ag_cnt;
+#define AG_CNT_START 13
+        u8 exp_too_low_cnt;
+        u8 exp_too_high_cnt;
+
+        u8 bridge;
+        u8 webcam;
+};
+
+enum bridges {
+        BRIDGE_NW800,   /* and et31x110 */
+        BRIDGE_NW801,
+        BRIDGE_NW802,
+};
+enum webcams {
+        Generic800,
+        SpaceCam,       /* Trust 120 SpaceCam */
+        SpaceCam2,      /* other Trust 120 SpaceCam */
+        Cvideopro,      /* Conceptronic Video Pro */
+        Dlink350c,
+        DS3303u,
+        Kr651us,
+        Kritter,
+        Mustek300,
+        Proscope,
+        Twinkle,
+        DvcV6,
+        P35u,
+        Generic802,
+        NWEBCAMS        /* number of webcams */
+};
+
+static const u8 webcam_chip[NWEBCAMS] = {
+        [Generic800]    = BRIDGE_NW800, /* 06a5:0000
+                                         * Typhoon Webcam 100 USB */
+
+        [SpaceCam]      = BRIDGE_NW800, /* 06a5:d800
+                                * Trust SpaceCam120 or SpaceCam100 PORTABLE */
+
+        [SpaceCam2]     = BRIDGE_NW800, /* 06a5:d800 - pas106
+                        * other Trust SpaceCam120 or SpaceCam100 PORTABLE */
+
+        [Cvideopro]     = BRIDGE_NW802, /* 06a5:d001
+                        * Conceptronic Video Pro 'CVIDEOPRO USB Webcam CCD' */
+
+        [Dlink350c]     = BRIDGE_NW802, /* 06a5:d001
+                                         * D-Link NetQam Pro 250plus */
+
+        [DS3303u]       = BRIDGE_NW801, /* 06a5:d001
+                                * Plustek Opticam 500U or ProLink DS3303u */
+
+        [Kr651us]       = BRIDGE_NW802, /* 06a5:d001
+                                         * Panasonic GP-KR651US */
+
+        [Kritter]       = BRIDGE_NW802, /* 06a5:d001
+                                         * iRez Kritter cam */
+
+        [Mustek300]     = BRIDGE_NW802, /* 055f:d001
+                                         * Mustek Wcam 300 mini */
+
+        [Proscope]      = BRIDGE_NW802, /* 06a5:d001
+                                         * Scalar USB Microscope (ProScope) */
+
+        [Twinkle]       = BRIDGE_NW800, /* 06a5:d800 - hv7121b? (seems pas106)
+                                         * Divio Chicony TwinkleCam
+                                         * DSB-C110 */
+
+        [DvcV6]         = BRIDGE_NW802, /* 0502:d001
+                                         * DVC V6 */
+
+        [P35u]          = BRIDGE_NW801, /* 052b:d001, 06a5:d001 and 06be:d001
+                                         * EZCam Pro p35u */
+
+        [Generic802]    = BRIDGE_NW802,
+};
+/*
+ * other webcams:
+ *      - nw801 046d:d001
+ *              Logitech QuickCam Pro (dark focus ring)
+ *      - nw801 0728:d001
+ *              AVerMedia Camguard
+ *      - nw??? 06a5:d001
+ *              D-Link NetQam Pro 250plus
+ *      - nw800 065a:d800
+ *              Showcam NGS webcam
+ *      - nw??? ????:????
+ *              Sceptre svc300
+ */
+
+/*
+ * registers
+ *    nw800/et31x110      nw801           nw802
+ *      0000..009e      0000..00a1      0000..009e
+ *      0200..0211         id              id
+ *      0300..0302         id              id
+ *      0400..0406        (inex)        0400..0406
+ *      0500..0505      0500..0506        (inex)
+ *      0600..061a      0600..0601      0600..0601
+ *      0800..0814         id              id
+ *      1000..109c      1000..10a1      1000..109a
+ */
+
+/* resolutions
+ *      nw800: 320x240, 352x288
+ *      nw801/802: 320x240, 640x480
+ */
+static const struct v4l2_pix_format cif_mode[] = {
+        {320, 240, V4L2_PIX_FMT_JPGL, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 4 / 8,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+        {352, 288, V4L2_PIX_FMT_JPGL, V4L2_FIELD_NONE,
+                .bytesperline = 352,
+                .sizeimage = 352 * 288 * 4 / 8,
+                .colorspace = V4L2_COLORSPACE_JPEG}
+};
+static const struct v4l2_pix_format vga_mode[] = {
+        {320, 240, V4L2_PIX_FMT_JPGL, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 4 / 8,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+        {640, 480, V4L2_PIX_FMT_JPGL, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480 * 3 / 8,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+};
+
+/*
+ * The sequences below contain:
+ *      - 1st and 2nd bytes: either
+ *              - register number (BE)
+ *              - I2C0 + i2c address
+ *      - 3rd byte: data length (=0 for end of sequence)
+ *      - n bytes: data
+ */
+#define I2C0 0xff
+
+static const u8 nw800_init[] = {
+        0x04, 0x05, 0x01, 0x61,
+        0x04, 0x04, 0x01, 0x01,
+        0x04, 0x06, 0x01, 0x04,
+        0x04, 0x04, 0x03, 0x00, 0x00, 0x00,
+        0x05, 0x05, 0x01, 0x00,
+        0, 0, 0
+};
+static const u8 nw800_start[] = {
+        0x04, 0x06, 0x01, 0xc0,
+        0x00, 0x00, 0x40, 0x10, 0x43, 0x00, 0xb4, 0x01, 0x10, 0x00, 0x4f,
+                          0xef, 0x0e, 0x00, 0x74, 0x01, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x3e, 0x00, 0x24,
+                          0x03, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0x3e, 0x00, 0x86, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xca, 0x03, 0x46, 0x04, 0xca, 0x03, 0x46,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xf0,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x1f, 0xa0, 0x48, 0xc3, 0x02, 0x88, 0x0c, 0x68, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xa8, 0x06, 0x00, 0x08,
+                          0x00, 0x32, 0x01, 0x01, 0x00, 0x16, 0x00, 0x04,
+                          0x00, 0x4b, 0x00, 0x76, 0x00, 0x86, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x61, 0xc0,
+        0x05, 0x00, 0x06, 0xe8, 0x00, 0x00, 0x00, 0x20, 0x20,
+        0x06, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0x83, 0x02, 0x20, 0x00, 0x13, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1d, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x62,
+                          0x01, 0x24, 0x01, 0x62, 0x01, 0x24, 0x01, 0x20,
+                          0x01, 0x60, 0x01, 0x00, 0x00,
+
+        0x04, 0x04, 0x01, 0xff,
+        0x04, 0x06, 0x01, 0xc4,
+
+        0x04, 0x06, 0x01, 0xc0,
+        0x00, 0x00, 0x40, 0x10, 0x43, 0x00, 0xb4, 0x01, 0x10, 0x00, 0x4f,
+                          0xef, 0x0e, 0x00, 0x74, 0x01, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x3e, 0x00, 0x24,
+                          0x03, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0x3e, 0x00, 0x86, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xca, 0x03, 0x46, 0x04, 0xca, 0x03, 0x46,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xf0,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x1f, 0xa0, 0x48, 0xc3, 0x02, 0x88, 0x0c, 0x68, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xa8, 0x06, 0x00, 0x08,
+                          0x00, 0x32, 0x01, 0x01, 0x00, 0x16, 0x00, 0x04,
+                          0x00, 0x4b, 0x00, 0x76, 0x00, 0x86, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x61, 0xc0,
+        0x05, 0x00, 0x06, 0xe8, 0x00, 0x00, 0x00, 0x20, 0x20,
+        0x06, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0x83, 0x02, 0x20, 0x00, 0x13, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1d, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x62,
+                          0x01, 0x24, 0x01, 0x62, 0x01, 0x24, 0x01, 0x20,
+                          0x01, 0x60, 0x01, 0x00, 0x00,
+
+        0x02, 0x00, 0x11, 0x48, 0x58, 0x9e, 0x48, 0x58, 0x00, 0x00, 0x00,
+                          0x00, 0x84, 0x36, 0x05, 0x01, 0xf2, 0x86, 0x65,
+                          0x40,
+        0x00, 0x80, 0x01, 0xa0,
+        0x10, 0x1a, 0x01, 0x00,
+        0x00, 0x91, 0x02, 0x6c, 0x01,
+        0x00, 0x03, 0x02, 0xc8, 0x01,
+        0x10, 0x1a, 0x01, 0x00,
+        0x10, 0x00, 0x01, 0x83,
+        0x10, 0x8f, 0x0c, 0x62, 0x01, 0x24, 0x01, 0x62, 0x01, 0x24, 0x01,
+                          0x20, 0x01, 0x60, 0x01,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x1f, 0x01,
+        0x10, 0x1b, 0x02, 0x69, 0x00,
+        0x10, 0x11, 0x08, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x1f, 0x01,
+        0x05, 0x02, 0x01, 0x02,
+        0x06, 0x00, 0x02, 0x04, 0xd9,
+        0x05, 0x05, 0x01, 0x20,
+        0x05, 0x05, 0x01, 0x21,
+        0x10, 0x0e, 0x01, 0x08,
+        0x10, 0x41, 0x11, 0x00, 0x08, 0x21, 0x3d, 0x52, 0x63, 0x75, 0x83,
+                          0x91, 0x9e, 0xaa, 0xb6, 0xc1, 0xcc, 0xd6, 0xe0,
+                          0xea,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x13, 0x13,
+        0x10, 0x03, 0x01, 0x14,
+        0x10, 0x41, 0x11, 0x00, 0x08, 0x21, 0x3d, 0x52, 0x63, 0x75, 0x83,
+                          0x91, 0x9e, 0xaa, 0xb6, 0xc1, 0xcc, 0xd6, 0xe0,
+                          0xea,
+        0x10, 0x0b, 0x01, 0x14,
+        0x10, 0x0d, 0x01, 0x20,
+        0x10, 0x0c, 0x01, 0x34,
+        0x04, 0x06, 0x01, 0xc3,
+        0x04, 0x04, 0x01, 0x00,
+        0x05, 0x02, 0x01, 0x02,
+        0x06, 0x00, 0x02, 0x00, 0x48,
+        0x05, 0x05, 0x01, 0x20,
+        0x05, 0x05, 0x01, 0x21,
+        0, 0, 0
+};
+
+/* 06a5:d001 - nw801 - Panasonic
+ *              P35u */
+static const u8 nw801_start_1[] = {
+        0x05, 0x06, 0x01, 0x04,
+        0x00, 0x00, 0x40, 0x0e, 0x00, 0x00, 0xf9, 0x02, 0x11, 0x00, 0x0e,
+                          0x01, 0x1f, 0x00, 0x0d, 0x02, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0xce, 0x00, 0xf4,
+                          0x05, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0x3e, 0x00, 0x86, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xca, 0x03, 0x46, 0x04, 0xca, 0x03, 0x46,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xf0,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x22, 0xb4, 0x6f, 0x3f, 0x0f, 0x88, 0x20, 0x08, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x69, 0xa8, 0x1f, 0x00,
+                          0x0d, 0x02, 0x07, 0x00, 0x01, 0x00, 0x19, 0x00,
+                          0xf2, 0x00, 0x18, 0x06, 0x10, 0x06, 0x10, 0x00,
+                          0x36, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
+        0x05, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x06, 0x00, 0x02, 0x09, 0x99,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0x22, 0x02, 0x80, 0x00, 0x1e, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x0a, 0x15, 0x08, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x01, 0x35, 0xfd, 0x07, 0x3d, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x14, 0x02,
+                          0x00, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+                          0x40, 0x00, 0x00, 0x00, 0x40, 0x20, 0x10, 0x06,
+                          0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06, 0xf7,
+        0x10, 0x40, 0x40, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80, 0x80,
+                          0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99, 0xa4,
+                          0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc, 0xcf,
+                          0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54, 0x64,
+                          0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2, 0xe2,
+                          0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+        0x10, 0x80, 0x22, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x82, 0x02,
+                          0xe4, 0x01, 0x40, 0x01, 0xf0, 0x00, 0x40, 0x01,
+                          0xf0, 0x00,
+        0, 0, 0,
+};
+static const u8 nw801_start_qvga[] = {
+        0x02, 0x00, 0x10, 0x3c, 0x50, 0x9e, 0x3c, 0x50, 0x00, 0x00, 0x00,
+                          0x00, 0x78, 0x18, 0x0b, 0x06, 0xa2, 0x86, 0x78,
+        0x02, 0x0f, 0x01, 0x6b,
+        0x10, 0x1a, 0x01, 0x15,
+        0x00, 0x00, 0x01, 0x1e,
+        0x10, 0x00, 0x01, 0x2f,
+        0x10, 0x8c, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x11, 0x08, 0x29, 0x00, 0x18, 0x01, 0x1f, 0x00, 0xd2, 0x00,
+                                                        /* AE window */
+        0, 0, 0,
+};
+static const u8 nw801_start_vga[] = {
+        0x02, 0x00, 0x10, 0x78, 0xa0, 0x97, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xf0,
+        0x02, 0x0f, 0x01, 0xd5,
+        0x10, 0x1a, 0x01, 0x15,
+        0x00, 0x00, 0x01, 0x0e,
+        0x10, 0x00, 0x01, 0x22,
+        0x10, 0x8c, 0x08, 0x00, 0x00, 0x7f, 0x02, 0x00, 0x00, 0xdf, 0x01,
+        0x10, 0x11, 0x08, 0x51, 0x00, 0x30, 0x02, 0x3d, 0x00, 0xa4, 0x01,
+        0, 0, 0,
+};
+static const u8 nw801_start_2[] = {
+        0x10, 0x04, 0x01, 0x1a,
+        0x10, 0x19, 0x01, 0x09,                         /* clock */
+        0x10, 0x24, 0x06, 0xc0, 0x00, 0x3f, 0x02, 0x00, 0x01,
+                                                         /* .. gain .. */
+        0x00, 0x03, 0x02, 0x92, 0x03,
+        0x00, 0x1d, 0x04, 0xf2, 0x00, 0x24, 0x07,
+        0x00, 0x7b, 0x01, 0xcf,
+        0x10, 0x94, 0x01, 0x07,
+        0x05, 0x05, 0x01, 0x01,
+        0x05, 0x04, 0x01, 0x01,
+        0x10, 0x0e, 0x01, 0x08,
+        0x10, 0x48, 0x11, 0x00, 0x37, 0x55, 0x6b, 0x7d, 0x8d, 0x9b, 0xa8,
+                          0xb4, 0xbf, 0xca, 0xd4, 0xdd, 0xe6, 0xef, 0xf0,
+                          0xf0,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x0c, 0x0c,
+        0x10, 0x03, 0x01, 0x08,
+        0x10, 0x48, 0x11, 0x00, 0x37, 0x55, 0x6b, 0x7d, 0x8d, 0x9b, 0xa8,
+                          0xb4, 0xbf, 0xca, 0xd4, 0xdd, 0xe6, 0xef, 0xf0,
+                          0xf0,
+        0x10, 0x0b, 0x01, 0x0b,
+        0x10, 0x0d, 0x01, 0x0b,
+        0x10, 0x0c, 0x01, 0x1f,
+        0x05, 0x06, 0x01, 0x03,
+        0, 0, 0
+};
+
+/* nw802 (sharp IR3Y38M?) */
+static const u8 nw802_start[] = {
+        0x04, 0x06, 0x01, 0x04,
+        0x00, 0x00, 0x40, 0x10, 0x00, 0x00, 0xf9, 0x02, 0x10, 0x00, 0x4d,
+                          0x0f, 0x1f, 0x00, 0x0d, 0x02, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0xce, 0x00, 0xf4,
+                          0x05, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0x3e, 0x00, 0x86, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xca, 0x03, 0x46, 0x04, 0xca, 0x03, 0x46,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xf0,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x1f, 0xb4, 0x6f, 0x3f, 0x0f, 0x88, 0x20, 0x68, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xa8, 0x08, 0x00, 0x11,
+                          0x00, 0x0c, 0x02, 0x01, 0x00, 0x16, 0x00, 0x94,
+                          0x00, 0x10, 0x06, 0x08, 0x00, 0x18, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x21, 0x00,
+        0x06, 0x00, 0x02, 0x09, 0x99,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0xa1, 0x02, 0x80, 0x00, 0x1d, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0xff, 0x01, 0xc0, 0x00, 0x14,
+                          0x02, 0x00, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1b, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x05, 0x82,
+                          0x02, 0xe4, 0x01, 0x40, 0x01, 0xf0, 0x00, 0x40,
+                          0x01, 0xf0, 0x00,
+        0x02, 0x00, 0x11, 0x3c, 0x50, 0x9e, 0x3c, 0x50, 0x00, 0x00, 0x00,
+                          0x00, 0x78, 0x3f, 0x10, 0x02, 0xf2, 0x8f, 0x78,
+                          0x40,
+        0x10, 0x1a, 0x01, 0x00,
+        0x10, 0x00, 0x01, 0xad,
+        0x00, 0x00, 0x01, 0x08,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1b, 0x02, 0x00, 0x00,
+        0x10, 0x11, 0x08, 0x51, 0x00, 0xf0, 0x00, 0x3d, 0x00, 0xb4, 0x00,
+        0x10, 0x1d, 0x08, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
+        0x10, 0x0e, 0x01, 0x27,
+        0x10, 0x41, 0x11, 0x00, 0x0e, 0x35, 0x4f, 0x62, 0x71, 0x7f, 0x8b,
+                          0x96, 0xa0, 0xa9, 0xb2, 0xbb, 0xc3, 0xca, 0xd2,
+                          0xd8,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x14, 0x14,
+        0x10, 0x03, 0x01, 0x0c,
+        0x10, 0x41, 0x11, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54, 0x64, 0x74,
+                          0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2, 0xe2, 0xf1,
+                          0xff,
+/*                        0x00, 0x0e, 0x35, 0x4f, 0x62, 0x71, 0x7f, 0x8b,
+ *                        0x96, 0xa0, 0xa9, 0xb2, 0xbb, 0xc3, 0xca, 0xd2,
+ *                        0xd8, */
+        0x10, 0x0b, 0x01, 0x10,
+        0x10, 0x0d, 0x01, 0x11,
+        0x10, 0x0c, 0x01, 0x1c,
+        0x04, 0x06, 0x01, 0x03,
+        0x04, 0x04, 0x01, 0x00,
+        0, 0, 0
+};
+/* et31x110 - Trust 120 SpaceCam */
+static const u8 spacecam_init[] = {
+        0x04, 0x05, 0x01, 0x01,
+        0x04, 0x04, 0x01, 0x01,
+        0x04, 0x06, 0x01, 0x04,
+        0x04, 0x04, 0x03, 0x00, 0x00, 0x00,
+        0x05, 0x05, 0x01, 0x00,
+        0, 0, 0
+};
+static const u8 spacecam_start[] = {
+        0x04, 0x06, 0x01, 0x44,
+        0x00, 0x00, 0x40, 0x10, 0x43, 0x00, 0xb4, 0x01, 0x10, 0x00, 0x4f,
+                          0xef, 0x0e, 0x00, 0x74, 0x01, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x3e, 0x00, 0x24,
+                          0x03, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0x3e, 0x00, 0x86, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xca, 0x03, 0x46, 0x04, 0xca, 0x03, 0x46,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xf0,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x1f, 0xa0, 0x48, 0xc3, 0x02, 0x88, 0x0c, 0x68, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xa8, 0x06, 0x00, 0x08,
+                          0x00, 0x32, 0x01, 0x01, 0x00, 0x16, 0x00, 0x04,
+                          0x00, 0x4b, 0x00, 0x7c, 0x00, 0x80, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x05, 0x00, 0x06, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x06, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0x83, 0x02, 0x20, 0x00, 0x11, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1d, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x62,
+                          0x01, 0x24, 0x01, 0x62, 0x01, 0x24, 0x01, 0x20,
+                          0x01, 0x60, 0x01, 0x00, 0x00,
+        0x04, 0x06, 0x01, 0xc0,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x1f, 0x01,
+        0x02, 0x00, 0x11, 0x48, 0x58, 0x9e, 0x48, 0x58, 0x00, 0x00, 0x00,
+                          0x00, 0x84, 0x36, 0x05, 0x01, 0xf2, 0x86, 0x65,
+                          0x40,
+        0x00, 0x80, 0x01, 0xa0,
+        0x10, 0x1a, 0x01, 0x00,
+        0x00, 0x91, 0x02, 0x32, 0x01,
+        0x00, 0x03, 0x02, 0x08, 0x02,
+        0x10, 0x00, 0x01, 0x83,
+        0x10, 0x8f, 0x0c, 0x62, 0x01, 0x24, 0x01, 0x62, 0x01, 0x24, 0x01,
+                          0x20, 0x01, 0x60, 0x01,
+        0x10, 0x11, 0x08, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x1f, 0x01,
+        0x10, 0x0e, 0x01, 0x08,
+        0x10, 0x41, 0x11, 0x00, 0x64, 0x99, 0xc0, 0xe2, 0xf9, 0xf9, 0xf9,
+                          0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9,
+                          0xf9,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x13, 0x13,
+        0x10, 0x03, 0x01, 0x06,
+        0x10, 0x41, 0x11, 0x00, 0x64, 0x99, 0xc0, 0xe2, 0xf9, 0xf9, 0xf9,
+                          0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9,
+                          0xf9,
+        0x10, 0x0b, 0x01, 0x08,
+        0x10, 0x0d, 0x01, 0x10,
+        0x10, 0x0c, 0x01, 0x1f,
+        0x04, 0x06, 0x01, 0xc3,
+        0x04, 0x05, 0x01, 0x40,
+        0x04, 0x04, 0x01, 0x40,
+        0, 0, 0
+};
+/* et31x110 - pas106 - other Trust SpaceCam120 */
+static const u8 spacecam2_start[] = {
+        0x04, 0x06, 0x01, 0x44,
+        0x04, 0x06, 0x01, 0x00,
+        0x00, 0x00, 0x40, 0x14, 0x83, 0x00, 0xba, 0x01, 0x10, 0x00, 0x4f,
+                          0xef, 0x00, 0x00, 0x60, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x06, 0x00, 0xfc,
+                          0x01, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0x3e, 0x00, 0x86, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xca, 0x03, 0x46, 0x04, 0xca, 0x03, 0x46,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xf0,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x1f, 0xb8, 0x48, 0x0f, 0x04, 0x88, 0x14, 0x68, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xa8, 0x01, 0x00, 0x03,
+                          0x00, 0x24, 0x01, 0x01, 0x00, 0x16, 0x00, 0x04,
+                          0x00, 0x4b, 0x00, 0x76, 0x00, 0x86, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x61, 0x00,
+        0x05, 0x00, 0x06, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x06, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0x80, 0x02, 0x20, 0x00, 0x13, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1d, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x62,
+                          0x01, 0x24, 0x01, 0x62, 0x01, 0x24, 0x01, 0x20,
+                          0x01, 0x60, 0x01, 0x00, 0x00,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x1f, 0x01,
+        0x04, 0x04, 0x01, 0x40,
+        0x04, 0x04, 0x01, 0x00,
+        I2C0, 0x40, 0x0c, 0x02, 0x0c, 0x12, 0x07, 0x00, 0x00, 0x00, 0x05,
+                          0x00, 0x00, 0x05, 0x05,
+        I2C0, 0x40, 0x02, 0x11, 0x06,
+        I2C0, 0x40, 0x02, 0x14, 0x00,
+        I2C0, 0x40, 0x02, 0x13, 0x01,           /* i2c end */
+        0x02, 0x00, 0x11, 0x48, 0x58, 0x9e, 0x48, 0x58, 0x00, 0x00, 0x00,
+                          0x00, 0x84, 0x36, 0x05, 0x01, 0xf2, 0x86, 0x65,
+                          0x40,
+        I2C0, 0x40, 0x02, 0x02, 0x0c,           /* pixel clock */
+        I2C0, 0x40, 0x02, 0x0f, 0x00,
+        I2C0, 0x40, 0x02, 0x13, 0x01,           /* i2c end */
+        0x10, 0x00, 0x01, 0x01,
+        0x10, 0x8f, 0x0c, 0x62, 0x01, 0x24, 0x01, 0x62, 0x01, 0x24, 0x01,
+                          0x20, 0x01, 0x60, 0x01,
+        I2C0, 0x40, 0x02, 0x05, 0x0f,           /* exposure */
+        I2C0, 0x40, 0x02, 0x13, 0x01,           /* i2c end */
+        I2C0, 0x40, 0x07, 0x09, 0x0b, 0x0f, 0x05, 0x05, 0x0f, 0x00,
+                                                /* gains */
+        I2C0, 0x40, 0x03, 0x12, 0x04, 0x01,
+        0x10, 0x11, 0x08, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x1f, 0x01,
+        0x10, 0x0e, 0x01, 0x08,
+        0x10, 0x41, 0x11, 0x00, 0x17, 0x3f, 0x69, 0x7b, 0x8c, 0x9a, 0xa7,
+                          0xb3, 0xbf, 0xc9, 0xd3, 0xdd, 0xe6, 0xef, 0xf7,
+                          0xf9,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x13, 0x13,
+        0x10, 0x03, 0x01, 0x06,
+        0x10, 0x41, 0x11, 0x00, 0x17, 0x3f, 0x69, 0x7b, 0x8c, 0x9a, 0xa7,
+                          0xb3, 0xbf, 0xc9, 0xd3, 0xdd, 0xe6, 0xef, 0xf7,
+                          0xf9,
+        0x10, 0x0b, 0x01, 0x11,
+        0x10, 0x0d, 0x01, 0x10,
+        0x10, 0x0c, 0x01, 0x14,
+        0x04, 0x06, 0x01, 0x03,
+        0x04, 0x05, 0x01, 0x61,
+        0x04, 0x04, 0x01, 0x00,
+        0, 0, 0
+};
+
+/* nw802 - Conceptronic Video Pro */
+static const u8 cvideopro_start[] = {
+        0x04, 0x06, 0x01, 0x04,
+        0x00, 0x00, 0x40, 0x54, 0x96, 0x98, 0xf9, 0x02, 0x18, 0x00, 0x4c,
+                          0x0f, 0x1f, 0x00, 0x0d, 0x02, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x0b, 0x00, 0x1b, 0x00, 0xc8, 0x00, 0xf4,
+                          0x05, 0xb4, 0x00, 0xcc, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xa2, 0x00, 0xc6, 0x00, 0x60, 0x00, 0xc6,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0xae, 0x00, 0xd2, 0x00, 0xae, 0x00, 0xd2,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xa8, 0x00, 0xc0, 0x00, 0x66, 0x00, 0xc0,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x0a, 0x00, 0x54, 0x00, 0x0a, 0x00, 0x54,
+                          0x00, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6,
+                          0x00, 0x5d, 0x00, 0xc7, 0x00, 0x7e, 0x00, 0x30,
+        0x00, 0x80, 0x1f, 0x98, 0x43, 0x3f, 0x0d, 0x88, 0x20, 0x80, 0x3f,
+                          0x47, 0xaf, 0x00, 0x00, 0xa8, 0x08, 0x00, 0x11,
+                          0x00, 0x0c, 0x02, 0x0c, 0x00, 0x1c, 0x00, 0x94,
+                          0x00, 0x10, 0x06, 0x24, 0x00, 0x4a, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0xff, 0x00,
+        0x06, 0x00, 0x02, 0x09, 0x99,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0xa0, 0x02, 0x80, 0x00, 0x12, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0xe0, 0x00, 0x0c,
+                          0x00, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1b, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x05, 0x82,
+                          0x02, 0xe4, 0x01, 0x40, 0x01, 0xf0, 0x00, 0x40,
+                          0x01, 0xf0, 0x00,
+        0x02, 0x00, 0x11, 0x3c, 0x50, 0x8c, 0x3c, 0x50, 0x00, 0x00, 0x00,
+                          0x00, 0x78, 0x3f, 0x3f, 0x06, 0xf2, 0x8f, 0xf0,
+                          0x40,
+        0x10, 0x1a, 0x01, 0x03,
+        0x10, 0x00, 0x01, 0xac,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1b, 0x02, 0x3b, 0x01,
+        0x10, 0x11, 0x08, 0x61, 0x00, 0xe0, 0x00, 0x49, 0x00, 0xa8, 0x00,
+        0x10, 0x1f, 0x06, 0x01, 0x20, 0x02, 0xe8, 0x03, 0x00,
+        0x10, 0x1d, 0x02, 0x40, 0x06,
+        0x10, 0x0e, 0x01, 0x08,
+        0x10, 0x41, 0x11, 0x00, 0x0f, 0x46, 0x62, 0x76, 0x86, 0x94, 0xa0,
+                          0xab, 0xb6, 0xbf, 0xc8, 0xcf, 0xd7, 0xdc, 0xdc,
+                          0xdc,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x12, 0x12,
+        0x10, 0x03, 0x01, 0x0c,
+        0x10, 0x41, 0x11, 0x00, 0x0f, 0x46, 0x62, 0x76, 0x86, 0x94, 0xa0,
+                          0xab, 0xb6, 0xbf, 0xc8, 0xcf, 0xd7, 0xdc, 0xdc,
+                          0xdc,
+        0x10, 0x0b, 0x01, 0x09,
+        0x10, 0x0d, 0x01, 0x10,
+        0x10, 0x0c, 0x01, 0x2f,
+        0x04, 0x06, 0x01, 0x03,
+        0x04, 0x04, 0x01, 0x00,
+        0, 0, 0
+};
+
+/* nw802 - D-link dru-350c cam */
+static const u8 dlink_start[] = {
+        0x04, 0x06, 0x01, 0x04,
+        0x00, 0x00, 0x40, 0x10, 0x00, 0x00, 0x92, 0x03, 0x10, 0x00, 0x4d,
+                          0x0f, 0x1f, 0x00, 0x0d, 0x02, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0xce, 0x00, 0xf4,
+                          0x05, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0x3e, 0x00, 0x86, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xca, 0x03, 0x46, 0x04, 0xca, 0x03, 0x46,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xf0,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x1f, 0xb4, 0x6f, 0x3f, 0x0f, 0x88, 0x20, 0x68, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xa8, 0x08, 0x00, 0x11,
+                          0x00, 0x0c, 0x02, 0x01, 0x00, 0x16, 0x00, 0x94,
+                          0x00, 0x10, 0x06, 0x10, 0x00, 0x36, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x21, 0x00,
+        0x06, 0x00, 0x02, 0x09, 0x99,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0xa1, 0x02, 0x80, 0x00, 0x12, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0xc0, 0x00, 0x14,
+                          0x02, 0x00, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1b, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x01, 0x82,
+                          0x02, 0xe4, 0x01, 0x40, 0x01, 0xf0, 0x00, 0x40,
+                          0x01, 0xf0, 0x00,
+        0x02, 0x00, 0x11, 0x3c, 0x50, 0x9e, 0x3c, 0x50, 0x00, 0x00, 0x00,
+                          0x00, 0x78, 0x3f, 0x10, 0x02, 0xf2, 0x8f, 0x78,
+                          0x40,
+        0x10, 0x1a, 0x01, 0x00,
+        0x10, 0x00, 0x01, 0xad,
+        0x00, 0x00, 0x01, 0x08,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1b, 0x02, 0x00, 0x00,
+        0x10, 0x11, 0x08, 0x51, 0x00, 0xf0, 0x00, 0x3d, 0x00, 0xb4, 0x00,
+        0x10, 0x1d, 0x08, 0x40, 0x06, 0x01, 0x20, 0x02, 0xe8, 0x03, 0x00,
+        0x10, 0x0e, 0x01, 0x20,
+        0x10, 0x41, 0x11, 0x00, 0x07, 0x1e, 0x38, 0x4d, 0x60, 0x70, 0x7f,
+                          0x8e, 0x9b, 0xa8, 0xb4, 0xbf, 0xca, 0xd5, 0xdf,
+                          0xea,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x11, 0x11,
+        0x10, 0x03, 0x01, 0x10,
+        0x10, 0x41, 0x11, 0x00, 0x07, 0x1e, 0x38, 0x4d, 0x60, 0x70, 0x7f,
+                          0x8e, 0x9b, 0xa8, 0xb4, 0xbf, 0xca, 0xd5, 0xdf,
+                          0xea,
+        0x10, 0x0b, 0x01, 0x19,
+        0x10, 0x0d, 0x01, 0x10,
+        0x10, 0x0c, 0x01, 0x1e,
+        0x04, 0x06, 0x01, 0x03,
+        0x04, 0x04, 0x01, 0x00,
+        0, 0, 0
+};
+
+/* 06a5:d001 - nw801 - Sony
+ *              Plustek Opticam 500U or ProLink DS3303u (Hitachi HD49322BF) */
+/*fixme: 320x240 only*/
+static const u8 ds3303_start[] = {
+        0x05, 0x06, 0x01, 0x04,
+        0x00, 0x00, 0x40, 0x16, 0x00, 0x00, 0xf9, 0x02, 0x11, 0x00, 0x0e,
+                          0x01, 0x1f, 0x00, 0x0d, 0x02, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0xce, 0x00, 0xf4,
+                          0x05, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0x3e, 0x00, 0x86, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xca, 0x03, 0x46, 0x04, 0xca, 0x03, 0x46,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xf0,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x22, 0xb4, 0x6f, 0x3f, 0x0f, 0x88, 0x20, 0x08, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xa9, 0xa8, 0x1f, 0x00,
+                          0x0d, 0x02, 0x07, 0x00, 0x01, 0x00, 0x19, 0x00,
+                          0xf2, 0x00, 0x18, 0x06, 0x10, 0x06, 0x10, 0x00,
+                          0x36, 0x00,
+        0x02, 0x00, 0x12, 0x03, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0x50,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x05, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0xff, 0x00,
+        0x06, 0x00, 0x02, 0x09, 0x99,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0x2f, 0x02, 0x80, 0x00, 0x12, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x1f, 0x10, 0x08, 0x0a,
+                          0x0a, 0x51, 0x00, 0xf1, 0x00, 0x3c, 0x00, 0xb4,
+                          0x00, 0x01, 0x15, 0xfd, 0x07, 0x3d, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x8c, 0x04, 0x01, 0x20,
+                          0x02, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0x00,
+                          0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08, 0x03,
+                          0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06, 0xf7,
+        0x10, 0x40, 0x40, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80, 0x80,
+                          0x00, 0x2d, 0x46, 0x58, 0x67, 0x74, 0x7f, 0x88,
+                          0x94, 0x9d, 0xa6, 0xae, 0xb5, 0xbd, 0xc4, 0xcb,
+                          0xd1, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54, 0x64,
+                          0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2, 0xe2,
+                          0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+        0x10, 0x80, 0x22, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x3f, 0x01,
+                          0x00, 0x00, 0xef, 0x00, 0x02, 0x0a, 0x82, 0x02,
+                          0xe4, 0x01, 0x40, 0x01, 0xf0, 0x00, 0x40, 0x01,
+                          0xf0, 0x00,
+
+        0x02, 0x00, 0x11, 0x3c, 0x50, 0x9e, 0x3c, 0x50, 0x00, 0x00, 0x00,
+                          0x00, 0x78, 0x3f, 0x3f, 0x00, 0xf2, 0x8f, 0x81,
+                          0x40,
+        0x10, 0x1a, 0x01, 0x15,
+        0x10, 0x00, 0x01, 0x2f,
+        0x10, 0x8c, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1b, 0x02, 0x00, 0x00,
+        0x10, 0x11, 0x08, 0x61, 0x00, 0xe0, 0x00, 0x49, 0x00, 0xa8, 0x00,
+        0x10, 0x26, 0x06, 0x01, 0x20, 0x02, 0xe8, 0x03, 0x00,
+        0x10, 0x24, 0x02, 0x40, 0x06,
+        0x10, 0x0e, 0x01, 0x08,
+        0x10, 0x48, 0x11, 0x00, 0x15, 0x40, 0x67, 0x84, 0x9d, 0xb2, 0xc6,
+                          0xd6, 0xe7, 0xf6, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9,
+                          0xf9,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x16, 0x16,
+        0x10, 0x03, 0x01, 0x0c,
+        0x10, 0x48, 0x11, 0x00, 0x15, 0x40, 0x67, 0x84, 0x9d, 0xb2, 0xc6,
+                          0xd6, 0xe7, 0xf6, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9,
+                          0xf9,
+        0x10, 0x0b, 0x01, 0x26,
+        0x10, 0x0d, 0x01, 0x10,
+        0x10, 0x0c, 0x01, 0x1c,
+        0x05, 0x06, 0x01, 0x03,
+        0x05, 0x04, 0x01, 0x00,
+        0, 0, 0
+};
+
+/* 06a5:d001 - nw802 - Panasonic
+ *              GP-KR651US (Philips TDA8786) */
+static const u8 kr651_start_1[] = {
+        0x04, 0x06, 0x01, 0x04,
+        0x00, 0x00, 0x40, 0x44, 0x96, 0x98, 0xf9, 0x02, 0x18, 0x00, 0x48,
+                          0x0f, 0x1f, 0x00, 0x0d, 0x02, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x0b, 0x00, 0x1b, 0x00, 0xc8, 0x00, 0xf4,
+                          0x05, 0xb4, 0x00, 0xcc, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xa2, 0x00, 0xc6, 0x00, 0x60, 0x00, 0xc6,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0xae, 0x00, 0xd2, 0x00, 0xae, 0x00, 0xd2,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xa8, 0x00, 0xc0, 0x00, 0x66, 0x00, 0xc0,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x0a, 0x00, 0x54, 0x00, 0x0a, 0x00, 0x54,
+                          0x00, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6,
+                          0x00, 0x5d, 0x00, 0xc7, 0x00, 0x7e, 0x00, 0x30,
+        0x00, 0x80, 0x1f, 0x18, 0x43, 0x3f, 0x0d, 0x88, 0x20, 0x80, 0x3f,
+                          0x47, 0xaf, 0x00, 0x00, 0xa8, 0x08, 0x00, 0x11,
+                          0x00, 0x0c, 0x02, 0x0c, 0x00, 0x1c, 0x00, 0x94,
+                          0x00, 0x10, 0x06, 0x24, 0x00, 0x4a, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x02, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x21, 0x00,
+        0x06, 0x00, 0x02, 0x09, 0x99,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0xa0, 0x02, 0x80, 0x00, 0x12, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0xe0, 0x00, 0x0c,
+                          0x00, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1b, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x05, 0x82,
+                          0x02, 0xe4, 0x01, 0x40, 0x01, 0xf0, 0x00, 0x40,
+                          0x01, 0xf0, 0x00,
+        0, 0, 0
+};
+static const u8 kr651_start_qvga[] = {
+        0x02, 0x00, 0x11, 0x3c, 0x50, 0x9e, 0x3c, 0x50, 0x00, 0x00, 0x00,
+                          0x00, 0x78, 0x3f, 0x10, 0x02, 0xf2, 0x8f, 0x78,
+                          0x40,
+        0x10, 0x1a, 0x01, 0x03,
+        0x10, 0x00, 0x01, 0xac,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1b, 0x02, 0x00, 0x00,
+        0x10, 0x11, 0x08, 0x29, 0x00, 0x18, 0x01, 0x1f, 0x00, 0xd2, 0x00,
+        0x10, 0x1d, 0x06, 0xe0, 0x00, 0x0c, 0x00, 0x52, 0x00,
+        0x10, 0x1d, 0x02, 0x28, 0x01,
+        0, 0, 0
+};
+static const u8 kr651_start_vga[] = {
+        0x02, 0x00, 0x11, 0x78, 0xa0, 0x8c, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x30, 0x03, 0x01, 0x82, 0x82, 0x98,
+                          0x80,
+        0x10, 0x1a, 0x01, 0x03,
+        0x10, 0x00, 0x01, 0xa0,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x7f, 0x02, 0x00, 0x00, 0xdf, 0x01,
+        0x10, 0x1b, 0x02, 0x00, 0x00,
+        0x10, 0x11, 0x08, 0x51, 0x00, 0x30, 0x02, 0x3d, 0x00, 0xa4, 0x01,
+        0x10, 0x1d, 0x06, 0xe0, 0x00, 0x0c, 0x00, 0x52, 0x00,
+        0x10, 0x1d, 0x02, 0x68, 0x00,
+};
+static const u8 kr651_start_2[] = {
+        0x10, 0x0e, 0x01, 0x08,
+        0x10, 0x41, 0x11, 0x00, 0x11, 0x3c, 0x5c, 0x74, 0x88, 0x99, 0xa8,
+                          0xb7, 0xc4, 0xd0, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc,
+                          0xdc,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x0c, 0x0c,
+        0x10, 0x03, 0x01, 0x0c,
+        0x10, 0x41, 0x11, 0x00, 0x11, 0x3c, 0x5c, 0x74, 0x88, 0x99, 0xa8,
+                          0xb7, 0xc4, 0xd0, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc,
+                          0xdc,
+        0x10, 0x0b, 0x01, 0x10,
+        0x10, 0x0d, 0x01, 0x10,
+        0x10, 0x0c, 0x01, 0x2d,
+        0x04, 0x06, 0x01, 0x03,
+        0x04, 0x04, 0x01, 0x00,
+        0, 0, 0
+};
+
+/* nw802 - iRez Kritter cam */
+static const u8 kritter_start[] = {
+        0x04, 0x06, 0x01, 0x06,
+        0x00, 0x00, 0x40, 0x44, 0x96, 0x98, 0x94, 0x03, 0x18, 0x00, 0x48,
+                          0x0f, 0x1e, 0x00, 0x0c, 0x02, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x0b, 0x00, 0x1b, 0x00, 0x0a, 0x01, 0x28,
+                          0x07, 0xb4, 0x00, 0xcc, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xa2, 0x00, 0xc6, 0x00, 0x60, 0x00, 0xc6,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0xae, 0x00, 0xd2, 0x00, 0xae, 0x00, 0xd2,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xa8, 0x00, 0xc0, 0x00, 0x66, 0x00, 0xc0,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x0a, 0x00, 0x54, 0x00, 0x0a, 0x00, 0x54,
+                          0x00, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6,
+                          0x00, 0x5d, 0x00, 0x0e, 0x00, 0x7e, 0x00, 0x30,
+        0x00, 0x80, 0x1f, 0x18, 0x43, 0x3f, 0x0d, 0x88, 0x20, 0x80, 0x3f,
+                          0x47, 0xaf, 0x00, 0x00, 0xa8, 0x08, 0x00, 0x11,
+                          0x00, 0x0b, 0x02, 0x0c, 0x00, 0x1c, 0x00, 0x94,
+                          0x00, 0x10, 0x06, 0x24, 0x00, 0x4a, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x02, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0xff, 0x00,
+        0x06, 0x00, 0x02, 0x09, 0x99,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0xa0, 0x02, 0x80, 0x00, 0x12, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0xe0, 0x00, 0x0c,
+                          0x00, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1b, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x82,
+                          0x02, 0xe4, 0x01, 0x40, 0x01, 0xf0, 0x00, 0x40,
+                          0x01, 0xf0, 0x00,
+        0x02, 0x00, 0x11, 0x3c, 0x50, 0x8c, 0x3c, 0x50, 0x00, 0x00, 0x00,
+                          0x00, 0x78, 0x3f, 0x3f, 0x06, 0xf2, 0x8f, 0xf0,
+                          0x40,
+        0x10, 0x1a, 0x01, 0x03,
+        0x10, 0x00, 0x01, 0xaf,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1b, 0x02, 0x3b, 0x01,
+        0x10, 0x11, 0x08, 0x61, 0x00, 0xe0, 0x00, 0x49, 0x00, 0xa8, 0x00,
+        0x10, 0x1d, 0x06, 0xe0, 0x00, 0x0c, 0x00, 0x52, 0x00,
+        0x10, 0x1d, 0x02, 0x00, 0x00,
+        0x10, 0x0e, 0x01, 0x08,
+        0x10, 0x41, 0x11, 0x00, 0x0d, 0x36, 0x4e, 0x60, 0x6f, 0x7b, 0x86,
+                          0x90, 0x98, 0xa1, 0xa9, 0xb1, 0xb7, 0xbe, 0xc4,
+                          0xcb,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x0d, 0x0d,
+        0x10, 0x03, 0x01, 0x02,
+        0x10, 0x41, 0x11, 0x00, 0x0d, 0x36, 0x4e, 0x60, 0x6f, 0x7b, 0x86,
+                          0x90, 0x98, 0xa1, 0xa9, 0xb1, 0xb7, 0xbe, 0xc4,
+                          0xcb,
+        0x10, 0x0b, 0x01, 0x17,
+        0x10, 0x0d, 0x01, 0x10,
+        0x10, 0x0c, 0x01, 0x1e,
+        0x04, 0x06, 0x01, 0x03,
+        0x04, 0x04, 0x01, 0x00,
+        0, 0, 0
+};
+
+/* nw802 - Mustek Wcam 300 mini */
+static const u8 mustek_start[] = {
+        0x04, 0x06, 0x01, 0x04,
+        0x00, 0x00, 0x40, 0x10, 0x00, 0x00, 0x92, 0x03, 0x10, 0x00, 0x4d,
+                          0x0f, 0x1f, 0x00, 0x0d, 0x02, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0xce, 0x00, 0xf4,
+                          0x05, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0x3e, 0x00, 0x86, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xca, 0x03, 0x46, 0x04, 0xca, 0x03, 0x46,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xf0,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x1f, 0xb4, 0x6f, 0x3f, 0x0f, 0x88, 0x20, 0x68, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xa8, 0x08, 0x00, 0x11,
+                          0x00, 0x0c, 0x02, 0x01, 0x00, 0x16, 0x00, 0x94,
+                          0x00, 0x10, 0x06, 0xfc, 0x05, 0x0c, 0x06,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x21, 0x00,
+        0x06, 0x00, 0x02, 0x09, 0x99,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0xa1, 0x02, 0x80, 0x00, 0x13, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0xc0, 0x00, 0x14,
+                          0x02, 0x00, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1b, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x01, 0x82,
+                          0x02, 0xe4, 0x01, 0x40, 0x01, 0xf0, 0x00, 0x40,
+                          0x01, 0xf0, 0x00,
+        0x02, 0x00, 0x11, 0x3c, 0x50, 0x9e, 0x3c, 0x50, 0x00, 0x00, 0x00,
+                          0x00, 0x78, 0x3f, 0x10, 0x02, 0xf2, 0x8f, 0x78,
+                          0x40,
+        0x10, 0x1a, 0x01, 0x00,
+        0x10, 0x00, 0x01, 0xad,
+        0x00, 0x00, 0x01, 0x08,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1b, 0x02, 0x00, 0x00,
+        0x10, 0x11, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1d, 0x08, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20,
+        0x10, 0x0e, 0x01, 0x0f,
+        0x10, 0x41, 0x11, 0x00, 0x0f, 0x29, 0x4a, 0x64, 0x7a, 0x8c, 0x9e,
+                          0xad, 0xba, 0xc7, 0xd3, 0xde, 0xe8, 0xf1, 0xf9,
+                          0xff,
+        0x10, 0x0f, 0x02, 0x11, 0x11,
+        0x10, 0x03, 0x01, 0x0c,
+        0x10, 0x41, 0x11, 0x00, 0x0f, 0x29, 0x4a, 0x64, 0x7a, 0x8c, 0x9e,
+                          0xad, 0xba, 0xc7, 0xd3, 0xde, 0xe8, 0xf1, 0xf9,
+                          0xff,
+        0x10, 0x0b, 0x01, 0x1c,
+        0x10, 0x0d, 0x01, 0x1a,
+        0x10, 0x0c, 0x01, 0x34,
+        0x04, 0x05, 0x01, 0x61,
+        0x04, 0x04, 0x01, 0x40,
+        0x04, 0x06, 0x01, 0x03,
+        0, 0, 0
+};
+
+/* nw802 - Scope USB Microscope M2 (ProScope) (Hitachi HD49322BF) */
+static const u8 proscope_init[] = {
+        0x04, 0x05, 0x01, 0x21,
+        0x04, 0x04, 0x01, 0x01,
+        0, 0, 0
+};
+static const u8 proscope_start_1[] = {
+        0x04, 0x06, 0x01, 0x04,
+        0x00, 0x00, 0x40, 0x10, 0x01, 0x00, 0xf9, 0x02, 0x10, 0x00, 0x04,
+                          0x0f, 0x1f, 0x00, 0x0d, 0x02, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x08, 0x00, 0x17, 0x00, 0xce, 0x00, 0xf4,
+                          0x05, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0xce, 0x00, 0xf8, 0x03, 0x3e, 0x00, 0x86,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0xb6,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xf6, 0x03, 0x34, 0x04, 0xf6, 0x03, 0x34,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xe8,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x1f, 0xb4, 0x6f, 0x1f, 0x0f, 0x08, 0x20, 0xa8, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xa8, 0x08, 0x00, 0x11,
+                          0x00, 0x0c, 0x02, 0x01, 0x00, 0x19, 0x00, 0x94,
+                          0x00, 0x10, 0x06, 0x10, 0x00, 0x36, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x21, 0x00,
+        0x06, 0x00, 0x02, 0x09, 0x99,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0xad, 0x02, 0x80, 0x00, 0x12, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x1f, 0x10, 0x08, 0x0a,
+                          0x0a, 0x51, 0x00, 0xf1, 0x00, 0x3c, 0x00, 0xb4,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0x8c, 0x04, 0x01,
+                          0x20, 0x02, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x2d, 0x46, 0x58, 0x67, 0x74, 0x7f,
+                          0x88, 0x94, 0x9d, 0xa6, 0xae, 0xb5, 0xbd, 0xc4,
+                          0xcb, 0xd1, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1b, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x3f,
+                          0x01, 0x00, 0x00, 0xef, 0x00, 0x09, 0x05, 0x82,
+                          0x02, 0xe4, 0x01, 0x40, 0x01, 0xf0, 0x00, 0x40,
+                          0x01, 0xf0, 0x00,
+        0, 0, 0
+};
+static const u8 proscope_start_qvga[] = {
+        0x02, 0x00, 0x11, 0x3c, 0x50, 0x9e, 0x3c, 0x50, 0x00, 0x00, 0x00,
+                          0x00, 0x78, 0x3f, 0x10, 0x02, 0xf2, 0x8f, 0x78,
+                          0x40,
+        0x10, 0x1a, 0x01, 0x06,
+        0x00, 0x03, 0x02, 0xf9, 0x02,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1b, 0x02, 0x00, 0x00,
+        0x10, 0x11, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1d, 0x08, 0xc0, 0x0d, 0x01, 0x20, 0x02, 0xe8, 0x03, 0x00,
+        0x10, 0x0e, 0x01, 0x10,
+        0, 0, 0
+};
+static const u8 proscope_start_vga[] = {
+        0x00, 0x03, 0x02, 0xf9, 0x02,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x7f, 0x02, 0x00, 0x00, 0xdf, 0x01,
+        0x02, 0x00, 0x11, 0x78, 0xa0, 0x8c, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x16, 0x00, 0x00, 0x82, 0x84, 0x00,
+                          0x80,
+        0x10, 0x1a, 0x01, 0x06,
+        0x10, 0x00, 0x01, 0xa1,
+        0x10, 0x1b, 0x02, 0x00, 0x00,
+        0x10, 0x1d, 0x08, 0xc0, 0x0d, 0x01, 0x20, 0x02, 0xe8, 0x03, 0x00,
+        0x10, 0x11, 0x08, 0x00, 0x00, 0x7f, 0x02, 0x00, 0x00, 0xdf, 0x01,
+        0x10, 0x0e, 0x01, 0x10,
+        0x10, 0x41, 0x11, 0x00, 0x10, 0x51, 0x6e, 0x83, 0x93, 0xa1, 0xae,
+                          0xb9, 0xc3, 0xcc, 0xd4, 0xdd, 0xe4, 0xeb, 0xf2,
+                          0xf9,
+        0x10, 0x03, 0x01, 0x00,
+        0, 0, 0
+};
+static const u8 proscope_start_2[] = {
+        0x10, 0x0f, 0x02, 0x0c, 0x0c,
+        0x10, 0x03, 0x01, 0x0c,
+        0x10, 0x41, 0x11, 0x00, 0x10, 0x51, 0x6e, 0x83, 0x93, 0xa1, 0xae,
+                          0xb9, 0xc3, 0xcc, 0xd4, 0xdd, 0xe4, 0xeb, 0xf2,
+                          0xf9,
+        0x10, 0x0b, 0x01, 0x0b,
+        0x10, 0x0d, 0x01, 0x10,
+        0x10, 0x0c, 0x01, 0x1b,
+        0x04, 0x06, 0x01, 0x03,
+        0x04, 0x05, 0x01, 0x21,
+        0x04, 0x04, 0x01, 0x00,
+        0, 0, 0
+};
+
+/* nw800 - hv7121b? (seems pas106) - Divio Chicony TwinkleCam */
+static const u8 twinkle_start[] = {
+        0x04, 0x06, 0x01, 0x44,
+        0x04, 0x06, 0x01, 0x00,
+        0x00, 0x00, 0x40, 0x14, 0x83, 0x00, 0xba, 0x01, 0x10, 0x00, 0x4f,
+                          0xef, 0x00, 0x00, 0x60, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x06, 0x00, 0xfc,
+                          0x01, 0x3e, 0x00, 0x86, 0x00, 0x3e, 0x00, 0x86,
+                          0x00, 0x3e, 0x00, 0x86, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x56, 0x00, 0x9e,
+                          0x00, 0x56, 0x00, 0x9e, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x6e, 0x00, 0xb6, 0x00, 0x6e, 0x00, 0x78,
+                          0x04, 0x6e, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xca, 0x03, 0x46, 0x04, 0xca, 0x03, 0x46,
+                          0x04, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0xf0,
+                          0x00, 0x3e, 0x00, 0xaa, 0x00, 0x88, 0x00, 0x2e,
+        0x00, 0x80, 0x1f, 0xb8, 0x48, 0x0f, 0x04, 0x88, 0x14, 0x68, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0xa8, 0x01, 0x00, 0x03,
+                          0x00, 0x24, 0x01, 0x01, 0x00, 0x16, 0x00, 0x04,
+                          0x00, 0x4b, 0x00, 0x76, 0x00, 0x86, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0x61, 0x00,
+        0x05, 0x00, 0x06, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x06, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0x80, 0x02, 0x20, 0x00, 0x11, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x08,
+                          0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x10, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x00, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1d, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x62,
+                          0x01, 0x24, 0x01, 0x62, 0x01, 0x24, 0x01, 0x20,
+                          0x01, 0x60, 0x01, 0x00, 0x00,
+
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x1f, 0x01,
+        0x04, 0x04, 0x01, 0x10,
+        0x04, 0x04, 0x01, 0x00,
+        0x04, 0x05, 0x01, 0x61,
+        0x04, 0x04, 0x01, 0x01,
+        I2C0, 0x40, 0x0c, 0x02, 0x0c, 0x12, 0x07, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x0a,
+        I2C0, 0x40, 0x02, 0x11, 0x06,
+        I2C0, 0x40, 0x02, 0x14, 0x00,
+        I2C0, 0x40, 0x02, 0x13, 0x01,           /* i2c end */
+        I2C0, 0x40, 0x02, 0x07, 0x01,
+        0x02, 0x00, 0x11, 0x48, 0x58, 0x9e, 0x48, 0x58, 0x00, 0x00, 0x00,
+                          0x00, 0x84, 0x36, 0x05, 0x01, 0xf2, 0x86, 0x65,
+                          0x40,
+        I2C0, 0x40, 0x02, 0x02, 0x0c,
+        I2C0, 0x40, 0x02, 0x13, 0x01,
+        0x10, 0x00, 0x01, 0x01,
+        0x10, 0x8f, 0x0c, 0x62, 0x01, 0x24, 0x01, 0x62, 0x01, 0x24, 0x01,
+                          0x20, 0x01, 0x60, 0x01,
+        I2C0, 0x40, 0x02, 0x05, 0x0f,
+        I2C0, 0x40, 0x02, 0x13, 0x01,
+        I2C0, 0x40, 0x08, 0x08, 0x04, 0x0b, 0x01, 0x01, 0x02, 0x00, 0x17,
+        I2C0, 0x40, 0x03, 0x12, 0x00, 0x01,
+        0x10, 0x11, 0x08, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x1f, 0x01,
+        I2C0, 0x40, 0x02, 0x12, 0x00,
+        I2C0, 0x40, 0x02, 0x0e, 0x00,
+        I2C0, 0x40, 0x02, 0x11, 0x06,
+        0x10, 0x41, 0x11, 0x00, 0x17, 0x3f, 0x69, 0x7b, 0x8c, 0x9a, 0xa7,
+                          0xb3, 0xbf, 0xc9, 0xd3, 0xdd, 0xe6, 0xef, 0xf7,
+                          0xf9,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x0c, 0x0c,
+        0x10, 0x03, 0x01, 0x06,
+        0x10, 0x41, 0x11, 0x00, 0x17, 0x3f, 0x69, 0x7b, 0x8c, 0x9a, 0xa7,
+                          0xb3, 0xbf, 0xc9, 0xd3, 0xdd, 0xe6, 0xef, 0xf7,
+                          0xf9,
+        0x10, 0x0b, 0x01, 0x19,
+        0x10, 0x0d, 0x01, 0x10,
+        0x10, 0x0c, 0x01, 0x0d,
+        0x04, 0x06, 0x01, 0x03,
+        0x04, 0x05, 0x01, 0x61,
+        0x04, 0x04, 0x01, 0x41,
+        0, 0, 0
+};
+
+/* nw802 dvc-v6 */
+static const u8 dvcv6_start[] = {
+        0x04, 0x06, 0x01, 0x06,
+        0x00, 0x00, 0x40, 0x54, 0x96, 0x98, 0xf9, 0x02, 0x18, 0x00, 0x4c,
+                          0x0f, 0x1f, 0x00, 0x0d, 0x02, 0x01, 0x00, 0x19,
+                          0x00, 0x01, 0x00, 0x19, 0x00, 0x01, 0x00, 0x19,
+                          0x00, 0x0b, 0x00, 0x1b, 0x00, 0xc8, 0x00, 0xf4,
+                          0x05, 0xb4, 0x00, 0xcc, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xa2, 0x00, 0xc6, 0x00, 0x60, 0x00, 0xc6,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+        0x00, 0x40, 0x40, 0x00, 0xae, 0x00, 0xd2, 0x00, 0xae, 0x00, 0xd2,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0xa8, 0x00, 0xc0, 0x00, 0x66, 0x00, 0xc0,
+                          0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+                          0x00, 0x0a, 0x00, 0x54, 0x00, 0x0a, 0x00, 0x54,
+                          0x00, 0x10, 0x00, 0x36, 0x00, 0xd2, 0x00, 0xee,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6,
+                          0x00, 0x5d, 0x00, 0xc7, 0x00, 0x7e, 0x00, 0x30,
+        0x00, 0x80, 0x1f, 0x98, 0x43, 0x3f, 0x0d, 0x88, 0x20, 0x80, 0x3f,
+                          0x47, 0xaf, 0x00, 0x00, 0xa8, 0x08, 0x00, 0x11,
+                          0x00, 0x0c, 0x02, 0x0c, 0x00, 0x1c, 0x00, 0x94,
+                          0x00, 0x10, 0x06, 0x24, 0x00, 0x4a, 0x00,
+        0x02, 0x00, 0x12, 0x78, 0xa0, 0x9e, 0x78, 0xa0, 0x00, 0x00, 0x00,
+                          0x00, 0xf0, 0x18, 0x0b, 0x06, 0x62, 0x82, 0xa0,
+                          0x40, 0x20,
+        0x03, 0x00, 0x03, 0x03, 0x00, 0x00,
+        0x04, 0x00, 0x07, 0x01, 0x10, 0x00, 0x00, 0x00, 0xff, 0x00,
+        0x06, 0x00, 0x02, 0x09, 0x99,
+        0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00,
+        0x10, 0x00, 0x40, 0xa0, 0x02, 0x80, 0x00, 0x12, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x08, 0x0a,
+                          0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x49, 0x13, 0x00, 0x00, 0xe0, 0x00, 0x0c,
+                          0x00, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+                          0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08,
+                          0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x06,
+                          0xf7, 0xee, 0x1c, 0x1c, 0xe9, 0xfc, 0x10, 0x80,
+        0x10, 0x40, 0x40, 0x80, 0x00, 0x05, 0x35, 0x5e, 0x78, 0x8b, 0x99,
+                          0xa4, 0xae, 0xb5, 0xbc, 0xc1, 0xc6, 0xc9, 0xcc,
+                          0xcf, 0xd0, 0x00, 0x11, 0x22, 0x32, 0x43, 0x54,
+                          0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3, 0xd2,
+                          0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32, 0x43,
+                          0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3, 0xc3,
+                          0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x11, 0x22, 0x32,
+                          0x43, 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb3,
+        0x10, 0x80, 0x1b, 0xc3, 0xd2, 0xe2, 0xf1, 0xff, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x05, 0x82,
+                          0x02, 0xe4, 0x01, 0x40, 0x01, 0xf0, 0x00, 0x40,
+                          0x01, 0xf0, 0x00,
+        0x00, 0x03, 0x02, 0x94, 0x03,
+        0x00, 0x1d, 0x04, 0x0a, 0x01, 0x28, 0x07,
+        0x00, 0x7b, 0x02, 0xe0, 0x00,
+        0x10, 0x8d, 0x01, 0x00,
+        0x00, 0x09, 0x04, 0x1e, 0x00, 0x0c, 0x02,
+        0x00, 0x91, 0x02, 0x0b, 0x02,
+        0x10, 0x00, 0x01, 0xaf,
+        0x02, 0x00, 0x11, 0x3c, 0x50, 0x8f, 0x3c, 0x50, 0x00, 0x00, 0x00,
+                          0x00, 0x78, 0x3f, 0x3f, 0x06, 0xf2, 0x8f, 0xf0,
+                          0x40,
+        0x10, 0x1a, 0x01, 0x02,
+        0x10, 0x00, 0x01, 0xaf,
+        0x10, 0x85, 0x08, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0xef, 0x00,
+        0x10, 0x1b, 0x02, 0x07, 0x01,
+        0x10, 0x11, 0x08, 0x61, 0x00, 0xe0, 0x00, 0x49, 0x00, 0xa8, 0x00,
+        0x10, 0x1f, 0x06, 0x01, 0x20, 0x02, 0xe8, 0x03, 0x00,
+        0x10, 0x1d, 0x02, 0x40, 0x06,
+        0x10, 0x0e, 0x01, 0x08,
+        0x10, 0x41, 0x11, 0x00, 0x0f, 0x54, 0x6f, 0x82, 0x91, 0x9f, 0xaa,
+                          0xb4, 0xbd, 0xc5, 0xcd, 0xd5, 0xdb, 0xdc, 0xdc,
+                          0xdc,
+        0x10, 0x03, 0x01, 0x00,
+        0x10, 0x0f, 0x02, 0x12, 0x12,
+        0x10, 0x03, 0x01, 0x11,
+        0x10, 0x41, 0x11, 0x00, 0x0f, 0x54, 0x6f, 0x82, 0x91, 0x9f, 0xaa,
+                          0xb4, 0xbd, 0xc5, 0xcd, 0xd5, 0xdb, 0xdc, 0xdc,
+                          0xdc,
+        0x10, 0x0b, 0x01, 0x16,
+        0x10, 0x0d, 0x01, 0x10,
+        0x10, 0x0c, 0x01, 0x1a,
+        0x04, 0x06, 0x01, 0x03,
+        0x04, 0x04, 0x01, 0x00,
+};
+
+static const u8 *webcam_start[] = {
+        [Generic800] = nw800_start,
+        [SpaceCam] = spacecam_start,
+        [SpaceCam2] = spacecam2_start,
+        [Cvideopro] = cvideopro_start,
+        [Dlink350c] = dlink_start,
+        [DS3303u] = ds3303_start,
+        [Kr651us] = kr651_start_1,
+        [Kritter] = kritter_start,
+        [Mustek300] = mustek_start,
+        [Proscope] = proscope_start_1,
+        [Twinkle] = twinkle_start,
+        [DvcV6] = dvcv6_start,
+        [P35u] = nw801_start_1,
+        [Generic802] = nw802_start,
+};
+
+/* -- write a register -- */
+static void reg_w(struct gspca_dev *gspca_dev,
+                        u16 index,
+                        const u8 *data,
+                        int len)
+{
+        struct usb_device *dev = gspca_dev->dev;
+        int ret;
+
+        if (gspca_dev->usb_err < 0)
+                return;
+        if (len == 1)
+                PDEBUG(D_USBO, "SET 00 0000 %04x %02x", index, *data);
+        else
+                PDEBUG(D_USBO, "SET 00 0000 %04x %02x %02x ...",
+                                index, *data, data[1]);
+        memcpy(gspca_dev->usb_buf, data, len);
+        ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+                        0x00,
+                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                        0x00,           /* value */
+                        index,
+                        gspca_dev->usb_buf,
+                        len,
+                        500);
+        if (ret < 0) {
+                err("reg_w err %d", ret);
+                gspca_dev->usb_err = ret;
+        }
+}
+
+/* -- read registers in usb_buf -- */
+static void reg_r(struct gspca_dev *gspca_dev,
+                        u16 index,
+                        int len)
+{
+        struct usb_device *dev = gspca_dev->dev;
+        int ret;
+
+        if (gspca_dev->usb_err < 0)
+                return;
+        ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+                        0x00,
+                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                        0x00, index,
+                        gspca_dev->usb_buf, len, 500);
+        if (ret < 0) {
+                err("reg_r err %d", ret);
+                gspca_dev->usb_err = ret;
+                return;
+        }
+        if (len == 1)
+                PDEBUG(D_USBI, "GET 00 0000 %04x %02x",
+                                index, gspca_dev->usb_buf[0]);
+        else
+                PDEBUG(D_USBI, "GET 00 0000 %04x %02x %02x ..",
+                                index, gspca_dev->usb_buf[0],
+                                gspca_dev->usb_buf[1]);
+}
+
+static void i2c_w(struct gspca_dev *gspca_dev,
+                        u8 i2c_addr,
+                        const u8 *data,
+                        int len)
+{
+        u8 val[2];
+        int i;
+
+        reg_w(gspca_dev, 0x0600, data + 1, len - 1);
+        reg_w(gspca_dev, 0x0600, data, len);
+        val[0] = len;
+        val[1] = i2c_addr;
+        reg_w(gspca_dev, 0x0502, val, 2);
+        val[0] = 0x01;
+        reg_w(gspca_dev, 0x0501, val, 1);
+        for (i = 5; --i >= 0; ) {
+                msleep(4);
+                reg_r(gspca_dev, 0x0505, 1);
+                if (gspca_dev->usb_err < 0)
+                        return;
+                if (gspca_dev->usb_buf[0] == 0)
+                        return;
+        }
+        gspca_dev->usb_err = -ETIME;
+}
+
+static void reg_w_buf(struct gspca_dev *gspca_dev,
+                        const u8 *cmd)
+{
+        u16 reg;
+        int len;
+
+        for (;;) {
+                reg = *cmd++ << 8;
+                reg += *cmd++;
+                len = *cmd++;
+                if (len == 0)
+                        break;
+                if (cmd[-3] != I2C0)
+                        reg_w(gspca_dev, reg, cmd, len);
+                else
+                        i2c_w(gspca_dev, reg, cmd, len);
+                cmd += len;
+        }
+}
+
+static int swap_bits(int v)
+{
+        int r, i;
+
+        r = 0;
+        for (i = 0; i < 8; i++) {
+                r <<= 1;
+                if (v & 1)
+                        r++;
+                v >>= 1;
+        }
+        return r;
+}
+
+static void setgain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 val, v[2];
+
+        val = sd->ctrls[GAIN].val;
+        switch (sd->webcam) {
+        case P35u:
+                /* Note the control goes from 0-255 not 0-127, but anything
+                   above 127 just means amplifying noise */
+                val >>= 1;                      /* 0 - 255 -> 0 - 127 */
+                reg_w(gspca_dev, 0x1026, &val, 1);
+                break;
+        case Kr651us:
+                /* 0 - 253 */
+                val = swap_bits(val);
+                v[0] = val << 3;
+                v[1] = val >> 5;
+                reg_w(gspca_dev, 0x101d, v, 2); /* SIF reg0/1 (AGC) */
+                break;
+        }
+}
+
+static void setexposure(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s16 val;
+        u8 v[2];
+
+        val = sd->ctrls[EXPOSURE].val;
+        switch (sd->webcam) {
+        case P35u:
+                v[0] = ((9 - val) << 3) | 0x01;
+                reg_w(gspca_dev, 0x1019, v, 1);
+                break;
+        case Cvideopro:
+        case DvcV6:
+        case Kritter:
+        case Kr651us:
+                v[0] = val;
+                v[1] = val >> 8;
+                reg_w(gspca_dev, 0x101b, v, 2);
+                break;
+        }
+}
+
+static void setautogain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int w, h;
+
+        if (gspca_dev->ctrl_dis & (1 << AUTOGAIN))
+                return;
+        if (!sd->ctrls[AUTOGAIN].val) {
+                sd->ag_cnt = -1;
+                return;
+        }
+        sd->ag_cnt = AG_CNT_START;
+
+        reg_r(gspca_dev, 0x1004, 1);
+        if (gspca_dev->usb_buf[0] & 0x04) {     /* if AE_FULL_FRM */
+                sd->ae_res = gspca_dev->width * gspca_dev->height;
+        } else {                                /* get the AE window size */
+                reg_r(gspca_dev, 0x1011, 8);
+                w = (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0]
+                  - (gspca_dev->usb_buf[3] << 8) - gspca_dev->usb_buf[2];
+                h = (gspca_dev->usb_buf[5] << 8) + gspca_dev->usb_buf[4]
+                  - (gspca_dev->usb_buf[7] << 8) - gspca_dev->usb_buf[6];
+                sd->ae_res = h * w;
+                if (sd->ae_res == 0)
+                        sd->ae_res = gspca_dev->width * gspca_dev->height;
+        }
+}
+
+static int nw802_test_reg(struct gspca_dev *gspca_dev,
+                        u16 index,
+                        u8 value)
+{
+        /* write the value */
+        reg_w(gspca_dev, index, &value, 1);
+
+        /* read it */
+        reg_r(gspca_dev, index, 1);
+
+        return gspca_dev->usb_buf[0] == value;
+}
+
+/* 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;
+
+        if ((unsigned) webcam >= NWEBCAMS)
+                webcam = 0;
+        sd->webcam = webcam;
+        gspca_dev->cam.reverse_alts = 1;
+        gspca_dev->cam.ctrls = sd->ctrls;
+        sd->ag_cnt = -1;
+
+        /*
+         * Autodetect sequence inspired from some log.
+         * We try to detect what registers exist or not.
+         * If 0x0500 does not exist => NW802
+         * If it does, test 0x109b. If it doesn't exist,
+         * then it's a NW801. Else, a NW800
+         * If a et31x110 (nw800 and 06a5:d800)
+         *      get the sensor ID
+         */
+        if (!nw802_test_reg(gspca_dev, 0x0500, 0x55)) {
+                sd->bridge = BRIDGE_NW802;
+                if (sd->webcam == Generic800)
+                        sd->webcam = Generic802;
+        } else if (!nw802_test_reg(gspca_dev, 0x109b, 0xaa)) {
+                sd->bridge = BRIDGE_NW801;
+                if (sd->webcam == Generic800)
+                        sd->webcam = P35u;
+        } else if (id->idVendor == 0x06a5 && id->idProduct == 0xd800) {
+                reg_r(gspca_dev, 0x0403, 1);            /* GPIO */
+                PDEBUG(D_PROBE, "et31x110 sensor type %02x",
+                                gspca_dev->usb_buf[0]);
+                switch (gspca_dev->usb_buf[0] >> 1) {
+                case 0x00:                              /* ?? */
+                        if (sd->webcam == Generic800)
+                                sd->webcam = SpaceCam;
+                        break;
+                case 0x01:                              /* Hynix? */
+                        if (sd->webcam == Generic800)
+                                sd->webcam = Twinkle;
+                        break;
+                case 0x0a:                              /* Pixart */
+                        if (sd->webcam == Generic800)
+                                sd->webcam = SpaceCam2;
+                        break;
+                }
+        }
+        if (webcam_chip[sd->webcam] != sd->bridge) {
+                err("Bad webcam type %d for NW80%d", sd->webcam, sd->bridge);
+                gspca_dev->usb_err = -ENODEV;
+                return gspca_dev->usb_err;
+        }
+        PDEBUG(D_PROBE, "Bridge nw80%d - type: %d", sd->bridge, sd->webcam);
+
+        if (sd->bridge == BRIDGE_NW800) {
+                switch (sd->webcam) {
+                case DS3303u:
+                        gspca_dev->cam.cam_mode = cif_mode;     /* qvga */
+                        break;
+                default:
+                        gspca_dev->cam.cam_mode = &cif_mode[1]; /* cif */
+                        break;
+                }
+                gspca_dev->cam.nmodes = 1;
+        } else {
+                gspca_dev->cam.cam_mode = vga_mode;
+                switch (sd->webcam) {
+                case Kr651us:
+                case Proscope:
+                case P35u:
+                        gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
+                        break;
+                default:
+                        gspca_dev->cam.nmodes = 1;      /* qvga only */
+                        break;
+                }
+        }
+        switch (sd->webcam) {
+        case P35u:
+/*              sd->ctrls[EXPOSURE].max = 9;
+ *              sd->ctrls[EXPOSURE].def = 9; */
+                /* coarse expo auto gain function gain minimum, to avoid
+                 * a large settings jump the first auto adjustment */
+                sd->ctrls[GAIN].def = 255 / 5 * 2;
+                break;
+        case Cvideopro:
+        case DvcV6:
+        case Kritter:
+                gspca_dev->ctrl_dis = (1 << GAIN) | (1 << AUTOGAIN);
+                /* fall thru */
+        case Kr651us:
+                sd->ctrls[EXPOSURE].max = 315;
+                sd->ctrls[EXPOSURE].def = 150;
+                break;
+        default:
+                gspca_dev->ctrl_dis = (1 << GAIN) | (1 << EXPOSURE)
+                                         | (1 << AUTOGAIN);
+                break;
+        }
+
+#if AUTOGAIN_DEF
+        if (!(gspca_dev->ctrl_dis & (1 << AUTOGAIN)))
+                gspca_dev->ctrl_inac = (1 << GAIN) | (1 << EXPOSURE);
+#endif
+        return gspca_dev->usb_err;
+}
+
+/* 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;
+
+        switch (sd->bridge) {
+        case BRIDGE_NW800:
+                switch (sd->webcam) {
+                case SpaceCam:
+                        reg_w_buf(gspca_dev, spacecam_init);
+                        break;
+                default:
+                        reg_w_buf(gspca_dev, nw800_init);
+                        break;
+                }
+                break;
+        default:
+                switch (sd->webcam) {
+                case Mustek300:
+                case P35u:
+                case Proscope:
+                        reg_w_buf(gspca_dev, proscope_init);
+                        break;
+                }
+                break;
+        }
+        return gspca_dev->usb_err;
+}
+
+/* -- start the camera -- */
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        const u8 *cmd;
+
+        cmd = webcam_start[sd->webcam];
+        reg_w_buf(gspca_dev, cmd);
+        switch (sd->webcam) {
+        case P35u:
+                if (gspca_dev->width == 320)
+                        reg_w_buf(gspca_dev, nw801_start_qvga);
+                else
+                        reg_w_buf(gspca_dev, nw801_start_vga);
+                reg_w_buf(gspca_dev, nw801_start_2);
+                break;
+        case Kr651us:
+                if (gspca_dev->width == 320)
+                        reg_w_buf(gspca_dev, kr651_start_qvga);
+                else
+                        reg_w_buf(gspca_dev, kr651_start_vga);
+                reg_w_buf(gspca_dev, kr651_start_2);
+                break;
+        case Proscope:
+                if (gspca_dev->width == 320)
+                        reg_w_buf(gspca_dev, proscope_start_qvga);
+                else
+                        reg_w_buf(gspca_dev, proscope_start_vga);
+                reg_w_buf(gspca_dev, proscope_start_2);
+                break;
+        }
+
+        setgain(gspca_dev);
+        setexposure(gspca_dev);
+        setautogain(gspca_dev);
+        sd->exp_too_high_cnt = 0;
+        sd->exp_too_low_cnt = 0;
+        return gspca_dev->usb_err;
+}
+
+static void sd_stopN(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 value;
+
+        /* 'go' off */
+        if (sd->bridge != BRIDGE_NW801) {
+                value = 0x02;
+                reg_w(gspca_dev, 0x0406, &value, 1);
+        }
+
+        /* LED off */
+        switch (sd->webcam) {
+        case Cvideopro:
+        case Kr651us:
+        case DvcV6:
+        case Kritter:
+                value = 0xff;
+                break;
+        case Dlink350c:
+                value = 0x21;
+                break;
+        case SpaceCam:
+        case SpaceCam2:
+        case Proscope:
+        case Twinkle:
+                value = 0x01;
+                break;
+        default:
+                return;
+        }
+        reg_w(gspca_dev, 0x0404, &value, 1);
+}
+
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,                       /* isoc packet */
+                        int len)                        /* iso packet length */
+{
+        /*
+         * frame header = '00 00 hh ww ss xx ff ff'
+         * with:
+         *      - 'hh': height / 4
+         *      - 'ww': width / 4
+         *      - 'ss': frame sequence number c0..dd
+         */
+        if (data[0] == 0x00 && data[1] == 0x00
+         && data[6] == 0xff && data[7] == 0xff) {
+                gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
+                gspca_frame_add(gspca_dev, FIRST_PACKET, data + 8, len - 8);
+        } else {
+                gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
+        }
+}
+
+static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->ctrls[AUTOGAIN].val = val;
+        if (val)
+                gspca_dev->ctrl_inac = (1 << GAIN) | (1 << EXPOSURE);
+        else
+                gspca_dev->ctrl_inac = 0;
+        if (gspca_dev->streaming)
+                setautogain(gspca_dev);
+        return gspca_dev->usb_err;
+}
+
+#include "autogain_functions.h"
+
+static void do_autogain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int luma;
+
+        if (sd->ag_cnt < 0)
+                return;
+        if (--sd->ag_cnt >= 0)
+                return;
+        sd->ag_cnt = AG_CNT_START;
+
+        /* get the average luma */
+        reg_r(gspca_dev, sd->bridge == BRIDGE_NW801 ? 0x080d : 0x080c, 4);
+        luma = (gspca_dev->usb_buf[3] << 24) + (gspca_dev->usb_buf[2] << 16)
+                + (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
+        luma /= sd->ae_res;
+
+        switch (sd->webcam) {
+        case P35u:
+                coarse_grained_expo_autogain(gspca_dev, luma, 100, 5);
+                break;
+        default:
+                auto_gain_n_exposure(gspca_dev, luma, 100, 5, 230, 0);
+                break;
+        }
+}
+
+/* V4L2 controls supported by the driver */
+static const struct ctrl sd_ctrls[NCTRLS] = {
+[GAIN] = {
+            {
+                .id      = V4L2_CID_GAIN,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Gain",
+                .minimum = 0,
+                .maximum = 253,
+                .step    = 1,
+                .default_value = 128
+            },
+            .set_control = setgain
+        },
+[EXPOSURE] = {
+            {
+                .id      = V4L2_CID_EXPOSURE,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Exposure",
+                .minimum = 0,
+                .maximum = 9,
+                .step    = 1,
+                .default_value = 9
+            },
+            .set_control = setexposure
+        },
+[AUTOGAIN] = {
+            {
+                .id      = V4L2_CID_AUTOGAIN,
+                .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                .name    = "Auto Gain",
+                .minimum = 0,
+                .maximum = 1,
+                .step    = 1,
+                .default_value = AUTOGAIN_DEF,
+                .flags   = V4L2_CTRL_FLAG_UPDATE
+            },
+            .set = sd_setautogain
+        },
+};
+
+/* 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,
+        .dq_callback = do_autogain,
+};
+
+/* -- module initialisation -- */
+static const struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x046d, 0xd001)},
+        {USB_DEVICE(0x0502, 0xd001)},
+        {USB_DEVICE(0x052b, 0xd001)},
+        {USB_DEVICE(0x055f, 0xd001)},
+        {USB_DEVICE(0x06a5, 0x0000)},
+        {USB_DEVICE(0x06a5, 0xd001)},
+        {USB_DEVICE(0x06a5, 0xd800)},
+        {USB_DEVICE(0x06be, 0xd001)},
+        {USB_DEVICE(0x0728, 0xd001)},
+        {}
+};
+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)
+{
+        return usb_register(&sd_driver);
+}
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
+
+module_param(webcam, int, 0644);
+MODULE_PARM_DESC(webcam,
+        "Webcam type\n"
+        "0: generic\n"
+        "1: Trust 120 SpaceCam\n"
+        "2: other Trust 120 SpaceCam\n"
+        "3: Conceptronic Video Pro\n"
+        "4: D-link dru-350c\n"
+        "5: Plustek Opticam 500U\n"
+        "6: Panasonic GP-KR651US\n"
+        "7: iRez Kritter\n"
+        "8: Mustek Wcam 300 mini\n"
+        "9: Scalar USB Microscope M2 (Proscope)\n"
+        "10: Divio Chicony TwinkleCam\n"
+        "11: DVC-V6\n");
diff --git a/drivers/media/video/gspca/ov519.c b/drivers/media/video/gspca/ov519.c
index 2b2cbdbf03fe..057e287b9152 100644
--- a/drivers/media/video/gspca/ov519.c
+++ b/drivers/media/video/gspca/ov519.c
@@ -1,7 +1,7 @@
 /**
  * OV519 driver
  *
- * Copyright (C) 2008 Jean-Francois Moine (http://moinejf.free.fr)
+ * Copyright (C) 2008-2011 Jean-François Moine <moinejf@free.fr>
  * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com>
  *
  * This module is adapted from the ov51x-jpeg package, which itself
@@ -57,18 +57,34 @@ static int frame_rate;
  * are getting "Failed to read sensor ID..." */
 static int i2c_detect_tries = 10;
 
+/* controls */
+enum e_ctrl {
+        BRIGHTNESS,
+        CONTRAST,
+        EXPOSURE,
+        COLORS,
+        HFLIP,
+        VFLIP,
+        AUTOBRIGHT,
+        AUTOGAIN,
+        FREQ,
+        NCTRL           /* number of controls */
+};
+
 /* ov519 device descriptor */
 struct sd {
         struct gspca_dev gspca_dev;             /* !! must be the first item */
 
-        __u8 packet_nr;
+        struct gspca_ctrl ctrls[NCTRL];
+
+        u8 packet_nr;
 
         char bridge;
 #define BRIDGE_OV511            0
 #define BRIDGE_OV511PLUS        1
 #define BRIDGE_OV518            2
 #define BRIDGE_OV518PLUS        3
-#define BRIDGE_OV519            4
+#define BRIDGE_OV519            4               /* = ov530 */
 #define BRIDGE_OVFX2            5
 #define BRIDGE_W9968CF          6
 #define BRIDGE_MASK             7
@@ -80,49 +96,45 @@ struct sd {
         char snapshot_needs_reset;
 
         /* Determined by sensor type */
-        __u8 sif;
-
-        __u8 brightness;
-        __u8 contrast;
-        __u8 colors;
-        __u8 hflip;
-        __u8 vflip;
-        __u8 autobrightness;
-        __u8 freq;
-        __u8 quality;
+        u8 sif;
+
+        u8 quality;
 #define QUALITY_MIN 50
 #define QUALITY_MAX 70
 #define QUALITY_DEF 50
 
-        __u8 stopped;           /* Streaming is temporarily paused */
-        __u8 first_frame;
-
-        __u8 frame_rate;        /* current Framerate */
-        __u8 clockdiv;          /* clockdiv override */
-
-        char sensor;            /* Type of image sensor chip (SEN_*) */
-#define SEN_UNKNOWN 0
-#define SEN_OV2610 1
-#define SEN_OV3610 2
-#define SEN_OV6620 3
-#define SEN_OV6630 4
-#define SEN_OV66308AF 5
-#define SEN_OV7610 6
-#define SEN_OV7620 7
-#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 stopped;             /* Streaming is temporarily paused */
+        u8 first_frame;
+
+        u8 frame_rate;          /* current Framerate */
+        u8 clockdiv;            /* clockdiv override */
+
+        s8 sensor;              /* Type of image sensor chip (SEN_*) */
 
         u8 sensor_addr;
-        int sensor_width;
-        int sensor_height;
-        int sensor_reg_cache[256];
+        u16 sensor_width;
+        u16 sensor_height;
+        s16 sensor_reg_cache[256];
 
         u8 jpeg_hdr[JPEG_HDR_SZ];
 };
+enum sensors {
+        SEN_OV2610,
+        SEN_OV2610AE,
+        SEN_OV3610,
+        SEN_OV6620,
+        SEN_OV6630,
+        SEN_OV66308AF,
+        SEN_OV7610,
+        SEN_OV7620,
+        SEN_OV7620AE,
+        SEN_OV7640,
+        SEN_OV7648,
+        SEN_OV7660,
+        SEN_OV7670,
+        SEN_OV76BE,
+        SEN_OV8610,
+};
 
 /* Note this is a bit of a hack, but the w9968cf driver needs the code for all
    the ov sensors which is already present here. When we have the time we
@@ -130,29 +142,18 @@ struct sd {
 #include "w996Xcf.c"
 
 /* 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);
-static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
-static int sd_setautobrightness(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getautobrightness(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 void setbrightness(struct gspca_dev *gspca_dev);
 static void setcontrast(struct gspca_dev *gspca_dev);
+static void setexposure(struct gspca_dev *gspca_dev);
 static void setcolors(struct gspca_dev *gspca_dev);
-static void setautobrightness(struct sd *sd);
-static void setfreq(struct sd *sd);
+static void sethvflip(struct gspca_dev *gspca_dev);
+static void setautobright(struct gspca_dev *gspca_dev);
+static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
+static void setfreq(struct gspca_dev *gspca_dev);
+static void setfreq_i(struct sd *sd);
 
 static const struct ctrl sd_ctrls[] = {
-#define BRIGHTNESS_IDX 0
-        {
+[BRIGHTNESS] = {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -160,14 +161,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define BRIGHTNESS_DEF 127
-                .default_value = BRIGHTNESS_DEF,
+                .default_value = 127,
             },
-            .set = sd_setbrightness,
-            .get = sd_getbrightness,
+            .set_control = setbrightness,
         },
-#define CONTRAST_IDX 1
-        {
+[CONTRAST] = {
             {
                 .id      = V4L2_CID_CONTRAST,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -175,14 +173,23 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define CONTRAST_DEF 127
-                .default_value = CONTRAST_DEF,
+                .default_value = 127,
+            },
+            .set_control = setcontrast,
+        },
+[EXPOSURE] = {
+            {
+                .id      = V4L2_CID_EXPOSURE,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Exposure",
+                .minimum = 0,
+                .maximum = 255,
+                .step    = 1,
+                .default_value = 127,
             },
-            .set = sd_setcontrast,
-            .get = sd_getcontrast,
+            .set_control = setexposure,
         },
-#define COLOR_IDX 2
-        {
+[COLORS] = {
             {
                 .id      = V4L2_CID_SATURATION,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -190,15 +197,12 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define COLOR_DEF 127
-                .default_value = COLOR_DEF,
+                .default_value = 127,
             },
-            .set = sd_setcolors,
-            .get = sd_getcolors,
+            .set_control = setcolors,
         },
-/* The flip controls work with ov7670 only */
-#define HFLIP_IDX 3
-        {
+/* The flip controls work for sensors ov7660 and ov7670 only */
+[HFLIP] = {
             {
                 .id      = V4L2_CID_HFLIP,
                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -206,14 +210,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-#define HFLIP_DEF 0
-                .default_value = HFLIP_DEF,
+                .default_value = 0,
             },
-            .set = sd_sethflip,
-            .get = sd_gethflip,
+            .set_control = sethvflip,
         },
-#define VFLIP_IDX 4
-        {
+[VFLIP] = {
             {
                 .id      = V4L2_CID_VFLIP,
                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -221,14 +222,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-#define VFLIP_DEF 0
-                .default_value = VFLIP_DEF,
+                .default_value = 0,
             },
-            .set = sd_setvflip,
-            .get = sd_getvflip,
+            .set_control = sethvflip,
         },
-#define AUTOBRIGHT_IDX 5
-        {
+[AUTOBRIGHT] = {
             {
                 .id      = V4L2_CID_AUTOBRIGHTNESS,
                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -236,44 +234,114 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-#define AUTOBRIGHT_DEF 1
-                .default_value = AUTOBRIGHT_DEF,
+                .default_value = 1,
             },
-            .set = sd_setautobrightness,
-            .get = sd_getautobrightness,
+            .set_control = setautobright,
         },
-#define FREQ_IDX 6
-        {
+[AUTOGAIN] = {
             {
-                .id      = V4L2_CID_POWER_LINE_FREQUENCY,
-                .type    = V4L2_CTRL_TYPE_MENU,
-                .name    = "Light frequency filter",
+                .id      = V4L2_CID_AUTOGAIN,
+                .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                .name    = "Auto Gain",
                 .minimum = 0,
-                .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
+                .maximum = 1,
                 .step    = 1,
-#define FREQ_DEF 0
-                .default_value = FREQ_DEF,
+                .default_value = 1,
+                .flags   = V4L2_CTRL_FLAG_UPDATE
             },
-            .set = sd_setfreq,
-            .get = sd_getfreq,
+            .set = sd_setautogain,
         },
-#define OV7670_FREQ_IDX 7
-        {
+[FREQ] = {
             {
                 .id      = V4L2_CID_POWER_LINE_FREQUENCY,
                 .type    = V4L2_CTRL_TYPE_MENU,
                 .name    = "Light frequency filter",
                 .minimum = 0,
-                .maximum = 3,   /* 0: 0, 1: 50Hz, 2:60Hz 3: Auto Hz */
+                .maximum = 2,   /* 0: no flicker, 1: 50Hz, 2:60Hz, 3: auto */
                 .step    = 1,
-#define OV7670_FREQ_DEF 3
-                .default_value = OV7670_FREQ_DEF,
+                .default_value = 0,
             },
-            .set = sd_setfreq,
-            .get = sd_getfreq,
+            .set_control = setfreq,
         },
 };
 
+/* table of the disabled controls */
+static const unsigned ctrl_dis[] = {
+[SEN_OV2610] =          ((1 << NCTRL) - 1)      /* no control */
+                        ^ ((1 << EXPOSURE)      /* but exposure */
+                         | (1 << AUTOGAIN)),    /* and autogain */
+
+[SEN_OV2610AE] =        ((1 << NCTRL) - 1)      /* no control */
+                        ^ ((1 << EXPOSURE)      /* but exposure */
+                         | (1 << AUTOGAIN)),    /* and autogain */
+
+[SEN_OV3610] =          (1 << NCTRL) - 1,       /* no control */
+
+[SEN_OV6620] =          (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV6630] =          (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV66308AF] =       (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV7610] =          (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV7620] =          (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV7620AE] =        (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV7640] =          (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << AUTOBRIGHT) |
+                        (1 << CONTRAST) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV7648] =          (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << AUTOBRIGHT) |
+                        (1 << CONTRAST) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV7660] =          (1 << AUTOBRIGHT) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV7670] =          (1 << COLORS) |
+                        (1 << AUTOBRIGHT) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV76BE] =          (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN),
+
+[SEN_OV8610] =          (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << EXPOSURE) |
+                        (1 << AUTOGAIN) |
+                        (1 << FREQ),
+};
+
 static const struct v4l2_pix_format ov519_vga_mode[] = {
         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
                 .bytesperline = 320,
@@ -313,7 +381,7 @@ static const struct v4l2_pix_format ov519_sif_mode[] = {
    larger then necessary, however they need to be this big as the ov511 /
    ov518 always fills the entire isoc frame, using 0 padding bytes when
    it doesn't have any data. So with low framerates the amount of data
-   transfered can become quite large (libv4l will remove all the 0 padding
+   transferred can become quite large (libv4l will remove all the 0 padding
    in userspace). */
 static const struct v4l2_pix_format ov518_vga_mode[] = {
         {320, 240, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
@@ -420,6 +488,11 @@ static const struct v4l2_pix_format ovfx2_cif_mode[] = {
                 .priv = 0},
 };
 static const struct v4l2_pix_format ovfx2_ov2610_mode[] = {
+        {800, 600, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
+                .bytesperline = 800,
+                .sizeimage = 800 * 600,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 1},
         {1600, 1200, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
                 .bytesperline = 1600,
                 .sizeimage = 1600 * 1200,
@@ -453,15 +526,14 @@ static const struct v4l2_pix_format ovfx2_ov3610_mode[] = {
                 .priv = 0},
 };
 
-
 /* Registers common to OV511 / OV518 */
 #define R51x_FIFO_PSIZE                 0x30    /* 2 bytes wide w/ OV518(+) */
-#define R51x_SYS_RESET                  0x50
+#define R51x_SYS_RESET                  0x50
         /* Reset type flags */
         #define OV511_RESET_OMNICE      0x08
-#define R51x_SYS_INIT                   0x53
+#define R51x_SYS_INIT                   0x53
 #define R51x_SYS_SNAP                   0x52
-#define R51x_SYS_CUST_ID                0x5F
+#define R51x_SYS_CUST_ID                0x5f
 #define R51x_COMP_LUT_BEGIN             0x80
 
 /* OV511 Camera interface register numbers */
@@ -476,13 +548,12 @@ static const struct v4l2_pix_format ovfx2_ov3610_mode[] = {
 #define R511_CAM_OPTS                   0x18
 
 #define R511_SNAP_FRAME                 0x19
-#define R511_SNAP_PXCNT                 0x1A
-#define R511_SNAP_LNCNT                 0x1B
-#define R511_SNAP_PXDIV                 0x1C
-#define R511_SNAP_LNDIV                 0x1D
-#define R511_SNAP_UV_EN                 0x1E
-#define R511_SNAP_UV_EN                 0x1E
-#define R511_SNAP_OPTS                  0x1F
+#define R511_SNAP_PXCNT                 0x1a
+#define R511_SNAP_LNCNT                 0x1b
+#define R511_SNAP_PXDIV                 0x1c
+#define R511_SNAP_LNDIV                 0x1d
+#define R511_SNAP_UV_EN                 0x1e
+#define R511_SNAP_OPTS                  0x1f
 
 #define R511_DRAM_FLOW_CTL              0x20
 #define R511_FIFO_OPTS                  0x31
@@ -507,13 +578,14 @@ static const struct v4l2_pix_format ovfx2_ov3610_mode[] = {
 #define OV519_R25_FORMAT                0x25
 
 /* OV519 System Controller register numbers */
-#define OV519_SYS_RESET1 0x51
-#define OV519_SYS_EN_CLK1 0x54
+#define OV519_R51_RESET1                0x51
+#define OV519_R54_EN_CLK1               0x54
+#define OV519_R57_SNAPSHOT              0x57
 
 #define OV519_GPIO_DATA_OUT0            0x71
 #define OV519_GPIO_IO_CTRL0             0x72
 
-#define OV511_ENDPOINT_ADDRESS  1       /* Isoc endpoint number */
+/*#define OV511_ENDPOINT_ADDRESS 1       * Isoc endpoint number */
 
 /*
  * The FX2 chip does not give us a zero length read at end of frame.
@@ -537,6 +609,7 @@ static const struct v4l2_pix_format ovfx2_ov3610_mode[] = {
  * buffers, there are some pretty strict real time constraints for
  * isochronous transfer for larger frame sizes).
  */
+/*jfm: this value does not work for 800x600 - see isoc_init */
 #define OVFX2_BULK_SIZE (13 * 4096)
 
 /* I2C registers */
@@ -567,90 +640,107 @@ static const struct v4l2_pix_format ovfx2_ov3610_mode[] = {
 #define OV7610_REG_ID_LOW       0x1d    /* manufacturer ID LSB */
 #define OV7610_REG_COM_I        0x29    /* misc settings */
 
-/* OV7670 registers */
-#define OV7670_REG_GAIN        0x00    /* Gain lower 8 bits (rest in vref) */
-#define OV7670_REG_BLUE        0x01    /* blue gain */
-#define OV7670_REG_RED         0x02    /* red gain */
-#define OV7670_REG_VREF        0x03    /* Pieces of GAIN, VSTART, VSTOP */
-#define OV7670_REG_COM1        0x04    /* Control 1 */
-#define OV7670_REG_AECHH       0x07    /* AEC MS 5 bits */
-#define OV7670_REG_COM3        0x0c    /* Control 3 */
-#define OV7670_REG_COM4        0x0d    /* Control 4 */
-#define OV7670_REG_COM5        0x0e    /* All "reserved" */
-#define OV7670_REG_COM6        0x0f    /* Control 6 */
-#define OV7670_REG_AECH        0x10    /* More bits of AEC value */
-#define OV7670_REG_CLKRC       0x11    /* Clock control */
-#define OV7670_REG_COM7        0x12    /* Control 7 */
-#define   OV7670_COM7_FMT_VGA    0x00
-#define   OV7670_COM7_YUV        0x00    /* YUV */
-#define   OV7670_COM7_FMT_QVGA   0x10    /* QVGA format */
-#define   OV7670_COM7_FMT_MASK   0x38
-#define   OV7670_COM7_RESET      0x80    /* Register reset */
-#define OV7670_REG_COM8        0x13    /* Control 8 */
-#define   OV7670_COM8_AEC        0x01    /* Auto exposure enable */
-#define   OV7670_COM8_AWB        0x02    /* White balance enable */
-#define   OV7670_COM8_AGC        0x04    /* Auto gain enable */
-#define   OV7670_COM8_BFILT      0x20    /* Band filter enable */
-#define   OV7670_COM8_AECSTEP    0x40    /* Unlimited AEC step size */
-#define   OV7670_COM8_FASTAEC    0x80    /* Enable fast AGC/AEC */
-#define OV7670_REG_COM9        0x14    /* Control 9  - gain ceiling */
-#define OV7670_REG_COM10       0x15    /* Control 10 */
-#define OV7670_REG_HSTART      0x17    /* Horiz start high bits */
-#define OV7670_REG_HSTOP       0x18    /* Horiz stop high bits */
-#define OV7670_REG_VSTART      0x19    /* Vert start high bits */
-#define OV7670_REG_VSTOP       0x1a    /* Vert stop high bits */
-#define OV7670_REG_MVFP        0x1e    /* Mirror / vflip */
-#define   OV7670_MVFP_VFLIP      0x10    /* vertical flip */
-#define   OV7670_MVFP_MIRROR     0x20    /* Mirror image */
-#define OV7670_REG_AEW         0x24    /* AGC upper limit */
-#define OV7670_REG_AEB         0x25    /* AGC lower limit */
-#define OV7670_REG_VPT         0x26    /* AGC/AEC fast mode op region */
-#define OV7670_REG_HREF        0x32    /* HREF pieces */
-#define OV7670_REG_TSLB        0x3a    /* lots of stuff */
-#define OV7670_REG_COM11       0x3b    /* Control 11 */
-#define   OV7670_COM11_EXP       0x02
-#define   OV7670_COM11_HZAUTO    0x10    /* Auto detect 50/60 Hz */
-#define OV7670_REG_COM12       0x3c    /* Control 12 */
-#define OV7670_REG_COM13       0x3d    /* Control 13 */
-#define   OV7670_COM13_GAMMA     0x80    /* Gamma enable */
-#define   OV7670_COM13_UVSAT     0x40    /* UV saturation auto adjustment */
-#define OV7670_REG_COM14       0x3e    /* Control 14 */
-#define OV7670_REG_EDGE        0x3f    /* Edge enhancement factor */
-#define OV7670_REG_COM15       0x40    /* Control 15 */
-#define   OV7670_COM15_R00FF     0xc0    /*            00 to FF */
-#define OV7670_REG_COM16       0x41    /* Control 16 */
-#define   OV7670_COM16_AWBGAIN   0x08    /* AWB gain enable */
-#define OV7670_REG_BRIGHT      0x55    /* Brightness */
-#define OV7670_REG_CONTRAS     0x56    /* Contrast control */
-#define OV7670_REG_GFIX        0x69    /* Fix gain control */
-#define OV7670_REG_RGB444      0x8c    /* RGB 444 control */
-#define OV7670_REG_HAECC1      0x9f    /* Hist AEC/AGC control 1 */
-#define OV7670_REG_HAECC2      0xa0    /* Hist AEC/AGC control 2 */
-#define OV7670_REG_BD50MAX     0xa5    /* 50hz banding step limit */
-#define OV7670_REG_HAECC3      0xa6    /* Hist AEC/AGC control 3 */
-#define OV7670_REG_HAECC4      0xa7    /* Hist AEC/AGC control 4 */
-#define OV7670_REG_HAECC5      0xa8    /* Hist AEC/AGC control 5 */
-#define OV7670_REG_HAECC6      0xa9    /* Hist AEC/AGC control 6 */
-#define OV7670_REG_HAECC7      0xaa    /* Hist AEC/AGC control 7 */
-#define OV7670_REG_BD60MAX     0xab    /* 60hz banding step limit */
+/* OV7660 and OV7670 registers */
+#define OV7670_R00_GAIN         0x00    /* Gain lower 8 bits (rest in vref) */
+#define OV7670_R01_BLUE         0x01    /* blue gain */
+#define OV7670_R02_RED          0x02    /* red gain */
+#define OV7670_R03_VREF         0x03    /* Pieces of GAIN, VSTART, VSTOP */
+#define OV7670_R04_COM1         0x04    /* Control 1 */
+/*#define OV7670_R07_AECHH      0x07     * AEC MS 5 bits */
+#define OV7670_R0C_COM3         0x0c    /* Control 3 */
+#define OV7670_R0D_COM4         0x0d    /* Control 4 */
+#define OV7670_R0E_COM5         0x0e    /* All "reserved" */
+#define OV7670_R0F_COM6         0x0f    /* Control 6 */
+#define OV7670_R10_AECH         0x10    /* More bits of AEC value */
+#define OV7670_R11_CLKRC        0x11    /* Clock control */
+#define OV7670_R12_COM7         0x12    /* Control 7 */
+#define   OV7670_COM7_FMT_VGA    0x00
+/*#define   OV7670_COM7_YUV      0x00    * YUV */
+#define   OV7670_COM7_FMT_QVGA   0x10   /* QVGA format */
+#define   OV7670_COM7_FMT_MASK   0x38
+#define   OV7670_COM7_RESET      0x80   /* Register reset */
+#define OV7670_R13_COM8         0x13    /* Control 8 */
+#define   OV7670_COM8_AEC        0x01   /* Auto exposure enable */
+#define   OV7670_COM8_AWB        0x02   /* White balance enable */
+#define   OV7670_COM8_AGC        0x04   /* Auto gain enable */
+#define   OV7670_COM8_BFILT      0x20   /* Band filter enable */
+#define   OV7670_COM8_AECSTEP    0x40   /* Unlimited AEC step size */
+#define   OV7670_COM8_FASTAEC    0x80   /* Enable fast AGC/AEC */
+#define OV7670_R14_COM9         0x14    /* Control 9 - gain ceiling */
+#define OV7670_R15_COM10        0x15    /* Control 10 */
+#define OV7670_R17_HSTART       0x17    /* Horiz start high bits */
+#define OV7670_R18_HSTOP        0x18    /* Horiz stop high bits */
+#define OV7670_R19_VSTART       0x19    /* Vert start high bits */
+#define OV7670_R1A_VSTOP        0x1a    /* Vert stop high bits */
+#define OV7670_R1E_MVFP         0x1e    /* Mirror / vflip */
+#define   OV7670_MVFP_VFLIP      0x10   /* vertical flip */
+#define   OV7670_MVFP_MIRROR     0x20   /* Mirror image */
+#define OV7670_R24_AEW          0x24    /* AGC upper limit */
+#define OV7670_R25_AEB          0x25    /* AGC lower limit */
+#define OV7670_R26_VPT          0x26    /* AGC/AEC fast mode op region */
+#define OV7670_R32_HREF         0x32    /* HREF pieces */
+#define OV7670_R3A_TSLB         0x3a    /* lots of stuff */
+#define OV7670_R3B_COM11        0x3b    /* Control 11 */
+#define   OV7670_COM11_EXP       0x02
+#define   OV7670_COM11_HZAUTO    0x10   /* Auto detect 50/60 Hz */
+#define OV7670_R3C_COM12        0x3c    /* Control 12 */
+#define OV7670_R3D_COM13        0x3d    /* Control 13 */
+#define   OV7670_COM13_GAMMA     0x80   /* Gamma enable */
+#define   OV7670_COM13_UVSAT     0x40   /* UV saturation auto adjustment */
+#define OV7670_R3E_COM14        0x3e    /* Control 14 */
+#define OV7670_R3F_EDGE         0x3f    /* Edge enhancement factor */
+#define OV7670_R40_COM15        0x40    /* Control 15 */
+/*#define   OV7670_COM15_R00FF   0xc0    *      00 to FF */
+#define OV7670_R41_COM16        0x41    /* Control 16 */
+#define   OV7670_COM16_AWBGAIN   0x08   /* AWB gain enable */
+/* end of ov7660 common registers */
+#define OV7670_R55_BRIGHT       0x55    /* Brightness */
+#define OV7670_R56_CONTRAS      0x56    /* Contrast control */
+#define OV7670_R69_GFIX         0x69    /* Fix gain control */
+/*#define OV7670_R8C_RGB444     0x8c     * RGB 444 control */
+#define OV7670_R9F_HAECC1       0x9f    /* Hist AEC/AGC control 1 */
+#define OV7670_RA0_HAECC2       0xa0    /* Hist AEC/AGC control 2 */
+#define OV7670_RA5_BD50MAX      0xa5    /* 50hz banding step limit */
+#define OV7670_RA6_HAECC3       0xa6    /* Hist AEC/AGC control 3 */
+#define OV7670_RA7_HAECC4       0xa7    /* Hist AEC/AGC control 4 */
+#define OV7670_RA8_HAECC5       0xa8    /* Hist AEC/AGC control 5 */
+#define OV7670_RA9_HAECC6       0xa9    /* Hist AEC/AGC control 6 */
+#define OV7670_RAA_HAECC7       0xaa    /* Hist AEC/AGC control 7 */
+#define OV7670_RAB_BD60MAX      0xab    /* 60hz banding step limit */
 
 struct ov_regvals {
-        __u8 reg;
-        __u8 val;
+        u8 reg;
+        u8 val;
 };
 struct ov_i2c_regvals {
-        __u8 reg;
-        __u8 val;
+        u8 reg;
+        u8 val;
 };
 
 /* Settings for OV2610 camera chip */
-static const struct ov_i2c_regvals norm_2610[] =
-{
+static const struct ov_i2c_regvals norm_2610[] = {
         { 0x12, 0x80 }, /* reset */
 };
 
-static const struct ov_i2c_regvals norm_3620b[] =
-{
+static const struct ov_i2c_regvals norm_2610ae[] = {
+        {0x12, 0x80},   /* reset */
+        {0x13, 0xcd},
+        {0x09, 0x01},
+        {0x0d, 0x00},
+        {0x11, 0x80},
+        {0x12, 0x20},   /* 1600x1200 */
+        {0x33, 0x0c},
+        {0x35, 0x90},
+        {0x36, 0x37},
+/* ms-win traces */
+        {0x11, 0x83},   /* clock / 3 ? */
+        {0x2d, 0x00},   /* 60 Hz filter */
+        {0x24, 0xb0},   /* normal colors */
+        {0x25, 0x90},
+        {0x10, 0x43},
+};
+
+static const struct ov_i2c_regvals norm_3620b[] = {
         /*
          * From the datasheet: "Note that after writing to register COMH
          * (0x12) to change the sensor mode, registers related to the
@@ -660,7 +750,6 @@ static const struct ov_i2c_regvals norm_3620b[] =
          * "wait 4096 external clock ... to make sure the sensor is
          * stable and ready to access registers" i.e. 160us at 24MHz
          */
-
         { 0x12, 0x80 }, /* COMH reset */
         { 0x12, 0x00 }, /* QXGA, master */
 
@@ -693,7 +782,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    COMI[0] "Exposure control"
          *                  =   0 (0x00) .......0 "Manual"
          */
-        { 0x13, 0xC0 },
+        { 0x13, 0xc0 },
 
         /*
          * 09 COMC "Common Control C"
@@ -749,7 +838,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    COME[0] "Auto zero circuit select"
          *                  =   1 (0x01) .......1 "On"
          */
-        { 0x0d, 0xA1 },
+        { 0x0d, 0xa1 },
 
         /*
          * 0E COMF "Common Control F"
@@ -813,7 +902,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    COMJ[0] "Reserved"
          *                  =   0 (0x00) .......0
          */
-        { 0x14, 0xC6 },
+        { 0x14, 0xc6 },
 
         /*
          * 15 COMK "Common Control K"
@@ -919,7 +1008,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    FVOPT[7:0] "Range"
          *                  =  31 (0x1F) 00011111
          */
-        { 0x3c, 0x1F },
+        { 0x3c, 0x1f },
 
         /*
          * 44 Undocumented  =   0 (0x00) 00000000
@@ -968,7 +1057,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    48[7:0] "It's a secret"
          *                  = 192 (0xC0) 11000000
          */
-        { 0x48, 0xC0 },
+        { 0x48, 0xc0 },
 
         /*
          * 49 Undocumented  =  25 (0x19) 00011001
@@ -982,18 +1071,18 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    4B[7:0] "It's a secret"
          *                  = 128 (0x80) 10000000
          */
-        { 0x4B, 0x80 },
+        { 0x4b, 0x80 },
 
         /*
          * 4D Undocumented  = 196 (0xC4) 11000100
          *    4D[7:0] "It's a secret"
          *                  = 196 (0xC4) 11000100
          */
-        { 0x4D, 0xC4 },
+        { 0x4d, 0xc4 },
 
         /*
          * 35 VREF "Reference Voltage Control"
-         *                  =  76 (0x4C) 01001100
+         *                  =  76 (0x4c) 01001100
          *    VREF[7:5] "Column high reference control"
          *                  =   2 (0x02) 010..... "higher voltage"
          *    VREF[4:2] "Column low reference control"
@@ -1001,21 +1090,21 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    VREF[1:0] "Reserved"
          *                  =   0 (0x00) ......00
          */
-        { 0x35, 0x4C },
+        { 0x35, 0x4c },
 
         /*
          * 3D Undocumented  =   0 (0x00) 00000000
          *    3D[7:0] "It's a secret"
          *                  =   0 (0x00) 00000000
          */
-        { 0x3D, 0x00 },
+        { 0x3d, 0x00 },
 
         /*
          * 3E Undocumented  =   0 (0x00) 00000000
          *    3E[7:0] "It's a secret"
          *                  =   0 (0x00) 00000000
          */
-        { 0x3E, 0x00 },
+        { 0x3e, 0x00 },
 
         /*
          * 3B FREFB "Internal Reference Adjustment"
@@ -1055,7 +1144,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    VBLM[3:0] "Sensor current control"
          *                  =  10 (0x0A) ....1010
          */
-        { 0x34, 0x5A },
+        { 0x34, 0x5a },
 
         /*
          * 3B FREFB "Internal Reference Adjustment"
@@ -1121,7 +1210,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    HREFST[7:0] "Horizontal window start, 8 MSBs"
          *                  =  31 (0x1F) 00011111
          */
-        { 0x17, 0x1F },
+        { 0x17, 0x1f },
 
         /*
          * 18 HREFEND "Horizontal window end"
@@ -1129,7 +1218,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    HREFEND[7:0] "Horizontal Window End, 8 MSBs"
          *                  =  95 (0x5F) 01011111
          */
-        { 0x18, 0x5F },
+        { 0x18, 0x5f },
 
         /*
          * 19 VSTRT "Vertical window start"
@@ -1169,7 +1258,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    COMA[1:0] "Vertical window start line control 2 LSBs"
          *                  =   2 (0x02) ......10
          */
-        { 0x03, 0x4A },
+        { 0x03, 0x4a },
 
         /*
          * 11 CLKRC "Clock Rate Control"
@@ -1226,7 +1315,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    HREFST[7:0] "Horizontal window start, 8 MSBs"
          *                  =  31 (0x1F) 00011111
          */
-        { 0x17, 0x1F },
+        { 0x17, 0x1f },
 
         /*
          * 18 HREFEND "Horizontal window end"
@@ -1234,7 +1323,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    HREFEND[7:0] "Horizontal Window End, 8 MSBs"
          *                  =  95 (0x5F) 01011111
          */
-        { 0x18, 0x5F },
+        { 0x18, 0x5f },
 
         /*
          * 19 VSTRT "Vertical window start"
@@ -1274,7 +1363,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    COMA[1:0] "Vertical window start line control 2 LSBs"
          *                  =   2 (0x02) ......10
          */
-        { 0x03, 0x4A },
+        { 0x03, 0x4a },
 
         /*
          * 02 RED "Red Gain Control"
@@ -1284,7 +1373,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    RED[6:0] "Value"
          *                  =  47 (0x2F) .0101111
          */
-        { 0x02, 0xAF },
+        { 0x02, 0xaf },
 
         /*
          * 2D ADDVSL "VSYNC Pulse Width"
@@ -1292,7 +1381,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    ADDVSL[7:0] "VSYNC pulse width, LSB"
          *                  = 210 (0xD2) 11010010
          */
-        { 0x2d, 0xD2 },
+        { 0x2d, 0xd2 },
 
         /*
          * 00 GAIN          =  24 (0x18) 00011000
@@ -1315,7 +1404,7 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    BLUE[6:0] "Value"
          *                  = 112 (0x70) .1110000
          */
-        { 0x01, 0xF0 },
+        { 0x01, 0xf0 },
 
         /*
          * 10 AEC "Automatic Exposure Control"
@@ -1323,14 +1412,14 @@ static const struct ov_i2c_regvals norm_3620b[] =
          *    AEC[7:0] "Automatic Exposure Control, 8 MSBs"
          *                  =  10 (0x0A) 00001010
          */
-        { 0x10, 0x0A },
-
-        { 0xE1, 0x67 },
-        { 0xE3, 0x03 },
-        { 0xE4, 0x26 },
-        { 0xE5, 0x3E },
-        { 0xF8, 0x01 },
-        { 0xFF, 0x01 },
+        { 0x10, 0x0a },
+
+        { 0xe1, 0x67 },
+        { 0xe3, 0x03 },
+        { 0xe4, 0x26 },
+        { 0xe5, 0x3e },
+        { 0xf8, 0x01 },
+        { 0xff, 0x01 },
 };
 
 static const struct ov_i2c_regvals norm_6x20[] = {
@@ -1339,7 +1428,7 @@ static const struct ov_i2c_regvals norm_6x20[] = {
         { 0x03, 0x60 },
         { 0x05, 0x7f }, /* For when autoadjust is off */
         { 0x07, 0xa8 },
-        /* The ratio of 0x0c and 0x0d  controls the white point */
+        /* The ratio of 0x0c and 0x0d controls the white point */
         { 0x0c, 0x24 },
         { 0x0d, 0x24 },
         { 0x0f, 0x15 }, /* COMS */
@@ -1507,7 +1596,7 @@ static const struct ov_i2c_regvals norm_7620[] = {
         { 0x00, 0x00 },         /* gain */
         { 0x01, 0x80 },         /* blue gain */
         { 0x02, 0x80 },         /* red gain */
-        { 0x03, 0xc0 },         /* OV7670_REG_VREF */
+        { 0x03, 0xc0 },         /* OV7670_R03_VREF */
         { 0x06, 0x60 },
         { 0x07, 0x00 },
         { 0x0c, 0x24 },
@@ -1575,33 +1664,177 @@ static const struct ov_i2c_regvals norm_7640[] = {
         { 0x12, 0x14 },
 };
 
+static const struct ov_regvals init_519_ov7660[] = {
+        { 0x5d, 0x03 }, /* Turn off suspend mode */
+        { 0x53, 0x9b }, /* 0x9f enables the (unused) microcontroller */
+        { 0x54, 0x0f }, /* bit2 (jpeg enable) */
+        { 0xa2, 0x20 }, /* a2-a5 are undocumented */
+        { 0xa3, 0x18 },
+        { 0xa4, 0x04 },
+        { 0xa5, 0x28 },
+        { 0x37, 0x00 }, /* SetUsbInit */
+        { 0x55, 0x02 }, /* 4.096 Mhz audio clock */
+        /* Enable both fields, YUV Input, disable defect comp (why?) */
+        { 0x20, 0x0c }, /* 0x0d does U <-> V swap */
+        { 0x21, 0x38 },
+        { 0x22, 0x1d },
+        { 0x17, 0x50 }, /* undocumented */
+        { 0x37, 0x00 }, /* undocumented */
+        { 0x40, 0xff }, /* I2C timeout counter */
+        { 0x46, 0x00 }, /* I2C clock prescaler */
+};
+static const struct ov_i2c_regvals norm_7660[] = {
+        {OV7670_R12_COM7, OV7670_COM7_RESET},
+        {OV7670_R11_CLKRC, 0x81},
+        {0x92, 0x00},                   /* DM_LNL */
+        {0x93, 0x00},                   /* DM_LNH */
+        {0x9d, 0x4c},                   /* BD50ST */
+        {0x9e, 0x3f},                   /* BD60ST */
+        {OV7670_R3B_COM11, 0x02},
+        {OV7670_R13_COM8, 0xf5},
+        {OV7670_R10_AECH, 0x00},
+        {OV7670_R00_GAIN, 0x00},
+        {OV7670_R01_BLUE, 0x7c},
+        {OV7670_R02_RED, 0x9d},
+        {OV7670_R12_COM7, 0x00},
+        {OV7670_R04_COM1, 00},
+        {OV7670_R18_HSTOP, 0x01},
+        {OV7670_R17_HSTART, 0x13},
+        {OV7670_R32_HREF, 0x92},
+        {OV7670_R19_VSTART, 0x02},
+        {OV7670_R1A_VSTOP, 0x7a},
+        {OV7670_R03_VREF, 0x00},
+        {OV7670_R0E_COM5, 0x04},
+        {OV7670_R0F_COM6, 0x62},
+        {OV7670_R15_COM10, 0x00},
+        {0x16, 0x02},                   /* RSVD */
+        {0x1b, 0x00},                   /* PSHFT */
+        {OV7670_R1E_MVFP, 0x01},
+        {0x29, 0x3c},                   /* RSVD */
+        {0x33, 0x00},                   /* CHLF */
+        {0x34, 0x07},                   /* ARBLM */
+        {0x35, 0x84},                   /* RSVD */
+        {0x36, 0x00},                   /* RSVD */
+        {0x37, 0x04},                   /* ADC */
+        {0x39, 0x43},                   /* OFON */
+        {OV7670_R3A_TSLB, 0x00},
+        {OV7670_R3C_COM12, 0x6c},
+        {OV7670_R3D_COM13, 0x98},
+        {OV7670_R3F_EDGE, 0x23},
+        {OV7670_R40_COM15, 0xc1},
+        {OV7670_R41_COM16, 0x22},
+        {0x6b, 0x0a},                   /* DBLV */
+        {0xa1, 0x08},                   /* RSVD */
+        {0x69, 0x80},                   /* HV */
+        {0x43, 0xf0},                   /* RSVD.. */
+        {0x44, 0x10},
+        {0x45, 0x78},
+        {0x46, 0xa8},
+        {0x47, 0x60},
+        {0x48, 0x80},
+        {0x59, 0xba},
+        {0x5a, 0x9a},
+        {0x5b, 0x22},
+        {0x5c, 0xb9},
+        {0x5d, 0x9b},
+        {0x5e, 0x10},
+        {0x5f, 0xe0},
+        {0x60, 0x85},
+        {0x61, 0x60},
+        {0x9f, 0x9d},                   /* RSVD */
+        {0xa0, 0xa0},                   /* DSPC2 */
+        {0x4f, 0x60},                   /* matrix */
+        {0x50, 0x64},
+        {0x51, 0x04},
+        {0x52, 0x18},
+        {0x53, 0x3c},
+        {0x54, 0x54},
+        {0x55, 0x40},
+        {0x56, 0x40},
+        {0x57, 0x40},
+        {0x58, 0x0d},                   /* matrix sign */
+        {0x8b, 0xcc},                   /* RSVD */
+        {0x8c, 0xcc},
+        {0x8d, 0xcf},
+        {0x6c, 0x40},                   /* gamma curve */
+        {0x6d, 0xe0},
+        {0x6e, 0xa0},
+        {0x6f, 0x80},
+        {0x70, 0x70},
+        {0x71, 0x80},
+        {0x72, 0x60},
+        {0x73, 0x60},
+        {0x74, 0x50},
+        {0x75, 0x40},
+        {0x76, 0x38},
+        {0x77, 0x3c},
+        {0x78, 0x32},
+        {0x79, 0x1a},
+        {0x7a, 0x28},
+        {0x7b, 0x24},
+        {0x7c, 0x04},                   /* gamma curve */
+        {0x7d, 0x12},
+        {0x7e, 0x26},
+        {0x7f, 0x46},
+        {0x80, 0x54},
+        {0x81, 0x64},
+        {0x82, 0x70},
+        {0x83, 0x7c},
+        {0x84, 0x86},
+        {0x85, 0x8e},
+        {0x86, 0x9c},
+        {0x87, 0xab},
+        {0x88, 0xc4},
+        {0x89, 0xd1},
+        {0x8a, 0xe5},
+        {OV7670_R14_COM9, 0x1e},
+        {OV7670_R24_AEW, 0x80},
+        {OV7670_R25_AEB, 0x72},
+        {OV7670_R26_VPT, 0xb3},
+        {0x62, 0x80},                   /* LCC1 */
+        {0x63, 0x80},                   /* LCC2 */
+        {0x64, 0x06},                   /* LCC3 */
+        {0x65, 0x00},                   /* LCC4 */
+        {0x66, 0x01},                   /* LCC5 */
+        {0x94, 0x0e},                   /* RSVD.. */
+        {0x95, 0x14},
+        {OV7670_R13_COM8, OV7670_COM8_FASTAEC
+                        | OV7670_COM8_AECSTEP
+                        | OV7670_COM8_BFILT
+                        | 0x10
+                        | OV7670_COM8_AGC
+                        | OV7670_COM8_AWB
+                        | OV7670_COM8_AEC},
+        {0xa1, 0xc8}
+};
+
 /* 7670. Defaults taken from OmniVision provided data,
 *  as provided by Jonathan Corbet of OLPC               */
 static const struct ov_i2c_regvals norm_7670[] = {
-        { OV7670_REG_COM7, OV7670_COM7_RESET },
-        { OV7670_REG_TSLB, 0x04 },              /* OV */
-        { OV7670_REG_COM7, OV7670_COM7_FMT_VGA }, /* VGA */
-        { OV7670_REG_CLKRC, 0x01 },
+        { OV7670_R12_COM7, OV7670_COM7_RESET },
+        { OV7670_R3A_TSLB, 0x04 },              /* OV */
+        { OV7670_R12_COM7, OV7670_COM7_FMT_VGA }, /* VGA */
+        { OV7670_R11_CLKRC, 0x01 },
 /*
  * Set the hardware window.  These values from OV don't entirely
  * make sense - hstop is less than hstart.  But they work...
  */
-        { OV7670_REG_HSTART, 0x13 },
-        { OV7670_REG_HSTOP, 0x01 },
-        { OV7670_REG_HREF, 0xb6 },
-        { OV7670_REG_VSTART, 0x02 },
-        { OV7670_REG_VSTOP, 0x7a },
-        { OV7670_REG_VREF, 0x0a },
-
-        { OV7670_REG_COM3, 0x00 },
-        { OV7670_REG_COM14, 0x00 },
+        { OV7670_R17_HSTART, 0x13 },
+        { OV7670_R18_HSTOP, 0x01 },
+        { OV7670_R32_HREF, 0xb6 },
+        { OV7670_R19_VSTART, 0x02 },
+        { OV7670_R1A_VSTOP, 0x7a },
+        { OV7670_R03_VREF, 0x0a },
+
+        { OV7670_R0C_COM3, 0x00 },
+        { OV7670_R3E_COM14, 0x00 },
 /* Mystery scaling numbers */
         { 0x70, 0x3a },
         { 0x71, 0x35 },
         { 0x72, 0x11 },
         { 0x73, 0xf0 },
         { 0xa2, 0x02 },
-/*      { OV7670_REG_COM10, 0x0 }, */
+/*      { OV7670_R15_COM10, 0x0 }, */
 
 /* Gamma curve values */
         { 0x7a, 0x20 },
@@ -1623,37 +1856,37 @@ static const struct ov_i2c_regvals norm_7670[] = {
 
 /* AGC and AEC parameters.  Note we start by disabling those features,
    then turn them only after tweaking the values. */
-        { OV7670_REG_COM8, OV7670_COM8_FASTAEC
+        { OV7670_R13_COM8, OV7670_COM8_FASTAEC
                          | OV7670_COM8_AECSTEP
                          | OV7670_COM8_BFILT },
-        { OV7670_REG_GAIN, 0x00 },
-        { OV7670_REG_AECH, 0x00 },
-        { OV7670_REG_COM4, 0x40 }, /* magic reserved bit */
-        { OV7670_REG_COM9, 0x18 }, /* 4x gain + magic rsvd bit */
-        { OV7670_REG_BD50MAX, 0x05 },
-        { OV7670_REG_BD60MAX, 0x07 },
-        { OV7670_REG_AEW, 0x95 },
-        { OV7670_REG_AEB, 0x33 },
-        { OV7670_REG_VPT, 0xe3 },
-        { OV7670_REG_HAECC1, 0x78 },
-        { OV7670_REG_HAECC2, 0x68 },
+        { OV7670_R00_GAIN, 0x00 },
+        { OV7670_R10_AECH, 0x00 },
+        { OV7670_R0D_COM4, 0x40 }, /* magic reserved bit */
+        { OV7670_R14_COM9, 0x18 }, /* 4x gain + magic rsvd bit */
+        { OV7670_RA5_BD50MAX, 0x05 },
+        { OV7670_RAB_BD60MAX, 0x07 },
+        { OV7670_R24_AEW, 0x95 },
+        { OV7670_R25_AEB, 0x33 },
+        { OV7670_R26_VPT, 0xe3 },
+        { OV7670_R9F_HAECC1, 0x78 },
+        { OV7670_RA0_HAECC2, 0x68 },
         { 0xa1, 0x03 }, /* magic */
-        { OV7670_REG_HAECC3, 0xd8 },
-        { OV7670_REG_HAECC4, 0xd8 },
-        { OV7670_REG_HAECC5, 0xf0 },
-        { OV7670_REG_HAECC6, 0x90 },
-        { OV7670_REG_HAECC7, 0x94 },
-        { OV7670_REG_COM8, OV7670_COM8_FASTAEC
+        { OV7670_RA6_HAECC3, 0xd8 },
+        { OV7670_RA7_HAECC4, 0xd8 },
+        { OV7670_RA8_HAECC5, 0xf0 },
+        { OV7670_RA9_HAECC6, 0x90 },
+        { OV7670_RAA_HAECC7, 0x94 },
+        { OV7670_R13_COM8, OV7670_COM8_FASTAEC
                         | OV7670_COM8_AECSTEP
                         | OV7670_COM8_BFILT
                         | OV7670_COM8_AGC
                         | OV7670_COM8_AEC },
 
 /* Almost all of these are magic "reserved" values.  */
-        { OV7670_REG_COM5, 0x61 },
-        { OV7670_REG_COM6, 0x4b },
+        { OV7670_R0E_COM5, 0x61 },
+        { OV7670_R0F_COM6, 0x4b },
         { 0x16, 0x02 },
-        { OV7670_REG_MVFP, 0x07 },
+        { OV7670_R1E_MVFP, 0x07 },
         { 0x21, 0x02 },
         { 0x22, 0x91 },
         { 0x29, 0x07 },
@@ -1662,10 +1895,10 @@ static const struct ov_i2c_regvals norm_7670[] = {
         { 0x37, 0x1d },
         { 0x38, 0x71 },
         { 0x39, 0x2a },
-        { OV7670_REG_COM12, 0x78 },
+        { OV7670_R3C_COM12, 0x78 },
         { 0x4d, 0x40 },
         { 0x4e, 0x20 },
-        { OV7670_REG_GFIX, 0x00 },
+        { OV7670_R69_GFIX, 0x00 },
         { 0x6b, 0x4a },
         { 0x74, 0x10 },
         { 0x8d, 0x4f },
@@ -1697,12 +1930,11 @@ static const struct ov_i2c_regvals norm_7670[] = {
         { 0x6c, 0x0a },
         { 0x6d, 0x55 },
         { 0x6e, 0x11 },
-        { 0x6f, 0x9f },
-                                        /* "9e for advance AWB" */
+        { 0x6f, 0x9f },                 /* "9e for advance AWB" */
         { 0x6a, 0x40 },
-        { OV7670_REG_BLUE, 0x40 },
-        { OV7670_REG_RED, 0x60 },
-        { OV7670_REG_COM8, OV7670_COM8_FASTAEC
+        { OV7670_R01_BLUE, 0x40 },
+        { OV7670_R02_RED, 0x60 },
+        { OV7670_R13_COM8, OV7670_COM8_FASTAEC
                         | OV7670_COM8_AECSTEP
                         | OV7670_COM8_BFILT
                         | OV7670_COM8_AGC
@@ -1718,22 +1950,22 @@ static const struct ov_i2c_regvals norm_7670[] = {
         { 0x54, 0x80 },
         { 0x58, 0x9e },
 
-        { OV7670_REG_COM16, OV7670_COM16_AWBGAIN },
-        { OV7670_REG_EDGE, 0x00 },
+        { OV7670_R41_COM16, OV7670_COM16_AWBGAIN },
+        { OV7670_R3F_EDGE, 0x00 },
         { 0x75, 0x05 },
         { 0x76, 0xe1 },
         { 0x4c, 0x00 },
         { 0x77, 0x01 },
-        { OV7670_REG_COM13, OV7670_COM13_GAMMA
+        { OV7670_R3D_COM13, OV7670_COM13_GAMMA
                           | OV7670_COM13_UVSAT
                           | 2},         /* was 3 */
         { 0x4b, 0x09 },
         { 0xc9, 0x60 },
-        { OV7670_REG_COM16, 0x38 },
+        { OV7670_R41_COM16, 0x38 },
         { 0x56, 0x40 },
 
         { 0x34, 0x11 },
-        { OV7670_REG_COM11, OV7670_COM11_EXP|OV7670_COM11_HZAUTO },
+        { OV7670_R3B_COM11, OV7670_COM11_EXP|OV7670_COM11_HZAUTO },
         { 0xa4, 0x88 },
         { 0x96, 0x00 },
         { 0x97, 0x30 },
@@ -1868,10 +2100,13 @@ static unsigned char ov7670_abs_to_sm(unsigned char v)
 }
 
 /* Write a OV519 register */
-static int reg_w(struct sd *sd, __u16 index, __u16 value)
+static void reg_w(struct sd *sd, u16 index, u16 value)
 {
         int ret, req = 0;
 
+        if (sd->gspca_dev.usb_err < 0)
+                return;
+
         switch (sd->bridge) {
         case BRIDGE_OV511:
         case BRIDGE_OV511PLUS:
@@ -1881,6 +2116,8 @@ static int reg_w(struct sd *sd, __u16 index, __u16 value)
                 req = 0x0a;
                 /* fall through */
         case BRIDGE_W9968CF:
+                PDEBUG(D_USBO, "SET %02x %04x %04x",
+                                req, value, index);
                 ret = usb_control_msg(sd->gspca_dev.dev,
                         usb_sndctrlpipe(sd->gspca_dev.dev, 0),
                         req,
@@ -1891,6 +2128,8 @@ static int reg_w(struct sd *sd, __u16 index, __u16 value)
                 req = 1;
         }
 
+        PDEBUG(D_USBO, "SET %02x 0000 %04x %02x",
+                        req, index, value);
         sd->gspca_dev.usb_buf[0] = value;
         ret = usb_control_msg(sd->gspca_dev.dev,
                         usb_sndctrlpipe(sd->gspca_dev.dev, 0),
@@ -1900,22 +2139,22 @@ static int reg_w(struct sd *sd, __u16 index, __u16 value)
                         sd->gspca_dev.usb_buf, 1, 500);
 leave:
         if (ret < 0) {
-                PDEBUG(D_ERR, "Write reg 0x%04x -> [0x%02x] failed",
-                       value, index);
-                return ret;
+                err("reg_w %02x failed %d", index, ret);
+                sd->gspca_dev.usb_err = ret;
+                return;
         }
-
-        PDEBUG(D_USBO, "Write reg 0x%04x -> [0x%02x]", value, index);
-        return 0;
 }
 
 /* Read from a OV519 register, note not valid for the w9968cf!! */
 /* returns: negative is error, pos or zero is data */
-static int reg_r(struct sd *sd, __u16 index)
+static int reg_r(struct sd *sd, u16 index)
 {
         int ret;
         int req;
 
+        if (sd->gspca_dev.usb_err < 0)
+                return -1;
+
         switch (sd->bridge) {
         case BRIDGE_OV511:
         case BRIDGE_OV511PLUS:
@@ -1936,29 +2175,37 @@ static int reg_r(struct sd *sd, __u16 index)
 
         if (ret >= 0) {
                 ret = sd->gspca_dev.usb_buf[0];
-                PDEBUG(D_USBI, "Read reg [0x%02X] -> 0x%04X", index, ret);
-        } else
-                PDEBUG(D_ERR, "Read reg [0x%02x] failed", index);
+                PDEBUG(D_USBI, "GET %02x 0000 %04x %02x",
+                        req, index, ret);
+        } else {
+                err("reg_r %02x failed %d", index, ret);
+                sd->gspca_dev.usb_err = ret;
+        }
 
         return ret;
 }
 
 /* Read 8 values from a OV519 register */
 static int reg_r8(struct sd *sd,
-                  __u16 index)
+                  u16 index)
 {
         int ret;
 
+        if (sd->gspca_dev.usb_err < 0)
+                return -1;
+
         ret = usb_control_msg(sd->gspca_dev.dev,
                         usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
                         1,                      /* REQ_IO */
                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         0, index, sd->gspca_dev.usb_buf, 8, 500);
 
-        if (ret >= 0)
+        if (ret >= 0) {
                 ret = sd->gspca_dev.usb_buf[0];
-        else
-                PDEBUG(D_ERR, "Read reg 8 [0x%02x] failed", index);
+        } else {
+                err("reg_r8 %02x failed %d", index, ret);
+                sd->gspca_dev.usb_err = ret;
+        }
 
         return ret;
 }
@@ -1969,34 +2216,37 @@ static int reg_r8(struct sd *sd,
  * that are in the same position as 0's in "mask" are preserved, regardless
  * of their respective state in "value".
  */
-static int reg_w_mask(struct sd *sd,
-                        __u16 index,
-                        __u8 value,
-                        __u8 mask)
+static void reg_w_mask(struct sd *sd,
+                        u16 index,
+                        u8 value,
+                        u8 mask)
 {
         int ret;
-        __u8 oldval;
+        u8 oldval;
 
         if (mask != 0xff) {
                 value &= mask;                  /* Enforce mask on value */
                 ret = reg_r(sd, index);
                 if (ret < 0)
-                        return ret;
+                        return;
 
                 oldval = ret & ~mask;           /* Clear the masked bits */
                 value |= oldval;                /* Set the desired bits */
         }
-        return reg_w(sd, index, value);
+        reg_w(sd, index, value);
 }
 
 /*
  * Writes multiple (n) byte value to a single register. Only valid with certain
  * registers (0x30 and 0xc4 - 0xce).
  */
-static int ov518_reg_w32(struct sd *sd, __u16 index, u32 value, int n)
+static void ov518_reg_w32(struct sd *sd, u16 index, u32 value, int n)
 {
         int ret;
 
+        if (sd->gspca_dev.usb_err < 0)
+                return;
+
         *((__le32 *) sd->gspca_dev.usb_buf) = __cpu_to_le32(value);
 
         ret = usb_control_msg(sd->gspca_dev.dev,
@@ -2006,69 +2256,55 @@ static int ov518_reg_w32(struct sd *sd, __u16 index, u32 value, int n)
                         0, index,
                         sd->gspca_dev.usb_buf, n, 500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "Write reg32 [%02x] %08x failed", index, value);
-                return ret;
+                err("reg_w32 %02x failed %d", index, ret);
+                sd->gspca_dev.usb_err = ret;
         }
-
-        return 0;
 }
 
-static int ov511_i2c_w(struct sd *sd, __u8 reg, __u8 value)
+static void ov511_i2c_w(struct sd *sd, u8 reg, u8 value)
 {
         int rc, retries;
 
-        PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
+        PDEBUG(D_USBO, "ov511_i2c_w %02x %02x", reg, value);
 
         /* Three byte write cycle */
         for (retries = 6; ; ) {
                 /* Select camera register */
-                rc = reg_w(sd, R51x_I2C_SADDR_3, reg);
-                if (rc < 0)
-                        return rc;
+                reg_w(sd, R51x_I2C_SADDR_3, reg);
 
                 /* Write "value" to I2C data port of OV511 */
-                rc = reg_w(sd, R51x_I2C_DATA, value);
-                if (rc < 0)
-                        return rc;
+                reg_w(sd, R51x_I2C_DATA, value);
 
                 /* Initiate 3-byte write cycle */
-                rc = reg_w(sd, R511_I2C_CTL, 0x01);
-                if (rc < 0)
-                        return rc;
+                reg_w(sd, R511_I2C_CTL, 0x01);
 
                 do {
                         rc = reg_r(sd, R511_I2C_CTL);
                 } while (rc > 0 && ((rc & 1) == 0)); /* Retry until idle */
 
                 if (rc < 0)
-                        return rc;
+                        return;
 
                 if ((rc & 2) == 0) /* Ack? */
                         break;
                 if (--retries < 0) {
                         PDEBUG(D_USBO, "i2c write retries exhausted");
-                        return -1;
+                        return;
                 }
         }
-
-        return 0;
 }
 
-static int ov511_i2c_r(struct sd *sd, __u8 reg)
+static int ov511_i2c_r(struct sd *sd, u8 reg)
 {
         int rc, value, retries;
 
         /* Two byte write cycle */
         for (retries = 6; ; ) {
                 /* Select camera register */
-                rc = reg_w(sd, R51x_I2C_SADDR_2, reg);
-                if (rc < 0)
-                        return rc;
+                reg_w(sd, R51x_I2C_SADDR_2, reg);
 
                 /* Initiate 2-byte write cycle */
-                rc = reg_w(sd, R511_I2C_CTL, 0x03);
-                if (rc < 0)
-                        return rc;
+                reg_w(sd, R511_I2C_CTL, 0x03);
 
                 do {
                         rc = reg_r(sd, R511_I2C_CTL);
@@ -2092,9 +2328,7 @@ static int ov511_i2c_r(struct sd *sd, __u8 reg)
         /* Two byte read cycle */
         for (retries = 6; ; ) {
                 /* Initiate 2-byte read cycle */
-                rc = reg_w(sd, R511_I2C_CTL, 0x05);
-                if (rc < 0)
-                        return rc;
+                reg_w(sd, R511_I2C_CTL, 0x05);
 
                 do {
                         rc = reg_r(sd, R511_I2C_CTL);
@@ -2107,9 +2341,7 @@ static int ov511_i2c_r(struct sd *sd, __u8 reg)
                         break;
 
                 /* I2C abort */
-                rc = reg_w(sd, R511_I2C_CTL, 0x10);
-                if (rc < 0)
-                        return rc;
+                reg_w(sd, R511_I2C_CTL, 0x10);
 
                 if (--retries < 0) {
                         PDEBUG(D_USBI, "i2c read retries exhausted");
@@ -2119,12 +2351,10 @@ static int ov511_i2c_r(struct sd *sd, __u8 reg)
 
         value = reg_r(sd, R51x_I2C_DATA);
 
-        PDEBUG(D_USBI, "i2c [0x%02X] -> 0x%02X", reg, value);
+        PDEBUG(D_USBI, "ov511_i2c_r %02x %02x", reg, value);
 
         /* This is needed to make i2c_w() work */
-        rc = reg_w(sd, R511_I2C_CTL, 0x05);
-        if (rc < 0)
-                return rc;
+        reg_w(sd, R511_I2C_CTL, 0x05);
 
         return value;
 }
@@ -2134,32 +2364,24 @@ static int ov511_i2c_r(struct sd *sd, __u8 reg)
  * This is normally only called from i2c_w(). Note that this function
  * always succeeds regardless of whether the sensor is present and working.
  */
-static int ov518_i2c_w(struct sd *sd,
-                __u8 reg,
-                __u8 value)
+static void ov518_i2c_w(struct sd *sd,
+                u8 reg,
+                u8 value)
 {
-        int rc;
-
-        PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
+        PDEBUG(D_USBO, "ov518_i2c_w %02x %02x", reg, value);
 
         /* Select camera register */
-        rc = reg_w(sd, R51x_I2C_SADDR_3, reg);
-        if (rc < 0)
-                return rc;
+        reg_w(sd, R51x_I2C_SADDR_3, reg);
 
         /* Write "value" to I2C data port of OV511 */
-        rc = reg_w(sd, R51x_I2C_DATA, value);
-        if (rc < 0)
-                return rc;
+        reg_w(sd, R51x_I2C_DATA, value);
 
         /* Initiate 3-byte write cycle */
-        rc = reg_w(sd, R518_I2C_CTL, 0x01);
-        if (rc < 0)
-                return rc;
+        reg_w(sd, R518_I2C_CTL, 0x01);
 
         /* wait for write complete */
         msleep(4);
-        return reg_r8(sd, R518_I2C_CTL);
+        reg_r8(sd, R518_I2C_CTL);
 }
 
 /*
@@ -2169,105 +2391,102 @@ static int ov518_i2c_w(struct sd *sd,
  * This is normally only called from i2c_r(). Note that this function
  * always succeeds regardless of whether the sensor is present and working.
  */
-static int ov518_i2c_r(struct sd *sd, __u8 reg)
+static int ov518_i2c_r(struct sd *sd, u8 reg)
 {
-        int rc, value;
+        int value;
 
         /* Select camera register */
-        rc = reg_w(sd, R51x_I2C_SADDR_2, reg);
-        if (rc < 0)
-                return rc;
+        reg_w(sd, R51x_I2C_SADDR_2, reg);
 
         /* Initiate 2-byte write cycle */
-        rc = reg_w(sd, R518_I2C_CTL, 0x03);
-        if (rc < 0)
-                return rc;
+        reg_w(sd, R518_I2C_CTL, 0x03);
 
         /* Initiate 2-byte read cycle */
-        rc = reg_w(sd, R518_I2C_CTL, 0x05);
-        if (rc < 0)
-                return rc;
+        reg_w(sd, R518_I2C_CTL, 0x05);
         value = reg_r(sd, R51x_I2C_DATA);
-        PDEBUG(D_USBI, "i2c [0x%02X] -> 0x%02X", reg, value);
+        PDEBUG(D_USBI, "ov518_i2c_r %02x %02x", reg, value);
         return value;
 }
 
-static int ovfx2_i2c_w(struct sd *sd, __u8 reg, __u8 value)
+static void ovfx2_i2c_w(struct sd *sd, u8 reg, u8 value)
 {
         int ret;
 
+        if (sd->gspca_dev.usb_err < 0)
+                return;
+
         ret = usb_control_msg(sd->gspca_dev.dev,
                         usb_sndctrlpipe(sd->gspca_dev.dev, 0),
                         0x02,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                        (__u16)value, (__u16)reg, NULL, 0, 500);
+                        (u16) value, (u16) reg, NULL, 0, 500);
 
         if (ret < 0) {
-                PDEBUG(D_ERR, "i2c 0x%02x -> [0x%02x] failed", value, reg);
-                return ret;
+                err("ovfx2_i2c_w %02x failed %d", reg, ret);
+                sd->gspca_dev.usb_err = ret;
         }
 
-        PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
-        return 0;
+        PDEBUG(D_USBO, "ovfx2_i2c_w %02x %02x", reg, value);
 }
 
-static int ovfx2_i2c_r(struct sd *sd, __u8 reg)
+static int ovfx2_i2c_r(struct sd *sd, u8 reg)
 {
         int ret;
 
+        if (sd->gspca_dev.usb_err < 0)
+                return -1;
+
         ret = usb_control_msg(sd->gspca_dev.dev,
                         usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
                         0x03,
                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                        0, (__u16)reg, sd->gspca_dev.usb_buf, 1, 500);
+                        0, (u16) reg, sd->gspca_dev.usb_buf, 1, 500);
 
         if (ret >= 0) {
                 ret = sd->gspca_dev.usb_buf[0];
-                PDEBUG(D_USBI, "i2c [0x%02X] -> 0x%02X", reg, ret);
-        } else
-                PDEBUG(D_ERR, "i2c read [0x%02x] failed", reg);
+                PDEBUG(D_USBI, "ovfx2_i2c_r %02x %02x", reg, ret);
+        } else {
+                err("ovfx2_i2c_r %02x failed %d", reg, ret);
+                sd->gspca_dev.usb_err = ret;
+        }
 
         return ret;
 }
 
-static int i2c_w(struct sd *sd, __u8 reg, __u8 value)
+static void i2c_w(struct sd *sd, u8 reg, u8 value)
 {
-        int ret = -1;
-
         if (sd->sensor_reg_cache[reg] == value)
-                return 0;
+                return;
 
         switch (sd->bridge) {
         case BRIDGE_OV511:
         case BRIDGE_OV511PLUS:
-                ret = ov511_i2c_w(sd, reg, value);
+                ov511_i2c_w(sd, reg, value);
                 break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
         case BRIDGE_OV519:
-                ret = ov518_i2c_w(sd, reg, value);
+                ov518_i2c_w(sd, reg, value);
                 break;
         case BRIDGE_OVFX2:
-                ret = ovfx2_i2c_w(sd, reg, value);
+                ovfx2_i2c_w(sd, reg, value);
                 break;
         case BRIDGE_W9968CF:
-                ret = w9968cf_i2c_w(sd, reg, value);
+                w9968cf_i2c_w(sd, reg, value);
                 break;
         }
 
-        if (ret >= 0) {
+        if (sd->gspca_dev.usb_err >= 0) {
                 /* Up on sensor reset empty the register cache */
                 if (reg == 0x12 && (value & 0x80))
                         memset(sd->sensor_reg_cache, -1,
-                               sizeof(sd->sensor_reg_cache));
+                                sizeof(sd->sensor_reg_cache));
                 else
                         sd->sensor_reg_cache[reg] = value;
         }
-
-        return ret;
 }
 
-static int i2c_r(struct sd *sd, __u8 reg)
+static int i2c_r(struct sd *sd, u8 reg)
 {
         int ret = -1;
 
@@ -2303,95 +2522,99 @@ static int i2c_r(struct sd *sd, __u8 reg)
  * that are in the same position as 0's in "mask" are preserved, regardless
  * of their respective state in "value".
  */
-static int i2c_w_mask(struct sd *sd,
-                   __u8 reg,
-                   __u8 value,
-                   __u8 mask)
+static void i2c_w_mask(struct sd *sd,
+                        u8 reg,
+                        u8 value,
+                        u8 mask)
 {
         int rc;
-        __u8 oldval;
+        u8 oldval;
 
         value &= mask;                  /* Enforce mask on value */
         rc = i2c_r(sd, reg);
         if (rc < 0)
-                return rc;
+                return;
         oldval = rc & ~mask;            /* Clear the masked bits */
         value |= oldval;                /* Set the desired bits */
-        return i2c_w(sd, reg, value);
+        i2c_w(sd, reg, value);
 }
 
 /* Temporarily stops OV511 from functioning. Must do this before changing
  * registers while the camera is streaming */
-static inline int ov51x_stop(struct sd *sd)
+static inline void ov51x_stop(struct sd *sd)
 {
         PDEBUG(D_STREAM, "stopping");
         sd->stopped = 1;
         switch (sd->bridge) {
         case BRIDGE_OV511:
         case BRIDGE_OV511PLUS:
-                return reg_w(sd, R51x_SYS_RESET, 0x3d);
+                reg_w(sd, R51x_SYS_RESET, 0x3d);
+                break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
-                return reg_w_mask(sd, R51x_SYS_RESET, 0x3a, 0x3a);
+                reg_w_mask(sd, R51x_SYS_RESET, 0x3a, 0x3a);
+                break;
         case BRIDGE_OV519:
-                return reg_w(sd, OV519_SYS_RESET1, 0x0f);
+                reg_w(sd, OV519_R51_RESET1, 0x0f);
+                reg_w(sd, OV519_R51_RESET1, 0x00);
+                reg_w(sd, 0x22, 0x00);          /* FRAR */
+                break;
         case BRIDGE_OVFX2:
-                return reg_w_mask(sd, 0x0f, 0x00, 0x02);
+                reg_w_mask(sd, 0x0f, 0x00, 0x02);
+                break;
         case BRIDGE_W9968CF:
-                return reg_w(sd, 0x3c, 0x0a05); /* stop USB transfer */
+                reg_w(sd, 0x3c, 0x0a05); /* stop USB transfer */
+                break;
         }
-
-        return 0;
 }
 
 /* Restarts OV511 after ov511_stop() is called. Has no effect if it is not
  * actually stopped (for performance). */
-static inline int ov51x_restart(struct sd *sd)
+static inline void ov51x_restart(struct sd *sd)
 {
-        int rc;
-
         PDEBUG(D_STREAM, "restarting");
         if (!sd->stopped)
-                return 0;
+                return;
         sd->stopped = 0;
 
         /* Reinitialize the stream */
         switch (sd->bridge) {
         case BRIDGE_OV511:
         case BRIDGE_OV511PLUS:
-                return reg_w(sd, R51x_SYS_RESET, 0x00);
+                reg_w(sd, R51x_SYS_RESET, 0x00);
+                break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
-                rc = reg_w(sd, 0x2f, 0x80);
-                if (rc < 0)
-                        return rc;
-                return reg_w(sd, R51x_SYS_RESET, 0x00);
+                reg_w(sd, 0x2f, 0x80);
+                reg_w(sd, R51x_SYS_RESET, 0x00);
+                break;
         case BRIDGE_OV519:
-                return reg_w(sd, OV519_SYS_RESET1, 0x00);
+                reg_w(sd, OV519_R51_RESET1, 0x0f);
+                reg_w(sd, OV519_R51_RESET1, 0x00);
+                reg_w(sd, 0x22, 0x1d);          /* FRAR */
+                break;
         case BRIDGE_OVFX2:
-                return reg_w_mask(sd, 0x0f, 0x02, 0x02);
+                reg_w_mask(sd, 0x0f, 0x02, 0x02);
+                break;
         case BRIDGE_W9968CF:
-                return reg_w(sd, 0x3c, 0x8a05); /* USB FIFO enable */
+                reg_w(sd, 0x3c, 0x8a05); /* USB FIFO enable */
+                break;
         }
-
-        return 0;
 }
 
-static int ov51x_set_slave_ids(struct sd *sd, __u8 slave);
+static void ov51x_set_slave_ids(struct sd *sd, u8 slave);
 
 /* This does an initial reset of an OmniVision sensor and ensures that I2C
  * is synchronized. Returns <0 on failure.
  */
-static int init_ov_sensor(struct sd *sd, __u8 slave)
+static int init_ov_sensor(struct sd *sd, u8 slave)
 {
         int i;
 
-        if (ov51x_set_slave_ids(sd, slave) < 0)
-                return -EIO;
+        ov51x_set_slave_ids(sd, slave);
 
         /* Reset the sensor */
-        if (i2c_w(sd, 0x12, 0x80) < 0)
-                return -EIO;
+        i2c_w(sd, 0x12, 0x80);
 
         /* Wait for it to initialize */
         msleep(150);
@@ -2404,15 +2627,16 @@ static int init_ov_sensor(struct sd *sd, __u8 slave)
                 }
 
                 /* Reset the sensor */
-                if (i2c_w(sd, 0x12, 0x80) < 0)
-                        return -EIO;
+                i2c_w(sd, 0x12, 0x80);
+
                 /* Wait for it to initialize */
                 msleep(150);
+
                 /* Dummy read to sync I2C */
                 if (i2c_r(sd, 0x00) < 0)
-                        return -EIO;
+                        return -1;
         }
-        return -EIO;
+        return -1;
 }
 
 /* Set the read and write slave IDs. The "slave" argument is the write slave,
@@ -2420,53 +2644,40 @@ static int init_ov_sensor(struct sd *sd, __u8 slave)
  * This should not be called from outside the i2c I/O functions.
  * Sets I2C read and write slave IDs. Returns <0 for error
  */
-static int ov51x_set_slave_ids(struct sd *sd,
-                                __u8 slave)
+static void ov51x_set_slave_ids(struct sd *sd,
+                                u8 slave)
 {
-        int rc;
-
         switch (sd->bridge) {
         case BRIDGE_OVFX2:
-                return reg_w(sd, OVFX2_I2C_ADDR, slave);
+                reg_w(sd, OVFX2_I2C_ADDR, slave);
+                return;
         case BRIDGE_W9968CF:
                 sd->sensor_addr = slave;
-                return 0;
+                return;
         }
 
-        rc = reg_w(sd, R51x_I2C_W_SID, slave);
-        if (rc < 0)
-                return rc;
-        return reg_w(sd, R51x_I2C_R_SID, slave + 1);
+        reg_w(sd, R51x_I2C_W_SID, slave);
+        reg_w(sd, R51x_I2C_R_SID, slave + 1);
 }
 
-static int write_regvals(struct sd *sd,
+static void write_regvals(struct sd *sd,
                          const struct ov_regvals *regvals,
                          int n)
 {
-        int rc;
-
         while (--n >= 0) {
-                rc = reg_w(sd, regvals->reg, regvals->val);
-                if (rc < 0)
-                        return rc;
+                reg_w(sd, regvals->reg, regvals->val);
                 regvals++;
         }
-        return 0;
 }
 
-static int write_i2c_regvals(struct sd *sd,
-                             const struct ov_i2c_regvals *regvals,
-                             int n)
+static void write_i2c_regvals(struct sd *sd,
+                        const struct ov_i2c_regvals *regvals,
+                        int n)
 {
-        int rc;
-
         while (--n >= 0) {
-                rc = i2c_w(sd, regvals->reg, regvals->val);
-                if (rc < 0)
-                        return rc;
+                i2c_w(sd, regvals->reg, regvals->val);
                 regvals++;
         }
-        return 0;
 }
 
 /****************************************************************************
@@ -2476,13 +2687,13 @@ static int write_i2c_regvals(struct sd *sd,
  ***************************************************************************/
 
 /* This initializes the OV2x10 / OV3610 / OV3620 */
-static int ov_hires_configure(struct sd *sd)
+static void ov_hires_configure(struct sd *sd)
 {
         int high, low;
 
         if (sd->bridge != BRIDGE_OVFX2) {
-                PDEBUG(D_ERR, "error hires sensors only supported with ovfx2");
-                return -1;
+                err("error hires sensors only supported with ovfx2");
+                return;
         }
 
         PDEBUG(D_PROBE, "starting ov hires configuration");
@@ -2494,24 +2705,22 @@ static int ov_hires_configure(struct sd *sd)
         if (high == 0x96 && low == 0x40) {
                 PDEBUG(D_PROBE, "Sensor is an OV2610");
                 sd->sensor = SEN_OV2610;
+        } else if (high == 0x96 && low == 0x41) {
+                PDEBUG(D_PROBE, "Sensor is an OV2610AE");
+                sd->sensor = SEN_OV2610AE;
         } else if (high == 0x36 && (low & 0x0f) == 0x00) {
                 PDEBUG(D_PROBE, "Sensor is an OV3610");
                 sd->sensor = SEN_OV3610;
         } else {
-                PDEBUG(D_ERR, "Error unknown sensor type: 0x%02x%02x",
-                       high, low);
-                return -1;
+                err("Error unknown sensor type: %02x%02x",
+                        high, low);
         }
-
-        /* Set sensor-specific vars */
-        return 0;
 }
 
-
 /* This initializes the OV8110, OV8610 sensor. The OV8110 uses
  * the same register settings as the OV8610, since they are very similar.
  */
-static int ov8xx0_configure(struct sd *sd)
+static void ov8xx0_configure(struct sd *sd)
 {
         int rc;
 
@@ -2521,27 +2730,21 @@ static int ov8xx0_configure(struct sd *sd)
         rc = i2c_r(sd, OV7610_REG_COM_I);
         if (rc < 0) {
                 PDEBUG(D_ERR, "Error detecting sensor type");
-                return -1;
+                return;
         }
-        if ((rc & 3) == 1) {
+        if ((rc & 3) == 1)
                 sd->sensor = SEN_OV8610;
-        } else {
-                PDEBUG(D_ERR, "Unknown image sensor version: %d", rc & 3);
-                return -1;
-        }
-
-        /* Set sensor-specific vars */
-        return 0;
+        else
+                err("Unknown image sensor version: %d", rc & 3);
 }
 
 /* This initializes the OV7610, OV7620, or OV76BE sensor. The OV76BE uses
  * the same register settings as the OV7610, since they are very similar.
  */
-static int ov7xx0_configure(struct sd *sd)
+static void ov7xx0_configure(struct sd *sd)
 {
         int rc, high, low;
 
-
         PDEBUG(D_PROBE, "starting OV7xx0 configuration");
 
         /* Detect sensor (sub)type */
@@ -2551,15 +2754,15 @@ static int ov7xx0_configure(struct sd *sd)
          * it appears to be wrongly detected as a 7610 by default */
         if (rc < 0) {
                 PDEBUG(D_ERR, "Error detecting sensor type");
-                return -1;
+                return;
         }
         if ((rc & 3) == 3) {
                 /* quick hack to make OV7670s work */
                 high = i2c_r(sd, 0x0a);
                 low = i2c_r(sd, 0x0b);
                 /* info("%x, %x", high, low); */
-                if (high == 0x76 && low == 0x73) {
-                        PDEBUG(D_PROBE, "Sensor is an OV7670");
+                if (high == 0x76 && (low & 0xf0) == 0x70) {
+                        PDEBUG(D_PROBE, "Sensor is an OV76%02x", low);
                         sd->sensor = SEN_OV7670;
                 } else {
                         PDEBUG(D_PROBE, "Sensor is an OV7610");
@@ -2579,20 +2782,19 @@ static int ov7xx0_configure(struct sd *sd)
                 high = i2c_r(sd, 0x0a);
                 if (high < 0) {
                         PDEBUG(D_ERR, "Error detecting camera chip PID");
-                        return high;
+                        return;
                 }
                 low = i2c_r(sd, 0x0b);
                 if (low < 0) {
                         PDEBUG(D_ERR, "Error detecting camera chip VER");
-                        return low;
+                        return;
                 }
                 if (high == 0x76) {
                         switch (low) {
                         case 0x30:
-                                PDEBUG(D_PROBE, "Sensor is an OV7630/OV7635");
-                                PDEBUG(D_ERR,
-                                      "7630 is not supported by this driver");
-                                return -1;
+                                err("Sensor is an OV7630/OV7635");
+                                err("7630 is not supported by this driver");
+                                return;
                         case 0x40:
                                 PDEBUG(D_PROBE, "Sensor is an OV7645");
                                 sd->sensor = SEN_OV7640; /* FIXME */
@@ -2605,25 +2807,26 @@ static int ov7xx0_configure(struct sd *sd)
                                 PDEBUG(D_PROBE, "Sensor is an OV7648");
                                 sd->sensor = SEN_OV7648;
                                 break;
+                        case 0x60:
+                                PDEBUG(D_PROBE, "Sensor is a OV7660");
+                                sd->sensor = SEN_OV7660;
+                                sd->invert_led = 0;
+                                break;
                         default:
                                 PDEBUG(D_PROBE, "Unknown sensor: 0x76%x", low);
-                                return -1;
+                                return;
                         }
                 } else {
                         PDEBUG(D_PROBE, "Sensor is an OV7620");
                         sd->sensor = SEN_OV7620;
                 }
         } else {
-                PDEBUG(D_ERR, "Unknown image sensor version: %d", rc & 3);
-                return -1;
+                err("Unknown image sensor version: %d", rc & 3);
         }
-
-        /* Set sensor-specific vars */
-        return 0;
 }
 
 /* This initializes the OV6620, OV6630, OV6630AE, or OV6630AF sensor. */
-static int ov6xx0_configure(struct sd *sd)
+static void ov6xx0_configure(struct sd *sd)
 {
         int rc;
         PDEBUG(D_PROBE, "starting OV6xx0 configuration");
@@ -2632,7 +2835,7 @@ static int ov6xx0_configure(struct sd *sd)
         rc = i2c_r(sd, OV7610_REG_COM_I);
         if (rc < 0) {
                 PDEBUG(D_ERR, "Error detecting sensor type");
-                return -1;
+                return;
         }
 
         /* Ugh. The first two bits are the version bits, but
@@ -2641,9 +2844,8 @@ static int ov6xx0_configure(struct sd *sd)
         switch (rc) {
         case 0x00:
                 sd->sensor = SEN_OV6630;
-                PDEBUG(D_ERR,
-                        "WARNING: Sensor is an OV66308. Your camera may have");
-                PDEBUG(D_ERR, "been misdetected in previous driver versions.");
+                warn("WARNING: Sensor is an OV66308. Your camera may have");
+                warn("been misdetected in previous driver versions.");
                 break;
         case 0x01:
                 sd->sensor = SEN_OV6620;
@@ -2659,19 +2861,16 @@ static int ov6xx0_configure(struct sd *sd)
                 break;
         case 0x90:
                 sd->sensor = SEN_OV6630;
-                PDEBUG(D_ERR,
-                        "WARNING: Sensor is an OV66307. Your camera may have");
-                PDEBUG(D_ERR, "been misdetected in previous driver versions.");
+                warn("WARNING: Sensor is an OV66307. Your camera may have");
+                warn("been misdetected in previous driver versions.");
                 break;
         default:
-                PDEBUG(D_ERR, "FATAL: Unknown sensor version: 0x%02x", rc);
-                return -1;
+                err("FATAL: Unknown sensor version: 0x%02x", rc);
+                return;
         }
 
         /* Set sensor-specific vars */
         sd->sif = 1;
-
-        return 0;
 }
 
 /* Turns on or off the LED. Only has an effect with OV511+/OV518(+)/OV519 */
@@ -2683,14 +2882,14 @@ static void ov51x_led_control(struct sd *sd, int on)
         switch (sd->bridge) {
         /* OV511 has no LED control */
         case BRIDGE_OV511PLUS:
-                reg_w(sd, R511_SYS_LED_CTL, on ? 1 : 0);
+                reg_w(sd, R511_SYS_LED_CTL, on);
                 break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
-                reg_w_mask(sd, R518_GPIO_OUT, on ? 0x02 : 0x00, 0x02);
+                reg_w_mask(sd, R518_GPIO_OUT, 0x02 * on, 0x02);
                 break;
         case BRIDGE_OV519:
-                reg_w_mask(sd, OV519_GPIO_DATA_OUT0, !on, 1);   /* 0 / 1 */
+                reg_w_mask(sd, OV519_GPIO_DATA_OUT0, on, 1);
                 break;
         }
 }
@@ -2725,7 +2924,7 @@ static void sd_reset_snapshot(struct gspca_dev *gspca_dev)
         }
 }
 
-static int ov51x_upload_quan_tables(struct sd *sd)
+static void ov51x_upload_quan_tables(struct sd *sd)
 {
         const unsigned char yQuanTable511[] = {
                 0, 1, 1, 2, 2, 3, 3, 4,
@@ -2756,7 +2955,6 @@ static int ov51x_upload_quan_tables(struct sd *sd)
                 6, 6, 6, 6, 7, 7, 7, 8,
                 7, 7, 6, 7, 7, 7, 8, 8
         };
-
         const unsigned char uvQuanTable518[] = {
                 6, 6, 6, 7, 7, 7, 7, 7,
                 6, 6, 6, 7, 7, 7, 7, 7,
@@ -2766,18 +2964,18 @@ static int ov51x_upload_quan_tables(struct sd *sd)
 
         const unsigned char *pYTable, *pUVTable;
         unsigned char val0, val1;
-        int i, size, rc, reg = R51x_COMP_LUT_BEGIN;
+        int i, size, reg = R51x_COMP_LUT_BEGIN;
 
         PDEBUG(D_PROBE, "Uploading quantization tables");
 
         if (sd->bridge == BRIDGE_OV511 || sd->bridge == BRIDGE_OV511PLUS) {
                 pYTable = yQuanTable511;
                 pUVTable = uvQuanTable511;
-                size  = 32;
+                size = 32;
         } else {
                 pYTable = yQuanTable518;
                 pUVTable = uvQuanTable518;
-                size  = 16;
+                size = 16;
         }
 
         for (i = 0; i < size; i++) {
@@ -2786,30 +2984,23 @@ static int ov51x_upload_quan_tables(struct sd *sd)
                 val0 &= 0x0f;
                 val1 &= 0x0f;
                 val0 |= val1 << 4;
-                rc = reg_w(sd, reg, val0);
-                if (rc < 0)
-                        return rc;
+                reg_w(sd, reg, val0);
 
                 val0 = *pUVTable++;
                 val1 = *pUVTable++;
                 val0 &= 0x0f;
                 val1 &= 0x0f;
                 val0 |= val1 << 4;
-                rc = reg_w(sd, reg + size, val0);
-                if (rc < 0)
-                        return rc;
+                reg_w(sd, reg + size, val0);
 
                 reg++;
         }
-
-        return 0;
 }
 
 /* This initializes the OV511/OV511+ and the sensor */
-static int ov511_configure(struct gspca_dev *gspca_dev)
+static void ov511_configure(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int rc;
 
         /* For 511 and 511+ */
         const struct ov_regvals init_511[] = {
@@ -2823,7 +3014,7 @@ static int ov511_configure(struct gspca_dev *gspca_dev)
         };
 
         const struct ov_regvals norm_511[] = {
-                { R511_DRAM_FLOW_CTL,   0x01 },
+                { R511_DRAM_FLOW_CTL,   0x01 },
                 { R51x_SYS_SNAP,        0x00 },
                 { R51x_SYS_SNAP,        0x02 },
                 { R51x_SYS_SNAP,        0x00 },
@@ -2855,42 +3046,27 @@ static int ov511_configure(struct gspca_dev *gspca_dev)
 
         PDEBUG(D_PROBE, "Device custom id %x", reg_r(sd, R51x_SYS_CUST_ID));
 
-        rc = write_regvals(sd, init_511, ARRAY_SIZE(init_511));
-        if (rc < 0)
-                return rc;
+        write_regvals(sd, init_511, ARRAY_SIZE(init_511));
 
         switch (sd->bridge) {
         case BRIDGE_OV511:
-                rc = write_regvals(sd, norm_511, ARRAY_SIZE(norm_511));
-                if (rc < 0)
-                        return rc;
+                write_regvals(sd, norm_511, ARRAY_SIZE(norm_511));
                 break;
         case BRIDGE_OV511PLUS:
-                rc = write_regvals(sd, norm_511_p, ARRAY_SIZE(norm_511_p));
-                if (rc < 0)
-                        return rc;
+                write_regvals(sd, norm_511_p, ARRAY_SIZE(norm_511_p));
                 break;
         }
 
         /* Init compression */
-        rc = write_regvals(sd, compress_511, ARRAY_SIZE(compress_511));
-        if (rc < 0)
-                return rc;
+        write_regvals(sd, compress_511, ARRAY_SIZE(compress_511));
 
-        rc = ov51x_upload_quan_tables(sd);
-        if (rc < 0) {
-                PDEBUG(D_ERR, "Error uploading quantization tables");
-                return rc;
-        }
-
-        return 0;
+        ov51x_upload_quan_tables(sd);
 }
 
 /* This initializes the OV518/OV518+ and the sensor */
-static int ov518_configure(struct gspca_dev *gspca_dev)
+static void ov518_configure(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int rc;
 
         /* For 518 and 518+ */
         const struct ov_regvals init_518[] = {
@@ -2907,7 +3083,7 @@ static int ov518_configure(struct gspca_dev *gspca_dev)
         const struct ov_regvals norm_518[] = {
                 { R51x_SYS_SNAP,        0x02 }, /* Reset */
                 { R51x_SYS_SNAP,        0x01 }, /* Enable */
-                { 0x31,                 0x0f },
+                { 0x31,                 0x0f },
                 { 0x5d,                 0x03 },
                 { 0x24,                 0x9f },
                 { 0x25,                 0x90 },
@@ -2920,7 +3096,7 @@ static int ov518_configure(struct gspca_dev *gspca_dev)
         const struct ov_regvals norm_518_p[] = {
                 { R51x_SYS_SNAP,        0x02 }, /* Reset */
                 { R51x_SYS_SNAP,        0x01 }, /* Enable */
-                { 0x31,                 0x0f },
+                { 0x31,                 0x0f },
                 { 0x5d,                 0x03 },
                 { 0x24,                 0x9f },
                 { 0x25,                 0x90 },
@@ -2938,65 +3114,49 @@ static int ov518_configure(struct gspca_dev *gspca_dev)
 
         /* First 5 bits of custom ID reg are a revision ID on OV518 */
         PDEBUG(D_PROBE, "Device revision %d",
-               0x1F & reg_r(sd, R51x_SYS_CUST_ID));
+                0x1f & reg_r(sd, R51x_SYS_CUST_ID));
 
-        rc = write_regvals(sd, init_518, ARRAY_SIZE(init_518));
-        if (rc < 0)
-                return rc;
+        write_regvals(sd, init_518, ARRAY_SIZE(init_518));
 
         /* Set LED GPIO pin to output mode */
-        rc = reg_w_mask(sd, R518_GPIO_CTL, 0x00, 0x02);
-        if (rc < 0)
-                return rc;
+        reg_w_mask(sd, R518_GPIO_CTL, 0x00, 0x02);
 
         switch (sd->bridge) {
         case BRIDGE_OV518:
-                rc = write_regvals(sd, norm_518, ARRAY_SIZE(norm_518));
-                if (rc < 0)
-                        return rc;
+                write_regvals(sd, norm_518, ARRAY_SIZE(norm_518));
                 break;
         case BRIDGE_OV518PLUS:
-                rc = write_regvals(sd, norm_518_p, ARRAY_SIZE(norm_518_p));
-                if (rc < 0)
-                        return rc;
+                write_regvals(sd, norm_518_p, ARRAY_SIZE(norm_518_p));
                 break;
         }
 
-        rc = ov51x_upload_quan_tables(sd);
-        if (rc < 0) {
-                PDEBUG(D_ERR, "Error uploading quantization tables");
-                return rc;
-        }
+        ov51x_upload_quan_tables(sd);
 
-        rc = reg_w(sd, 0x2f, 0x80);
-        if (rc < 0)
-                return rc;
-
-        return 0;
+        reg_w(sd, 0x2f, 0x80);
 }
 
-static int ov519_configure(struct sd *sd)
+static void ov519_configure(struct sd *sd)
 {
         static const struct ov_regvals init_519[] = {
-                { 0x5a,  0x6d }, /* EnableSystem */
-                { 0x53,  0x9b },
-                { 0x54,  0xff }, /* set bit2 to enable jpeg */
-                { 0x5d,  0x03 },
-                { 0x49,  0x01 },
-                { 0x48,  0x00 },
+                { 0x5a, 0x6d }, /* EnableSystem */
+                { 0x53, 0x9b }, /* don't enable the microcontroller */
+                { OV519_R54_EN_CLK1, 0xff }, /* set bit2 to enable jpeg */
+                { 0x5d, 0x03 },
+                { 0x49, 0x01 },
+                { 0x48, 0x00 },
                 /* Set LED pin to output mode. Bit 4 must be cleared or sensor
                  * detection will fail. This deserves further investigation. */
                 { OV519_GPIO_IO_CTRL0,   0xee },
-                { 0x51,  0x0f }, /* SetUsbInit */
-                { 0x51,  0x00 },
-                { 0x22,  0x00 },
+                { OV519_R51_RESET1, 0x0f },
+                { OV519_R51_RESET1, 0x00 },
+                { 0x22, 0x00 },
                 /* windows reads 0x55 at this point*/
         };
 
-        return write_regvals(sd, init_519, ARRAY_SIZE(init_519));
+        write_regvals(sd, init_519, ARRAY_SIZE(init_519));
 }
 
-static int ovfx2_configure(struct sd *sd)
+static void ovfx2_configure(struct sd *sd)
 {
         static const struct ov_regvals init_fx2[] = {
                 { 0x00, 0x60 },
@@ -3010,7 +3170,99 @@ static int ovfx2_configure(struct sd *sd)
 
         sd->stopped = 1;
 
-        return write_regvals(sd, init_fx2, ARRAY_SIZE(init_fx2));
+        write_regvals(sd, init_fx2, ARRAY_SIZE(init_fx2));
+}
+
+/* set the mode */
+/* This function works for ov7660 only */
+static void ov519_set_mode(struct sd *sd)
+{
+        static const struct ov_regvals bridge_ov7660[2][10] = {
+                {{0x10, 0x14}, {0x11, 0x1e}, {0x12, 0x00}, {0x13, 0x00},
+                 {0x14, 0x00}, {0x15, 0x00}, {0x16, 0x00}, {0x20, 0x0c},
+                 {0x25, 0x01}, {0x26, 0x00}},
+                {{0x10, 0x28}, {0x11, 0x3c}, {0x12, 0x00}, {0x13, 0x00},
+                 {0x14, 0x00}, {0x15, 0x00}, {0x16, 0x00}, {0x20, 0x0c},
+                 {0x25, 0x03}, {0x26, 0x00}}
+        };
+        static const struct ov_i2c_regvals sensor_ov7660[2][3] = {
+                {{0x12, 0x00}, {0x24, 0x00}, {0x0c, 0x0c}},
+                {{0x12, 0x00}, {0x04, 0x00}, {0x0c, 0x00}}
+        };
+        static const struct ov_i2c_regvals sensor_ov7660_2[] = {
+                {OV7670_R17_HSTART, 0x13},
+                {OV7670_R18_HSTOP, 0x01},
+                {OV7670_R32_HREF, 0x92},
+                {OV7670_R19_VSTART, 0x02},
+                {OV7670_R1A_VSTOP, 0x7a},
+                {OV7670_R03_VREF, 0x00},
+/*              {0x33, 0x00}, */
+/*              {0x34, 0x07}, */
+/*              {0x36, 0x00}, */
+/*              {0x6b, 0x0a}, */
+        };
+
+        write_regvals(sd, bridge_ov7660[sd->gspca_dev.curr_mode],
+                        ARRAY_SIZE(bridge_ov7660[0]));
+        write_i2c_regvals(sd, sensor_ov7660[sd->gspca_dev.curr_mode],
+                        ARRAY_SIZE(sensor_ov7660[0]));
+        write_i2c_regvals(sd, sensor_ov7660_2,
+                        ARRAY_SIZE(sensor_ov7660_2));
+}
+
+/* set the frame rate */
+/* This function works for sensors ov7640, ov7648 ov7660 and ov7670 only */
+static void ov519_set_fr(struct sd *sd)
+{
+        int fr;
+        u8 clock;
+        /* frame rate table with indices:
+         *      - mode = 0: 320x240, 1: 640x480
+         *      - fr rate = 0: 30, 1: 25, 2: 20, 3: 15, 4: 10, 5: 5
+         *      - reg = 0: bridge a4, 1: bridge 23, 2: sensor 11 (clock)
+         */
+        static const u8 fr_tb[2][6][3] = {
+                {{0x04, 0xff, 0x00},
+                 {0x04, 0x1f, 0x00},
+                 {0x04, 0x1b, 0x00},
+                 {0x04, 0x15, 0x00},
+                 {0x04, 0x09, 0x00},
+                 {0x04, 0x01, 0x00}},
+                {{0x0c, 0xff, 0x00},
+                 {0x0c, 0x1f, 0x00},
+                 {0x0c, 0x1b, 0x00},
+                 {0x04, 0xff, 0x01},
+                 {0x04, 0x1f, 0x01},
+                 {0x04, 0x1b, 0x01}},
+        };
+
+        if (frame_rate > 0)
+                sd->frame_rate = frame_rate;
+        if (sd->frame_rate >= 30)
+                fr = 0;
+        else if (sd->frame_rate >= 25)
+                fr = 1;
+        else if (sd->frame_rate >= 20)
+                fr = 2;
+        else if (sd->frame_rate >= 15)
+                fr = 3;
+        else if (sd->frame_rate >= 10)
+                fr = 4;
+        else
+                fr = 5;
+        reg_w(sd, 0xa4, fr_tb[sd->gspca_dev.curr_mode][fr][0]);
+        reg_w(sd, 0x23, fr_tb[sd->gspca_dev.curr_mode][fr][1]);
+        clock = fr_tb[sd->gspca_dev.curr_mode][fr][2];
+        if (sd->sensor == SEN_OV7660)
+                clock |= 0x80;          /* enable double clock */
+        ov518_i2c_w(sd, OV7670_R11_CLKRC, clock);
+}
+
+static void setautogain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        i2c_w_mask(sd, 0x13, sd->ctrls[AUTOGAIN].val ? 0x05 : 0x00, 0x05);
 }
 
 /* this function is called at probe time */
@@ -3019,221 +3271,250 @@ static int sd_config(struct gspca_dev *gspca_dev,
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct cam *cam = &gspca_dev->cam;
-        int ret = 0;
 
         sd->bridge = id->driver_info & BRIDGE_MASK;
-        sd->invert_led = id->driver_info & BRIDGE_INVERT_LED;
+        sd->invert_led = (id->driver_info & BRIDGE_INVERT_LED) != 0;
 
         switch (sd->bridge) {
         case BRIDGE_OV511:
         case BRIDGE_OV511PLUS:
-                ret = ov511_configure(gspca_dev);
+                cam->cam_mode = ov511_vga_mode;
+                cam->nmodes = ARRAY_SIZE(ov511_vga_mode);
                 break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
-                ret = ov518_configure(gspca_dev);
+                cam->cam_mode = ov518_vga_mode;
+                cam->nmodes = ARRAY_SIZE(ov518_vga_mode);
                 break;
         case BRIDGE_OV519:
-                ret = ov519_configure(sd);
+                cam->cam_mode = ov519_vga_mode;
+                cam->nmodes = ARRAY_SIZE(ov519_vga_mode);
+                sd->invert_led = !sd->invert_led;
                 break;
         case BRIDGE_OVFX2:
-                ret = ovfx2_configure(sd);
+                cam->cam_mode = ov519_vga_mode;
+                cam->nmodes = ARRAY_SIZE(ov519_vga_mode);
                 cam->bulk_size = OVFX2_BULK_SIZE;
                 cam->bulk_nurbs = MAX_NURBS;
                 cam->bulk = 1;
                 break;
         case BRIDGE_W9968CF:
-                ret = w9968cf_configure(sd);
+                cam->cam_mode = w9968cf_vga_mode;
+                cam->nmodes = ARRAY_SIZE(w9968cf_vga_mode);
                 cam->reverse_alts = 1;
                 break;
         }
 
-        if (ret)
-                goto error;
+        gspca_dev->cam.ctrls = sd->ctrls;
+        sd->quality = QUALITY_DEF;
+        sd->frame_rate = 15;
 
-        ov51x_led_control(sd, 0);       /* turn LED off */
+        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;
+        struct cam *cam = &gspca_dev->cam;
+
+        switch (sd->bridge) {
+        case BRIDGE_OV511:
+        case BRIDGE_OV511PLUS:
+                ov511_configure(gspca_dev);
+                break;
+        case BRIDGE_OV518:
+        case BRIDGE_OV518PLUS:
+                ov518_configure(gspca_dev);
+                break;
+        case BRIDGE_OV519:
+                ov519_configure(sd);
+                break;
+        case BRIDGE_OVFX2:
+                ovfx2_configure(sd);
+                break;
+        case BRIDGE_W9968CF:
+                w9968cf_configure(sd);
+                break;
+        }
 
         /* The OV519 must be more aggressive about sensor detection since
          * I2C write will never fail if the sensor is not present. We have
          * to try to initialize the sensor to detect its presence */
+        sd->sensor = -1;
 
         /* Test for 76xx */
         if (init_ov_sensor(sd, OV7xx0_SID) >= 0) {
-                if (ov7xx0_configure(sd) < 0) {
-                        PDEBUG(D_ERR, "Failed to configure OV7xx0");
-                        goto error;
-                }
+                ov7xx0_configure(sd);
+
         /* Test for 6xx0 */
         } else if (init_ov_sensor(sd, OV6xx0_SID) >= 0) {
-                if (ov6xx0_configure(sd) < 0) {
-                        PDEBUG(D_ERR, "Failed to configure OV6xx0");
-                        goto error;
-                }
+                ov6xx0_configure(sd);
+
         /* Test for 8xx0 */
         } else if (init_ov_sensor(sd, OV8xx0_SID) >= 0) {
-                if (ov8xx0_configure(sd) < 0) {
-                        PDEBUG(D_ERR, "Failed to configure OV8xx0");
-                        goto error;
-                }
+                ov8xx0_configure(sd);
+
         /* Test for 3xxx / 2xxx */
         } else if (init_ov_sensor(sd, OV_HIRES_SID) >= 0) {
-                if (ov_hires_configure(sd) < 0) {
-                        PDEBUG(D_ERR, "Failed to configure high res OV");
-                        goto error;
-                }
+                ov_hires_configure(sd);
         } else {
-                PDEBUG(D_ERR, "Can't determine sensor slave IDs");
+                err("Can't determine sensor slave IDs");
                 goto error;
         }
 
+        if (sd->sensor < 0)
+                goto error;
+
+        ov51x_led_control(sd, 0);       /* turn LED off */
+
         switch (sd->bridge) {
         case BRIDGE_OV511:
         case BRIDGE_OV511PLUS:
-                if (!sd->sif) {
-                        cam->cam_mode = ov511_vga_mode;
-                        cam->nmodes = ARRAY_SIZE(ov511_vga_mode);
-                } else {
+                if (sd->sif) {
                         cam->cam_mode = ov511_sif_mode;
                         cam->nmodes = ARRAY_SIZE(ov511_sif_mode);
                 }
                 break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
-                if (!sd->sif) {
-                        cam->cam_mode = ov518_vga_mode;
-                        cam->nmodes = ARRAY_SIZE(ov518_vga_mode);
-                } else {
+                if (sd->sif) {
                         cam->cam_mode = ov518_sif_mode;
                         cam->nmodes = ARRAY_SIZE(ov518_sif_mode);
                 }
                 break;
         case BRIDGE_OV519:
-                if (!sd->sif) {
-                        cam->cam_mode = ov519_vga_mode;
-                        cam->nmodes = ARRAY_SIZE(ov519_vga_mode);
-                } else {
+                if (sd->sif) {
                         cam->cam_mode = ov519_sif_mode;
                         cam->nmodes = ARRAY_SIZE(ov519_sif_mode);
                 }
                 break;
         case BRIDGE_OVFX2:
-                if (sd->sensor == SEN_OV2610) {
+                switch (sd->sensor) {
+                case SEN_OV2610:
+                case SEN_OV2610AE:
                         cam->cam_mode = ovfx2_ov2610_mode;
                         cam->nmodes = ARRAY_SIZE(ovfx2_ov2610_mode);
-                } else if (sd->sensor == SEN_OV3610) {
+                        break;
+                case SEN_OV3610:
                         cam->cam_mode = ovfx2_ov3610_mode;
                         cam->nmodes = ARRAY_SIZE(ovfx2_ov3610_mode);
-                } else if (!sd->sif) {
-                        cam->cam_mode = ov519_vga_mode;
-                        cam->nmodes = ARRAY_SIZE(ov519_vga_mode);
-                } else {
-                        cam->cam_mode = ov519_sif_mode;
-                        cam->nmodes = ARRAY_SIZE(ov519_sif_mode);
+                        break;
+                default:
+                        if (sd->sif) {
+                                cam->cam_mode = ov519_sif_mode;
+                                cam->nmodes = ARRAY_SIZE(ov519_sif_mode);
+                        }
+                        break;
                 }
                 break;
         case BRIDGE_W9968CF:
-                cam->cam_mode = w9968cf_vga_mode;
-                cam->nmodes = ARRAY_SIZE(w9968cf_vga_mode);
                 if (sd->sif)
-                        cam->nmodes--;
+                        cam->nmodes = ARRAY_SIZE(w9968cf_vga_mode) - 1;
 
                 /* w9968cf needs initialisation once the sensor is known */
-                if (w9968cf_init(sd) < 0)
-                        goto error;
+                w9968cf_init(sd);
                 break;
         }
-        sd->brightness = BRIGHTNESS_DEF;
-        if (sd->sensor == SEN_OV6630 || sd->sensor == SEN_OV66308AF)
-                sd->contrast = 200; /* The default is too low for the ov6630 */
-        else
-                sd->contrast = CONTRAST_DEF;
-        sd->colors = COLOR_DEF;
-        sd->hflip = HFLIP_DEF;
-        sd->vflip = VFLIP_DEF;
-        sd->autobrightness = AUTOBRIGHT_DEF;
-        if (sd->sensor == SEN_OV7670) {
-                sd->freq = OV7670_FREQ_DEF;
-                gspca_dev->ctrl_dis = (1 << FREQ_IDX) | (1 << COLOR_IDX);
-        } else {
-                sd->freq = FREQ_DEF;
-                gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX) |
-                                      (1 << OV7670_FREQ_IDX);
-        }
-        sd->quality = QUALITY_DEF;
-        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)
-                gspca_dev->ctrl_dis |= 1 << FREQ_IDX;
-        /* No controls for the OV2610/OV3610 */
-        if (sd->sensor == SEN_OV2610 || sd->sensor == SEN_OV3610)
-                gspca_dev->ctrl_dis |= 0xFF;
-
-        return 0;
-error:
-        PDEBUG(D_ERR, "OV519 Config failed");
-        return -EBUSY;
-}
 
-/* 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;
+        gspca_dev->ctrl_dis = ctrl_dis[sd->sensor];
 
         /* initialize the sensor */
         switch (sd->sensor) {
         case SEN_OV2610:
-                if (write_i2c_regvals(sd, norm_2610, ARRAY_SIZE(norm_2610)))
-                        return -EIO;
+                write_i2c_regvals(sd, norm_2610, ARRAY_SIZE(norm_2610));
+
                 /* Enable autogain, autoexpo, awb, bandfilter */
-                if (i2c_w_mask(sd, 0x13, 0x27, 0x27) < 0)
-                        return -EIO;
+                i2c_w_mask(sd, 0x13, 0x27, 0x27);
+                break;
+        case SEN_OV2610AE:
+                write_i2c_regvals(sd, norm_2610ae, ARRAY_SIZE(norm_2610ae));
+
+                /* enable autoexpo */
+                i2c_w_mask(sd, 0x13, 0x05, 0x05);
                 break;
         case SEN_OV3610:
-                if (write_i2c_regvals(sd, norm_3620b, ARRAY_SIZE(norm_3620b)))
-                        return -EIO;
+                write_i2c_regvals(sd, norm_3620b, ARRAY_SIZE(norm_3620b));
+
                 /* Enable autogain, autoexpo, awb, bandfilter */
-                if (i2c_w_mask(sd, 0x13, 0x27, 0x27) < 0)
-                        return -EIO;
+                i2c_w_mask(sd, 0x13, 0x27, 0x27);
                 break;
         case SEN_OV6620:
-                if (write_i2c_regvals(sd, norm_6x20, ARRAY_SIZE(norm_6x20)))
-                        return -EIO;
+                write_i2c_regvals(sd, norm_6x20, ARRAY_SIZE(norm_6x20));
                 break;
         case SEN_OV6630:
         case SEN_OV66308AF:
-                if (write_i2c_regvals(sd, norm_6x30, ARRAY_SIZE(norm_6x30)))
-                        return -EIO;
+                sd->ctrls[CONTRAST].def = 200;
+                                 /* The default is too low for the ov6630 */
+                write_i2c_regvals(sd, norm_6x30, ARRAY_SIZE(norm_6x30));
                 break;
         default:
 /*      case SEN_OV7610: */
 /*      case SEN_OV76BE: */
-                if (write_i2c_regvals(sd, norm_7610, ARRAY_SIZE(norm_7610)))
-                        return -EIO;
-                if (i2c_w_mask(sd, 0x0e, 0x00, 0x40))
-                        return -EIO;
+                write_i2c_regvals(sd, norm_7610, ARRAY_SIZE(norm_7610));
+                i2c_w_mask(sd, 0x0e, 0x00, 0x40);
                 break;
         case SEN_OV7620:
         case SEN_OV7620AE:
-                if (write_i2c_regvals(sd, norm_7620, ARRAY_SIZE(norm_7620)))
-                        return -EIO;
+                write_i2c_regvals(sd, norm_7620, ARRAY_SIZE(norm_7620));
                 break;
         case SEN_OV7640:
         case SEN_OV7648:
-                if (write_i2c_regvals(sd, norm_7640, ARRAY_SIZE(norm_7640)))
-                        return -EIO;
+                write_i2c_regvals(sd, norm_7640, ARRAY_SIZE(norm_7640));
+                break;
+        case SEN_OV7660:
+                i2c_w(sd, OV7670_R12_COM7, OV7670_COM7_RESET);
+                msleep(14);
+                reg_w(sd, OV519_R57_SNAPSHOT, 0x23);
+                write_regvals(sd, init_519_ov7660,
+                                ARRAY_SIZE(init_519_ov7660));
+                write_i2c_regvals(sd, norm_7660, ARRAY_SIZE(norm_7660));
+                sd->gspca_dev.curr_mode = 1;    /* 640x480 */
+                ov519_set_mode(sd);
+                ov519_set_fr(sd);
+                sd->ctrls[COLORS].max = 4;      /* 0..4 */
+                sd->ctrls[COLORS].val =
+                        sd->ctrls[COLORS].def = 2;
+                setcolors(gspca_dev);
+                sd->ctrls[CONTRAST].max = 6;    /* 0..6 */
+                sd->ctrls[CONTRAST].val =
+                        sd->ctrls[CONTRAST].def = 3;
+                setcontrast(gspca_dev);
+                sd->ctrls[BRIGHTNESS].max = 6;  /* 0..6 */
+                sd->ctrls[BRIGHTNESS].val =
+                        sd->ctrls[BRIGHTNESS].def = 3;
+                setbrightness(gspca_dev);
+                sd_reset_snapshot(gspca_dev);
+                ov51x_restart(sd);
+                ov51x_stop(sd);                 /* not in win traces */
+                ov51x_led_control(sd, 0);
                 break;
         case SEN_OV7670:
-                if (write_i2c_regvals(sd, norm_7670, ARRAY_SIZE(norm_7670)))
-                        return -EIO;
+                sd->ctrls[FREQ].max = 3;        /* auto */
+                sd->ctrls[FREQ].def = 3;
+                write_i2c_regvals(sd, norm_7670, ARRAY_SIZE(norm_7670));
                 break;
         case SEN_OV8610:
-                if (write_i2c_regvals(sd, norm_8610, ARRAY_SIZE(norm_8610)))
-                        return -EIO;
+                write_i2c_regvals(sd, norm_8610, ARRAY_SIZE(norm_8610));
+                break;
+        }
+        return gspca_dev->usb_err;
+error:
+        PDEBUG(D_ERR, "OV519 Config failed");
+        return -EINVAL;
+}
+
+/* function called at start time before URB creation */
+static int sd_isoc_init(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        switch (sd->bridge) {
+        case BRIDGE_OVFX2:
+                if (gspca_dev->width != 800)
+                        gspca_dev->cam.bulk_size = OVFX2_BULK_SIZE;
+                else
+                        gspca_dev->cam.bulk_size = 7 * 4096;
                 break;
         }
         return 0;
@@ -3243,7 +3524,7 @@ static int sd_init(struct gspca_dev *gspca_dev)
  *
  * Do not put any sensor-specific code in here (including I2C I/O functions)
  */
-static int ov511_mode_init_regs(struct sd *sd)
+static void ov511_mode_init_regs(struct sd *sd)
 {
         int hsegs, vsegs, packet_size, fps, needed;
         int interlaced = 0;
@@ -3253,8 +3534,9 @@ static int ov511_mode_init_regs(struct sd *sd)
         intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
         alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
         if (!alt) {
-                PDEBUG(D_ERR, "Couldn't get altsetting");
-                return -EIO;
+                err("Couldn't get altsetting");
+                sd->gspca_dev.usb_err = -EIO;
+                return;
         }
 
         packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
@@ -3357,8 +3639,6 @@ static int ov511_mode_init_regs(struct sd *sd)
 
         reg_w(sd, R51x_SYS_RESET, OV511_RESET_OMNICE);
         reg_w(sd, R51x_SYS_RESET, 0);
-
-        return 0;
 }
 
 /* Sets up the OV518/OV518+ with the given image parameters
@@ -3368,7 +3648,7 @@ static int ov511_mode_init_regs(struct sd *sd)
  *
  * Do not put any sensor-specific code in here (including I2C I/O functions)
  */
-static int ov518_mode_init_regs(struct sd *sd)
+static void ov518_mode_init_regs(struct sd *sd)
 {
         int hsegs, vsegs, packet_size;
         struct usb_host_interface *alt;
@@ -3377,15 +3657,15 @@ static int ov518_mode_init_regs(struct sd *sd)
         intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
         alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
         if (!alt) {
-                PDEBUG(D_ERR, "Couldn't get altsetting");
-                return -EIO;
+                err("Couldn't get altsetting");
+                sd->gspca_dev.usb_err = -EIO;
+                return;
         }
 
         packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
         ov518_reg_w32(sd, R51x_FIFO_PSIZE, packet_size & ~7, 2);
 
         /******** Set the mode ********/
-
         reg_w(sd, 0x2b, 0);
         reg_w(sd, 0x2c, 0);
         reg_w(sd, 0x2d, 0);
@@ -3419,7 +3699,7 @@ static int ov518_mode_init_regs(struct sd *sd)
         /* Windows driver does this here; who knows why */
         reg_w(sd, 0x2f, 0x80);
 
-        /******** Set the framerate  ********/
+        /******** Set the framerate ********/
         sd->clockdiv = 1;
 
         /* Mode independent, but framerate dependent, regs */
@@ -3482,11 +3762,8 @@ static int ov518_mode_init_regs(struct sd *sd)
         }
 
         reg_w(sd, 0x2f, 0x80);
-
-        return 0;
 }
 
-
 /* Sets up the OV519 with the given image parameters
  *
  * OV519 needs a completely different approach, until we can figure out what
@@ -3494,12 +3771,12 @@ static int ov518_mode_init_regs(struct sd *sd)
  *
  * Do not put any sensor-specific code in here (including I2C I/O functions)
  */
-static int ov519_mode_init_regs(struct sd *sd)
+static void ov519_mode_init_regs(struct sd *sd)
 {
         static const struct ov_regvals mode_init_519_ov7670[] = {
                 { 0x5d, 0x03 }, /* Turn off suspend mode */
                 { 0x53, 0x9f }, /* was 9b in 1.65-1.08 */
-                { 0x54, 0x0f }, /* bit2 (jpeg enable) */
+                { OV519_R54_EN_CLK1, 0x0f }, /* bit2 (jpeg enable) */
                 { 0xa2, 0x20 }, /* a2-a5 are undocumented */
                 { 0xa3, 0x18 },
                 { 0xa4, 0x04 },
@@ -3522,7 +3799,7 @@ static int ov519_mode_init_regs(struct sd *sd)
         static const struct ov_regvals mode_init_519[] = {
                 { 0x5d, 0x03 }, /* Turn off suspend mode */
                 { 0x53, 0x9f }, /* was 9b in 1.65-1.08 */
-                { 0x54, 0x0f }, /* bit2 (jpeg enable) */
+                { OV519_R54_EN_CLK1, 0x0f }, /* bit2 (jpeg enable) */
                 { 0xa2, 0x20 }, /* a2-a5 are undocumented */
                 { 0xa3, 0x18 },
                 { 0xa4, 0x04 },
@@ -3541,19 +3818,21 @@ static int ov519_mode_init_regs(struct sd *sd)
         };
 
         /******** Set the mode ********/
-        if (sd->sensor != SEN_OV7670) {
-                if (write_regvals(sd, mode_init_519,
-                                  ARRAY_SIZE(mode_init_519)))
-                        return -EIO;
+        switch (sd->sensor) {
+        default:
+                write_regvals(sd, mode_init_519, ARRAY_SIZE(mode_init_519));
                 if (sd->sensor == SEN_OV7640 ||
                     sd->sensor == SEN_OV7648) {
                         /* Select 8-bit input mode */
                         reg_w_mask(sd, OV519_R20_DFR, 0x10, 0x10);
                 }
-        } else {
-                if (write_regvals(sd, mode_init_519_ov7670,
-                                  ARRAY_SIZE(mode_init_519_ov7670)))
-                        return -EIO;
+                break;
+        case SEN_OV7660:
+                return;         /* done by ov519_set_mode/fr() */
+        case SEN_OV7670:
+                write_regvals(sd, mode_init_519_ov7670,
+                                ARRAY_SIZE(mode_init_519_ov7670));
+                break;
         }
 
         reg_w(sd, OV519_R10_H_SIZE,     sd->gspca_dev.width >> 4);
@@ -3649,17 +3928,16 @@ static int ov519_mode_init_regs(struct sd *sd)
                 }
                 break;
         }
-        return 0;
 }
 
-static int mode_init_ov_sensor_regs(struct sd *sd)
+static void mode_init_ov_sensor_regs(struct sd *sd)
 {
         struct gspca_dev *gspca_dev;
         int qvga, xstart, xend, ystart, yend;
-        __u8 v;
+        u8 v;
 
         gspca_dev = &sd->gspca_dev;
-        qvga = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv & 1;
+        qvga = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv & 1;
 
         /******** Mode (VGA/QVGA) and sensor specific regs ********/
         switch (sd->sensor) {
@@ -3671,7 +3949,26 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
                 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);
-                return 0;
+                return;
+        case SEN_OV2610AE: {
+                u8 v;
+
+                /* frame rates:
+                 *      10fps / 5 fps for 1600x1200
+                 *      40fps / 20fps for 800x600
+                 */
+                v = 80;
+                if (qvga) {
+                        if (sd->frame_rate < 25)
+                                v = 0x81;
+                } else {
+                        if (sd->frame_rate < 10)
+                                v = 0x81;
+                }
+                i2c_w(sd, 0x11, v);
+                i2c_w(sd, 0x12, qvga ? 0x60 : 0x20);
+                return;
+            }
         case SEN_OV3610:
                 if (qvga) {
                         xstart = (1040 - gspca_dev->width) / 2 + (0x1f << 4);
@@ -3695,7 +3992,7 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
                 i2c_w(sd, 0x18, xend >> 4);
                 i2c_w(sd, 0x19, ystart >> 3);
                 i2c_w(sd, 0x1a, yend >> 3);
-                return 0;
+                return;
         case SEN_OV8610:
                 /* For OV8610 qvga means qsvga */
                 i2c_w_mask(sd, OV7610_REG_COM_C, qvga ? (1 << 5) : 0, 1 << 5);
@@ -3706,7 +4003,7 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
                 break;
         case SEN_OV7610:
                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
-                i2c_w(sd, 0x35, qvga?0x1e:0x9e);
+                i2c_w(sd, 0x35, qvga ? 0x1e : 0x9e);
                 i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
                 i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
                 break;
@@ -3742,11 +4039,11 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
                 /* set COM7_FMT_VGA or COM7_FMT_QVGA
                  * do we need to set anything else?
                  *      HSTART etc are set in set_ov_sensor_window itself */
-                i2c_w_mask(sd, OV7670_REG_COM7,
+                i2c_w_mask(sd, OV7670_R12_COM7,
                          qvga ? OV7670_COM7_FMT_QVGA : OV7670_COM7_FMT_VGA,
                          OV7670_COM7_FMT_MASK);
                 i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
-                i2c_w_mask(sd, OV7670_REG_COM8, OV7670_COM8_AWB,
+                i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_AWB,
                                 OV7670_COM8_AWB);
                 if (qvga) {             /* QVGA from ov7670.c by
                                          * Jonathan Corbet */
@@ -3762,21 +4059,21 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
                 }
                 /* OV7670 hardware window registers are split across
                  * multiple locations */
-                i2c_w(sd, OV7670_REG_HSTART, xstart >> 3);
-                i2c_w(sd, OV7670_REG_HSTOP, xend >> 3);
-                v = i2c_r(sd, OV7670_REG_HREF);
+                i2c_w(sd, OV7670_R17_HSTART, xstart >> 3);
+                i2c_w(sd, OV7670_R18_HSTOP, xend >> 3);
+                v = i2c_r(sd, OV7670_R32_HREF);
                 v = (v & 0xc0) | ((xend & 0x7) << 3) | (xstart & 0x07);
                 msleep(10);     /* need to sleep between read and write to
                                  * same reg! */
-                i2c_w(sd, OV7670_REG_HREF, v);
+                i2c_w(sd, OV7670_R32_HREF, v);
 
-                i2c_w(sd, OV7670_REG_VSTART, ystart >> 2);
-                i2c_w(sd, OV7670_REG_VSTOP, yend >> 2);
-                v = i2c_r(sd, OV7670_REG_VREF);
+                i2c_w(sd, OV7670_R19_VSTART, ystart >> 2);
+                i2c_w(sd, OV7670_R1A_VSTOP, yend >> 2);
+                v = i2c_r(sd, OV7670_R03_VREF);
                 v = (v & 0xc0) | ((yend & 0x3) << 2) | (ystart & 0x03);
                 msleep(10);     /* need to sleep between read and write to
                                  * same reg! */
-                i2c_w(sd, OV7670_REG_VREF, v);
+                i2c_w(sd, OV7670_R03_VREF, v);
                 break;
         case SEN_OV6620:
                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
@@ -3789,44 +4086,51 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
                 i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
                 break;
         default:
-                return -EINVAL;
+                return;
         }
 
         /******** Clock programming ********/
         i2c_w(sd, 0x11, sd->clockdiv);
-
-        return 0;
 }
 
-static void sethvflip(struct sd *sd)
+/* this function works for bridge ov519 and sensors ov7660 and ov7670 only */
+static void sethvflip(struct gspca_dev *gspca_dev)
 {
-        if (sd->sensor != SEN_OV7670)
-                return;
+        struct sd *sd = (struct sd *) gspca_dev;
+
         if (sd->gspca_dev.streaming)
-                ov51x_stop(sd);
-        i2c_w_mask(sd, OV7670_REG_MVFP,
-                OV7670_MVFP_MIRROR * sd->hflip
-                        | OV7670_MVFP_VFLIP * sd->vflip,
+                reg_w(sd, OV519_R51_RESET1, 0x0f);      /* block stream */
+        i2c_w_mask(sd, OV7670_R1E_MVFP,
+                OV7670_MVFP_MIRROR * sd->ctrls[HFLIP].val
+                        | OV7670_MVFP_VFLIP * sd->ctrls[VFLIP].val,
                 OV7670_MVFP_MIRROR | OV7670_MVFP_VFLIP);
         if (sd->gspca_dev.streaming)
-                ov51x_restart(sd);
+                reg_w(sd, OV519_R51_RESET1, 0x00);      /* restart stream */
 }
 
-static int set_ov_sensor_window(struct sd *sd)
+static void set_ov_sensor_window(struct sd *sd)
 {
         struct gspca_dev *gspca_dev;
         int qvga, crop;
         int hwsbase, hwebase, vwsbase, vwebase, hwscale, vwscale;
-        int ret;
 
         /* mode setup is fully handled in mode_init_ov_sensor_regs for these */
-        if (sd->sensor == SEN_OV2610 || sd->sensor == SEN_OV3610 ||
-            sd->sensor == SEN_OV7670)
-                return mode_init_ov_sensor_regs(sd);
+        switch (sd->sensor) {
+        case SEN_OV2610:
+        case SEN_OV2610AE:
+        case SEN_OV3610:
+        case SEN_OV7670:
+                mode_init_ov_sensor_regs(sd);
+                return;
+        case SEN_OV7660:
+                ov519_set_mode(sd);
+                ov519_set_fr(sd);
+                return;
+        }
 
         gspca_dev = &sd->gspca_dev;
-        qvga = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv & 1;
-        crop = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv & 2;
+        qvga = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv & 1;
+        crop = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv & 2;
 
         /* The different sensor ICs handle setting up of window differently.
          * IF YOU SET IT WRONG, YOU WILL GET ALL ZERO ISOC DATA FROM OV51x!! */
@@ -3873,7 +4177,7 @@ static int set_ov_sensor_window(struct sd *sd)
                 vwsbase = vwebase = 0x03;
                 break;
         default:
-                return -EINVAL;
+                return;
         }
 
         switch (sd->sensor) {
@@ -3908,23 +4212,18 @@ static int set_ov_sensor_window(struct sd *sd)
                 }
         }
 
-        ret = mode_init_ov_sensor_regs(sd);
-        if (ret < 0)
-                return ret;
+        mode_init_ov_sensor_regs(sd);
 
         i2c_w(sd, 0x17, hwsbase);
         i2c_w(sd, 0x18, hwebase + (sd->sensor_width >> hwscale));
         i2c_w(sd, 0x19, vwsbase);
         i2c_w(sd, 0x1a, vwebase + (sd->sensor_height >> vwscale));
-
-        return 0;
 }
 
 /* -- start the camera -- */
 static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int ret = 0;
 
         /* Default for most bridges, allow bridge_mode_init_regs to override */
         sd->sensor_width = sd->gspca_dev.width;
@@ -3933,50 +4232,50 @@ static int sd_start(struct gspca_dev *gspca_dev)
         switch (sd->bridge) {
         case BRIDGE_OV511:
         case BRIDGE_OV511PLUS:
-                ret = ov511_mode_init_regs(sd);
+                ov511_mode_init_regs(sd);
                 break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
-                ret = ov518_mode_init_regs(sd);
+                ov518_mode_init_regs(sd);
                 break;
         case BRIDGE_OV519:
-                ret = ov519_mode_init_regs(sd);
+                ov519_mode_init_regs(sd);
                 break;
         /* case BRIDGE_OVFX2: nothing to do */
         case BRIDGE_W9968CF:
-                ret = w9968cf_mode_init_regs(sd);
+                w9968cf_mode_init_regs(sd);
                 break;
         }
-        if (ret < 0)
-                goto out;
 
-        ret = set_ov_sensor_window(sd);
-        if (ret < 0)
-                goto out;
+        set_ov_sensor_window(sd);
 
-        setcontrast(gspca_dev);
-        setbrightness(gspca_dev);
-        setcolors(gspca_dev);
-        sethvflip(sd);
-        setautobrightness(sd);
-        setfreq(sd);
+        if (!(sd->gspca_dev.ctrl_dis & (1 << CONTRAST)))
+                setcontrast(gspca_dev);
+        if (!(sd->gspca_dev.ctrl_dis & (1 << BRIGHTNESS)))
+                setbrightness(gspca_dev);
+        if (!(sd->gspca_dev.ctrl_dis & (1 << EXPOSURE)))
+                setexposure(gspca_dev);
+        if (!(sd->gspca_dev.ctrl_dis & (1 << COLORS)))
+                setcolors(gspca_dev);
+        if (!(sd->gspca_dev.ctrl_dis & ((1 << HFLIP) | (1 << VFLIP))))
+                sethvflip(gspca_dev);
+        if (!(sd->gspca_dev.ctrl_dis & (1 << AUTOBRIGHT)))
+                setautobright(gspca_dev);
+        if (!(sd->gspca_dev.ctrl_dis & (1 << AUTOGAIN)))
+                setautogain(gspca_dev);
+        if (!(sd->gspca_dev.ctrl_dis & (1 << FREQ)))
+                setfreq_i(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;
 
         sd->first_frame = 3;
 
-        ret = ov51x_restart(sd);
-        if (ret < 0)
-                goto out;
+        ov51x_restart(sd);
         ov51x_led_control(sd, 1);
-        return 0;
-out:
-        PDEBUG(D_ERR, "camera start error:%d", ret);
-        return ret;
+        return gspca_dev->usb_err;
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
@@ -3991,8 +4290,21 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
+        if (!sd->gspca_dev.present)
+                return;
         if (sd->bridge == BRIDGE_W9968CF)
                 w9968cf_stop0(sd);
+
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+        /* If the last button state is pressed, release it now! */
+        if (sd->snapshot_pressed) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                input_sync(gspca_dev->input_dev);
+                sd->snapshot_pressed = 0;
+        }
+#endif
+        if (sd->bridge == BRIDGE_OV519)
+                reg_w(sd, OV519_R57_SNAPSHOT, 0x23);
 }
 
 static void ov51x_handle_button(struct gspca_dev *gspca_dev, u8 state)
@@ -4000,7 +4312,7 @@ 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
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, state);
                 input_sync(gspca_dev->input_dev);
 #endif
@@ -4056,7 +4368,7 @@ static void ov511_pkt_scan(struct gspca_dev *gspca_dev,
                                 gspca_dev->last_packet_type = DISCARD_PACKET;
                                 return;
                         }
-                        /* Add 11 byte footer to frame, might be usefull */
+                        /* Add 11 byte footer to frame, might be useful */
                         gspca_frame_add(gspca_dev, LAST_PACKET, in, 11);
                         return;
                 } else {
@@ -4166,7 +4478,7 @@ static void ovfx2_pkt_scan(struct gspca_dev *gspca_dev,
         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 
         /* A short read signals EOF */
-        if (len < OVFX2_BULK_SIZE) {
+        if (len < gspca_dev->cam.bulk_size) {
                 /* If the frame is short, and it is one of the first ones
                    the sensor and bridge are still syncing, so drop it. */
                 if (sd->first_frame) {
@@ -4213,8 +4525,24 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int val;
+        static const struct ov_i2c_regvals brit_7660[][7] = {
+                {{0x0f, 0x6a}, {0x24, 0x40}, {0x25, 0x2b}, {0x26, 0x90},
+                        {0x27, 0xe0}, {0x28, 0xe0}, {0x2c, 0xe0}},
+                {{0x0f, 0x6a}, {0x24, 0x50}, {0x25, 0x40}, {0x26, 0xa1},
+                        {0x27, 0xc0}, {0x28, 0xc0}, {0x2c, 0xc0}},
+                {{0x0f, 0x6a}, {0x24, 0x68}, {0x25, 0x58}, {0x26, 0xc2},
+                        {0x27, 0xa0}, {0x28, 0xa0}, {0x2c, 0xa0}},
+                {{0x0f, 0x6a}, {0x24, 0x70}, {0x25, 0x68}, {0x26, 0xd3},
+                        {0x27, 0x80}, {0x28, 0x80}, {0x2c, 0x80}},
+                {{0x0f, 0x6a}, {0x24, 0x80}, {0x25, 0x70}, {0x26, 0xd3},
+                        {0x27, 0x20}, {0x28, 0x20}, {0x2c, 0x20}},
+                {{0x0f, 0x6a}, {0x24, 0x88}, {0x25, 0x78}, {0x26, 0xd3},
+                        {0x27, 0x40}, {0x28, 0x40}, {0x2c, 0x40}},
+                {{0x0f, 0x6a}, {0x24, 0x90}, {0x25, 0x80}, {0x26, 0xd4},
+                        {0x27, 0x60}, {0x28, 0x60}, {0x2c, 0x60}}
+        };
 
-        val = sd->brightness;
+        val = sd->ctrls[BRIGHTNESS].val;
         switch (sd->sensor) {
         case SEN_OV8610:
         case SEN_OV7610:
@@ -4229,13 +4557,17 @@ static void setbrightness(struct gspca_dev *gspca_dev)
         case SEN_OV7620:
         case SEN_OV7620AE:
                 /* 7620 doesn't like manual changes when in auto mode */
-                if (!sd->autobrightness)
+                if (!sd->ctrls[AUTOBRIGHT].val)
                         i2c_w(sd, OV7610_REG_BRT, val);
                 break;
+        case SEN_OV7660:
+                write_i2c_regvals(sd, brit_7660[val],
+                                ARRAY_SIZE(brit_7660[0]));
+                break;
         case SEN_OV7670:
 /*win trace
- *              i2c_w_mask(sd, OV7670_REG_COM8, 0, OV7670_COM8_AEC); */
-                i2c_w(sd, OV7670_REG_BRIGHT, ov7670_abs_to_sm(val));
+ *              i2c_w_mask(sd, OV7670_R13_COM8, 0, OV7670_COM8_AEC); */
+                i2c_w(sd, OV7670_R55_BRIGHT, ov7670_abs_to_sm(val));
                 break;
         }
 }
@@ -4244,8 +4576,66 @@ static void setcontrast(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int val;
+        static const struct ov_i2c_regvals contrast_7660[][31] = {
+                {{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf8}, {0x6f, 0xa0},
+                 {0x70, 0x58}, {0x71, 0x38}, {0x72, 0x30}, {0x73, 0x30},
+                 {0x74, 0x28}, {0x75, 0x28}, {0x76, 0x24}, {0x77, 0x24},
+                 {0x78, 0x22}, {0x79, 0x28}, {0x7a, 0x2a}, {0x7b, 0x34},
+                 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3d}, {0x7f, 0x65},
+                 {0x80, 0x70}, {0x81, 0x77}, {0x82, 0x7d}, {0x83, 0x83},
+                 {0x84, 0x88}, {0x85, 0x8d}, {0x86, 0x96}, {0x87, 0x9f},
+                 {0x88, 0xb0}, {0x89, 0xc4}, {0x8a, 0xd9}},
+                {{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf8}, {0x6f, 0x94},
+                 {0x70, 0x58}, {0x71, 0x40}, {0x72, 0x30}, {0x73, 0x30},
+                 {0x74, 0x30}, {0x75, 0x30}, {0x76, 0x2c}, {0x77, 0x24},
+                 {0x78, 0x22}, {0x79, 0x28}, {0x7a, 0x2a}, {0x7b, 0x31},
+                 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3d}, {0x7f, 0x62},
+                 {0x80, 0x6d}, {0x81, 0x75}, {0x82, 0x7b}, {0x83, 0x81},
+                 {0x84, 0x87}, {0x85, 0x8d}, {0x86, 0x98}, {0x87, 0xa1},
+                 {0x88, 0xb2}, {0x89, 0xc6}, {0x8a, 0xdb}},
+                {{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf0}, {0x6f, 0x84},
+                 {0x70, 0x58}, {0x71, 0x48}, {0x72, 0x40}, {0x73, 0x40},
+                 {0x74, 0x28}, {0x75, 0x28}, {0x76, 0x28}, {0x77, 0x24},
+                 {0x78, 0x26}, {0x79, 0x28}, {0x7a, 0x28}, {0x7b, 0x34},
+                 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3c}, {0x7f, 0x5d},
+                 {0x80, 0x68}, {0x81, 0x71}, {0x82, 0x79}, {0x83, 0x81},
+                 {0x84, 0x86}, {0x85, 0x8b}, {0x86, 0x95}, {0x87, 0x9e},
+                 {0x88, 0xb1}, {0x89, 0xc5}, {0x8a, 0xd9}},
+                {{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf0}, {0x6f, 0x70},
+                 {0x70, 0x58}, {0x71, 0x58}, {0x72, 0x48}, {0x73, 0x48},
+                 {0x74, 0x38}, {0x75, 0x40}, {0x76, 0x34}, {0x77, 0x34},
+                 {0x78, 0x2e}, {0x79, 0x28}, {0x7a, 0x24}, {0x7b, 0x22},
+                 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3c}, {0x7f, 0x58},
+                 {0x80, 0x63}, {0x81, 0x6e}, {0x82, 0x77}, {0x83, 0x80},
+                 {0x84, 0x87}, {0x85, 0x8f}, {0x86, 0x9c}, {0x87, 0xa9},
+                 {0x88, 0xc0}, {0x89, 0xd4}, {0x8a, 0xe6}},
+                {{0x6c, 0xa0}, {0x6d, 0xf0}, {0x6e, 0x90}, {0x6f, 0x80},
+                 {0x70, 0x70}, {0x71, 0x80}, {0x72, 0x60}, {0x73, 0x60},
+                 {0x74, 0x58}, {0x75, 0x60}, {0x76, 0x4c}, {0x77, 0x38},
+                 {0x78, 0x38}, {0x79, 0x2a}, {0x7a, 0x20}, {0x7b, 0x0e},
+                 {0x7c, 0x0a}, {0x7d, 0x14}, {0x7e, 0x26}, {0x7f, 0x46},
+                 {0x80, 0x54}, {0x81, 0x64}, {0x82, 0x70}, {0x83, 0x7c},
+                 {0x84, 0x87}, {0x85, 0x93}, {0x86, 0xa6}, {0x87, 0xb4},
+                 {0x88, 0xd0}, {0x89, 0xe5}, {0x8a, 0xf5}},
+                {{0x6c, 0x60}, {0x6d, 0x80}, {0x6e, 0x60}, {0x6f, 0x80},
+                 {0x70, 0x80}, {0x71, 0x80}, {0x72, 0x88}, {0x73, 0x30},
+                 {0x74, 0x70}, {0x75, 0x68}, {0x76, 0x64}, {0x77, 0x50},
+                 {0x78, 0x3c}, {0x79, 0x22}, {0x7a, 0x10}, {0x7b, 0x08},
+                 {0x7c, 0x06}, {0x7d, 0x0e}, {0x7e, 0x1a}, {0x7f, 0x3a},
+                 {0x80, 0x4a}, {0x81, 0x5a}, {0x82, 0x6b}, {0x83, 0x7b},
+                 {0x84, 0x89}, {0x85, 0x96}, {0x86, 0xaf}, {0x87, 0xc3},
+                 {0x88, 0xe1}, {0x89, 0xf2}, {0x8a, 0xfa}},
+                {{0x6c, 0x20}, {0x6d, 0x40}, {0x6e, 0x20}, {0x6f, 0x60},
+                 {0x70, 0x88}, {0x71, 0xc8}, {0x72, 0xc0}, {0x73, 0xb8},
+                 {0x74, 0xa8}, {0x75, 0xb8}, {0x76, 0x80}, {0x77, 0x5c},
+                 {0x78, 0x26}, {0x79, 0x10}, {0x7a, 0x08}, {0x7b, 0x04},
+                 {0x7c, 0x02}, {0x7d, 0x06}, {0x7e, 0x0a}, {0x7f, 0x22},
+                 {0x80, 0x33}, {0x81, 0x4c}, {0x82, 0x64}, {0x83, 0x7b},
+                 {0x84, 0x90}, {0x85, 0xa7}, {0x86, 0xc7}, {0x87, 0xde},
+                 {0x88, 0xf1}, {0x89, 0xf9}, {0x8a, 0xfd}},
+        };
 
-        val = sd->contrast;
+        val = sd->ctrls[CONTRAST].val;
         switch (sd->sensor) {
         case SEN_OV7610:
         case SEN_OV6620:
@@ -4256,7 +4646,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                 i2c_w_mask(sd, OV7610_REG_CNT, val >> 4, 0x0f);
                 break;
         case SEN_OV8610: {
-                static const __u8 ctab[] = {
+                static const u8 ctab[] = {
                         0x03, 0x09, 0x0b, 0x0f, 0x53, 0x6f, 0x35, 0x7f
                 };
 
@@ -4266,7 +4656,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
             }
         case SEN_OV7620:
         case SEN_OV7620AE: {
-                static const __u8 ctab[] = {
+                static const u8 ctab[] = {
                         0x01, 0x05, 0x09, 0x11, 0x15, 0x35, 0x37, 0x57,
                         0x5b, 0xa5, 0xa7, 0xc7, 0xc9, 0xcf, 0xef, 0xff
                 };
@@ -4275,19 +4665,43 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                 i2c_w(sd, 0x64, ctab[val >> 4]);
                 break;
             }
+        case SEN_OV7660:
+                write_i2c_regvals(sd, contrast_7660[val],
+                                        ARRAY_SIZE(contrast_7660[0]));
+                break;
         case SEN_OV7670:
                 /* check that this isn't just the same as ov7610 */
-                i2c_w(sd, OV7670_REG_CONTRAS, val >> 1);
+                i2c_w(sd, OV7670_R56_CONTRAS, val >> 1);
                 break;
         }
 }
 
+static void setexposure(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (!sd->ctrls[AUTOGAIN].val)
+                i2c_w(sd, 0x10, sd->ctrls[EXPOSURE].val);
+}
+
 static void setcolors(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int val;
+        static const struct ov_i2c_regvals colors_7660[][6] = {
+                {{0x4f, 0x28}, {0x50, 0x2a}, {0x51, 0x02}, {0x52, 0x0a},
+                 {0x53, 0x19}, {0x54, 0x23}},
+                {{0x4f, 0x47}, {0x50, 0x4a}, {0x51, 0x03}, {0x52, 0x11},
+                 {0x53, 0x2c}, {0x54, 0x3e}},
+                {{0x4f, 0x66}, {0x50, 0x6b}, {0x51, 0x05}, {0x52, 0x19},
+                 {0x53, 0x40}, {0x54, 0x59}},
+                {{0x4f, 0x84}, {0x50, 0x8b}, {0x51, 0x06}, {0x52, 0x20},
+                 {0x53, 0x53}, {0x54, 0x73}},
+                {{0x4f, 0xa3}, {0x50, 0xab}, {0x51, 0x08}, {0x52, 0x28},
+                 {0x53, 0x66}, {0x54, 0x8e}},
+        };
 
-        val = sd->colors;
+        val = sd->ctrls[COLORS].val;
         switch (sd->sensor) {
         case SEN_OV8610:
         case SEN_OV7610:
@@ -4309,6 +4723,10 @@ static void setcolors(struct gspca_dev *gspca_dev)
         case SEN_OV7648:
                 i2c_w(sd, OV7610_REG_SAT, val & 0xf0);
                 break;
+        case SEN_OV7660:
+                write_i2c_regvals(sd, colors_7660[val],
+                                        ARRAY_SIZE(colors_7660[0]));
+                break;
         case SEN_OV7670:
                 /* supported later once I work out how to do it
                  * transparently fail now! */
@@ -4317,45 +4735,56 @@ static void setcolors(struct gspca_dev *gspca_dev)
         }
 }
 
-static void setautobrightness(struct sd *sd)
+static void setautobright(struct gspca_dev *gspca_dev)
 {
-        if (sd->sensor == SEN_OV7640 || sd->sensor == SEN_OV7648 ||
-            sd->sensor == SEN_OV7670 ||
-            sd->sensor == SEN_OV2610 || sd->sensor == SEN_OV3610)
-                return;
+        struct sd *sd = (struct sd *) gspca_dev;
 
-        i2c_w_mask(sd, 0x2d, sd->autobrightness ? 0x10 : 0x00, 0x10);
+        i2c_w_mask(sd, 0x2d, sd->ctrls[AUTOBRIGHT].val ? 0x10 : 0x00, 0x10);
 }
 
-static void setfreq(struct sd *sd)
+static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
 {
-        if (sd->sensor == SEN_OV2610 || sd->sensor == SEN_OV3610)
-                return;
+        struct sd *sd = (struct sd *) gspca_dev;
 
-        if (sd->sensor == SEN_OV7670) {
-                switch (sd->freq) {
+        sd->ctrls[AUTOGAIN].val = val;
+        if (val) {
+                gspca_dev->ctrl_inac |= (1 << EXPOSURE);
+        } else {
+                gspca_dev->ctrl_inac &= ~(1 << EXPOSURE);
+                sd->ctrls[EXPOSURE].val = i2c_r(sd, 0x10);
+        }
+        if (gspca_dev->streaming)
+                setautogain(gspca_dev);
+        return gspca_dev->usb_err;
+}
+
+static void setfreq_i(struct sd *sd)
+{
+        if (sd->sensor == SEN_OV7660
+         || sd->sensor == SEN_OV7670) {
+                switch (sd->ctrls[FREQ].val) {
                 case 0: /* Banding filter disabled */
-                        i2c_w_mask(sd, OV7670_REG_COM8, 0, OV7670_COM8_BFILT);
+                        i2c_w_mask(sd, OV7670_R13_COM8, 0, OV7670_COM8_BFILT);
                         break;
                 case 1: /* 50 hz */
-                        i2c_w_mask(sd, OV7670_REG_COM8, OV7670_COM8_BFILT,
+                        i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_BFILT,
                                    OV7670_COM8_BFILT);
-                        i2c_w_mask(sd, OV7670_REG_COM11, 0x08, 0x18);
+                        i2c_w_mask(sd, OV7670_R3B_COM11, 0x08, 0x18);
                         break;
                 case 2: /* 60 hz */
-                        i2c_w_mask(sd, OV7670_REG_COM8, OV7670_COM8_BFILT,
+                        i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_BFILT,
                                    OV7670_COM8_BFILT);
-                        i2c_w_mask(sd, OV7670_REG_COM11, 0x00, 0x18);
+                        i2c_w_mask(sd, OV7670_R3B_COM11, 0x00, 0x18);
                         break;
-                case 3: /* Auto hz */
-                        i2c_w_mask(sd, OV7670_REG_COM8, OV7670_COM8_BFILT,
+                case 3: /* Auto hz - ov7670 only */
+                        i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_BFILT,
                                    OV7670_COM8_BFILT);
-                        i2c_w_mask(sd, OV7670_REG_COM11, OV7670_COM11_HZAUTO,
+                        i2c_w_mask(sd, OV7670_R3B_COM11, OV7670_COM11_HZAUTO,
                                    0x18);
                         break;
                 }
         } else {
-                switch (sd->freq) {
+                switch (sd->ctrls[FREQ].val) {
                 case 0: /* Banding filter disabled */
                         i2c_w_mask(sd, 0x2d, 0x00, 0x04);
                         i2c_w_mask(sd, 0x2a, 0x00, 0x80);
@@ -4387,135 +4816,15 @@ static void setfreq(struct sd *sd)
                 }
         }
 }
-
-static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
+static void setfreq(struct gspca_dev *gspca_dev)
 {
         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;
-}
+        setfreq_i(sd);
 
-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;
-
-        sd->hflip = val;
-        if (gspca_dev->streaming)
-                sethvflip(sd);
-        return 0;
-}
-
-static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->hflip;
-        return 0;
-}
-
-static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->vflip = val;
-        if (gspca_dev->streaming)
-                sethvflip(sd);
-        return 0;
-}
-
-static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->vflip;
-        return 0;
-}
-
-static int sd_setautobrightness(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->autobrightness = val;
-        if (gspca_dev->streaming)
-                setautobrightness(sd);
-        return 0;
-}
-
-static int sd_getautobrightness(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->autobrightness;
-        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(sd);
-                /* Ugly but necessary */
-                if (sd->bridge == BRIDGE_W9968CF)
-                        w9968cf_set_crop_window(sd);
-        }
-        return 0;
-}
-
-static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->freq;
-        return 0;
+        /* Ugly but necessary */
+        if (sd->bridge == BRIDGE_W9968CF)
+                w9968cf_set_crop_window(sd);
 }
 
 static int sd_querymenu(struct gspca_dev *gspca_dev,
@@ -4593,6 +4902,7 @@ static const struct sd_desc sd_desc = {
         .nctrls = ARRAY_SIZE(sd_ctrls),
         .config = sd_config,
         .init = sd_init,
+        .isoc_init = sd_isoc_init,
         .start = sd_start,
         .stopN = sd_stopN,
         .stop0 = sd_stop0,
@@ -4601,27 +4911,27 @@ static const struct sd_desc sd_desc = {
         .querymenu = sd_querymenu,
         .get_jcomp = sd_get_jcomp,
         .set_jcomp = sd_set_jcomp,
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .other_input = 1,
 #endif
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x4003), .driver_info = BRIDGE_W9968CF },
         {USB_DEVICE(0x041e, 0x4052), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x041e, 0x405f), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x041e, 0x4060), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x041e, 0x4061), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x041e, 0x4064),
-         .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
+                .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
         {USB_DEVICE(0x041e, 0x4067), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x041e, 0x4068),
-         .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
+                .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 | BRIDGE_INVERT_LED },
+                .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 },
@@ -4635,7 +4945,7 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0b62, 0x0059), .driver_info = BRIDGE_OVFX2 },
         {USB_DEVICE(0x0e96, 0xc001), .driver_info = BRIDGE_OVFX2 },
         {USB_DEVICE(0x1046, 0x9967), .driver_info = BRIDGE_W9968CF },
-        {USB_DEVICE(0x8020, 0xEF04), .driver_info = BRIDGE_OVFX2 },
+        {USB_DEVICE(0x8020, 0xef04), .driver_info = BRIDGE_OVFX2 },
         {}
 };
 
@@ -4663,17 +4973,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/ov534.c b/drivers/media/video/gspca/ov534.c
index 96cb3a976581..0c6369b7fe18 100644
--- a/drivers/media/video/gspca/ov534.c
+++ b/drivers/media/video/gspca/ov534.c
@@ -1,5 +1,5 @@
 /*
- * ov534-ov772x gspca driver
+ * ov534-ov7xxx gspca driver
  *
  * Copyright (C) 2008 Antonio Ospite <ospite@studenti.unina.it>
  * Copyright (C) 2008 Jim Paris <jim@jtan.com>
@@ -49,54 +49,59 @@ MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
 MODULE_DESCRIPTION("GSPCA/OV534 USB Camera Driver");
 MODULE_LICENSE("GPL");
 
+/* controls */
+enum e_ctrl {
+        BRIGHTNESS,
+        CONTRAST,
+        GAIN,
+        EXPOSURE,
+        AGC,
+        AWB,
+        AEC,
+        SHARPNESS,
+        HFLIP,
+        VFLIP,
+        COLORS,
+        LIGHTFREQ,
+        NCTRLS          /* number of controls */
+};
+
 /* specific webcam descriptor */
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
+
+        struct gspca_ctrl ctrls[NCTRLS];
+
         __u32 last_pts;
         u16 last_fid;
         u8 frame_rate;
 
-        u8 brightness;
-        u8 contrast;
-        u8 gain;
-        u8 exposure;
-        u8 agc;
-        u8 awb;
-        u8 aec;
-        s8 sharpness;
-        u8 hflip;
-        u8 vflip;
-        u8 freqfltr;
+        u8 sensor;
+};
+enum sensors {
+        SENSOR_OV767x,
+        SENSOR_OV772x,
+        NSENSORS
 };
 
 /* V4L2 controls supported by the driver */
-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_setexposure(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
+static void setbrightness(struct gspca_dev *gspca_dev);
+static void setcontrast(struct gspca_dev *gspca_dev);
+static void setgain(struct gspca_dev *gspca_dev);
+static void setexposure(struct gspca_dev *gspca_dev);
 static int sd_setagc(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getagc(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_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);
-static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
-static int sd_setawb(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getawb(struct gspca_dev *gspca_dev, __s32 *val);
-static int sd_setaec(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getaec(struct gspca_dev *gspca_dev, __s32 *val);
-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_setfreqfltr(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getfreqfltr(struct gspca_dev *gspca_dev, __s32 *val);
-static int sd_querymenu(struct gspca_dev *gspca_dev,
-                struct v4l2_querymenu *menu);
+static void setawb(struct gspca_dev *gspca_dev);
+static void setaec(struct gspca_dev *gspca_dev);
+static void setsharpness(struct gspca_dev *gspca_dev);
+static void sethvflip(struct gspca_dev *gspca_dev);
+static void setcolors(struct gspca_dev *gspca_dev);
+static void setlightfreq(struct gspca_dev *gspca_dev);
+
+static int sd_start(struct gspca_dev *gspca_dev);
+static void sd_stopN(struct gspca_dev *gspca_dev);
 
 static const struct ctrl sd_ctrls[] = {
-        {       /* 0 */
+[BRIGHTNESS] = {
                 {
                         .id      = V4L2_CID_BRIGHTNESS,
                         .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -104,13 +109,11 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 255,
                         .step    = 1,
-#define BRIGHTNESS_DEF 0
-                        .default_value = BRIGHTNESS_DEF,
+                        .default_value = 0,
                 },
-                .set = sd_setbrightness,
-                .get = sd_getbrightness,
+                .set_control = setbrightness
         },
-        {       /* 1 */
+[CONTRAST] = {
                 {
                         .id      = V4L2_CID_CONTRAST,
                         .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -118,13 +121,11 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 255,
                         .step    = 1,
-#define CONTRAST_DEF 32
-                        .default_value = CONTRAST_DEF,
+                        .default_value = 32,
                 },
-                .set = sd_setcontrast,
-                .get = sd_getcontrast,
+                .set_control = setcontrast
         },
-        {       /* 2 */
+[GAIN] = {
                 {
                         .id      = V4L2_CID_GAIN,
                         .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -132,13 +133,11 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 63,
                         .step    = 1,
-#define GAIN_DEF 20
-                        .default_value = GAIN_DEF,
+                        .default_value = 20,
                 },
-                .set = sd_setgain,
-                .get = sd_getgain,
+                .set_control = setgain
         },
-        {       /* 3 */
+[EXPOSURE] = {
                 {
                         .id      = V4L2_CID_EXPOSURE,
                         .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -146,13 +145,11 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 255,
                         .step    = 1,
-#define EXPO_DEF 120
-                        .default_value = EXPO_DEF,
+                        .default_value = 120,
                 },
-                .set = sd_setexposure,
-                .get = sd_getexposure,
+                .set_control = setexposure
         },
-        {       /* 4 */
+[AGC] = {
                 {
                         .id      = V4L2_CID_AUTOGAIN,
                         .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -160,14 +157,11 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 1,
                         .step    = 1,
-#define AGC_DEF 1
-                        .default_value = AGC_DEF,
+                        .default_value = 1,
                 },
-                .set = sd_setagc,
-                .get = sd_getagc,
+                .set = sd_setagc
         },
-#define AWB_IDX 5
-        {       /* 5 */
+[AWB] = {
                 {
                         .id      = V4L2_CID_AUTO_WHITE_BALANCE,
                         .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -175,13 +169,11 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 1,
                         .step    = 1,
-#define AWB_DEF 1
-                        .default_value = AWB_DEF,
+                        .default_value = 1,
                 },
-                .set = sd_setawb,
-                .get = sd_getawb,
+                .set_control = setawb
         },
-        {       /* 6 */
+[AEC] = {
                 {
                         .id      = V4L2_CID_EXPOSURE_AUTO,
                         .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -189,13 +181,11 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 1,
                         .step    = 1,
-#define AEC_DEF 1
-                        .default_value = AEC_DEF,
+                        .default_value = 1,
                 },
-                .set = sd_setaec,
-                .get = sd_getaec,
+                .set_control = setaec
         },
-        {       /* 7 */
+[SHARPNESS] = {
                 {
                         .id      = V4L2_CID_SHARPNESS,
                         .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -203,13 +193,11 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 63,
                         .step    = 1,
-#define SHARPNESS_DEF 0
-                        .default_value = SHARPNESS_DEF,
+                        .default_value = 0,
                 },
-                .set = sd_setsharpness,
-                .get = sd_getsharpness,
+                .set_control = setsharpness
         },
-        {       /* 8 */
+[HFLIP] = {
                 {
                         .id      = V4L2_CID_HFLIP,
                         .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -217,13 +205,11 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 1,
                         .step    = 1,
-#define HFLIP_DEF 0
-                        .default_value = HFLIP_DEF,
+                        .default_value = 0,
                 },
-                .set = sd_sethflip,
-                .get = sd_gethflip,
+                .set_control = sethvflip
         },
-        {       /* 9 */
+[VFLIP] = {
                 {
                         .id      = V4L2_CID_VFLIP,
                         .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -231,13 +217,23 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 1,
                         .step    = 1,
-#define VFLIP_DEF 0
-                        .default_value = VFLIP_DEF,
+                        .default_value = 0,
                 },
-                .set = sd_setvflip,
-                .get = sd_getvflip,
+                .set_control = sethvflip
         },
-        {       /* 10 */
+[COLORS] = {
+                {
+                        .id      = V4L2_CID_SATURATION,
+                        .type    = V4L2_CTRL_TYPE_INTEGER,
+                        .name    = "Saturation",
+                        .minimum = 0,
+                        .maximum = 6,
+                        .step    = 1,
+                        .default_value = 3,
+                },
+                .set_control = setcolors
+        },
+[LIGHTFREQ] = {
                 {
                         .id      = V4L2_CID_POWER_LINE_FREQUENCY,
                         .type    = V4L2_CTRL_TYPE_MENU,
@@ -245,11 +241,9 @@ static const struct ctrl sd_ctrls[] = {
                         .minimum = 0,
                         .maximum = 1,
                         .step    = 1,
-#define FREQFLTR_DEF 0
-                        .default_value = FREQFLTR_DEF,
+                        .default_value = 0,
                 },
-                .set = sd_setfreqfltr,
-                .get = sd_getfreqfltr,
+                .set_control = setlightfreq
         },
 };
 
@@ -265,6 +259,16 @@ static const struct v4l2_pix_format ov772x_mode[] = {
          .colorspace = V4L2_COLORSPACE_SRGB,
          .priv = 0},
 };
+static const struct v4l2_pix_format ov767x_mode[] = {
+        {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+        {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG},
+};
 
 static const u8 qvga_rates[] = {125, 100, 75, 60, 50, 40, 30};
 static const u8 vga_rates[] = {60, 50, 40, 30, 15};
@@ -280,7 +284,288 @@ static const struct framerates ov772x_framerates[] = {
         },
 };
 
-static const u8 bridge_init[][2] = {
+struct reg_array {
+        const u8 (*val)[2];
+        int len;
+};
+
+static const u8 bridge_init_767x[][2] = {
+/* comments from the ms-win file apollo7670.set */
+/* str1 */
+        {0xf1, 0x42},
+        {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, 0x00},
+        {0x1d, 0x48},
+        {0x1d, 0x00},
+        {0x1d, 0xff},
+        {0x1d, 0x02},
+        {0x1d, 0x58},
+        {0x1d, 0x00},
+        {0x1c, 0x0a},
+        {0x1d, 0x0a},
+        {0x1d, 0x0e},
+        {0xc0, 0x50},   /* HSize 640 */
+        {0xc1, 0x3c},   /* VSize 480 */
+        {0x34, 0x05},   /* enable Audio Suspend mode */
+        {0xc2, 0x0c},   /* Input YUV */
+        {0xc3, 0xf9},   /* enable PRE */
+        {0x34, 0x05},   /* enable Audio Suspend mode */
+        {0xe7, 0x2e},   /* this solves failure of "SuspendResumeTest" */
+        {0x31, 0xf9},   /* enable 1.8V Suspend */
+        {0x35, 0x02},   /* turn on JPEG */
+        {0xd9, 0x10},
+        {0x25, 0x42},   /* GPIO[8]:Input */
+        {0x94, 0x11},   /* If the default setting is loaded when
+                         * system boots up, this flag is closed here */
+};
+static const u8 sensor_init_767x[][2] = {
+        {0x12, 0x80},
+        {0x11, 0x03},
+        {0x3a, 0x04},
+        {0x12, 0x00},
+        {0x17, 0x13},
+        {0x18, 0x01},
+        {0x32, 0xb6},
+        {0x19, 0x02},
+        {0x1a, 0x7a},
+        {0x03, 0x0a},
+        {0x0c, 0x00},
+        {0x3e, 0x00},
+        {0x70, 0x3a},
+        {0x71, 0x35},
+        {0x72, 0x11},
+        {0x73, 0xf0},
+        {0xa2, 0x02},
+        {0x7a, 0x2a},   /* set Gamma=1.6 below */
+        {0x7b, 0x12},
+        {0x7c, 0x1d},
+        {0x7d, 0x2d},
+        {0x7e, 0x45},
+        {0x7f, 0x50},
+        {0x80, 0x59},
+        {0x81, 0x62},
+        {0x82, 0x6b},
+        {0x83, 0x73},
+        {0x84, 0x7b},
+        {0x85, 0x8a},
+        {0x86, 0x98},
+        {0x87, 0xb2},
+        {0x88, 0xca},
+        {0x89, 0xe0},
+        {0x13, 0xe0},
+        {0x00, 0x00},
+        {0x10, 0x00},
+        {0x0d, 0x40},
+        {0x14, 0x38},   /* gain max 16x */
+        {0xa5, 0x05},
+        {0xab, 0x07},
+        {0x24, 0x95},
+        {0x25, 0x33},
+        {0x26, 0xe3},
+        {0x9f, 0x78},
+        {0xa0, 0x68},
+        {0xa1, 0x03},
+        {0xa6, 0xd8},
+        {0xa7, 0xd8},
+        {0xa8, 0xf0},
+        {0xa9, 0x90},
+        {0xaa, 0x94},
+        {0x13, 0xe5},
+        {0x0e, 0x61},
+        {0x0f, 0x4b},
+        {0x16, 0x02},
+        {0x21, 0x02},
+        {0x22, 0x91},
+        {0x29, 0x07},
+        {0x33, 0x0b},
+        {0x35, 0x0b},
+        {0x37, 0x1d},
+        {0x38, 0x71},
+        {0x39, 0x2a},
+        {0x3c, 0x78},
+        {0x4d, 0x40},
+        {0x4e, 0x20},
+        {0x69, 0x00},
+        {0x6b, 0x4a},
+        {0x74, 0x10},
+        {0x8d, 0x4f},
+        {0x8e, 0x00},
+        {0x8f, 0x00},
+        {0x90, 0x00},
+        {0x91, 0x00},
+        {0x96, 0x00},
+        {0x9a, 0x80},
+        {0xb0, 0x84},
+        {0xb1, 0x0c},
+        {0xb2, 0x0e},
+        {0xb3, 0x82},
+        {0xb8, 0x0a},
+        {0x43, 0x0a},
+        {0x44, 0xf0},
+        {0x45, 0x34},
+        {0x46, 0x58},
+        {0x47, 0x28},
+        {0x48, 0x3a},
+        {0x59, 0x88},
+        {0x5a, 0x88},
+        {0x5b, 0x44},
+        {0x5c, 0x67},
+        {0x5d, 0x49},
+        {0x5e, 0x0e},
+        {0x6c, 0x0a},
+        {0x6d, 0x55},
+        {0x6e, 0x11},
+        {0x6f, 0x9f},
+        {0x6a, 0x40},
+        {0x01, 0x40},
+        {0x02, 0x40},
+        {0x13, 0xe7},
+        {0x4f, 0x80},
+        {0x50, 0x80},
+        {0x51, 0x00},
+        {0x52, 0x22},
+        {0x53, 0x5e},
+        {0x54, 0x80},
+        {0x58, 0x9e},
+        {0x41, 0x08},
+        {0x3f, 0x00},
+        {0x75, 0x04},
+        {0x76, 0xe1},
+        {0x4c, 0x00},
+        {0x77, 0x01},
+        {0x3d, 0xc2},
+        {0x4b, 0x09},
+        {0xc9, 0x60},
+        {0x41, 0x38},   /* jfm: auto sharpness + auto de-noise  */
+        {0x56, 0x40},
+        {0x34, 0x11},
+        {0x3b, 0xc2},
+        {0xa4, 0x8a},   /* Night mode trigger point */
+        {0x96, 0x00},
+        {0x97, 0x30},
+        {0x98, 0x20},
+        {0x99, 0x20},
+        {0x9a, 0x84},
+        {0x9b, 0x29},
+        {0x9c, 0x03},
+        {0x9d, 0x4c},
+        {0x9e, 0x3f},
+        {0x78, 0x04},
+        {0x79, 0x01},
+        {0xc8, 0xf0},
+        {0x79, 0x0f},
+        {0xc8, 0x00},
+        {0x79, 0x10},
+        {0xc8, 0x7e},
+        {0x79, 0x0a},
+        {0xc8, 0x80},
+        {0x79, 0x0b},
+        {0xc8, 0x01},
+        {0x79, 0x0c},
+        {0xc8, 0x0f},
+        {0x79, 0x0d},
+        {0xc8, 0x20},
+        {0x79, 0x09},
+        {0xc8, 0x80},
+        {0x79, 0x02},
+        {0xc8, 0xc0},
+        {0x79, 0x03},
+        {0xc8, 0x20},
+        {0x79, 0x26},
+};
+static const u8 bridge_start_vga_767x[][2] = {
+/* str59 JPG */
+        {0x94, 0xaa},
+        {0xf1, 0x42},
+        {0xe5, 0x04},
+        {0xc0, 0x50},
+        {0xc1, 0x3c},
+        {0xc2, 0x0c},
+        {0x35, 0x02},   /* turn on JPEG */
+        {0xd9, 0x10},
+        {0xda, 0x00},   /* for higher clock rate(30fps) */
+        {0x34, 0x05},   /* enable Audio Suspend mode */
+        {0xc3, 0xf9},   /* enable PRE */
+        {0x8c, 0x00},   /* CIF VSize LSB[2:0] */
+        {0x8d, 0x1c},   /* output YUV */
+/*      {0x34, 0x05},    * enable Audio Suspend mode (?) */
+        {0x50, 0x00},   /* H/V divider=0 */
+        {0x51, 0xa0},   /* input H=640/4 */
+        {0x52, 0x3c},   /* input V=480/4 */
+        {0x53, 0x00},   /* offset X=0 */
+        {0x54, 0x00},   /* offset Y=0 */
+        {0x55, 0x00},   /* H/V size[8]=0 */
+        {0x57, 0x00},   /* H-size[9]=0 */
+        {0x5c, 0x00},   /* output size[9:8]=0 */
+        {0x5a, 0xa0},   /* output H=640/4 */
+        {0x5b, 0x78},   /* output V=480/4 */
+        {0x1c, 0x0a},
+        {0x1d, 0x0a},
+        {0x94, 0x11},
+};
+static const u8 sensor_start_vga_767x[][2] = {
+        {0x11, 0x01},
+        {0x1e, 0x04},
+        {0x19, 0x02},
+        {0x1a, 0x7a},
+};
+static const u8 bridge_start_qvga_767x[][2] = {
+/* str86 JPG */
+        {0x94, 0xaa},
+        {0xf1, 0x42},
+        {0xe5, 0x04},
+        {0xc0, 0x80},
+        {0xc1, 0x60},
+        {0xc2, 0x0c},
+        {0x35, 0x02},   /* turn on JPEG */
+        {0xd9, 0x10},
+        {0xc0, 0x50},   /* CIF HSize 640 */
+        {0xc1, 0x3c},   /* CIF VSize 480 */
+        {0x8c, 0x00},   /* CIF VSize LSB[2:0] */
+        {0x8d, 0x1c},   /* output YUV */
+        {0x34, 0x05},   /* enable Audio Suspend mode */
+        {0xc2, 0x4c},   /* output YUV and Enable DCW */
+        {0xc3, 0xf9},   /* enable PRE */
+        {0x1c, 0x00},   /* indirect addressing */
+        {0x1d, 0x48},   /* output YUV422 */
+        {0x50, 0x89},   /* H/V divider=/2; plus DCW AVG */
+        {0x51, 0xa0},   /* DCW input H=640/4 */
+        {0x52, 0x78},   /* DCW input V=480/4 */
+        {0x53, 0x00},   /* offset X=0 */
+        {0x54, 0x00},   /* offset Y=0 */
+        {0x55, 0x00},   /* H/V size[8]=0 */
+        {0x57, 0x00},   /* H-size[9]=0 */
+        {0x5c, 0x00},   /* DCW output size[9:8]=0 */
+        {0x5a, 0x50},   /* DCW output H=320/4 */
+        {0x5b, 0x3c},   /* DCW output V=240/4 */
+        {0x1c, 0x0a},
+        {0x1d, 0x0a},
+        {0x94, 0x11},
+};
+static const u8 sensor_start_qvga_767x[][2] = {
+        {0x11, 0x01},
+        {0x1e, 0x04},
+        {0x19, 0x02},
+        {0x1a, 0x7a},
+};
+
+static const u8 bridge_init_772x[][2] = {
         { 0xc2, 0x0c },
         { 0x88, 0xf8 },
         { 0xc3, 0x69 },
@@ -338,7 +623,7 @@ static const u8 bridge_init[][2] = {
         { 0xc1, 0x3c },
         { 0xc2, 0x0c },
 };
-static const u8 sensor_init[][2] = {
+static const u8 sensor_init_772x[][2] = {
         { 0x12, 0x80 },
         { 0x11, 0x01 },
 /*fixme: better have a delay?*/
@@ -431,7 +716,7 @@ static const u8 sensor_init[][2] = {
         { 0x8e, 0x00 },         /* De-noise threshold */
         { 0x0c, 0xd0 }
 };
-static const u8 bridge_start_vga[][2] = {
+static const u8 bridge_start_vga_772x[][2] = {
         {0x1c, 0x00},
         {0x1d, 0x40},
         {0x1d, 0x02},
@@ -442,7 +727,7 @@ static const u8 bridge_start_vga[][2] = {
         {0xc0, 0x50},
         {0xc1, 0x3c},
 };
-static const u8 sensor_start_vga[][2] = {
+static const u8 sensor_start_vga_772x[][2] = {
         {0x12, 0x00},
         {0x17, 0x26},
         {0x18, 0xa0},
@@ -452,7 +737,7 @@ static const u8 sensor_start_vga[][2] = {
         {0x2c, 0xf0},
         {0x65, 0x20},
 };
-static const u8 bridge_start_qvga[][2] = {
+static const u8 bridge_start_qvga_772x[][2] = {
         {0x1c, 0x00},
         {0x1d, 0x40},
         {0x1d, 0x02},
@@ -463,7 +748,7 @@ static const u8 bridge_start_qvga[][2] = {
         {0xc0, 0x28},
         {0xc1, 0x1e},
 };
-static const u8 sensor_start_qvga[][2] = {
+static const u8 sensor_start_qvga_772x[][2] = {
         {0x12, 0x40},
         {0x17, 0x3f},
         {0x18, 0x50},
@@ -479,15 +764,20 @@ static void ov534_reg_write(struct gspca_dev *gspca_dev, u16 reg, u8 val)
         struct usb_device *udev = gspca_dev->dev;
         int ret;
 
-        PDEBUG(D_USBO, "reg=0x%04x, val=0%02x", reg, val);
+        if (gspca_dev->usb_err < 0)
+                return;
+
+        PDEBUG(D_USBO, "SET 01 0000 %04x %02x", reg, val);
         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, "write failed");
+        if (ret < 0) {
+                err("write failed %d", ret);
+                gspca_dev->usb_err = ret;
+        }
 }
 
 static u8 ov534_reg_read(struct gspca_dev *gspca_dev, u16 reg)
@@ -495,14 +785,18 @@ static u8 ov534_reg_read(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=0x%04x, data=0x%02x", reg, gspca_dev->usb_buf[0]);
-        if (ret < 0)
-                PDEBUG(D_ERR, "read failed");
+        PDEBUG(D_USBI, "GET 01 0000 %04x %02x", reg, gspca_dev->usb_buf[0]);
+        if (ret < 0) {
+                err("read failed %d", ret);
+                gspca_dev->usb_err = ret;
+        }
         return gspca_dev->usb_buf[0];
 }
 
@@ -558,13 +852,15 @@ static int sccb_check_status(struct gspca_dev *gspca_dev)
 
 static void sccb_reg_write(struct gspca_dev *gspca_dev, u8 reg, u8 val)
 {
-        PDEBUG(D_USBO, "reg: 0x%02x, val: 0x%02x", reg, val);
+        PDEBUG(D_USBO, "sccb write: %02x %02x", reg, val);
         ov534_reg_write(gspca_dev, OV534_REG_SUBADDR, reg);
         ov534_reg_write(gspca_dev, OV534_REG_WRITE, val);
         ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_3);
 
-        if (!sccb_check_status(gspca_dev))
-                PDEBUG(D_ERR, "sccb_reg_write failed");
+        if (!sccb_check_status(gspca_dev)) {
+                err("sccb_reg_write failed");
+                gspca_dev->usb_err = -EIO;
+        }
 }
 
 static u8 sccb_reg_read(struct gspca_dev *gspca_dev, u16 reg)
@@ -572,11 +868,11 @@ static u8 sccb_reg_read(struct gspca_dev *gspca_dev, u16 reg)
         ov534_reg_write(gspca_dev, OV534_REG_SUBADDR, reg);
         ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_2);
         if (!sccb_check_status(gspca_dev))
-                PDEBUG(D_ERR, "sccb_reg_read failed 1");
+                err("sccb_reg_read failed 1");
 
         ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_READ_2);
         if (!sccb_check_status(gspca_dev))
-                PDEBUG(D_ERR, "sccb_reg_read failed 2");
+                err("sccb_reg_read failed 2");
 
         return ov534_reg_read(gspca_dev, OV534_REG_READ);
 }
@@ -635,6 +931,8 @@ static void set_frame_rate(struct gspca_dev *gspca_dev)
                 {30, 0x04, 0x41, 0x04},
         };
 
+        if (sd->sensor != SENSOR_OV772x)
+                return;
         if (gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv == 0) {
                 r = rate_0;
                 i = ARRAY_SIZE(rate_0);
@@ -658,15 +956,28 @@ static void set_frame_rate(struct gspca_dev *gspca_dev)
 static void setbrightness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        int val;
 
-        sccb_reg_write(gspca_dev, 0x9b, sd->brightness);
+        val = sd->ctrls[BRIGHTNESS].val;
+        if (sd->sensor == SENSOR_OV767x) {
+                if (val < 0)
+                        val = 0x80 - val;
+                sccb_reg_write(gspca_dev, 0x55, val);   /* bright */
+        } else {
+                sccb_reg_write(gspca_dev, 0x9b, val);
+        }
 }
 
 static void setcontrast(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        u8 val;
 
-        sccb_reg_write(gspca_dev, 0x9c, sd->contrast);
+        val = sd->ctrls[CONTRAST].val;
+        if (sd->sensor == SENSOR_OV767x)
+                sccb_reg_write(gspca_dev, 0x56, val);   /* contras */
+        else
+                sccb_reg_write(gspca_dev, 0x9c, val);
 }
 
 static void setgain(struct gspca_dev *gspca_dev)
@@ -674,10 +985,10 @@ static void setgain(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         u8 val;
 
-        if (sd->agc)
+        if (sd->ctrls[AGC].val)
                 return;
 
-        val = sd->gain;
+        val = sd->ctrls[GAIN].val;
         switch (val & 0x30) {
         case 0x00:
                 val &= 0x0f;
@@ -704,25 +1015,32 @@ static void setexposure(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         u8 val;
 
-        if (sd->aec)
+        if (sd->ctrls[AEC].val)
                 return;
 
-        /* 'val' is one byte and represents half of the exposure value we are
-         * going to set into registers, a two bytes value:
-         *
-         *    MSB: ((u16) val << 1) >> 8   == val >> 7
-         *    LSB: ((u16) val << 1) & 0xff == val << 1
-         */
-        val = sd->exposure;
-        sccb_reg_write(gspca_dev, 0x08, val >> 7);
-        sccb_reg_write(gspca_dev, 0x10, val << 1);
+        val = sd->ctrls[EXPOSURE].val;
+        if (sd->sensor == SENSOR_OV767x) {
+
+                /* set only aec[9:2] */
+                sccb_reg_write(gspca_dev, 0x10, val);   /* aech */
+        } else {
+
+                /* 'val' is one byte and represents half of the exposure value
+                 * we are going to set into registers, a two bytes value:
+                 *
+                 *    MSB: ((u16) val << 1) >> 8   == val >> 7
+                 *    LSB: ((u16) val << 1) & 0xff == val << 1
+                 */
+                sccb_reg_write(gspca_dev, 0x08, val >> 7);
+                sccb_reg_write(gspca_dev, 0x10, val << 1);
+        }
 }
 
 static void setagc(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        if (sd->agc) {
+        if (sd->ctrls[AGC].val) {
                 sccb_reg_write(gspca_dev, 0x13,
                                 sccb_reg_read(gspca_dev, 0x13) | 0x04);
                 sccb_reg_write(gspca_dev, 0x64,
@@ -741,15 +1059,17 @@ static void setawb(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        if (sd->awb) {
+        if (sd->ctrls[AWB].val) {
                 sccb_reg_write(gspca_dev, 0x13,
                                 sccb_reg_read(gspca_dev, 0x13) | 0x02);
-                sccb_reg_write(gspca_dev, 0x63,
+                if (sd->sensor == SENSOR_OV772x)
+                        sccb_reg_write(gspca_dev, 0x63,
                                 sccb_reg_read(gspca_dev, 0x63) | 0xc0);
         } else {
                 sccb_reg_write(gspca_dev, 0x13,
                                 sccb_reg_read(gspca_dev, 0x13) & ~0x02);
-                sccb_reg_write(gspca_dev, 0x63,
+                if (sd->sensor == SENSOR_OV772x)
+                        sccb_reg_write(gspca_dev, 0x63,
                                 sccb_reg_read(gspca_dev, 0x63) & ~0xc0);
         }
 }
@@ -757,14 +1077,22 @@ static void setawb(struct gspca_dev *gspca_dev)
 static void setaec(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        u8 data;
 
-        if (sd->aec)
+        data = sd->sensor == SENSOR_OV767x ?
+                        0x05 :          /* agc + aec */
+                        0x01;           /* agc */
+        if (sd->ctrls[AEC].val)
                 sccb_reg_write(gspca_dev, 0x13,
-                                sccb_reg_read(gspca_dev, 0x13) | 0x01);
+                                sccb_reg_read(gspca_dev, 0x13) | data);
         else {
                 sccb_reg_write(gspca_dev, 0x13,
-                                sccb_reg_read(gspca_dev, 0x13) & ~0x01);
-                setexposure(gspca_dev);
+                                sccb_reg_read(gspca_dev, 0x13) & ~data);
+                if (sd->sensor == SENSOR_OV767x)
+                        sd->ctrls[EXPOSURE].val =
+                                sccb_reg_read(gspca_dev, 10);   /* aech */
+                else
+                        setexposure(gspca_dev);
         }
 }
 
@@ -773,43 +1101,67 @@ static void setsharpness(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         u8 val;
 
-        val = sd->sharpness;
+        val = sd->ctrls[SHARPNESS].val;
         sccb_reg_write(gspca_dev, 0x91, val);   /* Auto de-noise threshold */
         sccb_reg_write(gspca_dev, 0x8e, val);   /* De-noise threshold */
 }
 
-static void sethflip(struct gspca_dev *gspca_dev)
+static void sethvflip(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        u8 val;
 
-        if (sd->hflip == 0)
-                sccb_reg_write(gspca_dev, 0x0c,
-                                sccb_reg_read(gspca_dev, 0x0c) | 0x40);
-        else
-                sccb_reg_write(gspca_dev, 0x0c,
-                                sccb_reg_read(gspca_dev, 0x0c) & ~0x40);
+        if (sd->sensor == SENSOR_OV767x) {
+                val = sccb_reg_read(gspca_dev, 0x1e);   /* mvfp */
+                val &= ~0x30;
+                if (sd->ctrls[HFLIP].val)
+                        val |= 0x20;
+                if (sd->ctrls[VFLIP].val)
+                        val |= 0x10;
+                sccb_reg_write(gspca_dev, 0x1e, val);
+        } else {
+                val = sccb_reg_read(gspca_dev, 0x0c);
+                val &= ~0xc0;
+                if (sd->ctrls[HFLIP].val == 0)
+                        val |= 0x40;
+                if (sd->ctrls[VFLIP].val == 0)
+                        val |= 0x80;
+                sccb_reg_write(gspca_dev, 0x0c, val);
+        }
 }
 
-static void setvflip(struct gspca_dev *gspca_dev)
+static void setcolors(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        u8 val;
+        int i;
+        static u8 color_tb[][6] = {
+                {0x42, 0x42, 0x00, 0x11, 0x30, 0x41},
+                {0x52, 0x52, 0x00, 0x16, 0x3c, 0x52},
+                {0x66, 0x66, 0x00, 0x1b, 0x4b, 0x66},
+                {0x80, 0x80, 0x00, 0x22, 0x5e, 0x80},
+                {0x9a, 0x9a, 0x00, 0x29, 0x71, 0x9a},
+                {0xb8, 0xb8, 0x00, 0x31, 0x87, 0xb8},
+                {0xdd, 0xdd, 0x00, 0x3b, 0xa2, 0xdd},
+        };
 
-        if (sd->vflip == 0)
-                sccb_reg_write(gspca_dev, 0x0c,
-                                sccb_reg_read(gspca_dev, 0x0c) | 0x80);
-        else
-                sccb_reg_write(gspca_dev, 0x0c,
-                                sccb_reg_read(gspca_dev, 0x0c) & ~0x80);
+        val = sd->ctrls[COLORS].val;
+        for (i = 0; i < ARRAY_SIZE(color_tb[0]); i++)
+                sccb_reg_write(gspca_dev, 0x4f + i, color_tb[val][i]);
 }
 
-static void setfreqfltr(struct gspca_dev *gspca_dev)
+static void setlightfreq(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        u8 val;
 
-        if (sd->freqfltr == 0)
-                sccb_reg_write(gspca_dev, 0x2b, 0x00);
-        else
-                sccb_reg_write(gspca_dev, 0x2b, 0x9e);
+        val = sd->ctrls[LIGHTFREQ].val ? 0x9e : 0x00;
+        if (sd->sensor == SENSOR_OV767x) {
+                sccb_reg_write(gspca_dev, 0x2a, 0x00);
+                if (val)
+                        val = 0x9d;     /* insert dummy to 25fps for 50Hz */
+        }
+        sccb_reg_write(gspca_dev, 0x2b, val);
 }
 
 
@@ -822,39 +1174,33 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         cam = &gspca_dev->cam;
 
+        cam->ctrls = sd->ctrls;
+
+        /* the auto white balance control works only when auto gain is set */
+        if (sd_ctrls[AGC].qctrl.default_value == 0)
+                gspca_dev->ctrl_inac |= (1 << AWB);
+
         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;
 
         sd->frame_rate = 30;
 
-        sd->brightness = BRIGHTNESS_DEF;
-        sd->contrast = CONTRAST_DEF;
-        sd->gain = GAIN_DEF;
-        sd->exposure = EXPO_DEF;
-#if AGC_DEF != 0
-        sd->agc = AGC_DEF;
-#else
-        gspca_dev->ctrl_inac |= (1 << AWB_IDX);
-#endif
-        sd->awb = AWB_DEF;
-        sd->aec = AEC_DEF;
-        sd->sharpness = SHARPNESS_DEF;
-        sd->hflip = HFLIP_DEF;
-        sd->vflip = VFLIP_DEF;
-        sd->freqfltr = FREQFLTR_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 struct reg_array bridge_init[NSENSORS] = {
+        [SENSOR_OV767x] = {bridge_init_767x, ARRAY_SIZE(bridge_init_767x)},
+        [SENSOR_OV772x] = {bridge_init_772x, ARRAY_SIZE(bridge_init_772x)},
+        };
+        static const struct reg_array sensor_init[NSENSORS] = {
+        [SENSOR_OV767x] = {sensor_init_767x, ARRAY_SIZE(sensor_init_767x)},
+        [SENSOR_OV772x] = {sensor_init_772x, ARRAY_SIZE(sensor_init_772x)},
+        };
 
         /* reset bridge */
         ov534_reg_write(gspca_dev, 0xe7, 0x3a);
@@ -875,52 +1221,104 @@ static int sd_init(struct gspca_dev *gspca_dev)
         sensor_id |= sccb_reg_read(gspca_dev, 0x0b);
         PDEBUG(D_PROBE, "Sensor ID: %04x", sensor_id);
 
+        if ((sensor_id & 0xfff0) == 0x7670) {
+                sd->sensor = SENSOR_OV767x;
+                gspca_dev->ctrl_dis = (1 << GAIN) |
+                                        (1 << AGC) |
+                                        (1 << SHARPNESS);       /* auto */
+                sd->ctrls[BRIGHTNESS].min = -127;
+                sd->ctrls[BRIGHTNESS].max = 127;
+                sd->ctrls[BRIGHTNESS].def = 0;
+                sd->ctrls[CONTRAST].max = 0x80;
+                sd->ctrls[CONTRAST].def = 0x40;
+                sd->ctrls[EXPOSURE].min = 0x08;
+                sd->ctrls[EXPOSURE].max = 0x60;
+                sd->ctrls[EXPOSURE].def = 0x13;
+                sd->ctrls[SHARPNESS].max = 9;
+                sd->ctrls[SHARPNESS].def = 4;
+                sd->ctrls[HFLIP].def = 1;
+                gspca_dev->cam.cam_mode = ov767x_mode;
+                gspca_dev->cam.nmodes = ARRAY_SIZE(ov767x_mode);
+        } else {
+                sd->sensor = SENSOR_OV772x;
+                gspca_dev->ctrl_dis = (1 << COLORS);
+                gspca_dev->cam.bulk = 1;
+                gspca_dev->cam.bulk_size = 16384;
+                gspca_dev->cam.bulk_nurbs = 2;
+                gspca_dev->cam.mode_framerates = ov772x_framerates;
+        }
+
         /* initialize */
-        reg_w_array(gspca_dev, bridge_init,
-                        ARRAY_SIZE(bridge_init));
+        reg_w_array(gspca_dev, bridge_init[sd->sensor].val,
+                        bridge_init[sd->sensor].len);
         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;
+        sccb_w_array(gspca_dev, sensor_init[sd->sensor].val,
+                        sensor_init[sd->sensor].len);
+        if (sd->sensor == SENSOR_OV767x)
+                sd_start(gspca_dev);
+        sd_stopN(gspca_dev);
+/*      set_frame_rate(gspca_dev);      */
+
+        return gspca_dev->usb_err;
 }
 
 static int sd_start(struct gspca_dev *gspca_dev)
 {
+        struct sd *sd = (struct sd *) gspca_dev;
         int mode;
+        static const struct reg_array bridge_start[NSENSORS][2] = {
+        [SENSOR_OV767x] = {{bridge_start_qvga_767x,
+                                        ARRAY_SIZE(bridge_start_qvga_767x)},
+                        {bridge_start_vga_767x,
+                                        ARRAY_SIZE(bridge_start_vga_767x)}},
+        [SENSOR_OV772x] = {{bridge_start_qvga_772x,
+                                        ARRAY_SIZE(bridge_start_qvga_772x)},
+                        {bridge_start_vga_772x,
+                                        ARRAY_SIZE(bridge_start_vga_772x)}},
+        };
+        static const struct reg_array sensor_start[NSENSORS][2] = {
+        [SENSOR_OV767x] = {{sensor_start_qvga_767x,
+                                        ARRAY_SIZE(sensor_start_qvga_767x)},
+                        {sensor_start_vga_767x,
+                                        ARRAY_SIZE(sensor_start_vga_767x)}},
+        [SENSOR_OV772x] = {{sensor_start_qvga_772x,
+                                        ARRAY_SIZE(sensor_start_qvga_772x)},
+                        {sensor_start_vga_772x,
+                                        ARRAY_SIZE(sensor_start_vga_772x)}},
+        };
+
+        /* (from ms-win trace) */
+        if (sd->sensor == SENSOR_OV767x)
+                sccb_reg_write(gspca_dev, 0x1e, 0x04);
+                                        /* black sun enable ? */
+
+        mode = gspca_dev->curr_mode;    /* 0: 320x240, 1: 640x480 */
+        reg_w_array(gspca_dev, bridge_start[sd->sensor][mode].val,
+                                bridge_start[sd->sensor][mode].len);
+        sccb_w_array(gspca_dev, sensor_start[sd->sensor][mode].val,
+                                sensor_start[sd->sensor][mode].len);
 
-        mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
-        if (mode != 0) {        /* 320x240 */
-                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_vga,
-                                ARRAY_SIZE(bridge_start_vga));
-                sccb_w_array(gspca_dev, sensor_start_vga,
-                                ARRAY_SIZE(sensor_start_vga));
-        }
         set_frame_rate(gspca_dev);
 
-        setagc(gspca_dev);
+        if (!(gspca_dev->ctrl_dis & (1 << AGC)))
+                setagc(gspca_dev);
         setawb(gspca_dev);
         setaec(gspca_dev);
-        setgain(gspca_dev);
+        if (!(gspca_dev->ctrl_dis & (1 << GAIN)))
+                setgain(gspca_dev);
         setexposure(gspca_dev);
         setbrightness(gspca_dev);
         setcontrast(gspca_dev);
-        setsharpness(gspca_dev);
-        setvflip(gspca_dev);
-        sethflip(gspca_dev);
-        setfreqfltr(gspca_dev);
+        if (!(gspca_dev->ctrl_dis & (1 << SHARPNESS)))
+                setsharpness(gspca_dev);
+        sethvflip(gspca_dev);
+        if (!(gspca_dev->ctrl_dis & (1 << COLORS)))
+                setcolors(gspca_dev);
+        setlightfreq(gspca_dev);
 
         ov534_set_led(gspca_dev, 1);
         ov534_reg_write(gspca_dev, 0xe0, 0x00);
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
@@ -946,9 +1344,11 @@ 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, 2048);
+                len = min(remaining_len, payload_len);
 
                 /* Payloads are prefixed with a UVC-style header.  We
                    consider a frame to start when the FID toggles, or the PTS
@@ -988,8 +1388,9 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                 /* If this packet is marked as EOF, end the frame */
                 } else if (data[1] & UVC_STREAM_EOF) {
                         sd->last_pts = 0;
-                        if (gspca_dev->image_len + len - 12 !=
-                            gspca_dev->width * gspca_dev->height * 2) {
+                        if (gspca_dev->pixfmt == V4L2_PIX_FMT_YUYV
+                         && gspca_dev->image_len + len - 12 !=
+                                   gspca_dev->width * gspca_dev->height * 2) {
                                 PDEBUG(D_PACK, "wrong sized frame");
                                 goto discard;
                         }
@@ -1015,212 +1416,27 @@ scan_next:
         } while (remaining_len > 0);
 }
 
-/* controls */
-static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->gain = val;
-        if (gspca_dev->streaming)
-                setgain(gspca_dev);
-        return 0;
-}
-
-static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->gain;
-        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 0;
-}
-
-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_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_setagc(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        sd->agc = val;
+        sd->ctrls[AGC].val = val;
 
-        if (gspca_dev->streaming) {
-
-                /* 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);
-                setagc(gspca_dev);
+        /* the auto white balance control works only
+         * when auto gain is set */
+        if (val) {
+                gspca_dev->ctrl_inac &= ~(1 << AWB);
+        } else {
+                gspca_dev->ctrl_inac |= (1 << AWB);
+                if (sd->ctrls[AWB].val) {
+                        sd->ctrls[AWB].val = 0;
+                        if (gspca_dev->streaming)
+                                setawb(gspca_dev);
+                }
         }
-        return 0;
-}
-
-static int sd_getagc(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->agc;
-        return 0;
-}
-
-static int sd_setawb(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->awb = val;
-        if (gspca_dev->streaming)
-                setawb(gspca_dev);
-        return 0;
-}
-
-static int sd_getawb(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->awb;
-        return 0;
-}
-
-static int sd_setaec(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->aec = val;
         if (gspca_dev->streaming)
-                setaec(gspca_dev);
-        return 0;
-}
-
-static int sd_getaec(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->aec;
-        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 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_sethflip(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->hflip = val;
-        if (gspca_dev->streaming)
-                sethflip(gspca_dev);
-        return 0;
-}
-
-static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->hflip;
-        return 0;
-}
-
-static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->vflip = val;
-        if (gspca_dev->streaming)
-                setvflip(gspca_dev);
-        return 0;
-}
-
-static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->vflip;
-        return 0;
-}
-
-static int sd_setfreqfltr(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->freqfltr = val;
-        if (gspca_dev->streaming)
-                setfreqfltr(gspca_dev);
-        return 0;
-}
-
-static int sd_getfreqfltr(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->freqfltr;
-        return 0;
+                setagc(gspca_dev);
+        return gspca_dev->usb_err;
 }
 
 static int sd_querymenu(struct gspca_dev *gspca_dev,
@@ -1243,34 +1459,26 @@ static int sd_querymenu(struct gspca_dev *gspca_dev,
 }
 
 /* get stream parameters (framerate) */
-static int sd_get_streamparm(struct gspca_dev *gspca_dev,
+static void sd_get_streamparm(struct gspca_dev *gspca_dev,
                              struct v4l2_streamparm *parm)
 {
         struct v4l2_captureparm *cp = &parm->parm.capture;
         struct v4l2_fract *tpf = &cp->timeperframe;
         struct sd *sd = (struct sd *) gspca_dev;
 
-        if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return -EINVAL;
-
         cp->capability |= V4L2_CAP_TIMEPERFRAME;
         tpf->numerator = 1;
         tpf->denominator = sd->frame_rate;
-
-        return 0;
 }
 
 /* set stream parameters (framerate) */
-static int sd_set_streamparm(struct gspca_dev *gspca_dev,
+static void sd_set_streamparm(struct gspca_dev *gspca_dev,
                              struct v4l2_streamparm *parm)
 {
         struct v4l2_captureparm *cp = &parm->parm.capture;
         struct v4l2_fract *tpf = &cp->timeperframe;
         struct sd *sd = (struct sd *) gspca_dev;
 
-        if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return -EINVAL;
-
         /* Set requested framerate */
         sd->frame_rate = tpf->denominator / tpf->numerator;
         if (gspca_dev->streaming)
@@ -1279,8 +1487,6 @@ static int sd_set_streamparm(struct gspca_dev *gspca_dev,
         /* Return the actual framerate */
         tpf->numerator = 1;
         tpf->denominator = sd->frame_rate;
-
-        return 0;
 }
 
 /* sub-driver description */
@@ -1299,8 +1505,9 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x1415, 0x2000)},
+        {USB_DEVICE(0x06f8, 0x3002)},
         {}
 };
 
@@ -1327,19 +1534,12 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/ov534_9.c b/drivers/media/video/gspca/ov534_9.c
index bbe5a030e3b4..aaf5428c57f5 100644
--- a/drivers/media/video/gspca/ov534_9.c
+++ b/drivers/media/video/gspca/ov534_9.c
@@ -785,7 +785,7 @@ static void reg_w_i(struct gspca_dev *gspca_dev, u16 reg, u8 val)
                               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);
+                err("reg_w failed %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -810,7 +810,7 @@ static u8 reg_r(struct gspca_dev *gspca_dev, u16 reg)
                               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);
+                err("reg_r err %d", ret);
                 gspca_dev->usb_err = ret;
         }
         return gspca_dev->usb_buf[0];
@@ -848,7 +848,7 @@ static void sccb_write(struct gspca_dev *gspca_dev, u8 reg, u8 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");
+                err("sccb_write failed");
 }
 
 static u8 sccb_read(struct gspca_dev *gspca_dev, u16 reg)
@@ -856,11 +856,11 @@ 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");
+                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");
+                err("sccb_read failed 2");
 
         return reg_r(gspca_dev, OV534_REG_READ);
 }
@@ -945,7 +945,6 @@ static void setautogain(struct gspca_dev *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)
@@ -1430,7 +1429,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x06f8, 0x3003)},
         {}
 };
@@ -1458,19 +1457,12 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/pac207.c b/drivers/media/video/gspca/pac207.c
index a40f8893310d..81739a2f205e 100644
--- a/drivers/media/video/gspca/pac207.c
+++ b/drivers/media/video/gspca/pac207.c
@@ -1,7 +1,7 @@
 /*
  * Pixart PAC207BCA library
  *
- * Copyright (C) 2008 Hans de Goede <hdgoede@redhat.com>
+ * Copyright (C) 2008 Hans de Goede <hdegoede@redhat.com>
  * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
  * Copyleft (C) 2005 Michel Xhaard mxhaard@magic.fr
  *
@@ -28,7 +28,7 @@
 #include <linux/input.h>
 #include "gspca.h"
 
-MODULE_AUTHOR("Hans de Goede <hdgoede@redhat.com>");
+MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
 MODULE_DESCRIPTION("Pixart PAC207");
 MODULE_LICENSE("GPL");
 
@@ -45,7 +45,7 @@ MODULE_LICENSE("GPL");
 
 #define PAC207_GAIN_MIN                 0
 #define PAC207_GAIN_MAX                 31
-#define PAC207_GAIN_DEFAULT             9 /* power on default: 9 */
+#define PAC207_GAIN_DEFAULT             9 /* power on default: 9 */
 #define PAC207_GAIN_KNEE                31
 
 #define PAC207_AUTOGAIN_DEADZONE        30
@@ -162,7 +162,7 @@ static const __u8 pac207_sensor_init[][8] = {
         {0x10, 0x12, 0x0d, 0x12, 0x0c, 0x01, 0x29, 0x84},
         {0x49, 0x64, 0x64, 0x64, 0x04, 0x10, 0xf0, 0x30},
         {0x00, 0x00, 0x00, 0x70, 0xa0, 0xf8, 0x00, 0x00},
-        {0x32, 0x00, 0x96, 0x00, 0xA2, 0x02, 0xaf, 0x00},
+        {0x32, 0x00, 0x96, 0x00, 0xa2, 0x02, 0xaf, 0x00},
 };
 
 static int pac207_write_regs(struct gspca_dev *gspca_dev, u16 index,
@@ -178,8 +178,7 @@ static int pac207_write_regs(struct gspca_dev *gspca_dev, u16 index,
                         0x00, index,
                         gspca_dev->usb_buf, length, PAC207_CTRL_TIMEOUT);
         if (err < 0)
-                PDEBUG(D_ERR,
-                        "Failed to write registers to index 0x%04X, error %d)",
+                err("Failed to write registers to index 0x%04X, error %d)",
                         index, err);
 
         return err;
@@ -195,7 +194,7 @@ static int pac207_write_reg(struct gspca_dev *gspca_dev, u16 index, u16 value)
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                         value, index, NULL, 0, PAC207_CTRL_TIMEOUT);
         if (err)
-                PDEBUG(D_ERR, "Failed to write a register (index 0x%04X,"
+                err("Failed to write a register (index 0x%04X,"
                         " value 0x%02X, error %d)", index, value, err);
 
         return err;
@@ -211,8 +210,7 @@ static int pac207_read_reg(struct gspca_dev *gspca_dev, u16 index)
                         0x00, index,
                         gspca_dev->usb_buf, 1, PAC207_CTRL_TIMEOUT);
         if (res < 0) {
-                PDEBUG(D_ERR,
-                        "Failed to read a register (index 0x%04X, error %d)",
+                err("Failed to read a register (index 0x%04X, error %d)",
                         index, res);
                 return res;
         }
@@ -230,7 +228,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         idreg[0] = pac207_read_reg(gspca_dev, 0x0000);
         idreg[1] = pac207_read_reg(gspca_dev, 0x0001);
-        idreg[0] = ((idreg[0] & 0x0F) << 4) | ((idreg[1] & 0xf0) >> 4);
+        idreg[0] = ((idreg[0] & 0x0f) << 4) | ((idreg[1] & 0xf0) >> 4);
         idreg[1] = idreg[1] & 0x0f;
         PDEBUG(D_PROBE, "Pixart Sensor ID 0x%02X Chips ID 0x%02X",
                 idreg[0], idreg[1]);
@@ -496,7 +494,7 @@ static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrput packet length */
@@ -526,13 +524,13 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .dq_callback = pac207_do_auto_gain,
         .pkt_scan = sd_pkt_scan,
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x4028)},
         {USB_DEVICE(0x093a, 0x2460)},
         {USB_DEVICE(0x093a, 0x2461)},
@@ -572,17 +570,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/pac7302.c b/drivers/media/video/gspca/pac7302.c
index a66df07d7625..5615d7bd8304 100644
--- a/drivers/media/video/gspca/pac7302.c
+++ b/drivers/media/video/gspca/pac7302.c
@@ -393,7 +393,7 @@ static const __u8 page3_7302[] = {
 
 static void reg_w_buf(struct gspca_dev *gspca_dev,
                   __u8 index,
-                  const char *buffer, int len)
+                  const u8 *buffer, int len)
 {
         int ret;
 
@@ -408,9 +408,8 @@ static void reg_w_buf(struct gspca_dev *gspca_dev,
                         index, gspca_dev->usb_buf, len,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w_buf(): "
-                "Failed to write registers to index 0x%x, error %i",
-                index, ret);
+                err("reg_w_buf failed index 0x%02x, error %d",
+                        index, ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -432,9 +431,8 @@ static void reg_w(struct gspca_dev *gspca_dev,
                         0, index, gspca_dev->usb_buf, 1,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w(): "
-                "Failed to write register to index 0x%x, value 0x%x, error %i",
-                index, value, ret);
+                err("reg_w() failed index 0x%02x, value 0x%02x, error %d",
+                        index, value, ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -468,10 +466,9 @@ static void reg_w_page(struct gspca_dev *gspca_dev,
                                 0, index, gspca_dev->usb_buf, 1,
                                 500);
                 if (ret < 0) {
-                        PDEBUG(D_ERR, "reg_w_page(): "
-                        "Failed to write register to index 0x%x, "
-                        "value 0x%x, error %i",
-                        index, page[index], ret);
+                        err("reg_w_page() failed index 0x%02x, "
+                        "value 0x%02x, error %d",
+                                index, page[index], ret);
                         gspca_dev->usb_err = ret;
                         break;
                 }
@@ -900,9 +897,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 (gspca_dev->streaming)
                 setbrightcont(gspca_dev);
-        }
         return gspca_dev->usb_err;
 }
 
@@ -1135,7 +1131,7 @@ static int sd_chip_ident(struct gspca_dev *gspca_dev,
 }
 #endif
 
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrput packet length */
@@ -1182,13 +1178,13 @@ static const struct sd_desc sd_desc = {
         .set_register = sd_dbg_s_register,
         .get_chip_ident = sd_chip_ident,
 #endif
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
 
 /* -- module initialisation -- */
-static const struct usb_device_id device_table[] __devinitconst = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x06f8, 0x3009)},
         {USB_DEVICE(0x093a, 0x2620)},
         {USB_DEVICE(0x093a, 0x2621)},
@@ -1205,7 +1201,7 @@ static const struct usb_device_id device_table[] __devinitconst = {
 MODULE_DEVICE_TABLE(usb, device_table);
 
 /* -- device connect -- */
-static int __devinit sd_probe(struct usb_interface *intf,
+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),
@@ -1226,17 +1222,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/pac7311.c b/drivers/media/video/gspca/pac7311.c
index 1cb7e99e92bd..f8801b50e64f 100644
--- a/drivers/media/video/gspca/pac7311.c
+++ b/drivers/media/video/gspca/pac7311.c
@@ -261,7 +261,7 @@ static const __u8 page4_7311[] = {
 
 static void reg_w_buf(struct gspca_dev *gspca_dev,
                   __u8 index,
-                  const char *buffer, int len)
+                  const u8 *buffer, int len)
 {
         int ret;
 
@@ -276,9 +276,8 @@ static void reg_w_buf(struct gspca_dev *gspca_dev,
                         index, gspca_dev->usb_buf, len,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w_buf(): "
-                "Failed to write registers to index 0x%x, error %i",
-                index, ret);
+                err("reg_w_buf() failed index 0x%02x, error %d",
+                        index, ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -300,9 +299,8 @@ static void reg_w(struct gspca_dev *gspca_dev,
                         0, index, gspca_dev->usb_buf, 1,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w(): "
-                "Failed to write register to index 0x%x, value 0x%x, error %i",
-                index, value, ret);
+                err("reg_w() failed index 0x%02x, value 0x%02x, error %d",
+                        index, value, ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -336,10 +334,9 @@ static void reg_w_page(struct gspca_dev *gspca_dev,
                                 0, index, gspca_dev->usb_buf, 1,
                                 500);
                 if (ret < 0) {
-                        PDEBUG(D_ERR, "reg_w_page(): "
-                        "Failed to write register to index 0x%x, "
-                        "value 0x%x, error %i",
-                        index, page[index], ret);
+                        err("reg_w_page() failed index 0x%02x, "
+                        "value 0x%02x, error %d",
+                                index, page[index], ret);
                         gspca_dev->usb_err = ret;
                         break;
                 }
@@ -675,9 +672,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 (gspca_dev->streaming)
                 setcontrast(gspca_dev);
-        }
         return gspca_dev->usb_err;
 }
 
@@ -792,7 +788,7 @@ static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrupt packet length */
@@ -835,13 +831,13 @@ static const struct sd_desc sd_desc = {
         .stop0 = sd_stop0,
         .pkt_scan = sd_pkt_scan,
         .dq_callback = do_autogain,
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
 
 /* -- module initialisation -- */
-static const struct usb_device_id device_table[] __devinitconst = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x093a, 0x2600)},
         {USB_DEVICE(0x093a, 0x2601)},
         {USB_DEVICE(0x093a, 0x2603)},
@@ -853,7 +849,7 @@ static const struct usb_device_id device_table[] __devinitconst = {
 MODULE_DEVICE_TABLE(usb, device_table);
 
 /* -- device connect -- */
-static int __devinit sd_probe(struct usb_interface *intf,
+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),
@@ -874,17 +870,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/sn9c2028.c b/drivers/media/video/gspca/sn9c2028.c
index 71d9447a7986..4271f86dfe01 100644
--- a/drivers/media/video/gspca/sn9c2028.c
+++ b/drivers/media/video/gspca/sn9c2028.c
@@ -75,7 +75,7 @@ static int sn9c2028_command(struct gspca_dev *gspca_dev, u8 *command)
                         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",
+                err("command write [%02x] error %d",
                                 gspca_dev->usb_buf[0], rc);
                 return rc;
         }
@@ -93,7 +93,7 @@ static int sn9c2028_read1(struct gspca_dev *gspca_dev)
                         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);
+                err("read1 error %d", rc);
                 return (rc < 0) ? rc : -EIO;
         }
         PDEBUG(D_USBI, "read1 response %02x", gspca_dev->usb_buf[0]);
@@ -109,7 +109,7 @@ static int sn9c2028_read4(struct gspca_dev *gspca_dev, u8 *reading)
                         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);
+                err("read4 error %d", rc);
                 return (rc < 0) ? rc : -EIO;
         }
         memcpy(reading, gspca_dev->usb_buf, 4);
@@ -131,7 +131,7 @@ static int sn9c2028_long_command(struct gspca_dev *gspca_dev, u8 *command)
         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);
+                err("long command status read error %d", status);
                 return (status < 0) ? status : -EIO;
         }
 
@@ -638,7 +638,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 err_code = start_vivitar_cam(gspca_dev);
                 break;
         default:
-                PDEBUG(D_ERR, "Starting unknown camera, please report this");
+                err("Starting unknown camera, please report this");
                 return -ENXIO;
         }
 
@@ -703,7 +703,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const 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 */
@@ -738,19 +738,12 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/sn9c20x.c b/drivers/media/video/gspca/sn9c20x.c
index 9052d5702556..c431900cd292 100644
--- a/drivers/media/video/gspca/sn9c20x.c
+++ b/drivers/media/video/gspca/sn9c20x.c
@@ -18,9 +18,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 
-#ifdef CONFIG_INPUT
 #include <linux/input.h>
-#endif
 
 #include "gspca.h"
 #include "jpeg.h"
@@ -35,6 +33,14 @@ MODULE_LICENSE("GPL");
 
 #define MODULE_NAME "sn9c20x"
 
+/*
+ * Pixel format private data
+ */
+#define SCALE_MASK      0x0f
+#define SCALE_160x120   0
+#define SCALE_320x240   1
+#define SCALE_640x480   2
+#define SCALE_1280x1024 3
 #define MODE_RAW        0x10
 #define MODE_JPEG       0x20
 #define MODE_SXGA       0x80
@@ -146,6 +152,13 @@ static const struct dmi_system_id flip_dmi_table[] = {
                 }
         },
         {
+                .ident = "MSI MS-1633X",
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_VENDOR, "MSI"),
+                        DMI_MATCH(DMI_BOARD_NAME, "MS-1633X")
+                }
+        },
+        {
                 .ident = "MSI MS-1635X",
                 .matches = {
                         DMI_MATCH(DMI_BOARD_VENDOR, "MSI"),
@@ -347,103 +360,126 @@ static const struct ctrl sd_ctrls[] = {
 
 static const struct v4l2_pix_format vga_mode[] = {
         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-                .bytesperline = 240,
-                .sizeimage = 240 * 120,
+                .bytesperline = 160,
+                .sizeimage = 160 * 120 * 4 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
-                .priv = 0 | MODE_JPEG},
+                .priv = SCALE_160x120 | MODE_JPEG},
         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
                 .bytesperline = 160,
                 .sizeimage = 160 * 120,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 0 | MODE_RAW},
+                .priv = SCALE_160x120 | MODE_RAW},
         {160, 120, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
-                .bytesperline = 240,
+                .bytesperline = 160,
                 .sizeimage = 240 * 120,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 0},
+                .priv = SCALE_160x120},
         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-                .bytesperline = 480,
-                .sizeimage = 480 * 240 ,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 4 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
-                .priv = 1 | MODE_JPEG},
+                .priv = SCALE_320x240 | MODE_JPEG},
         {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
                 .bytesperline = 320,
                 .sizeimage = 320 * 240 ,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 1 | MODE_RAW},
+                .priv = SCALE_320x240 | MODE_RAW},
         {320, 240, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
-                .bytesperline = 480,
+                .bytesperline = 320,
                 .sizeimage = 480 * 240 ,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 1},
+                .priv = SCALE_320x240},
         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-                .bytesperline = 960,
-                .sizeimage = 960 * 480,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480 * 4 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
-                .priv = 2 | MODE_JPEG},
+                .priv = SCALE_640x480 | MODE_JPEG},
         {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
                 .bytesperline = 640,
                 .sizeimage = 640 * 480,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 2 | MODE_RAW},
+                .priv = SCALE_640x480 | MODE_RAW},
         {640, 480, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
-                .bytesperline = 960,
+                .bytesperline = 640,
                 .sizeimage = 960 * 480,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 2},
+                .priv = SCALE_640x480},
 };
 
 static const struct v4l2_pix_format sxga_mode[] = {
         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-                .bytesperline = 240,
-                .sizeimage = 240 * 120,
+                .bytesperline = 160,
+                .sizeimage = 160 * 120 * 4 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
-                .priv = 0 | MODE_JPEG},
+                .priv = SCALE_160x120 | MODE_JPEG},
         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
                 .bytesperline = 160,
                 .sizeimage = 160 * 120,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 0 | MODE_RAW},
+                .priv = SCALE_160x120 | MODE_RAW},
         {160, 120, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
-                .bytesperline = 240,
+                .bytesperline = 160,
                 .sizeimage = 240 * 120,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 0},
+                .priv = SCALE_160x120},
         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-                .bytesperline = 480,
-                .sizeimage = 480 * 240 ,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 4 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
-                .priv = 1 | MODE_JPEG},
+                .priv = SCALE_320x240 | MODE_JPEG},
         {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
                 .bytesperline = 320,
                 .sizeimage = 320 * 240 ,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 1 | MODE_RAW},
+                .priv = SCALE_320x240 | MODE_RAW},
         {320, 240, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
-                .bytesperline = 480,
+                .bytesperline = 320,
                 .sizeimage = 480 * 240 ,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 1},
+                .priv = SCALE_320x240},
         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
-                .bytesperline = 960,
-                .sizeimage = 960 * 480,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480 * 4 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
-                .priv = 2 | MODE_JPEG},
+                .priv = SCALE_640x480 | MODE_JPEG},
         {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
                 .bytesperline = 640,
                 .sizeimage = 640 * 480,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 2 | MODE_RAW},
+                .priv = SCALE_640x480 | MODE_RAW},
         {640, 480, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
-                .bytesperline = 960,
+                .bytesperline = 640,
                 .sizeimage = 960 * 480,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 2},
+                .priv = SCALE_640x480},
         {1280, 1024, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
                 .bytesperline = 1280,
-                .sizeimage = (1280 * 1024) + 64,
+                .sizeimage = 1280 * 1024,
                 .colorspace = V4L2_COLORSPACE_SRGB,
-                .priv = 3 | MODE_RAW | MODE_SXGA},
+                .priv = SCALE_1280x1024 | MODE_RAW | MODE_SXGA},
+};
+
+static const struct v4l2_pix_format mono_mode[] = {
+        {160, 120, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
+                .bytesperline = 160,
+                .sizeimage = 160 * 120,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = SCALE_160x120 | MODE_RAW},
+        {320, 240, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 ,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = SCALE_320x240 | MODE_RAW},
+        {640, 480, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = SCALE_640x480 | MODE_RAW},
+        {1280, 1024, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
+                .bytesperline = 1280,
+                .sizeimage = 1280 * 1024,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = SCALE_1280x1024 | MODE_RAW | MODE_SXGA},
 };
 
 static const s16 hsv_red_x[] = {
@@ -855,6 +891,9 @@ static struct i2c_reg_u8 ov7660_init[] = {
         {0x0e, 0x80}, {0x0d, 0x08}, {0x0f, 0xc3},
         {0x04, 0xc3}, {0x10, 0x40}, {0x11, 0x40},
         {0x12, 0x05}, {0x13, 0xba}, {0x14, 0x2a},
+        /* HDG Set hstart and hstop, datasheet default 0x11, 0x61, using
+           0x10, 0x61 and sd->hstart, vstart = 3, fixes ugly colored borders */
+        {0x17, 0x10}, {0x18, 0x61},
         {0x37, 0x0f}, {0x38, 0x02}, {0x39, 0x43},
         {0x3a, 0x00}, {0x69, 0x90}, {0x2d, 0xf6},
         {0x2e, 0x0b}, {0x01, 0x78}, {0x02, 0x50},
@@ -1031,16 +1070,19 @@ static struct i2c_reg_u16 mt9v011_init[] = {
 };
 
 static struct i2c_reg_u16 mt9m001_init[] = {
-        {0x0d, 0x0001}, {0x0d, 0x0000}, {0x01, 0x000e},
-        {0x02, 0x0014}, {0x03, 0x03c1}, {0x04, 0x0501},
-        {0x05, 0x0083}, {0x06, 0x0006}, {0x0d, 0x0002},
-        {0x0a, 0x0000}, {0x0c, 0x0000}, {0x11, 0x0000},
-        {0x1e, 0x8000}, {0x5f, 0x8904}, {0x60, 0x0000},
-        {0x61, 0x0000}, {0x62, 0x0498}, {0x63, 0x0000},
-        {0x64, 0x0000}, {0x20, 0x111d}, {0x06, 0x00f2},
-        {0x05, 0x0013}, {0x09, 0x10f2}, {0x07, 0x0003},
-        {0x2b, 0x002a}, {0x2d, 0x002a}, {0x2c, 0x002a},
-        {0x2e, 0x0029}, {0x07, 0x0002},
+        {0x0d, 0x0001},
+        {0x0d, 0x0000},
+        {0x04, 0x0500},         /* hres = 1280 */
+        {0x03, 0x0400},         /* vres = 1024 */
+        {0x20, 0x1100},
+        {0x06, 0x0010},
+        {0x2b, 0x0024},
+        {0x2e, 0x0024},
+        {0x35, 0x0024},
+        {0x2d, 0x0020},
+        {0x2c, 0x0020},
+        {0x09, 0x0ad4},
+        {0x35, 0x0057},
 };
 
 static struct i2c_reg_u16 mt9m111_init[] = {
@@ -1226,8 +1268,17 @@ static int i2c_r2(struct gspca_dev *gspca_dev, u8 reg, u16 *val)
 static int ov9650_init_sensor(struct gspca_dev *gspca_dev)
 {
         int i;
+        u16 id;
         struct sd *sd = (struct sd *) gspca_dev;
 
+        if (i2c_r2(gspca_dev, 0x1c, &id) < 0)
+                return -EINVAL;
+
+        if (id != 0x7fa2) {
+                err("sensor id for ov9650 doesn't match (0x%04x)", id);
+                return -ENODEV;
+        }
+
         for (i = 0; i < ARRAY_SIZE(ov9650_init); i++) {
                 if (i2c_w1(gspca_dev, ov9650_init[i].reg,
                                 ov9650_init[i].val) < 0) {
@@ -1272,7 +1323,8 @@ static int soi968_init_sensor(struct gspca_dev *gspca_dev)
                 }
         }
         /* disable hflip and vflip */
-        gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << EXPOSURE_IDX);
+        gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX)
+                                | (1 << EXPOSURE_IDX);
         sd->hstart = 60;
         sd->vstart = 11;
         return 0;
@@ -1290,10 +1342,8 @@ static int ov7660_init_sensor(struct gspca_dev *gspca_dev)
                         return -ENODEV;
                 }
         }
-        /* disable hflip and vflip */
-        gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX);
-        sd->hstart = 1;
-        sd->vstart = 1;
+        sd->hstart = 3;
+        sd->vstart = 3;
         return 0;
 }
 
@@ -1351,7 +1401,9 @@ static int mt9v_init_sensor(struct gspca_dev *gspca_dev)
                                 return -ENODEV;
                         }
                 }
-                gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX) | (1 << GAIN_IDX);
+                gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX)
+                                        | (1 << AUTOGAIN_IDX)
+                                        | (1 << GAIN_IDX);
                 sd->hstart = 2;
                 sd->vstart = 2;
                 sd->sensor = SENSOR_MT9V111;
@@ -1395,7 +1447,8 @@ static int mt9m112_init_sensor(struct gspca_dev *gspca_dev)
                         return -ENODEV;
                 }
         }
-        gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX) | (1 << GAIN_IDX);
+        gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX)
+                                | (1 << GAIN_IDX);
         sd->hstart = 0;
         sd->vstart = 2;
         return 0;
@@ -1412,7 +1465,8 @@ static int mt9m111_init_sensor(struct gspca_dev *gspca_dev)
                         return -ENODEV;
                 }
         }
-        gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX) | (1 << GAIN_IDX);
+        gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX)
+                                | (1 << GAIN_IDX);
         sd->hstart = 0;
         sd->vstart = 2;
         return 0;
@@ -1422,6 +1476,25 @@ static int mt9m001_init_sensor(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int i;
+        u16 id;
+
+        if (i2c_r2(gspca_dev, 0x00, &id) < 0)
+                return -EINVAL;
+
+        /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */
+        switch (id) {
+        case 0x8411:
+        case 0x8421:
+                info("MT9M001 color sensor detected");
+                break;
+        case 0x8431:
+                info("MT9M001 mono sensor detected");
+                break;
+        default:
+                err("No MT9M001 chip detected, ID = %x\n", id);
+                return -ENODEV;
+        }
+
         for (i = 0; i < ARRAY_SIZE(mt9m001_init); i++) {
                 if (i2c_w2(gspca_dev, mt9m001_init[i].reg,
                                 mt9m001_init[i].val) < 0) {
@@ -1431,8 +1504,8 @@ static int mt9m001_init_sensor(struct gspca_dev *gspca_dev)
         }
         /* disable hflip and vflip */
         gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX);
-        sd->hstart = 2;
-        sd->vstart = 2;
+        sd->hstart = 1;
+        sd->vstart = 1;
         return 0;
 }
 
@@ -1543,6 +1616,18 @@ static int set_hvflip(struct gspca_dev *gspca_dev)
         }
 
         switch (sd->sensor) {
+        case SENSOR_OV7660:
+                value = 0x01;
+                if (hflip)
+                        value |= 0x20;
+                if (vflip) {
+                        value |= 0x10;
+                        sd->vstart = 2;
+                } else
+                        sd->vstart = 3;
+                reg_w1(gspca_dev, 0x1182, sd->vstart);
+                i2c_w1(gspca_dev, 0x1e, value);
+                break;
         case SENSOR_OV9650:
                 i2c_r1(gspca_dev, 0x1e, &value);
                 value &= ~0x30;
@@ -1974,6 +2059,10 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 cam->cam_mode = sxga_mode;
                 cam->nmodes = ARRAY_SIZE(sxga_mode);
                 break;
+        case SENSOR_MT9M001:
+                cam->cam_mode = mono_mode;
+                cam->nmodes = ARRAY_SIZE(mono_mode);
+                break;
         default:
                 cam->cam_mode = vga_mode;
                 cam->nmodes = ARRAY_SIZE(vga_mode);
@@ -2072,7 +2161,6 @@ static int sd_init(struct gspca_dev *gspca_dev)
         case SENSOR_MT9M001:
                 if (mt9m001_init_sensor(gspca_dev) < 0)
                         return -ENODEV;
-                info("MT9M001 sensor detected");
                 break;
         case SENSOR_HV7131R:
                 if (hv7131r_init_sensor(gspca_dev) < 0)
@@ -2170,22 +2258,22 @@ static int sd_start(struct gspca_dev *gspca_dev)
         else if (mode & MODE_JPEG)
                 fmt = 0x2c;
         else
-                fmt = 0x2f;
+                fmt = 0x2f;     /* YUV 420 */
 
-        switch (mode & 0x0f) {
-        case 3:
+        switch (mode & SCALE_MASK) {
+        case SCALE_1280x1024:
                 scale = 0xc0;
                 info("Set 1280x1024");
                 break;
-        case 2:
+        case SCALE_640x480:
                 scale = 0x80;
                 info("Set 640x480");
                 break;
-        case 1:
+        case SCALE_320x240:
                 scale = 0x90;
                 info("Set 320x240");
                 break;
-        case 0:
+        case SCALE_160x120:
                 scale = 0xa0;
                 info("Set 160x120");
                 break;
@@ -2304,7 +2392,7 @@ static void sd_dqcallback(struct gspca_dev *gspca_dev)
                 do_autoexposure(gspca_dev, avg_lum);
 }
 
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet */
                         int len)                /* interrupt packet length */
@@ -2386,7 +2474,7 @@ static const struct sd_desc sd_desc = {
         .start = sd_start,
         .stopN = sd_stopN,
         .pkt_scan = sd_pkt_scan,
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
         .dq_callback = sd_dqcallback,
@@ -2402,7 +2490,7 @@ static const struct sd_desc sd_desc = {
                         | (SENSOR_ ## sensor << 8) \
                         | (i2c_addr)
 
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0c45, 0x6240), SN9C20X(MT9M001, 0x5d, 0)},
         {USB_DEVICE(0x0c45, 0x6242), SN9C20X(MT9M111, 0x5d, 0)},
         {USB_DEVICE(0x0c45, 0x6248), SN9C20X(OV9655, 0x30, 0)},
@@ -2414,7 +2502,7 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0c45, 0x6253), SN9C20X(OV9650, 0x30, 0)},
         {USB_DEVICE(0x0c45, 0x6260), SN9C20X(OV7670, 0x21, 0)},
         {USB_DEVICE(0x0c45, 0x6270), SN9C20X(MT9VPRB, 0x00, 0)},
-        {USB_DEVICE(0x0c45, 0x627b), SN9C20X(OV7660, 0x21, 0)},
+        {USB_DEVICE(0x0c45, 0x627b), SN9C20X(OV7660, 0x21, FLIP_DETECT)},
         {USB_DEVICE(0x0c45, 0x627c), SN9C20X(HV7131R, 0x11, 0)},
         {USB_DEVICE(0x0c45, 0x627f), SN9C20X(OV9650, 0x30, 0)},
         {USB_DEVICE(0x0c45, 0x6280), SN9C20X(MT9M001, 0x5d, 0)},
@@ -2426,7 +2514,7 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0c45, 0x62a0), SN9C20X(OV7670, 0x21, 0)},
         {USB_DEVICE(0x0c45, 0x62b0), SN9C20X(MT9VPRB, 0x00, 0)},
         {USB_DEVICE(0x0c45, 0x62b3), SN9C20X(OV9655, 0x30, 0)},
-        {USB_DEVICE(0x0c45, 0x62bb), SN9C20X(OV7660, 0x21, 0)},
+        {USB_DEVICE(0x0c45, 0x62bb), SN9C20X(OV7660, 0x21, LED_REVERSE)},
         {USB_DEVICE(0x0c45, 0x62bc), SN9C20X(HV7131R, 0x11, 0)},
         {USB_DEVICE(0x045e, 0x00f4), SN9C20X(OV9650, 0x30, 0)},
         {USB_DEVICE(0x145f, 0x013d), SN9C20X(OV7660, 0x21, 0)},
@@ -2467,17 +2555,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        info("deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/sonixb.c b/drivers/media/video/gspca/sonixb.c
index 204bb3af4559..146b459b08d5 100644
--- a/drivers/media/video/gspca/sonixb.c
+++ b/drivers/media/video/gspca/sonixb.c
@@ -1,9 +1,9 @@
 /*
  *              sonix sn9c102 (bayer) library
- *              Copyright (C) 2003 2004 Michel Xhaard mxhaard@magic.fr
- * Add Pas106 Stefano Mozzi (C) 2004
  *
- * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
+ * Copyright (C) 2009-2011 Jean-François Moine <http://moinejf.free.fr>
+ * Copyright (C) 2003 2004 Michel Xhaard mxhaard@magic.fr
+ * Add Pas106 Stefano Mozzi (C) 2004
  *
  * 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
@@ -23,8 +23,15 @@
 /* Some documentation on known sonixb registers:
 
 Reg     Use
+sn9c101 / sn9c102:
 0x10    high nibble red gain low nibble blue gain
 0x11    low nibble green gain
+sn9c103:
+0x05    red gain 0-127
+0x06    blue gain 0-127
+0x07    green gain 0-127
+all:
+0x08-0x0f i2c / 3wire registers
 0x12    hstart
 0x13    vstart
 0x15    hsize (hsize = register-value * 16)
@@ -45,25 +52,35 @@ Reg	Use
 #include <linux/input.h>
 #include "gspca.h"
 
-MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
+MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
 MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver");
 MODULE_LICENSE("GPL");
 
+/* controls */
+enum e_ctrl {
+        BRIGHTNESS,
+        GAIN,
+        EXPOSURE,
+        AUTOGAIN,
+        FREQ,
+        NCTRLS          /* number of controls */
+};
+
 /* specific webcam descriptor */
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
+
+        struct gspca_ctrl ctrls[NCTRLS];
+
         atomic_t avg_lum;
         int prev_avg_lum;
         int exp_too_low_cnt;
         int exp_too_high_cnt;
+        int header_read;
+        u8 header[12]; /* Header without sof marker */
 
-        unsigned short exposure;
-        unsigned char gain;
-        unsigned char brightness;
-        unsigned char autogain;
         unsigned char autogain_ignore_frames;
         unsigned char frames_to_drop;
-        unsigned char freq;             /* light freq filter setting */
 
         __u8 bridge;                    /* Type of bridge */
 #define BRIDGE_101 0
@@ -71,26 +88,24 @@ struct sd {
 #define BRIDGE_103 1
 
         __u8 sensor;                    /* Type of image sensor chip */
-#define SENSOR_HV7131R 0
-#define SENSOR_OV6650 1
-#define SENSOR_OV7630 2
-#define SENSOR_PAS106 3
-#define SENSOR_PAS202 4
-#define SENSOR_TAS5110C 5
-#define SENSOR_TAS5110D 6
-#define SENSOR_TAS5130CXX 7
+#define SENSOR_HV7131D 0
+#define SENSOR_HV7131R 1
+#define SENSOR_OV6650 2
+#define SENSOR_OV7630 3
+#define SENSOR_PAS106 4
+#define SENSOR_PAS202 5
+#define SENSOR_TAS5110C 6
+#define SENSOR_TAS5110D 7
+#define SENSOR_TAS5130CXX 8
         __u8 reg11;
 };
 
 typedef const __u8 sensor_init_t[8];
 
 struct sensor_data {
-        const __u8 *bridge_init[2];
-        int bridge_init_size[2];
+        const __u8 *bridge_init;
         sensor_init_t *sensor_init;
         int sensor_init_size;
-        sensor_init_t *sensor_bridge_init[2];
-        int sensor_bridge_init_size[2];
         int flags;
         unsigned ctrl_dis;
         __u8 sensor_addr;
@@ -106,12 +121,10 @@ struct sensor_data {
 #define MODE_REDUCED_SIF 0x20   /* vga mode (320x240 / 160x120) on sif cam */
 
 /* ctrl_dis helper macros */
-#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)
+#define NO_EXPO ((1 << EXPOSURE) | (1 << AUTOGAIN))
+#define NO_FREQ (1 << FREQ)
+#define NO_BRIGHTNESS (1 << BRIGHTNESS)
 
-#define COMP2 0x8f
 #define COMP 0xc7               /* 0x87 //0x07 */
 #define COMP1 0xc9              /* 0x89 //0x09 */
 
@@ -120,15 +133,11 @@ struct sensor_data {
 
 #define SYS_CLK 0x04
 
-#define SENS(bridge_1, bridge_3, sensor, sensor_1, \
-        sensor_3, _flags, _ctrl_dis, _sensor_addr) \
+#define SENS(bridge, sensor, _flags, _ctrl_dis, _sensor_addr) \
 { \
-        .bridge_init = { bridge_1, bridge_3 }, \
-        .bridge_init_size = { sizeof(bridge_1), sizeof(bridge_3) }, \
+        .bridge_init = bridge, \
         .sensor_init = sensor, \
         .sensor_init_size = sizeof(sensor), \
-        .sensor_bridge_init = { sensor_1, sensor_3,}, \
-        .sensor_bridge_init_size = { sizeof(sensor_1), sizeof(sensor_3)}, \
         .flags = _flags, .ctrl_dis = _ctrl_dis, .sensor_addr = _sensor_addr \
 }
 
@@ -139,20 +148,14 @@ struct sensor_data {
 #define AUTOGAIN_IGNORE_FRAMES 1
 
 /* 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_setgain(struct gspca_dev *gspca_dev, __s32 val);
-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 void setbrightness(struct gspca_dev *gspca_dev);
+static void setgain(struct gspca_dev *gspca_dev);
+static void setexposure(struct gspca_dev *gspca_dev);
 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_setfreq(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
+static void setfreq(struct gspca_dev *gspca_dev);
 
-static const struct ctrl sd_ctrls[] = {
-#define BRIGHTNESS_IDX 0
-        {
+static const struct ctrl sd_ctrls[NCTRLS] = {
+[BRIGHTNESS] = {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -160,14 +163,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define BRIGHTNESS_DEF 127
-                .default_value = BRIGHTNESS_DEF,
+                .default_value = 127,
             },
-            .set = sd_setbrightness,
-            .get = sd_getbrightness,
+            .set_control = setbrightness
         },
-#define GAIN_IDX 1
-        {
+[GAIN] = {
             {
                 .id      = V4L2_CID_GAIN,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -175,48 +175,31 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define GAIN_DEF 127
 #define GAIN_KNEE 230
-                .default_value = GAIN_DEF,
+                .default_value = 127,
             },
-            .set = sd_setgain,
-            .get = sd_getgain,
+            .set_control = setgain
         },
-#define EXPOSURE_IDX 2
-        {
+[EXPOSURE] = {
                 {
                         .id = V4L2_CID_EXPOSURE,
                         .type = V4L2_CTRL_TYPE_INTEGER,
                         .name = "Exposure",
-#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 = 1023,
                         .step = 1,
-                        .default_value = EXPOSURE_DEF,
+                        .default_value = 66,
+                                /*  33 ms / 30 fps (except on PASXXX) */
+#define EXPOSURE_KNEE 200       /* 100 ms / 10 fps (except on PASXXX) */
                         .flags = 0,
                 },
-                .set = sd_setexposure,
-                .get = sd_getexposure,
+                .set_control = setexposure
         },
-#define COARSE_EXPOSURE_IDX 3
-        {
-                {
-                        .id = V4L2_CID_EXPOSURE,
-                        .type = V4L2_CTRL_TYPE_INTEGER,
-                        .name = "Exposure",
+/* for coarse exposure */
+#define COARSE_EXPOSURE_MIN 2
+#define COARSE_EXPOSURE_MAX 15
 #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
-        {
+[AUTOGAIN] = {
                 {
                         .id = V4L2_CID_AUTOGAIN,
                         .type = V4L2_CTRL_TYPE_BOOLEAN,
@@ -226,13 +209,11 @@ static const struct ctrl sd_ctrls[] = {
                         .step = 1,
 #define AUTOGAIN_DEF 1
                         .default_value = AUTOGAIN_DEF,
-                        .flags = 0,
+                        .flags = V4L2_CTRL_FLAG_UPDATE
                 },
                 .set = sd_setautogain,
-                .get = sd_getautogain,
         },
-#define FREQ_IDX 5
-        {
+[FREQ] = {
                 {
                         .id      = V4L2_CID_POWER_LINE_FREQUENCY,
                         .type    = V4L2_CTRL_TYPE_MENU,
@@ -243,8 +224,7 @@ static const struct ctrl sd_ctrls[] = {
 #define FREQ_DEF 0
                         .default_value = FREQ_DEF,
                 },
-                .set = sd_setfreq,
-                .get = sd_getfreq,
+                .set_control = setfreq
         },
 };
 
@@ -303,14 +283,27 @@ static const struct v4l2_pix_format sif_mode[] = {
                 .priv = 0},
 };
 
-static const __u8 initHv7131[] = {
+static const __u8 initHv7131d[] = {
+        0x04, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
+        0x00, 0x00,
+        0x00, 0x00, 0x00, 0x02, 0x02, 0x00,
+        0x28, 0x1e, 0x60, 0x8e, 0x42,
+};
+static const __u8 hv7131d_sensor_init[][8] = {
+        {0xa0, 0x11, 0x01, 0x04, 0x00, 0x00, 0x00, 0x17},
+        {0xa0, 0x11, 0x02, 0x00, 0x00, 0x00, 0x00, 0x17},
+        {0xa0, 0x11, 0x28, 0x00, 0x00, 0x00, 0x00, 0x17},
+        {0xa0, 0x11, 0x30, 0x30, 0x00, 0x00, 0x00, 0x17}, /* reset level */
+        {0xa0, 0x11, 0x34, 0x02, 0x00, 0x00, 0x00, 0x17}, /* pixel bias volt */
+};
+
+static const __u8 initHv7131r[] = {
         0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
         0x00, 0x00,
         0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
         0x28, 0x1e, 0x60, 0x8a, 0x20,
-        0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c
 };
-static const __u8 hv7131_sensor_init[][8] = {
+static const __u8 hv7131r_sensor_init[][8] = {
         {0xc0, 0x11, 0x31, 0x38, 0x2a, 0x2e, 0x00, 0x10},
         {0xa0, 0x11, 0x01, 0x08, 0x2a, 0x2e, 0x00, 0x10},
         {0xb0, 0x11, 0x20, 0x00, 0xd0, 0x2e, 0x00, 0x10},
@@ -321,12 +314,11 @@ static const __u8 initOv6650[] = {
         0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
         0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x01, 0x01, 0x0a, 0x16, 0x12, 0x68, 0x8b,
-        0x10, 0x1d, 0x10, 0x02, 0x02, 0x09, 0x07
+        0x10,
 };
-static const __u8 ov6650_sensor_init[][8] =
-{
+static const __u8 ov6650_sensor_init[][8] = {
         /* Bright, contrast, etc are set through SCBB interface.
-         * AVCAP on win2 do not send any data on this   controls. */
+         * AVCAP on win2 do not send any data on this controls. */
         /* Anyway, some registers appears to alter bright and constrat */
 
         /* Reset sensor */
@@ -341,7 +333,7 @@ static const __u8 ov6650_sensor_init[][8] =
                  * but blue wont be there. Avoid this data ... */
         {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10}, /* format out? */
         {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10},
-        {0xa0, 0x60, 0x30, 0x3d, 0x0A, 0xd8, 0xa4, 0x10},
+        {0xa0, 0x60, 0x30, 0x3d, 0x0a, 0xd8, 0xa4, 0x10},
         /* Enable rgb brightness control */
         {0xa0, 0x60, 0x61, 0x08, 0x00, 0x00, 0x00, 0x10},
         /* HDG: Note windows uses the line below, which sets both register 0x60
@@ -361,24 +353,13 @@ static const __u8 initOv7630[] = {
         0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* r09 .. r10 */
         0x00, 0x01, 0x01, 0x0a,                         /* r11 .. r14 */
         0x28, 0x1e,                     /* H & V sizes     r15 .. r16 */
-        0x68, COMP2, MCK_INIT1,                         /* r17 .. r19 */
-        0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c              /* r1a .. r1f */
-};
-static const __u8 initOv7630_3[] = {
-        0x44, 0x44, 0x00, 0x1a, 0x20, 0x20, 0x20, 0x80, /* r01 .. r08 */
-        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 */
-        0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c, 0x00,       /* r1a .. r20 */
-        0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, /* r21 .. r28 */
-        0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0xff  /* r29 .. r30 */
 };
 static const __u8 ov7630_sensor_init[][8] = {
         {0xa0, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
         {0xb0, 0x21, 0x01, 0x77, 0x3a, 0x00, 0x00, 0x10},
 /*      {0xd0, 0x21, 0x12, 0x7c, 0x01, 0x80, 0x34, 0x10},          jfm */
-        {0xd0, 0x21, 0x12, 0x1c, 0x00, 0x80, 0x34, 0x10},       /* jfm */
+        {0xd0, 0x21, 0x12, 0x5c, 0x00, 0x80, 0x34, 0x10},       /* jfm */
         {0xa0, 0x21, 0x1b, 0x04, 0x00, 0x80, 0x34, 0x10},
         {0xa0, 0x21, 0x20, 0x44, 0x00, 0x80, 0x34, 0x10},
         {0xa0, 0x21, 0x23, 0xee, 0x00, 0x80, 0x34, 0x10},
@@ -396,16 +377,11 @@ static const __u8 ov7630_sensor_init[][8] = {
         {0xd0, 0x21, 0x17, 0x1c, 0xbd, 0x06, 0xf6, 0x10},
 };
 
-static const __u8 ov7630_sensor_init_3[][8] = {
-        {0xa0, 0x21, 0x13, 0x80, 0x00,  0x00, 0x00, 0x10},
-};
-
 static const __u8 initPas106[] = {
         0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00,
         0x00, 0x00,
         0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
         0x16, 0x12, 0x24, COMP1, MCK_INIT1,
-        0x18, 0x10, 0x02, 0x02, 0x09, 0x07
 };
 /* compression 0x86 mckinit1 0x2b */
 
@@ -479,7 +455,6 @@ static const __u8 initPas202[] = {
         0x00, 0x00,
         0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
         0x28, 0x1e, 0x20, 0x89, 0x20,
-        0x00, 0x00, 0x02, 0x03, 0x0f, 0x0c
 };
 
 /* "Known" PAS202BCB registers:
@@ -506,7 +481,7 @@ static const __u8 pas202_sensor_init[][8] = {
         {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, 0x01, 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},
@@ -520,7 +495,6 @@ static const __u8 initTas5110c[] = {
         0x00, 0x00,
         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[] = {
@@ -528,12 +502,19 @@ static const __u8 initTas5110d[] = {
         0x00, 0x00,
         0x00, 0x00, 0x00, 0x41, 0x09, 0x0a,
         0x16, 0x12, 0x60, 0x86, 0x2b,
-        0x14, 0x0a, 0x02, 0x02, 0x09, 0x07
 };
-static const __u8 tas5110_sensor_init[][8] = {
+/* tas5110c is 3 wire, tas5110d is 2 wire (regular i2c) */
+static const __u8 tas5110c_sensor_init[][8] = {
         {0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10},
         {0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10},
-        {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17},
+};
+/* Known TAS5110D registers
+ * reg02: gain, bit order reversed!! 0 == max gain, 255 == min gain
+ * reg03: bit3: vflip, bit4: ~hflip, bit7: ~gainboost (~ == inverted)
+ *        Note: writing reg03 seems to only work when written together with 02
+ */
+static const __u8 tas5110d_sensor_init[][8] = {
+        {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17}, /* reset */
 };
 
 static const __u8 initTas5130[] = {
@@ -541,31 +522,28 @@ static const __u8 initTas5130[] = {
         0x00, 0x00,
         0x00, 0x00, 0x00, 0x68, 0x0c, 0x0a,
         0x28, 0x1e, 0x60, COMP, MCK_INIT,
-        0x18, 0x10, 0x04, 0x03, 0x11, 0x0c
 };
 static const __u8 tas5130_sensor_init[][8] = {
-/*      {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
+/*      {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
                                         * shutter 0x47 short exposure? */
         {0x30, 0x11, 0x00, 0x40, 0x01, 0x00, 0x00, 0x10},
                                         /* shutter 0x01 long exposure */
         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10},
 };
 
-static struct sensor_data sensor_data[] = {
-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_GAIN|F_SIF, 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),
+static const struct sensor_data sensor_data[] = {
+SENS(initHv7131d, hv7131d_sensor_init, F_GAIN, NO_BRIGHTNESS|NO_FREQ, 0),
+SENS(initHv7131r, hv7131r_sensor_init, 0, NO_BRIGHTNESS|NO_EXPO|NO_FREQ, 0),
+SENS(initOv6650, ov6650_sensor_init, F_GAIN|F_SIF, 0, 0x60),
+SENS(initOv7630, ov7630_sensor_init, F_GAIN, 0, 0x21),
+SENS(initPas106, pas106_sensor_init, F_GAIN|F_SIF, NO_FREQ, 0),
+SENS(initPas202, pas202_sensor_init, F_GAIN, NO_FREQ, 0),
+SENS(initTas5110c, tas5110c_sensor_init, F_GAIN|F_SIF|F_COARSE_EXPO,
+        NO_BRIGHTNESS|NO_FREQ, 0),
+SENS(initTas5110d, tas5110d_sensor_init, F_GAIN|F_SIF|F_COARSE_EXPO,
+        NO_BRIGHTNESS|NO_FREQ, 0),
+SENS(initTas5130, tas5130_sensor_init, F_GAIN,
+        NO_BRIGHTNESS|NO_EXPO|NO_FREQ, 0),
 };
 
 /* get one byte in gspca_dev->usb_buf */
@@ -637,7 +615,6 @@ static void i2c_w_vector(struct gspca_dev *gspca_dev,
 static void setbrightness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        __u8 value;
 
         switch (sd->sensor) {
         case  SENSOR_OV6650:
@@ -647,7 +624,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 
                 /* change reg 0x06 */
                 i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
-                i2cOV[3] = sd->brightness;
+                i2cOV[3] = sd->ctrls[BRIGHTNESS].val;
                 if (i2c_w(gspca_dev, i2cOV) < 0)
                         goto err;
                 break;
@@ -665,13 +642,13 @@ static void setbrightness(struct gspca_dev *gspca_dev)
                         i2cpdoit[2] = 0x13;
                 }
 
-                if (sd->brightness < 127) {
+                if (sd->ctrls[BRIGHTNESS].val < 127) {
                         /* change reg 0x0b, signreg */
                         i2cpbright[3] = 0x01;
                         /* set reg 0x0c, offset */
-                        i2cpbright[4] = 127 - sd->brightness;
+                        i2cpbright[4] = 127 - sd->ctrls[BRIGHTNESS].val;
                 } else
-                        i2cpbright[4] = sd->brightness - 127;
+                        i2cpbright[4] = sd->ctrls[BRIGHTNESS].val - 127;
 
                 if (i2c_w(gspca_dev, i2cpbright) < 0)
                         goto err;
@@ -679,17 +656,6 @@ static void setbrightness(struct gspca_dev *gspca_dev)
                         goto err;
                 break;
             }
-        case SENSOR_TAS5130CXX: {
-                __u8 i2c[] =
-                        {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
-
-                value = 0xff - sd->brightness;
-                i2c[4] = value;
-                PDEBUG(D_CONF, "brightness %d : %d", value, i2c[4]);
-                if (i2c_w(gspca_dev, i2c) < 0)
-                        goto err;
-                break;
-            }
         }
         return;
 err:
@@ -699,12 +665,23 @@ err:
 static void setsensorgain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        unsigned char gain = sd->gain;
+        u8 gain = sd->ctrls[GAIN].val;
 
         switch (sd->sensor) {
+        case SENSOR_HV7131D: {
+                __u8 i2c[] =
+                        {0xc0, 0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x17};
+
+                i2c[3] = 0x3f - (gain / 4);
+                i2c[4] = 0x3f - (gain / 4);
+                i2c[5] = 0x3f - (gain / 4);
 
+                if (i2c_w(gspca_dev, i2c) < 0)
+                        goto err;
+                break;
+            }
         case SENSOR_TAS5110C:
-        case SENSOR_TAS5110D: {
+        case SENSOR_TAS5130CXX: {
                 __u8 i2c[] =
                         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
 
@@ -713,6 +690,23 @@ static void setsensorgain(struct gspca_dev *gspca_dev)
                         goto err;
                 break;
             }
+        case SENSOR_TAS5110D: {
+                __u8 i2c[] = {
+                        0xb0, 0x61, 0x02, 0x00, 0x10, 0x00, 0x00, 0x17 };
+                gain = 255 - gain;
+                /* The bits in the register are the wrong way around!! */
+                i2c[3] |= (gain & 0x80) >> 7;
+                i2c[3] |= (gain & 0x40) >> 5;
+                i2c[3] |= (gain & 0x20) >> 3;
+                i2c[3] |= (gain & 0x10) >> 1;
+                i2c[3] |= (gain & 0x08) << 1;
+                i2c[3] |= (gain & 0x04) << 3;
+                i2c[3] |= (gain & 0x02) << 5;
+                i2c[3] |= (gain & 0x01) << 7;
+                if (i2c_w(gspca_dev, i2c) < 0)
+                        goto err;
+                break;
+            }
 
         case SENSOR_OV6650:
                 gain >>= 1;
@@ -743,11 +737,11 @@ static void setsensorgain(struct gspca_dev *gspca_dev)
                         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;
+                i2cpgain[3] = gain >> 3;
+                i2cpcolorgain[3] = gain >> 4;
+                i2cpcolorgain[4] = gain >> 4;
+                i2cpcolorgain[5] = gain >> 4;
+                i2cpcolorgain[6] = gain >> 4;
 
                 if (i2c_w(gspca_dev, i2cpgain) < 0)
                         goto err;
@@ -767,7 +761,7 @@ static void setgain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         __u8 gain;
-        __u8 buf[2] = { 0, 0 };
+        __u8 buf[3] = { 0, 0, 0 };
 
         if (sensor_data[sd->sensor].flags & F_GAIN) {
                 /* Use the sensor gain to do the actual gain */
@@ -775,13 +769,18 @@ static void setgain(struct gspca_dev *gspca_dev)
                 return;
         }
 
-        gain = sd->gain >> 4;
-
-        /* red and blue gain */
-        buf[0] = gain << 4 | gain;
-        /* green gain */
-        buf[1] = gain;
-        reg_w(gspca_dev, 0x10, buf, 2);
+        if (sd->bridge == BRIDGE_103) {
+                gain = sd->ctrls[GAIN].val >> 1;
+                buf[0] = gain; /* Red */
+                buf[1] = gain; /* Green */
+                buf[2] = gain; /* Blue */
+                reg_w(gspca_dev, 0x05, buf, 3);
+        } else {
+                gain = sd->ctrls[GAIN].val >> 4;
+                buf[0] = gain << 4 | gain; /* Red and blue */
+                buf[1] = gain; /* Green */
+                reg_w(gspca_dev, 0x10, buf, 2);
+        }
 }
 
 static void setexposure(struct gspca_dev *gspca_dev)
@@ -789,12 +788,31 @@ static void setexposure(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
 
         switch (sd->sensor) {
+        case SENSOR_HV7131D: {
+                /* Note the datasheet wrongly says line mode exposure uses reg
+                   0x26 and 0x27, testing has shown 0x25 + 0x26 */
+                __u8 i2c[] = {0xc0, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x17};
+                /* The HV7131D's exposure goes from 0 - 65535, we scale our
+                   exposure of 0-1023 to 0-6138. There are 2 reasons for this:
+                   1) This puts our exposure knee of 200 at approx the point
+                      where the framerate starts dropping
+                   2) At 6138 the framerate has already dropped to 2 fps,
+                      going any lower makes little sense */
+                u16 reg = sd->ctrls[EXPOSURE].val * 6;
+
+                i2c[3] = reg >> 8;
+                i2c[4] = reg & 0xff;
+                if (i2c_w(gspca_dev, i2c) != 0)
+                        goto err;
+                break;
+            }
         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 */
-                __u8 reg = sd->exposure;
+                u8 reg = sd->ctrls[EXPOSURE].val;
+
                 reg = (reg << 4) | 0x0b;
                 reg_w(gspca_dev, 0x19, &reg, 1);
                 break;
@@ -809,7 +827,7 @@ static void setexposure(struct gspca_dev *gspca_dev)
                    possible to use less exposure then what the fps maximum
                    allows by setting register 10. register 10 configures the
                    actual exposure as quotient of the full exposure, with 0
-                   being no exposure at all (not very usefull) and reg10_max
+                   being no exposure at all (not very useful) and reg10_max
                    being max exposure possible at that framerate.
 
                    The code maps our 0 - 510 ms exposure ctrl to these 2
@@ -830,7 +848,7 @@ static void setexposure(struct gspca_dev *gspca_dev)
                 } else
                         reg10_max = 0x41;
 
-                reg11 = (15 * sd->exposure + 999) / 1000;
+                reg11 = (15 * sd->ctrls[EXPOSURE].val + 999) / 1000;
                 if (reg11 < 1)
                         reg11 = 1;
                 else if (reg11 > 16)
@@ -843,14 +861,16 @@ static void setexposure(struct gspca_dev *gspca_dev)
                         reg11 = 4;
 
                 /* frame exposure time in ms = 1000 * reg11 / 30    ->
-                reg10 = (sd->exposure / 2) * reg10_max / (1000 * reg11 / 30) */
-                reg10 = (sd->exposure * 15 * reg10_max) / (1000 * reg11);
+                reg10 = (sd->ctrls[EXPOSURE].val / 2) * reg10_max
+                                / (1000 * reg11 / 30) */
+                reg10 = (sd->ctrls[EXPOSURE].val * 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
                    the image to oscilate from much too dark, to much too bright
                    and back again. */
-                if (sd->autogain && reg10 < 10)
+                if (sd->ctrls[AUTOGAIN].val && reg10 < 10)
                         reg10 = 10;
                 else if (reg10 > reg10_max)
                         reg10 = reg10_max;
@@ -861,7 +881,7 @@ static void setexposure(struct gspca_dev *gspca_dev)
                 i2c[4] |= reg11 - 1;
 
                 /* If register 11 didn't change, don't change it */
-                if (sd->reg11 == reg11 )
+                if (sd->reg11 == reg11)
                         i2c[0] = 0xa0;
 
                 if (i2c_w(gspca_dev, i2c) == 0)
@@ -889,15 +909,16 @@ static void setexposure(struct gspca_dev *gspca_dev)
                    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;
+                if (sd->ctrls[EXPOSURE].val < 200) {
+                        i2cpexpo[3] = 255 - (sd->ctrls[EXPOSURE].val * 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;
+                        framerate_ctrl = (sd->ctrls[EXPOSURE].val - 200)
+                                                        * 1000 / 229 +  500;
                 }
 
                 i2cpframerate[3] = framerate_ctrl >> 6;
@@ -921,15 +942,15 @@ static void setexposure(struct gspca_dev *gspca_dev)
 
                 /* For values below 150 use partial frame exposure, above
                    that use framerate ctrl */
-                if (sd->exposure < 150) {
-                        i2cpexpo[3] = 150 - sd->exposure;
+                if (sd->ctrls[EXPOSURE].val < 150) {
+                        i2cpexpo[3] = 150 - sd->ctrls[EXPOSURE].val;
                         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;
+                        framerate_ctrl = (sd->ctrls[EXPOSURE].val - 150)
+                                                * 1000 / 230 + 300;
                 }
 
                 i2cpframerate[3] = framerate_ctrl >> 4;
@@ -960,7 +981,7 @@ static void setfreq(struct gspca_dev *gspca_dev)
                    0x2b register, see ov6630 datasheet.
                    0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
                 __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
-                switch (sd->freq) {
+                switch (sd->ctrls[FREQ].val) {
                 default:
 /*              case 0:                  * no filter*/
 /*              case 2:                  * 60 hz */
@@ -979,7 +1000,7 @@ static void setfreq(struct gspca_dev *gspca_dev)
         }
 }
 
-#include "coarse_expo_autogain.h"
+#include "autogain_functions.h"
 
 static void do_autogain(struct gspca_dev *gspca_dev)
 {
@@ -987,7 +1008,8 @@ static void do_autogain(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         int avg_lum = atomic_read(&sd->avg_lum);
 
-        if (avg_lum == -1 || !sd->autogain)
+        if ((gspca_dev->ctrl_dis & (1 << AUTOGAIN)) ||
+            avg_lum == -1 || !sd->ctrls[AUTOGAIN].val)
                 return;
 
         if (sd->autogain_ignore_frames > 0) {
@@ -1003,21 +1025,24 @@ static void do_autogain(struct gspca_dev *gspca_dev)
                 desired_avg_lum = 5000;
         } else {
                 deadzone = 1500;
-                desired_avg_lum = 18000;
+                desired_avg_lum = 13000;
         }
 
         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,
+                result = coarse_grained_expo_autogain(gspca_dev, avg_lum,
+                                sd->ctrls[BRIGHTNESS].val
+                                                * desired_avg_lum / 127,
                                 deadzone);
         else
-                result = gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
-                                sd->brightness * desired_avg_lum / 127,
+                result = auto_gain_n_exposure(gspca_dev, avg_lum,
+                                sd->ctrls[BRIGHTNESS].val
+                                                * 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);
+                        (int) sd->ctrls[GAIN].val,
+                        (int) sd->ctrls[EXPOSURE].val);
                 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
         }
 }
@@ -1036,9 +1061,15 @@ static int sd_config(struct gspca_dev *gspca_dev,
         /* copy the webcam info from the device id */
         sd->sensor = id->driver_info >> 8;
         sd->bridge = id->driver_info & 0xff;
+
         gspca_dev->ctrl_dis = sensor_data[sd->sensor].ctrl_dis;
+#if AUTOGAIN_DEF
+        if (!(gspca_dev->ctrl_dis & (1 << AUTOGAIN)))
+                gspca_dev->ctrl_inac = (1 << GAIN) | (1 << EXPOSURE);
+#endif
 
         cam = &gspca_dev->cam;
+        cam->ctrls = sd->ctrls;
         if (!(sensor_data[sd->sensor].flags & F_SIF)) {
                 cam->cam_mode = vga_mode;
                 cam->nmodes = ARRAY_SIZE(vga_mode);
@@ -1048,20 +1079,11 @@ static int sd_config(struct gspca_dev *gspca_dev,
         }
         cam->npkt = 36;                 /* 36 packets per ISOC message */
 
-        sd->brightness = BRIGHTNESS_DEF;
-        sd->gain = GAIN_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);
+                sd->ctrls[EXPOSURE].min = COARSE_EXPOSURE_MIN;
+                sd->ctrls[EXPOSURE].max = COARSE_EXPOSURE_MAX;
+                sd->ctrls[EXPOSURE].def = COARSE_EXPOSURE_DEF;
         }
-        if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
-                sd->autogain = 0; /* Disable do_autogain callback */
-        else
-                sd->autogain = AUTOGAIN_DEF;
-        sd->freq = FREQ_DEF;
 
         return 0;
 }
@@ -1081,53 +1103,91 @@ static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct cam *cam = &gspca_dev->cam;
-        int mode, l;
-        const __u8 *sn9c10x;
-        __u8 reg12_19[8];
+        int i, mode;
+        __u8 regs[0x31];
 
         mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
-        sn9c10x = sensor_data[sd->sensor].bridge_init[sd->bridge];
-        l = sensor_data[sd->sensor].bridge_init_size[sd->bridge];
-        memcpy(reg12_19, &sn9c10x[0x12 - 1], 8);
-        reg12_19[6] = sn9c10x[0x18 - 1] | (mode << 4);
-        /* Special cases where reg 17 and or 19 value depends on mode */
+        /* Copy registers 0x01 - 0x19 from the template */
+        memcpy(&regs[0x01], sensor_data[sd->sensor].bridge_init, 0x19);
+        /* Set the mode */
+        regs[0x18] |= mode << 4;
+
+        /* Set bridge gain to 1.0 */
+        if (sd->bridge == BRIDGE_103) {
+                regs[0x05] = 0x20; /* Red */
+                regs[0x06] = 0x20; /* Green */
+                regs[0x07] = 0x20; /* Blue */
+        } else {
+                regs[0x10] = 0x00; /* Red and blue */
+                regs[0x11] = 0x00; /* Green */
+        }
+
+        /* Setup pixel numbers and auto exposure window */
+        if (sensor_data[sd->sensor].flags & F_SIF) {
+                regs[0x1a] = 0x14; /* HO_SIZE 640, makes no sense */
+                regs[0x1b] = 0x0a; /* VO_SIZE 320, makes no sense */
+                regs[0x1c] = 0x02; /* AE H-start 64 */
+                regs[0x1d] = 0x02; /* AE V-start 64 */
+                regs[0x1e] = 0x09; /* AE H-end 288 */
+                regs[0x1f] = 0x07; /* AE V-end 224 */
+        } else {
+                regs[0x1a] = 0x1d; /* HO_SIZE 960, makes no sense */
+                regs[0x1b] = 0x10; /* VO_SIZE 512, makes no sense */
+                regs[0x1c] = 0x05; /* AE H-start 160 */
+                regs[0x1d] = 0x03; /* AE V-start 96 */
+                regs[0x1e] = 0x0f; /* AE H-end 480 */
+                regs[0x1f] = 0x0c; /* AE V-end 384 */
+        }
+
+        /* Setup the gamma table (only used with the sn9c103 bridge) */
+        for (i = 0; i < 16; i++)
+                regs[0x20 + i] = i * 16;
+        regs[0x20 + i] = 255;
+
+        /* Special cases where some regs depend on mode or bridge */
         switch (sd->sensor) {
         case SENSOR_TAS5130CXX:
-                /* probably not mode specific at all most likely the upper
+                /* FIXME / TESTME
+                   probably not mode specific at all most likely the upper
                    nibble of 0x19 is exposure (clock divider) just as with
                    the tas5110, we need someone to test this. */
-                reg12_19[7] = mode ? 0x23 : 0x43;
+                regs[0x19] = mode ? 0x23 : 0x43;
                 break;
+        case SENSOR_OV7630:
+                /* FIXME / TESTME for some reason with the 101/102 bridge the
+                   clock is set to 12 Mhz (reg1 == 0x04), rather then 24.
+                   Also the hstart needs to go from 1 to 2 when using a 103,
+                   which is likely related. This does not seem right. */
+                if (sd->bridge == BRIDGE_103) {
+                        regs[0x01] = 0x44; /* Select 24 Mhz clock */
+                        regs[0x12] = 0x02; /* Set hstart to 2 */
+                }
         }
         /* Disable compression when the raw bayer format has been selected */
         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
-                reg12_19[6] &= ~0x80;
+                regs[0x18] &= ~0x80;
 
         /* Vga mode emulation on SIF sensor? */
         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
-                reg12_19[0] += 16; /* 0x12: hstart adjust */
-                reg12_19[1] += 24; /* 0x13: vstart adjust */
-                reg12_19[3] = 320 / 16; /* 0x15: hsize */
-                reg12_19[4] = 240 / 16; /* 0x16: vsize */
+                regs[0x12] += 16;       /* hstart adjust */
+                regs[0x13] += 24;       /* vstart adjust */
+                regs[0x15]  = 320 / 16; /* hsize */
+                regs[0x16]  = 240 / 16; /* vsize */
         }
 
         /* reg 0x01 bit 2 video transfert on */
-        reg_w(gspca_dev, 0x01, &sn9c10x[0x01 - 1], 1);
+        reg_w(gspca_dev, 0x01, &regs[0x01], 1);
         /* reg 0x17 SensorClk enable inv Clk 0x60 */
-        reg_w(gspca_dev, 0x17, &sn9c10x[0x17 - 1], 1);
+        reg_w(gspca_dev, 0x17, &regs[0x17], 1);
         /* Set the registers from the template */
-        reg_w(gspca_dev, 0x01, sn9c10x, l);
+        reg_w(gspca_dev, 0x01, &regs[0x01],
+              (sd->bridge == BRIDGE_103) ? 0x30 : 0x1f);
 
         /* Init the sensor */
         i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
                         sensor_data[sd->sensor].sensor_init_size);
-        if (sensor_data[sd->sensor].sensor_bridge_init[sd->bridge])
-                i2c_w_vector(gspca_dev,
-                        sensor_data[sd->sensor].sensor_bridge_init[sd->bridge],
-                        sensor_data[sd->sensor].sensor_bridge_init_size[
-                                sd->bridge]);
 
-        /* Mode specific sensor setup */
+        /* Mode / bridge specific sensor setup */
         switch (sd->sensor) {
         case SENSOR_PAS202: {
                 const __u8 i2cpclockdiv[] =
@@ -1135,27 +1195,37 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 /* clockdiv from 4 to 3 (7.5 -> 10 fps) when in low res mode */
                 if (mode)
                         i2c_w(gspca_dev, i2cpclockdiv);
+                break;
             }
+        case SENSOR_OV7630:
+                /* FIXME / TESTME We should be able to handle this identical
+                   for the 101/102 and the 103 case */
+                if (sd->bridge == BRIDGE_103) {
+                        const __u8 i2c[] = { 0xa0, 0x21, 0x13,
+                                             0x80, 0x00, 0x00, 0x00, 0x10 };
+                        i2c_w(gspca_dev, i2c);
+                }
+                break;
         }
         /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
-        reg_w(gspca_dev, 0x15, &reg12_19[3], 2);
+        reg_w(gspca_dev, 0x15, &regs[0x15], 2);
         /* compression register */
-        reg_w(gspca_dev, 0x18, &reg12_19[6], 1);
+        reg_w(gspca_dev, 0x18, &regs[0x18], 1);
         /* H_start */
-        reg_w(gspca_dev, 0x12, &reg12_19[0], 1);
+        reg_w(gspca_dev, 0x12, &regs[0x12], 1);
         /* V_START */
-        reg_w(gspca_dev, 0x13, &reg12_19[1], 1);
+        reg_w(gspca_dev, 0x13, &regs[0x13], 1);
         /* reset 0x17 SensorClk enable inv Clk 0x60 */
                                 /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
-        reg_w(gspca_dev, 0x17, &reg12_19[5], 1);
+        reg_w(gspca_dev, 0x17, &regs[0x17], 1);
         /*MCKSIZE ->3 */        /*fixme: not ov7630*/
-        reg_w(gspca_dev, 0x19, &reg12_19[7], 1);
+        reg_w(gspca_dev, 0x19, &regs[0x19], 1);
         /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
-        reg_w(gspca_dev, 0x1c, &sn9c10x[0x1c - 1], 4);
+        reg_w(gspca_dev, 0x1c, &regs[0x1c], 4);
         /* Enable video transfert */
-        reg_w(gspca_dev, 0x01, &sn9c10x[0], 1);
+        reg_w(gspca_dev, 0x01, &regs[0x01], 1);
         /* Compression */
-        reg_w(gspca_dev, 0x18, &reg12_19[6], 2);
+        reg_w(gspca_dev, 0x18, &regs[0x18], 2);
         msleep(20);
 
         sd->reg11 = -1;
@@ -1178,13 +1248,10 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
         sd_init(gspca_dev);
 }
 
-static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                        u8 *data,                       /* isoc packet */
-                        int len)                        /* iso packet length */
+static u8* find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
 {
-        int i;
         struct sd *sd = (struct sd *) gspca_dev;
-        struct cam *cam = &gspca_dev->cam;
+        int i, header_size = (sd->bridge == BRIDGE_103) ? 18 : 12;
 
         /* frames start with:
          *      ff ff 00 c4 c4 96       synchro
@@ -1195,58 +1262,84 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
          *      ll mm           brightness sum outside auto exposure
          *      (xx xx xx xx xx)        audio values for snc103
          */
-        if (len > 6 && len < 24) {
-                for (i = 0; i < len - 6; i++) {
-                        if (data[0 + i] == 0xff
-                            && data[1 + i] == 0xff
-                            && data[2 + i] == 0x00
-                            && data[3 + i] == 0xc4
-                            && data[4 + i] == 0xc4
-                            && data[5 + i] == 0x96) {   /* start of frame */
-                                int lum = -1;
-                                int pkt_type = LAST_PACKET;
-                                int fr_h_sz = (sd->bridge == BRIDGE_103) ?
-                                        18 : 12;
-
-                                if (len - i < fr_h_sz) {
-                                        PDEBUG(D_STREAM, "packet too short to"
-                                                " get avg brightness");
-                                } else if (sd->bridge == BRIDGE_103) {
-                                        lum = data[i + 9] +
-                                                (data[i + 10] << 8);
-                                } else {
-                                        lum = data[i + 8] + (data[i + 9] << 8);
-                                }
-                                /* When exposure changes midway a frame we
-                                   get a lum of 0 in this case drop 2 frames
-                                   as the frames directly after an exposure
-                                   change have an unstable image. Sometimes lum
-                                   *really* is 0 (cam used in low light with
-                                   low exposure setting), so do not drop frames
-                                   if the previous lum was 0 too. */
-                                if (lum == 0 && sd->prev_avg_lum != 0) {
-                                        lum = -1;
-                                        sd->frames_to_drop = 2;
-                                        sd->prev_avg_lum = 0;
-                                } else
-                                        sd->prev_avg_lum = lum;
-                                atomic_set(&sd->avg_lum, lum);
-
-                                if (sd->frames_to_drop) {
-                                        sd->frames_to_drop--;
-                                        pkt_type = DISCARD_PACKET;
-                                }
-
-                                gspca_frame_add(gspca_dev, pkt_type,
-                                                NULL, 0);
-                                data += i + fr_h_sz;
-                                len -= i + fr_h_sz;
-                                gspca_frame_add(gspca_dev, FIRST_PACKET,
-                                                data, len);
-                                return;
+        for (i = 0; i < len; i++) {
+                switch (sd->header_read) {
+                case 0:
+                        if (data[i] == 0xff)
+                                sd->header_read++;
+                        break;
+                case 1:
+                        if (data[i] == 0xff)
+                                sd->header_read++;
+                        else
+                                sd->header_read = 0;
+                        break;
+                case 2:
+                        if (data[i] == 0x00)
+                                sd->header_read++;
+                        else if (data[i] != 0xff)
+                                sd->header_read = 0;
+                        break;
+                case 3:
+                        if (data[i] == 0xc4)
+                                sd->header_read++;
+                        else if (data[i] == 0xff)
+                                sd->header_read = 1;
+                        else
+                                sd->header_read = 0;
+                        break;
+                case 4:
+                        if (data[i] == 0xc4)
+                                sd->header_read++;
+                        else if (data[i] == 0xff)
+                                sd->header_read = 1;
+                        else
+                                sd->header_read = 0;
+                        break;
+                case 5:
+                        if (data[i] == 0x96)
+                                sd->header_read++;
+                        else if (data[i] == 0xff)
+                                sd->header_read = 1;
+                        else
+                                sd->header_read = 0;
+                        break;
+                default:
+                        sd->header[sd->header_read - 6] = data[i];
+                        sd->header_read++;
+                        if (sd->header_read == header_size) {
+                                sd->header_read = 0;
+                                return data + i + 1;
                         }
                 }
         }
+        return NULL;
+}
+
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,                       /* isoc packet */
+                        int len)                        /* iso packet length */
+{
+        int fr_h_sz = 0, lum_offset = 0, len_after_sof = 0;
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct cam *cam = &gspca_dev->cam;
+        u8 *sof;
+
+        sof = find_sof(gspca_dev, data, len);
+        if (sof) {
+                if (sd->bridge == BRIDGE_103) {
+                        fr_h_sz = 18;
+                        lum_offset = 3;
+                } else {
+                        fr_h_sz = 12;
+                        lum_offset = 2;
+                }
+
+                len_after_sof = len - (sof - data);
+                len = (sof - data) - fr_h_sz;
+                if (len < 0)
+                        len = 0;
+        }
 
         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
                 /* In raw mode we sometimes get some garbage after the frame
@@ -1260,67 +1353,40 @@ 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_setgain(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->gain = val;
-        if (gspca_dev->streaming)
-                setgain(gspca_dev);
-        return 0;
-}
-
-static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
 
-        *val = sd->gain;
-        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 0;
-}
+        if (sof) {
+                int  lum = sd->header[lum_offset] +
+                          (sd->header[lum_offset + 1] << 8);
+
+                /* When exposure changes midway a frame we
+                   get a lum of 0 in this case drop 2 frames
+                   as the frames directly after an exposure
+                   change have an unstable image. Sometimes lum
+                   *really* is 0 (cam used in low light with
+                   low exposure setting), so do not drop frames
+                   if the previous lum was 0 too. */
+                if (lum == 0 && sd->prev_avg_lum != 0) {
+                        lum = -1;
+                        sd->frames_to_drop = 2;
+                        sd->prev_avg_lum = 0;
+                } else
+                        sd->prev_avg_lum = lum;
+                atomic_set(&sd->avg_lum, lum);
 
-static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
+                if (sd->frames_to_drop)
+                        sd->frames_to_drop--;
+                else
+                        gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
 
-        *val = sd->exposure;
-        return 0;
+                gspca_frame_add(gspca_dev, FIRST_PACKET, sof, len_after_sof);
+        }
 }
 
 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        sd->autogain = val;
+        sd->ctrls[AUTOGAIN].val = val;
         sd->exp_too_high_cnt = 0;
         sd->exp_too_low_cnt = 0;
 
@@ -1328,9 +1394,10 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
            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 && !(sensor_data[sd->sensor].flags & F_COARSE_EXPO)) {
-                sd->exposure = EXPOSURE_DEF;
-                sd->gain = GAIN_DEF;
+        if (sd->ctrls[AUTOGAIN].val
+         && !(sensor_data[sd->sensor].flags & F_COARSE_EXPO)) {
+                sd->ctrls[EXPOSURE].val = sd->ctrls[EXPOSURE].def;
+                sd->ctrls[GAIN].val = sd->ctrls[GAIN].def;
                 if (gspca_dev->streaming) {
                         sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
                         setexposure(gspca_dev);
@@ -1338,32 +1405,11 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
                 }
         }
 
-        return 0;
-}
-
-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_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 0;
-}
-
-static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
+        if (sd->ctrls[AUTOGAIN].val)
+                gspca_dev->ctrl_inac = (1 << GAIN) | (1 << EXPOSURE);
+        else
+                gspca_dev->ctrl_inac = 0;
 
-        *val = sd->freq;
         return 0;
 }
 
@@ -1388,7 +1434,7 @@ static int sd_querymenu(struct gspca_dev *gspca_dev,
         return -EINVAL;
 }
 
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrupt packet length */
@@ -1419,7 +1465,7 @@ static const struct sd_desc sd_desc = {
         .pkt_scan = sd_pkt_scan,
         .querymenu = sd_querymenu,
         .dq_callback = do_autogain,
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
@@ -1429,36 +1475,41 @@ static const struct sd_desc sd_desc = {
         .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
 
 
-static const struct usb_device_id device_table[] __devinitconst = {
+static const struct usb_device_id device_table[] = {
         {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(TAS5110D, 101)}, /* TAS5110D */
-#endif
         {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
         {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
         {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
-#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
         {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
+#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
         {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)},
+        {USB_DEVICE(0x0c45, 0x602a), SB(HV7131D, 102)},
+        /* {USB_DEVICE(0x0c45, 0x602b), SB(MI0343, 102)}, */
         {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
         {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
         {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
+        /* {USB_DEVICE(0x0c45, 0x6030), SB(MI03XX, 102)}, */ /* MI0343 MI0360 MI0330 */
+        /* {USB_DEVICE(0x0c45, 0x6082), SB(MI03XX, 103)}, */ /* MI0343 MI0360 */
+        {USB_DEVICE(0x0c45, 0x6083), SB(HV7131D, 103)},
+        {USB_DEVICE(0x0c45, 0x608c), SB(HV7131R, 103)},
+        /* {USB_DEVICE(0x0c45, 0x608e), SB(CISVF10, 103)}, */
         {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
-#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
+        {USB_DEVICE(0x0c45, 0x60a8), SB(PAS106, 103)},
+        {USB_DEVICE(0x0c45, 0x60aa), SB(TAS5130CXX, 103)},
         {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
-#endif
         {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
         {}
 };
 MODULE_DEVICE_TABLE(usb, device_table);
 
 /* -- device connect -- */
-static int __devinit sd_probe(struct usb_interface *intf,
+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),
@@ -1479,17 +1530,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c
index 370544361be2..81b8a600783b 100644
--- a/drivers/media/video/gspca/sonixj.c
+++ b/drivers/media/video/gspca/sonixj.c
@@ -25,37 +25,53 @@
 #include "gspca.h"
 #include "jpeg.h"
 
-#define V4L2_CID_INFRARED (V4L2_CID_PRIVATE_BASE + 0)
-
 MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
 MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver");
 MODULE_LICENSE("GPL");
 
+/* controls */
+enum e_ctrl {
+        BRIGHTNESS,
+        CONTRAST,
+        COLORS,
+        BLUE,
+        RED,
+        GAMMA,
+        AUTOGAIN,
+        HFLIP,
+        VFLIP,
+        SHARPNESS,
+        ILLUM,
+        FREQ,
+        NCTRLS          /* number of controls */
+};
+
 /* specific webcam descriptor */
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
 
+        struct gspca_ctrl ctrls[NCTRLS];
+
         atomic_t avg_lum;
         u32 exposure;
 
-        u16 brightness;
-        u8 contrast;
-        u8 colors;
-        u8 autogain;
-        u8 blue;
-        u8 red;
-        u8 gamma;
-        u8 vflip;                       /* ov7630/ov7648 only */
-        u8 sharpness;
-        u8 infrared;                    /* mt9v111 only */
-        u8 freq;                        /* ov76xx only */
+        struct work_struct work;
+        struct workqueue_struct *work_thread;
+
+        u32 pktsz;                      /* (used by pkt_scan) */
+        u16 npkt;
+        s8 nchg;
+        s8 short_mark;
+
         u8 quality;                     /* image quality */
-#define QUALITY_MIN 60
-#define QUALITY_MAX 95
-#define QUALITY_DEF 80
-        u8 jpegqual;                    /* webcam quality */
+#define QUALITY_MIN 25
+#define QUALITY_MAX 90
+#define QUALITY_DEF 70
 
+        u8 reg01;
+        u8 reg17;
         u8 reg18;
+        u8 flags;
 
         s8 ag_cnt;
 #define AG_CNT_START 13
@@ -75,6 +91,7 @@ enum sensors {
         SENSOR_GC0307,
         SENSOR_HV7131R,
         SENSOR_MI0360,
+        SENSOR_MI0360B,
         SENSOR_MO4000,
         SENSOR_MT9V111,
         SENSOR_OM6802,
@@ -87,49 +104,51 @@ enum sensors {
         SENSOR_SP80708,
 };
 
+static void qual_upd(struct work_struct *work);
+
+/* device flags */
+#define F_PDN_INV       0x01    /* inverse pin S_PWR_DN / sn_xxx tables */
+#define F_ILLUM         0x02    /* presence of illuminator */
+
+/* sn9c1xx definitions */
+/* register 0x01 */
+#define S_PWR_DN        0x01    /* sensor power down */
+#define S_PDN_INV       0x02    /* inverse pin S_PWR_DN */
+#define V_TX_EN         0x04    /* video transfer enable */
+#define LED             0x08    /* output to pin LED */
+#define SCL_SEL_OD      0x20    /* open-drain mode */
+#define SYS_SEL_48M     0x40    /* system clock 0: 24MHz, 1: 48MHz */
+/* register 0x17 */
+#define MCK_SIZE_MASK   0x1f    /* sensor master clock */
+#define SEN_CLK_EN      0x20    /* enable sensor clock */
+#define DEF_EN          0x80    /* defect pixel by 0: soft, 1: hard */
+
 /* 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_setblue_balance(struct gspca_dev *gspca_dev, __s32 val);
-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 int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getgamma(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_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 const struct ctrl sd_ctrls[] = {
-#define BRIGHTNESS_IDX 0
-        {
+static void setbrightness(struct gspca_dev *gspca_dev);
+static void setcontrast(struct gspca_dev *gspca_dev);
+static void setcolors(struct gspca_dev *gspca_dev);
+static void setredblue(struct gspca_dev *gspca_dev);
+static void setgamma(struct gspca_dev *gspca_dev);
+static void setautogain(struct gspca_dev *gspca_dev);
+static void sethvflip(struct gspca_dev *gspca_dev);
+static void setsharpness(struct gspca_dev *gspca_dev);
+static void setillum(struct gspca_dev *gspca_dev);
+static void setfreq(struct gspca_dev *gspca_dev);
+
+static const struct ctrl sd_ctrls[NCTRLS] = {
+[BRIGHTNESS] =  {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
                 .name    = "Brightness",
                 .minimum = 0,
-#define BRIGHTNESS_MAX 0xffff
-                .maximum = BRIGHTNESS_MAX,
+                .maximum = 0xff,
                 .step    = 1,
-#define BRIGHTNESS_DEF 0x8000
-                .default_value = BRIGHTNESS_DEF,
+                .default_value = 0x80,
             },
-            .set = sd_setbrightness,
-            .get = sd_getbrightness,
+            .set_control = setbrightness
         },
-#define CONTRAST_IDX 1
-        {
+[CONTRAST] = {
             {
                 .id      = V4L2_CID_CONTRAST,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -138,14 +157,11 @@ static const struct ctrl sd_ctrls[] = {
 #define CONTRAST_MAX 127
                 .maximum = CONTRAST_MAX,
                 .step    = 1,
-#define CONTRAST_DEF 63
-                .default_value = CONTRAST_DEF,
+                .default_value = 63,
             },
-            .set = sd_setcontrast,
-            .get = sd_getcontrast,
+            .set_control = setcontrast
         },
-#define COLOR_IDX 2
-        {
+[COLORS] = {
             {
                 .id      = V4L2_CID_SATURATION,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -153,14 +169,12 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 40,
                 .step    = 1,
-#define COLOR_DEF 25
-                .default_value = COLOR_DEF,
+#define COLORS_DEF 25
+                .default_value = COLORS_DEF,
             },
-            .set = sd_setcolors,
-            .get = sd_getcolors,
+            .set_control = setcolors
         },
-#define BLUE_BALANCE_IDX 3
-        {
+[BLUE] = {
             {
                 .id      = V4L2_CID_BLUE_BALANCE,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -168,14 +182,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 24,
                 .maximum = 40,
                 .step    = 1,
-#define BLUE_BALANCE_DEF 32
-                .default_value = BLUE_BALANCE_DEF,
+                .default_value = 32,
             },
-            .set = sd_setblue_balance,
-            .get = sd_getblue_balance,
+            .set_control = setredblue
         },
-#define RED_BALANCE_IDX 4
-        {
+[RED] = {
             {
                 .id      = V4L2_CID_RED_BALANCE,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -183,14 +194,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 24,
                 .maximum = 40,
                 .step    = 1,
-#define RED_BALANCE_DEF 32
-                .default_value = RED_BALANCE_DEF,
+                .default_value = 32,
             },
-            .set = sd_setred_balance,
-            .get = sd_getred_balance,
+            .set_control = setredblue
         },
-#define GAMMA_IDX 5
-        {
+[GAMMA] = {
             {
                 .id      = V4L2_CID_GAMMA,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -201,11 +209,9 @@ static const struct ctrl sd_ctrls[] = {
 #define GAMMA_DEF 20
                 .default_value = GAMMA_DEF,
             },
-            .set = sd_setgamma,
-            .get = sd_getgamma,
+            .set_control = setgamma
         },
-#define AUTOGAIN_IDX 6
-        {
+[AUTOGAIN] = {
             {
                 .id      = V4L2_CID_AUTOGAIN,
                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -213,15 +219,23 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-#define AUTOGAIN_DEF 1
-                .default_value = AUTOGAIN_DEF,
+                .default_value = 1
+            },
+            .set_control = setautogain
+        },
+[HFLIP] = {
+            {
+                .id      = V4L2_CID_HFLIP,
+                .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                .name    = "Mirror",
+                .minimum = 0,
+                .maximum = 1,
+                .step    = 1,
+                .default_value = 0,
             },
-            .set = sd_setautogain,
-            .get = sd_getautogain,
+            .set_control = sethvflip
         },
-/* ov7630/ov7648 only */
-#define VFLIP_IDX 7
-        {
+[VFLIP] = {
             {
                 .id      = V4L2_CID_VFLIP,
                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -229,14 +243,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-#define VFLIP_DEF 0
-                .default_value = VFLIP_DEF,
+                .default_value = 0,
             },
-            .set = sd_setvflip,
-            .get = sd_getvflip,
+            .set_control = sethvflip
         },
-#define SHARPNESS_IDX 8
-        {
+[SHARPNESS] = {
             {
                 .id      = V4L2_CID_SHARPNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -244,31 +255,24 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define SHARPNESS_DEF 90
-                .default_value = SHARPNESS_DEF,
+                .default_value = 90,
             },
-            .set = sd_setsharpness,
-            .get = sd_getsharpness,
+            .set_control = setsharpness
         },
-/* mt9v111 only */
-#define INFRARED_IDX 9
-        {
+[ILLUM] = {
             {
-                .id      = V4L2_CID_INFRARED,
+                .id      = V4L2_CID_ILLUMINATORS_1,
                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
-                .name    = "Infrared",
+                .name    = "Illuminator / infrared",
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-#define INFRARED_DEF 0
-                .default_value = INFRARED_DEF,
+                .default_value = 0,
             },
-            .set = sd_setinfrared,
-            .get = sd_getinfrared,
+            .set_control = setillum
         },
 /* ov7630/ov7648/ov7660 only */
-#define FREQ_IDX 10
-        {
+[FREQ] = {
             {
                 .id      = V4L2_CID_POWER_LINE_FREQUENCY,
                 .type    = V4L2_CTRL_TYPE_MENU,
@@ -276,69 +280,71 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
                 .step    = 1,
-#define FREQ_DEF 1
-                .default_value = FREQ_DEF,
+                .default_value = 1,
             },
-            .set = sd_setfreq,
-            .get = sd_getfreq,
+            .set_control = setfreq
         },
 };
 
 /* table of the disabled controls */
 static const __u32 ctrl_dis[] = {
-[SENSOR_ADCM1700] =     (1 << AUTOGAIN_IDX) |
-                        (1 << INFRARED_IDX) |
-                        (1 << VFLIP_IDX) |
-                        (1 << FREQ_IDX),
-
-[SENSOR_GC0307] =       (1 << INFRARED_IDX) |
-                        (1 << VFLIP_IDX) |
-                        (1 << FREQ_IDX),
-
-[SENSOR_HV7131R] =      (1 << INFRARED_IDX) |
-                        (1 << FREQ_IDX),
-
-[SENSOR_MI0360] =       (1 << INFRARED_IDX) |
-                        (1 << VFLIP_IDX) |
-                        (1 << FREQ_IDX),
-
-[SENSOR_MO4000] =       (1 << INFRARED_IDX) |
-                        (1 << VFLIP_IDX) |
-                        (1 << FREQ_IDX),
-
-[SENSOR_MT9V111] =      (1 << VFLIP_IDX) |
-                        (1 << FREQ_IDX),
-
-[SENSOR_OM6802] =       (1 << INFRARED_IDX) |
-                        (1 << VFLIP_IDX) |
-                        (1 << FREQ_IDX),
-
-[SENSOR_OV7630] =       (1 << INFRARED_IDX),
-
-[SENSOR_OV7648] =       (1 << INFRARED_IDX),
-
-[SENSOR_OV7660] =       (1 << AUTOGAIN_IDX) |
-                        (1 << INFRARED_IDX) |
-                        (1 << VFLIP_IDX),
-
-[SENSOR_PO1030] =       (1 << AUTOGAIN_IDX) |
-                        (1 << INFRARED_IDX) |
-                        (1 << VFLIP_IDX) |
-                        (1 << FREQ_IDX),
-
-[SENSOR_PO2030N] =      (1 << AUTOGAIN_IDX) |
-                        (1 << INFRARED_IDX) |
-                        (1 << VFLIP_IDX) |
-                        (1 << FREQ_IDX),
-[SENSOR_SOI768] =       (1 << AUTOGAIN_IDX) |
-                        (1 << INFRARED_IDX) |
-                        (1 << VFLIP_IDX) |
-                        (1 << FREQ_IDX),
-
-[SENSOR_SP80708] =      (1 << AUTOGAIN_IDX) |
-                        (1 << INFRARED_IDX) |
-                        (1 << VFLIP_IDX) |
-                        (1 << FREQ_IDX),
+[SENSOR_ADCM1700] =     (1 << AUTOGAIN) |
+                        (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << FREQ),
+
+[SENSOR_GC0307] =       (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << FREQ),
+
+[SENSOR_HV7131R] =      (1 << HFLIP) |
+                        (1 << FREQ),
+
+[SENSOR_MI0360] =       (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << FREQ),
+
+[SENSOR_MI0360B] =      (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << FREQ),
+
+[SENSOR_MO4000] =       (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << FREQ),
+
+[SENSOR_MT9V111] =      (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << FREQ),
+
+[SENSOR_OM6802] =       (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << FREQ),
+
+[SENSOR_OV7630] =       (1 << HFLIP),
+
+[SENSOR_OV7648] =       (1 << HFLIP),
+
+[SENSOR_OV7660] =       (1 << AUTOGAIN) |
+                        (1 << HFLIP) |
+                        (1 << VFLIP),
+
+[SENSOR_PO1030] =       (1 << AUTOGAIN) |
+                        (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << FREQ),
+
+[SENSOR_PO2030N] =      (1 << AUTOGAIN) |
+                        (1 << FREQ),
+
+[SENSOR_SOI768] =       (1 << AUTOGAIN) |
+                        (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << FREQ),
+
+[SENSOR_SP80708] =      (1 << AUTOGAIN) |
+                        (1 << HFLIP) |
+                        (1 << VFLIP) |
+                        (1 << FREQ),
 };
 
 static const struct v4l2_pix_format cif_mode[] = {
@@ -402,7 +408,7 @@ static const u8 sn_hv7131[0x1c] = {
 
 static const u8 sn_mi0360[0x1c] = {
 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
-        0x00,   0x61,   0x40,   0x00,   0x1a,   0x20,   0x20,   0x20,
+        0x00,   0x63,   0x40,   0x00,   0x1a,   0x20,   0x20,   0x20,
 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
         0x81,   0x5d,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
@@ -411,6 +417,17 @@ static const u8 sn_mi0360[0x1c] = {
         0x06,   0x00,   0x00,   0x00
 };
 
+static const u8 sn_mi0360b[0x1c] = {
+/*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
+        0x00,   0x61,   0x40,   0x00,   0x1a,   0x00,   0x00,   0x00,
+/*      reg8    reg9    rega    regb    regc    regd    rege    regf */
+        0x81,   0x5d,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
+/*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
+        0x03,   0x00,   0x00,   0x02,   0x0a,   0x28,   0x1e,   0x40,
+/*      reg18   reg19   reg1a   reg1b */
+        0x06,   0x00,   0x00,   0x00
+};
+
 static const u8 sn_mo4000[0x1c] = {
 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
         0x00,   0x23,   0x60,   0x00,   0x1a,   0x00,   0x20,   0x18,
@@ -527,6 +544,7 @@ static const u8 *sn_tb[] = {
 [SENSOR_GC0307] =       sn_gc0307,
 [SENSOR_HV7131R] =      sn_hv7131,
 [SENSOR_MI0360] =       sn_mi0360,
+[SENSOR_MI0360B] =      sn_mi0360b,
 [SENSOR_MO4000] =       sn_mo4000,
 [SENSOR_MT9V111] =      sn_mt9v111,
 [SENSOR_OM6802] =       sn_om6802,
@@ -572,20 +590,23 @@ static const u8 reg84[] = {
         0x3e, 0x00, 0xcd, 0x0f, 0xf7, 0x0f,     /* VR VG VB */
         0x00, 0x00, 0x00                        /* YUV offsets */
 };
+
+#define DELAY   0xdd
+
 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},
+        {DELAY, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
         {0xb0, 0x51, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
-        {0xdd, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+        {DELAY, 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},
+        {DELAY, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
         {0xb0, 0x51, 0x04, 0x04, 0x00, 0x00, 0x00, 0x10},
-        {0xdd, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+        {DELAY, 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},
@@ -629,7 +650,7 @@ static const u8 gc0307_sensor_init[][8] = {
         {0xa0, 0x21, 0x0e, 0x02, 0x00, 0x00, 0x00, 0x10},
         {0xa0, 0x21, 0x0f, 0xb2, 0x00, 0x00, 0x00, 0x10},
         {0xa0, 0x21, 0x12, 0x70, 0x00, 0x00, 0x00, 0x10},
-        {0xdd, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 10ms*/
+        {DELAY, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 10ms*/
         {0xa0, 0x21, 0x13, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xa0, 0x21, 0x15, 0xb8, 0x00, 0x00, 0x00, 0x10},
         {0xa0, 0x21, 0x16, 0x13, 0x00, 0x00, 0x00, 0x10},
@@ -747,6 +768,62 @@ static const u8 mi0360_sensor_init[][8] = {
         {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
         {}
 };
+static const u8 mi0360b_sensor_init[][8] = {
+        {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
+        {0xb1, 0x5d, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
+        {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 20ms*/
+        {0xb1, 0x5d, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 20ms*/
+        {0xd1, 0x5d, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
+        {0xd1, 0x5d, 0x03, 0x01, 0xe2, 0x02, 0x82, 0x10},
+        {0xd1, 0x5d, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xb1, 0x5d, 0x0d, 0x00, 0x02, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xb1, 0x5d, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
+        {0xd1, 0x5d, 0x2f, 0xf7, 0xb0, 0x00, 0x04, 0x10},
+        {0xd1, 0x5d, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
+        {0xb1, 0x5d, 0x3d, 0x06, 0x8f, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x40, 0x01, 0xe0, 0x00, 0xd1, 0x10},
+        {0xb1, 0x5d, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
+        {0xd1, 0x5d, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x5e, 0x00, 0x00, 0xa3, 0x1d, 0x10},
+        {0xb1, 0x5d, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},
+
+        {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
+        {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
+        {0xb1, 0x5d, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
+        {0xd1, 0x5d, 0x2b, 0x00, 0x33, 0x00, 0xa0, 0x10},
+        {0xd1, 0x5d, 0x2d, 0x00, 0xa0, 0x00, 0x33, 0x10},
+        {}
+};
+static const u8 mi0360b_sensor_param1[][8] = {
+        {0xb1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xb1, 0x5d, 0x06, 0x00, 0x53, 0x00, 0x00, 0x10},
+        {0xb1, 0x5d, 0x05, 0x00, 0x09, 0x00, 0x00, 0x10},
+        {0xb1, 0x5d, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10}, /* exposure 2 */
+
+        {0xd1, 0x5d, 0x2b, 0x00, 0xd1, 0x01, 0xc9, 0x10},
+        {0xd1, 0x5d, 0x2d, 0x00, 0xed, 0x00, 0xd1, 0x10},
+        {0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10}, /* update */
+        {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
+        {}
+};
 static const u8 mo4000_sensor_init[][8] = {
         {0xa1, 0x21, 0x01, 0x02, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10},
@@ -772,23 +849,13 @@ static const u8 mo4000_sensor_init[][8] = {
 };
 static const u8 mt9v111_sensor_init[][8] = {
         {0xb1, 0x5c, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10}, /* reset? */
-        {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
+        {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
         {0xb1, 0x5c, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xb1, 0x5c, 0x01, 0x00, 0x01, 0x00, 0x00, 0x10}, /* IFP select */
         {0xb1, 0x5c, 0x08, 0x04, 0x80, 0x00, 0x00, 0x10}, /* output fmt ctrl */
         {0xb1, 0x5c, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10}, /* op mode ctrl */
-        {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10},
-        {0xb1, 0x5c, 0x03, 0x01, 0xe1, 0x00, 0x00, 0x10},
-        {0xb1, 0x5c, 0x04, 0x02, 0x81, 0x00, 0x00, 0x10},
-        {0xb1, 0x5c, 0x05, 0x00, 0x04, 0x00, 0x00, 0x10},
         {0xb1, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10}, /* sensor select */
-        {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10},
-        {0xb1, 0x5c, 0x03, 0x01, 0xe6, 0x00, 0x00, 0x10},
-        {0xb1, 0x5c, 0x04, 0x02, 0x86, 0x00, 0x00, 0x10},
-        {0xb1, 0x5c, 0x05, 0x00, 0x04, 0x00, 0x00, 0x10},
-        {0xb1, 0x5c, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xb1, 0x5c, 0x08, 0x00, 0x08, 0x00, 0x00, 0x10}, /* row start */
-        {0xb1, 0x5c, 0x0e, 0x00, 0x08, 0x00, 0x00, 0x10},
         {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10}, /* col start */
         {0xb1, 0x5c, 0x03, 0x01, 0xe7, 0x00, 0x00, 0x10}, /* window height */
         {0xb1, 0x5c, 0x04, 0x02, 0x87, 0x00, 0x00, 0x10}, /* window width */
@@ -802,15 +869,10 @@ static const u8 mt9v111_sensor_init[][8] = {
         {}
 };
 static const u8 mt9v111_sensor_param1[][8] = {
-        {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
-        {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
-        {0xb1, 0x5c, 0x09, 0x01, 0x2c, 0x00, 0x00, 0x10},
-        {0xd1, 0x5c, 0x2b, 0x00, 0x33, 0x00, 0xa0, 0x10}, /* green1 gain */
-        {0xd1, 0x5c, 0x2d, 0x00, 0xa0, 0x00, 0x33, 0x10}, /* red gain */
-        /*******/
-        {0xb1, 0x5c, 0x06, 0x00, 0x1e, 0x00, 0x00, 0x10}, /* vert blanking */
-        {0xb1, 0x5c, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x10}, /* horiz blanking */
-        {0xd1, 0x5c, 0x2c, 0x00, 0xad, 0x00, 0xad, 0x10}, /* blue gain */
+        {0xd1, 0x5c, 0x2b, 0x00, 0x33, 0x00, 0xad, 0x10}, /* G1 and B gains */
+        {0xd1, 0x5c, 0x2d, 0x00, 0xad, 0x00, 0x33, 0x10}, /* R and G2 gains */
+        {0xb1, 0x5c, 0x06, 0x00, 0x40, 0x00, 0x00, 0x10}, /* vert blanking */
+        {0xb1, 0x5c, 0x05, 0x00, 0x09, 0x00, 0x00, 0x10}, /* horiz blanking */
         {0xb1, 0x5c, 0x35, 0x01, 0xc0, 0x00, 0x00, 0x10}, /* global gain */
         {}
 };
@@ -860,10 +922,10 @@ static const u8 om6802_sensor_param1[][8] = {
 static const u8 ov7630_sensor_init[][8] = {
         {0xa1, 0x21, 0x76, 0x01, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
-        {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
+        {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
         {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
-        {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
+        {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
         {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 /* win: i2c_r from 00 to 80 */
         {0xd1, 0x21, 0x03, 0x80, 0x10, 0x20, 0x80, 0x10},
@@ -917,7 +979,7 @@ static const u8 ov7630_sensor_param1[][8] = {
 static const u8 ov7648_sensor_init[][8] = {
         {0xa1, 0x21, 0x76, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},       /* reset */
-        {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
+        {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
         {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xd1, 0x21, 0x03, 0xa4, 0x30, 0x88, 0x00, 0x10},
         {0xb1, 0x21, 0x11, 0x80, 0x08, 0x00, 0x00, 0x10},
@@ -966,7 +1028,7 @@ static const u8 ov7648_sensor_param1[][8] = {
 
 static const u8 ov7660_sensor_init[][8] = {
         {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset SCCB */
-        {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
+        {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
         {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
                                                 /* Outformat = rawRGB */
         {0xa1, 0x21, 0x13, 0xb8, 0x00, 0x00, 0x00, 0x10}, /* init COM8 */
@@ -1062,7 +1124,7 @@ static const u8 ov7660_sensor_param1[][8] = {
 static const u8 po1030_sensor_init[][8] = {
 /* the sensor registers are described in m5602/m5602_po1030.h */
         {0xa1, 0x6e, 0x3f, 0x20, 0x00, 0x00, 0x00, 0x10}, /* sensor reset */
-        {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
+        {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
         {0xa1, 0x6e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x6e, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xd1, 0x6e, 0x04, 0x02, 0xb1, 0x02, 0x39, 0x10},
@@ -1116,10 +1178,10 @@ static const u8 po1030_sensor_param1[][8] = {
 static const u8 po2030n_sensor_init[][8] = {
         {0xa1, 0x6e, 0x1e, 0x1a, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x6e, 0x1f, 0x99, 0x00, 0x00, 0x00, 0x10},
-        {0xdd, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 10ms */
+        {DELAY, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 10ms */
         {0xa1, 0x6e, 0x1e, 0x0a, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x6e, 0x1f, 0x19, 0x00, 0x00, 0x00, 0x10},
-        {0xdd, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 10ms */
+        {DELAY, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 10ms */
         {0xa1, 0x6e, 0x20, 0x44, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x6e, 0x04, 0x03, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x6e, 0x05, 0x70, 0x00, 0x00, 0x00, 0x10},
@@ -1168,7 +1230,7 @@ static const u8 po2030n_sensor_init[][8] = {
 };
 static const u8 po2030n_sensor_param1[][8] = {
         {0xa1, 0x6e, 0x1a, 0x01, 0x00, 0x00, 0x00, 0x10},
-        {0xdd, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 8ms */
+        {DELAY, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 8ms */
         {0xa1, 0x6e, 0x1b, 0xf4, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10},
         {0xd1, 0x6e, 0x16, 0x50, 0x40, 0x49, 0x40, 0x10},
@@ -1182,16 +1244,16 @@ static const u8 po2030n_sensor_param1[][8] = {
         {0xc1, 0x6e, 0x16, 0x52, 0x40, 0x48, 0x00, 0x10},
 /*after start*/
         {0xa1, 0x6e, 0x15, 0x0f, 0x00, 0x00, 0x00, 0x10},
-        {0xdd, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 5ms */
+        {DELAY, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 5ms */
         {0xa1, 0x6e, 0x1a, 0x05, 0x00, 0x00, 0x00, 0x10},
-        {0xdd, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 5ms */
+        {DELAY, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 5ms */
         {0xa1, 0x6e, 0x1b, 0x53, 0x00, 0x00, 0x00, 0x10},
         {}
 };
 
 static const u8 soi768_sensor_init[][8] = {
         {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset */
-        {0xdd, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 96ms */
+        {DELAY, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 96ms */
         {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x21, 0x13, 0x80, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x21, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x10},
@@ -1310,6 +1372,7 @@ static const u8 (*sensor_init[])[8] = {
 [SENSOR_GC0307] =       gc0307_sensor_init,
 [SENSOR_HV7131R] =      hv7131r_sensor_init,
 [SENSOR_MI0360] =       mi0360_sensor_init,
+[SENSOR_MI0360B] =      mi0360b_sensor_init,
 [SENSOR_MO4000] =       mo4000_sensor_init,
 [SENSOR_MT9V111] =      mt9v111_sensor_init,
 [SENSOR_OM6802] =       om6802_sensor_init,
@@ -1326,13 +1389,17 @@ static const u8 (*sensor_init[])[8] = {
 static void reg_r(struct gspca_dev *gspca_dev,
                   u16 value, int len)
 {
+        int ret;
+
+        if (gspca_dev->usb_err < 0)
+                return;
 #ifdef GSPCA_DEBUG
         if (len > USB_BUF_SZ) {
                 err("reg_r: buffer overflow");
                 return;
         }
 #endif
-        usb_control_msg(gspca_dev->dev,
+        ret = usb_control_msg(gspca_dev->dev,
                         usb_rcvctrlpipe(gspca_dev->dev, 0),
                         0,
                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
@@ -1340,15 +1407,23 @@ static void reg_r(struct gspca_dev *gspca_dev,
                         gspca_dev->usb_buf, len,
                         500);
         PDEBUG(D_USBI, "reg_r [%02x] -> %02x", value, gspca_dev->usb_buf[0]);
+        if (ret < 0) {
+                err("reg_r err %d", ret);
+                gspca_dev->usb_err = ret;
+        }
 }
 
 static void reg_w1(struct gspca_dev *gspca_dev,
                    u16 value,
                    u8 data)
 {
+        int ret;
+
+        if (gspca_dev->usb_err < 0)
+                return;
         PDEBUG(D_USBO, "reg_w1 [%04x] = %02x", value, data);
         gspca_dev->usb_buf[0] = data;
-        usb_control_msg(gspca_dev->dev,
+        ret = usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
                         0x08,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
@@ -1356,12 +1431,20 @@ static void reg_w1(struct gspca_dev *gspca_dev,
                         0,
                         gspca_dev->usb_buf, 1,
                         500);
+        if (ret < 0) {
+                err("reg_w1 err %d", ret);
+                gspca_dev->usb_err = ret;
+        }
 }
 static void reg_w(struct gspca_dev *gspca_dev,
                           u16 value,
                           const u8 *buffer,
                           int len)
 {
+        int ret;
+
+        if (gspca_dev->usb_err < 0)
+                return;
         PDEBUG(D_USBO, "reg_w [%04x] = %02x %02x ..",
                 value, buffer[0], buffer[1]);
 #ifdef GSPCA_DEBUG
@@ -1371,20 +1454,27 @@ static void reg_w(struct gspca_dev *gspca_dev,
         }
 #endif
         memcpy(gspca_dev->usb_buf, buffer, len);
-        usb_control_msg(gspca_dev->dev,
+        ret = usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
                         0x08,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                         value, 0,
                         gspca_dev->usb_buf, len,
                         500);
+        if (ret < 0) {
+                err("reg_w err %d", ret);
+                gspca_dev->usb_err = ret;
+        }
 }
 
 /* I2C write 1 byte */
 static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        int ret;
 
+        if (gspca_dev->usb_err < 0)
+                return;
         PDEBUG(D_USBO, "i2c_w1 [%02x] = %02x", reg, val);
         switch (sd->sensor) {
         case SENSOR_ADCM1700:
@@ -1403,7 +1493,7 @@ static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
         gspca_dev->usb_buf[5] = 0;
         gspca_dev->usb_buf[6] = 0;
         gspca_dev->usb_buf[7] = 0x10;
-        usb_control_msg(gspca_dev->dev,
+        ret = usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
                         0x08,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
@@ -1411,16 +1501,24 @@ static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
                         0,
                         gspca_dev->usb_buf, 8,
                         500);
+        if (ret < 0) {
+                err("i2c_w1 err %d", ret);
+                gspca_dev->usb_err = ret;
+        }
 }
 
 /* I2C write 8 bytes */
 static void i2c_w8(struct gspca_dev *gspca_dev,
                    const u8 *buffer)
 {
+        int ret;
+
+        if (gspca_dev->usb_err < 0)
+                return;
         PDEBUG(D_USBO, "i2c_w8 [%02x] = %02x ..",
                 buffer[2], buffer[3]);
         memcpy(gspca_dev->usb_buf, buffer, 8);
-        usb_control_msg(gspca_dev->dev,
+        ret = usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
                         0x08,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
@@ -1428,6 +1526,10 @@ static void i2c_w8(struct gspca_dev *gspca_dev,
                         gspca_dev->usb_buf, 8,
                         500);
         msleep(2);
+        if (ret < 0) {
+                err("i2c_w8 err %d", ret);
+                gspca_dev->usb_err = ret;
+        }
 }
 
 /* sensor read 'len' (1..5) bytes in gspca_dev->usb_buf */
@@ -1466,7 +1568,7 @@ static void i2c_w_seq(struct gspca_dev *gspca_dev,
                         const u8 (*data)[8])
 {
         while ((*data)[0] != 0) {
-                if ((*data)[0] != 0xdd)
+                if ((*data)[0] != DELAY)
                         i2c_w8(gspca_dev, *data);
                 else
                         msleep((*data)[1]);
@@ -1474,22 +1576,22 @@ static void i2c_w_seq(struct gspca_dev *gspca_dev,
         }
 }
 
+/* check the ID of the hv7131 sensor */
+/* this sequence is needed because it activates the sensor */
 static void hv7131r_probe(struct gspca_dev *gspca_dev)
 {
-        i2c_w1(gspca_dev, 0x02, 0);                     /* sensor wakeup */
+        i2c_w1(gspca_dev, 0x02, 0);             /* sensor wakeup */
         msleep(10);
-        reg_w1(gspca_dev, 0x02, 0x66);                  /* Gpio on */
+        reg_w1(gspca_dev, 0x02, 0x66);          /* Gpio on */
         msleep(10);
-        i2c_r(gspca_dev, 0, 5);                         /* read sensor id */
-        if (gspca_dev->usb_buf[0] == 0x02
+        i2c_r(gspca_dev, 0, 5);                 /* read sensor id */
+        if (gspca_dev->usb_buf[0] == 0x02       /* chip ID (02 is R) */
             && gspca_dev->usb_buf[1] == 0x09
-            && gspca_dev->usb_buf[2] == 0x01
-            && gspca_dev->usb_buf[3] == 0x00
-            && gspca_dev->usb_buf[4] == 0x00) {
-                PDEBUG(D_PROBE, "Sensor sn9c102P HV7131R found");
+            && gspca_dev->usb_buf[2] == 0x01) {
+                PDEBUG(D_PROBE, "Sensor HV7131R found");
                 return;
         }
-        PDEBUG(D_PROBE, "Sensor 0x%02x 0x%02x 0x%02x - sn9c102P not found",
+        warn("Erroneous HV7131R ID 0x%02x 0x%02x 0x%02x",
                 gspca_dev->usb_buf[0], gspca_dev->usb_buf[1],
                 gspca_dev->usb_buf[2]);
 }
@@ -1529,7 +1631,13 @@ static void mi0360_probe(struct gspca_dev *gspca_dev)
                 if (val != 0xffff)
                         break;
         }
+        if (gspca_dev->usb_err < 0)
+                return;
         switch (val) {
+        case 0x8221:
+                PDEBUG(D_PROBE, "Sensor mi0360b");
+                sd->sensor = SENSOR_MI0360B;
+                break;
         case 0x823a:
                 PDEBUG(D_PROBE, "Sensor mt9v111");
                 sd->sensor = SENSOR_MT9V111;
@@ -1556,6 +1664,8 @@ static void ov7630_probe(struct gspca_dev *gspca_dev)
         val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
         reg_w1(gspca_dev, 0x01, 0x29);
         reg_w1(gspca_dev, 0x17, 0x42);
+        if (gspca_dev->usb_err < 0)
+                return;
         if (val == 0x7628) {                    /* soi768 */
                 sd->sensor = SENSOR_SOI768;
 /*fixme: only valid for 0c45:613e?*/
@@ -1593,13 +1703,14 @@ static void ov7648_probe(struct gspca_dev *gspca_dev)
         val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
         reg_w1(gspca_dev, 0x01, 0x29);
         reg_w1(gspca_dev, 0x17, 0x42);
+        if (gspca_dev->usb_err < 0)
+                return;
         if (val == 0x1030) {                    /* po1030 */
                 PDEBUG(D_PROBE, "Sensor po1030");
                 sd->sensor = SENSOR_PO1030;
                 return;
         }
-
-        PDEBUG(D_PROBE, "Unknown sensor %04x", val);
+        err("Unknown sensor %04x", val);
 }
 
 /* 0c45:6142 sensor may be po2030n, gc0305 or gc0307 */
@@ -1631,141 +1742,13 @@ static void po2030n_probe(struct gspca_dev *gspca_dev)
         val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
         reg_w1(gspca_dev, 0x01, 0x29);
         reg_w1(gspca_dev, 0x17, 0x42);
+        if (gspca_dev->usb_err < 0)
+                return;
         if (val == 0x2030) {
                 PDEBUG(D_PROBE, "Sensor po2030n");
 /*              sd->sensor = SENSOR_PO2030N; */
         } else {
-                PDEBUG(D_PROBE, "Unknown sensor ID %04x", val);
-        }
-}
-
-static void bridge_init(struct gspca_dev *gspca_dev,
-                          const u8 *sn9c1xx)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        u8 reg0102[2];
-        const u8 *reg9a;
-        static const u8 reg9a_def[] =
-                {0x00, 0x40, 0x20, 0x00, 0x00, 0x00};
-        static const u8 reg9a_spec[] =
-                {0x00, 0x40, 0x38, 0x30, 0x00, 0x20};
-        static const u8 regd4[] = {0x60, 0x00, 0x00};
-
-        /* sensor clock already enabled in sd_init */
-        /* reg_w1(gspca_dev, 0xf1, 0x00); */
-        reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
-
-        /* configure gpio */
-        reg0102[0] = sn9c1xx[1];
-        reg0102[1] = sn9c1xx[2];
-        if (gspca_dev->audio)
-                reg0102[1] |= 0x04;     /* keep the audio connection */
-        reg_w(gspca_dev, 0x01, reg0102, 2);
-        reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2);
-        reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 5);
-        switch (sd->sensor) {
-        case SENSOR_GC0307:
-        case SENSOR_OV7660:
-        case SENSOR_PO1030:
-        case SENSOR_PO2030N:
-        case SENSOR_SOI768:
-        case SENSOR_SP80708:
-                reg9a = reg9a_spec;
-                break;
-        default:
-                reg9a = reg9a_def;
-                break;
-        }
-        reg_w(gspca_dev, 0x9a, reg9a, 6);
-
-        reg_w(gspca_dev, 0xd4, regd4, sizeof regd4);
-
-        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_GC0307:
-                msleep(50);
-                reg_w1(gspca_dev, 0x01, 0x61);
-                reg_w1(gspca_dev, 0x17, 0x22);
-                reg_w1(gspca_dev, 0x01, 0x60);
-                reg_w1(gspca_dev, 0x01, 0x40);
-                msleep(50);
-                break;
-        case SENSOR_MT9V111:
-                reg_w1(gspca_dev, 0x01, 0x61);
-                reg_w1(gspca_dev, 0x17, 0x61);
-                reg_w1(gspca_dev, 0x01, 0x60);
-                reg_w1(gspca_dev, 0x01, 0x40);
-                break;
-        case SENSOR_OM6802:
-                msleep(10);
-                reg_w1(gspca_dev, 0x02, 0x73);
-                reg_w1(gspca_dev, 0x17, 0x60);
-                reg_w1(gspca_dev, 0x01, 0x22);
-                msleep(100);
-                reg_w1(gspca_dev, 0x01, 0x62);
-                reg_w1(gspca_dev, 0x17, 0x64);
-                reg_w1(gspca_dev, 0x17, 0x64);
-                reg_w1(gspca_dev, 0x01, 0x42);
-                msleep(10);
-                reg_w1(gspca_dev, 0x01, 0x42);
-                i2c_w8(gspca_dev, om6802_init0[0]);
-                i2c_w8(gspca_dev, om6802_init0[1]);
-                msleep(15);
-                reg_w1(gspca_dev, 0x02, 0x71);
-                msleep(150);
-                break;
-        case SENSOR_OV7630:
-                reg_w1(gspca_dev, 0x01, 0x61);
-                reg_w1(gspca_dev, 0x17, 0xe2);
-                reg_w1(gspca_dev, 0x01, 0x60);
-                reg_w1(gspca_dev, 0x01, 0x40);
-                break;
-        case SENSOR_OV7648:
-                reg_w1(gspca_dev, 0x01, 0x63);
-                reg_w1(gspca_dev, 0x17, 0x20);
-                reg_w1(gspca_dev, 0x01, 0x62);
-                reg_w1(gspca_dev, 0x01, 0x42);
-                break;
-        case SENSOR_PO1030:
-        case SENSOR_SOI768:
-                reg_w1(gspca_dev, 0x01, 0x61);
-                reg_w1(gspca_dev, 0x17, 0x20);
-                reg_w1(gspca_dev, 0x01, 0x60);
-                reg_w1(gspca_dev, 0x01, 0x40);
-                break;
-        case SENSOR_PO2030N:
-        case SENSOR_OV7660:
-                reg_w1(gspca_dev, 0x01, 0x63);
-                reg_w1(gspca_dev, 0x17, 0x20);
-                reg_w1(gspca_dev, 0x01, 0x62);
-                reg_w1(gspca_dev, 0x01, 0x42);
-                break;
-        case SENSOR_SP80708:
-                reg_w1(gspca_dev, 0x01, 0x63);
-                reg_w1(gspca_dev, 0x17, 0x20);
-                reg_w1(gspca_dev, 0x01, 0x62);
-                reg_w1(gspca_dev, 0x01, 0x42);
-                msleep(100);
-                reg_w1(gspca_dev, 0x02, 0x62);
-                break;
-        default:
-/*      case SENSOR_HV7131R: */
-/*      case SENSOR_MI0360: */
-/*      case SENSOR_MO4000: */
-                reg_w1(gspca_dev, 0x01, 0x43);
-                reg_w1(gspca_dev, 0x17, 0x61);
-                reg_w1(gspca_dev, 0x01, 0x42);
-                if (sd->sensor == SENSOR_HV7131R
-                    && sd->bridge == BRIDGE_SN9C102P)
-                        hv7131r_probe(gspca_dev);
-                break;
+                err("Unknown sensor ID %04x", val);
         }
 }
 
@@ -1777,7 +1760,8 @@ static int sd_config(struct gspca_dev *gspca_dev,
         struct cam *cam;
 
         sd->bridge = id->driver_info >> 16;
-        sd->sensor = id->driver_info;
+        sd->sensor = id->driver_info >> 8;
+        sd->flags = id->driver_info;
 
         cam = &gspca_dev->cam;
         if (sd->sensor == SENSOR_ADCM1700) {
@@ -1788,28 +1772,16 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 cam->nmodes = ARRAY_SIZE(vga_mode);
         }
         cam->npkt = 24;                 /* 24 packets per ISOC message */
+        cam->ctrls = sd->ctrls;
 
-        sd->brightness = BRIGHTNESS_DEF;
-        sd->contrast = CONTRAST_DEF;
-        sd->colors = COLOR_DEF;
-        sd->blue = BLUE_BALANCE_DEF;
-        sd->red = RED_BALANCE_DEF;
-        sd->gamma = GAMMA_DEF;
-        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;
-        sd->jpegqual = 80;
+
+        /* if USB 1.1, let some bandwidth for the audio device */
+        if (gspca_dev->audio && gspca_dev->dev->speed < USB_SPEED_HIGH)
+                gspca_dev->nbalt--;
+
+        INIT_WORK(&sd->work, qual_upd);
 
         return 0;
 }
@@ -1819,58 +1791,60 @@ static int sd_init(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         const u8 *sn9c1xx;
-        u8 regGpio[] = { 0x29, 0x74 };          /* with audio */
+        u8 regGpio[] = { 0x29, 0x70 };          /* no audio */
         u8 regF1;
 
         /* setup a selector by bridge */
         reg_w1(gspca_dev, 0xf1, 0x01);
         reg_r(gspca_dev, 0x00, 1);
-        reg_w1(gspca_dev, 0xf1, gspca_dev->usb_buf[0]);
+        reg_w1(gspca_dev, 0xf1, 0x00);
         reg_r(gspca_dev, 0x00, 1);              /* get sonix chip id */
         regF1 = gspca_dev->usb_buf[0];
+        if (gspca_dev->usb_err < 0)
+                return gspca_dev->usb_err;
         PDEBUG(D_PROBE, "Sonix chip id: %02x", regF1);
+        if (gspca_dev->audio)
+                regGpio[1] |= 0x04;             /* with audio */
         switch (sd->bridge) {
         case BRIDGE_SN9C102P:
-                if (regF1 != 0x11)
-                        return -ENODEV;
-                reg_w1(gspca_dev, 0x02, regGpio[1]);
-                break;
         case BRIDGE_SN9C105:
                 if (regF1 != 0x11)
                         return -ENODEV;
-                if (sd->sensor == SENSOR_MI0360)
-                        mi0360_probe(gspca_dev);
-                reg_w(gspca_dev, 0x01, regGpio, 2);
-                break;
-        case BRIDGE_SN9C120:
-                if (regF1 != 0x12)
-                        return -ENODEV;
-                switch (sd->sensor) {
-                case SENSOR_MI0360:
-                        mi0360_probe(gspca_dev);
-                        break;
-                case SENSOR_OV7630:
-                        ov7630_probe(gspca_dev);
-                        break;
-                case SENSOR_OV7648:
-                        ov7648_probe(gspca_dev);
-                        break;
-                case SENSOR_PO2030N:
-                        po2030n_probe(gspca_dev);
-                        break;
-                }
-                regGpio[1] = 0x70;              /* no audio */
-                reg_w(gspca_dev, 0x01, regGpio, 2);
                 break;
         default:
 /*      case BRIDGE_SN9C110: */
-/*      case BRIDGE_SN9C325: */
+/*      case BRIDGE_SN9C120: */
                 if (regF1 != 0x12)
                         return -ENODEV;
-                reg_w1(gspca_dev, 0x02, 0x62);
+        }
+
+        switch (sd->sensor) {
+        case SENSOR_MI0360:
+                mi0360_probe(gspca_dev);
+                break;
+        case SENSOR_OV7630:
+                ov7630_probe(gspca_dev);
+                break;
+        case SENSOR_OV7648:
+                ov7648_probe(gspca_dev);
+                break;
+        case SENSOR_PO2030N:
+                po2030n_probe(gspca_dev);
                 break;
         }
 
+        switch (sd->bridge) {
+        case BRIDGE_SN9C102P:
+                reg_w1(gspca_dev, 0x02, regGpio[1]);
+                break;
+        default:
+                reg_w(gspca_dev, 0x01, regGpio, 2);
+                break;
+        }
+
+        if (sd->sensor == SENSOR_OM6802)
+                sd->ctrls[SHARPNESS].def = 0x10;
+
         /* 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);
@@ -1880,8 +1854,10 @@ static int sd_init(struct gspca_dev *gspca_dev)
         sd->i2c_addr = sn9c1xx[9];
 
         gspca_dev->ctrl_dis = ctrl_dis[sd->sensor];
+        if (!(sd->flags & F_ILLUM))
+                gspca_dev->ctrl_dis |= (1 << ILLUM);
 
-        return 0;
+        return gspca_dev->usb_err;
 }
 
 static u32 setexposure(struct gspca_dev *gspca_dev,
@@ -1912,7 +1888,8 @@ static u32 setexposure(struct gspca_dev *gspca_dev,
                 i2c_w8(gspca_dev, Expodoit);
                 break;
             }
-        case SENSOR_MI0360: {
+        case SENSOR_MI0360:
+        case SENSOR_MI0360B: {
                 u8 expoMi[] =           /* exposure 0x0635 -> 4 fp/s 0x10 */
                         { 0xb1, 0x5d, 0x09, 0x00, 0x00, 0x00, 0x00, 0x16 };
                 static const u8 doit[] =                /* update sensor */
@@ -1959,10 +1936,10 @@ static u32 setexposure(struct gspca_dev *gspca_dev,
                 u8 expo_c1[] =
                         { 0xb1, 0x5c, 0x09, 0x00, 0x00, 0x00, 0x00, 0x10 };
 
-                if (expo > 0x0280)
-                        expo = 0x0280;
-                else if (expo < 0x0040)
-                        expo = 0x0040;
+                if (expo > 0x0390)
+                        expo = 0x0390;
+                else if (expo < 0x0060)
+                        expo = 0x0060;
                 expo_c1[3] = expo >> 8;
                 expo_c1[4] = expo;
                 i2c_w8(gspca_dev, expo_c1);
@@ -1991,16 +1968,18 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         unsigned int expo;
+        int brightness;
         u8 k2;
 
-        k2 = ((int) sd->brightness - 0x8000) >> 10;
+        brightness = sd->ctrls[BRIGHTNESS].val;
+        k2 = (brightness - 0x80) >> 2;
         switch (sd->sensor) {
         case SENSOR_ADCM1700:
                 if (k2 > 0x1f)
                         k2 = 0;         /* only positive Y offset */
                 break;
         case SENSOR_HV7131R:
-                expo = sd->brightness << 4;
+                expo = brightness << 12;
                 if (expo > 0x002dc6c0)
                         expo = 0x002dc6c0;
                 else if (expo < 0x02a0)
@@ -2009,18 +1988,25 @@ static void setbrightness(struct gspca_dev *gspca_dev)
                 break;
         case SENSOR_MI0360:
         case SENSOR_MO4000:
-                expo = sd->brightness >> 4;
+                expo = brightness << 4;
+                sd->exposure = setexposure(gspca_dev, expo);
+                break;
+        case SENSOR_MI0360B:
+                expo = brightness << 2;
                 sd->exposure = setexposure(gspca_dev, expo);
                 break;
         case SENSOR_GC0307:
+                expo = brightness;
+                sd->exposure = setexposure(gspca_dev, expo);
+                return;                 /* don't set the Y offset */
         case SENSOR_MT9V111:
-                expo = sd->brightness >> 8;
+                expo = brightness << 2;
                 sd->exposure = setexposure(gspca_dev, expo);
                 return;                 /* don't set the Y offset */
         case SENSOR_OM6802:
-                expo = sd->brightness >> 6;
+                expo = brightness << 2;
                 sd->exposure = setexposure(gspca_dev, expo);
-                k2 = sd->brightness >> 11;
+                k2 = brightness >> 3;
                 break;
         }
 
@@ -2033,7 +2019,8 @@ static void setcontrast(struct gspca_dev *gspca_dev)
         u8 k2;
         u8 contrast[6];
 
-        k2 = sd->contrast * 0x30 / (CONTRAST_MAX + 1) + 0x10;   /* 10..40 */
+        k2 = sd->ctrls[CONTRAST].val * 0x30 / (CONTRAST_MAX + 1)
+                                + 0x10;         /* 10..40 */
         contrast[0] = (k2 + 1) / 2;             /* red */
         contrast[1] = 0;
         contrast[2] = k2;                       /* green */
@@ -2046,15 +2033,25 @@ static void setcontrast(struct gspca_dev *gspca_dev)
 static void setcolors(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int i, v;
+        int i, v, colors;
+        const s16 *uv;
         u8 reg8a[12];                   /* U & V gains */
-        static const s16 uv[6] = {      /* same as reg84 in signed decimal */
+        static const s16 uv_com[6] = {  /* same as reg84 in signed decimal */
                 -24, -38, 64,           /* UR UG UB */
                  62, -51, -9            /* VR VG VB */
         };
+        static const s16 uv_mi0360b[6] = {
+                -20, -38, 64,           /* UR UG UB */
+                 60, -51, -9            /* VR VG VB */
+        };
 
+        colors = sd->ctrls[COLORS].val;
+        if (sd->sensor == SENSOR_MI0360B)
+                uv = uv_mi0360b;
+        else
+                uv = uv_com;
         for (i = 0; i < 6; i++) {
-                v = uv[i] * sd->colors / COLOR_DEF;
+                v = uv[i] * colors / COLORS_DEF;
                 reg8a[i * 2] = v;
                 reg8a[i * 2 + 1] = (v >> 8) & 0x0f;
         }
@@ -2065,15 +2062,15 @@ static void setredblue(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        reg_w1(gspca_dev, 0x05, sd->red);
+        reg_w1(gspca_dev, 0x05, sd->ctrls[RED].val);
 /*      reg_w1(gspca_dev, 0x07, 32); */
-        reg_w1(gspca_dev, 0x06, sd->blue);
+        reg_w1(gspca_dev, 0x06, sd->ctrls[BLUE].val);
 }
 
 static void setgamma(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int i;
+        int i, val;
         u8 gamma[17];
         const u8 *gamma_base;
         static const u8 delta[17] = {
@@ -2086,6 +2083,7 @@ static void setgamma(struct gspca_dev *gspca_dev)
                 gamma_base = gamma_spec_0;
                 break;
         case SENSOR_HV7131R:
+        case SENSOR_MI0360B:
         case SENSOR_MT9V111:
                 gamma_base = gamma_spec_1;
                 break;
@@ -2100,9 +2098,10 @@ static void setgamma(struct gspca_dev *gspca_dev)
                 break;
         }
 
+        val = sd->ctrls[GAMMA].val;
         for (i = 0; i < sizeof gamma; i++)
                 gamma[i] = gamma_base[i]
-                        + delta[i] * (sd->gamma - GAMMA_DEF) / 32;
+                        + delta[i] * (val - GAMMA_DEF) / 32;
         reg_w(gspca_dev, 0x20, gamma, sizeof gamma);
 }
 
@@ -2110,7 +2109,7 @@ static void setautogain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
+        if (gspca_dev->ctrl_dis & (1 << AUTOGAIN))
                 return;
         switch (sd->sensor) {
         case SENSOR_OV7630:
@@ -2121,74 +2120,100 @@ static void setautogain(struct gspca_dev *gspca_dev)
                         comb = 0xc0;
                 else
                         comb = 0xa0;
-                if (sd->autogain)
+                if (sd->ctrls[AUTOGAIN].val)
                         comb |= 0x03;
                 i2c_w1(&sd->gspca_dev, 0x13, comb);
                 return;
             }
         }
-        if (sd->autogain)
+        if (sd->ctrls[AUTOGAIN].val)
                 sd->ag_cnt = AG_CNT_START;
         else
                 sd->ag_cnt = -1;
 }
 
-/* hv7131r/ov7630/ov7648 only */
-static void setvflip(struct sd *sd)
+static void sethvflip(struct gspca_dev *gspca_dev)
 {
+        struct sd *sd = (struct sd *) gspca_dev;
         u8 comn;
 
-        if (sd->gspca_dev.ctrl_dis & (1 << VFLIP_IDX))
-                return;
         switch (sd->sensor) {
         case SENSOR_HV7131R:
                 comn = 0x18;                    /* clkdiv = 1, ablcen = 1 */
-                if (sd->vflip)
+                if (sd->ctrls[VFLIP].val)
                         comn |= 0x01;
-                i2c_w1(&sd->gspca_dev, 0x01, comn);     /* sctra */
+                i2c_w1(gspca_dev, 0x01, comn);  /* sctra */
                 break;
         case SENSOR_OV7630:
                 comn = 0x02;
-                if (!sd->vflip)
+                if (!sd->ctrls[VFLIP].val)
                         comn |= 0x80;
-                i2c_w1(&sd->gspca_dev, 0x75, comn);
+                i2c_w1(gspca_dev, 0x75, comn);
                 break;
-        default:
-/*      case SENSOR_OV7648: */
+        case SENSOR_OV7648:
                 comn = 0x06;
-                if (sd->vflip)
+                if (sd->ctrls[VFLIP].val)
+                        comn |= 0x80;
+                i2c_w1(gspca_dev, 0x75, comn);
+                break;
+        case SENSOR_PO2030N:
+                /* Reg. 0x1E: Timing Generator Control Register 2 (Tgcontrol2)
+                 * (reset value: 0x0A)
+                 * bit7: HM: Horizontal Mirror: 0: disable, 1: enable
+                 * bit6: VM: Vertical Mirror: 0: disable, 1: enable
+                 * bit5: ST: Shutter Selection: 0: electrical, 1: mechanical
+                 * bit4: FT: Single Frame Transfer: 0: disable, 1: enable
+                 * bit3-0: X
+                 */
+                comn = 0x0a;
+                if (sd->ctrls[HFLIP].val)
                         comn |= 0x80;
-                i2c_w1(&sd->gspca_dev, 0x75, comn);
+                if (sd->ctrls[VFLIP].val)
+                        comn |= 0x40;
+                i2c_w1(&sd->gspca_dev, 0x1e, comn);
                 break;
         }
 }
 
-static void setsharpness(struct sd *sd)
+static void setsharpness(struct gspca_dev *gspca_dev)
 {
-        reg_w1(&sd->gspca_dev, 0x99, sd->sharpness);
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        reg_w1(gspca_dev, 0x99, sd->ctrls[SHARPNESS].val);
 }
 
-static void setinfrared(struct sd *sd)
+static void setillum(struct gspca_dev *gspca_dev)
 {
-        if (sd->gspca_dev.ctrl_dis & (1 << INFRARED_IDX))
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (gspca_dev->ctrl_dis & (1 << ILLUM))
                 return;
-/*fixme: different sequence for StarCam Clip and StarCam 370i */
-/* Clip */
-        i2c_w1(&sd->gspca_dev, 0x02,                    /* gpio */
-                sd->infrared ? 0x66 : 0x64);
+        switch (sd->sensor) {
+        case SENSOR_ADCM1700:
+                reg_w1(gspca_dev, 0x02,                         /* gpio */
+                        sd->ctrls[ILLUM].val ? 0x64 : 0x60);
+                break;
+        case SENSOR_MT9V111:
+                reg_w1(gspca_dev, 0x02,
+                        sd->ctrls[ILLUM].val ? 0x77 : 0x74);
+/* should have been: */
+/*                                              0x55 : 0x54);   * 370i */
+/*                                              0x66 : 0x64);   * Clip */
+                break;
+        }
 }
 
 static void setfreq(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        if (gspca_dev->ctrl_dis & (1 << FREQ_IDX))
+        if (gspca_dev->ctrl_dis & (1 << FREQ))
                 return;
         if (sd->sensor == SENSOR_OV7660) {
                 u8 com8;
 
                 com8 = 0xdf;            /* auto gain/wb/expo */
-                switch (sd->freq) {
+                switch (sd->ctrls[FREQ].val) {
                 case 0: /* Banding filter disabled */
                         i2c_w1(gspca_dev, 0x13, com8 | 0x20);
                         break;
@@ -2216,7 +2241,7 @@ static void setfreq(struct gspca_dev *gspca_dev)
                         break;
                 }
 
-                switch (sd->freq) {
+                switch (sd->ctrls[FREQ].val) {
                 case 0: /* Banding filter disabled */
                         break;
                 case 1: /* 50 hz (filter on and framerate adj) */
@@ -2238,18 +2263,12 @@ static void setfreq(struct gspca_dev *gspca_dev)
 static void setjpegqual(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int i, sc;
 
-        if (sd->jpegqual < 50)
-                sc = 5000 / sd->jpegqual;
-        else
-                sc = 200 - sd->jpegqual * 2;
+        jpeg_set_qual(sd->jpeg_hdr, sd->quality);
 #if USB_BUF_SZ < 64
 #error "No room enough in usb_buf for quantization table"
 #endif
-        for (i = 0; i < 64; i++)
-                gspca_dev->usb_buf[i] =
-                        (jpeg_head[JPEG_QT0_OFFSET + i] * sc + 50) / 100;
+        memcpy(gspca_dev->usb_buf, &sd->jpeg_hdr[JPEG_QT0_OFFSET], 64);
         usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
                         0x08,
@@ -2257,9 +2276,7 @@ static void setjpegqual(struct gspca_dev *gspca_dev)
                         0x0100, 0,
                         gspca_dev->usb_buf, 64,
                         500);
-        for (i = 0; i < 64; i++)
-                gspca_dev->usb_buf[i] =
-                        (jpeg_head[JPEG_QT1_OFFSET + i] * sc + 50) / 100;
+        memcpy(gspca_dev->usb_buf, &sd->jpeg_hdr[JPEG_QT1_OFFSET], 64);
         usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
                         0x08,
@@ -2272,15 +2289,35 @@ static void setjpegqual(struct gspca_dev *gspca_dev)
         reg_w1(gspca_dev, 0x18, sd->reg18);
 }
 
+/* JPEG quality update */
+/* This function is executed from a work queue. */
+static void qual_upd(struct work_struct *work)
+{
+        struct sd *sd = container_of(work, struct sd, work);
+        struct gspca_dev *gspca_dev = &sd->gspca_dev;
+
+        mutex_lock(&gspca_dev->usb_lock);
+        PDEBUG(D_STREAM, "qual_upd %d%%", sd->quality);
+        setjpegqual(gspca_dev);
+        mutex_unlock(&gspca_dev->usb_lock);
+}
+
 /* -- start the camera -- */
 static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int i;
-        u8 reg1, reg17;
+        u8 reg01, reg17;
+        u8 reg0102[2];
         const u8 *sn9c1xx;
         const u8 (*init)[8];
+        const u8 *reg9a;
         int mode;
+        static const u8 reg9a_def[] =
+                {0x00, 0x40, 0x20, 0x00, 0x00, 0x00};
+        static const u8 reg9a_spec[] =
+                {0x00, 0x40, 0x38, 0x30, 0x00, 0x20};
+        static const u8 regd4[] = {0x60, 0x00, 0x00};
         static const u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
         static const u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
         static const u8 CA_adcm1700[] =
@@ -2298,11 +2335,88 @@ static int sd_start(struct gspca_dev *gspca_dev)
         /* create the JPEG header */
         jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
                         0x21);          /* JPEG 422 */
-        jpeg_set_qual(sd->jpeg_hdr, sd->quality);
 
         /* initialize the bridge */
         sn9c1xx = sn_tb[sd->sensor];
-        bridge_init(gspca_dev, sn9c1xx);
+
+        /* sensor clock already enabled in sd_init */
+        /* reg_w1(gspca_dev, 0xf1, 0x00); */
+        reg01 = sn9c1xx[1];
+        if (sd->flags & F_PDN_INV)
+                reg01 ^= S_PDN_INV;             /* power down inverted */
+        reg_w1(gspca_dev, 0x01, reg01);
+
+        /* configure gpio */
+        reg0102[0] = reg01;
+        reg0102[1] = sn9c1xx[2];
+        if (gspca_dev->audio)
+                reg0102[1] |= 0x04;     /* keep the audio connection */
+        reg_w(gspca_dev, 0x01, reg0102, 2);
+        reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2);
+        reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 5);
+        switch (sd->sensor) {
+        case SENSOR_GC0307:
+        case SENSOR_OV7660:
+        case SENSOR_PO1030:
+        case SENSOR_PO2030N:
+        case SENSOR_SOI768:
+        case SENSOR_SP80708:
+                reg9a = reg9a_spec;
+                break;
+        default:
+                reg9a = reg9a_def;
+                break;
+        }
+        reg_w(gspca_dev, 0x9a, reg9a, 6);
+
+        reg_w(gspca_dev, 0xd4, regd4, sizeof regd4);
+
+        reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
+
+        reg17 = sn9c1xx[0x17];
+        switch (sd->sensor) {
+        case SENSOR_GC0307:
+                msleep(50);             /*fixme: is it useful? */
+                break;
+        case SENSOR_OM6802:
+                msleep(10);
+                reg_w1(gspca_dev, 0x02, 0x73);
+                reg17 |= SEN_CLK_EN;
+                reg_w1(gspca_dev, 0x17, reg17);
+                reg_w1(gspca_dev, 0x01, 0x22);
+                msleep(100);
+                reg01 = SCL_SEL_OD | S_PDN_INV;
+                reg17 &= MCK_SIZE_MASK;
+                reg17 |= 0x04;          /* clock / 4 */
+                break;
+        }
+        reg01 |= SYS_SEL_48M;
+        reg_w1(gspca_dev, 0x01, reg01);
+        reg17 |= SEN_CLK_EN;
+        reg_w1(gspca_dev, 0x17, reg17);
+        reg01 &= ~S_PWR_DN;             /* sensor power on */
+        reg_w1(gspca_dev, 0x01, reg01);
+        reg01 &= ~SYS_SEL_48M;
+        reg_w1(gspca_dev, 0x01, reg01);
+
+        switch (sd->sensor) {
+        case SENSOR_HV7131R:
+                hv7131r_probe(gspca_dev);       /*fixme: is it useful? */
+                break;
+        case SENSOR_OM6802:
+                msleep(10);
+                reg_w1(gspca_dev, 0x01, reg01);
+                i2c_w8(gspca_dev, om6802_init0[0]);
+                i2c_w8(gspca_dev, om6802_init0[1]);
+                msleep(15);
+                reg_w1(gspca_dev, 0x02, 0x71);
+                msleep(150);
+                break;
+        case SENSOR_SP80708:
+                msleep(100);
+                reg_w1(gspca_dev, 0x02, 0x62);
+                break;
+        }
 
         /* initialize the sensor */
         i2c_w_seq(gspca_dev, sensor_init[sd->sensor]);
@@ -2330,29 +2444,11 @@ static int sd_start(struct gspca_dev *gspca_dev)
         }
         reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
         switch (sd->sensor) {
-        case SENSOR_GC0307:
-                reg17 = 0xa2;
-                break;
-        case SENSOR_MT9V111:
-                reg17 = 0xe0;
-                break;
-        case SENSOR_ADCM1700:
-        case SENSOR_OV7630:
-                reg17 = 0xe2;
-                break;
-        case SENSOR_OV7648:
-                reg17 = 0x20;
-                break;
-        case SENSOR_OV7660:
-        case SENSOR_SOI768:
-                reg17 = 0xa0;
-                break;
-        case SENSOR_PO1030:
-        case SENSOR_PO2030N:
-                reg17 = 0xa0;
+        case SENSOR_OM6802:
+/*      case SENSOR_OV7648:             * fixme: sometimes */
                 break;
         default:
-                reg17 = 0x60;
+                reg17 |= DEF_EN;
                 break;
         }
         reg_w1(gspca_dev, 0x17, reg17);
@@ -2375,6 +2471,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 break;
         case SENSOR_GC0307:
         case SENSOR_MT9V111:
+        case SENSOR_MI0360B:
                 reg_w1(gspca_dev, 0x9a, 0x07);
                 break;
         case SENSOR_OV7630:
@@ -2389,7 +2486,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 reg_w1(gspca_dev, 0x9a, 0x08);
                 break;
         }
-        setsharpness(sd);
+        setsharpness(gspca_dev);
 
         reg_w(gspca_dev, 0x84, reg84, sizeof reg84);
         reg_w1(gspca_dev, 0x05, 0x20);          /* red */
@@ -2398,91 +2495,67 @@ static int sd_start(struct gspca_dev *gspca_dev)
 
         init = NULL;
         mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
-        if (mode)
-                reg1 = 0x46;    /* 320x240: clk 48Mhz, video trf enable */
-        else
-                reg1 = 0x06;    /* 640x480: clk 24Mhz, video trf enable */
-        reg17 = 0x61;           /* 0x:20: enable sensor clock */
+        reg01 |= SYS_SEL_48M | V_TX_EN;
+        reg17 &= ~MCK_SIZE_MASK;
+        reg17 |= 0x02;                  /* clock / 2 */
         switch (sd->sensor) {
         case SENSOR_ADCM1700:
                 init = adcm1700_sensor_param1;
-                reg1 = 0x46;
-                reg17 = 0xe2;
                 break;
         case SENSOR_GC0307:
                 init = gc0307_sensor_param1;
-                reg17 = 0xa2;
-                reg1 = 0x44;
+                break;
+        case SENSOR_HV7131R:
+        case SENSOR_MI0360:
+                if (mode)
+                        reg01 |= SYS_SEL_48M;   /* 320x240: clk 48Mhz */
+                else
+                        reg01 &= ~SYS_SEL_48M;  /* 640x480: clk 24Mhz */
+                reg17 &= ~MCK_SIZE_MASK;
+                reg17 |= 0x01;                  /* clock / 1 */
+                break;
+        case SENSOR_MI0360B:
+                init = mi0360b_sensor_param1;
                 break;
         case SENSOR_MO4000:
-                if (mode) {
-/*                      reg1 = 0x46;     * 320 clk 48Mhz 60fp/s */
-                        reg1 = 0x06;    /* clk 24Mz */
-                } else {
-                        reg17 = 0x22;   /* 640 MCKSIZE */
-/*                      reg1 = 0x06;     * 640 clk 24Mz (done) */
+                if (mode) {                     /* if 320x240 */
+                        reg01 &= ~SYS_SEL_48M;  /* clk 24Mz */
+                        reg17 &= ~MCK_SIZE_MASK;
+                        reg17 |= 0x01;          /* clock / 1 */
                 }
                 break;
         case SENSOR_MT9V111:
                 init = mt9v111_sensor_param1;
-                if (mode) {
-                        reg1 = 0x04;    /* 320 clk 48Mhz */
-                } else {
-/*                      reg1 = 0x06;     * 640 clk 24Mz (done) */
-                        reg17 = 0xc2;
-                }
                 break;
         case SENSOR_OM6802:
                 init = om6802_sensor_param1;
-                reg17 = 0x64;           /* 640 MCKSIZE */
+                if (!mode) {                    /* if 640x480 */
+                        reg17 &= ~MCK_SIZE_MASK;
+                        reg17 |= 0x04;          /* clock / 4 */
+                }
                 break;
         case SENSOR_OV7630:
                 init = ov7630_sensor_param1;
-                reg17 = 0xe2;
-                reg1 = 0x44;
                 break;
         case SENSOR_OV7648:
                 init = ov7648_sensor_param1;
-                reg17 = 0x21;
-/*              reg1 = 0x42;             * 42 - 46? */
+                reg17 &= ~MCK_SIZE_MASK;
+                reg17 |= 0x01;                  /* clock / 1 */
                 break;
         case SENSOR_OV7660:
                 init = ov7660_sensor_param1;
-                if (sd->bridge == BRIDGE_SN9C120) {
-                        if (mode) {             /* 320x240 - 160x120 */
-                                reg17 = 0xa2;
-                                reg1 = 0x44;    /* 48 Mhz, video trf eneble */
-                        }
-                } else {
-                        reg17 = 0x22;
-                        reg1 = 0x06;    /* 24 Mhz, video trf eneble
-                                         * inverse power down */
-                }
                 break;
         case SENSOR_PO1030:
                 init = po1030_sensor_param1;
-                reg17 = 0xa2;
-                reg1 = 0x44;
                 break;
         case SENSOR_PO2030N:
                 init = po2030n_sensor_param1;
-                reg1 = 0x46;
-                reg17 = 0xa2;
                 break;
         case SENSOR_SOI768:
                 init = soi768_sensor_param1;
-                reg1 = 0x44;
-                reg17 = 0xa2;
                 break;
-        default:
-/*      case SENSOR_SP80708: */
+        case SENSOR_SP80708:
                 init = sp80708_sensor_param1;
-                if (mode) {
-/*??                    reg1 = 0x04;     * 320 clk 48Mhz */
-                } else {
-                        reg1 = 0x46;     /* 640 clk 48Mz */
-                        reg17 = 0xa2;
-                }
                 break;
         }
 
@@ -2526,22 +2599,28 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 break;
         }
 
-
         /* here change size mode 0 -> VGA; 1 -> CIF */
         sd->reg18 = sn9c1xx[0x18] | (mode << 4) | 0x40;
         reg_w1(gspca_dev, 0x18, sd->reg18);
         setjpegqual(gspca_dev);
 
         reg_w1(gspca_dev, 0x17, reg17);
-        reg_w1(gspca_dev, 0x01, reg1);
+        reg_w1(gspca_dev, 0x01, reg01);
+        sd->reg01 = reg01;
+        sd->reg17 = reg17;
 
-        setvflip(sd);
+        sethvflip(gspca_dev);
         setbrightness(gspca_dev);
         setcontrast(gspca_dev);
         setcolors(gspca_dev);
         setautogain(gspca_dev);
         setfreq(gspca_dev);
-        return 0;
+
+        sd->pktsz = sd->npkt = 0;
+        sd->nchg = sd->short_mark = 0;
+        sd->work_thread = create_singlethread_workqueue(MODULE_NAME);
+
+        return gspca_dev->usb_err;
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
@@ -2555,44 +2634,82 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
                 { 0xa1, 0x21, 0x76, 0x20, 0x00, 0x00, 0x00, 0x10 };
         static const u8 stopsoi768[] =
                 { 0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10 };
-        u8 data;
-        const u8 *sn9c1xx;
+        u8 reg01;
+        u8 reg17;
 
-        data = 0x0b;
+        reg01 = sd->reg01;
+        reg17 = sd->reg17 & ~SEN_CLK_EN;
         switch (sd->sensor) {
+        case SENSOR_ADCM1700:
         case SENSOR_GC0307:
-                data = 0x29;
+        case SENSOR_PO2030N:
+        case SENSOR_SP80708:
+                reg01 |= LED;
+                reg_w1(gspca_dev, 0x01, reg01);
+                reg01 &= ~(LED | V_TX_EN);
+                reg_w1(gspca_dev, 0x01, reg01);
+/*              reg_w1(gspca_dev, 0x02, 0x??);   * LED off ? */
                 break;
         case SENSOR_HV7131R:
+                reg01 &= ~V_TX_EN;
+                reg_w1(gspca_dev, 0x01, reg01);
                 i2c_w8(gspca_dev, stophv7131);
-                data = 0x2b;
                 break;
         case SENSOR_MI0360:
+        case SENSOR_MI0360B:
+                reg01 &= ~V_TX_EN;
+                reg_w1(gspca_dev, 0x01, reg01);
+/*              reg_w1(gspca_dev, 0x02, 0x40);    * LED off ? */
                 i2c_w8(gspca_dev, stopmi0360);
-                data = 0x29;
                 break;
-        case SENSOR_OV7648:
-                i2c_w8(gspca_dev, stopov7648);
-                /* fall thru */
         case SENSOR_MT9V111:
-        case SENSOR_OV7630:
+        case SENSOR_OM6802:
         case SENSOR_PO1030:
-                data = 0x29;
+                reg01 &= ~V_TX_EN;
+                reg_w1(gspca_dev, 0x01, reg01);
+                break;
+        case SENSOR_OV7630:
+        case SENSOR_OV7648:
+                reg01 &= ~V_TX_EN;
+                reg_w1(gspca_dev, 0x01, reg01);
+                i2c_w8(gspca_dev, stopov7648);
+                break;
+        case SENSOR_OV7660:
+                reg01 &= ~V_TX_EN;
+                reg_w1(gspca_dev, 0x01, reg01);
                 break;
         case SENSOR_SOI768:
                 i2c_w8(gspca_dev, stopsoi768);
-                data = 0x29;
                 break;
         }
-        sn9c1xx = sn_tb[sd->sensor];
-        reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
-        reg_w1(gspca_dev, 0x17, sn9c1xx[0x17]);
-        reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
-        reg_w1(gspca_dev, 0x01, data);
+
+        reg01 |= SCL_SEL_OD;
+        reg_w1(gspca_dev, 0x01, reg01);
+        reg01 |= S_PWR_DN;              /* sensor power down */
+        reg_w1(gspca_dev, 0x01, reg01);
+        reg_w1(gspca_dev, 0x17, reg17);
+        reg01 &= ~SYS_SEL_48M;          /* clock 24MHz */
+        reg_w1(gspca_dev, 0x01, reg01);
+        reg01 |= LED;
+        reg_w1(gspca_dev, 0x01, reg01);
         /* Don't disable sensor clock as that disables the button on the cam */
         /* reg_w1(gspca_dev, 0xf1, 0x01); */
 }
 
+/* called on streamoff with alt==0 and on disconnect */
+/* the usb_lock is held at entry - restore on exit */
+static void sd_stop0(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (sd->work_thread != NULL) {
+                mutex_unlock(&gspca_dev->usb_lock);
+                destroy_workqueue(sd->work_thread);
+                mutex_lock(&gspca_dev->usb_lock);
+                sd->work_thread = NULL;
+        }
+}
+
 static void do_autogain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -2630,6 +2747,7 @@ static void do_autogain(struct gspca_dev *gspca_dev)
                                         (unsigned int) (expotimes << 8));
                         break;
                 case SENSOR_OM6802:
+                case SENSOR_MT9V111:
                         expotimes = sd->exposure;
                         expotimes += (luma_mean - delta) >> 2;
                         if (expotimes < 0)
@@ -2641,7 +2759,7 @@ static void do_autogain(struct gspca_dev *gspca_dev)
                 default:
 /*              case SENSOR_MO4000: */
 /*              case SENSOR_MI0360: */
-/*              case SENSOR_MT9V111: */
+/*              case SENSOR_MI0360B: */
                         expotimes = sd->exposure;
                         expotimes += (luma_mean - delta) >> 6;
                         if (expotimes < 0)
@@ -2654,261 +2772,171 @@ static void do_autogain(struct gspca_dev *gspca_dev)
         }
 }
 
-/* scan the URB packets */
-/* This function is run at interrupt level. */
-static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                        u8 *data,                       /* isoc packet */
-                        int len)                        /* iso packet length */
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        int sof, avg_lum;
-
-        sof = len - 64;
-        if (sof >= 0 && data[sof] == 0xff && data[sof + 1] == 0xd9) {
-
-                /* end of frame */
-                gspca_frame_add(gspca_dev, LAST_PACKET,
-                                data, sof + 2);
-                if (sd->ag_cnt < 0)
-                        return;
-/* w1 w2 w3 */
-/* w4 w5 w6 */
-/* w7 w8 */
-/* w4 */
-                avg_lum = ((data[sof + 29] << 8) | data[sof + 30]) >> 6;
-/* w6 */
-                avg_lum += ((data[sof + 33] << 8) | data[sof + 34]) >> 6;
-/* w2 */
-                avg_lum += ((data[sof + 25] << 8) | data[sof + 26]) >> 6;
-/* w8 */
-                avg_lum += ((data[sof + 37] << 8) | data[sof + 38]) >> 6;
-/* w5 */
-                avg_lum += ((data[sof + 31] << 8) | data[sof + 32]) >> 4;
-                avg_lum >>= 4;
-                atomic_set(&sd->avg_lum, avg_lum);
-                return;
-        }
-        if (gspca_dev->last_packet_type == LAST_PACKET) {
-
-                /* put the JPEG 422 header */
-                gspca_frame_add(gspca_dev, FIRST_PACKET,
-                        sd->jpeg_hdr, JPEG_HDR_SZ);
-        }
-        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)
+/* set the average luminosity from an isoc marker */
+static void set_lum(struct sd *sd,
+                    u8 *data)
 {
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->colors;
-        return 0;
-}
+        int avg_lum;
 
-static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->blue = val;
-        if (gspca_dev->streaming)
-                setredblue(gspca_dev);
-        return 0;
-}
+        /*      w0 w1 w2
+         *      w3 w4 w5
+         *      w6 w7 w8
+         */
+        avg_lum = (data[27] << 8) + data[28]            /* w3 */
 
-static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
+                + (data[31] << 8) + data[32]            /* w5 */
 
-        *val = sd->blue;
-        return 0;
-}
+                + (data[23] << 8) + data[24]            /* w1 */
 
-static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
+                + (data[35] << 8) + data[36]            /* w7 */
 
-        sd->red = val;
-        if (gspca_dev->streaming)
-                setredblue(gspca_dev);
-        return 0;
-}
-
-static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->red;
-        return 0;
-}
-
-static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->gamma = val;
-        if (gspca_dev->streaming)
-                setgamma(gspca_dev);
-        return 0;
-}
-
-static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->gamma;
-        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)
-                setautogain(gspca_dev);
-        return 0;
-}
-
-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_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;
+                + (data[29] << 10) + (data[30] << 2);   /* w4 * 4 */
+        avg_lum >>= 10;
+        atomic_set(&sd->avg_lum, avg_lum);
 }
 
-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;
-
-        sd->vflip = val;
-        if (gspca_dev->streaming)
-                setvflip(sd);
-        return 0;
-}
-
-static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->vflip;
-        return 0;
-}
-
-static int sd_setinfrared(struct gspca_dev *gspca_dev, __s32 val)
+/* scan the URB packets */
+/* This function is run at interrupt level. */
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data,                       /* isoc packet */
+                        int len)                        /* iso packet length */
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        int i, new_qual;
+
+        /*
+         * A frame ends on the marker
+         *              ff ff 00 c4 c4 96 ..
+         * which is 62 bytes long and is followed by various information
+         * including statuses and luminosity.
+         *
+         * A marker may be splitted on two packets.
+         *
+         * The 6th byte of a marker contains the bits:
+         *      0x08: USB full
+         *      0xc0: frame sequence
+         * When the bit 'USB full' is set, the frame must be discarded;
+         * this is also the case when the 2 bytes before the marker are
+         * not the JPEG end of frame ('ff d9').
+         */
+
+/*fixme: assumption about the following code:
+ *      - there can be only one marker in a packet
+ */
 
-        sd->infrared = val;
-        if (gspca_dev->streaming)
-                setinfrared(sd);
-        return 0;
-}
+        /* skip the remaining bytes of a short marker */
+        i = sd->short_mark;
+        if (i != 0) {
+                sd->short_mark = 0;
+                if (i < 0       /* if 'ff' at end of previous packet */
+                 && data[0] == 0xff
+                 && data[1] == 0x00)
+                        goto marker_found;
+                if (data[0] == 0xff && data[1] == 0xff) {
+                        i = 0;
+                        goto marker_found;
+                }
+                len -= i;
+                if (len <= 0)
+                        return;
+                data += i;
+        }
 
-static int sd_getinfrared(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
+        /* count the packets and their size */
+        sd->npkt++;
+        sd->pktsz += len;
 
-        *val = sd->infrared;
-        return 0;
-}
+        /* search backwards if there is a marker in the packet */
+        for (i = len - 1; --i >= 0; ) {
+                if (data[i] != 0xff) {
+                        i--;
+                        continue;
+                }
+                if (data[i + 1] == 0xff) {
 
-static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
+                        /* (there may be 'ff ff' inside a marker) */
+                        if (i + 2 >= len || data[i + 2] == 0x00)
+                                goto marker_found;
+                }
+        }
 
-        sd->freq = val;
-        if (gspca_dev->streaming)
-                setfreq(gspca_dev);
-        return 0;
-}
+        /* no marker found */
+        /* add the JPEG header if first fragment */
+        if (data[len - 1] == 0xff)
+                sd->short_mark = -1;
+        if (gspca_dev->last_packet_type == LAST_PACKET)
+                gspca_frame_add(gspca_dev, FIRST_PACKET,
+                                sd->jpeg_hdr, JPEG_HDR_SZ);
+        gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
+        return;
+
+        /* marker found */
+        /* if some error, discard the frame and decrease the quality */
+marker_found:
+        new_qual = 0;
+        if (i > 2) {
+                if (data[i - 2] != 0xff || data[i - 1] != 0xd9) {
+                        gspca_dev->last_packet_type = DISCARD_PACKET;
+                        new_qual = -3;
+                }
+        } else if (i + 6 < len) {
+                if (data[i + 6] & 0x08) {
+                        gspca_dev->last_packet_type = DISCARD_PACKET;
+                        new_qual = -5;
+                }
+        }
 
-static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
+        gspca_frame_add(gspca_dev, LAST_PACKET, data, i);
 
-        *val = sd->freq;
-        return 0;
-}
+        /* compute the filling rate and a new JPEG quality */
+        if (new_qual == 0) {
+                int r;
 
-static int sd_set_jcomp(struct gspca_dev *gspca_dev,
-                        struct v4l2_jpegcompression *jcomp)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
+                r = (sd->pktsz * 100) /
+                        (sd->npkt *
+                                gspca_dev->urb[0]->iso_frame_desc[0].length);
+                if (r >= 85)
+                        new_qual = -3;
+                else if (r < 75)
+                        new_qual = 2;
+        }
+        if (new_qual != 0) {
+                sd->nchg += new_qual;
+                if (sd->nchg < -6 || sd->nchg >= 12) {
+                        sd->nchg = 0;
+                        new_qual += sd->quality;
+                        if (new_qual < QUALITY_MIN)
+                                new_qual = QUALITY_MIN;
+                        else if (new_qual > QUALITY_MAX)
+                                new_qual = QUALITY_MAX;
+                        if (new_qual != sd->quality) {
+                                sd->quality = new_qual;
+                                queue_work(sd->work_thread, &sd->work);
+                        }
+                }
+        } else {
+                sd->nchg = 0;
+        }
+        sd->pktsz = sd->npkt = 0;
 
-        if (jcomp->quality < QUALITY_MIN)
-                sd->quality = QUALITY_MIN;
-        else if (jcomp->quality > QUALITY_MAX)
-                sd->quality = QUALITY_MAX;
-        else
-                sd->quality = jcomp->quality;
-        if (gspca_dev->streaming)
-                jpeg_set_qual(sd->jpeg_hdr, sd->quality);
-        return 0;
+        /* if the marker is smaller than 62 bytes,
+         * memorize the number of bytes to skip in the next packet */
+        if (i + 62 > len) {                     /* no more usable data */
+                sd->short_mark = i + 62 - len;
+                return;
+        }
+        if (sd->ag_cnt >= 0)
+                set_lum(sd, data + i);
+
+        /* if more data, start a new frame */
+        i += 62;
+        if (i < len) {
+                data += i;
+                len -= i;
+                gspca_frame_add(gspca_dev, FIRST_PACKET,
+                                sd->jpeg_hdr, JPEG_HDR_SZ);
+                gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
+        }
 }
 
 static int sd_get_jcomp(struct gspca_dev *gspca_dev,
@@ -2944,7 +2972,7 @@ static int sd_querymenu(struct gspca_dev *gspca_dev,
         return -EINVAL;
 }
 
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrupt packet length */
@@ -2967,17 +2995,17 @@ static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
 static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
         .ctrls = sd_ctrls,
-        .nctrls = ARRAY_SIZE(sd_ctrls),
+        .nctrls = NCTRLS,
         .config = sd_config,
         .init = sd_init,
         .start = sd_start,
         .stopN = sd_stopN,
+        .stop0 = sd_stop0,
         .pkt_scan = sd_pkt_scan,
         .dq_callback = do_autogain,
         .get_jcomp = sd_get_jcomp,
-        .set_jcomp = sd_set_jcomp,
         .querymenu = sd_querymenu,
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
@@ -2985,14 +3013,16 @@ static const struct sd_desc sd_desc = {
 /* -- module initialisation -- */
 #define BS(bridge, sensor) \
         .driver_info = (BRIDGE_ ## bridge << 16) \
-                        | SENSOR_ ## sensor
-static const __devinitdata struct usb_device_id device_table[] = {
-#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
+                        | (SENSOR_ ## sensor << 8)
+#define BSF(bridge, sensor, flags) \
+        .driver_info = (BRIDGE_ ## bridge << 16) \
+                        | (SENSOR_ ## sensor << 8) \
+                        | (flags)
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0458, 0x7025), BS(SN9C120, MI0360)},
         {USB_DEVICE(0x0458, 0x702e), BS(SN9C120, OV7660)},
-#endif
-        {USB_DEVICE(0x045e, 0x00f5), BS(SN9C105, OV7660)},
-        {USB_DEVICE(0x045e, 0x00f7), BS(SN9C105, OV7660)},
+        {USB_DEVICE(0x045e, 0x00f5), BSF(SN9C105, OV7660, F_PDN_INV)},
+        {USB_DEVICE(0x045e, 0x00f7), BSF(SN9C105, OV7660, F_PDN_INV)},
         {USB_DEVICE(0x0471, 0x0327), BS(SN9C105, MI0360)},
         {USB_DEVICE(0x0471, 0x0328), BS(SN9C105, MI0360)},
         {USB_DEVICE(0x0471, 0x0330), BS(SN9C105, MI0360)},
@@ -3004,7 +3034,8 @@ static const __devinitdata struct usb_device_id device_table[] = {
 /*      {USB_DEVICE(0x0c45, 0x607b), BS(SN9C102P, OV7660)}, */
         {USB_DEVICE(0x0c45, 0x607c), BS(SN9C102P, HV7131R)},
 /*      {USB_DEVICE(0x0c45, 0x607e), BS(SN9C102P, OV7630)}, */
-        {USB_DEVICE(0x0c45, 0x60c0), BS(SN9C105, MI0360)},
+        {USB_DEVICE(0x0c45, 0x60c0), BSF(SN9C105, MI0360, F_ILLUM)},
+                                                /* or MT9V111 */
 /*      {USB_DEVICE(0x0c45, 0x60c2), BS(SN9C105, P1030xC)}, */
 /*      {USB_DEVICE(0x0c45, 0x60c8), BS(SN9C105, OM6802)}, */
 /*      {USB_DEVICE(0x0c45, 0x60cc), BS(SN9C105, HV7131GP)}, */
@@ -3014,12 +3045,10 @@ static const __devinitdata struct usb_device_id device_table[] = {
 /*      {USB_DEVICE(0x0c45, 0x60fa), BS(SN9C105, OV7648)}, */
 /*      {USB_DEVICE(0x0c45, 0x60f2), BS(SN9C105, OV7660)}, */
         {USB_DEVICE(0x0c45, 0x60fb), BS(SN9C105, OV7660)},
-#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
         {USB_DEVICE(0x0c45, 0x60fc), BS(SN9C105, HV7131R)},
         {USB_DEVICE(0x0c45, 0x60fe), BS(SN9C105, OV7630)},
-#endif
         {USB_DEVICE(0x0c45, 0x6100), BS(SN9C120, MI0360)},      /*sn9c128*/
-/*      {USB_DEVICE(0x0c45, 0x6102), BS(SN9C120, PO2030N)}, * / GC0305*/
+        {USB_DEVICE(0x0c45, 0x6102), BS(SN9C120, PO2030N)},     /* /GC0305*/
 /*      {USB_DEVICE(0x0c45, 0x6108), BS(SN9C120, OM6802)}, */
         {USB_DEVICE(0x0c45, 0x610a), BS(SN9C120, OV7648)},      /*sn9c128*/
         {USB_DEVICE(0x0c45, 0x610b), BS(SN9C120, OV7660)},      /*sn9c128*/
@@ -3031,25 +3060,24 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0c45, 0x6128), BS(SN9C120, OM6802)},      /*sn9c325?*/
 /*bw600.inf:*/
         {USB_DEVICE(0x0c45, 0x612a), BS(SN9C120, OV7648)},      /*sn9c325?*/
+        {USB_DEVICE(0x0c45, 0x612b), BS(SN9C110, ADCM1700)},
         {USB_DEVICE(0x0c45, 0x612c), BS(SN9C110, MO4000)},
         {USB_DEVICE(0x0c45, 0x612e), BS(SN9C110, OV7630)},
 /*      {USB_DEVICE(0x0c45, 0x612f), BS(SN9C110, ICM105C)}, */
-#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
         {USB_DEVICE(0x0c45, 0x6130), BS(SN9C120, MI0360)},
-#endif
+                                                /* or MT9V111 / MI0360B */
 /*      {USB_DEVICE(0x0c45, 0x6132), BS(SN9C120, OV7670)}, */
         {USB_DEVICE(0x0c45, 0x6138), BS(SN9C120, MO4000)},
         {USB_DEVICE(0x0c45, 0x613a), BS(SN9C120, OV7648)},
-#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
         {USB_DEVICE(0x0c45, 0x613b), BS(SN9C120, OV7660)},
-#endif
         {USB_DEVICE(0x0c45, 0x613c), BS(SN9C120, HV7131R)},
         {USB_DEVICE(0x0c45, 0x613e), BS(SN9C120, OV7630)},
         {USB_DEVICE(0x0c45, 0x6142), BS(SN9C120, PO2030N)},     /*sn9c120b*/
                                                 /* or GC0305 / GC0307 */
         {USB_DEVICE(0x0c45, 0x6143), BS(SN9C120, SP80708)},     /*sn9c120b*/
         {USB_DEVICE(0x0c45, 0x6148), BS(SN9C120, OM6802)},      /*sn9c120b*/
-        {USB_DEVICE(0x0c45, 0x614a), BS(SN9C120, ADCM1700)},    /*sn9c120b*/
+        {USB_DEVICE(0x0c45, 0x614a), BSF(SN9C120, ADCM1700, F_ILLUM)},
+/*      {USB_DEVICE(0x0c45, 0x614c), BS(SN9C120, GC0306)}, */   /*sn9c120b*/
         {}
 };
 MODULE_DEVICE_TABLE(usb, device_table);
@@ -3076,17 +3104,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        info("deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/spca1528.c b/drivers/media/video/gspca/spca1528.c
index 3f514eb1d99d..76c006b2bc83 100644
--- a/drivers/media/video/gspca/spca1528.c
+++ b/drivers/media/video/gspca/spca1528.c
@@ -171,7 +171,7 @@ static void reg_r(struct gspca_dev *gspca_dev,
         PDEBUG(D_USBI, "GET %02x 0000 %04x %02x", req, index,
                          gspca_dev->usb_buf[0]);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_r err %d", ret);
+                err("reg_r err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -193,7 +193,7 @@ static void reg_w(struct gspca_dev *gspca_dev,
                         value, index,
                         NULL, 0, 500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w err %d", ret);
+                err("reg_w err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -217,7 +217,7 @@ static void reg_wb(struct gspca_dev *gspca_dev,
                         value, index,
                         gspca_dev->usb_buf, 1, 500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w err %d", ret);
+                err("reg_w err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -555,7 +555,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x04fc, 0x1528)},
         {}
 };
@@ -587,18 +587,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        info("deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/spca500.c b/drivers/media/video/gspca/spca500.c
index c02beb6c1e93..3e76951e3c19 100644
--- a/drivers/media/video/gspca/spca500.c
+++ b/drivers/media/video/gspca/spca500.c
@@ -396,7 +396,7 @@ static int reg_w(struct gspca_dev *gspca_dev,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         value, index, NULL, 0, 500);
         if (ret < 0)
-                PDEBUG(D_ERR, "reg write: error %d", ret);
+                err("reg write: error %d", ret);
         return ret;
 }
 
@@ -418,8 +418,8 @@ static int reg_r_12(struct gspca_dev *gspca_dev,
                         gspca_dev->usb_buf, length,
                         500);           /* timeout */
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_r_12 err %d", ret);
-                return -1;
+                err("reg_r_12 err %d", ret);
+                return ret;
         }
         return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
 }
@@ -607,7 +607,7 @@ static void spca500_reinit(struct gspca_dev *gspca_dev)
         reg_w(gspca_dev, 0x00, 0x8880, 2);
         /* family cam Quicksmart stuff */
         reg_w(gspca_dev, 0x00, 0x800a, 0x00);
-        /* Set agc transfer: synced inbetween frames */
+        /* Set agc transfer: synced between frames */
         reg_w(gspca_dev, 0x00, 0x820f, 0x01);
         /* Init SDRAM - needed for SDRAM access */
         reg_w(gspca_dev, 0x00, 0x870a, 0x04);
@@ -831,7 +831,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
 
                 /* familycam Quicksmart pocketDV stuff */
                 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
-                /* Set agc transfer: synced inbetween frames */
+                /* Set agc transfer: synced between frames */
                 reg_w(gspca_dev, 0x00, 0x820f, 0x01);
                 /* Init SDRAM - needed for SDRAM access */
                 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
@@ -1051,7 +1051,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x040a, 0x0300), .driver_info = KodakEZ200},
         {USB_DEVICE(0x041e, 0x400a), .driver_info = CreativePCCam300},
         {USB_DEVICE(0x046d, 0x0890), .driver_info = LogitechTraveler},
@@ -1093,17 +1093,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/spca501.c b/drivers/media/video/gspca/spca501.c
index c99333933e32..f7ef282cc600 100644
--- a/drivers/media/video/gspca/spca501.c
+++ b/drivers/media/video/gspca/spca501.c
@@ -1724,7 +1724,7 @@ static const __u16 spca501c_mysterious_init_data[][3] = {
         {0x00, 0x0000, 0x0048},
         {0x00, 0x0000, 0x0049},
         {0x00, 0x0008, 0x004a},
-/* DSP Registers         */
+/* DSP Registers        */
         {0x01, 0x00a6, 0x0000},
         {0x01, 0x0028, 0x0001},
         {0x01, 0x0000, 0x0002},
@@ -1788,7 +1788,7 @@ static const __u16 spca501c_mysterious_init_data[][3] = {
         {0x05, 0x0022, 0x0004},
         {0x05, 0x0025, 0x0001},
         {0x05, 0x0000, 0x0000},
-/* Part 4             */
+/* Part 4 */
         {0x05, 0x0026, 0x0001},
         {0x05, 0x0001, 0x0000},
         {0x05, 0x0027, 0x0001},
@@ -1806,7 +1806,7 @@ static const __u16 spca501c_mysterious_init_data[][3] = {
         {0x05, 0x0001, 0x0000},
         {0x05, 0x0027, 0x0001},
         {0x05, 0x004e, 0x0000},
-/* Part 5                */
+/* Part 5 */
         {0x01, 0x0003, 0x003f},
         {0x01, 0x0001, 0x0056},
         {0x01, 0x000f, 0x0008},
@@ -1852,7 +1852,7 @@ static int reg_write(struct usb_device *dev,
         PDEBUG(D_USBO, "reg write: 0x%02x 0x%02x 0x%02x",
                 req, index, value);
         if (ret < 0)
-                PDEBUG(D_ERR, "reg write: error %d", ret);
+                err("reg write: error %d", ret);
         return ret;
 }
 
@@ -2155,7 +2155,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x040a, 0x0002), .driver_info = KodakDVC325},
         {USB_DEVICE(0x0497, 0xc001), .driver_info = SmileIntlCamera},
         {USB_DEVICE(0x0506, 0x00df), .driver_info = ThreeComHomeConnectLite},
@@ -2189,17 +2189,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/spca505.c b/drivers/media/video/gspca/spca505.c
index c576eed73abe..e5bf865147d7 100644
--- a/drivers/media/video/gspca/spca505.c
+++ b/drivers/media/video/gspca/spca505.c
@@ -368,10 +368,6 @@ static const u8 spca505b_init_data[][3] = {
         {0x08, 0x00, 0x00},
         {0x08, 0x00, 0x01},
         {0x08, 0x00, 0x02},
-        {0x00, 0x01, 0x00},
-        {0x00, 0x01, 0x01},
-        {0x00, 0x01, 0x34},
-        {0x00, 0x01, 0x35},
         {0x06, 0x18, 0x08},
         {0x06, 0xfc, 0x09},
         {0x06, 0xfc, 0x0a},
@@ -582,7 +578,7 @@ static int reg_write(struct usb_device *dev,
         PDEBUG(D_USBO, "reg write: 0x%02x,0x%02x:0x%02x, %d",
                 req, index, value, ret);
         if (ret < 0)
-                PDEBUG(D_ERR, "reg write: error %d", ret);
+                err("reg write: error %d", ret);
         return ret;
 }
 
@@ -689,8 +685,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 return ret;
         }
         if (ret != 0x0101) {
-                PDEBUG(D_ERR|D_CONF,
-                        "After vector read returns 0x%04x should be 0x0101",
+                err("After vector read returns 0x%04x should be 0x0101",
                         ret);
         }
 
@@ -791,7 +786,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x401d), .driver_info = Nxultra},
         {USB_DEVICE(0x0733, 0x0430), .driver_info = IntelPCCameraPro},
 /*fixme: may be UsbGrabberPV321 BRIDGE_SPCA506 SENSOR_SAA7113 */
@@ -821,18 +816,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/spca508.c b/drivers/media/video/gspca/spca508.c
index edf0fe157501..9d0b46027b93 100644
--- a/drivers/media/video/gspca/spca508.c
+++ b/drivers/media/video/gspca/spca508.c
@@ -92,8 +92,7 @@ static const struct v4l2_pix_format sif_mode[] = {
  * Initialization data: this is the first set-up data written to the
  * device (before the open data).
  */
-static const u16 spca508_init_data[][2] =
-{
+static const u16 spca508_init_data[][2] = {
         {0x0000, 0x870b},
 
         {0x0020, 0x8112},       /* Video drop enable, ISO streaming disable */
@@ -593,7 +592,7 @@ static const u16 spca508_sightcam_init_data[][2] = {
 /* This line seems to setup the frame/canvas */
         {0x000f, 0x8402},
 
-/* Theese 6 lines are needed to startup the webcam */
+/* These 6 lines are needed to startup the webcam */
         {0x0090, 0x8110},
         {0x0001, 0x8114},
         {0x0001, 0x8114},
@@ -1276,7 +1275,7 @@ static int reg_write(struct usb_device *dev,
         PDEBUG(D_USBO, "reg write i:0x%04x = 0x%02x",
                 index, value);
         if (ret < 0)
-                PDEBUG(D_ERR|D_USBO, "reg write: error %d", ret);
+                err("reg write: error %d", ret);
         return ret;
 }
 
@@ -1298,7 +1297,7 @@ static int reg_read(struct gspca_dev *gspca_dev,
         PDEBUG(D_USBI, "reg read i:%04x --> %02x",
                 index, gspca_dev->usb_buf[0]);
         if (ret < 0) {
-                PDEBUG(D_ERR|D_USBI, "reg_read err %d", ret);
+                err("reg_read err %d", ret);
                 return ret;
         }
         return gspca_dev->usb_buf[0];
@@ -1376,7 +1375,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct cam *cam;
-        int data1, data2;
         const u16 (*init_data)[2];
         static const u16 (*(init_data_tb[]))[2] = {
                 spca508_vista_init_data,        /* CreativeVista 0 */
@@ -1387,6 +1385,9 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 spca508_init_data,              /* ViewQuestVQ110 5 */
         };
 
+#ifdef GSPCA_DEBUG
+        int data1, data2;
+
         /* Read from global register the USB product and vendor IDs, just to
          * prove that we can communicate with the device.  This works, which
          * confirms at we are communicating properly and that the device
@@ -1401,6 +1402,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         data1 = reg_read(gspca_dev, 0x8621);
         PDEBUG(D_PROBE, "Window 1 average luminance: %d", data1);
+#endif
 
         cam = &gspca_dev->cam;
         cam->cam_mode = sif_mode;
@@ -1510,7 +1512,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0130, 0x0130), .driver_info = HamaUSBSightcam},
         {USB_DEVICE(0x041e, 0x4018), .driver_info = CreativeVista},
         {USB_DEVICE(0x0733, 0x0110), .driver_info = ViewQuestVQ110},
@@ -1543,18 +1545,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/spca561.c b/drivers/media/video/gspca/spca561.c
index 7bb2355005dc..e836e778dfb6 100644
--- a/drivers/media/video/gspca/spca561.c
+++ b/drivers/media/video/gspca/spca561.c
@@ -315,7 +315,7 @@ static void reg_w_val(struct usb_device *dev, __u16 index, __u8 value)
                               value, index, NULL, 0, 500);
         PDEBUG(D_USBO, "reg write: 0x%02x:0x%02x", index, value);
         if (ret < 0)
-                PDEBUG(D_ERR, "reg write: error %d", ret);
+                err("reg write: error %d", ret);
 }
 
 static void write_vector(struct gspca_dev *gspca_dev,
@@ -597,7 +597,7 @@ static void setgain(struct gspca_dev *gspca_dev)
         else if (sd->gain < 128)
                 gspca_dev->usb_buf[0] = (sd->gain / 2) | 0x40;
         else
-                gspca_dev->usb_buf[0] = (sd->gain / 4) | 0xC0;
+                gspca_dev->usb_buf[0] = (sd->gain / 4) | 0xc0;
 
         gspca_dev->usb_buf[1] = 0;
         reg_w_buf(gspca_dev, 0x8335, 2);
@@ -787,7 +787,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                         return;
                 }
 
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
                 if (data[0] & 0x20) {
                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
                         input_sync(gspca_dev->input_dev);
@@ -1037,7 +1037,7 @@ static const struct sd_desc sd_desc_12a = {
         .start = sd_start_12a,
         .stopN = sd_stopN,
         .pkt_scan = sd_pkt_scan,
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .other_input = 1,
 #endif
 };
@@ -1051,7 +1051,7 @@ static const struct sd_desc sd_desc_72a = {
         .stopN = sd_stopN,
         .pkt_scan = sd_pkt_scan,
         .dq_callback = do_autogain,
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .other_input = 1,
 #endif
 };
@@ -1061,7 +1061,7 @@ static const struct sd_desc *sd_desc[2] = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x401a), .driver_info = Rev072A},
         {USB_DEVICE(0x041e, 0x403b), .driver_info = Rev012A},
         {USB_DEVICE(0x0458, 0x7004), .driver_info = Rev072A},
@@ -1107,17 +1107,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/sq905.c b/drivers/media/video/gspca/sq905.c
index 09b3f93fa4d6..5ba96aff2252 100644
--- a/drivers/media/video/gspca/sq905.c
+++ b/drivers/media/video/gspca/sq905.c
@@ -22,7 +22,7 @@
  * History and Acknowledgments
  *
  * The original Linux driver for SQ905 based cameras was written by
- * Marcell Lengyel and furter developed by many other contributers
+ * Marcell Lengyel and furter developed by many other contributors
  * and is available from http://sourceforge.net/projects/sqcam/
  *
  * This driver takes advantage of the reverse engineering work done for
@@ -123,7 +123,7 @@ static int sq905_command(struct gspca_dev *gspca_dev, u16 index)
                               SQ905_COMMAND, index, gspca_dev->usb_buf, 1,
                               SQ905_CMD_TIMEOUT);
         if (ret < 0) {
-                PDEBUG(D_ERR, "%s: usb_control_msg failed (%d)",
+                err("%s: usb_control_msg failed (%d)",
                         __func__, ret);
                 return ret;
         }
@@ -135,7 +135,7 @@ static int sq905_command(struct gspca_dev *gspca_dev, u16 index)
                               SQ905_PING, 0, gspca_dev->usb_buf, 1,
                               SQ905_CMD_TIMEOUT);
         if (ret < 0) {
-                PDEBUG(D_ERR, "%s: usb_control_msg failed 2 (%d)",
+                err("%s: usb_control_msg failed 2 (%d)",
                         __func__, ret);
                 return ret;
         }
@@ -158,7 +158,7 @@ static int sq905_ack_frame(struct gspca_dev *gspca_dev)
                               SQ905_READ_DONE, 0, gspca_dev->usb_buf, 1,
                               SQ905_CMD_TIMEOUT);
         if (ret < 0) {
-                PDEBUG(D_ERR, "%s: usb_control_msg failed (%d)", __func__, ret);
+                err("%s: usb_control_msg failed (%d)", __func__, ret);
                 return ret;
         }
 
@@ -186,7 +186,7 @@ sq905_read_data(struct gspca_dev *gspca_dev, u8 *data, int size, int need_lock)
         if (need_lock)
                 mutex_unlock(&gspca_dev->usb_lock);
         if (ret < 0) {
-                PDEBUG(D_ERR, "%s: usb_control_msg failed (%d)", __func__, ret);
+                err("%s: usb_control_msg failed (%d)", __func__, ret);
                 return ret;
         }
         ret = usb_bulk_msg(gspca_dev->dev,
@@ -195,7 +195,7 @@ sq905_read_data(struct gspca_dev *gspca_dev, u8 *data, int size, int need_lock)
 
         /* successful, it returns 0, otherwise  negative */
         if (ret < 0 || act_len != size) {
-                PDEBUG(D_ERR, "bulk read fail (%d) len %d/%d",
+                err("bulk read fail (%d) len %d/%d",
                         ret, act_len, size);
                 return -EIO;
         }
@@ -226,7 +226,7 @@ static void sq905_dostream(struct work_struct *work)
 
         buffer = kmalloc(SQ905_MAX_TRANSFER, GFP_KERNEL | GFP_DMA);
         if (!buffer) {
-                PDEBUG(D_ERR, "Couldn't allocate USB buffer");
+                err("Couldn't allocate USB buffer");
                 goto quit_stream;
         }
 
@@ -396,7 +396,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
 }
 
 /* Table of supported USB devices */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x2770, 0x9120)},
         {}
 };
@@ -436,19 +436,12 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/sq905c.c b/drivers/media/video/gspca/sq905c.c
index 4c70628ca615..457563b7a71b 100644
--- a/drivers/media/video/gspca/sq905c.c
+++ b/drivers/media/video/gspca/sq905c.c
@@ -95,7 +95,7 @@ static int sq905c_command(struct gspca_dev *gspca_dev, u16 command, u16 index)
                               command, index, NULL, 0,
                               SQ905C_CMD_TIMEOUT);
         if (ret < 0) {
-                PDEBUG(D_ERR, "%s: usb_control_msg failed (%d)",
+                err("%s: usb_control_msg failed (%d)",
                         __func__, ret);
                 return ret;
         }
@@ -115,7 +115,7 @@ static int sq905c_read(struct gspca_dev *gspca_dev, u16 command, u16 index,
                               command, index, gspca_dev->usb_buf, size,
                               SQ905C_CMD_TIMEOUT);
         if (ret < 0) {
-                PDEBUG(D_ERR, "%s: usb_control_msg failed (%d)",
+                err("%s: usb_control_msg failed (%d)",
                        __func__, ret);
                 return ret;
         }
@@ -146,7 +146,7 @@ static void sq905c_dostream(struct work_struct *work)
 
         buffer = kmalloc(SQ905C_MAX_TRANSFER, GFP_KERNEL | GFP_DMA);
         if (!buffer) {
-                PDEBUG(D_ERR, "Couldn't allocate USB buffer");
+                err("Couldn't allocate USB buffer");
                 goto quit_stream;
         }
 
@@ -298,9 +298,10 @@ static int sd_start(struct gspca_dev *gspca_dev)
 }
 
 /* Table of supported USB devices */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x2770, 0x905c)},
         {USB_DEVICE(0x2770, 0x9050)},
+        {USB_DEVICE(0x2770, 0x9051)},
         {USB_DEVICE(0x2770, 0x9052)},
         {USB_DEVICE(0x2770, 0x913d)},
         {}
@@ -341,19 +342,12 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/sq930x.c b/drivers/media/video/gspca/sq930x.c
index 7ae6522d4edf..8215d5dcd456 100644
--- a/drivers/media/video/gspca/sq930x.c
+++ b/drivers/media/video/gspca/sq930x.c
@@ -468,7 +468,7 @@ static void reg_r(struct gspca_dev *gspca_dev,
                         value, 0, gspca_dev->usb_buf, len,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_r %04x failed %d", value, ret);
+                err("reg_r %04x failed %d", value, ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -488,7 +488,7 @@ static void reg_w(struct gspca_dev *gspca_dev, u16 value, u16 index)
                         500);
         msleep(30);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w %04x %04x failed %d", value, index, ret);
+                err("reg_w %04x %04x failed %d", value, index, ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -511,7 +511,7 @@ static void reg_wb(struct gspca_dev *gspca_dev, u16 value, u16 index,
                         1000);
         msleep(30);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_wb %04x %04x failed %d", value, index, ret);
+                err("reg_wb %04x %04x failed %d", value, index, ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -556,7 +556,7 @@ static void i2c_write(struct sd *sd,
                         gspca_dev->usb_buf, buf - gspca_dev->usb_buf,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "i2c_write failed %d", ret);
+                err("i2c_write failed %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -612,7 +612,7 @@ static void ucbus_write(struct gspca_dev *gspca_dev,
                                 gspca_dev->usb_buf, buf - gspca_dev->usb_buf,
                                 500);
                 if (ret < 0) {
-                        PDEBUG(D_ERR, "ucbus_write failed %d", ret);
+                        err("ucbus_write failed %d", ret);
                         gspca_dev->usb_err = ret;
                         return;
                 }
@@ -687,10 +687,19 @@ static void cmos_probe(struct gspca_dev *gspca_dev)
                 if (gspca_dev->usb_buf[0] != 0)
                         break;
         }
-        if (i >= ARRAY_SIZE(probe_order))
-                PDEBUG(D_PROBE, "Unknown sensor");
-        else
-                sd->sensor = probe_order[i];
+        if (i >= ARRAY_SIZE(probe_order)) {
+                err("Unknown sensor");
+                gspca_dev->usb_err = -EINVAL;
+                return;
+        }
+        sd->sensor = probe_order[i];
+        switch (sd->sensor) {
+        case SENSOR_OV7660:
+        case SENSOR_OV9630:
+                err("Sensor %s not yet treated", sensor_tb[sd->sensor].name);
+                gspca_dev->usb_err = -EINVAL;
+                break;
+        }
 }
 
 static void mt9v111_init(struct gspca_dev *gspca_dev)
@@ -867,6 +876,9 @@ static int sd_init(struct gspca_dev *gspca_dev)
  */
 
         reg_r(gspca_dev, SQ930_CTRL_GET_DEV_INFO, 8);
+        if (gspca_dev->usb_err < 0)
+                return gspca_dev->usb_err;
+
 /* it returns:
  * 03 00 12 93 0b f6 c9 00      live! ultra
  * 03 00 07 93 0b f6 ca 00      live! ultra for notebook
@@ -900,15 +912,15 @@ static int sd_init(struct gspca_dev *gspca_dev)
         if (sd->sensor == SENSOR_MI0360) {
 
                 /* no sensor probe for icam tracer */
-                if (gspca_dev->usb_buf[5] == 0xf6)      /* if CMOS */
+                if (gspca_dev->usb_buf[5] == 0xf6)      /* if ccd */
                         sd->sensor = SENSOR_ICX098BQ;
                 else
                         cmos_probe(gspca_dev);
         }
-
-        PDEBUG(D_PROBE, "Sensor %s", sensor_tb[sd->sensor].name);
-
-        global_init(sd, 1);
+        if (gspca_dev->usb_err >= 0) {
+                PDEBUG(D_PROBE, "Sensor %s", sensor_tb[sd->sensor].name);
+                global_init(sd, 1);
+        }
         return gspca_dev->usb_err;
 }
 
@@ -1079,7 +1091,7 @@ static void sd_dq_callback(struct gspca_dev *gspca_dev)
         gspca_dev->cam.bulk_nurbs = 1;
         ret = usb_submit_urb(gspca_dev->urb[0], GFP_ATOMIC);
         if (ret < 0)
-                PDEBUG(D_ERR|D_PACK, "sd_dq_callback() err %d", ret);
+                err("sd_dq_callback() err %d", ret);
 
         /* wait a little time, otherwise the webcam crashes */
         msleep(100);
@@ -1151,7 +1163,7 @@ static const struct sd_desc sd_desc = {
 #define ST(sensor, type) \
         .driver_info = (SENSOR_ ## sensor << 8) \
                         | (type)
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x4038), ST(MI0360, 0)},
         {USB_DEVICE(0x041e, 0x403c), ST(LZ24BP, 0)},
         {USB_DEVICE(0x041e, 0x403d), ST(LZ24BP, 0)},
@@ -1185,18 +1197,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        info("deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/stk014.c b/drivers/media/video/gspca/stk014.c
index 2aedf4b1bfa3..763747700f10 100644
--- a/drivers/media/video/gspca/stk014.c
+++ b/drivers/media/video/gspca/stk014.c
@@ -27,14 +27,21 @@ MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
 MODULE_DESCRIPTION("Syntek DV4000 (STK014) USB Camera Driver");
 MODULE_LICENSE("GPL");
 
+/* controls */
+enum e_ctrl {
+        BRIGHTNESS,
+        CONTRAST,
+        COLORS,
+        LIGHTFREQ,
+        NCTRLS          /* number of controls */
+};
+
 /* specific webcam descriptor */
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
 
-        unsigned char brightness;
-        unsigned char contrast;
-        unsigned char colors;
-        unsigned char lightfreq;
+        struct gspca_ctrl ctrls[NCTRLS];
+
         u8 quality;
 #define QUALITY_MIN 70
 #define QUALITY_MAX 95
@@ -44,17 +51,13 @@ 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_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[] = {
-        {
+static void setbrightness(struct gspca_dev *gspca_dev);
+static void setcontrast(struct gspca_dev *gspca_dev);
+static void setcolors(struct gspca_dev *gspca_dev);
+static void setlightfreq(struct gspca_dev *gspca_dev);
+
+static const struct ctrl sd_ctrls[NCTRLS] = {
+[BRIGHTNESS] = {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -62,13 +65,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define BRIGHTNESS_DEF 127
-                .default_value = BRIGHTNESS_DEF,
+                .default_value = 127,
             },
-            .set = sd_setbrightness,
-            .get = sd_getbrightness,
+            .set_control = setbrightness
         },
-        {
+[CONTRAST] = {
             {
                 .id      = V4L2_CID_CONTRAST,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -76,13 +77,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define CONTRAST_DEF 127
-                .default_value = CONTRAST_DEF,
+                .default_value = 127,
             },
-            .set = sd_setcontrast,
-            .get = sd_getcontrast,
+            .set_control = setcontrast
         },
-        {
+[COLORS] = {
             {
                 .id      = V4L2_CID_SATURATION,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -90,13 +89,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define COLOR_DEF 127
-                .default_value = COLOR_DEF,
+                .default_value = 127,
             },
-            .set = sd_setcolors,
-            .get = sd_getcolors,
+            .set_control = setcolors
         },
-        {
+[LIGHTFREQ] = {
             {
                 .id      = V4L2_CID_POWER_LINE_FREQUENCY,
                 .type    = V4L2_CTRL_TYPE_MENU,
@@ -104,11 +101,9 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 1,
                 .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
                 .step    = 1,
-#define FREQ_DEF 1
-                .default_value = FREQ_DEF,
+                .default_value = 1,
             },
-            .set = sd_setfreq,
-            .get = sd_getfreq,
+            .set_control = setlightfreq
         },
 };
 
@@ -142,7 +137,7 @@ static u8 reg_r(struct gspca_dev *gspca_dev,
                         gspca_dev->usb_buf, 1,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_r err %d", ret);
+                err("reg_r err %d", ret);
                 gspca_dev->usb_err = ret;
                 return 0;
         }
@@ -167,7 +162,7 @@ static void reg_w(struct gspca_dev *gspca_dev,
                         0,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w err %d", ret);
+                err("reg_w err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -197,7 +192,7 @@ static void rcv_val(struct gspca_dev *gspca_dev,
                         &alen,
                         500);           /* timeout in milliseconds */
         if (ret < 0) {
-                PDEBUG(D_ERR, "rcv_val err %d", ret);
+                err("rcv_val err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -240,7 +235,7 @@ static void snd_val(struct gspca_dev *gspca_dev,
                         &alen,
                         500);   /* timeout in milliseconds */
         if (ret < 0) {
-                PDEBUG(D_ERR, "snd_val err %d", ret);
+                err("snd_val err %d", ret);
                 gspca_dev->usb_err = ret;
         } else {
                 if (ads == 0x003f08) {
@@ -264,7 +259,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
         int parval;
 
         parval = 0x06000000             /* whiteness */
-                + (sd->brightness << 16);
+                + (sd->ctrls[BRIGHTNESS].val << 16);
         set_par(gspca_dev, parval);
 }
 
@@ -274,7 +269,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
         int parval;
 
         parval = 0x07000000             /* contrast */
-                + (sd->contrast << 16);
+                + (sd->ctrls[CONTRAST].val << 16);
         set_par(gspca_dev, parval);
 }
 
@@ -284,15 +279,15 @@ static void setcolors(struct gspca_dev *gspca_dev)
         int parval;
 
         parval = 0x08000000             /* saturation */
-                + (sd->colors << 16);
+                + (sd->ctrls[COLORS].val << 16);
         set_par(gspca_dev, parval);
 }
 
-static void setfreq(struct gspca_dev *gspca_dev)
+static void setlightfreq(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        set_par(gspca_dev, sd->lightfreq == 1
+        set_par(gspca_dev, sd->ctrls[LIGHTFREQ].val == 1
                         ? 0x33640000            /* 50 Hz */
                         : 0x33780000);          /* 60 Hz */
 }
@@ -305,10 +300,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         gspca_dev->cam.cam_mode = vga_mode;
         gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
-        sd->brightness = BRIGHTNESS_DEF;
-        sd->contrast = CONTRAST_DEF;
-        sd->colors = COLOR_DEF;
-        sd->lightfreq = FREQ_DEF;
+        gspca_dev->cam.ctrls = sd->ctrls;
         sd->quality = QUALITY_DEF;
         return 0;
 }
@@ -323,7 +315,7 @@ static int sd_init(struct gspca_dev *gspca_dev)
         ret = reg_r(gspca_dev, 0x0740);
         if (gspca_dev->usb_err >= 0) {
                 if (ret != 0xff) {
-                        PDEBUG(D_ERR|D_STREAM, "init reg: 0x%02x", ret);
+                        err("init reg: 0x%02x", ret);
                         gspca_dev->usb_err = -EIO;
                 }
         }
@@ -357,7 +349,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                                         gspca_dev->iface,
                                         gspca_dev->alt);
         if (ret < 0) {
-                PDEBUG(D_ERR|D_STREAM, "set intf %d %d failed",
+                err("set intf %d %d failed",
                         gspca_dev->iface, gspca_dev->alt);
                 gspca_dev->usb_err = ret;
                 goto out;
@@ -378,7 +370,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
         set_par(gspca_dev, 0x0a800000);         /* Green ? */
         set_par(gspca_dev, 0x0b800000);         /* Blue ? */
         set_par(gspca_dev, 0x0d030000);         /* Gamma ? */
-        setfreq(gspca_dev);                     /* light frequency */
+        setlightfreq(gspca_dev);
 
         /* start the video flow */
         set_par(gspca_dev, 0x01000000);
@@ -441,92 +433,17 @@ 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 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_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 gspca_dev->usb_err;
-}
-
-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_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 gspca_dev->usb_err;
-}
-
-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_querymenu(struct gspca_dev *gspca_dev,
                         struct v4l2_querymenu *menu)
 {
+        static const char *freq_nm[3] = {"NoFliker", "50 Hz", "60 Hz"};
+
         switch (menu->id) {
         case V4L2_CID_POWER_LINE_FREQUENCY:
-                switch (menu->index) {
-                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;
+                if ((unsigned) menu->index >= ARRAY_SIZE(freq_nm))
+                        break;
+                strcpy((char *) menu->name, freq_nm[menu->index]);
+                return 0;
         }
         return -EINVAL;
 }
@@ -563,7 +480,7 @@ static int sd_get_jcomp(struct gspca_dev *gspca_dev,
 static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
         .ctrls = sd_ctrls,
-        .nctrls = ARRAY_SIZE(sd_ctrls),
+        .nctrls = NCTRLS,
         .config = sd_config,
         .init = sd_init,
         .start = sd_start,
@@ -575,7 +492,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x05e1, 0x0893)},
         {}
 };
@@ -603,17 +520,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        info("deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/stv0680.c b/drivers/media/video/gspca/stv0680.c
index e50dd7693f74..e2ef41cf72d7 100644
--- a/drivers/media/video/gspca/stv0680.c
+++ b/drivers/media/video/gspca/stv0680.c
@@ -1,7 +1,7 @@
 /*
  * STV0680 USB Camera Driver
  *
- * Copyright (C) 2009 Hans de Goede <hdgoede@redhat.com>
+ * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com>
  *
  * This module is adapted from the in kernel v4l1 stv680 driver:
  *
@@ -31,7 +31,7 @@
 
 #include "gspca.h"
 
-MODULE_AUTHOR("Hans de Goede <hdgoede@redhat.com>");
+MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
 MODULE_DESCRIPTION("STV0680 USB Camera Driver");
 MODULE_LICENSE("GPL");
 
@@ -79,8 +79,7 @@ static int stv_sndctrl(struct gspca_dev *gspca_dev, int set, u8 req, u16 val,
                               val, 0, gspca_dev->usb_buf, size, 500);
 
         if ((ret < 0) && (req != 0x0a))
-                PDEBUG(D_ERR,
-                       "usb_control_msg error %i, request = 0x%x, error = %i",
+                err("usb_control_msg error %i, request = 0x%x, error = %i",
                        set, req, ret);
 
         return ret;
@@ -237,7 +236,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         if (stv_sndctrl(gspca_dev, 2, 0x06, 0x0100, 0x12) != 0x12 ||
             gspca_dev->usb_buf[8] != 0x53 || gspca_dev->usb_buf[9] != 0x05) {
-                PDEBUG(D_ERR, "Could not get descriptor 0100.");
+                err("Could not get descriptor 0100.");
                 return stv0680_handle_error(gspca_dev, -EIO);
         }
 
@@ -328,7 +327,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0553, 0x0202)},
         {USB_DEVICE(0x041e, 0x4007)},
         {}
@@ -357,17 +356,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx.c b/drivers/media/video/gspca/stv06xx/stv06xx.c
index 14f179a19485..abf1658fa33e 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx.c
@@ -189,7 +189,7 @@ int stv06xx_read_sensor(struct sd *sd, const u8 address, u16 *value)
                               0x04, 0x40, 0x1400, 0, buf, I2C_BUFFER_LENGTH,
                               STV06XX_URB_MSG_TIMEOUT);
         if (err < 0) {
-                PDEBUG(D_ERR, "I2C: Read error writing address: %d", err);
+                err("I2C: Read error writing address: %d", err);
                 return err;
         }
 
@@ -263,7 +263,21 @@ static int stv06xx_init(struct gspca_dev *gspca_dev)
 static int stv06xx_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int err;
+        struct usb_host_interface *alt;
+        struct usb_interface *intf;
+        int err, packet_size;
+
+        intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
+        alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
+        if (!alt) {
+                PDEBUG(D_ERR, "Couldn't get altsetting");
+                return -EIO;
+        }
+
+        packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
+        err = stv06xx_write_bridge(sd, STV_ISO_SIZE_L, packet_size);
+        if (err < 0)
+                return err;
 
         /* Prepare the sensor for start */
         err = sd->sensor->start(sd);
@@ -282,6 +296,43 @@ out:
         return (err < 0) ? err : 0;
 }
 
+static int stv06xx_isoc_init(struct gspca_dev *gspca_dev)
+{
+        struct usb_host_interface *alt;
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        /* Start isoc bandwidth "negotiation" at max isoc bandwidth */
+        alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
+        alt->endpoint[0].desc.wMaxPacketSize =
+                cpu_to_le16(sd->sensor->max_packet_size[gspca_dev->curr_mode]);
+
+        return 0;
+}
+
+static int stv06xx_isoc_nego(struct gspca_dev *gspca_dev)
+{
+        int ret, packet_size, min_packet_size;
+        struct usb_host_interface *alt;
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
+        packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
+        min_packet_size = sd->sensor->min_packet_size[gspca_dev->curr_mode];
+        if (packet_size <= min_packet_size)
+                return -EIO;
+
+        packet_size -= 100;
+        if (packet_size < min_packet_size)
+                packet_size = min_packet_size;
+        alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(packet_size);
+
+        ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
+        if (ret < 0)
+                PDEBUG(D_ERR|D_STREAM, "set alt 1 err %d", ret);
+
+        return ret;
+}
+
 static void stv06xx_stopN(struct gspca_dev *gspca_dev)
 {
         int err;
@@ -349,7 +400,7 @@ static void stv06xx_pkt_scan(struct gspca_dev *gspca_dev,
                 }
 
                 /* First byte seem to be 02=data 2nd byte is unknown??? */
-                if (sd->bridge == BRIDGE_ST6422 && (id & 0xFF00) == 0x0200)
+                if (sd->bridge == BRIDGE_ST6422 && (id & 0xff00) == 0x0200)
                         goto frame_data;
 
                 switch (id) {
@@ -428,7 +479,7 @@ frame_data:
         }
 }
 
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrupt packet length */
@@ -462,7 +513,9 @@ static const struct sd_desc sd_desc = {
         .start = stv06xx_start,
         .stopN = stv06xx_stopN,
         .pkt_scan = stv06xx_pkt_scan,
-#ifdef CONFIG_INPUT
+        .isoc_init = stv06xx_isoc_init,
+        .isoc_nego = stv06xx_isoc_nego,
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
@@ -472,11 +525,9 @@ static int stv06xx_config(struct gspca_dev *gspca_dev,
                           const struct usb_device_id *id)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        struct cam *cam;
 
         PDEBUG(D_PROBE, "Configuring camera");
 
-        cam = &gspca_dev->cam;
         sd->desc = sd_desc;
         sd->bridge = id->driver_info;
         gspca_dev->sd_desc = &sd->desc;
@@ -511,7 +562,7 @@ static int stv06xx_config(struct gspca_dev *gspca_dev,
 
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         /* QuickCam Express */
         {USB_DEVICE(0x046d, 0x0840), .driver_info = BRIDGE_STV600 },
         /* LEGO cam / QuickCam Web */
@@ -562,17 +613,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx.h b/drivers/media/video/gspca/stv06xx/stv06xx.h
index 053a27e3a400..e0f63c51f40d 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx.h
+++ b/drivers/media/video/gspca/stv06xx/stv06xx.h
@@ -37,7 +37,7 @@
 
 #define STV_ISOC_ENDPOINT_ADDR          0x81
 
-#define STV_REG23                       0x0423
+#define STV_REG23                       0x0423
 
 /* Control registers of the STV0600 ASIC */
 #define STV_I2C_PARTNER                 0x1420
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c b/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c
index 706e08dc5254..b8156855f2b7 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c
@@ -39,8 +39,8 @@ static const struct ctrl hdcs1x00_ctrl[] = {
                         .minimum        = 0x00,
                         .maximum        = 0xff,
                         .step           = 0x1,
-                        .default_value  = HDCS_DEFAULT_EXPOSURE,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .default_value  = HDCS_DEFAULT_EXPOSURE,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = hdcs_set_exposure,
                 .get = hdcs_get_exposure
@@ -52,8 +52,8 @@ static const struct ctrl hdcs1x00_ctrl[] = {
                         .minimum        = 0x00,
                         .maximum        = 0xff,
                         .step           = 0x1,
-                        .default_value  = HDCS_DEFAULT_GAIN,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .default_value  = HDCS_DEFAULT_GAIN,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = hdcs_set_gain,
                 .get = hdcs_get_gain
@@ -83,8 +83,8 @@ static const struct ctrl hdcs1020_ctrl[] = {
                         .minimum        = 0x00,
                         .maximum        = 0xffff,
                         .step           = 0x1,
-                        .default_value  = HDCS_DEFAULT_EXPOSURE,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .default_value  = HDCS_DEFAULT_EXPOSURE,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = hdcs_set_exposure,
                 .get = hdcs_get_exposure
@@ -96,8 +96,8 @@ static const struct ctrl hdcs1020_ctrl[] = {
                         .minimum        = 0x00,
                         .maximum        = 0xff,
                         .step           = 0x1,
-                        .default_value  = HDCS_DEFAULT_GAIN,
-                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                        .default_value  = HDCS_DEFAULT_GAIN,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
                 },
                 .set = hdcs_set_gain,
                 .get = hdcs_get_gain
@@ -163,7 +163,8 @@ static int hdcs_reg_write_seq(struct sd *sd, u8 reg, u8 *vals, u8 len)
         for (i = 0; i < len; i++) {
                 regs[2 * i] = reg;
                 regs[2 * i + 1] = vals[i];
-                /* All addresses are shifted left one bit as bit 0 toggles r/w */
+                /* All addresses are shifted left one bit
+                 * as bit 0 toggles r/w */
                 reg += 2;
         }
 
@@ -568,7 +569,7 @@ static int hdcs_init(struct sd *sd)
         if (err < 0)
                 return err;
 
-        /* Enable continous frame capture, bit 2: stop when frame complete */
+        /* Enable continuous frame capture, bit 2: stop when frame complete */
         err = stv06xx_write_sensor(sd, HDCS_REG_CONFIG(sd), BIT(3));
         if (err < 0)
                 return err;
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.h b/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.h
index 37b31c99d956..a14a84a5079b 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.h
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.h
@@ -37,7 +37,7 @@
 #define HDCS_REG_CONTROL(sd)    (IS_1020(sd) ? HDCS20_CONTROL : HDCS00_CONTROL)
 
 #define HDCS_1X00_DEF_WIDTH     360
-#define HDCS_1X00_DEF_HEIGHT    296
+#define HDCS_1X00_DEF_HEIGHT    296
 
 #define HDCS_1020_DEF_WIDTH     352
 #define HDCS_1020_DEF_HEIGHT    292
@@ -125,7 +125,7 @@
 #define HDCS_SLEEP_MODE         (1 << 1)
 
 #define HDCS_DEFAULT_EXPOSURE   48
-#define HDCS_DEFAULT_GAIN       128
+#define HDCS_DEFAULT_GAIN       50
 
 static int hdcs_probe_1x00(struct sd *sd);
 static int hdcs_probe_1020(struct sd *sd);
@@ -146,6 +146,11 @@ const struct stv06xx_sensor stv06xx_sensor_hdcs1x00 = {
         .i2c_addr = (0x55 << 1),
         .i2c_len = 1,
 
+        /* FIXME (see if we can lower min_packet_size, needs testing, and also
+           adjusting framerate when the bandwidth gets lower) */
+        .min_packet_size = { 847 },
+        .max_packet_size = { 847 },
+
         .init = hdcs_init,
         .probe = hdcs_probe_1x00,
         .start = hdcs_start,
@@ -160,6 +165,11 @@ const struct stv06xx_sensor stv06xx_sensor_hdcs1020 = {
         .i2c_addr = (0x55 << 1),
         .i2c_len = 1,
 
+        /* FIXME (see if we can lower min_packet_size, needs testing, and also
+           adjusting framerate when the bandwidthm gets lower) */
+        .min_packet_size = { 847 },
+        .max_packet_size = { 847 },
+
         .init = hdcs_init,
         .probe = hdcs_probe_1020,
         .start = hdcs_start,
@@ -177,7 +187,6 @@ static const u16 stv_bridge_init[][2] = {
         {STV_REG04, 0x07},
 
         {STV_SCAN_RATE, 0x20},
-        {STV_ISO_SIZE_L, 847},
         {STV_Y_CTRL, 0x01},
         {STV_X_CTRL, 0x0a}
 };
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_pb0100.c b/drivers/media/video/gspca/stv06xx/stv06xx_pb0100.c
index 285221e6b390..75a5b9c2f15f 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_pb0100.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_pb0100.c
@@ -208,11 +208,26 @@ static int pb0100_probe(struct sd *sd)
 
 static int pb0100_start(struct sd *sd)
 {
-        int err;
+        int err, packet_size, max_packet_size;
+        struct usb_host_interface *alt;
+        struct usb_interface *intf;
         struct cam *cam = &sd->gspca_dev.cam;
         s32 *sensor_settings = sd->sensor_priv;
         u32 mode = cam->cam_mode[sd->gspca_dev.curr_mode].priv;
 
+        intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
+        alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
+        if (!alt)
+                return -ENODEV;
+        packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
+
+        /* If we don't have enough bandwidth use a lower framerate */
+        max_packet_size = sd->sensor->max_packet_size[sd->gspca_dev.curr_mode];
+        if (packet_size < max_packet_size)
+                stv06xx_write_sensor(sd, PB_ROWSPEED, BIT(4)|BIT(3)|BIT(1));
+        else
+                stv06xx_write_sensor(sd, PB_ROWSPEED, BIT(5)|BIT(3)|BIT(1));
+
         /* Setup sensor window */
         if (mode & PB0100_CROP_TO_VGA) {
                 stv06xx_write_sensor(sd, PB_RSTART, 30);
@@ -328,9 +343,6 @@ static int pb0100_init(struct sd *sd)
         stv06xx_write_bridge(sd, STV_REG03, 0x45);
         stv06xx_write_bridge(sd, STV_REG04, 0x07);
 
-        /* ISO-Size (0x27b: 635... why? - HDCS uses 847) */
-        stv06xx_write_bridge(sd, STV_ISO_SIZE_L, 847);
-
         /* Scan/timing for the sensor */
         stv06xx_write_sensor(sd, PB_ROWSPEED, BIT(4)|BIT(3)|BIT(1));
         stv06xx_write_sensor(sd, PB_CFILLIN, 14);
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_pb0100.h b/drivers/media/video/gspca/stv06xx/stv06xx_pb0100.h
index 4de4fa5ebc57..757de246dc75 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_pb0100.h
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_pb0100.h
@@ -138,6 +138,9 @@ const struct stv06xx_sensor stv06xx_sensor_pb0100 = {
         .i2c_addr = 0xba,
         .i2c_len = 2,
 
+        .min_packet_size = { 635, 847 },
+        .max_packet_size = { 847, 923 },
+
         .init = pb0100_init,
         .probe = pb0100_probe,
         .start = pb0100_start,
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_sensor.h b/drivers/media/video/gspca/stv06xx/stv06xx_sensor.h
index 934b9cebc1ab..fb229d8ded58 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_sensor.h
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_sensor.h
@@ -53,6 +53,10 @@ struct stv06xx_sensor {
         /* length of an i2c word */
         u8 i2c_len;
 
+        /* Isoc packet size (per mode) */
+        int min_packet_size[4];
+        int max_packet_size[4];
+
         /* Probes if the sensor is connected */
         int (*probe)(struct sd *sd);
 
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c b/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c
index c11f06e4ae76..8a456de4970a 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c
@@ -28,6 +28,20 @@
 
 #include "stv06xx_st6422.h"
 
+/* controls */
+enum e_ctrl {
+        BRIGHTNESS,
+        CONTRAST,
+        GAIN,
+        EXPOSURE,
+        NCTRLS          /* number of controls */
+};
+
+/* sensor settings */
+struct st6422_settings {
+        struct gspca_ctrl ctrls[NCTRLS];
+};
+
 static struct v4l2_pix_format st6422_mode[] = {
         /* Note we actually get 124 lines of data, of which we skip the 4st
            4 as they are garbage */
@@ -57,9 +71,14 @@ static struct v4l2_pix_format st6422_mode[] = {
         },
 };
 
-static const struct ctrl st6422_ctrl[] = {
-#define BRIGHTNESS_IDX 0
-        {
+/* V4L2 controls supported by the driver */
+static void st6422_set_brightness(struct gspca_dev *gspca_dev);
+static void st6422_set_contrast(struct gspca_dev *gspca_dev);
+static void st6422_set_gain(struct gspca_dev *gspca_dev);
+static void st6422_set_exposure(struct gspca_dev *gspca_dev);
+
+static const struct ctrl st6422_ctrl[NCTRLS] = {
+[BRIGHTNESS] = {
                 {
                         .id             = V4L2_CID_BRIGHTNESS,
                         .type           = V4L2_CTRL_TYPE_INTEGER,
@@ -69,11 +88,9 @@ static const struct ctrl st6422_ctrl[] = {
                         .step           = 1,
                         .default_value  = 3
                 },
-                .set = st6422_set_brightness,
-                .get = st6422_get_brightness
+                .set_control = st6422_set_brightness
         },
-#define CONTRAST_IDX 1
-        {
+[CONTRAST] = {
                 {
                         .id             = V4L2_CID_CONTRAST,
                         .type           = V4L2_CTRL_TYPE_INTEGER,
@@ -83,11 +100,9 @@ static const struct ctrl st6422_ctrl[] = {
                         .step           = 1,
                         .default_value  = 11
                 },
-                .set = st6422_set_contrast,
-                .get = st6422_get_contrast
+                .set_control = st6422_set_contrast
         },
-#define GAIN_IDX 2
-        {
+[GAIN] = {
                 {
                         .id             = V4L2_CID_GAIN,
                         .type           = V4L2_CTRL_TYPE_INTEGER,
@@ -97,49 +112,43 @@ static const struct ctrl st6422_ctrl[] = {
                         .step           = 1,
                         .default_value  = 64
                 },
-                .set = st6422_set_gain,
-                .get = st6422_get_gain
+                .set_control = st6422_set_gain
         },
-#define EXPOSURE_IDX 3
-        {
+[EXPOSURE] = {
                 {
                         .id             = V4L2_CID_EXPOSURE,
                         .type           = V4L2_CTRL_TYPE_INTEGER,
                         .name           = "Exposure",
                         .minimum        = 0,
-                        .maximum        = 1023,
+#define EXPOSURE_MAX 1023
+                        .maximum        = EXPOSURE_MAX,
                         .step           = 1,
                         .default_value  = 256
                 },
-                .set = st6422_set_exposure,
-                .get = st6422_get_exposure
+                .set_control = st6422_set_exposure
         },
 };
 
 static int st6422_probe(struct sd *sd)
 {
-        int i;
-        s32 *sensor_settings;
+        struct st6422_settings *sensor_settings;
 
         if (sd->bridge != BRIDGE_ST6422)
                 return -ENODEV;
 
         info("st6422 sensor detected");
 
-        sensor_settings = kmalloc(ARRAY_SIZE(st6422_ctrl) * sizeof(s32),
-                                  GFP_KERNEL);
+        sensor_settings = kmalloc(sizeof *sensor_settings, GFP_KERNEL);
         if (!sensor_settings)
                 return -ENOMEM;
 
         sd->gspca_dev.cam.cam_mode = st6422_mode;
         sd->gspca_dev.cam.nmodes = ARRAY_SIZE(st6422_mode);
+        sd->gspca_dev.cam.ctrls = sensor_settings->ctrls;
         sd->desc.ctrls = st6422_ctrl;
         sd->desc.nctrls = ARRAY_SIZE(st6422_ctrl);
         sd->sensor_priv = sensor_settings;
 
-        for (i = 0; i < sd->desc.nctrls; i++)
-                sensor_settings[i] = st6422_ctrl[i].qctrl.default_value;
-
         return 0;
 }
 
@@ -151,11 +160,11 @@ static int st6422_init(struct sd *sd)
                 { STV_ISO_ENABLE, 0x00 }, /* disable capture */
                 { 0x1436, 0x00 },
                 { 0x1432, 0x03 },       /* 0x00-0x1F brightness */
-                { 0x143a, 0xF9 },       /* 0x00-0x0F contrast */
+                { 0x143a, 0xf9 },       /* 0x00-0x0F contrast */
                 { 0x0509, 0x38 },       /* R */
                 { 0x050a, 0x38 },       /* G */
                 { 0x050b, 0x38 },       /* B */
-                { 0x050c, 0x2A },
+                { 0x050c, 0x2a },
                 { 0x050d, 0x01 },
 
 
@@ -213,7 +222,6 @@ static int st6422_init(struct sd *sd)
                 { 0x150e, 0x8e },
                 { 0x150f, 0x37 },
                 { 0x15c0, 0x00 },
-                { 0x15c1, 1023 }, /* 160x120, ISOC_PACKET_SIZE */
                 { 0x15c3, 0x08 },       /* 0x04/0x14 ... test pictures ??? */
 
 
@@ -235,91 +243,92 @@ static void st6422_disconnect(struct sd *sd)
         kfree(sd->sensor_priv);
 }
 
-static int st6422_start(struct sd *sd)
+static int setbrightness(struct sd *sd)
 {
-        int err, packet_size;
-        struct cam *cam = &sd->gspca_dev.cam;
-        s32 *sensor_settings = sd->sensor_priv;
-        struct usb_host_interface *alt;
-        struct usb_interface *intf;
-
-        intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
-        alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
-        if (!alt) {
-                PDEBUG(D_ERR, "Couldn't get altsetting");
-                return -EIO;
-        }
+        struct st6422_settings *sensor_settings = sd->sensor_priv;
 
-        packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
-        err = stv06xx_write_bridge(sd, 0x15c1, packet_size);
-        if (err < 0)
-                return err;
+        /* val goes from 0 -> 31 */
+        return stv06xx_write_bridge(sd, 0x1432,
+                        sensor_settings->ctrls[BRIGHTNESS].val);
+}
 
-        if (cam->cam_mode[sd->gspca_dev.curr_mode].priv)
-                err = stv06xx_write_bridge(sd, 0x1505, 0x0f);
-        else
-                err = stv06xx_write_bridge(sd, 0x1505, 0x02);
-        if (err < 0)
-                return err;
+static int setcontrast(struct sd *sd)
+{
+        struct st6422_settings *sensor_settings = sd->sensor_priv;
+
+        /* Val goes from 0 -> 15 */
+        return stv06xx_write_bridge(sd, 0x143a,
+                        sensor_settings->ctrls[CONTRAST].val | 0xf0);
+}
+
+static int setgain(struct sd *sd)
+{
+        struct st6422_settings *sensor_settings = sd->sensor_priv;
+        u8 gain;
+        int err;
+
+        gain = sensor_settings->ctrls[GAIN].val;
 
-        err = st6422_set_brightness(&sd->gspca_dev,
-                                    sensor_settings[BRIGHTNESS_IDX]);
+        /* Set red, green, blue, gain */
+        err = stv06xx_write_bridge(sd, 0x0509, gain);
         if (err < 0)
                 return err;
 
-        err = st6422_set_contrast(&sd->gspca_dev,
-                                  sensor_settings[CONTRAST_IDX]);
+        err = stv06xx_write_bridge(sd, 0x050a, gain);
         if (err < 0)
                 return err;
 
-        err = st6422_set_exposure(&sd->gspca_dev,
-                                  sensor_settings[EXPOSURE_IDX]);
+        err = stv06xx_write_bridge(sd, 0x050b, gain);
         if (err < 0)
                 return err;
 
-        err = st6422_set_gain(&sd->gspca_dev,
-                              sensor_settings[GAIN_IDX]);
+        /* 2 mystery writes */
+        err = stv06xx_write_bridge(sd, 0x050c, 0x2a);
         if (err < 0)
                 return err;
 
-        PDEBUG(D_STREAM, "Starting stream");
-
-        return 0;
+        return stv06xx_write_bridge(sd, 0x050d, 0x01);
 }
 
-static int st6422_stop(struct sd *sd)
+static int setexposure(struct sd *sd)
 {
-        PDEBUG(D_STREAM, "Halting stream");
-
-        return 0;
-}
-
-static int st6422_get_brightness(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        s32 *sensor_settings = sd->sensor_priv;
-
-        *val = sensor_settings[BRIGHTNESS_IDX];
+        struct st6422_settings *sensor_settings = sd->sensor_priv;
+        u16 expo;
+        int err;
 
-        PDEBUG(D_V4L2, "Read brightness %d", *val);
+        expo = sensor_settings->ctrls[EXPOSURE].val;
+        err = stv06xx_write_bridge(sd, 0x143d, expo & 0xff);
+        if (err < 0)
+                return err;
 
-        return 0;
+        return stv06xx_write_bridge(sd, 0x143e, expo >> 8);
 }
 
-static int st6422_set_brightness(struct gspca_dev *gspca_dev, __s32 val)
+static int st6422_start(struct sd *sd)
 {
         int err;
-        struct sd *sd = (struct sd *) gspca_dev;
-        s32 *sensor_settings = sd->sensor_priv;
+        struct cam *cam = &sd->gspca_dev.cam;
 
-        sensor_settings[BRIGHTNESS_IDX] = val;
+        if (cam->cam_mode[sd->gspca_dev.curr_mode].priv)
+                err = stv06xx_write_bridge(sd, 0x1505, 0x0f);
+        else
+                err = stv06xx_write_bridge(sd, 0x1505, 0x02);
+        if (err < 0)
+                return err;
 
-        if (!gspca_dev->streaming)
-                return 0;
+        err = setbrightness(sd);
+        if (err < 0)
+                return err;
 
-        /* val goes from 0 -> 31 */
-        PDEBUG(D_V4L2, "Set brightness to %d", val);
-        err = stv06xx_write_bridge(sd, 0x1432, val);
+        err = setcontrast(sd);
+        if (err < 0)
+                return err;
+
+        err = setexposure(sd);
+        if (err < 0)
+                return err;
+
+        err = setgain(sd);
         if (err < 0)
                 return err;
 
@@ -328,125 +337,65 @@ static int st6422_set_brightness(struct gspca_dev *gspca_dev, __s32 val)
         return (err < 0) ? err : 0;
 }
 
-static int st6422_get_contrast(struct gspca_dev *gspca_dev, __s32 *val)
+static int st6422_stop(struct sd *sd)
 {
-        struct sd *sd = (struct sd *) gspca_dev;
-        s32 *sensor_settings = sd->sensor_priv;
-
-        *val = sensor_settings[CONTRAST_IDX];
-
-        PDEBUG(D_V4L2, "Read contrast %d", *val);
+        PDEBUG(D_STREAM, "Halting stream");
 
         return 0;
 }
 
-static int st6422_set_contrast(struct gspca_dev *gspca_dev, __s32 val)
+static void st6422_set_brightness(struct gspca_dev *gspca_dev)
 {
         int err;
         struct sd *sd = (struct sd *) gspca_dev;
-        s32 *sensor_settings = sd->sensor_priv;
-
-        sensor_settings[CONTRAST_IDX] = val;
 
-        if (!gspca_dev->streaming)
-                return 0;
-
-        /* Val goes from 0 -> 15 */
-        PDEBUG(D_V4L2, "Set contrast to %d\n", val);
-        err = stv06xx_write_bridge(sd, 0x143a, 0xf0 | val);
-        if (err < 0)
-                return err;
+        err = setbrightness(sd);
 
         /* commit settings */
-        err = stv06xx_write_bridge(sd, 0x143f, 0x01);
-        return (err < 0) ? err : 0;
-}
-
-static int st6422_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        s32 *sensor_settings = sd->sensor_priv;
-
-        *val = sensor_settings[GAIN_IDX];
-
-        PDEBUG(D_V4L2, "Read gain %d", *val);
+        if (err >= 0)
+                err = stv06xx_write_bridge(sd, 0x143f, 0x01);
 
-        return 0;
+        gspca_dev->usb_err = err;
 }
 
-static int st6422_set_gain(struct gspca_dev *gspca_dev, __s32 val)
+static void st6422_set_contrast(struct gspca_dev *gspca_dev)
 {
         int err;
         struct sd *sd = (struct sd *) gspca_dev;
-        s32 *sensor_settings = sd->sensor_priv;
-
-        sensor_settings[GAIN_IDX] = val;
-
-        if (!gspca_dev->streaming)
-                return 0;
-
-        PDEBUG(D_V4L2, "Set gain to %d", val);
 
-        /* Set red, green, blue, gain */
-        err = stv06xx_write_bridge(sd, 0x0509, val);
-        if (err < 0)
-                return err;
-
-        err = stv06xx_write_bridge(sd, 0x050a, val);
-        if (err < 0)
-                return err;
-
-        err = stv06xx_write_bridge(sd, 0x050b, val);
-        if (err < 0)
-                return err;
-
-        /* 2 mystery writes */
-        err = stv06xx_write_bridge(sd, 0x050c, 0x2a);
-        if (err < 0)
-                return err;
-
-        err = stv06xx_write_bridge(sd, 0x050d, 0x01);
-        if (err < 0)
-                return err;
+        err = setcontrast(sd);
 
         /* commit settings */
-        err = stv06xx_write_bridge(sd, 0x143f, 0x01);
-        return (err < 0) ? err : 0;
+        if (err >= 0)
+                err = stv06xx_write_bridge(sd, 0x143f, 0x01);
+
+        gspca_dev->usb_err = err;
 }
 
-static int st6422_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
+static void st6422_set_gain(struct gspca_dev *gspca_dev)
 {
+        int err;
         struct sd *sd = (struct sd *) gspca_dev;
-        s32 *sensor_settings = sd->sensor_priv;
 
-        *val = sensor_settings[EXPOSURE_IDX];
+        err = setgain(sd);
 
-        PDEBUG(D_V4L2, "Read exposure %d", *val);
+        /* commit settings */
+        if (err >= 0)
+                err = stv06xx_write_bridge(sd, 0x143f, 0x01);
 
-        return 0;
+        gspca_dev->usb_err = err;
 }
 
-static int st6422_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
+static void st6422_set_exposure(struct gspca_dev *gspca_dev)
 {
         int err;
         struct sd *sd = (struct sd *) gspca_dev;
-        s32 *sensor_settings = sd->sensor_priv;
-
-        sensor_settings[EXPOSURE_IDX] = val;
 
-        if (!gspca_dev->streaming)
-                return 0;
-
-        PDEBUG(D_V4L2, "Set exposure to %d\n", val);
-        err = stv06xx_write_bridge(sd, 0x143d, val & 0xff);
-        if (err < 0)
-                return err;
-
-        err = stv06xx_write_bridge(sd, 0x143e, val >> 8);
-        if (err < 0)
-                return err;
+        err = setexposure(sd);
 
         /* commit settings */
-        err = stv06xx_write_bridge(sd, 0x143f, 0x01);
-        return (err < 0) ? err : 0;
+        if (err >= 0)
+                err = stv06xx_write_bridge(sd, 0x143f, 0x01);
+
+        gspca_dev->usb_err = err;
 }
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_st6422.h b/drivers/media/video/gspca/stv06xx/stv06xx_st6422.h
index b2d45fe50522..d7498e06432b 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_st6422.h
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_st6422.h
@@ -37,18 +37,11 @@ static int st6422_init(struct sd *sd);
 static int st6422_stop(struct sd *sd);
 static void st6422_disconnect(struct sd *sd);
 
-/* V4L2 controls supported by the driver */
-static int st6422_get_brightness(struct gspca_dev *gspca_dev, __s32 *val);
-static int st6422_set_brightness(struct gspca_dev *gspca_dev, __s32 val);
-static int st6422_get_contrast(struct gspca_dev *gspca_dev, __s32 *val);
-static int st6422_set_contrast(struct gspca_dev *gspca_dev, __s32 val);
-static int st6422_get_gain(struct gspca_dev *gspca_dev, __s32 *val);
-static int st6422_set_gain(struct gspca_dev *gspca_dev, __s32 val);
-static int st6422_get_exposure(struct gspca_dev *gspca_dev, __s32 *val);
-static int st6422_set_exposure(struct gspca_dev *gspca_dev, __s32 val);
-
 const struct stv06xx_sensor stv06xx_sensor_st6422 = {
         .name = "ST6422",
+        /* No known way to lower framerate in case of less bandwidth */
+        .min_packet_size = { 300, 847 },
+        .max_packet_size = { 300, 847 },
         .init = st6422_init,
         .probe = st6422_probe,
         .start = st6422_start,
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_vv6410.c b/drivers/media/video/gspca/stv06xx/stv06xx_vv6410.c
index 11a0c002f5dc..f8398434c328 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_vv6410.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_vv6410.c
@@ -66,7 +66,7 @@ static const struct ctrl vv6410_ctrl[] = {
                         .minimum        = 0,
                         .maximum        = 1,
                         .step           = 1,
-                        .default_value  = 0
+                        .default_value  = 0
                 },
                 .set = vv6410_set_vflip,
                 .get = vv6410_get_vflip
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_vv6410.h b/drivers/media/video/gspca/stv06xx/stv06xx_vv6410.h
index 96c61926d372..7fe3587f5f71 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_vv6410.h
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_vv6410.h
@@ -157,8 +157,8 @@
 /* Audio Amplifier Setup Register */
 #define VV6410_AT1                      0x79
 
-#define VV6410_HFLIP                    (1 << 3)
-#define VV6410_VFLIP                    (1 << 4)
+#define VV6410_HFLIP                    (1 << 3)
+#define VV6410_VFLIP                    (1 << 4)
 
 #define VV6410_LOW_POWER_MODE           (1 << 0)
 #define VV6410_SOFT_RESET               (1 << 2)
@@ -197,6 +197,10 @@ const struct stv06xx_sensor stv06xx_sensor_vv6410 = {
         .i2c_flush = 5,
         .i2c_addr = 0x20,
         .i2c_len = 1,
+        /* FIXME (see if we can lower packet_size-s, needs testing, and also
+           adjusting framerate when the bandwidth gets lower) */
+        .min_packet_size = { 1023 },
+        .max_packet_size = { 1023 },
         .init = vv6410_init,
         .probe = vv6410_probe,
         .start = vv6410_start,
@@ -220,10 +224,6 @@ static const u8 x1536[] = {	/* 0x1536 - 0x153b */
         0x02, 0x00, 0x60, 0x01, 0x20, 0x01
 };
 
-static const u8 x15c1[] = {     /* 0x15c1 - 0x15c2 */
-        0xff, 0x03 /* Output word 0x03ff = 1023 (ISO size) */
-};
-
 static const struct stv_init stv_bridge_init[] = {
         /* This reg is written twice. Some kind of reset? */
         {NULL,  0x1620, 0x80},
@@ -232,7 +232,6 @@ static const struct stv_init stv_bridge_init[] = {
         {NULL,  0x1423, 0x04},
         {x1500, 0x1500, ARRAY_SIZE(x1500)},
         {x1536, 0x1536, ARRAY_SIZE(x1536)},
-        {x15c1, 0x15c1, ARRAY_SIZE(x15c1)}
 };
 
 static const u8 vv6410_sensor_init[][2] = {
diff --git a/drivers/media/video/gspca/sunplus.c b/drivers/media/video/gspca/sunplus.c
index 9494f86b9a85..b089c0d3ee9f 100644
--- a/drivers/media/video/gspca/sunplus.c
+++ b/drivers/media/video/gspca/sunplus.c
@@ -343,7 +343,7 @@ static void reg_r(struct gspca_dev *gspca_dev,
                         len ? gspca_dev->usb_buf : NULL, len,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_r err %d", ret);
+                err("reg_r err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -368,7 +368,7 @@ static void reg_w_1(struct gspca_dev *gspca_dev,
                         gspca_dev->usb_buf, 1,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w_1 err %d", ret);
+                err("reg_w_1 err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -388,7 +388,7 @@ static void reg_w_riv(struct gspca_dev *gspca_dev,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         value, index, NULL, 0, 500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w_riv err %d", ret);
+                err("reg_w_riv err %d", ret);
                 gspca_dev->usb_err = ret;
                 return;
         }
@@ -396,57 +396,6 @@ static void reg_w_riv(struct gspca_dev *gspca_dev,
                 req, index, value);
 }
 
-/* read 1 byte */
-static u8 reg_r_1(struct gspca_dev *gspca_dev,
-                        u16 value)      /* wValue */
-{
-        int ret;
-
-        if (gspca_dev->usb_err < 0)
-                return 0;
-        ret = usb_control_msg(gspca_dev->dev,
-                        usb_rcvctrlpipe(gspca_dev->dev, 0),
-                        0x20,                   /* request */
-                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                        value,
-                        0,                      /* index */
-                        gspca_dev->usb_buf, 1,
-                        500);                   /* timeout */
-        if (ret < 0) {
-                PDEBUG(D_ERR, "reg_r_1 err %d", ret);
-                gspca_dev->usb_err = ret;
-                return 0;
-        }
-        return gspca_dev->usb_buf[0];
-}
-
-/* read 1 or 2 bytes */
-static u16 reg_r_12(struct gspca_dev *gspca_dev,
-                        u8 req,         /* bRequest */
-                        u16 index,      /* wIndex */
-                        u16 length)     /* wLength (1 or 2 only) */
-{
-        int ret;
-
-        if (gspca_dev->usb_err < 0)
-                return 0;
-        gspca_dev->usb_buf[1] = 0;
-        ret = usb_control_msg(gspca_dev->dev,
-                        usb_rcvctrlpipe(gspca_dev->dev, 0),
-                        req,
-                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                        0,              /* value */
-                        index,
-                        gspca_dev->usb_buf, length,
-                        500);
-        if (ret < 0) {
-                PDEBUG(D_ERR, "reg_r_12 err %d", ret);
-                gspca_dev->usb_err = ret;
-                return 0;
-        }
-        return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
-}
-
 static void write_vector(struct gspca_dev *gspca_dev,
                         const struct cmd *data, int ncmds)
 {
@@ -463,7 +412,7 @@ static void setup_qtable(struct gspca_dev *gspca_dev,
 
         /* loop over y components */
         for (i = 0; i < 64; i++)
-                 reg_w_riv(gspca_dev, 0x00, 0x2800 + i, qtable[0][i]);
+                reg_w_riv(gspca_dev, 0x00, 0x2800 + i, qtable[0][i]);
 
         /* loop over c components */
         for (i = 0; i < 64; i++)
@@ -473,44 +422,46 @@ static void setup_qtable(struct gspca_dev *gspca_dev,
 static void spca504_acknowledged_command(struct gspca_dev *gspca_dev,
                              u8 req, u16 idx, u16 val)
 {
-        u16 notdone;
-
         reg_w_riv(gspca_dev, req, idx, val);
-        notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
+        reg_r(gspca_dev, 0x01, 0x0001, 1);
+        PDEBUG(D_FRAM, "before wait 0x%04x", gspca_dev->usb_buf[0]);
         reg_w_riv(gspca_dev, req, idx, val);
 
-        PDEBUG(D_FRAM, "before wait 0x%04x", notdone);
-
         msleep(200);
-        notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
-        PDEBUG(D_FRAM, "after wait 0x%04x", notdone);
+        reg_r(gspca_dev, 0x01, 0x0001, 1);
+        PDEBUG(D_FRAM, "after wait 0x%04x", gspca_dev->usb_buf[0]);
 }
 
+#ifdef GSPCA_DEBUG
 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);
+        for (i = 0; i < 6; i++) {
+                reg_r(gspca_dev, 0, i, 1);
+                info[i] = gspca_dev->usb_buf[0];
+        }
         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]);
 }
+#endif
 
 static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
                         u8 req,
-                        u16 idx, u16 val, u16 endcode, u8 count)
+                        u16 idx, u16 val, u8 endcode, u8 count)
 {
         u16 status;
 
         reg_w_riv(gspca_dev, req, idx, val);
-        status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
+        reg_r(gspca_dev, 0x01, 0x0001, 1);
         if (gspca_dev->usb_err < 0)
                 return;
-        PDEBUG(D_FRAM, "Status 0x%04x Need 0x%04x", status, endcode);
+        PDEBUG(D_FRAM, "Status 0x%02x Need 0x%02x",
+                        gspca_dev->usb_buf[0], endcode);
         if (!count)
                 return;
         count = 200;
@@ -518,7 +469,8 @@ static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
                 msleep(10);
                 /* gsmart mini2 write a each wait setting 1 ms is enough */
 /*              reg_w_riv(gspca_dev, req, idx, val); */
-                status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
+                reg_r(gspca_dev, 0x01, 0x0001, 1);
+                status = gspca_dev->usb_buf[0];
                 if (status == endcode) {
                         PDEBUG(D_FRAM, "status 0x%04x after wait %d",
                                 status, 200 - count);
@@ -555,17 +507,19 @@ static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
         }
 }
 
+#ifdef GSPCA_DEBUG
 static void spca50x_GetFirmware(struct gspca_dev *gspca_dev)
 {
         u8 *data;
 
         data = gspca_dev->usb_buf;
         reg_r(gspca_dev, 0x20, 0, 5);
-        PDEBUG(D_STREAM, "FirmWare : %d %d %d %d %d ",
+        PDEBUG(D_STREAM, "FirmWare: %d %d %d %d %d",
                 data[0], data[1], data[2], data[3], data[4]);
         reg_r(gspca_dev, 0x23, 0, 64);
         reg_r(gspca_dev, 0x23, 1, 64);
 }
+#endif
 
 static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
 {
@@ -578,7 +532,9 @@ static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
                 reg_w_riv(gspca_dev, 0x31, 0, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
                 spca504B_PollingDataReady(gspca_dev);
+#ifdef GSPCA_DEBUG
                 spca50x_GetFirmware(gspca_dev);
+#endif
                 reg_w_1(gspca_dev, 0x24, 0, 8, 2);              /* type */
                 reg_r(gspca_dev, 0x24, 8, 1);
 
@@ -628,7 +584,8 @@ static void spca504_wait_status(struct gspca_dev *gspca_dev)
         cnt = 256;
         while (--cnt > 0) {
                 /* With this we get the status, when return 0 it's all ok */
-                if (reg_r_12(gspca_dev, 0x06, 0x00, 1) == 0)
+                reg_r(gspca_dev, 0x06, 0x00, 1);
+                if (gspca_dev->usb_buf[0] == 0)
                         return;
                 msleep(10);
         }
@@ -712,8 +669,9 @@ static int sd_config(struct gspca_dev *gspca_dev,
         sd->subtype = id->driver_info;
 
         if (sd->subtype == AiptekMiniPenCam13) {
-/* try to get the firmware as some cam answer 2.0.1.2.2
- * and should be a spca504b then overwrite that setting */
+
+                /* try to get the firmware as some cam answer 2.0.1.2.2
+                 * and should be a spca504b then overwrite that setting */
                 reg_r(gspca_dev, 0x20, 0, 1);
                 switch (gspca_dev->usb_buf[0]) {
                 case 1:
@@ -733,7 +691,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
 /*      case BRIDGE_SPCA504: */
 /*      case BRIDGE_SPCA536: */
                 cam->cam_mode = vga_mode;
-                cam->nmodes =ARRAY_SIZE(vga_mode);
+                cam->nmodes = ARRAY_SIZE(vga_mode);
                 break;
         case BRIDGE_SPCA533:
                 cam->cam_mode = custom_mode;
@@ -771,10 +729,14 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 /* fall thru */
         case BRIDGE_SPCA533:
                 spca504B_PollingDataReady(gspca_dev);
+#ifdef GSPCA_DEBUG
                 spca50x_GetFirmware(gspca_dev);
+#endif
                 break;
         case BRIDGE_SPCA536:
+#ifdef GSPCA_DEBUG
                 spca50x_GetFirmware(gspca_dev);
+#endif
                 reg_r(gspca_dev, 0x00, 0x5002, 1);
                 reg_w_1(gspca_dev, 0x24, 0, 0, 0);
                 reg_r(gspca_dev, 0x24, 0, 1);
@@ -800,7 +762,9 @@ static int sd_init(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA504: */
                 PDEBUG(D_STREAM, "Opening SPCA504");
                 if (sd->subtype == AiptekMiniPenCam13) {
+#ifdef GSPCA_DEBUG
                         spca504_read_info(gspca_dev);
+#endif
 
                         /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
                         spca504A_acknowledged_command(gspca_dev, 0x24,
@@ -872,7 +836,9 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 break;
         case BRIDGE_SPCA504:
                 if (sd->subtype == AiptekMiniPenCam13) {
+#ifdef GSPCA_DEBUG
                         spca504_read_info(gspca_dev);
+#endif
 
                         /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
                         spca504A_acknowledged_command(gspca_dev, 0x24,
@@ -884,7 +850,9 @@ static int sd_start(struct gspca_dev *gspca_dev)
                                                         0, 0, 0x9d, 1);
                 } else {
                         spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
+#ifdef GSPCA_DEBUG
                         spca504_read_info(gspca_dev);
+#endif
                         spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
                         spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
                 }
@@ -1161,7 +1129,7 @@ static const struct sd_desc sd_desc = {
 #define BS(bridge, subtype) \
         .driver_info = (BRIDGE_ ## bridge << 8) \
                         | (subtype)
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x400b), BS(SPCA504C, 0)},
         {USB_DEVICE(0x041e, 0x4012), BS(SPCA504C, 0)},
         {USB_DEVICE(0x041e, 0x4013), BS(SPCA504C, 0)},
@@ -1247,17 +1215,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/t613.c b/drivers/media/video/gspca/t613.c
index 3b3b983f2b9d..7e762d551099 100644
--- a/drivers/media/video/gspca/t613.c
+++ b/drivers/media/video/gspca/t613.c
@@ -92,8 +92,6 @@ static int sd_setmirror(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getmirror(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val);
 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 const struct ctrl sd_ctrls[] = {
         {
@@ -487,7 +485,7 @@ static const u8 gamma_table[GAMMA_MAX][17] = {
         {0x00, 0x02, 0x07, 0x0f, 0x18, 0x24, 0x30, 0x3f,        /* 3 */
          0x4f, 0x61, 0x73, 0x88, 0x9d, 0xb4, 0xcd, 0xe6,
          0xff},
-        {0x00, 0x04, 0x0B, 0x15, 0x20, 0x2d, 0x3b, 0x4a,        /* 4 */
+        {0x00, 0x04, 0x0b, 0x15, 0x20, 0x2d, 0x3b, 0x4a,        /* 4 */
          0x5b, 0x6c, 0x7f, 0x92, 0xa7, 0xbc, 0xd2, 0xe9,
          0xff},
         {0x00, 0x07, 0x11, 0x15, 0x20, 0x2d, 0x48, 0x58,        /* 5 */
@@ -892,7 +890,7 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 sd->sensor = SENSOR_OM6802;
                 break;
         default:
-                PDEBUG(D_ERR|D_PROBE, "unknown sensor %04x", sensor_id);
+                err("unknown sensor %04x", sensor_id);
                 return -EINVAL;
         }
 
@@ -1379,17 +1377,14 @@ static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val)
 static int sd_querymenu(struct gspca_dev *gspca_dev,
                         struct v4l2_querymenu *menu)
 {
+        static const char *freq_nm[3] = {"NoFliker", "50 Hz", "60 Hz"};
+
         switch (menu->id) {
         case V4L2_CID_POWER_LINE_FREQUENCY:
-                switch (menu->index) {
-                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;
+                if ((unsigned) menu->index >= ARRAY_SIZE(freq_nm))
+                        break;
+                strcpy((char *) menu->name, freq_nm[menu->index]);
+                return 0;
         case V4L2_CID_EFFECTS:
                 if ((unsigned) menu->index < ARRAY_SIZE(effects_control)) {
                         strncpy((char *) menu->name,
@@ -1416,7 +1411,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x17a1, 0x0128)},
         {}
 };
@@ -1444,17 +1439,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/tv8532.c b/drivers/media/video/gspca/tv8532.c
index d9c5bf3449d4..933ef2ca658c 100644
--- a/drivers/media/video/gspca/tv8532.c
+++ b/drivers/media/video/gspca/tv8532.c
@@ -132,7 +132,7 @@ static const struct v4l2_pix_format sif_mode[] = {
 #define R36_PID         0x36
 #define R37_PIDH        0x37
 #define R39_Test1       0x39            /* GPIO */
-#define R3B_Test3       0x3B            /* GPIO */
+#define R3B_Test3       0x3b            /* GPIO */
 #define R83_AD_IDH      0x83
 #define R91_AD_SLOPEREG 0x91
 #define R94_AD_BITCONTROL 0x94
@@ -388,7 +388,7 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x046d, 0x0920)},
         {USB_DEVICE(0x046d, 0x0921)},
         {USB_DEVICE(0x0545, 0x808b)},
@@ -421,18 +421,12 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/vc032x.c b/drivers/media/video/gspca/vc032x.c
index b16fd47e8ced..6caed734a06a 100644
--- a/drivers/media/video/gspca/vc032x.c
+++ b/drivers/media/video/gspca/vc032x.c
@@ -47,24 +47,29 @@ struct sd {
         u8 image_offset;
 
         u8 bridge;
-#define BRIDGE_VC0321 0
-#define BRIDGE_VC0323 1
         u8 sensor;
-#define SENSOR_HV7131R 0
-#define SENSOR_MI0360 1
-#define SENSOR_MI1310_SOC 2
-#define SENSOR_MI1320 3
-#define SENSOR_MI1320_SOC 4
-#define SENSOR_OV7660 5
-#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 */
 #define FL_VFLIP 0x04           /* vertical flipped by default */
 };
+enum bridges {
+        BRIDGE_VC0321,
+        BRIDGE_VC0323,
+};
+enum sensors {
+        SENSOR_HV7131R,
+        SENSOR_MI0360,
+        SENSOR_MI1310_SOC,
+        SENSOR_MI1320,
+        SENSOR_MI1320_SOC,
+        SENSOR_OV7660,
+        SENSOR_OV7670,
+        SENSOR_PO1200,
+        SENSOR_PO3130NC,
+        SENSOR_POxxxx,
+        NSENSORS
+};
 
 /* V4L2 controls supported by the driver */
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
@@ -260,56 +265,56 @@ static const struct ctrl sd_ctrls[] = {
 };
 
 /* table of the disabled controls */
-static u32 ctrl_dis[] = {
-/* SENSOR_HV7131R 0 */
+static u32 ctrl_dis[NSENSORS] = {
+    [SENSOR_HV7131R] =
         (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
                 | (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX)
                 | (1 << SHARPNESS_IDX)
                 | (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
                 | (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
-/* SENSOR_MI0360 1 */
+    [SENSOR_MI0360] =
         (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
                 | (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX)
                 | (1 << SHARPNESS_IDX)
                 | (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
                 | (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
-/* SENSOR_MI1310_SOC 2 */
+    [SENSOR_MI1310_SOC] =
         (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
                 | (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX)
                 | (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
                 | (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
-/* SENSOR_MI1320 3 */
+    [SENSOR_MI1320] =
         (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
                 | (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX)
                 | (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
                 | (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
-/* SENSOR_MI1320_SOC 4 */
+    [SENSOR_MI1320_SOC] =
         (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
                 | (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX)
                 | (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
                 | (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
-/* SENSOR_OV7660 5 */
+    [SENSOR_OV7660] =
         (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
                 | (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX)
                 | (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
                 | (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
-/* SENSOR_OV7670 6 */
+    [SENSOR_OV7670] =
         (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
                 | (1 << SHARPNESS_IDX)
                 | (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
                 | (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
-/* SENSOR_PO1200 7 */
+    [SENSOR_PO1200] =
         (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
                 | (1 << LIGHTFREQ_IDX)
                 | (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
                 | (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
-/* SENSOR_PO3130NC 8 */
+    [SENSOR_PO3130NC] =
         (1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
                 | (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX)
                 | (1 << SHARPNESS_IDX)
                 | (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
                 | (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
-/* SENSOR_POxxxx 9 */
+    [SENSOR_POxxxx] =
         (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX),
 };
 
@@ -3164,7 +3169,7 @@ static void reg_r_i(struct gspca_dev *gspca_dev,
                         index, gspca_dev->usb_buf, len,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_r err %d", ret);
+                err("reg_r err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -3205,7 +3210,7 @@ static void reg_w_i(struct gspca_dev *gspca_dev,
                         value, index, NULL, 0,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w err %d", ret);
+                err("reg_w err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -3230,7 +3235,7 @@ static u16 read_sensor_register(struct gspca_dev *gspca_dev,
 
         reg_r(gspca_dev, 0xa1, 0xb33f, 1);
         if (!(gspca_dev->usb_buf[0] & 0x02)) {
-                PDEBUG(D_ERR, "I2c Bus Busy Wait %02x",
+                err("I2c Bus Busy Wait %02x",
                         gspca_dev->usb_buf[0]);
                 return 0;
         }
@@ -3344,7 +3349,7 @@ static void i2c_write(struct gspca_dev *gspca_dev,
                 msleep(20);
         } while (--retry > 0);
         if (retry <= 0)
-                PDEBUG(D_ERR, "i2c_write timeout");
+                err("i2c_write timeout");
 }
 
 static void put_tab_to_reg(struct gspca_dev *gspca_dev,
@@ -3420,17 +3425,18 @@ static int sd_init(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         struct cam *cam;
         int sensor;
-        static u8 npkt[] = {    /* number of packets per ISOC message */
-                64,             /* HV7131R 0 */
-                32,             /* MI0360 1 */
-                32,             /* MI1310_SOC 2 */
-                64,             /* MI1320 3 */
-                128,            /* MI1320_SOC 4 */
-                32,             /* OV7660 5 */
-                64,             /* OV7670 6 */
-                128,            /* PO1200 7 */
-                128,            /* PO3130NC 8 */
-                128,            /* POxxxx 9 */
+        /* number of packets per ISOC message */
+        static u8 npkt[NSENSORS] = {
+                [SENSOR_HV7131R] =      64,
+                [SENSOR_MI0360] =       32,
+                [SENSOR_MI1310_SOC] =   32,
+                [SENSOR_MI1320] =       64,
+                [SENSOR_MI1320_SOC] =   128,
+                [SENSOR_OV7660] =       32,
+                [SENSOR_OV7670] =       64,
+                [SENSOR_PO1200] =       128,
+                [SENSOR_PO3130NC] =     128,
+                [SENSOR_POxxxx] =       128,
         };
 
         if (sd->sensor != SENSOR_POxxxx)
@@ -3440,7 +3446,7 @@ static int sd_init(struct gspca_dev *gspca_dev)
 
         switch (sensor) {
         case -1:
-                PDEBUG(D_PROBE, "Unknown sensor...");
+                err("Unknown sensor...");
                 return -EINVAL;
         case SENSOR_HV7131R:
                 PDEBUG(D_PROBE, "Find Sensor HV7131R");
@@ -4186,7 +4192,7 @@ static const struct sd_desc sd_desc = {
 #define BF(bridge, flags) \
         .driver_info = (BRIDGE_ ## bridge << 8) \
                 | (flags)
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x405b), BF(VC0323, FL_VFLIP)},
         {USB_DEVICE(0x046d, 0x0892), BF(VC0321, 0)},
         {USB_DEVICE(0x046d, 0x0896), BF(VC0321, 0)},
@@ -4226,18 +4232,11 @@ static struct usb_driver sd_driver = {
 /* -- 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;
+        return usb_register(&sd_driver);
 }
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);
diff --git a/drivers/media/video/gspca/vicam.c b/drivers/media/video/gspca/vicam.c
new file mode 100644
index 000000000000..84dfbab923b5
--- /dev/null
+++ b/drivers/media/video/gspca/vicam.c
@@ -0,0 +1,381 @@
+/*
+ * gspca ViCam subdriver
+ *
+ * Copyright (C) 2011 Hans de Goede <hdegoede@redhat.com>
+ *
+ * Based on the usbvideo vicam driver, which is:
+ *
+ * Copyright (c) 2002 Joe Burks (jburks@wavicle.org),
+ *                    Christopher L Cheney (ccheney@cheney.cx),
+ *                    Pavel Machek (pavel@ucw.cz),
+ *                    John Tyner (jtyner@cs.ucr.edu),
+ *                    Monroe Williams (monroe@pobox.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
+ * 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 "vicam"
+#define HEADER_SIZE 64
+
+#include <linux/workqueue.h>
+#include <linux/slab.h>
+#include <linux/firmware.h>
+#include <linux/ihex.h>
+#include "gspca.h"
+
+MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
+MODULE_DESCRIPTION("GSPCA ViCam USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+enum e_ctrl {
+        GAIN,
+        EXPOSURE,
+        NCTRL           /* number of controls */
+};
+
+struct sd {
+        struct gspca_dev gspca_dev;     /* !! must be the first item */
+        struct work_struct work_struct;
+        struct workqueue_struct *work_thread;
+        struct gspca_ctrl ctrls[NCTRL];
+};
+
+/* The vicam sensor has a resolution of 512 x 244, with I believe square
+   pixels, but this is forced to a 4:3 ratio by optics. So it has
+   non square pixels :( */
+static struct v4l2_pix_format vicam_mode[] = {
+        { 256, 122, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
+                .bytesperline = 256,
+                .sizeimage = 256 * 122,
+                .colorspace = V4L2_COLORSPACE_SRGB,},
+        /* 2 modes with somewhat more square pixels */
+        { 256, 200, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
+                .bytesperline = 256,
+                .sizeimage = 256 * 200,
+                .colorspace = V4L2_COLORSPACE_SRGB,},
+        { 256, 240, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
+                .bytesperline = 256,
+                .sizeimage = 256 * 240,
+                .colorspace = V4L2_COLORSPACE_SRGB,},
+#if 0   /* This mode has extremely non square pixels, testing use only */
+        { 512, 122, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
+                .bytesperline = 512,
+                .sizeimage = 512 * 122,
+                .colorspace = V4L2_COLORSPACE_SRGB,},
+#endif
+        { 512, 244, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
+                .bytesperline = 512,
+                .sizeimage = 512 * 244,
+                .colorspace = V4L2_COLORSPACE_SRGB,},
+};
+
+static const struct ctrl sd_ctrls[] = {
+[GAIN] = {
+            {
+                .id      = V4L2_CID_GAIN,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Gain",
+                .minimum = 0,
+                .maximum = 255,
+                .step    = 1,
+                .default_value = 200,
+            },
+        },
+[EXPOSURE] = {
+            {
+                .id      = V4L2_CID_EXPOSURE,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Exposure",
+                .minimum = 0,
+                .maximum = 2047,
+                .step    = 1,
+                .default_value = 256,
+            },
+        },
+};
+
+static int vicam_control_msg(struct gspca_dev *gspca_dev, u8 request,
+        u16 value, u16 index, u8 *data, u16 len)
+{
+        int ret;
+
+        ret = usb_control_msg(gspca_dev->dev,
+                              usb_sndctrlpipe(gspca_dev->dev, 0),
+                              request,
+                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                              value, index, data, len, 1000);
+        if (ret < 0)
+                err("control msg req %02X error %d", request, ret);
+
+        return ret;
+}
+
+static int vicam_set_camera_power(struct gspca_dev *gspca_dev, int state)
+{
+        int ret;
+
+        ret = vicam_control_msg(gspca_dev, 0x50, state, 0, NULL, 0);
+        if (ret < 0)
+                return ret;
+
+        if (state)
+                ret = vicam_control_msg(gspca_dev, 0x55, 1, 0, NULL, 0);
+
+        return ret;
+}
+
+/*
+ *  request and read a block of data - see warning on vicam_command.
+ */
+static int vicam_read_frame(struct gspca_dev *gspca_dev, u8 *data, int size)
+{
+        struct sd *sd = (struct sd *)gspca_dev;
+        int ret, unscaled_height, act_len = 0;
+        u8 *req_data = gspca_dev->usb_buf;
+
+        memset(req_data, 0, 16);
+        req_data[0] = sd->ctrls[GAIN].val;
+        if (gspca_dev->width == 256)
+                req_data[1] |= 0x01; /* low nibble x-scale */
+        if (gspca_dev->height <= 122) {
+                req_data[1] |= 0x10; /* high nibble y-scale */
+                unscaled_height = gspca_dev->height * 2;
+        } else
+                unscaled_height = gspca_dev->height;
+        req_data[2] = 0x90; /* unknown, does not seem to do anything */
+        if (unscaled_height <= 200)
+                req_data[3] = 0x06; /* vend? */
+        else if (unscaled_height <= 242) /* Yes 242 not 240 */
+                req_data[3] = 0x07; /* vend? */
+        else /* Up to 244 lines with req_data[3] == 0x08 */
+                req_data[3] = 0x08; /* vend? */
+
+        if (sd->ctrls[EXPOSURE].val < 256) {
+                /* Frame rate maxed out, use partial frame expo time */
+                req_data[4] = 255 - sd->ctrls[EXPOSURE].val;
+                req_data[5] = 0x00;
+                req_data[6] = 0x00;
+                req_data[7] = 0x01;
+        } else {
+                /* Modify frame rate */
+                req_data[4] = 0x00;
+                req_data[5] = 0x00;
+                req_data[6] = sd->ctrls[EXPOSURE].val & 0xFF;
+                req_data[7] = sd->ctrls[EXPOSURE].val >> 8;
+        }
+        req_data[8] = ((244 - unscaled_height) / 2) & ~0x01; /* vstart */
+        /* bytes 9-15 do not seem to affect exposure or image quality */
+
+        mutex_lock(&gspca_dev->usb_lock);
+        ret = vicam_control_msg(gspca_dev, 0x51, 0x80, 0, req_data, 16);
+        mutex_unlock(&gspca_dev->usb_lock);
+        if (ret < 0)
+                return ret;
+
+        ret = usb_bulk_msg(gspca_dev->dev,
+                           usb_rcvbulkpipe(gspca_dev->dev, 0x81),
+                           data, size, &act_len, 10000);
+        /* successful, it returns 0, otherwise  negative */
+        if (ret < 0 || act_len != size) {
+                err("bulk read fail (%d) len %d/%d",
+                        ret, act_len, size);
+                return -EIO;
+        }
+        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
+ * threads attempting to use the camera's USB interface we take the gspca
+ * usb_lock when performing USB operations. In practice the only thing we need
+ * to protect against is the usb_set_interface call that gspca makes during
+ * stream_off as the camera doesn't provide any controls that the user could try
+ * to change.
+ */
+static void vicam_dostream(struct work_struct *work)
+{
+        struct sd *sd = container_of(work, struct sd, work_struct);
+        struct gspca_dev *gspca_dev = &sd->gspca_dev;
+        int ret, frame_sz;
+        u8 *buffer;
+
+        frame_sz = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].sizeimage +
+                   HEADER_SIZE;
+        buffer = kmalloc(frame_sz, GFP_KERNEL | GFP_DMA);
+        if (!buffer) {
+                err("Couldn't allocate USB buffer");
+                goto exit;
+        }
+
+        while (gspca_dev->present && gspca_dev->streaming) {
+                ret = vicam_read_frame(gspca_dev, buffer, frame_sz);
+                if (ret < 0)
+                        break;
+
+                /* Note the frame header contents seem to be completely
+                   constant, they do not change with either image, or
+                   settings. So we simply discard it. The frames have
+                   a very similar 64 byte footer, which we don't even
+                   bother reading from the cam */
+                gspca_frame_add(gspca_dev, FIRST_PACKET,
+                                buffer + HEADER_SIZE,
+                                frame_sz - HEADER_SIZE);
+                gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
+        }
+exit:
+        kfree(buffer);
+}
+
+/* This function is called at probe time just before sd_init */
+static int sd_config(struct gspca_dev *gspca_dev,
+                const struct usb_device_id *id)
+{
+        struct cam *cam = &gspca_dev->cam;
+        struct sd *sd = (struct sd *)gspca_dev;
+
+        /* We don't use the buffer gspca allocates so make it small. */
+        cam->bulk = 1;
+        cam->bulk_size = 64;
+        cam->cam_mode = vicam_mode;
+        cam->nmodes = ARRAY_SIZE(vicam_mode);
+        cam->ctrls = sd->ctrls;
+
+        INIT_WORK(&sd->work_struct, vicam_dostream);
+
+        return 0;
+}
+
+/* this function is called at probe and resume time */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+        int ret;
+        const struct ihex_binrec *rec;
+        const struct firmware *uninitialized_var(fw);
+        u8 *firmware_buf;
+
+        ret = request_ihex_firmware(&fw, "vicam/firmware.fw",
+                                    &gspca_dev->dev->dev);
+        if (ret) {
+                err("Failed to load \"vicam/firmware.fw\": %d\n", ret);
+                return ret;
+        }
+
+        firmware_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!firmware_buf) {
+                ret = -ENOMEM;
+                goto exit;
+        }
+        for (rec = (void *)fw->data; rec; rec = ihex_next_binrec(rec)) {
+                memcpy(firmware_buf, rec->data, be16_to_cpu(rec->len));
+                ret = vicam_control_msg(gspca_dev, 0xff, 0, 0, firmware_buf,
+                                        be16_to_cpu(rec->len));
+                if (ret < 0)
+                        break;
+        }
+
+        kfree(firmware_buf);
+exit:
+        release_firmware(fw);
+        return ret;
+}
+
+/* Set up for getting frames. */
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *)gspca_dev;
+        int ret;
+
+        ret = vicam_set_camera_power(gspca_dev, 1);
+        if (ret < 0)
+                return ret;
+
+        /* Start the workqueue function to do the streaming */
+        sd->work_thread = create_singlethread_workqueue(MODULE_NAME);
+        queue_work(sd->work_thread, &sd->work_struct);
+
+        return 0;
+}
+
+/* called on streamoff with alt==0 and on disconnect */
+/* the usb_lock is held at entry - restore on exit */
+static void sd_stop0(struct gspca_dev *gspca_dev)
+{
+        struct sd *dev = (struct sd *)gspca_dev;
+
+        /* wait for the work queue to terminate */
+        mutex_unlock(&gspca_dev->usb_lock);
+        /* This waits for vicam_dostream to finish */
+        destroy_workqueue(dev->work_thread);
+        dev->work_thread = NULL;
+        mutex_lock(&gspca_dev->usb_lock);
+
+        vicam_set_camera_power(gspca_dev, 0);
+}
+
+/* Table of supported USB devices */
+static const struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x04c1, 0x009d)},
+        {USB_DEVICE(0x0602, 0x1001)},
+        {}
+};
+
+MODULE_DEVICE_TABLE(usb, device_table);
+
+/* 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,
+        .stop0  = sd_stop0,
+};
+
+/* -- 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)
+{
+        return usb_register(&sd_driver);
+}
+
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
diff --git a/drivers/media/video/gspca/w996Xcf.c b/drivers/media/video/gspca/w996Xcf.c
index 38a68591ce48..4a9e622e5e1b 100644
--- a/drivers/media/video/gspca/w996Xcf.c
+++ b/drivers/media/video/gspca/w996Xcf.c
@@ -59,18 +59,21 @@ static const struct v4l2_pix_format w9968cf_vga_mode[] = {
                 .colorspace = V4L2_COLORSPACE_JPEG},
 };
 
-static int reg_w(struct sd *sd, __u16 index, __u16 value);
+static void reg_w(struct sd *sd, u16 index, u16 value);
 
 /*--------------------------------------------------------------------------
   Write 64-bit data to the fast serial bus registers.
   Return 0 on success, -1 otherwise.
   --------------------------------------------------------------------------*/
-static int w9968cf_write_fsb(struct sd *sd, u16* data)
+static void w9968cf_write_fsb(struct sd *sd, u16* data)
 {
-        struct usb_device* udev = sd->gspca_dev.dev;
+        struct usb_device *udev = sd->gspca_dev.dev;
         u16 value;
         int ret;
 
+        if (sd->gspca_dev.usb_err < 0)
+                return;
+
         value = *data++;
         memcpy(sd->gspca_dev.usb_buf, data, 6);
 
@@ -78,21 +81,22 @@ static int w9968cf_write_fsb(struct sd *sd, u16* data)
                               USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
                               value, 0x06, sd->gspca_dev.usb_buf, 6, 500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "Write FSB registers failed (%d)", ret);
-                return ret;
+                err("Write FSB registers failed (%d)", ret);
+                sd->gspca_dev.usb_err = ret;
         }
-
-        return 0;
 }
 
 /*--------------------------------------------------------------------------
   Write data to the serial bus control register.
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
-static int w9968cf_write_sb(struct sd *sd, u16 value)
+static void w9968cf_write_sb(struct sd *sd, u16 value)
 {
         int ret;
 
+        if (sd->gspca_dev.usb_err < 0)
+                return;
+
         /* We don't use reg_w here, as that would cause all writes when
            bitbanging i2c to be logged, making the logs impossible to read */
         ret = usb_control_msg(sd->gspca_dev.dev,
@@ -104,11 +108,9 @@ static int w9968cf_write_sb(struct sd *sd, u16 value)
         udelay(W9968CF_I2C_BUS_DELAY);
 
         if (ret < 0) {
-                PDEBUG(D_ERR, "Write SB reg [01] %04x failed", value);
-                return ret;
+                err("Write SB reg [01] %04x failed", value);
+                sd->gspca_dev.usb_err = ret;
         }
-
-        return 0;
 }
 
 /*--------------------------------------------------------------------------
@@ -119,6 +121,9 @@ static int w9968cf_read_sb(struct sd *sd)
 {
         int ret;
 
+        if (sd->gspca_dev.usb_err < 0)
+                return -1;
+
         /* We don't use reg_r here, as the w9968cf is special and has 16
            bit registers instead of 8 bit */
         ret = usb_control_msg(sd->gspca_dev.dev,
@@ -126,11 +131,13 @@ static int w9968cf_read_sb(struct sd *sd)
                         1,
                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         0, 0x01, sd->gspca_dev.usb_buf, 2, 500);
-        if (ret >= 0)
+        if (ret >= 0) {
                 ret = sd->gspca_dev.usb_buf[0] |
                       (sd->gspca_dev.usb_buf[1] << 8);
-        else
-                PDEBUG(D_ERR, "Read SB reg [01] failed");
+        } else {
+                err("Read SB reg [01] failed");
+                sd->gspca_dev.usb_err = ret;
+        }
 
         udelay(W9968CF_I2C_BUS_DELAY);
 
@@ -142,22 +149,20 @@ static int w9968cf_read_sb(struct sd *sd)
   This function is called by w9968cf_start_transfer().
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
-static int w9968cf_upload_quantizationtables(struct sd *sd)
+static void w9968cf_upload_quantizationtables(struct sd *sd)
 {
         u16 a, b;
-        int ret = 0, i, j;
+        int i, j;
 
-        ret += reg_w(sd, 0x39, 0x0010); /* JPEG clock enable */
+        reg_w(sd, 0x39, 0x0010); /* JPEG clock enable */
 
         for (i = 0, j = 0; i < 32; i++, j += 2) {
-                a = Y_QUANTABLE[j] | ((unsigned)(Y_QUANTABLE[j+1]) << 8);
-                b = UV_QUANTABLE[j] | ((unsigned)(UV_QUANTABLE[j+1]) << 8);
-                ret += reg_w(sd, 0x40+i, a);
-                ret += reg_w(sd, 0x60+i, b);
+                a = Y_QUANTABLE[j] | ((unsigned)(Y_QUANTABLE[j + 1]) << 8);
+                b = UV_QUANTABLE[j] | ((unsigned)(UV_QUANTABLE[j + 1]) << 8);
+                reg_w(sd, 0x40 + i, a);
+                reg_w(sd, 0x60 + i, b);
         }
-        ret += reg_w(sd, 0x39, 0x0012); /* JPEG encoder enable */
-
-        return ret;
+        reg_w(sd, 0x39, 0x0012); /* JPEG encoder enable */
 }
 
 /****************************************************************************
@@ -168,50 +173,39 @@ static int w9968cf_upload_quantizationtables(struct sd *sd)
  * i2c_adap_read_byte()                                                     *
  ****************************************************************************/
 
-static int w9968cf_smbus_start(struct sd *sd)
+static void w9968cf_smbus_start(struct sd *sd)
 {
-        int ret = 0;
-
-        ret += w9968cf_write_sb(sd, 0x0011); /* SDE=1, SDA=0, SCL=1 */
-        ret += w9968cf_write_sb(sd, 0x0010); /* SDE=1, SDA=0, SCL=0 */
-
-        return ret;
+        w9968cf_write_sb(sd, 0x0011); /* SDE=1, SDA=0, SCL=1 */
+        w9968cf_write_sb(sd, 0x0010); /* SDE=1, SDA=0, SCL=0 */
 }
 
-static int w9968cf_smbus_stop(struct sd *sd)
+static void w9968cf_smbus_stop(struct sd *sd)
 {
-        int ret = 0;
-
-        ret += w9968cf_write_sb(sd, 0x0010); /* SDE=1, SDA=0, SCL=0 */
-        ret += w9968cf_write_sb(sd, 0x0011); /* SDE=1, SDA=0, SCL=1 */
-        ret += w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
-
-        return ret;
+        w9968cf_write_sb(sd, 0x0010); /* SDE=1, SDA=0, SCL=0 */
+        w9968cf_write_sb(sd, 0x0011); /* SDE=1, SDA=0, SCL=1 */
+        w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
 }
 
-static int w9968cf_smbus_write_byte(struct sd *sd, u8 v)
+static void w9968cf_smbus_write_byte(struct sd *sd, u8 v)
 {
         u8 bit;
-        int ret = 0, sda;
+        int sda;
 
         for (bit = 0 ; bit < 8 ; bit++) {
                 sda = (v & 0x80) ? 2 : 0;
                 v <<= 1;
                 /* SDE=1, SDA=sda, SCL=0 */
-                ret += w9968cf_write_sb(sd, 0x10 | sda);
+                w9968cf_write_sb(sd, 0x10 | sda);
                 /* SDE=1, SDA=sda, SCL=1 */
-                ret += w9968cf_write_sb(sd, 0x11 | sda);
+                w9968cf_write_sb(sd, 0x11 | sda);
                 /* SDE=1, SDA=sda, SCL=0 */
-                ret += w9968cf_write_sb(sd, 0x10 | sda);
+                w9968cf_write_sb(sd, 0x10 | sda);
         }
-
-        return ret;
 }
 
-static int w9968cf_smbus_read_byte(struct sd *sd, u8* v)
+static void w9968cf_smbus_read_byte(struct sd *sd, u8 *v)
 {
         u8 bit;
-        int ret = 0;
 
         /* No need to ensure SDA is high as we are always called after
            read_ack which ends with SDA high */
@@ -219,51 +213,40 @@ static int w9968cf_smbus_read_byte(struct sd *sd, u8* v)
         for (bit = 0 ; bit < 8 ; bit++) {
                 *v <<= 1;
                 /* SDE=1, SDA=1, SCL=1 */
-                ret += w9968cf_write_sb(sd, 0x0013);
+                w9968cf_write_sb(sd, 0x0013);
                 *v |= (w9968cf_read_sb(sd) & 0x0008) ? 1 : 0;
                 /* SDE=1, SDA=1, SCL=0 */
-                ret += w9968cf_write_sb(sd, 0x0012);
+                w9968cf_write_sb(sd, 0x0012);
         }
-
-        return ret;
 }
 
-static int w9968cf_smbus_write_nack(struct sd *sd)
+static void w9968cf_smbus_write_nack(struct sd *sd)
 {
-        int ret = 0;
-
         /* No need to ensure SDA is high as we are always called after
            read_byte which ends with SDA high */
-        ret += w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
-        ret += w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
-
-        return ret;
+        w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
+        w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
 }
 
-static int w9968cf_smbus_read_ack(struct sd *sd)
+static void w9968cf_smbus_read_ack(struct sd *sd)
 {
-        int ret = 0, sda;
+        int sda;
 
         /* Ensure SDA is high before raising clock to avoid a spurious stop */
-        ret += w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
-        ret += w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
+        w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
+        w9968cf_write_sb(sd, 0x0013); /* SDE=1, SDA=1, SCL=1 */
         sda = w9968cf_read_sb(sd);
-        ret += w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
-        if (sda < 0)
-                ret += sda;
-        else if (sda & 0x08) {
+        w9968cf_write_sb(sd, 0x0012); /* SDE=1, SDA=1, SCL=0 */
+        if (sda >= 0 && (sda & 0x08)) {
                 PDEBUG(D_USBI, "Did not receive i2c ACK");
-                ret += -1;
+                sd->gspca_dev.usb_err = -EIO;
         }
-
-        return ret;
 }
 
 /* SMBus protocol: S Addr Wr [A] Subaddr [A] Value [A] P */
-static int w9968cf_i2c_w(struct sd *sd, u8 reg, u8 value)
+static void w9968cf_i2c_w(struct sd *sd, u8 reg, u8 value)
 {
         u16* data = (u16 *)sd->gspca_dev.usb_buf;
-        int ret = 0;
 
         data[0] = 0x082f | ((sd->sensor_addr & 0x80) ? 0x1500 : 0x0);
         data[0] |= (sd->sensor_addr & 0x40) ? 0x4000 : 0x0;
@@ -276,7 +259,7 @@ static int w9968cf_i2c_w(struct sd *sd, u8 reg, u8 value)
         data[3] = 0x1d20 | ((sd->sensor_addr & 0x02) ? 0x0001 : 0x0);
         data[3] |= (sd->sensor_addr & 0x01) ? 0x0054 : 0x0;
 
-        ret += w9968cf_write_fsb(sd, data);
+        w9968cf_write_fsb(sd, data);
 
         data[0] = 0x8208 | ((reg & 0x80) ? 0x0015 : 0x0);
         data[0] |= (reg & 0x40) ? 0x0540 : 0x0;
@@ -290,7 +273,7 @@ static int w9968cf_i2c_w(struct sd *sd, u8 reg, u8 value)
         data[2] |= (reg & 0x01) ? 0x5400 : 0x0;
         data[3] = 0x001d;
 
-        ret += w9968cf_write_fsb(sd, data);
+        w9968cf_write_fsb(sd, data);
 
         data[0] = 0x8208 | ((value & 0x80) ? 0x0015 : 0x0);
         data[0] |= (value & 0x40) ? 0x0540 : 0x0;
@@ -304,14 +287,9 @@ static int w9968cf_i2c_w(struct sd *sd, u8 reg, u8 value)
         data[2] |= (value & 0x01) ? 0x5400 : 0x0;
         data[3] = 0xfe1d;
 
-        ret += w9968cf_write_fsb(sd, data);
+        w9968cf_write_fsb(sd, data);
 
-        if (!ret)
-                PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
-        else
-                PDEBUG(D_ERR, "i2c 0x%02x -> [0x%02x] failed", value, reg);
-
-        return ret;
+        PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
 }
 
 /* SMBus protocol: S Addr Wr [A] Subaddr [A] P S Addr+1 Rd [A] [Value] NA P */
@@ -321,28 +299,28 @@ static int w9968cf_i2c_r(struct sd *sd, u8 reg)
         u8 value;
 
         /* Fast serial bus data control disable */
-        ret += w9968cf_write_sb(sd, 0x0013); /* don't change ! */
-
-        ret += w9968cf_smbus_start(sd);
-        ret += w9968cf_smbus_write_byte(sd, sd->sensor_addr);
-        ret += w9968cf_smbus_read_ack(sd);
-        ret += w9968cf_smbus_write_byte(sd, reg);
-        ret += w9968cf_smbus_read_ack(sd);
-        ret += w9968cf_smbus_stop(sd);
-        ret += w9968cf_smbus_start(sd);
-        ret += w9968cf_smbus_write_byte(sd, sd->sensor_addr + 1);
-        ret += w9968cf_smbus_read_ack(sd);
-        ret += w9968cf_smbus_read_byte(sd, &value);
+        w9968cf_write_sb(sd, 0x0013); /* don't change ! */
+
+        w9968cf_smbus_start(sd);
+        w9968cf_smbus_write_byte(sd, sd->sensor_addr);
+        w9968cf_smbus_read_ack(sd);
+        w9968cf_smbus_write_byte(sd, reg);
+        w9968cf_smbus_read_ack(sd);
+        w9968cf_smbus_stop(sd);
+        w9968cf_smbus_start(sd);
+        w9968cf_smbus_write_byte(sd, sd->sensor_addr + 1);
+        w9968cf_smbus_read_ack(sd);
+        w9968cf_smbus_read_byte(sd, &value);
         /* signal we don't want to read anymore, the v4l1 driver used to
            send an ack here which is very wrong! (and then fixed
            the issues this gave by retrying reads) */
-        ret += w9968cf_smbus_write_nack(sd);
-        ret += w9968cf_smbus_stop(sd);
+        w9968cf_smbus_write_nack(sd);
+        w9968cf_smbus_stop(sd);
 
         /* Fast serial bus data control re-enable */
-        ret += w9968cf_write_sb(sd, 0x0030);
+        w9968cf_write_sb(sd, 0x0030);
 
-        if (!ret) {
+        if (sd->gspca_dev.usb_err >= 0) {
                 ret = value;
                 PDEBUG(D_USBI, "i2c [0x%02X] -> 0x%02X", reg, value);
         } else
@@ -351,79 +329,68 @@ static int w9968cf_i2c_r(struct sd *sd, u8 reg)
         return ret;
 }
 
-
 /*--------------------------------------------------------------------------
   Turn on the LED on some webcams. A beep should be heard too.
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
-static int w9968cf_configure(struct sd *sd)
+static void w9968cf_configure(struct sd *sd)
 {
-        int ret = 0;
-
-        ret += reg_w(sd, 0x00, 0xff00); /* power-down */
-        ret += reg_w(sd, 0x00, 0xbf17); /* reset everything */
-        ret += reg_w(sd, 0x00, 0xbf10); /* normal operation */
-        ret += reg_w(sd, 0x01, 0x0010); /* serial bus, SDS high */
-        ret += reg_w(sd, 0x01, 0x0000); /* serial bus, SDS low */
-        ret += reg_w(sd, 0x01, 0x0010); /* ..high 'beep-beep' */
-        ret += reg_w(sd, 0x01, 0x0030); /* Set sda scl to FSB mode */
-
-        if (ret)
-                PDEBUG(D_ERR, "Couldn't turn on the LED");
+        reg_w(sd, 0x00, 0xff00); /* power-down */
+        reg_w(sd, 0x00, 0xbf17); /* reset everything */
+        reg_w(sd, 0x00, 0xbf10); /* normal operation */
+        reg_w(sd, 0x01, 0x0010); /* serial bus, SDS high */
+        reg_w(sd, 0x01, 0x0000); /* serial bus, SDS low */
+        reg_w(sd, 0x01, 0x0010); /* ..high 'beep-beep' */
+        reg_w(sd, 0x01, 0x0030); /* Set sda scl to FSB mode */
 
         sd->stopped = 1;
-
-        return ret;
 }
 
-static int w9968cf_init(struct sd *sd)
+static void w9968cf_init(struct sd *sd)
 {
-        int ret = 0;
         unsigned long hw_bufsize = sd->sif ? (352 * 288 * 2) : (640 * 480 * 2),
                       y0 = 0x0000,
-                      u0 = y0 + hw_bufsize/2,
-                      v0 = u0 + hw_bufsize/4,
-                      y1 = v0 + hw_bufsize/4,
-                      u1 = y1 + hw_bufsize/2,
-                      v1 = u1 + hw_bufsize/4;
-
-        ret += reg_w(sd, 0x00, 0xff00); /* power off */
-        ret += reg_w(sd, 0x00, 0xbf10); /* power on */
-
-        ret += reg_w(sd, 0x03, 0x405d); /* DRAM timings */
-        ret += reg_w(sd, 0x04, 0x0030); /* SDRAM timings */
-
-        ret += reg_w(sd, 0x20, y0 & 0xffff); /* Y buf.0, low */
-        ret += reg_w(sd, 0x21, y0 >> 16);    /* Y buf.0, high */
-        ret += reg_w(sd, 0x24, u0 & 0xffff); /* U buf.0, low */
-        ret += reg_w(sd, 0x25, u0 >> 16);    /* U buf.0, high */
-        ret += reg_w(sd, 0x28, v0 & 0xffff); /* V buf.0, low */
-        ret += reg_w(sd, 0x29, v0 >> 16);    /* V buf.0, high */
-
-        ret += reg_w(sd, 0x22, y1 & 0xffff); /* Y buf.1, low */
-        ret += reg_w(sd, 0x23, y1 >> 16);    /* Y buf.1, high */
-        ret += reg_w(sd, 0x26, u1 & 0xffff); /* U buf.1, low */
-        ret += reg_w(sd, 0x27, u1 >> 16);    /* U buf.1, high */
-        ret += reg_w(sd, 0x2a, v1 & 0xffff); /* V buf.1, low */
-        ret += reg_w(sd, 0x2b, v1 >> 16);    /* V buf.1, high */
-
-        ret += reg_w(sd, 0x32, y1 & 0xffff); /* JPEG buf 0 low */
-        ret += reg_w(sd, 0x33, y1 >> 16);    /* JPEG buf 0 high */
-
-        ret += reg_w(sd, 0x34, y1 & 0xffff); /* JPEG buf 1 low */
-        ret += reg_w(sd, 0x35, y1 >> 16);    /* JPEG bug 1 high */
-
-        ret += reg_w(sd, 0x36, 0x0000);/* JPEG restart interval */
-        ret += reg_w(sd, 0x37, 0x0804);/*JPEG VLE FIFO threshold*/
-        ret += reg_w(sd, 0x38, 0x0000);/* disable hw up-scaling */
-        ret += reg_w(sd, 0x3f, 0x0000); /* JPEG/MCTL test data */
-
-        return ret;
+                      u0 = y0 + hw_bufsize / 2,
+                      v0 = u0 + hw_bufsize / 4,
+                      y1 = v0 + hw_bufsize / 4,
+                      u1 = y1 + hw_bufsize / 2,
+                      v1 = u1 + hw_bufsize / 4;
+
+        reg_w(sd, 0x00, 0xff00); /* power off */
+        reg_w(sd, 0x00, 0xbf10); /* power on */
+
+        reg_w(sd, 0x03, 0x405d); /* DRAM timings */
+        reg_w(sd, 0x04, 0x0030); /* SDRAM timings */
+
+        reg_w(sd, 0x20, y0 & 0xffff); /* Y buf.0, low */
+        reg_w(sd, 0x21, y0 >> 16);    /* Y buf.0, high */
+        reg_w(sd, 0x24, u0 & 0xffff); /* U buf.0, low */
+        reg_w(sd, 0x25, u0 >> 16);    /* U buf.0, high */
+        reg_w(sd, 0x28, v0 & 0xffff); /* V buf.0, low */
+        reg_w(sd, 0x29, v0 >> 16);    /* V buf.0, high */
+
+        reg_w(sd, 0x22, y1 & 0xffff); /* Y buf.1, low */
+        reg_w(sd, 0x23, y1 >> 16);    /* Y buf.1, high */
+        reg_w(sd, 0x26, u1 & 0xffff); /* U buf.1, low */
+        reg_w(sd, 0x27, u1 >> 16);    /* U buf.1, high */
+        reg_w(sd, 0x2a, v1 & 0xffff); /* V buf.1, low */
+        reg_w(sd, 0x2b, v1 >> 16);    /* V buf.1, high */
+
+        reg_w(sd, 0x32, y1 & 0xffff); /* JPEG buf 0 low */
+        reg_w(sd, 0x33, y1 >> 16);    /* JPEG buf 0 high */
+
+        reg_w(sd, 0x34, y1 & 0xffff); /* JPEG buf 1 low */
+        reg_w(sd, 0x35, y1 >> 16);    /* JPEG bug 1 high */
+
+        reg_w(sd, 0x36, 0x0000);/* JPEG restart interval */
+        reg_w(sd, 0x37, 0x0804);/*JPEG VLE FIFO threshold*/
+        reg_w(sd, 0x38, 0x0000);/* disable hw up-scaling */
+        reg_w(sd, 0x3f, 0x0000); /* JPEG/MCTL test data */
 }
 
-static int w9968cf_set_crop_window(struct sd *sd)
+static void w9968cf_set_crop_window(struct sd *sd)
 {
-        int ret = 0, start_cropx, start_cropy,  x, y, fw, fh, cw, ch,
+        int start_cropx, start_cropy,  x, y, fw, fh, cw, ch,
             max_width, max_height;
 
         if (sd->sif) {
@@ -437,7 +404,7 @@ static int w9968cf_set_crop_window(struct sd *sd)
         if (sd->sensor == SEN_OV7620) {
                 /* Sigh, this is dependend on the clock / framerate changes
                    made by the frequency control, sick. */
-                if (sd->freq == 1) {
+                if (sd->ctrls[FREQ].val == 1) {
                         start_cropx = 277;
                         start_cropy = 37;
                 } else {
@@ -456,8 +423,8 @@ static int w9968cf_set_crop_window(struct sd *sd)
         fw = SC(sd->gspca_dev.width) / max_width;
         fh = SC(sd->gspca_dev.height) / max_height;
 
-        cw = (fw >= fh) ? max_width : SC(sd->gspca_dev.width)/fh;
-        ch = (fw >= fh) ? SC(sd->gspca_dev.height)/fw : max_height;
+        cw = (fw >= fh) ? max_width : SC(sd->gspca_dev.width) / fh;
+        ch = (fw >= fh) ? SC(sd->gspca_dev.height) / fw : max_height;
 
         sd->sensor_width = max_width;
         sd->sensor_height = max_height;
@@ -465,42 +432,40 @@ static int w9968cf_set_crop_window(struct sd *sd)
         x = (max_width - cw) / 2;
         y = (max_height - ch) / 2;
 
-        ret += reg_w(sd, 0x10, start_cropx + x);
-        ret += reg_w(sd, 0x11, start_cropy + y);
-        ret += reg_w(sd, 0x12, start_cropx + x + cw);
-        ret += reg_w(sd, 0x13, start_cropy + y + ch);
-
-        return ret;
+        reg_w(sd, 0x10, start_cropx + x);
+        reg_w(sd, 0x11, start_cropy + y);
+        reg_w(sd, 0x12, start_cropx + x + cw);
+        reg_w(sd, 0x13, start_cropy + y + ch);
 }
 
-static int w9968cf_mode_init_regs(struct sd *sd)
+static void w9968cf_mode_init_regs(struct sd *sd)
 {
-        int ret = 0, val, vs_polarity, hs_polarity;
+        int val, vs_polarity, hs_polarity;
 
-        ret += w9968cf_set_crop_window(sd);
+        w9968cf_set_crop_window(sd);
 
-        ret += reg_w(sd, 0x14, sd->gspca_dev.width);
-        ret += reg_w(sd, 0x15, sd->gspca_dev.height);
+        reg_w(sd, 0x14, sd->gspca_dev.width);
+        reg_w(sd, 0x15, sd->gspca_dev.height);
 
         /* JPEG width & height */
-        ret += reg_w(sd, 0x30, sd->gspca_dev.width);
-        ret += reg_w(sd, 0x31, sd->gspca_dev.height);
+        reg_w(sd, 0x30, sd->gspca_dev.width);
+        reg_w(sd, 0x31, sd->gspca_dev.height);
 
         /* Y & UV frame buffer strides (in WORD) */
         if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
             V4L2_PIX_FMT_JPEG) {
-                ret += reg_w(sd, 0x2c, sd->gspca_dev.width/2);
-                ret += reg_w(sd, 0x2d, sd->gspca_dev.width/4);
+                reg_w(sd, 0x2c, sd->gspca_dev.width / 2);
+                reg_w(sd, 0x2d, sd->gspca_dev.width / 4);
         } else
-                ret += reg_w(sd, 0x2c, sd->gspca_dev.width);
+                reg_w(sd, 0x2c, sd->gspca_dev.width);
 
-        ret += reg_w(sd, 0x00, 0xbf17); /* reset everything */
-        ret += reg_w(sd, 0x00, 0xbf10); /* normal operation */
+        reg_w(sd, 0x00, 0xbf17); /* reset everything */
+        reg_w(sd, 0x00, 0xbf10); /* normal operation */
 
         /* Transfer size in WORDS (for UYVY format only) */
         val = sd->gspca_dev.width * sd->gspca_dev.height;
-        ret += reg_w(sd, 0x3d, val & 0xffff); /* low bits */
-        ret += reg_w(sd, 0x3e, val >> 16);    /* high bits */
+        reg_w(sd, 0x3d, val & 0xffff); /* low bits */
+        reg_w(sd, 0x3e, val >> 16);    /* high bits */
 
         if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
             V4L2_PIX_FMT_JPEG) {
@@ -508,7 +473,7 @@ static int w9968cf_mode_init_regs(struct sd *sd)
                 jpeg_define(sd->jpeg_hdr, sd->gspca_dev.height,
                             sd->gspca_dev.width, 0x22); /* JPEG 420 */
                 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
-                ret += w9968cf_upload_quantizationtables(sd);
+                w9968cf_upload_quantizationtables(sd);
         }
 
         /* Video Capture Control Register */
@@ -540,19 +505,15 @@ static int w9968cf_mode_init_regs(struct sd *sd)
 
         val |= 0x8000; /* capt. enable */
 
-        ret += reg_w(sd, 0x16, val);
+        reg_w(sd, 0x16, val);
 
         sd->gspca_dev.empty_packet = 0;
-
-        return ret;
 }
 
 static void w9968cf_stop0(struct sd *sd)
 {
-        if (sd->gspca_dev.present) {
-                reg_w(sd, 0x39, 0x0000); /* disable JPEG encoder */
-                reg_w(sd, 0x16, 0x0000); /* stop video capture */
-        }
+        reg_w(sd, 0x39, 0x0000); /* disable JPEG encoder */
+        reg_w(sd, 0x16, 0x0000); /* stop video capture */
 }
 
 /* The w9968cf docs say that a 0 sized packet means EOF (and also SOF
diff --git a/drivers/media/video/gspca/xirlink_cit.c b/drivers/media/video/gspca/xirlink_cit.c
new file mode 100644
index 000000000000..c089a0f6f1d0
--- /dev/null
+++ b/drivers/media/video/gspca/xirlink_cit.c
@@ -0,0 +1,3337 @@
+/*
+ * USB IBM C-It Video Camera driver
+ *
+ * Supports Xirlink C-It Video Camera, IBM PC Camera,
+ * IBM NetCamera and Veo Stingray.
+ *
+ * Copyright (C) 2010 Hans de Goede <hdegoede@redhat.com>
+ *
+ * This driver is based on earlier work of:
+ *
+ * (C) Copyright 1999 Johannes Erdfelt
+ * (C) Copyright 1999 Randy Dunlap
+ *
+ * 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 "xirlink-cit"
+
+#include <linux/input.h>
+#include "gspca.h"
+
+MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
+MODULE_DESCRIPTION("Xirlink C-IT");
+MODULE_LICENSE("GPL");
+
+/* FIXME we should autodetect this */
+static int ibm_netcam_pro;
+module_param(ibm_netcam_pro, int, 0);
+MODULE_PARM_DESC(ibm_netcam_pro,
+                 "Use IBM Netcamera Pro init sequences for Model 3 cams");
+
+/* FIXME this should be handled through the V4L2 input selection API */
+static int rca_input;
+module_param(rca_input, int, 0644);
+MODULE_PARM_DESC(rca_input,
+                 "Use rca input instead of ccd sensor on Model 3 cams");
+
+/* specific webcam descriptor */
+struct sd {
+        struct gspca_dev gspca_dev;             /* !! must be the first item */
+        u8 model;
+#define CIT_MODEL0 0 /* bcd version 0.01 cams ie the xvp-500 */
+#define CIT_MODEL1 1 /* The model 1 - 4 nomenclature comes from the old */
+#define CIT_MODEL2 2 /* ibmcam driver */
+#define CIT_MODEL3 3
+#define CIT_MODEL4 4
+#define CIT_IBM_NETCAM_PRO 5
+        u8 input_index;
+        u8 button_state;
+        u8 stop_on_control_change;
+        u8 sof_read;
+        u8 sof_len;
+        u8 contrast;
+        u8 brightness;
+        u8 hue;
+        u8 sharpness;
+        u8 lighting;
+        u8 hflip;
+};
+
+/* 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_sethue(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_gethue(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_setlighting(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getlighting(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 void sd_stop0(struct gspca_dev *gspca_dev);
+
+static const struct ctrl sd_ctrls[] = {
+#define SD_BRIGHTNESS 0
+        {
+            {
+                .id      = V4L2_CID_BRIGHTNESS,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Brightness",
+                .minimum = 0,
+                .maximum = 63,
+                .step = 1,
+#define BRIGHTNESS_DEFAULT 32
+                .default_value = BRIGHTNESS_DEFAULT,
+                .flags = 0,
+            },
+            .set = sd_setbrightness,
+            .get = sd_getbrightness,
+        },
+#define SD_CONTRAST 1
+        {
+            {
+                .id = V4L2_CID_CONTRAST,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "contrast",
+                .minimum = 0,
+                .maximum = 20,
+                .step = 1,
+#define CONTRAST_DEFAULT 10
+                .default_value = CONTRAST_DEFAULT,
+                .flags = 0,
+            },
+            .set = sd_setcontrast,
+            .get = sd_getcontrast,
+        },
+#define SD_HUE 2
+        {
+            {
+                .id     = V4L2_CID_HUE,
+                .type   = V4L2_CTRL_TYPE_INTEGER,
+                .name   = "Hue",
+                .minimum = 0,
+                .maximum = 127,
+                .step   = 1,
+#define HUE_DEFAULT 63
+                .default_value = HUE_DEFAULT,
+                .flags = 0,
+            },
+            .set = sd_sethue,
+            .get = sd_gethue,
+        },
+#define SD_SHARPNESS 3
+        {
+            {
+                .id = V4L2_CID_SHARPNESS,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Sharpness",
+                .minimum = 0,
+                .maximum = 6,
+                .step = 1,
+#define SHARPNESS_DEFAULT 3
+                .default_value = SHARPNESS_DEFAULT,
+                .flags = 0,
+            },
+            .set = sd_setsharpness,
+            .get = sd_getsharpness,
+        },
+#define SD_LIGHTING 4
+        {
+            {
+                .id = V4L2_CID_BACKLIGHT_COMPENSATION,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Lighting",
+                .minimum = 0,
+                .maximum = 2,
+                .step = 1,
+#define LIGHTING_DEFAULT 1
+                .default_value = LIGHTING_DEFAULT,
+                .flags = 0,
+            },
+            .set = sd_setlighting,
+            .get = sd_getlighting,
+        },
+#define SD_HFLIP 5
+        {
+            {
+                .id      = V4L2_CID_HFLIP,
+                .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                .name    = "Mirror",
+                .minimum = 0,
+                .maximum = 1,
+                .step    = 1,
+#define HFLIP_DEFAULT 0
+                .default_value = HFLIP_DEFAULT,
+            },
+            .set = sd_sethflip,
+            .get = sd_gethflip,
+        },
+};
+
+static const struct v4l2_pix_format cif_yuv_mode[] = {
+        {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
+                .bytesperline = 176,
+                .sizeimage = 176 * 144 * 3 / 2 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+        {352, 288, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
+                .bytesperline = 352,
+                .sizeimage = 352 * 288 * 3 / 2 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+};
+
+static const struct v4l2_pix_format vga_yuv_mode[] = {
+        {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
+                .bytesperline = 160,
+                .sizeimage = 160 * 120 * 3 / 2 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+        {320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 3 / 2 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+        {640, 480, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480 * 3 / 2 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+};
+
+static const struct v4l2_pix_format model0_mode[] = {
+        {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
+                .bytesperline = 160,
+                .sizeimage = 160 * 120 * 3 / 2 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+        {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
+                .bytesperline = 176,
+                .sizeimage = 176 * 144 * 3 / 2 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+        {320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 3 / 2 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+};
+
+static const struct v4l2_pix_format model2_mode[] = {
+        {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
+                .bytesperline = 160,
+                .sizeimage = 160 * 120 * 3 / 2 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+        {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
+                .bytesperline = 176,
+                .sizeimage = 176 * 144 * 3 / 2 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+        {320, 240, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+        {352, 288, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
+                .bytesperline = 352,
+                .sizeimage = 352 * 288 + 4,
+                .colorspace = V4L2_COLORSPACE_SRGB},
+};
+
+/*
+ * 01.01.08 - Added for RCA video in support -LO
+ * This struct is used to init the Model3 cam to use the RCA video in port
+ * instead of the CCD sensor.
+ */
+static const u16 rca_initdata[][3] = {
+        {0, 0x0000, 0x010c},
+        {0, 0x0006, 0x012c},
+        {0, 0x0078, 0x012d},
+        {0, 0x0046, 0x012f},
+        {0, 0xd141, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfea8, 0x0124},
+        {1, 0x0000, 0x0116},
+        {0, 0x0064, 0x0116},
+        {1, 0x0000, 0x0115},
+        {0, 0x0003, 0x0115},
+        {0, 0x0008, 0x0123},
+        {0, 0x0000, 0x0117},
+        {0, 0x0000, 0x0112},
+        {0, 0x0080, 0x0100},
+        {0, 0x0000, 0x0100},
+        {1, 0x0000, 0x0116},
+        {0, 0x0060, 0x0116},
+        {0, 0x0002, 0x0112},
+        {0, 0x0000, 0x0123},
+        {0, 0x0001, 0x0117},
+        {0, 0x0040, 0x0108},
+        {0, 0x0019, 0x012c},
+        {0, 0x0040, 0x0116},
+        {0, 0x000a, 0x0115},
+        {0, 0x000b, 0x0115},
+        {0, 0x0078, 0x012d},
+        {0, 0x0046, 0x012f},
+        {0, 0xd141, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfea8, 0x0124},
+        {0, 0x0064, 0x0116},
+        {0, 0x0000, 0x0115},
+        {0, 0x0001, 0x0115},
+        {0, 0xffff, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x00aa, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xffff, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x00f2, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x000f, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xffff, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x00f8, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x00fc, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xffff, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x00f9, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x003c, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xffff, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0027, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0019, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0021, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0006, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0045, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x002a, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x000e, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x002b, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x00f4, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x002c, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0004, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x002d, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0014, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x002e, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0003, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x002f, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0003, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0014, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0040, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0040, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0053, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0x0000, 0x0101},
+        {0, 0x00a0, 0x0103},
+        {0, 0x0078, 0x0105},
+        {0, 0x0000, 0x010a},
+        {0, 0x0024, 0x010b},
+        {0, 0x0028, 0x0119},
+        {0, 0x0088, 0x011b},
+        {0, 0x0002, 0x011d},
+        {0, 0x0003, 0x011e},
+        {0, 0x0000, 0x0129},
+        {0, 0x00fc, 0x012b},
+        {0, 0x0008, 0x0102},
+        {0, 0x0000, 0x0104},
+        {0, 0x0008, 0x011a},
+        {0, 0x0028, 0x011c},
+        {0, 0x0021, 0x012a},
+        {0, 0x0000, 0x0118},
+        {0, 0x0000, 0x0132},
+        {0, 0x0000, 0x0109},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0031, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0040, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0040, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x00dc, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0032, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0020, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0001, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0040, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0040, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0037, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0030, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0xfff9, 0x0124},
+        {0, 0x0086, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0038, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0008, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0x0000, 0x0127},
+        {0, 0xfff8, 0x0124},
+        {0, 0xfffd, 0x0124},
+        {0, 0xfffa, 0x0124},
+        {0, 0x0003, 0x0111},
+};
+
+/* TESTME the old ibmcam driver repeats certain commands to Model1 cameras, we
+   do the same for now (testing needed to see if this is really necessary) */
+static const int cit_model1_ntries = 5;
+static const int cit_model1_ntries2 = 2;
+
+static int cit_write_reg(struct gspca_dev *gspca_dev, u16 value, u16 index)
+{
+        struct usb_device *udev = gspca_dev->dev;
+        int err;
+
+        err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x00,
+                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
+                        value, index, NULL, 0, 1000);
+        if (err < 0)
+                err("Failed to write a register (index 0x%04X,"
+                        " value 0x%02X, error %d)", index, value, err);
+
+        return 0;
+}
+
+static int cit_read_reg(struct gspca_dev *gspca_dev, u16 index, int verbose)
+{
+        struct usb_device *udev = gspca_dev->dev;
+        __u8 *buf = gspca_dev->usb_buf;
+        int res;
+
+        res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01,
+                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
+                        0x00, index, buf, 8, 1000);
+        if (res < 0) {
+                err("Failed to read a register (index 0x%04X, error %d)",
+                        index, res);
+                return res;
+        }
+
+        if (verbose)
+                PDEBUG(D_PROBE, "Register %04x value: %02x", index, buf[0]);
+
+        return 0;
+}
+
+/*
+ * cit_send_FF_04_02()
+ *
+ * This procedure sends magic 3-command prefix to the camera.
+ * The purpose of this prefix is not known.
+ *
+ * History:
+ * 1/2/00   Created.
+ */
+static void cit_send_FF_04_02(struct gspca_dev *gspca_dev)
+{
+        cit_write_reg(gspca_dev, 0x00FF, 0x0127);
+        cit_write_reg(gspca_dev, 0x0004, 0x0124);
+        cit_write_reg(gspca_dev, 0x0002, 0x0124);
+}
+
+static void cit_send_00_04_06(struct gspca_dev *gspca_dev)
+{
+        cit_write_reg(gspca_dev, 0x0000, 0x0127);
+        cit_write_reg(gspca_dev, 0x0004, 0x0124);
+        cit_write_reg(gspca_dev, 0x0006, 0x0124);
+}
+
+static void cit_send_x_00(struct gspca_dev *gspca_dev, unsigned short x)
+{
+        cit_write_reg(gspca_dev, x,      0x0127);
+        cit_write_reg(gspca_dev, 0x0000, 0x0124);
+}
+
+static void cit_send_x_00_05(struct gspca_dev *gspca_dev, unsigned short x)
+{
+        cit_send_x_00(gspca_dev, x);
+        cit_write_reg(gspca_dev, 0x0005, 0x0124);
+}
+
+static void cit_send_x_00_05_02(struct gspca_dev *gspca_dev, unsigned short x)
+{
+        cit_write_reg(gspca_dev, x,      0x0127);
+        cit_write_reg(gspca_dev, 0x0000, 0x0124);
+        cit_write_reg(gspca_dev, 0x0005, 0x0124);
+        cit_write_reg(gspca_dev, 0x0002, 0x0124);
+}
+
+static void cit_send_x_01_00_05(struct gspca_dev *gspca_dev, u16 x)
+{
+        cit_write_reg(gspca_dev, x,      0x0127);
+        cit_write_reg(gspca_dev, 0x0001, 0x0124);
+        cit_write_reg(gspca_dev, 0x0000, 0x0124);
+        cit_write_reg(gspca_dev, 0x0005, 0x0124);
+}
+
+static void cit_send_x_00_05_02_01(struct gspca_dev *gspca_dev, u16 x)
+{
+        cit_write_reg(gspca_dev, x,      0x0127);
+        cit_write_reg(gspca_dev, 0x0000, 0x0124);
+        cit_write_reg(gspca_dev, 0x0005, 0x0124);
+        cit_write_reg(gspca_dev, 0x0002, 0x0124);
+        cit_write_reg(gspca_dev, 0x0001, 0x0124);
+}
+
+static void cit_send_x_00_05_02_08_01(struct gspca_dev *gspca_dev, u16 x)
+{
+        cit_write_reg(gspca_dev, x,      0x0127);
+        cit_write_reg(gspca_dev, 0x0000, 0x0124);
+        cit_write_reg(gspca_dev, 0x0005, 0x0124);
+        cit_write_reg(gspca_dev, 0x0002, 0x0124);
+        cit_write_reg(gspca_dev, 0x0008, 0x0124);
+        cit_write_reg(gspca_dev, 0x0001, 0x0124);
+}
+
+static void cit_Packet_Format1(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
+{
+        cit_send_x_01_00_05(gspca_dev, 0x0088);
+        cit_send_x_00_05(gspca_dev, fkey);
+        cit_send_x_00_05_02_08_01(gspca_dev, val);
+        cit_send_x_00_05(gspca_dev, 0x0088);
+        cit_send_x_00_05_02_01(gspca_dev, fkey);
+        cit_send_x_00_05(gspca_dev, 0x0089);
+        cit_send_x_00(gspca_dev, fkey);
+        cit_send_00_04_06(gspca_dev);
+        cit_read_reg(gspca_dev, 0x0126, 0);
+        cit_send_FF_04_02(gspca_dev);
+}
+
+static void cit_PacketFormat2(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
+{
+        cit_send_x_01_00_05(gspca_dev, 0x0088);
+        cit_send_x_00_05(gspca_dev, fkey);
+        cit_send_x_00_05_02(gspca_dev, val);
+}
+
+static void cit_model2_Packet2(struct gspca_dev *gspca_dev)
+{
+        cit_write_reg(gspca_dev, 0x00ff, 0x012d);
+        cit_write_reg(gspca_dev, 0xfea3, 0x0124);
+}
+
+static void cit_model2_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
+{
+        cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+        cit_write_reg(gspca_dev, 0x00ff, 0x012e);
+        cit_write_reg(gspca_dev, v1,     0x012f);
+        cit_write_reg(gspca_dev, 0x00ff, 0x0130);
+        cit_write_reg(gspca_dev, 0xc719, 0x0124);
+        cit_write_reg(gspca_dev, v2,     0x0127);
+
+        cit_model2_Packet2(gspca_dev);
+}
+
+/*
+ * cit_model3_Packet1()
+ *
+ * 00_0078_012d
+ * 00_0097_012f
+ * 00_d141_0124
+ * 00_0096_0127
+ * 00_fea8_0124
+*/
+static void cit_model3_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
+{
+        cit_write_reg(gspca_dev, 0x0078, 0x012d);
+        cit_write_reg(gspca_dev, v1,     0x012f);
+        cit_write_reg(gspca_dev, 0xd141, 0x0124);
+        cit_write_reg(gspca_dev, v2,     0x0127);
+        cit_write_reg(gspca_dev, 0xfea8, 0x0124);
+}
+
+static void cit_model4_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
+{
+        cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+        cit_write_reg(gspca_dev, v1,     0x012f);
+        cit_write_reg(gspca_dev, 0xd141, 0x0124);
+        cit_write_reg(gspca_dev, v2,     0x0127);
+        cit_write_reg(gspca_dev, 0xfea8, 0x0124);
+}
+
+static void cit_model4_BrightnessPacket(struct gspca_dev *gspca_dev, u16 val)
+{
+        cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+        cit_write_reg(gspca_dev, 0x0026, 0x012f);
+        cit_write_reg(gspca_dev, 0xd141, 0x0124);
+        cit_write_reg(gspca_dev, val,    0x0127);
+        cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+        cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+        cit_write_reg(gspca_dev, 0x0038, 0x012d);
+        cit_write_reg(gspca_dev, 0x0004, 0x012f);
+        cit_write_reg(gspca_dev, 0xd145, 0x0124);
+        cit_write_reg(gspca_dev, 0xfffa, 0x0124);
+}
+
+/* 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;
+
+        sd->model = id->driver_info;
+        if (sd->model == CIT_MODEL3 && ibm_netcam_pro)
+                sd->model = CIT_IBM_NETCAM_PRO;
+
+        cam = &gspca_dev->cam;
+        switch (sd->model) {
+        case CIT_MODEL0:
+                cam->cam_mode = model0_mode;
+                cam->nmodes = ARRAY_SIZE(model0_mode);
+                cam->reverse_alts = 1;
+                gspca_dev->ctrl_dis = ~((1 << SD_CONTRAST) | (1 << SD_HFLIP));
+                sd->sof_len = 4;
+                break;
+        case CIT_MODEL1:
+                cam->cam_mode = cif_yuv_mode;
+                cam->nmodes = ARRAY_SIZE(cif_yuv_mode);
+                cam->reverse_alts = 1;
+                gspca_dev->ctrl_dis = (1 << SD_HUE) | (1 << SD_HFLIP);
+                sd->sof_len = 4;
+                break;
+        case CIT_MODEL2:
+                cam->cam_mode = model2_mode + 1; /* no 160x120 */
+                cam->nmodes = 3;
+                gspca_dev->ctrl_dis = (1 << SD_CONTRAST) |
+                                      (1 << SD_SHARPNESS) |
+                                      (1 << SD_HFLIP);
+                break;
+        case CIT_MODEL3:
+                cam->cam_mode = vga_yuv_mode;
+                cam->nmodes = ARRAY_SIZE(vga_yuv_mode);
+                gspca_dev->ctrl_dis = (1 << SD_HUE) |
+                                      (1 << SD_LIGHTING) |
+                                      (1 << SD_HFLIP);
+                sd->stop_on_control_change = 1;
+                sd->sof_len = 4;
+                break;
+        case CIT_MODEL4:
+                cam->cam_mode = model2_mode;
+                cam->nmodes = ARRAY_SIZE(model2_mode);
+                gspca_dev->ctrl_dis = (1 << SD_CONTRAST) |
+                                      (1 << SD_SHARPNESS) |
+                                      (1 << SD_LIGHTING) |
+                                      (1 << SD_HFLIP);
+                break;
+        case CIT_IBM_NETCAM_PRO:
+                cam->cam_mode = vga_yuv_mode;
+                cam->nmodes = 2; /* no 640 x 480 */
+                cam->input_flags = V4L2_IN_ST_VFLIP;
+                gspca_dev->ctrl_dis = ~(1 << SD_CONTRAST);
+                sd->stop_on_control_change = 1;
+                sd->sof_len = 4;
+                break;
+        }
+
+        sd->brightness = BRIGHTNESS_DEFAULT;
+        sd->contrast = CONTRAST_DEFAULT;
+        sd->hue = HUE_DEFAULT;
+        sd->sharpness = SHARPNESS_DEFAULT;
+        sd->lighting = LIGHTING_DEFAULT;
+        sd->hflip = HFLIP_DEFAULT;
+
+        return 0;
+}
+
+static int cit_init_model0(struct gspca_dev *gspca_dev)
+{
+        cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
+        cit_write_reg(gspca_dev, 0x0001, 0x0112); /* turn on autogain ? */
+        cit_write_reg(gspca_dev, 0x0000, 0x0400);
+        cit_write_reg(gspca_dev, 0x0001, 0x0400);
+        cit_write_reg(gspca_dev, 0x0000, 0x0420);
+        cit_write_reg(gspca_dev, 0x0001, 0x0420);
+        cit_write_reg(gspca_dev, 0x000d, 0x0409);
+        cit_write_reg(gspca_dev, 0x0002, 0x040a);
+        cit_write_reg(gspca_dev, 0x0018, 0x0405);
+        cit_write_reg(gspca_dev, 0x0008, 0x0435);
+        cit_write_reg(gspca_dev, 0x0026, 0x040b);
+        cit_write_reg(gspca_dev, 0x0007, 0x0437);
+        cit_write_reg(gspca_dev, 0x0015, 0x042f);
+        cit_write_reg(gspca_dev, 0x002b, 0x0439);
+        cit_write_reg(gspca_dev, 0x0026, 0x043a);
+        cit_write_reg(gspca_dev, 0x0008, 0x0438);
+        cit_write_reg(gspca_dev, 0x001e, 0x042b);
+        cit_write_reg(gspca_dev, 0x0041, 0x042c);
+
+        return 0;
+}
+
+static int cit_init_ibm_netcam_pro(struct gspca_dev *gspca_dev)
+{
+        cit_read_reg(gspca_dev, 0x128, 1);
+        cit_write_reg(gspca_dev, 0x0003, 0x0133);
+        cit_write_reg(gspca_dev, 0x0000, 0x0117);
+        cit_write_reg(gspca_dev, 0x0008, 0x0123);
+        cit_write_reg(gspca_dev, 0x0000, 0x0100);
+        cit_read_reg(gspca_dev, 0x0116, 0);
+        cit_write_reg(gspca_dev, 0x0060, 0x0116);
+        cit_write_reg(gspca_dev, 0x0002, 0x0112);
+        cit_write_reg(gspca_dev, 0x0000, 0x0133);
+        cit_write_reg(gspca_dev, 0x0000, 0x0123);
+        cit_write_reg(gspca_dev, 0x0001, 0x0117);
+        cit_write_reg(gspca_dev, 0x0040, 0x0108);
+        cit_write_reg(gspca_dev, 0x0019, 0x012c);
+        cit_write_reg(gspca_dev, 0x0060, 0x0116);
+        cit_write_reg(gspca_dev, 0x0002, 0x0115);
+        cit_write_reg(gspca_dev, 0x000b, 0x0115);
+
+        cit_write_reg(gspca_dev, 0x0078, 0x012d);
+        cit_write_reg(gspca_dev, 0x0001, 0x012f);
+        cit_write_reg(gspca_dev, 0xd141, 0x0124);
+        cit_write_reg(gspca_dev, 0x0079, 0x012d);
+        cit_write_reg(gspca_dev, 0x00ff, 0x0130);
+        cit_write_reg(gspca_dev, 0xcd41, 0x0124);
+        cit_write_reg(gspca_dev, 0xfffa, 0x0124);
+        cit_read_reg(gspca_dev, 0x0126, 1);
+
+        cit_model3_Packet1(gspca_dev, 0x0000, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0000, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x000b, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x000c, 0x0008);
+        cit_model3_Packet1(gspca_dev, 0x000d, 0x003a);
+        cit_model3_Packet1(gspca_dev, 0x000e, 0x0060);
+        cit_model3_Packet1(gspca_dev, 0x000f, 0x0060);
+        cit_model3_Packet1(gspca_dev, 0x0010, 0x0008);
+        cit_model3_Packet1(gspca_dev, 0x0011, 0x0004);
+        cit_model3_Packet1(gspca_dev, 0x0012, 0x0028);
+        cit_model3_Packet1(gspca_dev, 0x0013, 0x0002);
+        cit_model3_Packet1(gspca_dev, 0x0014, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0015, 0x00fb);
+        cit_model3_Packet1(gspca_dev, 0x0016, 0x0002);
+        cit_model3_Packet1(gspca_dev, 0x0017, 0x0037);
+        cit_model3_Packet1(gspca_dev, 0x0018, 0x0036);
+        cit_model3_Packet1(gspca_dev, 0x001e, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x001f, 0x0008);
+        cit_model3_Packet1(gspca_dev, 0x0020, 0x00c1);
+        cit_model3_Packet1(gspca_dev, 0x0021, 0x0034);
+        cit_model3_Packet1(gspca_dev, 0x0022, 0x0034);
+        cit_model3_Packet1(gspca_dev, 0x0025, 0x0002);
+        cit_model3_Packet1(gspca_dev, 0x0028, 0x0022);
+        cit_model3_Packet1(gspca_dev, 0x0029, 0x000a);
+        cit_model3_Packet1(gspca_dev, 0x002b, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x002c, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x002d, 0x00ff);
+        cit_model3_Packet1(gspca_dev, 0x002e, 0x00ff);
+        cit_model3_Packet1(gspca_dev, 0x002f, 0x00ff);
+        cit_model3_Packet1(gspca_dev, 0x0030, 0x00ff);
+        cit_model3_Packet1(gspca_dev, 0x0031, 0x00ff);
+        cit_model3_Packet1(gspca_dev, 0x0032, 0x0007);
+        cit_model3_Packet1(gspca_dev, 0x0033, 0x0005);
+        cit_model3_Packet1(gspca_dev, 0x0037, 0x0040);
+        cit_model3_Packet1(gspca_dev, 0x0039, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x003a, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x003b, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x003c, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0040, 0x000c);
+        cit_model3_Packet1(gspca_dev, 0x0041, 0x00fb);
+        cit_model3_Packet1(gspca_dev, 0x0042, 0x0002);
+        cit_model3_Packet1(gspca_dev, 0x0043, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0045, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0048, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0049, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x004a, 0x00ff);
+        cit_model3_Packet1(gspca_dev, 0x004b, 0x00ff);
+        cit_model3_Packet1(gspca_dev, 0x004c, 0x00ff);
+        cit_model3_Packet1(gspca_dev, 0x004f, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0050, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0051, 0x0002);
+        cit_model3_Packet1(gspca_dev, 0x0055, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0056, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0057, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0058, 0x0002);
+        cit_model3_Packet1(gspca_dev, 0x0059, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x005c, 0x0016);
+        cit_model3_Packet1(gspca_dev, 0x005d, 0x0022);
+        cit_model3_Packet1(gspca_dev, 0x005e, 0x003c);
+        cit_model3_Packet1(gspca_dev, 0x005f, 0x0050);
+        cit_model3_Packet1(gspca_dev, 0x0060, 0x0044);
+        cit_model3_Packet1(gspca_dev, 0x0061, 0x0005);
+        cit_model3_Packet1(gspca_dev, 0x006a, 0x007e);
+        cit_model3_Packet1(gspca_dev, 0x006f, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0072, 0x001b);
+        cit_model3_Packet1(gspca_dev, 0x0073, 0x0005);
+        cit_model3_Packet1(gspca_dev, 0x0074, 0x000a);
+        cit_model3_Packet1(gspca_dev, 0x0075, 0x001b);
+        cit_model3_Packet1(gspca_dev, 0x0076, 0x002a);
+        cit_model3_Packet1(gspca_dev, 0x0077, 0x003c);
+        cit_model3_Packet1(gspca_dev, 0x0078, 0x0050);
+        cit_model3_Packet1(gspca_dev, 0x007b, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x007c, 0x0011);
+        cit_model3_Packet1(gspca_dev, 0x007d, 0x0024);
+        cit_model3_Packet1(gspca_dev, 0x007e, 0x0043);
+        cit_model3_Packet1(gspca_dev, 0x007f, 0x005a);
+        cit_model3_Packet1(gspca_dev, 0x0084, 0x0020);
+        cit_model3_Packet1(gspca_dev, 0x0085, 0x0033);
+        cit_model3_Packet1(gspca_dev, 0x0086, 0x000a);
+        cit_model3_Packet1(gspca_dev, 0x0087, 0x0030);
+        cit_model3_Packet1(gspca_dev, 0x0088, 0x0070);
+        cit_model3_Packet1(gspca_dev, 0x008b, 0x0008);
+        cit_model3_Packet1(gspca_dev, 0x008f, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0090, 0x0006);
+        cit_model3_Packet1(gspca_dev, 0x0091, 0x0028);
+        cit_model3_Packet1(gspca_dev, 0x0092, 0x005a);
+        cit_model3_Packet1(gspca_dev, 0x0093, 0x0082);
+        cit_model3_Packet1(gspca_dev, 0x0096, 0x0014);
+        cit_model3_Packet1(gspca_dev, 0x0097, 0x0020);
+        cit_model3_Packet1(gspca_dev, 0x0098, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00b0, 0x0046);
+        cit_model3_Packet1(gspca_dev, 0x00b1, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00b2, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00b3, 0x0004);
+        cit_model3_Packet1(gspca_dev, 0x00b4, 0x0007);
+        cit_model3_Packet1(gspca_dev, 0x00b6, 0x0002);
+        cit_model3_Packet1(gspca_dev, 0x00b7, 0x0004);
+        cit_model3_Packet1(gspca_dev, 0x00bb, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00bc, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x00bd, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00bf, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00c0, 0x00c8);
+        cit_model3_Packet1(gspca_dev, 0x00c1, 0x0014);
+        cit_model3_Packet1(gspca_dev, 0x00c2, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x00c3, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00c4, 0x0004);
+        cit_model3_Packet1(gspca_dev, 0x00cb, 0x00bf);
+        cit_model3_Packet1(gspca_dev, 0x00cc, 0x00bf);
+        cit_model3_Packet1(gspca_dev, 0x00cd, 0x00bf);
+        cit_model3_Packet1(gspca_dev, 0x00ce, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00cf, 0x0020);
+        cit_model3_Packet1(gspca_dev, 0x00d0, 0x0040);
+        cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf);
+        cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf);
+        cit_model3_Packet1(gspca_dev, 0x00d2, 0x00bf);
+        cit_model3_Packet1(gspca_dev, 0x00d3, 0x00bf);
+        cit_model3_Packet1(gspca_dev, 0x00ea, 0x0008);
+        cit_model3_Packet1(gspca_dev, 0x00eb, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00ec, 0x00e8);
+        cit_model3_Packet1(gspca_dev, 0x00ed, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x00ef, 0x0022);
+        cit_model3_Packet1(gspca_dev, 0x00f0, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00f2, 0x0028);
+        cit_model3_Packet1(gspca_dev, 0x00f4, 0x0002);
+        cit_model3_Packet1(gspca_dev, 0x00f5, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00fa, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00fb, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x00fc, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00fd, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00fe, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00ff, 0x0000);
+
+        cit_model3_Packet1(gspca_dev, 0x00be, 0x0003);
+        cit_model3_Packet1(gspca_dev, 0x00c8, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00c9, 0x0020);
+        cit_model3_Packet1(gspca_dev, 0x00ca, 0x0040);
+        cit_model3_Packet1(gspca_dev, 0x0053, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x0082, 0x000e);
+        cit_model3_Packet1(gspca_dev, 0x0083, 0x0020);
+        cit_model3_Packet1(gspca_dev, 0x0034, 0x003c);
+        cit_model3_Packet1(gspca_dev, 0x006e, 0x0055);
+        cit_model3_Packet1(gspca_dev, 0x0062, 0x0005);
+        cit_model3_Packet1(gspca_dev, 0x0063, 0x0008);
+        cit_model3_Packet1(gspca_dev, 0x0066, 0x000a);
+        cit_model3_Packet1(gspca_dev, 0x0067, 0x0006);
+        cit_model3_Packet1(gspca_dev, 0x006b, 0x0010);
+        cit_model3_Packet1(gspca_dev, 0x005a, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x005b, 0x000a);
+        cit_model3_Packet1(gspca_dev, 0x0023, 0x0006);
+        cit_model3_Packet1(gspca_dev, 0x0026, 0x0004);
+        cit_model3_Packet1(gspca_dev, 0x0036, 0x0069);
+        cit_model3_Packet1(gspca_dev, 0x0038, 0x0064);
+        cit_model3_Packet1(gspca_dev, 0x003d, 0x0003);
+        cit_model3_Packet1(gspca_dev, 0x003e, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x00b8, 0x0014);
+        cit_model3_Packet1(gspca_dev, 0x00b9, 0x0014);
+        cit_model3_Packet1(gspca_dev, 0x00e6, 0x0004);
+        cit_model3_Packet1(gspca_dev, 0x00e8, 0x0001);
+
+        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;
+
+        switch (sd->model) {
+        case CIT_MODEL0:
+                cit_init_model0(gspca_dev);
+                sd_stop0(gspca_dev);
+                break;
+        case CIT_MODEL1:
+        case CIT_MODEL2:
+        case CIT_MODEL3:
+        case CIT_MODEL4:
+                break; /* All is done in sd_start */
+        case CIT_IBM_NETCAM_PRO:
+                cit_init_ibm_netcam_pro(gspca_dev);
+                sd_stop0(gspca_dev);
+                break;
+        }
+        return 0;
+}
+
+static int cit_set_brightness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int i;
+
+        switch (sd->model) {
+        case CIT_MODEL0:
+        case CIT_IBM_NETCAM_PRO:
+                /* No (known) brightness control for these */
+                break;
+        case CIT_MODEL1:
+                /* Model 1: Brightness range 0 - 63 */
+                cit_Packet_Format1(gspca_dev, 0x0031, sd->brightness);
+                cit_Packet_Format1(gspca_dev, 0x0032, sd->brightness);
+                cit_Packet_Format1(gspca_dev, 0x0033, sd->brightness);
+                break;
+        case CIT_MODEL2:
+                /* Model 2: Brightness range 0x60 - 0xee */
+                /* Scale 0 - 63 to 0x60 - 0xee */
+                i = 0x60 + sd->brightness * 2254 / 1000;
+                cit_model2_Packet1(gspca_dev, 0x001a, i);
+                break;
+        case CIT_MODEL3:
+                /* Model 3: Brightness range 'i' in [0x0C..0x3F] */
+                i = sd->brightness;
+                if (i < 0x0c)
+                        i = 0x0c;
+                cit_model3_Packet1(gspca_dev, 0x0036, i);
+                break;
+        case CIT_MODEL4:
+                /* Model 4: Brightness range 'i' in [0x04..0xb4] */
+                /* Scale 0 - 63 to 0x04 - 0xb4 */
+                i = 0x04 + sd->brightness * 2794 / 1000;
+                cit_model4_BrightnessPacket(gspca_dev, i);
+                break;
+        }
+
+        return 0;
+}
+
+static int cit_set_contrast(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        switch (sd->model) {
+        case CIT_MODEL0: {
+                int i;
+                /* gain 0-15, 0-20 -> 0-15 */
+                i = sd->contrast * 1000 / 1333;
+                cit_write_reg(gspca_dev, i, 0x0422);
+                /* gain 0-31, may not be lower then 0x0422, 0-20 -> 0-31 */
+                i = sd->contrast * 2000 / 1333;
+                cit_write_reg(gspca_dev, i, 0x0423);
+                /* gain 0-127, may not be lower then 0x0423, 0-20 -> 0-63  */
+                i = sd->contrast * 4000 / 1333;
+                cit_write_reg(gspca_dev, i, 0x0424);
+                /* gain 0-127, may not be lower then 0x0424, , 0-20 -> 0-127 */
+                i = sd->contrast * 8000 / 1333;
+                cit_write_reg(gspca_dev, i, 0x0425);
+                break;
+        }
+        case CIT_MODEL2:
+        case CIT_MODEL4:
+                /* These models do not have this control. */
+                break;
+        case CIT_MODEL1:
+        {
+                /* Scale 0 - 20 to 15 - 0 */
+                int i, new_contrast = (20 - sd->contrast) * 1000 / 1333;
+                for (i = 0; i < cit_model1_ntries; i++) {
+                        cit_Packet_Format1(gspca_dev, 0x0014, new_contrast);
+                        cit_send_FF_04_02(gspca_dev);
+                }
+                break;
+        }
+        case CIT_MODEL3:
+        {       /* Preset hardware values */
+                static const struct {
+                        unsigned short cv1;
+                        unsigned short cv2;
+                        unsigned short cv3;
+                } cv[7] = {
+                        { 0x05, 0x05, 0x0f },   /* Minimum */
+                        { 0x04, 0x04, 0x16 },
+                        { 0x02, 0x03, 0x16 },
+                        { 0x02, 0x08, 0x16 },
+                        { 0x01, 0x0c, 0x16 },
+                        { 0x01, 0x0e, 0x16 },
+                        { 0x01, 0x10, 0x16 }    /* Maximum */
+                };
+                int i = sd->contrast / 3;
+                cit_model3_Packet1(gspca_dev, 0x0067, cv[i].cv1);
+                cit_model3_Packet1(gspca_dev, 0x005b, cv[i].cv2);
+                cit_model3_Packet1(gspca_dev, 0x005c, cv[i].cv3);
+                break;
+        }
+        case CIT_IBM_NETCAM_PRO:
+                cit_model3_Packet1(gspca_dev, 0x005b, sd->contrast + 1);
+                break;
+        }
+        return 0;
+}
+
+static int cit_set_hue(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        switch (sd->model) {
+        case CIT_MODEL0:
+        case CIT_MODEL1:
+        case CIT_IBM_NETCAM_PRO:
+                /* No hue control for these models */
+                break;
+        case CIT_MODEL2:
+                cit_model2_Packet1(gspca_dev, 0x0024, sd->hue);
+                /* cit_model2_Packet1(gspca_dev, 0x0020, sat); */
+                break;
+        case CIT_MODEL3: {
+                /* Model 3: Brightness range 'i' in [0x05..0x37] */
+                /* TESTME according to the ibmcam driver this does not work */
+                if (0) {
+                        /* Scale 0 - 127 to 0x05 - 0x37 */
+                        int i = 0x05 + sd->hue * 1000 / 2540;
+                        cit_model3_Packet1(gspca_dev, 0x007e, i);
+                }
+                break;
+        }
+        case CIT_MODEL4:
+                /* HDG: taken from ibmcam, setting the color gains does not
+                 * really belong here.
+                 *
+                 * I am not sure r/g/b_gain variables exactly control gain
+                 * of those channels. Most likely they subtly change some
+                 * very internal image processing settings in the camera.
+                 * In any case, here is what they do, and feel free to tweak:
+                 *
+                 * r_gain: seriously affects red gain
+                 * g_gain: seriously affects green gain
+                 * b_gain: seriously affects blue gain
+                 * hue: changes average color from violet (0) to red (0xFF)
+                 */
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x001e, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev,    160, 0x0127);  /* Green gain */
+                cit_write_reg(gspca_dev,    160, 0x012e);  /* Red gain */
+                cit_write_reg(gspca_dev,    160, 0x0130);  /* Blue gain */
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, sd->hue, 0x012d); /* Hue */
+                cit_write_reg(gspca_dev, 0xf545, 0x0124);
+                break;
+        }
+        return 0;
+}
+
+static int cit_set_sharpness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        switch (sd->model) {
+        case CIT_MODEL0:
+        case CIT_MODEL2:
+        case CIT_MODEL4:
+        case CIT_IBM_NETCAM_PRO:
+                /* These models do not have this control */
+                break;
+        case CIT_MODEL1: {
+                int i;
+                const unsigned short sa[] = {
+                        0x11, 0x13, 0x16, 0x18, 0x1a, 0x8, 0x0a };
+
+                for (i = 0; i < cit_model1_ntries; i++)
+                        cit_PacketFormat2(gspca_dev, 0x0013, sa[sd->sharpness]);
+                break;
+        }
+        case CIT_MODEL3:
+        {       /*
+                 * "Use a table of magic numbers.
+                 *  This setting doesn't really change much.
+                 *  But that's how Windows does it."
+                 */
+                static const struct {
+                        unsigned short sv1;
+                        unsigned short sv2;
+                        unsigned short sv3;
+                        unsigned short sv4;
+                } sv[7] = {
+                        { 0x00, 0x00, 0x05, 0x14 },     /* Smoothest */
+                        { 0x01, 0x04, 0x05, 0x14 },
+                        { 0x02, 0x04, 0x05, 0x14 },
+                        { 0x03, 0x04, 0x05, 0x14 },
+                        { 0x03, 0x05, 0x05, 0x14 },
+                        { 0x03, 0x06, 0x05, 0x14 },
+                        { 0x03, 0x07, 0x05, 0x14 }      /* Sharpest */
+                };
+                cit_model3_Packet1(gspca_dev, 0x0060, sv[sd->sharpness].sv1);
+                cit_model3_Packet1(gspca_dev, 0x0061, sv[sd->sharpness].sv2);
+                cit_model3_Packet1(gspca_dev, 0x0062, sv[sd->sharpness].sv3);
+                cit_model3_Packet1(gspca_dev, 0x0063, sv[sd->sharpness].sv4);
+                break;
+        }
+        }
+        return 0;
+}
+
+/*
+ * cit_set_lighting()
+ *
+ * Camera model 1:
+ * We have 3 levels of lighting conditions: 0=Bright, 1=Medium, 2=Low.
+ *
+ * Camera model 2:
+ * We have 16 levels of lighting, 0 for bright light and up to 15 for
+ * low light. But values above 5 or so are useless because camera is
+ * not really capable to produce anything worth viewing at such light.
+ * This setting may be altered only in certain camera state.
+ *
+ * Low lighting forces slower FPS.
+ *
+ * History:
+ * 1/5/00   Created.
+ * 2/20/00  Added support for Model 2 cameras.
+ */
+static void cit_set_lighting(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        switch (sd->model) {
+        case CIT_MODEL0:
+        case CIT_MODEL2:
+        case CIT_MODEL3:
+        case CIT_MODEL4:
+        case CIT_IBM_NETCAM_PRO:
+                break;
+        case CIT_MODEL1: {
+                int i;
+                for (i = 0; i < cit_model1_ntries; i++)
+                        cit_Packet_Format1(gspca_dev, 0x0027, sd->lighting);
+                break;
+        }
+        }
+}
+
+static void cit_set_hflip(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        switch (sd->model) {
+        case CIT_MODEL0:
+                if (sd->hflip)
+                        cit_write_reg(gspca_dev, 0x0020, 0x0115);
+                else
+                        cit_write_reg(gspca_dev, 0x0040, 0x0115);
+                break;
+        case CIT_MODEL1:
+        case CIT_MODEL2:
+        case CIT_MODEL3:
+        case CIT_MODEL4:
+        case CIT_IBM_NETCAM_PRO:
+                break;
+        }
+}
+
+static int cit_restart_stream(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        switch (sd->model) {
+        case CIT_MODEL0:
+        case CIT_MODEL1:
+                cit_write_reg(gspca_dev, 0x0001, 0x0114);
+                /* Fall through */
+        case CIT_MODEL2:
+        case CIT_MODEL4:
+                cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */
+                usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe);
+                break;
+        case CIT_MODEL3:
+        case CIT_IBM_NETCAM_PRO:
+                cit_write_reg(gspca_dev, 0x0001, 0x0114);
+                cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */
+                usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe);
+                /* Clear button events from while we were not streaming */
+                cit_write_reg(gspca_dev, 0x0001, 0x0113);
+                break;
+        }
+
+        sd->sof_read = 0;
+
+        return 0;
+}
+
+static int cit_get_packet_size(struct gspca_dev *gspca_dev)
+{
+        struct usb_host_interface *alt;
+        struct usb_interface *intf;
+
+        intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
+        alt = usb_altnum_to_altsetting(intf, gspca_dev->alt);
+        if (!alt) {
+                err("Couldn't get altsetting");
+                return -EIO;
+        }
+
+        return le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
+}
+
+/* Calculate the clockdiv giving us max fps given the available bandwidth */
+static int cit_get_clock_div(struct gspca_dev *gspca_dev)
+{
+        int clock_div = 7; /* 0=30 1=25 2=20 3=15 4=12 5=7.5 6=6 7=3fps ?? */
+        int fps[8] = { 30, 25, 20, 15, 12, 8, 6, 3 };
+        int packet_size;
+
+        packet_size = cit_get_packet_size(gspca_dev);
+        if (packet_size < 0)
+                return packet_size;
+
+        while (clock_div > 3 &&
+                        1000 * packet_size >
+                        gspca_dev->width * gspca_dev->height *
+                        fps[clock_div - 1] * 3 / 2)
+                clock_div--;
+
+        PDEBUG(D_PROBE,
+               "PacketSize: %d, res: %dx%d -> using clockdiv: %d (%d fps)",
+               packet_size, gspca_dev->width, gspca_dev->height, clock_div,
+               fps[clock_div]);
+
+        return clock_div;
+}
+
+static int cit_start_model0(struct gspca_dev *gspca_dev)
+{
+        const unsigned short compression = 0; /* 0=none, 7=best frame rate */
+        int clock_div;
+
+        clock_div = cit_get_clock_div(gspca_dev);
+        if (clock_div < 0)
+                return clock_div;
+
+        cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
+        cit_write_reg(gspca_dev, 0x0003, 0x0438);
+        cit_write_reg(gspca_dev, 0x001e, 0x042b);
+        cit_write_reg(gspca_dev, 0x0041, 0x042c);
+        cit_write_reg(gspca_dev, 0x0008, 0x0436);
+        cit_write_reg(gspca_dev, 0x0024, 0x0403);
+        cit_write_reg(gspca_dev, 0x002c, 0x0404);
+        cit_write_reg(gspca_dev, 0x0002, 0x0426);
+        cit_write_reg(gspca_dev, 0x0014, 0x0427);
+
+        switch (gspca_dev->width) {
+        case 160: /* 160x120 */
+                cit_write_reg(gspca_dev, 0x0004, 0x010b);
+                cit_write_reg(gspca_dev, 0x0001, 0x010a);
+                cit_write_reg(gspca_dev, 0x0010, 0x0102);
+                cit_write_reg(gspca_dev, 0x00a0, 0x0103);
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);
+                cit_write_reg(gspca_dev, 0x0078, 0x0105);
+                break;
+
+        case 176: /* 176x144 */
+                cit_write_reg(gspca_dev, 0x0006, 0x010b);
+                cit_write_reg(gspca_dev, 0x0000, 0x010a);
+                cit_write_reg(gspca_dev, 0x0005, 0x0102);
+                cit_write_reg(gspca_dev, 0x00b0, 0x0103);
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);
+                cit_write_reg(gspca_dev, 0x0090, 0x0105);
+                break;
+
+        case 320: /* 320x240 */
+                cit_write_reg(gspca_dev, 0x0008, 0x010b);
+                cit_write_reg(gspca_dev, 0x0004, 0x010a);
+                cit_write_reg(gspca_dev, 0x0005, 0x0102);
+                cit_write_reg(gspca_dev, 0x00a0, 0x0103);
+                cit_write_reg(gspca_dev, 0x0010, 0x0104);
+                cit_write_reg(gspca_dev, 0x0078, 0x0105);
+                break;
+        }
+
+        cit_write_reg(gspca_dev, compression, 0x0109);
+        cit_write_reg(gspca_dev, clock_div, 0x0111);
+
+        return 0;
+}
+
+static int cit_start_model1(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int i, clock_div;
+
+        clock_div = cit_get_clock_div(gspca_dev);
+        if (clock_div < 0)
+                return clock_div;
+
+        cit_read_reg(gspca_dev, 0x0128, 1);
+        cit_read_reg(gspca_dev, 0x0100, 0);
+        cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On  */
+        cit_read_reg(gspca_dev, 0x0100, 0);
+        cit_write_reg(gspca_dev, 0x81, 0x0100); /* LED Off */
+        cit_read_reg(gspca_dev, 0x0100, 0);
+        cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On  */
+        cit_write_reg(gspca_dev, 0x01, 0x0108);
+
+        cit_write_reg(gspca_dev, 0x03, 0x0112);
+        cit_read_reg(gspca_dev, 0x0115, 0);
+        cit_write_reg(gspca_dev, 0x06, 0x0115);
+        cit_read_reg(gspca_dev, 0x0116, 0);
+        cit_write_reg(gspca_dev, 0x44, 0x0116);
+        cit_read_reg(gspca_dev, 0x0116, 0);
+        cit_write_reg(gspca_dev, 0x40, 0x0116);
+        cit_read_reg(gspca_dev, 0x0115, 0);
+        cit_write_reg(gspca_dev, 0x0e, 0x0115);
+        cit_write_reg(gspca_dev, 0x19, 0x012c);
+
+        cit_Packet_Format1(gspca_dev, 0x00, 0x1e);
+        cit_Packet_Format1(gspca_dev, 0x39, 0x0d);
+        cit_Packet_Format1(gspca_dev, 0x39, 0x09);
+        cit_Packet_Format1(gspca_dev, 0x3b, 0x00);
+        cit_Packet_Format1(gspca_dev, 0x28, 0x22);
+        cit_Packet_Format1(gspca_dev, 0x27, 0x00);
+        cit_Packet_Format1(gspca_dev, 0x2b, 0x1f);
+        cit_Packet_Format1(gspca_dev, 0x39, 0x08);
+
+        for (i = 0; i < cit_model1_ntries; i++)
+                cit_Packet_Format1(gspca_dev, 0x2c, 0x00);
+
+        for (i = 0; i < cit_model1_ntries; i++)
+                cit_Packet_Format1(gspca_dev, 0x30, 0x14);
+
+        cit_PacketFormat2(gspca_dev, 0x39, 0x02);
+        cit_PacketFormat2(gspca_dev, 0x01, 0xe1);
+        cit_PacketFormat2(gspca_dev, 0x02, 0xcd);
+        cit_PacketFormat2(gspca_dev, 0x03, 0xcd);
+        cit_PacketFormat2(gspca_dev, 0x04, 0xfa);
+        cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
+        cit_PacketFormat2(gspca_dev, 0x39, 0x00);
+
+        cit_PacketFormat2(gspca_dev, 0x39, 0x02);
+        cit_PacketFormat2(gspca_dev, 0x0a, 0x37);
+        cit_PacketFormat2(gspca_dev, 0x0b, 0xb8);
+        cit_PacketFormat2(gspca_dev, 0x0c, 0xf3);
+        cit_PacketFormat2(gspca_dev, 0x0d, 0xe3);
+        cit_PacketFormat2(gspca_dev, 0x0e, 0x0d);
+        cit_PacketFormat2(gspca_dev, 0x0f, 0xf2);
+        cit_PacketFormat2(gspca_dev, 0x10, 0xd5);
+        cit_PacketFormat2(gspca_dev, 0x11, 0xba);
+        cit_PacketFormat2(gspca_dev, 0x12, 0x53);
+        cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
+        cit_PacketFormat2(gspca_dev, 0x39, 0x00);
+
+        cit_PacketFormat2(gspca_dev, 0x39, 0x02);
+        cit_PacketFormat2(gspca_dev, 0x16, 0x00);
+        cit_PacketFormat2(gspca_dev, 0x17, 0x28);
+        cit_PacketFormat2(gspca_dev, 0x18, 0x7d);
+        cit_PacketFormat2(gspca_dev, 0x19, 0xbe);
+        cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
+        cit_PacketFormat2(gspca_dev, 0x39, 0x00);
+
+        for (i = 0; i < cit_model1_ntries; i++)
+                cit_Packet_Format1(gspca_dev, 0x00, 0x18);
+        for (i = 0; i < cit_model1_ntries; i++)
+                cit_Packet_Format1(gspca_dev, 0x13, 0x18);
+        for (i = 0; i < cit_model1_ntries; i++)
+                cit_Packet_Format1(gspca_dev, 0x14, 0x06);
+
+        /* TESTME These are handled through controls
+           KEEP until someone can test leaving this out is ok */
+        if (0) {
+                /* This is default brightness */
+                for (i = 0; i < cit_model1_ntries; i++)
+                        cit_Packet_Format1(gspca_dev, 0x31, 0x37);
+                for (i = 0; i < cit_model1_ntries; i++)
+                        cit_Packet_Format1(gspca_dev, 0x32, 0x46);
+                for (i = 0; i < cit_model1_ntries; i++)
+                        cit_Packet_Format1(gspca_dev, 0x33, 0x55);
+        }
+
+        cit_Packet_Format1(gspca_dev, 0x2e, 0x04);
+        for (i = 0; i < cit_model1_ntries; i++)
+                cit_Packet_Format1(gspca_dev, 0x2d, 0x04);
+        for (i = 0; i < cit_model1_ntries; i++)
+                cit_Packet_Format1(gspca_dev, 0x29, 0x80);
+        cit_Packet_Format1(gspca_dev, 0x2c, 0x01);
+        cit_Packet_Format1(gspca_dev, 0x30, 0x17);
+        cit_Packet_Format1(gspca_dev, 0x39, 0x08);
+        for (i = 0; i < cit_model1_ntries; i++)
+                cit_Packet_Format1(gspca_dev, 0x34, 0x00);
+
+        cit_write_reg(gspca_dev, 0x00, 0x0101);
+        cit_write_reg(gspca_dev, 0x00, 0x010a);
+
+        switch (gspca_dev->width) {
+        case 128: /* 128x96 */
+                cit_write_reg(gspca_dev, 0x80, 0x0103);
+                cit_write_reg(gspca_dev, 0x60, 0x0105);
+                cit_write_reg(gspca_dev, 0x0c, 0x010b);
+                cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x0b, 0x011d);
+                cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x00, 0x0129);
+                break;
+        case 176: /* 176x144 */
+                cit_write_reg(gspca_dev, 0xb0, 0x0103);
+                cit_write_reg(gspca_dev, 0x8f, 0x0105);
+                cit_write_reg(gspca_dev, 0x06, 0x010b);
+                cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x0d, 0x011d);
+                cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x03, 0x0129);
+                break;
+        case 352: /* 352x288 */
+                cit_write_reg(gspca_dev, 0xb0, 0x0103);
+                cit_write_reg(gspca_dev, 0x90, 0x0105);
+                cit_write_reg(gspca_dev, 0x02, 0x010b);
+                cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x05, 0x011d);
+                cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x00, 0x0129);
+                break;
+        }
+
+        cit_write_reg(gspca_dev, 0xff, 0x012b);
+
+        /* TESTME These are handled through controls
+           KEEP until someone can test leaving this out is ok */
+        if (0) {
+                /* This is another brightness - don't know why */
+                for (i = 0; i < cit_model1_ntries; i++)
+                        cit_Packet_Format1(gspca_dev, 0x31, 0xc3);
+                for (i = 0; i < cit_model1_ntries; i++)
+                        cit_Packet_Format1(gspca_dev, 0x32, 0xd2);
+                for (i = 0; i < cit_model1_ntries; i++)
+                        cit_Packet_Format1(gspca_dev, 0x33, 0xe1);
+
+                /* Default contrast */
+                for (i = 0; i < cit_model1_ntries; i++)
+                        cit_Packet_Format1(gspca_dev, 0x14, 0x0a);
+
+                /* Default sharpness */
+                for (i = 0; i < cit_model1_ntries2; i++)
+                        cit_PacketFormat2(gspca_dev, 0x13, 0x1a);
+
+                /* Default lighting conditions */
+                cit_Packet_Format1(gspca_dev, 0x0027, sd->lighting);
+        }
+
+        /* Assorted init */
+        switch (gspca_dev->width) {
+        case 128: /* 128x96 */
+                cit_Packet_Format1(gspca_dev, 0x2b, 0x1e);
+                cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x36, 0x0102);
+                cit_write_reg(gspca_dev, 0x1a, 0x0104);
+                cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x2b, 0x011c);
+                cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
+                break;
+        case 176: /* 176x144 */
+                cit_Packet_Format1(gspca_dev, 0x2b, 0x1e);
+                cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x04, 0x0102);
+                cit_write_reg(gspca_dev, 0x02, 0x0104);
+                cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x2b, 0x011c);
+                cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
+                break;
+        case 352: /* 352x288 */
+                cit_Packet_Format1(gspca_dev, 0x2b, 0x1f);
+                cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x08, 0x0102);
+                cit_write_reg(gspca_dev, 0x01, 0x0104);
+                cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
+                cit_write_reg(gspca_dev, 0x2f, 0x011c);
+                cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
+                break;
+        }
+
+        cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On  */
+        cit_write_reg(gspca_dev, clock_div, 0x0111);
+
+        return 0;
+}
+
+static int cit_start_model2(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int clock_div = 0;
+
+        cit_write_reg(gspca_dev, 0x0000, 0x0100);       /* LED on */
+        cit_read_reg(gspca_dev, 0x0116, 0);
+        cit_write_reg(gspca_dev, 0x0060, 0x0116);
+        cit_write_reg(gspca_dev, 0x0002, 0x0112);
+        cit_write_reg(gspca_dev, 0x00bc, 0x012c);
+        cit_write_reg(gspca_dev, 0x0008, 0x012b);
+        cit_write_reg(gspca_dev, 0x0000, 0x0108);
+        cit_write_reg(gspca_dev, 0x0001, 0x0133);
+        cit_write_reg(gspca_dev, 0x0001, 0x0102);
+        switch (gspca_dev->width) {
+        case 176: /* 176x144 */
+                cit_write_reg(gspca_dev, 0x002c, 0x0103);       /* All except 320x240 */
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);       /* Same */
+                cit_write_reg(gspca_dev, 0x0024, 0x0105);       /* 176x144, 352x288 */
+                cit_write_reg(gspca_dev, 0x00b9, 0x010a);       /* Unique to this mode */
+                cit_write_reg(gspca_dev, 0x0038, 0x0119);       /* Unique to this mode */
+                /* TESTME HDG: this does not seem right
+                   (it is 2 for all other resolutions) */
+                sd->sof_len = 10;
+                break;
+        case 320: /* 320x240 */
+                cit_write_reg(gspca_dev, 0x0028, 0x0103);       /* Unique to this mode */
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);       /* Same */
+                cit_write_reg(gspca_dev, 0x001e, 0x0105);       /* 320x240, 352x240 */
+                cit_write_reg(gspca_dev, 0x0039, 0x010a);       /* All except 176x144 */
+                cit_write_reg(gspca_dev, 0x0070, 0x0119);       /* All except 176x144 */
+                sd->sof_len = 2;
+                break;
+        /* case VIDEOSIZE_352x240: */
+                cit_write_reg(gspca_dev, 0x002c, 0x0103);       /* All except 320x240 */
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);       /* Same */
+                cit_write_reg(gspca_dev, 0x001e, 0x0105);       /* 320x240, 352x240 */
+                cit_write_reg(gspca_dev, 0x0039, 0x010a);       /* All except 176x144 */
+                cit_write_reg(gspca_dev, 0x0070, 0x0119);       /* All except 176x144 */
+                sd->sof_len = 2;
+                break;
+        case 352: /* 352x288 */
+                cit_write_reg(gspca_dev, 0x002c, 0x0103);       /* All except 320x240 */
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);       /* Same */
+                cit_write_reg(gspca_dev, 0x0024, 0x0105);       /* 176x144, 352x288 */
+                cit_write_reg(gspca_dev, 0x0039, 0x010a);       /* All except 176x144 */
+                cit_write_reg(gspca_dev, 0x0070, 0x0119);       /* All except 176x144 */
+                sd->sof_len = 2;
+                break;
+        }
+
+        cit_write_reg(gspca_dev, 0x0000, 0x0100);       /* LED on */
+
+        switch (gspca_dev->width) {
+        case 176: /* 176x144 */
+                cit_write_reg(gspca_dev, 0x0050, 0x0111);
+                cit_write_reg(gspca_dev, 0x00d0, 0x0111);
+                break;
+        case 320: /* 320x240 */
+        case 352: /* 352x288 */
+                cit_write_reg(gspca_dev, 0x0040, 0x0111);
+                cit_write_reg(gspca_dev, 0x00c0, 0x0111);
+                break;
+        }
+        cit_write_reg(gspca_dev, 0x009b, 0x010f);
+        cit_write_reg(gspca_dev, 0x00bb, 0x010f);
+
+        /*
+         * Hardware settings, may affect CMOS sensor; not user controls!
+         * -------------------------------------------------------------
+         * 0x0004: no effect
+         * 0x0006: hardware effect
+         * 0x0008: no effect
+         * 0x000a: stops video stream, probably important h/w setting
+         * 0x000c: changes color in hardware manner (not user setting)
+         * 0x0012: changes number of colors (does not affect speed)
+         * 0x002a: no effect
+         * 0x002c: hardware setting (related to scan lines)
+         * 0x002e: stops video stream, probably important h/w setting
+         */
+        cit_model2_Packet1(gspca_dev, 0x000a, 0x005c);
+        cit_model2_Packet1(gspca_dev, 0x0004, 0x0000);
+        cit_model2_Packet1(gspca_dev, 0x0006, 0x00fb);
+        cit_model2_Packet1(gspca_dev, 0x0008, 0x0000);
+        cit_model2_Packet1(gspca_dev, 0x000c, 0x0009);
+        cit_model2_Packet1(gspca_dev, 0x0012, 0x000a);
+        cit_model2_Packet1(gspca_dev, 0x002a, 0x0000);
+        cit_model2_Packet1(gspca_dev, 0x002c, 0x0000);
+        cit_model2_Packet1(gspca_dev, 0x002e, 0x0008);
+
+        /*
+         * Function 0x0030 pops up all over the place. Apparently
+         * it is a hardware control register, with every bit assigned to
+         * do something.
+         */
+        cit_model2_Packet1(gspca_dev, 0x0030, 0x0000);
+
+        /*
+         * Magic control of CMOS sensor. Only lower values like
+         * 0-3 work, and picture shifts left or right. Don't change.
+         */
+        switch (gspca_dev->width) {
+        case 176: /* 176x144 */
+                cit_model2_Packet1(gspca_dev, 0x0014, 0x0002);
+                cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */
+                cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */
+                clock_div = 6;
+                break;
+        case 320: /* 320x240 */
+                cit_model2_Packet1(gspca_dev, 0x0014, 0x0009);
+                cit_model2_Packet1(gspca_dev, 0x0016, 0x0005); /* Horizontal shift */
+                cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Another hardware setting */
+                clock_div = 8;
+                break;
+        /* case VIDEOSIZE_352x240: */
+                /* This mode doesn't work as Windows programs it; changed to work */
+                cit_model2_Packet1(gspca_dev, 0x0014, 0x0009); /* Windows sets this to 8 */
+                cit_model2_Packet1(gspca_dev, 0x0016, 0x0003); /* Horizontal shift */
+                cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Windows sets this to 0x0045 */
+                clock_div = 10;
+                break;
+        case 352: /* 352x288 */
+                cit_model2_Packet1(gspca_dev, 0x0014, 0x0003);
+                cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */
+                cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */
+                clock_div = 16;
+                break;
+        }
+
+        /* TESTME These are handled through controls
+           KEEP until someone can test leaving this out is ok */
+        if (0)
+                cit_model2_Packet1(gspca_dev, 0x001a, 0x005a);
+
+        /*
+         * We have our own frame rate setting varying from 0 (slowest) to 6
+         * (fastest). The camera model 2 allows frame rate in range [0..0x1F]
+         # where 0 is also the slowest setting. However for all practical
+         # reasons high settings make no sense because USB is not fast enough
+         # to support high FPS. Be aware that the picture datastream will be
+         # severely disrupted if you ask for frame rate faster than allowed
+         # for the video size - see below:
+         *
+         * Allowable ranges (obtained experimentally on OHCI, K6-3, 450 MHz):
+         * -----------------------------------------------------------------
+         * 176x144: [6..31]
+         * 320x240: [8..31]
+         * 352x240: [10..31]
+         * 352x288: [16..31] I have to raise lower threshold for stability...
+         *
+         * As usual, slower FPS provides better sensitivity.
+         */
+        cit_model2_Packet1(gspca_dev, 0x001c, clock_div);
+
+        /*
+         * This setting does not visibly affect pictures; left it here
+         * because it was present in Windows USB data stream. This function
+         * does not allow arbitrary values and apparently is a bit mask, to
+         * be activated only at appropriate time. Don't change it randomly!
+         */
+        switch (gspca_dev->width) {
+        case 176: /* 176x144 */
+                cit_model2_Packet1(gspca_dev, 0x0026, 0x00c2);
+                break;
+        case 320: /* 320x240 */
+                cit_model2_Packet1(gspca_dev, 0x0026, 0x0044);
+                break;
+        /* case VIDEOSIZE_352x240: */
+                cit_model2_Packet1(gspca_dev, 0x0026, 0x0046);
+                break;
+        case 352: /* 352x288 */
+                cit_model2_Packet1(gspca_dev, 0x0026, 0x0048);
+                break;
+        }
+
+        /* FIXME this cannot be changed while streaming, so we
+           should report a grabbed flag for this control. */
+        cit_model2_Packet1(gspca_dev, 0x0028, sd->lighting);
+        /* color balance rg2 */
+        cit_model2_Packet1(gspca_dev, 0x001e, 0x002f);
+        /* saturation */
+        cit_model2_Packet1(gspca_dev, 0x0020, 0x0034);
+        /* color balance yb */
+        cit_model2_Packet1(gspca_dev, 0x0022, 0x00a0);
+
+        /* Hardware control command */
+        cit_model2_Packet1(gspca_dev, 0x0030, 0x0004);
+
+        return 0;
+}
+
+static int cit_start_model3(struct gspca_dev *gspca_dev)
+{
+        const unsigned short compression = 0; /* 0=none, 7=best frame rate */
+        int i, clock_div = 0;
+
+        /* HDG not in ibmcam driver, added to see if it helps with
+           auto-detecting between model3 and ibm netcamera pro */
+        cit_read_reg(gspca_dev, 0x128, 1);
+
+        cit_write_reg(gspca_dev, 0x0000, 0x0100);
+        cit_read_reg(gspca_dev, 0x0116, 0);
+        cit_write_reg(gspca_dev, 0x0060, 0x0116);
+        cit_write_reg(gspca_dev, 0x0002, 0x0112);
+        cit_write_reg(gspca_dev, 0x0000, 0x0123);
+        cit_write_reg(gspca_dev, 0x0001, 0x0117);
+        cit_write_reg(gspca_dev, 0x0040, 0x0108);
+        cit_write_reg(gspca_dev, 0x0019, 0x012c);
+        cit_write_reg(gspca_dev, 0x0060, 0x0116);
+        cit_write_reg(gspca_dev, 0x0002, 0x0115);
+        cit_write_reg(gspca_dev, 0x0003, 0x0115);
+        cit_read_reg(gspca_dev, 0x0115, 0);
+        cit_write_reg(gspca_dev, 0x000b, 0x0115);
+
+        /* TESTME HDG not in ibmcam driver, added to see if it helps with
+           auto-detecting between model3 and ibm netcamera pro */
+        if (0) {
+                cit_write_reg(gspca_dev, 0x0078, 0x012d);
+                cit_write_reg(gspca_dev, 0x0001, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0079, 0x012d);
+                cit_write_reg(gspca_dev, 0x00ff, 0x0130);
+                cit_write_reg(gspca_dev, 0xcd41, 0x0124);
+                cit_write_reg(gspca_dev, 0xfffa, 0x0124);
+                cit_read_reg(gspca_dev, 0x0126, 1);
+        }
+
+        cit_model3_Packet1(gspca_dev, 0x000a, 0x0040);
+        cit_model3_Packet1(gspca_dev, 0x000b, 0x00f6);
+        cit_model3_Packet1(gspca_dev, 0x000c, 0x0002);
+        cit_model3_Packet1(gspca_dev, 0x000d, 0x0020);
+        cit_model3_Packet1(gspca_dev, 0x000e, 0x0033);
+        cit_model3_Packet1(gspca_dev, 0x000f, 0x0007);
+        cit_model3_Packet1(gspca_dev, 0x0010, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0011, 0x0070);
+        cit_model3_Packet1(gspca_dev, 0x0012, 0x0030);
+        cit_model3_Packet1(gspca_dev, 0x0013, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0014, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x0015, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x0016, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x0017, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x0018, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x001e, 0x00c3);
+        cit_model3_Packet1(gspca_dev, 0x0020, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0028, 0x0010);
+        cit_model3_Packet1(gspca_dev, 0x0029, 0x0054);
+        cit_model3_Packet1(gspca_dev, 0x002a, 0x0013);
+        cit_model3_Packet1(gspca_dev, 0x002b, 0x0007);
+        cit_model3_Packet1(gspca_dev, 0x002d, 0x0028);
+        cit_model3_Packet1(gspca_dev, 0x002e, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0031, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0032, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0033, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0034, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0035, 0x0038);
+        cit_model3_Packet1(gspca_dev, 0x003a, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x003c, 0x001e);
+        cit_model3_Packet1(gspca_dev, 0x003f, 0x000a);
+        cit_model3_Packet1(gspca_dev, 0x0041, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0046, 0x003f);
+        cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0050, 0x0005);
+        cit_model3_Packet1(gspca_dev, 0x0052, 0x001a);
+        cit_model3_Packet1(gspca_dev, 0x0053, 0x0003);
+        cit_model3_Packet1(gspca_dev, 0x005a, 0x006b);
+        cit_model3_Packet1(gspca_dev, 0x005d, 0x001e);
+        cit_model3_Packet1(gspca_dev, 0x005e, 0x0030);
+        cit_model3_Packet1(gspca_dev, 0x005f, 0x0041);
+        cit_model3_Packet1(gspca_dev, 0x0064, 0x0008);
+        cit_model3_Packet1(gspca_dev, 0x0065, 0x0015);
+        cit_model3_Packet1(gspca_dev, 0x0068, 0x000f);
+        cit_model3_Packet1(gspca_dev, 0x0079, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x007a, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x007c, 0x003f);
+        cit_model3_Packet1(gspca_dev, 0x0082, 0x000f);
+        cit_model3_Packet1(gspca_dev, 0x0085, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0099, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x009b, 0x0023);
+        cit_model3_Packet1(gspca_dev, 0x009c, 0x0022);
+        cit_model3_Packet1(gspca_dev, 0x009d, 0x0096);
+        cit_model3_Packet1(gspca_dev, 0x009e, 0x0096);
+        cit_model3_Packet1(gspca_dev, 0x009f, 0x000a);
+
+        switch (gspca_dev->width) {
+        case 160:
+                cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
+                cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
+                cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
+                cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
+                cit_write_reg(gspca_dev, 0x0024, 0x010b); /* Differs everywhere */
+                cit_write_reg(gspca_dev, 0x00a9, 0x0119);
+                cit_write_reg(gspca_dev, 0x0016, 0x011b);
+                cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */
+                cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */
+                cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
+                cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
+                cit_write_reg(gspca_dev, 0x0018, 0x0102);
+                cit_write_reg(gspca_dev, 0x0004, 0x0104);
+                cit_write_reg(gspca_dev, 0x0004, 0x011a);
+                cit_write_reg(gspca_dev, 0x0028, 0x011c);
+                cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
+                cit_write_reg(gspca_dev, 0x0000, 0x0118);
+                cit_write_reg(gspca_dev, 0x0000, 0x0132);
+                cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
+                cit_write_reg(gspca_dev, compression, 0x0109);
+                clock_div = 3;
+                break;
+        case 320:
+                cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
+                cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
+                cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
+                cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
+                cit_write_reg(gspca_dev, 0x0028, 0x010b); /* Differs everywhere */
+                cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same */
+                cit_write_reg(gspca_dev, 0x0000, 0x011e);
+                cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
+                cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
+                /* 4 commands from 160x120 skipped */
+                cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
+                cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
+                cit_write_reg(gspca_dev, compression, 0x0109);
+                cit_write_reg(gspca_dev, 0x00d9, 0x0119);
+                cit_write_reg(gspca_dev, 0x0006, 0x011b);
+                cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
+                cit_write_reg(gspca_dev, 0x0010, 0x0104);
+                cit_write_reg(gspca_dev, 0x0004, 0x011a);
+                cit_write_reg(gspca_dev, 0x003f, 0x011c);
+                cit_write_reg(gspca_dev, 0x001c, 0x0118);
+                cit_write_reg(gspca_dev, 0x0000, 0x0132);
+                clock_div = 5;
+                break;
+        case 640:
+                cit_write_reg(gspca_dev, 0x00f0, 0x0105);
+                cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
+                cit_write_reg(gspca_dev, 0x0038, 0x010b); /* Differs everywhere */
+                cit_write_reg(gspca_dev, 0x00d9, 0x0119); /* Same on 320x240, 640x480 */
+                cit_write_reg(gspca_dev, 0x0006, 0x011b); /* Same on 320x240, 640x480 */
+                cit_write_reg(gspca_dev, 0x0004, 0x011d); /* NC */
+                cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */
+                cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
+                cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
+                cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
+                cit_write_reg(gspca_dev, 0x0016, 0x0104); /* NC */
+                cit_write_reg(gspca_dev, 0x0004, 0x011a); /* Same on 320x240, 640x480 */
+                cit_write_reg(gspca_dev, 0x003f, 0x011c); /* Same on 320x240, 640x480 */
+                cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
+                cit_write_reg(gspca_dev, 0x001c, 0x0118); /* Same on 320x240, 640x480 */
+                cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
+                cit_write_reg(gspca_dev, compression, 0x0109);
+                cit_write_reg(gspca_dev, 0x0040, 0x0101);
+                cit_write_reg(gspca_dev, 0x0040, 0x0103);
+                cit_write_reg(gspca_dev, 0x0000, 0x0132); /* Same on 320x240, 640x480 */
+                clock_div = 7;
+                break;
+        }
+
+        cit_model3_Packet1(gspca_dev, 0x007e, 0x000e);  /* Hue */
+        cit_model3_Packet1(gspca_dev, 0x0036, 0x0011);  /* Brightness */
+        cit_model3_Packet1(gspca_dev, 0x0060, 0x0002);  /* Sharpness */
+        cit_model3_Packet1(gspca_dev, 0x0061, 0x0004);  /* Sharpness */
+        cit_model3_Packet1(gspca_dev, 0x0062, 0x0005);  /* Sharpness */
+        cit_model3_Packet1(gspca_dev, 0x0063, 0x0014);  /* Sharpness */
+        cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0);  /* Red sharpness */
+        cit_model3_Packet1(gspca_dev, 0x0097, 0x0096);  /* Blue sharpness */
+        cit_model3_Packet1(gspca_dev, 0x0067, 0x0001);  /* Contrast */
+        cit_model3_Packet1(gspca_dev, 0x005b, 0x000c);  /* Contrast */
+        cit_model3_Packet1(gspca_dev, 0x005c, 0x0016);  /* Contrast */
+        cit_model3_Packet1(gspca_dev, 0x0098, 0x000b);
+        cit_model3_Packet1(gspca_dev, 0x002c, 0x0003);  /* Was 1, broke 640x480 */
+        cit_model3_Packet1(gspca_dev, 0x002f, 0x002a);
+        cit_model3_Packet1(gspca_dev, 0x0030, 0x0029);
+        cit_model3_Packet1(gspca_dev, 0x0037, 0x0002);
+        cit_model3_Packet1(gspca_dev, 0x0038, 0x0059);
+        cit_model3_Packet1(gspca_dev, 0x003d, 0x002e);
+        cit_model3_Packet1(gspca_dev, 0x003e, 0x0028);
+        cit_model3_Packet1(gspca_dev, 0x0078, 0x0005);
+        cit_model3_Packet1(gspca_dev, 0x007b, 0x0011);
+        cit_model3_Packet1(gspca_dev, 0x007d, 0x004b);
+        cit_model3_Packet1(gspca_dev, 0x007f, 0x0022);
+        cit_model3_Packet1(gspca_dev, 0x0080, 0x000c);
+        cit_model3_Packet1(gspca_dev, 0x0081, 0x000b);
+        cit_model3_Packet1(gspca_dev, 0x0083, 0x00fd);
+        cit_model3_Packet1(gspca_dev, 0x0086, 0x000b);
+        cit_model3_Packet1(gspca_dev, 0x0087, 0x000b);
+        cit_model3_Packet1(gspca_dev, 0x007e, 0x000e);
+        cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0);  /* Red sharpness */
+        cit_model3_Packet1(gspca_dev, 0x0097, 0x0096);  /* Blue sharpness */
+        cit_model3_Packet1(gspca_dev, 0x0098, 0x000b);
+
+        /* FIXME we should probably use cit_get_clock_div() here (in
+           combination with isoc negotiation using the programmable isoc size)
+           like with the IBM netcam pro). */
+        cit_write_reg(gspca_dev, clock_div, 0x0111); /* Clock Divider */
+
+        switch (gspca_dev->width) {
+        case 160:
+                cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */
+                cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */
+                cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */
+                cit_model3_Packet1(gspca_dev, 0x0040, 0x000a);
+                cit_model3_Packet1(gspca_dev, 0x0051, 0x000a);
+                break;
+        case 320:
+                cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */
+                cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */
+                cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */
+                cit_model3_Packet1(gspca_dev, 0x0040, 0x0008);
+                cit_model3_Packet1(gspca_dev, 0x0051, 0x000b);
+                break;
+        case 640:
+                cit_model3_Packet1(gspca_dev, 0x001f, 0x0002);  /* !Same */
+                cit_model3_Packet1(gspca_dev, 0x0039, 0x003e);  /* !Same */
+                cit_model3_Packet1(gspca_dev, 0x0040, 0x0008);
+                cit_model3_Packet1(gspca_dev, 0x0051, 0x000a);
+                break;
+        }
+
+/*      if (sd->input_index) { */
+        if (rca_input) {
+                for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) {
+                        if (rca_initdata[i][0])
+                                cit_read_reg(gspca_dev, rca_initdata[i][2], 0);
+                        else
+                                cit_write_reg(gspca_dev, rca_initdata[i][1],
+                                              rca_initdata[i][2]);
+                }
+        }
+
+        return 0;
+}
+
+static int cit_start_model4(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        cit_write_reg(gspca_dev, 0x0000, 0x0100);
+        cit_write_reg(gspca_dev, 0x00c0, 0x0111);
+        cit_write_reg(gspca_dev, 0x00bc, 0x012c);
+        cit_write_reg(gspca_dev, 0x0080, 0x012b);
+        cit_write_reg(gspca_dev, 0x0000, 0x0108);
+        cit_write_reg(gspca_dev, 0x0001, 0x0133);
+        cit_write_reg(gspca_dev, 0x009b, 0x010f);
+        cit_write_reg(gspca_dev, 0x00bb, 0x010f);
+        cit_model4_Packet1(gspca_dev, 0x0038, 0x0000);
+        cit_model4_Packet1(gspca_dev, 0x000a, 0x005c);
+
+        cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+        cit_write_reg(gspca_dev, 0x0004, 0x012f);
+        cit_write_reg(gspca_dev, 0xd141, 0x0124);
+        cit_write_reg(gspca_dev, 0x0000, 0x0127);
+        cit_write_reg(gspca_dev, 0x00fb, 0x012e);
+        cit_write_reg(gspca_dev, 0x0000, 0x0130);
+        cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+        cit_write_reg(gspca_dev, 0x00aa, 0x012f);
+        cit_write_reg(gspca_dev, 0xd055, 0x0124);
+        cit_write_reg(gspca_dev, 0x000c, 0x0127);
+        cit_write_reg(gspca_dev, 0x0009, 0x012e);
+        cit_write_reg(gspca_dev, 0xaa28, 0x0124);
+
+        cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+        cit_write_reg(gspca_dev, 0x0012, 0x012f);
+        cit_write_reg(gspca_dev, 0xd141, 0x0124);
+        cit_write_reg(gspca_dev, 0x0008, 0x0127);
+        cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+        cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+        cit_write_reg(gspca_dev, 0x002a, 0x012d);
+        cit_write_reg(gspca_dev, 0x0000, 0x012f);
+        cit_write_reg(gspca_dev, 0xd145, 0x0124);
+        cit_write_reg(gspca_dev, 0xfffa, 0x0124);
+        cit_model4_Packet1(gspca_dev, 0x0034, 0x0000);
+
+        switch (gspca_dev->width) {
+        case 128: /* 128x96 */
+                cit_write_reg(gspca_dev, 0x0070, 0x0119);
+                cit_write_reg(gspca_dev, 0x00d0, 0x0111);
+                cit_write_reg(gspca_dev, 0x0039, 0x010a);
+                cit_write_reg(gspca_dev, 0x0001, 0x0102);
+                cit_write_reg(gspca_dev, 0x0028, 0x0103);
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);
+                cit_write_reg(gspca_dev, 0x001e, 0x0105);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x0016, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x000a, 0x0127);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+                cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+                cit_write_reg(gspca_dev, 0x0014, 0x012d);
+                cit_write_reg(gspca_dev, 0x0008, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012e);
+                cit_write_reg(gspca_dev, 0x001a, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
+                cit_write_reg(gspca_dev, 0x005a, 0x012d);
+                cit_write_reg(gspca_dev, 0x9545, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0127);
+                cit_write_reg(gspca_dev, 0x0018, 0x012e);
+                cit_write_reg(gspca_dev, 0x0043, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012f);
+                cit_write_reg(gspca_dev, 0xd055, 0x0124);
+                cit_write_reg(gspca_dev, 0x001c, 0x0127);
+                cit_write_reg(gspca_dev, 0x00eb, 0x012e);
+                cit_write_reg(gspca_dev, 0xaa28, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x0032, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0000, 0x0127);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+                cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+                cit_write_reg(gspca_dev, 0x0036, 0x012d);
+                cit_write_reg(gspca_dev, 0x0008, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0xfffa, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x001e, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0017, 0x0127);
+                cit_write_reg(gspca_dev, 0x0013, 0x012e);
+                cit_write_reg(gspca_dev, 0x0031, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, 0x0017, 0x012d);
+                cit_write_reg(gspca_dev, 0x0078, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0x0000, 0x0127);
+                cit_write_reg(gspca_dev, 0xfea8, 0x0124);
+                sd->sof_len = 2;
+                break;
+        case 160: /* 160x120 */
+                cit_write_reg(gspca_dev, 0x0038, 0x0119);
+                cit_write_reg(gspca_dev, 0x00d0, 0x0111);
+                cit_write_reg(gspca_dev, 0x00b9, 0x010a);
+                cit_write_reg(gspca_dev, 0x0001, 0x0102);
+                cit_write_reg(gspca_dev, 0x0028, 0x0103);
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);
+                cit_write_reg(gspca_dev, 0x001e, 0x0105);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x0016, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x000b, 0x0127);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+                cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+                cit_write_reg(gspca_dev, 0x0014, 0x012d);
+                cit_write_reg(gspca_dev, 0x0008, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012e);
+                cit_write_reg(gspca_dev, 0x001a, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
+                cit_write_reg(gspca_dev, 0x005a, 0x012d);
+                cit_write_reg(gspca_dev, 0x9545, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0127);
+                cit_write_reg(gspca_dev, 0x0018, 0x012e);
+                cit_write_reg(gspca_dev, 0x0043, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012f);
+                cit_write_reg(gspca_dev, 0xd055, 0x0124);
+                cit_write_reg(gspca_dev, 0x001c, 0x0127);
+                cit_write_reg(gspca_dev, 0x00c7, 0x012e);
+                cit_write_reg(gspca_dev, 0xaa28, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x0032, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0025, 0x0127);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+                cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+                cit_write_reg(gspca_dev, 0x0036, 0x012d);
+                cit_write_reg(gspca_dev, 0x0008, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0xfffa, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x001e, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0048, 0x0127);
+                cit_write_reg(gspca_dev, 0x0035, 0x012e);
+                cit_write_reg(gspca_dev, 0x00d0, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, 0x0048, 0x012d);
+                cit_write_reg(gspca_dev, 0x0090, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0x0001, 0x0127);
+                cit_write_reg(gspca_dev, 0xfea8, 0x0124);
+                sd->sof_len = 2;
+                break;
+        case 176: /* 176x144 */
+                cit_write_reg(gspca_dev, 0x0038, 0x0119);
+                cit_write_reg(gspca_dev, 0x00d0, 0x0111);
+                cit_write_reg(gspca_dev, 0x00b9, 0x010a);
+                cit_write_reg(gspca_dev, 0x0001, 0x0102);
+                cit_write_reg(gspca_dev, 0x002c, 0x0103);
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);
+                cit_write_reg(gspca_dev, 0x0024, 0x0105);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x0016, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0007, 0x0127);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+                cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+                cit_write_reg(gspca_dev, 0x0014, 0x012d);
+                cit_write_reg(gspca_dev, 0x0001, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012e);
+                cit_write_reg(gspca_dev, 0x001a, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
+                cit_write_reg(gspca_dev, 0x005e, 0x012d);
+                cit_write_reg(gspca_dev, 0x9545, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0127);
+                cit_write_reg(gspca_dev, 0x0018, 0x012e);
+                cit_write_reg(gspca_dev, 0x0049, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012f);
+                cit_write_reg(gspca_dev, 0xd055, 0x0124);
+                cit_write_reg(gspca_dev, 0x001c, 0x0127);
+                cit_write_reg(gspca_dev, 0x00c7, 0x012e);
+                cit_write_reg(gspca_dev, 0xaa28, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x0032, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0028, 0x0127);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+                cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+                cit_write_reg(gspca_dev, 0x0036, 0x012d);
+                cit_write_reg(gspca_dev, 0x0008, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0xfffa, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x001e, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0010, 0x0127);
+                cit_write_reg(gspca_dev, 0x0013, 0x012e);
+                cit_write_reg(gspca_dev, 0x002a, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, 0x0010, 0x012d);
+                cit_write_reg(gspca_dev, 0x006d, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0x0001, 0x0127);
+                cit_write_reg(gspca_dev, 0xfea8, 0x0124);
+                /* TESTME HDG: this does not seem right
+                   (it is 2 for all other resolutions) */
+                sd->sof_len = 10;
+                break;
+        case 320: /* 320x240 */
+                cit_write_reg(gspca_dev, 0x0070, 0x0119);
+                cit_write_reg(gspca_dev, 0x00d0, 0x0111);
+                cit_write_reg(gspca_dev, 0x0039, 0x010a);
+                cit_write_reg(gspca_dev, 0x0001, 0x0102);
+                cit_write_reg(gspca_dev, 0x0028, 0x0103);
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);
+                cit_write_reg(gspca_dev, 0x001e, 0x0105);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x0016, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x000a, 0x0127);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+                cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+                cit_write_reg(gspca_dev, 0x0014, 0x012d);
+                cit_write_reg(gspca_dev, 0x0008, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012e);
+                cit_write_reg(gspca_dev, 0x001a, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
+                cit_write_reg(gspca_dev, 0x005a, 0x012d);
+                cit_write_reg(gspca_dev, 0x9545, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0127);
+                cit_write_reg(gspca_dev, 0x0018, 0x012e);
+                cit_write_reg(gspca_dev, 0x0043, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012f);
+                cit_write_reg(gspca_dev, 0xd055, 0x0124);
+                cit_write_reg(gspca_dev, 0x001c, 0x0127);
+                cit_write_reg(gspca_dev, 0x00eb, 0x012e);
+                cit_write_reg(gspca_dev, 0xaa28, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x0032, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0000, 0x0127);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+                cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+                cit_write_reg(gspca_dev, 0x0036, 0x012d);
+                cit_write_reg(gspca_dev, 0x0008, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0xfffa, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x001e, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0017, 0x0127);
+                cit_write_reg(gspca_dev, 0x0013, 0x012e);
+                cit_write_reg(gspca_dev, 0x0031, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, 0x0017, 0x012d);
+                cit_write_reg(gspca_dev, 0x0078, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0x0000, 0x0127);
+                cit_write_reg(gspca_dev, 0xfea8, 0x0124);
+                sd->sof_len = 2;
+                break;
+        case 352: /* 352x288 */
+                cit_write_reg(gspca_dev, 0x0070, 0x0119);
+                cit_write_reg(gspca_dev, 0x00c0, 0x0111);
+                cit_write_reg(gspca_dev, 0x0039, 0x010a);
+                cit_write_reg(gspca_dev, 0x0001, 0x0102);
+                cit_write_reg(gspca_dev, 0x002c, 0x0103);
+                cit_write_reg(gspca_dev, 0x0000, 0x0104);
+                cit_write_reg(gspca_dev, 0x0024, 0x0105);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x0016, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0006, 0x0127);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+                cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+                cit_write_reg(gspca_dev, 0x0014, 0x012d);
+                cit_write_reg(gspca_dev, 0x0002, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012e);
+                cit_write_reg(gspca_dev, 0x001a, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
+                cit_write_reg(gspca_dev, 0x005e, 0x012d);
+                cit_write_reg(gspca_dev, 0x9545, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0127);
+                cit_write_reg(gspca_dev, 0x0018, 0x012e);
+                cit_write_reg(gspca_dev, 0x0049, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012f);
+                cit_write_reg(gspca_dev, 0xd055, 0x0124);
+                cit_write_reg(gspca_dev, 0x001c, 0x0127);
+                cit_write_reg(gspca_dev, 0x00cf, 0x012e);
+                cit_write_reg(gspca_dev, 0xaa28, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x0032, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0000, 0x0127);
+                cit_write_reg(gspca_dev, 0x00aa, 0x0130);
+                cit_write_reg(gspca_dev, 0x82a8, 0x0124);
+                cit_write_reg(gspca_dev, 0x0036, 0x012d);
+                cit_write_reg(gspca_dev, 0x0008, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0xfffa, 0x0124);
+                cit_write_reg(gspca_dev, 0x00aa, 0x012d);
+                cit_write_reg(gspca_dev, 0x001e, 0x012f);
+                cit_write_reg(gspca_dev, 0xd141, 0x0124);
+                cit_write_reg(gspca_dev, 0x0010, 0x0127);
+                cit_write_reg(gspca_dev, 0x0013, 0x012e);
+                cit_write_reg(gspca_dev, 0x0025, 0x0130);
+                cit_write_reg(gspca_dev, 0x8a28, 0x0124);
+                cit_write_reg(gspca_dev, 0x0010, 0x012d);
+                cit_write_reg(gspca_dev, 0x0048, 0x012f);
+                cit_write_reg(gspca_dev, 0xd145, 0x0124);
+                cit_write_reg(gspca_dev, 0x0000, 0x0127);
+                cit_write_reg(gspca_dev, 0xfea8, 0x0124);
+                sd->sof_len = 2;
+                break;
+        }
+
+        cit_model4_Packet1(gspca_dev, 0x0038, 0x0004);
+
+        return 0;
+}
+
+static int cit_start_ibm_netcam_pro(struct gspca_dev *gspca_dev)
+{
+        const unsigned short compression = 0; /* 0=none, 7=best frame rate */
+        int i, clock_div;
+
+        clock_div = cit_get_clock_div(gspca_dev);
+        if (clock_div < 0)
+                return clock_div;
+
+        cit_write_reg(gspca_dev, 0x0003, 0x0133);
+        cit_write_reg(gspca_dev, 0x0000, 0x0117);
+        cit_write_reg(gspca_dev, 0x0008, 0x0123);
+        cit_write_reg(gspca_dev, 0x0000, 0x0100);
+        cit_write_reg(gspca_dev, 0x0060, 0x0116);
+        /* cit_write_reg(gspca_dev, 0x0002, 0x0112); see sd_stop0 */
+        cit_write_reg(gspca_dev, 0x0000, 0x0133);
+        cit_write_reg(gspca_dev, 0x0000, 0x0123);
+        cit_write_reg(gspca_dev, 0x0001, 0x0117);
+        cit_write_reg(gspca_dev, 0x0040, 0x0108);
+        cit_write_reg(gspca_dev, 0x0019, 0x012c);
+        cit_write_reg(gspca_dev, 0x0060, 0x0116);
+        /* cit_write_reg(gspca_dev, 0x000b, 0x0115); see sd_stop0 */
+
+        cit_model3_Packet1(gspca_dev, 0x0049, 0x0000);
+
+        cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
+        cit_write_reg(gspca_dev, 0x003a, 0x0102); /* Hstart */
+        cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
+        cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
+        cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
+        cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */
+        cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
+        cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
+        cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
+
+        switch (gspca_dev->width) {
+        case 160: /* 160x120 */
+                cit_write_reg(gspca_dev, 0x0024, 0x010b);
+                cit_write_reg(gspca_dev, 0x0089, 0x0119);
+                cit_write_reg(gspca_dev, 0x000a, 0x011b);
+                cit_write_reg(gspca_dev, 0x0003, 0x011e);
+                cit_write_reg(gspca_dev, 0x0007, 0x0104);
+                cit_write_reg(gspca_dev, 0x0009, 0x011a);
+                cit_write_reg(gspca_dev, 0x008b, 0x011c);
+                cit_write_reg(gspca_dev, 0x0008, 0x0118);
+                cit_write_reg(gspca_dev, 0x0000, 0x0132);
+                break;
+        case 320: /* 320x240 */
+                cit_write_reg(gspca_dev, 0x0028, 0x010b);
+                cit_write_reg(gspca_dev, 0x00d9, 0x0119);
+                cit_write_reg(gspca_dev, 0x0006, 0x011b);
+                cit_write_reg(gspca_dev, 0x0000, 0x011e);
+                cit_write_reg(gspca_dev, 0x000e, 0x0104);
+                cit_write_reg(gspca_dev, 0x0004, 0x011a);
+                cit_write_reg(gspca_dev, 0x003f, 0x011c);
+                cit_write_reg(gspca_dev, 0x000c, 0x0118);
+                cit_write_reg(gspca_dev, 0x0000, 0x0132);
+                break;
+        }
+
+        cit_model3_Packet1(gspca_dev, 0x0019, 0x0031);
+        cit_model3_Packet1(gspca_dev, 0x001a, 0x0003);
+        cit_model3_Packet1(gspca_dev, 0x001b, 0x0038);
+        cit_model3_Packet1(gspca_dev, 0x001c, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0024, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x0027, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x002a, 0x0004);
+        cit_model3_Packet1(gspca_dev, 0x0035, 0x000b);
+        cit_model3_Packet1(gspca_dev, 0x003f, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x0044, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x0054, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00c4, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00e7, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x00e9, 0x0001);
+        cit_model3_Packet1(gspca_dev, 0x00ee, 0x0000);
+        cit_model3_Packet1(gspca_dev, 0x00f3, 0x00c0);
+
+        cit_write_reg(gspca_dev, compression, 0x0109);
+        cit_write_reg(gspca_dev, clock_div, 0x0111);
+
+/*      if (sd->input_index) { */
+        if (rca_input) {
+                for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) {
+                        if (rca_initdata[i][0])
+                                cit_read_reg(gspca_dev, rca_initdata[i][2], 0);
+                        else
+                                cit_write_reg(gspca_dev, rca_initdata[i][1],
+                                              rca_initdata[i][2]);
+                }
+        }
+
+        return 0;
+}
+
+/* -- start the camera -- */
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int packet_size;
+
+        packet_size = cit_get_packet_size(gspca_dev);
+        if (packet_size < 0)
+                return packet_size;
+
+        switch (sd->model) {
+        case CIT_MODEL0:
+                cit_start_model0(gspca_dev);
+                break;
+        case CIT_MODEL1:
+                cit_start_model1(gspca_dev);
+                break;
+        case CIT_MODEL2:
+                cit_start_model2(gspca_dev);
+                break;
+        case CIT_MODEL3:
+                cit_start_model3(gspca_dev);
+                break;
+        case CIT_MODEL4:
+                cit_start_model4(gspca_dev);
+                break;
+        case CIT_IBM_NETCAM_PRO:
+                cit_start_ibm_netcam_pro(gspca_dev);
+                break;
+        }
+
+        cit_set_brightness(gspca_dev);
+        cit_set_contrast(gspca_dev);
+        cit_set_hue(gspca_dev);
+        cit_set_sharpness(gspca_dev);
+        cit_set_lighting(gspca_dev);
+        cit_set_hflip(gspca_dev);
+
+        /* Program max isoc packet size */
+        cit_write_reg(gspca_dev, packet_size >> 8, 0x0106);
+        cit_write_reg(gspca_dev, packet_size & 0xff, 0x0107);
+
+        cit_restart_stream(gspca_dev);
+
+        return 0;
+}
+
+static int sd_isoc_init(struct gspca_dev *gspca_dev)
+{
+        struct usb_host_interface *alt;
+        int max_packet_size;
+
+        switch (gspca_dev->width) {
+        case 160:
+                max_packet_size = 450;
+                break;
+        case 176:
+                max_packet_size = 600;
+                break;
+        default:
+                max_packet_size = 1022;
+                break;
+        }
+
+        /* Start isoc bandwidth "negotiation" at max isoc bandwidth */
+        alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
+        alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(max_packet_size);
+
+        return 0;
+}
+
+static int sd_isoc_nego(struct gspca_dev *gspca_dev)
+{
+        int ret, packet_size, min_packet_size;
+        struct usb_host_interface *alt;
+
+        switch (gspca_dev->width) {
+        case 160:
+                min_packet_size = 200;
+                break;
+        case 176:
+                min_packet_size = 266;
+                break;
+        default:
+                min_packet_size = 400;
+                break;
+        }
+
+        alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
+        packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
+        if (packet_size <= min_packet_size)
+                return -EIO;
+
+        packet_size -= 100;
+        if (packet_size < min_packet_size)
+                packet_size = min_packet_size;
+        alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(packet_size);
+
+        ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
+        if (ret < 0)
+                err("set alt 1 err %d", ret);
+
+        return ret;
+}
+
+static void sd_stopN(struct gspca_dev *gspca_dev)
+{
+        cit_write_reg(gspca_dev, 0x0000, 0x010c);
+}
+
+static void sd_stop0(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        /* We cannot use gspca_dev->present here as that is not set when
+           sd_init gets called and we get called from sd_init */
+        if (!gspca_dev->dev)
+                return;
+
+        switch (sd->model) {
+        case CIT_MODEL0:
+                /* HDG windows does this, but it causes the cams autogain to
+                   restart from a gain of 0, which does not look good when
+                   changing resolutions. */
+                /* cit_write_reg(gspca_dev, 0x0000, 0x0112); */
+                cit_write_reg(gspca_dev, 0x00c0, 0x0100); /* LED Off */
+                break;
+        case CIT_MODEL1:
+                cit_send_FF_04_02(gspca_dev);
+                cit_read_reg(gspca_dev, 0x0100, 0);
+                cit_write_reg(gspca_dev, 0x81, 0x0100); /* LED Off */
+                break;
+        case CIT_MODEL2:
+        case CIT_MODEL4:
+                cit_model2_Packet1(gspca_dev, 0x0030, 0x0004);
+
+                cit_write_reg(gspca_dev, 0x0080, 0x0100);       /* LED Off */
+                cit_write_reg(gspca_dev, 0x0020, 0x0111);
+                cit_write_reg(gspca_dev, 0x00a0, 0x0111);
+
+                cit_model2_Packet1(gspca_dev, 0x0030, 0x0002);
+
+                cit_write_reg(gspca_dev, 0x0020, 0x0111);
+                cit_write_reg(gspca_dev, 0x0000, 0x0112);
+                break;
+        case CIT_MODEL3:
+                cit_write_reg(gspca_dev, 0x0006, 0x012c);
+                cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
+                cit_read_reg(gspca_dev, 0x0116, 0);
+                cit_write_reg(gspca_dev, 0x0064, 0x0116);
+                cit_read_reg(gspca_dev, 0x0115, 0);
+                cit_write_reg(gspca_dev, 0x0003, 0x0115);
+                cit_write_reg(gspca_dev, 0x0008, 0x0123);
+                cit_write_reg(gspca_dev, 0x0000, 0x0117);
+                cit_write_reg(gspca_dev, 0x0000, 0x0112);
+                cit_write_reg(gspca_dev, 0x0080, 0x0100);
+                break;
+        case CIT_IBM_NETCAM_PRO:
+                cit_model3_Packet1(gspca_dev, 0x0049, 0x00ff);
+                cit_write_reg(gspca_dev, 0x0006, 0x012c);
+                cit_write_reg(gspca_dev, 0x0000, 0x0116);
+                /* HDG windows does this, but I cannot get the camera
+                   to restart with this without redoing the entire init
+                   sequence which makes switching modes really slow */
+                /* cit_write_reg(gspca_dev, 0x0006, 0x0115); */
+                cit_write_reg(gspca_dev, 0x0008, 0x0123);
+                cit_write_reg(gspca_dev, 0x0000, 0x0117);
+                cit_write_reg(gspca_dev, 0x0003, 0x0133);
+                cit_write_reg(gspca_dev, 0x0000, 0x0111);
+                /* HDG windows does this, but I get a green picture when
+                   restarting the stream after this */
+                /* cit_write_reg(gspca_dev, 0x0000, 0x0112); */
+                cit_write_reg(gspca_dev, 0x00c0, 0x0100);
+                break;
+        }
+
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+        /* If the last button state is pressed, release it now! */
+        if (sd->button_state) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                input_sync(gspca_dev->input_dev);
+                sd->button_state = 0;
+        }
+#endif
+}
+
+static u8 *cit_find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 byte3 = 0, byte4 = 0;
+        int i;
+
+        switch (sd->model) {
+        case CIT_MODEL0:
+        case CIT_MODEL1:
+        case CIT_MODEL3:
+        case CIT_IBM_NETCAM_PRO:
+                switch (gspca_dev->width) {
+                case 160: /* 160x120 */
+                        byte3 = 0x02;
+                        byte4 = 0x0a;
+                        break;
+                case 176: /* 176x144 */
+                        byte3 = 0x02;
+                        byte4 = 0x0e;
+                        break;
+                case 320: /* 320x240 */
+                        byte3 = 0x02;
+                        byte4 = 0x08;
+                        break;
+                case 352: /* 352x288 */
+                        byte3 = 0x02;
+                        byte4 = 0x00;
+                        break;
+                case 640:
+                        byte3 = 0x03;
+                        byte4 = 0x08;
+                        break;
+                }
+
+                /* These have a different byte3 */
+                if (sd->model <= CIT_MODEL1)
+                        byte3 = 0x00;
+
+                for (i = 0; i < len; i++) {
+                        /* For this model the SOF always starts at offset 0
+                           so no need to search the entire frame */
+                        if (sd->model == CIT_MODEL0 && sd->sof_read != i)
+                                break;
+
+                        switch (sd->sof_read) {
+                        case 0:
+                                if (data[i] == 0x00)
+                                        sd->sof_read++;
+                                break;
+                        case 1:
+                                if (data[i] == 0xff)
+                                        sd->sof_read++;
+                                else if (data[i] == 0x00)
+                                        sd->sof_read = 1;
+                                else
+                                        sd->sof_read = 0;
+                                break;
+                        case 2:
+                                if (data[i] == byte3)
+                                        sd->sof_read++;
+                                else if (data[i] == 0x00)
+                                        sd->sof_read = 1;
+                                else
+                                        sd->sof_read = 0;
+                                break;
+                        case 3:
+                                if (data[i] == byte4) {
+                                        sd->sof_read = 0;
+                                        return data + i + (sd->sof_len - 3);
+                                }
+                                if (byte3 == 0x00 && data[i] == 0xff)
+                                        sd->sof_read = 2;
+                                else if (data[i] == 0x00)
+                                        sd->sof_read = 1;
+                                else
+                                        sd->sof_read = 0;
+                                break;
+                        }
+                }
+                break;
+        case CIT_MODEL2:
+        case CIT_MODEL4:
+                /* TESTME we need to find a longer sof signature to avoid
+                   false positives */
+                for (i = 0; i < len; i++) {
+                        switch (sd->sof_read) {
+                        case 0:
+                                if (data[i] == 0x00)
+                                        sd->sof_read++;
+                                break;
+                        case 1:
+                                sd->sof_read = 0;
+                                if (data[i] == 0xff) {
+                                        if (i >= 4)
+                                                PDEBUG(D_FRAM,
+                                                       "header found at offset: %d: %02x %02x 00 %02x %02x %02x\n",
+                                                       i - 1,
+                                                       data[i - 4],
+                                                       data[i - 3],
+                                                       data[i],
+                                                       data[i + 1],
+                                                       data[i + 2]);
+                                        else
+                                                PDEBUG(D_FRAM,
+                                                       "header found at offset: %d: 00 %02x %02x %02x\n",
+                                                       i - 1,
+                                                       data[i],
+                                                       data[i + 1],
+                                                       data[i + 2]);
+                                        return data + i + (sd->sof_len - 1);
+                                }
+                                break;
+                        }
+                }
+                break;
+        }
+        return NULL;
+}
+
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        u8 *data, int len)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        unsigned char *sof;
+
+        sof = cit_find_sof(gspca_dev, data, len);
+        if (sof) {
+                int n;
+
+                /* finish decoding current frame */
+                n = sof - data;
+                if (n > sd->sof_len)
+                        n -= sd->sof_len;
+                else
+                        n = 0;
+                gspca_frame_add(gspca_dev, LAST_PACKET,
+                                data, n);
+                gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
+                len -= sof - data;
+                data = sof;
+        }
+
+        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) {
+                if (sd->stop_on_control_change)
+                        sd_stopN(gspca_dev);
+                cit_set_brightness(gspca_dev);
+                if (sd->stop_on_control_change)
+                        cit_restart_stream(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) {
+                if (sd->stop_on_control_change)
+                        sd_stopN(gspca_dev);
+                cit_set_contrast(gspca_dev);
+                if (sd->stop_on_control_change)
+                        cit_restart_stream(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_sethue(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->hue = val;
+        if (gspca_dev->streaming) {
+                if (sd->stop_on_control_change)
+                        sd_stopN(gspca_dev);
+                cit_set_hue(gspca_dev);
+                if (sd->stop_on_control_change)
+                        cit_restart_stream(gspca_dev);
+        }
+        return 0;
+}
+
+static int sd_gethue(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->hue;
+
+        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) {
+                if (sd->stop_on_control_change)
+                        sd_stopN(gspca_dev);
+                cit_set_sharpness(gspca_dev);
+                if (sd->stop_on_control_change)
+                        cit_restart_stream(gspca_dev);
+        }
+        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_setlighting(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->lighting = val;
+        if (gspca_dev->streaming) {
+                if (sd->stop_on_control_change)
+                        sd_stopN(gspca_dev);
+                cit_set_lighting(gspca_dev);
+                if (sd->stop_on_control_change)
+                        cit_restart_stream(gspca_dev);
+        }
+        return 0;
+}
+
+static int sd_getlighting(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->lighting;
+
+        return 0;
+}
+
+static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->hflip = val;
+        if (gspca_dev->streaming) {
+                if (sd->stop_on_control_change)
+                        sd_stopN(gspca_dev);
+                cit_set_hflip(gspca_dev);
+                if (sd->stop_on_control_change)
+                        cit_restart_stream(gspca_dev);
+        }
+        return 0;
+}
+
+static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->hflip;
+
+        return 0;
+}
+
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+static void cit_check_button(struct gspca_dev *gspca_dev)
+{
+        int new_button_state;
+        struct sd *sd = (struct sd *)gspca_dev;
+
+        switch (sd->model) {
+        case CIT_MODEL3:
+        case CIT_IBM_NETCAM_PRO:
+                break;
+        default: /* TEST ME unknown if this works on other models too */
+                return;
+        }
+
+        /* Read the button state */
+        cit_read_reg(gspca_dev, 0x0113, 0);
+        new_button_state = !gspca_dev->usb_buf[0];
+
+        /* Tell the cam we've seen the button press, notice that this
+           is a nop (iow the cam keeps reporting pressed) until the
+           button is actually released. */
+        if (new_button_state)
+                cit_write_reg(gspca_dev, 0x01, 0x0113);
+
+        if (sd->button_state != new_button_state) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA,
+                                 new_button_state);
+                input_sync(gspca_dev->input_dev);
+                sd->button_state = new_button_state;
+        }
+}
+#endif
+
+/* 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,
+        .stop0 = sd_stop0,
+        .pkt_scan = sd_pkt_scan,
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+        .dq_callback = cit_check_button,
+        .other_input = 1,
+#endif
+};
+
+static const struct sd_desc sd_desc_isoc_nego = {
+        .name = MODULE_NAME,
+        .ctrls = sd_ctrls,
+        .nctrls = ARRAY_SIZE(sd_ctrls),
+        .config = sd_config,
+        .init = sd_init,
+        .start = sd_start,
+        .isoc_init = sd_isoc_init,
+        .isoc_nego = sd_isoc_nego,
+        .stopN = sd_stopN,
+        .stop0 = sd_stop0,
+        .pkt_scan = sd_pkt_scan,
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+        .dq_callback = cit_check_button,
+        .other_input = 1,
+#endif
+};
+
+/* -- module initialisation -- */
+static const struct usb_device_id device_table[] = {
+        { USB_DEVICE_VER(0x0545, 0x8080, 0x0001, 0x0001), .driver_info = CIT_MODEL0 },
+        { USB_DEVICE_VER(0x0545, 0x8080, 0x0002, 0x0002), .driver_info = CIT_MODEL1 },
+        { USB_DEVICE_VER(0x0545, 0x8080, 0x030a, 0x030a), .driver_info = CIT_MODEL2 },
+        { USB_DEVICE_VER(0x0545, 0x8080, 0x0301, 0x0301), .driver_info = CIT_MODEL3 },
+        { USB_DEVICE_VER(0x0545, 0x8002, 0x030a, 0x030a), .driver_info = CIT_MODEL4 },
+        { USB_DEVICE_VER(0x0545, 0x800c, 0x030a, 0x030a), .driver_info = CIT_MODEL2 },
+        { USB_DEVICE_VER(0x0545, 0x800d, 0x030a, 0x030a), .driver_info = CIT_MODEL4 },
+        {}
+};
+MODULE_DEVICE_TABLE(usb, device_table);
+
+/* -- device connect -- */
+static int sd_probe(struct usb_interface *intf,
+                        const struct usb_device_id *id)
+{
+        const struct sd_desc *desc = &sd_desc;
+
+        switch (id->driver_info) {
+        case CIT_MODEL0:
+        case CIT_MODEL1:
+                if (intf->cur_altsetting->desc.bInterfaceNumber != 2)
+                        return -ENODEV;
+                break;
+        case CIT_MODEL2:
+        case CIT_MODEL4:
+                if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
+                        return -ENODEV;
+                break;
+        case CIT_MODEL3:
+                if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
+                        return -ENODEV;
+                /* FIXME this likely applies to all model3 cams and probably
+                   to other models too. */
+                if (ibm_netcam_pro)
+                        desc = &sd_desc_isoc_nego;
+                break;
+        }
+
+        return gspca_dev_probe2(intf, id, 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)
+{
+        return usb_register(&sd_driver);
+}
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
diff --git a/drivers/media/video/gspca/zc3xx-reg.h b/drivers/media/video/gspca/zc3xx-reg.h
index bfb559c3b713..a1bd94e8ce52 100644
--- a/drivers/media/video/gspca/zc3xx-reg.h
+++ b/drivers/media/video/gspca/zc3xx-reg.h
@@ -160,8 +160,6 @@
 #define ZC3XX_R1A6_YMEANAFTERAE        0x01a6
 #define ZC3XX_R1A7_CALCGLOBALMEAN      0x01a7
 
-#define ZC3XX_R1A2_BLUEMEANAFTERAGC    0x01a2
-
 /* Matrixes */
 
 /* Color matrix is like :
diff --git a/drivers/media/video/gspca/zc3xx.c b/drivers/media/video/gspca/zc3xx.c
index 0666038a51b0..61cdd56a74a9 100644
--- a/drivers/media/video/gspca/zc3xx.c
+++ b/drivers/media/video/gspca/zc3xx.c
@@ -1,7 +1,7 @@
 /*
  * Z-Star/Vimicro zc301/zc302p/vc30x library
  *
- * Copyright (C) 2009-2010 Jean-Francois Moine <http://moinejf.free.fr>
+ * Copyright (C) 2009-2011 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
@@ -21,9 +21,7 @@
 
 #define MODULE_NAME "zc3xx"
 
-#ifdef CONFIG_INPUT
 #include <linux/input.h>
-#endif
 #include "gspca.h"
 #include "jpeg.h"
 
@@ -37,16 +35,26 @@ static int force_sensor = -1;
 #define QUANT_VAL 1             /* quantization table */
 #include "zc3xx-reg.h"
 
+/* controls */
+enum e_ctrl {
+        BRIGHTNESS,
+        CONTRAST,
+        EXPOSURE,
+        GAMMA,
+        AUTOGAIN,
+        LIGHTFREQ,
+        SHARPNESS,
+        NCTRLS          /* number of controls */
+};
+
+#define AUTOGAIN_DEF 1
+
 /* specific webcam descriptor */
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
 
-        u8 brightness;
-        u8 contrast;
-        u8 gamma;
-        u8 autogain;
-        u8 lightfreq;
-        u8 sharpness;
+        struct gspca_ctrl ctrls[NCTRLS];
+
         u8 quality;                     /* image quality */
 #define QUALITY_MIN 50
 #define QUALITY_MAX 80
@@ -66,8 +74,9 @@ enum sensors {
         SENSOR_ADCM2700,
         SENSOR_CS2102,
         SENSOR_CS2102K,
+        SENSOR_GC0303,
         SENSOR_GC0305,
-        SENSOR_HDCS2020b,
+        SENSOR_HDCS2020,
         SENSOR_HV7131B,
         SENSOR_HV7131R,
         SENSOR_ICM105A,
@@ -81,26 +90,18 @@ enum sensors {
         SENSOR_PB0330,
         SENSOR_PO2030,
         SENSOR_TAS5130C,
-        SENSOR_TAS5130C_VF0250,
         SENSOR_MAX
 };
 
 /* 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 void setcontrast(struct gspca_dev *gspca_dev);
+static void setexposure(struct gspca_dev *gspca_dev);
 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_setgamma(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getgamma(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_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
-
-static const struct ctrl sd_ctrls[] = {
-        {
+static void setlightfreq(struct gspca_dev *gspca_dev);
+static void setsharpness(struct gspca_dev *gspca_dev);
+
+static const struct ctrl sd_ctrls[NCTRLS] = {
+[BRIGHTNESS] = {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -108,13 +109,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define BRIGHTNESS_DEF 128
-                .default_value = BRIGHTNESS_DEF,
+                .default_value = 128,
             },
-            .set = sd_setbrightness,
-            .get = sd_getbrightness,
+            .set_control = setcontrast
         },
-        {
+[CONTRAST] = {
             {
                 .id      = V4L2_CID_CONTRAST,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -122,13 +121,23 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-#define CONTRAST_DEF 128
-                .default_value = CONTRAST_DEF,
+                .default_value = 128,
+            },
+            .set_control = setcontrast
+        },
+[EXPOSURE] = {
+            {
+                .id      = V4L2_CID_EXPOSURE,
+                .type    = V4L2_CTRL_TYPE_INTEGER,
+                .name    = "Exposure",
+                .minimum = 0x30d,
+                .maximum        = 0x493e,
+                .step           = 1,
+                .default_value  = 0x927
             },
-            .set = sd_setcontrast,
-            .get = sd_getcontrast,
+            .set_control = setexposure
         },
-        {
+[GAMMA] = {
             {
                 .id      = V4L2_CID_GAMMA,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -138,10 +147,9 @@ static const struct ctrl sd_ctrls[] = {
                 .step    = 1,
                 .default_value = 4,
             },
-            .set = sd_setgamma,
-            .get = sd_getgamma,
+            .set_control = setcontrast
         },
-        {
+[AUTOGAIN] = {
             {
                 .id      = V4L2_CID_AUTOGAIN,
                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
@@ -149,14 +157,12 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-#define AUTOGAIN_DEF 1
                 .default_value = AUTOGAIN_DEF,
+                .flags   = V4L2_CTRL_FLAG_UPDATE
             },
-            .set = sd_setautogain,
-            .get = sd_getautogain,
+            .set = sd_setautogain
         },
-#define LIGHTFREQ_IDX 4
-        {
+[LIGHTFREQ] = {
             {
                 .id      = V4L2_CID_POWER_LINE_FREQUENCY,
                 .type    = V4L2_CTRL_TYPE_MENU,
@@ -164,13 +170,11 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
                 .step    = 1,
-#define FREQ_DEF 0
-                .default_value = FREQ_DEF,
+                .default_value = 0,
             },
-            .set = sd_setfreq,
-            .get = sd_getfreq,
+            .set_control = setlightfreq
         },
-        {
+[SHARPNESS] = {
             {
                 .id      = V4L2_CID_SHARPNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
@@ -178,11 +182,9 @@ static const struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 3,
                 .step    = 1,
-#define SHARPNESS_DEF 2
-                .default_value = SHARPNESS_DEF,
+                .default_value = 2,
             },
-            .set = sd_setsharpness,
-            .get = sd_getsharpness,
+            .set_control = setsharpness
         },
 };
 
@@ -1513,7 +1515,7 @@ static const struct usb_action gc0305_NoFliker[] = {
         {}
 };
 
-static const struct usb_action hdcs2020b_InitialScale[] = {
+static const struct usb_action hdcs2020_InitialScale[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x11, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},  /* qtable 0x05 */
@@ -1645,7 +1647,7 @@ static const struct usb_action hdcs2020b_InitialScale[] = {
         {0xa0, 0x40, ZC3XX_R118_BGAIN},
         {}
 };
-static const struct usb_action hdcs2020b_Initial[] = {
+static const struct usb_action hdcs2020_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
@@ -1773,7 +1775,7 @@ static const struct usb_action hdcs2020b_Initial[] = {
         {0xa0, 0x40, ZC3XX_R118_BGAIN},
         {}
 };
-static const struct usb_action hdcs2020b_50HZ[] = {
+static const struct usb_action hdcs2020_50HZ[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
         {0xaa, 0x13, 0x0018},                   /* 00,13,18,aa */
         {0xaa, 0x14, 0x0001},                   /* 00,14,01,aa */
@@ -1794,7 +1796,7 @@ static const struct usb_action hdcs2020b_50HZ[] = {
         {0xa0, 0x2f, ZC3XX_R01F_HSYNC_2}, /* 00,1f,2f,cc */
         {}
 };
-static const struct usb_action hdcs2020b_60HZ[] = {
+static const struct usb_action hdcs2020_60HZ[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
         {0xaa, 0x13, 0x0031},                   /* 00,13,31,aa */
         {0xaa, 0x14, 0x0001},                   /* 00,14,01,aa */
@@ -1815,7 +1817,7 @@ static const struct usb_action hdcs2020b_60HZ[] = {
         {0xa0, 0x2c, ZC3XX_R01F_HSYNC_2}, /* 00,1f,2c,cc */
         {}
 };
-static const struct usb_action hdcs2020b_NoFliker[] = {
+static const struct usb_action hdcs2020_NoFliker[] = {
         {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
         {0xaa, 0x13, 0x0010},                   /* 00,13,10,aa */
         {0xaa, 0x14, 0x0001},                   /* 00,14,01,aa */
@@ -2141,7 +2143,6 @@ static const struct usb_action hv7131r_Initial[] = {
         {0xa0, 0x80, ZC3XX_R004_FRAMEWIDTHLOW},
         {0xa0, 0x01, ZC3XX_R005_FRAMEHEIGHTHIGH},
         {0xa0, 0xe0, ZC3XX_R006_FRAMEHEIGHTLOW},
-
         {0xa0, 0x00, ZC3XX_R098_WINYSTARTLOW},
         {0xa0, 0x00, ZC3XX_R09A_WINXSTARTLOW},
         {0xa0, 0x01, ZC3XX_R09B_WINHEIGHTHIGH},
@@ -2893,7 +2894,7 @@ static const struct usb_action mc501cb_Initial[] = {
         {0xaa, 0x11, 0x0001}, /* 00,11,01,aa */
         {0xaa, 0x30, 0x0000}, /* 00,30,00,aa */
         {0xaa, 0x60, 0x0000}, /* 00,60,00,aa */
-        {0xaa, 0xa0, ZC3XX_R01A_LASTFRAMESTATE}, /* 00,a0,1a,aa */
+        {0xaa, 0xa0, 0x001a}, /* 00,a0,1a,aa */
         {0xaa, 0xa1, 0x0000}, /* 00,a1,00,aa */
         {0xaa, 0xa2, 0x003f}, /* 00,a2,3f,aa */
         {0xaa, 0xa3, 0x0028}, /* 00,a3,28,aa */
@@ -2953,7 +2954,7 @@ static const struct usb_action mc501cb_Initial[] = {
         {}
 };
 
-static const struct usb_action mc501cb_InitialScale[] = {        /* 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 */
@@ -3013,7 +3014,7 @@ static const struct usb_action mc501cb_InitialScale[] = {	 /* 320x240 */
         {0xaa, 0x11, 0x0001}, /* 00,11,01,aa */
         {0xaa, 0x30, 0x0000}, /* 00,30,00,aa */
         {0xaa, 0x60, 0x0000}, /* 00,60,00,aa */
-        {0xaa, 0xa0, ZC3XX_R01A_LASTFRAMESTATE}, /* 00,a0,1a,aa */
+        {0xaa, 0xa0, 0x001a}, /* 00,a0,1a,aa */
         {0xaa, 0xa1, 0x0000}, /* 00,a1,00,aa */
         {0xaa, 0xa2, 0x003f}, /* 00,a2,3f,aa */
         {0xaa, 0xa3, 0x0028}, /* 00,a3,28,aa */
@@ -3064,15 +3065,10 @@ static const struct usb_action mc501cb_InitialScale[] = {	 /* 320x240 */
         {0xaa, 0x55, 0x0010}, /* 00,55,10,aa */
         {0xa0, 0xf0, 0x0199}, /* 01,99,F0,cc */
         {0xa0, 0x80, 0x019a}, /* 01,9A,80,cc */
-        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
-        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
-        {0xaa, 0x36, 0x001d}, /* 00,36,1D,aa */
-        {0xaa, 0x37, 0x004c}, /* 00,37,4C,aa */
-        {0xaa, 0x3b, 0x001d}, /* 00,3B,1D,aa */
         {}
 };
 
-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, 0x001d}, /* 00,36,1D,aa */
@@ -3081,15 +3077,10 @@ static const struct usb_action mc501cb_50HZScale[] = {
         {0xaa, 0x3c, 0x004c}, /* 00,3C,4C,aa */
         {0xaa, 0x3d, 0x001d}, /* 00,3D,1D,aa */
         {0xaa, 0x3e, 0x004c}, /* 00,3E,4C,aa */
-        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
-        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
-        {0xaa, 0x36, 0x003a}, /* 00,36,3A,aa */
-        {0xaa, 0x37, 0x0098}, /* 00,37,98,aa */
-        {0xaa, 0x3b, 0x003a}, /* 00,3B,3A,aa */
         {}
 };
 
-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, 0x003a}, /* 00,36,3A,aa */
@@ -3098,15 +3089,10 @@ static const struct usb_action mc501cb_50HZ[] = {
         {0xaa, 0x3c, 0x0098}, /* 00,3C,98,aa */
         {0xaa, 0x3d, 0x003a}, /* 00,3D,3A,aa */
         {0xaa, 0x3e, 0x0098}, /* 00,3E,98,aa */
-        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
-        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
-        {0xaa, 0x36, 0x0018}, /* 00,36,18,aa */
-        {0xaa, 0x37, 0x006a}, /* 00,37,6A,aa */
-        {0xaa, 0x3d, 0x0018}, /* 00,3D,18,aa */
         {}
 };
 
-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, 0x0018}, /* 00,36,18,aa */
@@ -3115,15 +3101,10 @@ static const struct usb_action mc501cb_60HZScale[] = {
         {0xaa, 0x3e, 0x006a}, /* 00,3E,6A,aa */
         {0xaa, 0x3b, 0x0018}, /* 00,3B,18,aa */
         {0xaa, 0x3c, 0x006a}, /* 00,3C,6A,aa */
-        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
-        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
-        {0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
-        {0xaa, 0x37, 0x00d4}, /* 00,37,D4,aa */
-        {0xaa, 0x3d, 0x0030}, /* 00,3D,30,aa */
         {}
 };
 
-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, 0x0030}, /* 00,36,30,aa */
@@ -3132,15 +3113,10 @@ static const struct usb_action mc501cb_60HZ[] = {
         {0xaa, 0x3e, 0x00d4}, /* 00,3E,D4,aa */
         {0xaa, 0x3b, 0x0030}, /* 00,3B,30,aa */
         {0xaa, 0x3c, 0x00d4}, /* 00,3C,D4,aa */
-        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
-        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
-        {0xaa, 0x36, 0x0018}, /* 00,36,18,aa */
-        {0xaa, 0x37, 0x006a}, /* 00,37,6A,aa */
-        {0xaa, 0x3d, 0x0018}, /* 00,3D,18,aa */
         {}
 };
 
-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, 0x0018}, /* 00,36,18,aa */
@@ -3149,15 +3125,10 @@ static const struct usb_action mc501cb_NoFlikerScale[] = {
         {0xaa, 0x3e, 0x006a}, /* 00,3E,6A,aa */
         {0xaa, 0x3b, 0x0018}, /* 00,3B,18,aa */
         {0xaa, 0x3c, 0x006a}, /* 00,3C,6A,aa */
-        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
-        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
-        {0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
-        {0xaa, 0x37, 0x00d4}, /* 00,37,D4,aa */
-        {0xaa, 0x3d, 0x0030}, /* 00,3D,30,aa */
         {}
 };
 
-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, 0x0030}, /* 00,36,30,aa */
@@ -3325,7 +3296,7 @@ static const struct usb_action ov7620_50HZ[] = {
         {0xaa, 0x10, 0x0082},                           /* 00,10,82,aa */
         {0xaa, 0x76, 0x0003},                           /* 00,76,03,aa */
 /*      {0xa0, 0x40, ZC3XX_R002_CLOCKSELECT},            * 00,02,40,cc
-                                                         if mode0 (640x480) */
+                                                         * if mode0 (640x480) */
         {}
 };
 static const struct usb_action ov7620_60HZ[] = {
@@ -3731,7 +3702,6 @@ static const struct usb_action pas106b_InitialScale[] = {	/* 176x144 */
         {0xaa, 0x0d, 0x0000},
         {0xaa, 0x0e, 0x0002},
         {0xaa, 0x14, 0x0081},
-
 /* Other registers */
         {0xa0, 0x37, ZC3XX_R101_SENSORCORRECTION},
 /* Frame retreiving */
@@ -3785,7 +3755,6 @@ static const struct usb_action pas106b_InitialScale[] = {	/* 176x144 */
         {0xa0, 0x05, ZC3XX_R185_WINYWIDTH},
         {0xa0, 0x14, ZC3XX_R186_WINYCENTER},
         {0xa0, 0x00, ZC3XX_R180_AUTOCORRECTENABLE},
-
 /* Auto exposure and white balance */
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},
         {0xa0, 0x03, ZC3XX_R191_EXPOSURELIMITMID},
@@ -3849,7 +3818,6 @@ static const struct usb_action pas106b_Initial[] = {	/* 352x288 */
         {0xaa, 0x0d, 0x0000},
         {0xaa, 0x0e, 0x0002},
         {0xaa, 0x14, 0x0081},
-
 /* Other registers */
         {0xa0, 0x37, ZC3XX_R101_SENSORCORRECTION},
 /* Frame retreiving */
@@ -4504,7 +4472,7 @@ static const struct usb_action mt9v111_3_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
         {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
         {0xa0, 0x0a, ZC3XX_R010_CMOSSENSORSELECT},
-        {0xa0, 0x04, ZC3XX_R002_CLOCKSELECT},
+        {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x02, ZC3XX_R003_FRAMEWIDTHHIGH},
         {0xa0, 0x80, ZC3XX_R004_FRAMEWIDTHLOW},
         {0xa0, 0x01, ZC3XX_R005_FRAMEHEIGHTHIGH},
@@ -5411,7 +5379,7 @@ static const struct usb_action tas5130c_NoFlikerScale[] = {
         {}
 };
 
-static const struct usb_action tas5130c_vf0250_InitialScale[] = {
+static const struct usb_action gc0303_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, */
@@ -5478,7 +5446,7 @@ static const struct usb_action tas5130c_vf0250_InitialScale[] = {
         {}
 };
 
-static const struct usb_action tas5130c_vf0250_Initial[] = {
+static const struct usb_action gc0303_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, */
@@ -5543,7 +5511,7 @@ static const struct usb_action tas5130c_vf0250_Initial[] = {
         {0xa0, 0x65, ZC3XX_R118_BGAIN},         /* 01,18,65,cc */
         {}
 };
-static const struct usb_action tas5130c_vf0250_50HZScale[] = {
+static const struct usb_action gc0303_50HZScale[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0001},           /* 00,83,01,aa */
         {0xaa, 0x84, 0x00aa},           /* 00,84,aa,aa */
@@ -5567,7 +5535,7 @@ static const struct usb_action tas5130c_vf0250_50HZScale[] = {
         {}
 };
 
-static const struct usb_action tas5130c_vf0250_50HZ[] = {
+static const struct usb_action gc0303_50HZ[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0003},           /* 00,83,03,aa */
         {0xaa, 0x84, 0x0054},           /* 00,84,54,aa */
@@ -5591,7 +5559,7 @@ static const struct usb_action tas5130c_vf0250_50HZ[] = {
         {}
 };
 
-static const struct usb_action tas5130c_vf0250_60HZScale[] = {
+static const struct usb_action gc0303_60HZScale[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0001},           /* 00,83,01,aa */
         {0xaa, 0x84, 0x0062},           /* 00,84,62,aa */
@@ -5615,7 +5583,7 @@ static const struct usb_action tas5130c_vf0250_60HZScale[] = {
         {}
 };
 
-static const struct usb_action tas5130c_vf0250_60HZ[] = {
+static const struct usb_action gc0303_60HZ[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0002},           /* 00,83,02,aa */
         {0xaa, 0x84, 0x00c4},           /* 00,84,c4,aa */
@@ -5639,7 +5607,7 @@ static const struct usb_action tas5130c_vf0250_60HZ[] = {
         {}
 };
 
-static const struct usb_action tas5130c_vf0250_NoFlikerScale[] = {
+static const struct usb_action gc0303_NoFlikerScale[] = {
         {0xa0, 0x0c, ZC3XX_R100_OPERATIONMODE},         /* 01,00,0c,cc, */
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0000},           /* 00,83,00,aa */
@@ -5661,7 +5629,7 @@ static const struct usb_action tas5130c_vf0250_NoFlikerScale[] = {
         {}
 };
 
-static const struct usb_action tas5130c_vf0250_NoFliker[] = {
+static const struct usb_action gc0303_NoFliker[] = {
         {0xa0, 0x0c, ZC3XX_R100_OPERATIONMODE},         /* 01,00,0c,cc, */
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0000},           /* 00,83,00,aa */
@@ -5698,7 +5666,7 @@ static u8 reg_r_i(struct gspca_dev *gspca_dev,
                         index, gspca_dev->usb_buf, 1,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_r_i err %d", ret);
+                err("reg_r_i err %d", ret);
                 gspca_dev->usb_err = ret;
                 return 0;
         }
@@ -5730,7 +5698,7 @@ static void reg_w_i(struct gspca_dev *gspca_dev,
                         value, index, NULL, 0,
                         500);
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_w_i err %d", ret);
+                err("reg_w_i err %d", ret);
                 gspca_dev->usb_err = ret;
         }
 }
@@ -5811,7 +5779,7 @@ static void usb_exchange(struct gspca_dev *gspca_dev,
                         break;
                 default:
 /*              case 0xdd:       * delay */
-                        msleep(action->val / 64 + 10);
+                        msleep(action->idx);
                         break;
                 }
                 action++;
@@ -5838,16 +5806,17 @@ static void setmatrix(struct gspca_dev *gspca_dev)
                 {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 gc0303_matrix[9] =
                 {0x7b, 0xea, 0xea, 0xea, 0x7b, 0xea, 0xea, 0xea, 0x7b};
         static const u8 *matrix_tb[SENSOR_MAX] = {
                 [SENSOR_ADCM2700] =     adcm2700_matrix,
                 [SENSOR_CS2102] =       ov7620_matrix,
                 [SENSOR_CS2102K] =      NULL,
+                [SENSOR_GC0303] =       gc0303_matrix,
                 [SENSOR_GC0305] =       gc0305_matrix,
-                [SENSOR_HDCS2020b] =    NULL,
+                [SENSOR_HDCS2020] =     NULL,
                 [SENSOR_HV7131B] =      NULL,
-                [SENSOR_HV7131R] =      NULL,
+                [SENSOR_HV7131R] =      po2030_matrix,
                 [SENSOR_ICM105A] =      po2030_matrix,
                 [SENSOR_MC501CB] =      NULL,
                 [SENSOR_MT9V111_1] =    gc0305_matrix,
@@ -5859,7 +5828,6 @@ static void setmatrix(struct gspca_dev *gspca_dev)
                 [SENSOR_PB0330] =       gc0305_matrix,
                 [SENSOR_PO2030] =       po2030_matrix,
                 [SENSOR_TAS5130C] =     tas5130c_matrix,
-                [SENSOR_TAS5130C_VF0250] = vf0250_matrix,
         };
 
         matrix = matrix_tb[sd->sensor];
@@ -5880,7 +5848,7 @@ static void setsharpness(struct gspca_dev *gspca_dev)
                 {0x10, 0x1e}
         };
 
-        sharpness = sd->sharpness;
+        sharpness = sd->ctrls[SHARPNESS].val;
         reg_w(gspca_dev, sharpness_tb[sharpness][0], 0x01c6);
         reg_r(gspca_dev, 0x01c8);
         reg_r(gspca_dev, 0x01c9);
@@ -5915,10 +5883,10 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                  0xe0, 0xeb, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff},
         };
 
-        Tgamma = gamma_tb[sd->gamma - 1];
+        Tgamma = gamma_tb[sd->ctrls[GAMMA].val - 1];
 
-        contrast = ((int) sd->contrast - 128);          /* -128 / 127 */
-        brightness = ((int) sd->brightness - 128);      /* -128 / 92 */
+        contrast = ((int) sd->ctrls[CONTRAST].val - 128); /* -128 / 127 */
+        brightness = ((int) sd->ctrls[BRIGHTNESS].val - 128); /* -128 / 92 */
         adj = 0;
         gp1 = gp2 = 0;
         for (i = 0; i < 16; i++) {
@@ -5945,6 +5913,26 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                 reg_w(gspca_dev, gr[i], 0x0130 + i);    /* gradient */
 }
 
+static void getexposure(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->ctrls[EXPOSURE].val = (i2c_read(gspca_dev, 0x25) << 9)
+                | (i2c_read(gspca_dev, 0x26) << 1)
+                | (i2c_read(gspca_dev, 0x27) >> 7);
+}
+
+static void setexposure(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int val;
+
+        val = sd->ctrls[EXPOSURE].val;
+        i2c_write(gspca_dev, 0x25, val >> 9, 0x00);
+        i2c_write(gspca_dev, 0x26, val >> 1, 0x00);
+        i2c_write(gspca_dev, 0x27, val << 7, 0x00);
+}
+
 static void setquality(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -5954,6 +5942,7 @@ static void setquality(struct gspca_dev *gspca_dev)
         case SENSOR_ADCM2700:
         case SENSOR_GC0305:
         case SENSOR_HV7131B:
+        case SENSOR_HV7131R:
         case SENSOR_OV7620:
         case SENSOR_PAS202B:
         case SENSOR_PO2030:
@@ -5999,14 +5988,18 @@ static void setlightfreq(struct gspca_dev *gspca_dev)
                 {cs2102_NoFliker, cs2102_NoFlikerScale,
                  NULL, NULL, /* currently disabled */
                  NULL, NULL},
+        [SENSOR_GC0303] =
+                {gc0303_NoFliker, gc0303_NoFlikerScale,
+                 gc0303_50HZ, gc0303_50HZScale,
+                 gc0303_60HZ, gc0303_60HZScale},
         [SENSOR_GC0305] =
                 {gc0305_NoFliker, gc0305_NoFliker,
                  gc0305_50HZ, gc0305_50HZ,
                  gc0305_60HZ, gc0305_60HZ},
-        [SENSOR_HDCS2020b] =
-                {hdcs2020b_NoFliker, hdcs2020b_NoFliker,
-                 hdcs2020b_50HZ, hdcs2020b_50HZ,
-                 hdcs2020b_60HZ, hdcs2020b_60HZ},
+        [SENSOR_HDCS2020] =
+                {hdcs2020_NoFliker, hdcs2020_NoFliker,
+                 hdcs2020_50HZ, hdcs2020_50HZ,
+                 hdcs2020_60HZ, hdcs2020_60HZ},
         [SENSOR_HV7131B] =
                 {hv7131b_NoFliker, hv7131b_NoFlikerScale,
                  hv7131b_50HZ, hv7131b_50HZScale,
@@ -6059,14 +6052,10 @@ static void setlightfreq(struct gspca_dev *gspca_dev)
                 {tas5130c_NoFliker, tas5130c_NoFlikerScale,
                  tas5130c_50HZ, tas5130c_50HZScale,
                  tas5130c_60HZ, tas5130c_60HZScale},
-        [SENSOR_TAS5130C_VF0250] =
-                {tas5130c_vf0250_NoFliker, tas5130c_vf0250_NoFlikerScale,
-                 tas5130c_vf0250_50HZ, tas5130c_vf0250_50HZScale,
-                 tas5130c_vf0250_60HZ, tas5130c_vf0250_60HZScale},
         };
 
-        i = sd->lightfreq * 2;
-        mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
+        i = sd->ctrls[LIGHTFREQ].val * 2;
+        mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
         if (mode)
                 i++;                    /* 320x240 */
         zc3_freq = freq_tb[sd->sensor][i];
@@ -6075,14 +6064,14 @@ static void setlightfreq(struct gspca_dev *gspca_dev)
         usb_exchange(gspca_dev, zc3_freq);
         switch (sd->sensor) {
         case SENSOR_GC0305:
-                if (mode                        /* if 320x240 */
-                    && sd->lightfreq == 1)      /* and 50Hz */
+                if (mode                                /* if 320x240 */
+                    && sd->ctrls[LIGHTFREQ].val == 1)   /* and 50Hz */
                         reg_w(gspca_dev, 0x85, 0x018d);
                                         /* win: 0x80, 0x018d */
                 break;
         case SENSOR_OV7620:
-                if (!mode) {                    /* if 640x480 */
-                        if (sd->lightfreq != 0) /* and 50 or 60 Hz */
+                if (!mode) {                            /* if 640x480 */
+                        if (sd->ctrls[LIGHTFREQ].val != 0) /* and filter */
                                 reg_w(gspca_dev, 0x40, 0x0002);
                         else
                                 reg_w(gspca_dev, 0x44, 0x0002);
@@ -6099,7 +6088,7 @@ static void setautogain(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         u8 autoval;
 
-        if (sd->autogain)
+        if (sd->ctrls[AUTOGAIN].val)
                 autoval = 0x42;
         else
                 autoval = 0x02;
@@ -6108,7 +6097,7 @@ static void setautogain(struct gspca_dev *gspca_dev)
 
 static void send_unknown(struct gspca_dev *gspca_dev, int sensor)
 {
-        reg_w(gspca_dev, 0x01, 0x0000);         /* led off */
+        reg_w(gspca_dev, 0x01, 0x0000);         /* bridge reset */
         switch (sensor) {
         case SENSOR_PAS106:
                 reg_w(gspca_dev, 0x03, 0x003a);
@@ -6126,11 +6115,13 @@ static void send_unknown(struct gspca_dev *gspca_dev, int sensor)
                 reg_w(gspca_dev, 0x02, 0x003b);
                 reg_w(gspca_dev, 0x00, 0x0038);
                 break;
+        case SENSOR_HV7131R:
         case SENSOR_PAS202B:
                 reg_w(gspca_dev, 0x03, 0x003b);
                 reg_w(gspca_dev, 0x0c, 0x003a);
                 reg_w(gspca_dev, 0x0b, 0x0039);
-                reg_w(gspca_dev, 0x0b, 0x0038);
+                if (sensor == SENSOR_PAS202B)
+                        reg_w(gspca_dev, 0x0b, 0x0038);
                 break;
         }
 }
@@ -6275,7 +6266,6 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int i;
-        u8 retbyte;
         u16 retword;
 
 /*fixme: lack of 8b=b3 (11,12)-> 10, 8b=e0 (14,15,16)-> 12 found in gspcav1*/
@@ -6309,8 +6299,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
                 if (chipset_revision_sensor[i].revision == retword) {
                         sd->chip_revision = retword;
                         send_unknown(gspca_dev, SENSOR_PB0330);
-                        return chipset_revision_sensor[i]
-                                                .internal_sensor_id;
+                        return chipset_revision_sensor[i].internal_sensor_id;
                 }
         }
 
@@ -6326,6 +6315,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
                 return 0x0a;                    /* PB0330 */
         }
 
+        /* probe gc0303 / gc0305 */
         reg_w(gspca_dev, 0x01, 0x0000);
         reg_w(gspca_dev, 0x01, 0x0001);
         reg_w(gspca_dev, 0x98, 0x008b);
@@ -6336,8 +6326,8 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
         retword = i2c_read(gspca_dev, 0x00);
         if (retword != 0) {
                 PDEBUG(D_PROBE, "probe 3wr vga type %02x", retword);
-                if (retword == 0x0011)                  /* VF0250 */
-                        return 0x0250;
+                if (retword == 0x0011)                  /* gc0303 */
+                        return 0x0303;
                 if (retword == 0x0029)                  /* gc0305 */
                         send_unknown(gspca_dev, SENSOR_GC0305);
                 return retword;
@@ -6368,8 +6358,12 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
         retword |= i2c_read(gspca_dev, 0x01);           /* ID 1 */
         PDEBUG(D_PROBE, "probe 3wr vga 2 0x%04x", retword);
         if (retword == 0x2030) {
+#ifdef GSPCA_DEBUG
+                u8 retbyte;
+
                 retbyte = i2c_read(gspca_dev, 0x02);    /* revision number */
                 PDEBUG(D_PROBE, "sensor PO2030 rev 0x%02x", retbyte);
+#endif
                 send_unknown(gspca_dev, SENSOR_PO2030);
                 return retword;
         }
@@ -6398,7 +6392,7 @@ static int zcxx_probeSensor(struct gspca_dev *gspca_dev)
         switch (sd->sensor) {
         case SENSOR_MC501CB:
                 return -1;              /* don't probe */
-        case SENSOR_TAS5130C_VF0250:
+        case SENSOR_GC0303:
                         /* may probe but with no write in reg 0x0010 */
                 return -1;              /* don't probe */
         case SENSOR_PAS106:
@@ -6427,13 +6421,13 @@ static int sd_config(struct gspca_dev *gspca_dev,
         /* define some sensors from the vendor/product */
         sd->sensor = id->driver_info;
 
-        sd->sharpness = SHARPNESS_DEF;
-        sd->brightness = BRIGHTNESS_DEF;
-        sd->contrast = CONTRAST_DEF;
-        sd->autogain = AUTOGAIN_DEF;
-        sd->lightfreq = FREQ_DEF;
+        gspca_dev->cam.ctrls = sd->ctrls;
         sd->quality = QUALITY_DEF;
 
+        /* if USB 1.1, let some bandwidth for the audio device */
+        if (gspca_dev->audio && gspca_dev->dev->speed < USB_SPEED_HIGH)
+                gspca_dev->nbalt--;
+
         return 0;
 }
 
@@ -6447,8 +6441,9 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 [SENSOR_ADCM2700] =     4,
                 [SENSOR_CS2102] =       4,
                 [SENSOR_CS2102K] =      5,
+                [SENSOR_GC0303] =       3,
                 [SENSOR_GC0305] =       4,
-                [SENSOR_HDCS2020b] =    4,
+                [SENSOR_HDCS2020] =     4,
                 [SENSOR_HV7131B] =      4,
                 [SENSOR_HV7131R] =      4,
                 [SENSOR_ICM105A] =      4,
@@ -6462,14 +6457,14 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 [SENSOR_PB0330] =       4,
                 [SENSOR_PO2030] =       4,
                 [SENSOR_TAS5130C] =     3,
-                [SENSOR_TAS5130C_VF0250] = 3,
         };
         static const u8 mode_tb[SENSOR_MAX] = {
                 [SENSOR_ADCM2700] =     2,
                 [SENSOR_CS2102] =       1,
                 [SENSOR_CS2102K] =      1,
+                [SENSOR_GC0303] =       1,
                 [SENSOR_GC0305] =       1,
-                [SENSOR_HDCS2020b] =    1,
+                [SENSOR_HDCS2020] =     1,
                 [SENSOR_HV7131B] =      1,
                 [SENSOR_HV7131R] =      1,
                 [SENSOR_ICM105A] =      1,
@@ -6483,7 +6478,6 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 [SENSOR_PB0330] =       1,
                 [SENSOR_PO2030] =       1,
                 [SENSOR_TAS5130C] =     1,
-                [SENSOR_TAS5130C_VF0250] = 1,
         };
 
         sensor = zcxx_probeSensor(gspca_dev);
@@ -6499,12 +6493,11 @@ static int sd_init(struct gspca_dev *gspca_dev)
                         case SENSOR_MC501CB:
                                 PDEBUG(D_PROBE, "Sensor MC501CB");
                                 break;
-                        case SENSOR_TAS5130C_VF0250:
-                                PDEBUG(D_PROBE, "Sensor Tas5130 (VF0250)");
+                        case SENSOR_GC0303:
+                                PDEBUG(D_PROBE, "Sensor GC0303");
                                 break;
                         default:
-                                PDEBUG(D_PROBE,
-                                        "Unknown sensor - set to TAS5130C");
+                                warn("Unknown sensor - set to TAS5130C");
                                 sd->sensor = SENSOR_TAS5130C;
                         }
                         break;
@@ -6534,8 +6527,8 @@ static int sd_init(struct gspca_dev *gspca_dev)
                         sd->sensor = SENSOR_CS2102;
                         break;
                 case 0x08:
-                        PDEBUG(D_PROBE, "Find Sensor HDCS2020(b)");
-                        sd->sensor = SENSOR_HDCS2020b;
+                        PDEBUG(D_PROBE, "Find Sensor HDCS2020");
+                        sd->sensor = SENSOR_HDCS2020;
                         break;
                 case 0x0a:
                         PDEBUG(D_PROBE,
@@ -6588,14 +6581,14 @@ static int sd_init(struct gspca_dev *gspca_dev)
                         PDEBUG(D_PROBE, "Find Sensor GC0305");
                         sd->sensor = SENSOR_GC0305;
                         break;
-                case 0x0250:
-                        PDEBUG(D_PROBE, "Sensor Tas5130 (VF0250)");
-                        sd->sensor =  SENSOR_TAS5130C_VF0250;
+                case 0x0303:
+                        PDEBUG(D_PROBE, "Sensor GC0303");
+                        sd->sensor =  SENSOR_GC0303;
                         break;
                 case 0x2030:
                         PDEBUG(D_PROBE, "Find Sensor PO2030");
                         sd->sensor = SENSOR_PO2030;
-                        sd->sharpness = 0;              /* from win traces */
+                        sd->ctrls[SHARPNESS].def = 0;   /* from win traces */
                         break;
                 case 0x7620:
                         PDEBUG(D_PROBE, "Find Sensor OV7620");
@@ -6610,7 +6603,7 @@ static int sd_init(struct gspca_dev *gspca_dev)
                         sd->sensor = SENSOR_OV7620;     /* same sensor (?) */
                         break;
                 default:
-                        PDEBUG(D_ERR|D_PROBE, "Unknown sensor %04x", sensor);
+                        err("Unknown sensor %04x", sensor);
                         return -EINVAL;
                 }
         }
@@ -6636,13 +6629,23 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 cam->nmodes = ARRAY_SIZE(broken_vga_mode);
                 break;
         }
-        sd->gamma = gamma[sd->sensor];
+
+        sd->ctrls[GAMMA].def = gamma[sd->sensor];
 
         switch (sd->sensor) {
+        case SENSOR_HV7131R:
+                break;
         case SENSOR_OV7630C:
-                gspca_dev->ctrl_dis = (1 << LIGHTFREQ_IDX);
+                gspca_dev->ctrl_dis = (1 << LIGHTFREQ) | (1 << EXPOSURE);
+                break;
+        default:
+                gspca_dev->ctrl_dis = (1 << EXPOSURE);
                 break;
         }
+#if AUTOGAIN_DEF
+        if (sd->ctrls[AUTOGAIN].val)
+                gspca_dev->ctrl_inac = (1 << EXPOSURE);
+#endif
 
         /* switch off the led */
         reg_w(gspca_dev, 0x01, 0x0000);
@@ -6660,10 +6663,12 @@ static int sd_start(struct gspca_dev *gspca_dev)
                         {cs2102_Initial, cs2102_InitialScale},
         [SENSOR_CS2102K] =
                         {cs2102K_Initial, cs2102K_InitialScale},
+        [SENSOR_GC0303] =
+                {gc0303_Initial, gc0303_InitialScale},
         [SENSOR_GC0305] =
                         {gc0305_Initial, gc0305_InitialScale},
-        [SENSOR_HDCS2020b] =
-                        {hdcs2020b_Initial, hdcs2020b_InitialScale},
+        [SENSOR_HDCS2020] =
+                        {hdcs2020_Initial, hdcs2020_InitialScale},
         [SENSOR_HV7131B] =
                         {hv7131b_Initial, hv7131b_InitialScale},
         [SENSOR_HV7131R] =
@@ -6690,8 +6695,6 @@ static int sd_start(struct gspca_dev *gspca_dev)
                         {po2030_Initial, po2030_InitialScale},
         [SENSOR_TAS5130C] =
                         {tas5130c_Initial, tas5130c_InitialScale},
-        [SENSOR_TAS5130C_VF0250] =
-                {tas5130c_vf0250_Initial, tas5130c_vf0250_InitialScale},
         };
 
         /* create the JPEG header */
@@ -6716,7 +6719,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
         case SENSOR_OV7620:
         case SENSOR_PO2030:
         case SENSOR_TAS5130C:
-        case SENSOR_TAS5130C_VF0250:
+        case SENSOR_GC0303:
 /*              msleep(100);                     * ?? */
                 reg_r(gspca_dev, 0x0002);       /* --> 0x40 */
                 reg_w(gspca_dev, 0x09, 0x01ad); /* (from win traces) */
@@ -6727,10 +6730,13 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 reg_w(gspca_dev, 0x02, 0x003b);
                 reg_w(gspca_dev, 0x00, 0x0038);
                 break;
+        case SENSOR_HV7131R:
         case SENSOR_PAS202B:
                 reg_w(gspca_dev, 0x03, 0x003b);
                 reg_w(gspca_dev, 0x0c, 0x003a);
                 reg_w(gspca_dev, 0x0b, 0x0039);
+                if (sd->sensor == SENSOR_HV7131R)
+                        reg_w(gspca_dev, 0x50, ZC3XX_R11D_GLOBALGAIN);
                 break;
         }
 
@@ -6743,6 +6749,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 break;
         case SENSOR_PAS202B:
         case SENSOR_GC0305:
+        case SENSOR_HV7131R:
         case SENSOR_TAS5130C:
                 reg_r(gspca_dev, 0x0008);
                 /* fall thru */
@@ -6755,7 +6762,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
         /* set the gamma tables when not set */
         switch (sd->sensor) {
         case SENSOR_CS2102K:            /* gamma set in xxx_Initial */
-        case SENSOR_HDCS2020b:
+        case SENSOR_HDCS2020:
         case SENSOR_OV7630C:
                 break;
         default:
@@ -6783,6 +6790,11 @@ static int sd_start(struct gspca_dev *gspca_dev)
                                                 /* ms-win + */
                 reg_w(gspca_dev, 0x40, 0x0117);
                 break;
+        case SENSOR_HV7131R:
+                if (!sd->ctrls[AUTOGAIN].val)
+                        setexposure(gspca_dev);
+                reg_w(gspca_dev, 0x00, ZC3XX_R1A7_CALCGLOBALMEAN);
+                break;
         case SENSOR_GC0305:
         case SENSOR_TAS5130C:
                 reg_w(gspca_dev, 0x09, 0x01ad); /* (from win traces) */
@@ -6790,7 +6802,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 /* fall thru */
         case SENSOR_PAS202B:
         case SENSOR_PO2030:
-/*              reg_w(gspca_dev, 0x40, ZC3XX_R117_GGAIN);  * (from win traces) */
+/*              reg_w(gspca_dev, 0x40, ZC3XX_R117_GGAIN); in win traces */
                 reg_r(gspca_dev, 0x0180);
                 break;
         case SENSOR_OV7620:
@@ -6798,7 +6810,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 reg_w(gspca_dev, 0x15, 0x01ae);
                 i2c_read(gspca_dev, 0x13);      /*fixme: returns 0xa3 */
                 i2c_write(gspca_dev, 0x13, 0xa3, 0x00);
-                                         /*fixme: returned value to send? */
+                                        /*fixme: returned value to send? */
                 reg_w(gspca_dev, 0x40, 0x0117);
                 reg_r(gspca_dev, 0x0180);
                 break;
@@ -6831,9 +6843,17 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        if (data[0] == 0xff && data[1] == 0xd8) {       /* start of frame */
+        /* check the JPEG end of frame */
+        if (len >= 3
+         && data[len - 3] == 0xff && data[len - 2] == 0xd9) {
+/*fixme: what does the last byte mean?*/
                 gspca_frame_add(gspca_dev, LAST_PACKET,
-                                        NULL, 0);
+                                        data, len - 1);
+                return;
+        }
+
+        /* check the JPEG start of a frame */
+        if (data[0] == 0xff && data[1] == 0xd8) {
                 /* put the JPEG header in the new frame */
                 gspca_frame_add(gspca_dev, FIRST_PACKET,
                         sd->jpeg_hdr, JPEG_HDR_SZ);
@@ -6841,7 +6861,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                 /* remove the webcam's header:
                  * ff d8 ff fe 00 0e 00 00 ss ss 00 01 ww ww hh hh pp pp
                  *      - 'ss ss' is the frame sequence number (BE)
-                 *      - 'ww ww' and 'hh hh' are the window dimensions (BE)
+                 *      - 'ww ww' and 'hh hh' are the window dimensions (BE)
                  *      - 'pp pp' is the packet sequence number (BE)
                  */
                 data += 18;
@@ -6850,114 +6870,23 @@ 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)
-                setcontrast(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;
+        sd->ctrls[AUTOGAIN].val = val;
+        if (val) {
+                gspca_dev->ctrl_inac |= (1 << EXPOSURE);
+        } else {
+                gspca_dev->ctrl_inac &= ~(1 << EXPOSURE);
+                if (gspca_dev->streaming)
+                        getexposure(gspca_dev);
+        }
         if (gspca_dev->streaming)
                 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_setgamma(struct gspca_dev *gspca_dev, __s32 val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        sd->gamma = val;
-        if (gspca_dev->streaming)
-                setcontrast(gspca_dev);
-        return gspca_dev->usb_err;
-}
-
-static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-
-        *val = sd->gamma;
-        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)
-                setlightfreq(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->lightfreq;
-        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_querymenu(struct gspca_dev *gspca_dev,
                         struct v4l2_querymenu *menu)
 {
@@ -7007,7 +6936,7 @@ static int sd_get_jcomp(struct gspca_dev *gspca_dev,
         return 0;
 }
 
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrput packet length */
@@ -7035,12 +6964,12 @@ static const struct sd_desc sd_desc = {
         .querymenu = sd_querymenu,
         .get_jcomp = sd_get_jcomp,
         .set_jcomp = sd_set_jcomp,
-#ifdef CONFIG_INPUT
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
 
-static const __devinitdata struct usb_device_id device_table[] = {
+static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x041e)},
         {USB_DEVICE(0x041e, 0x4017)},
         {USB_DEVICE(0x041e, 0x401c), .driver_info = SENSOR_PAS106},
@@ -7052,8 +6981,8 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x4035), .driver_info = SENSOR_PAS106},
         {USB_DEVICE(0x041e, 0x4036)},
         {USB_DEVICE(0x041e, 0x403a)},
-        {USB_DEVICE(0x041e, 0x4051), .driver_info = SENSOR_TAS5130C_VF0250},
-        {USB_DEVICE(0x041e, 0x4053), .driver_info = SENSOR_TAS5130C_VF0250},
+        {USB_DEVICE(0x041e, 0x4051), .driver_info = SENSOR_GC0303},
+        {USB_DEVICE(0x041e, 0x4053), .driver_info = SENSOR_GC0303},
         {USB_DEVICE(0x0458, 0x7007)},
         {USB_DEVICE(0x0458, 0x700c)},
         {USB_DEVICE(0x0458, 0x700f)},
@@ -7073,8 +7002,8 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x046d, 0x08af)},
         {USB_DEVICE(0x046d, 0x08b9)},
         {USB_DEVICE(0x046d, 0x08d7)},
-        {USB_DEVICE(0x046d, 0x08d9)},
         {USB_DEVICE(0x046d, 0x08d8)},
+        {USB_DEVICE(0x046d, 0x08d9)},
         {USB_DEVICE(0x046d, 0x08da)},
         {USB_DEVICE(0x046d, 0x08dd), .driver_info = SENSOR_MC501CB},
         {USB_DEVICE(0x0471, 0x0325), .driver_info = SENSOR_PAS106},
@@ -7120,18 +7049,12 @@ static struct usb_driver sd_driver = {
 
 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;
+        return usb_register(&sd_driver);
 }
 
 static void __exit sd_mod_exit(void)
 {
         usb_deregister(&sd_driver);
-        PDEBUG(D_PROBE, "deregistered");
 }
 
 module_init(sd_mod_init);