102 files changed, 5792 insertions, 2788 deletions

diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index dcf9fa9264bb..1d758525d236 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -203,9 +203,9 @@ config VIDEO_CS53L32A
           module will be called cs53l32a.
 
 config VIDEO_M52790
-       tristate "Mitsubishi M52790 A/V switch"
-       depends on VIDEO_V4L2 && I2C
-       ---help---
+        tristate "Mitsubishi M52790 A/V switch"
+        depends on VIDEO_V4L2 && I2C
+        ---help---
          Support for the Mitsubishi M52790 A/V switch.
 
          To compile this driver as a module, choose M here: the
diff --git a/drivers/media/video/au0828/au0828-dvb.c b/drivers/media/video/au0828/au0828-dvb.c
index 14baffc22192..b8a4b52e8d47 100644
--- a/drivers/media/video/au0828/au0828-dvb.c
+++ b/drivers/media/video/au0828/au0828-dvb.c
@@ -151,7 +151,7 @@ static int start_urb_transfer(struct au0828_dev *dev)
         dprintk(2, "%s()\n", __func__);
 
         if (dev->urb_streaming) {
-                dprintk(2, "%s: iso xfer already running!\n", __func__);
+                dprintk(2, "%s: bulk xfer already running!\n", __func__);
                 return 0;
         }
 
diff --git a/drivers/media/video/au0828/au0828-i2c.c b/drivers/media/video/au0828/au0828-i2c.c
index 13e494365e70..cbdb65c34f21 100644
--- a/drivers/media/video/au0828/au0828-i2c.c
+++ b/drivers/media/video/au0828/au0828-i2c.c
@@ -320,7 +320,6 @@ static struct i2c_algorithm au0828_i2c_algo_template = {
 static struct i2c_adapter au0828_i2c_adap_template = {
         .name              = DRIVER_NAME,
         .owner             = THIS_MODULE,
-        .id                = I2C_HW_B_AU0828,
         .algo              = &au0828_i2c_algo_template,
 };
 
diff --git a/drivers/media/video/bt8xx/bttv-cards.c b/drivers/media/video/bt8xx/bttv-cards.c
index ca6558c394be..b42251fa96ba 100644
--- a/drivers/media/video/bt8xx/bttv-cards.c
+++ b/drivers/media/video/bt8xx/bttv-cards.c
@@ -1274,6 +1274,7 @@ struct tvcard bttv_tvcards[] = {
                 .pll            = PLL_28,
                 .tuner_type     = TUNER_TEMIC_PAL,
                 .tuner_addr     = ADDR_UNSET,
+                .has_remote     = 1,
         },
 
         /* ---- card 0x3c ---------------------------------- */
diff --git a/drivers/media/video/bt8xx/bttv-driver.c b/drivers/media/video/bt8xx/bttv-driver.c
index 8cc6dd28d6a7..939d1e512974 100644
--- a/drivers/media/video/bt8xx/bttv-driver.c
+++ b/drivers/media/video/bt8xx/bttv-driver.c
@@ -2652,6 +2652,8 @@ static int bttv_querycap(struct file *file, void  *priv,
                 V4L2_CAP_VBI_CAPTURE |
                 V4L2_CAP_READWRITE |
                 V4L2_CAP_STREAMING;
+        if (btv->has_saa6588)
+                cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
         if (no_overlay <= 0)
                 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
 
@@ -4593,14 +4595,10 @@ static int bttv_resume(struct pci_dev *pci_dev)
 #endif
 
 static struct pci_device_id bttv_pci_tbl[] = {
-        {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
+        {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
+        {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
+        {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
         {0,}
 };
 
diff --git a/drivers/media/video/bt8xx/bttv-i2c.c b/drivers/media/video/bt8xx/bttv-i2c.c
index ebd1ee9dc871..beda363418b0 100644
--- a/drivers/media/video/bt8xx/bttv-i2c.c
+++ b/drivers/media/video/bt8xx/bttv-i2c.c
@@ -352,7 +352,6 @@ int __devinit init_bttv_i2c(struct bttv *btv)
                 /* bt878 */
                 strlcpy(btv->c.i2c_adap.name, "bt878",
                         sizeof(btv->c.i2c_adap.name));
-                btv->c.i2c_adap.id = I2C_HW_B_BT848;    /* FIXME */
                 btv->c.i2c_adap.algo = &bttv_algo;
         } else {
                 /* bt848 */
@@ -362,7 +361,6 @@ int __devinit init_bttv_i2c(struct bttv *btv)
 
                 strlcpy(btv->c.i2c_adap.name, "bttv",
                         sizeof(btv->c.i2c_adap.name));
-                btv->c.i2c_adap.id = I2C_HW_B_BT848;
                 memcpy(&btv->i2c_algo, &bttv_i2c_algo_bit_template,
                        sizeof(bttv_i2c_algo_bit_template));
                 btv->i2c_algo.udelay = i2c_udelay;
diff --git a/drivers/media/video/bt8xx/bttv-input.c b/drivers/media/video/bt8xx/bttv-input.c
index 2f289d981fe6..ebd51afe8761 100644
--- a/drivers/media/video/bt8xx/bttv-input.c
+++ b/drivers/media/video/bt8xx/bttv-input.c
@@ -245,7 +245,7 @@ static void bttv_ir_stop(struct bttv *btv)
 int bttv_input_init(struct bttv *btv)
 {
         struct card_ir *ir;
-        IR_KEYTAB_TYPE *ir_codes = NULL;
+        struct ir_scancode_table *ir_codes = NULL;
         struct input_dev *input_dev;
         int ir_type = IR_TYPE_OTHER;
         int err = -ENOMEM;
@@ -263,7 +263,7 @@ int bttv_input_init(struct bttv *btv)
         case BTTV_BOARD_AVERMEDIA:
         case BTTV_BOARD_AVPHONE98:
         case BTTV_BOARD_AVERMEDIA98:
-                ir_codes         = ir_codes_avermedia;
+                ir_codes         = &ir_codes_avermedia_table;
                 ir->mask_keycode = 0xf88000;
                 ir->mask_keydown = 0x010000;
                 ir->polling      = 50; // ms
@@ -271,14 +271,14 @@ int bttv_input_init(struct bttv *btv)
 
         case BTTV_BOARD_AVDVBT_761:
         case BTTV_BOARD_AVDVBT_771:
-                ir_codes         = ir_codes_avermedia_dvbt;
+                ir_codes         = &ir_codes_avermedia_dvbt_table;
                 ir->mask_keycode = 0x0f00c0;
                 ir->mask_keydown = 0x000020;
                 ir->polling      = 50; // ms
                 break;
 
         case BTTV_BOARD_PXELVWPLTVPAK:
-                ir_codes         = ir_codes_pixelview;
+                ir_codes         = &ir_codes_pixelview_table;
                 ir->mask_keycode = 0x003e00;
                 ir->mask_keyup   = 0x010000;
                 ir->polling      = 50; // ms
@@ -286,54 +286,55 @@ int bttv_input_init(struct bttv *btv)
         case BTTV_BOARD_PV_M4900:
         case BTTV_BOARD_PV_BT878P_9B:
         case BTTV_BOARD_PV_BT878P_PLUS:
-                ir_codes         = ir_codes_pixelview;
+                ir_codes         = &ir_codes_pixelview_table;
                 ir->mask_keycode = 0x001f00;
                 ir->mask_keyup   = 0x008000;
                 ir->polling      = 50; // ms
                 break;
 
         case BTTV_BOARD_WINFAST2000:
-                ir_codes         = ir_codes_winfast;
+                ir_codes         = &ir_codes_winfast_table;
                 ir->mask_keycode = 0x1f8;
                 break;
         case BTTV_BOARD_MAGICTVIEW061:
         case BTTV_BOARD_MAGICTVIEW063:
-                ir_codes         = ir_codes_winfast;
+                ir_codes         = &ir_codes_winfast_table;
                 ir->mask_keycode = 0x0008e000;
                 ir->mask_keydown = 0x00200000;
                 break;
         case BTTV_BOARD_APAC_VIEWCOMP:
-                ir_codes         = ir_codes_apac_viewcomp;
+                ir_codes         = &ir_codes_apac_viewcomp_table;
                 ir->mask_keycode = 0x001f00;
                 ir->mask_keyup   = 0x008000;
                 ir->polling      = 50; // ms
                 break;
+        case BTTV_BOARD_ASKEY_CPH03X:
         case BTTV_BOARD_CONCEPTRONIC_CTVFMI2:
         case BTTV_BOARD_CONTVFMI:
-                ir_codes         = ir_codes_pixelview;
+                ir_codes         = &ir_codes_pixelview_table;
                 ir->mask_keycode = 0x001F00;
                 ir->mask_keyup   = 0x006000;
                 ir->polling      = 50; // ms
                 break;
         case BTTV_BOARD_NEBULA_DIGITV:
-                ir_codes = ir_codes_nebula;
+                ir_codes = &ir_codes_nebula_table;
                 btv->custom_irq = bttv_rc5_irq;
                 ir->rc5_gpio = 1;
                 break;
         case BTTV_BOARD_MACHTV_MAGICTV:
-                ir_codes         = ir_codes_apac_viewcomp;
+                ir_codes         = &ir_codes_apac_viewcomp_table;
                 ir->mask_keycode = 0x001F00;
                 ir->mask_keyup   = 0x004000;
                 ir->polling      = 50; /* ms */
                 break;
         case BTTV_BOARD_KOZUMI_KTV_01C:
-                ir_codes         = ir_codes_pctv_sedna;
+                ir_codes         = &ir_codes_pctv_sedna_table;
                 ir->mask_keycode = 0x001f00;
                 ir->mask_keyup   = 0x006000;
                 ir->polling      = 50; /* ms */
                 break;
         case BTTV_BOARD_ENLTV_FM_2:
-                ir_codes         = ir_codes_encore_enltv2;
+                ir_codes         = &ir_codes_encore_enltv2_table;
                 ir->mask_keycode = 0x00fd00;
                 ir->mask_keyup   = 0x000080;
                 ir->polling      = 1; /* ms */
diff --git a/drivers/media/video/cafe_ccic.c b/drivers/media/video/cafe_ccic.c
index c4d181dde1ca..9c149a781294 100644
--- a/drivers/media/video/cafe_ccic.c
+++ b/drivers/media/video/cafe_ccic.c
@@ -490,7 +490,6 @@ static int cafe_smbus_setup(struct cafe_camera *cam)
         int ret;
 
         cafe_smbus_enable_irq(cam);
-        adap->id = I2C_HW_SMBUS_CAFE;
         adap->owner = THIS_MODULE;
         adap->algo = &cafe_smbus_algo;
         strcpy(adap->name, "cafe_ccic");
diff --git a/drivers/media/video/cx18/cx18-cards.c b/drivers/media/video/cx18/cx18-cards.c
index 36f2d76006fd..f11e47a58286 100644
--- a/drivers/media/video/cx18/cx18-cards.c
+++ b/drivers/media/video/cx18/cx18-cards.c
@@ -56,7 +56,8 @@ static const struct cx18_card cx18_card_hvr1600_esmt = {
         .hw_audio_ctrl = CX18_HW_418_AV,
         .hw_muxer = CX18_HW_CS5345,
         .hw_all = CX18_HW_TVEEPROM | CX18_HW_418_AV | CX18_HW_TUNER |
-                  CX18_HW_CS5345 | CX18_HW_DVB | CX18_HW_GPIO_RESET_CTRL,
+                  CX18_HW_CS5345 | CX18_HW_DVB | CX18_HW_GPIO_RESET_CTRL |
+                  CX18_HW_Z8F0811_IR_HAUP,
         .video_inputs = {
                 { CX18_CARD_INPUT_VID_TUNER,  0, CX18_AV_COMPOSITE7 },
                 { CX18_CARD_INPUT_SVIDEO1,    1, CX18_AV_SVIDEO1    },
@@ -102,7 +103,8 @@ static const struct cx18_card cx18_card_hvr1600_samsung = {
         .hw_audio_ctrl = CX18_HW_418_AV,
         .hw_muxer = CX18_HW_CS5345,
         .hw_all = CX18_HW_TVEEPROM | CX18_HW_418_AV | CX18_HW_TUNER |
-                  CX18_HW_CS5345 | CX18_HW_DVB | CX18_HW_GPIO_RESET_CTRL,
+                  CX18_HW_CS5345 | CX18_HW_DVB | CX18_HW_GPIO_RESET_CTRL |
+                  CX18_HW_Z8F0811_IR_HAUP,
         .video_inputs = {
                 { CX18_CARD_INPUT_VID_TUNER,  0, CX18_AV_COMPOSITE7 },
                 { CX18_CARD_INPUT_SVIDEO1,    1, CX18_AV_SVIDEO1    },
@@ -204,7 +206,7 @@ static const struct cx18_card cx18_card_mpc718 = {
         .v4l2_capabilities = CX18_CAP_ENCODER,
         .hw_audio_ctrl = CX18_HW_418_AV,
         .hw_muxer = CX18_HW_GPIO_MUX,
-        .hw_all = CX18_HW_418_AV | CX18_HW_TUNER |
+        .hw_all = CX18_HW_TVEEPROM | CX18_HW_418_AV | CX18_HW_TUNER |
                   CX18_HW_GPIO_MUX | CX18_HW_DVB | CX18_HW_GPIO_RESET_CTRL,
         .video_inputs = {
                 { CX18_CARD_INPUT_VID_TUNER,  0, CX18_AV_COMPOSITE2 },
diff --git a/drivers/media/video/cx18/cx18-cards.h b/drivers/media/video/cx18/cx18-cards.h
index 3c552b6b7c4d..444e3c7c563e 100644
--- a/drivers/media/video/cx18/cx18-cards.h
+++ b/drivers/media/video/cx18/cx18-cards.h
@@ -22,13 +22,17 @@
  */
 
 /* hardware flags */
-#define CX18_HW_TUNER           (1 << 0)
-#define CX18_HW_TVEEPROM        (1 << 1)
-#define CX18_HW_CS5345          (1 << 2)
-#define CX18_HW_DVB             (1 << 3)
-#define CX18_HW_418_AV          (1 << 4)
-#define CX18_HW_GPIO_MUX        (1 << 5)
-#define CX18_HW_GPIO_RESET_CTRL (1 << 6)
+#define CX18_HW_TUNER                   (1 << 0)
+#define CX18_HW_TVEEPROM                (1 << 1)
+#define CX18_HW_CS5345                  (1 << 2)
+#define CX18_HW_DVB                     (1 << 3)
+#define CX18_HW_418_AV                  (1 << 4)
+#define CX18_HW_GPIO_MUX                (1 << 5)
+#define CX18_HW_GPIO_RESET_CTRL         (1 << 6)
+#define CX18_HW_Z8F0811_IR_TX_HAUP      (1 << 7)
+#define CX18_HW_Z8F0811_IR_RX_HAUP      (1 << 8)
+#define CX18_HW_Z8F0811_IR_HAUP (CX18_HW_Z8F0811_IR_RX_HAUP | \
+                                 CX18_HW_Z8F0811_IR_TX_HAUP)
 
 /* video inputs */
 #define CX18_CARD_INPUT_VID_TUNER       1
diff --git a/drivers/media/video/cx18/cx18-driver.c b/drivers/media/video/cx18/cx18-driver.c
index 92026e82e10e..dd0224f328ad 100644
--- a/drivers/media/video/cx18/cx18-driver.c
+++ b/drivers/media/video/cx18/cx18-driver.c
@@ -268,6 +268,20 @@ static void cx18_iounmap(struct cx18 *cx)
         }
 }
 
+static void cx18_eeprom_dump(struct cx18 *cx, unsigned char *eedata, int len)
+{
+        int i;
+
+        CX18_INFO("eeprom dump:\n");
+        for (i = 0; i < len; i++) {
+                if (0 == (i % 16))
+                        CX18_INFO("eeprom %02x:", i);
+                printk(KERN_CONT " %02x", eedata[i]);
+                if (15 == (i % 16))
+                        printk(KERN_CONT "\n");
+        }
+}
+
 /* Hauppauge card? get values from tveeprom */
 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
 {
@@ -279,8 +293,26 @@ void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
         c.adapter = &cx->i2c_adap[0];
         c.addr = 0xA0 >> 1;
 
-        tveeprom_read(&c, eedata, sizeof(eedata));
-        tveeprom_hauppauge_analog(&c, tv, eedata);
+        memset(tv, 0, sizeof(*tv));
+        if (tveeprom_read(&c, eedata, sizeof(eedata)))
+                return;
+
+        switch (cx->card->type) {
+        case CX18_CARD_HVR_1600_ESMT:
+        case CX18_CARD_HVR_1600_SAMSUNG:
+                tveeprom_hauppauge_analog(&c, tv, eedata);
+                break;
+        case CX18_CARD_YUAN_MPC718:
+                tv->model = 0x718;
+                cx18_eeprom_dump(cx, eedata, sizeof(eedata));
+                CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x\n",
+                          eedata[2], eedata[1], eedata[4], eedata[3]);
+                break;
+        default:
+                tv->model = 0xffffffff;
+                cx18_eeprom_dump(cx, eedata, sizeof(eedata));
+                break;
+        }
 }
 
 static void cx18_process_eeprom(struct cx18 *cx)
@@ -298,6 +330,11 @@ static void cx18_process_eeprom(struct cx18 *cx)
         case 74000 ... 74999:
                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
                 break;
+        case 0x718:
+                return;
+        case 0xffffffff:
+                CX18_INFO("Unknown EEPROM encoding\n");
+                return;
         case 0:
                 CX18_ERR("Invalid EEPROM\n");
                 return;
diff --git a/drivers/media/video/cx18/cx18-fileops.c b/drivers/media/video/cx18/cx18-fileops.c
index 29969c18949c..04d9c2508b86 100644
--- a/drivers/media/video/cx18/cx18-fileops.c
+++ b/drivers/media/video/cx18/cx18-fileops.c
@@ -690,7 +690,7 @@ int cx18_v4l2_open(struct file *filp)
         int res;
         struct video_device *video_dev = video_devdata(filp);
         struct cx18_stream *s = video_get_drvdata(video_dev);
-        struct cx18 *cx = s->cx;;
+        struct cx18 *cx = s->cx;
 
         mutex_lock(&cx->serialize_lock);
         if (cx18_init_on_first_open(cx)) {
diff --git a/drivers/media/video/cx18/cx18-i2c.c b/drivers/media/video/cx18/cx18-i2c.c
index 8591e4fc359f..da395fef50df 100644
--- a/drivers/media/video/cx18/cx18-i2c.c
+++ b/drivers/media/video/cx18/cx18-i2c.c
@@ -28,6 +28,7 @@
 #include "cx18-gpio.h"
 #include "cx18-i2c.h"
 #include "cx18-irq.h"
+#include <media/ir-kbd-i2c.h>
 
 #define CX18_REG_I2C_1_WR   0xf15000
 #define CX18_REG_I2C_1_RD   0xf15008
@@ -40,16 +41,20 @@
 #define GETSDL_BIT      0x0008
 
 #define CX18_CS5345_I2C_ADDR            0x4c
+#define CX18_Z8F0811_IR_TX_I2C_ADDR     0x70
+#define CX18_Z8F0811_IR_RX_I2C_ADDR     0x71
 
 /* This array should match the CX18_HW_ defines */
 static const u8 hw_addrs[] = {
-        0,                      /* CX18_HW_TUNER */
-        0,                      /* CX18_HW_TVEEPROM */
-        CX18_CS5345_I2C_ADDR,   /* CX18_HW_CS5345 */
-        0,                      /* CX18_HW_DVB */
-        0,                      /* CX18_HW_418_AV */
-        0,                      /* CX18_HW_GPIO_MUX */
-        0,                      /* CX18_HW_GPIO_RESET_CTRL */
+        0,                              /* CX18_HW_TUNER */
+        0,                              /* CX18_HW_TVEEPROM */
+        CX18_CS5345_I2C_ADDR,           /* CX18_HW_CS5345 */
+        0,                              /* CX18_HW_DVB */
+        0,                              /* CX18_HW_418_AV */
+        0,                              /* CX18_HW_GPIO_MUX */
+        0,                              /* CX18_HW_GPIO_RESET_CTRL */
+        CX18_Z8F0811_IR_TX_I2C_ADDR,    /* CX18_HW_Z8F0811_IR_TX_HAUP */
+        CX18_Z8F0811_IR_RX_I2C_ADDR,    /* CX18_HW_Z8F0811_IR_RX_HAUP */
 };
 
 /* This array should match the CX18_HW_ defines */
@@ -62,6 +67,8 @@ static const u8 hw_bus[] = {
         0,      /* CX18_HW_418_AV */
         0,      /* CX18_HW_GPIO_MUX */
         0,      /* CX18_HW_GPIO_RESET_CTRL */
+        0,      /* CX18_HW_Z8F0811_IR_TX_HAUP */
+        0,      /* CX18_HW_Z8F0811_IR_RX_HAUP */
 };
 
 /* This array should match the CX18_HW_ defines */
@@ -73,6 +80,8 @@ static const char * const hw_modules[] = {
         NULL,           /* CX18_HW_418_AV */
         NULL,           /* CX18_HW_GPIO_MUX */
         NULL,           /* CX18_HW_GPIO_RESET_CTRL */
+        NULL,           /* CX18_HW_Z8F0811_IR_TX_HAUP */
+        NULL,           /* CX18_HW_Z8F0811_IR_RX_HAUP */
 };
 
 /* This array should match the CX18_HW_ defines */
@@ -84,8 +93,38 @@ static const char * const hw_devicenames[] = {
         "cx23418_AV",
         "gpio_mux",
         "gpio_reset_ctrl",
+        "ir_tx_z8f0811_haup",
+        "ir_rx_z8f0811_haup",
 };
 
+static const struct IR_i2c_init_data z8f0811_ir_init_data = {
+        .ir_codes = &ir_codes_hauppauge_new_table,
+        .internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR,
+        .type = IR_TYPE_RC5,
+        .name = "CX23418 Z8F0811 Hauppauge",
+};
+
+static int cx18_i2c_new_ir(struct i2c_adapter *adap, u32 hw, const char *type,
+                           u8 addr)
+{
+        struct i2c_board_info info;
+        unsigned short addr_list[2] = { addr, I2C_CLIENT_END };
+
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, type, I2C_NAME_SIZE);
+
+        /* Our default information for ir-kbd-i2c.c to use */
+        switch (hw) {
+        case CX18_HW_Z8F0811_IR_RX_HAUP:
+                info.platform_data = &z8f0811_ir_init_data;
+                break;
+        default:
+                break;
+        }
+
+        return i2c_new_probed_device(adap, &info, addr_list) == NULL ? -1 : 0;
+}
+
 int cx18_i2c_register(struct cx18 *cx, unsigned idx)
 {
         struct v4l2_subdev *sd;
@@ -115,11 +154,14 @@ int cx18_i2c_register(struct cx18 *cx, unsigned idx)
                 return sd != NULL ? 0 : -1;
         }
 
+        if (hw & CX18_HW_Z8F0811_IR_HAUP)
+                return cx18_i2c_new_ir(adap, hw, type, hw_addrs[idx]);
+
         /* Is it not an I2C device or one we do not wish to register? */
         if (!hw_addrs[idx])
                 return -1;
 
-        /* It's an I2C device other than an analog tuner */
+        /* It's an I2C device other than an analog tuner or IR chip */
         sd = v4l2_i2c_new_subdev(&cx->v4l2_dev, adap, mod, type, hw_addrs[idx]);
         if (sd != NULL)
                 sd->grp_id = hw;
@@ -190,7 +232,6 @@ static int cx18_getsda(void *data)
 /* template for i2c-bit-algo */
 static struct i2c_adapter cx18_i2c_adap_template = {
         .name = "cx18 i2c driver",
-        .id = I2C_HW_B_CX2341X,
         .algo = NULL,                   /* set by i2c-algo-bit */
         .algo_data = NULL,              /* filled from template */
         .owner = THIS_MODULE,
diff --git a/drivers/media/video/cx18/cx18-ioctl.c b/drivers/media/video/cx18/cx18-ioctl.c
index d7b1921e6666..fc76e4d6ffa7 100644
--- a/drivers/media/video/cx18/cx18-ioctl.c
+++ b/drivers/media/video/cx18/cx18-ioctl.c
@@ -605,7 +605,7 @@ int cx18_s_input(struct file *file, void *fh, unsigned int inp)
         if (ret)
                 return ret;
 
-        if (inp < 0 || inp >= cx->nof_inputs)
+        if (inp >= cx->nof_inputs)
                 return -EINVAL;
 
         if (inp == cx->active_input) {
diff --git a/drivers/media/video/cx231xx/cx231xx-conf-reg.h b/drivers/media/video/cx231xx/cx231xx-conf-reg.h
index a6f398a175c5..31a8759f6e54 100644
--- a/drivers/media/video/cx231xx/cx231xx-conf-reg.h
+++ b/drivers/media/video/cx231xx/cx231xx-conf-reg.h
@@ -60,10 +60,10 @@
 #define PWR_RESETOUT_EN         0x100  /* bit8 */
 
 enum AV_MODE{
-       POLARIS_AVMODE_DEFAULT = 0,
-       POLARIS_AVMODE_DIGITAL = 0x10,
-       POLARIS_AVMODE_ANALOGT_TV = 0x20,
-       POLARIS_AVMODE_ENXTERNAL_AV = 0x30,
+        POLARIS_AVMODE_DEFAULT = 0,
+        POLARIS_AVMODE_DIGITAL = 0x10,
+        POLARIS_AVMODE_ANALOGT_TV = 0x20,
+        POLARIS_AVMODE_ENXTERNAL_AV = 0x30,
 
 };
 
diff --git a/drivers/media/video/cx231xx/cx231xx-i2c.c b/drivers/media/video/cx231xx/cx231xx-i2c.c
index 33219dc4d649..58d9cc0867b9 100644
--- a/drivers/media/video/cx231xx/cx231xx-i2c.c
+++ b/drivers/media/video/cx231xx/cx231xx-i2c.c
@@ -432,7 +432,6 @@ static struct i2c_algorithm cx231xx_algo = {
 static struct i2c_adapter cx231xx_adap_template = {
         .owner = THIS_MODULE,
         .name = "cx231xx",
-        .id = I2C_HW_B_CX231XX,
         .algo = &cx231xx_algo,
 };
 
diff --git a/drivers/media/video/cx231xx/cx231xx-video.c b/drivers/media/video/cx231xx/cx231xx-video.c
index 609bae6098d3..36503725d973 100644
--- a/drivers/media/video/cx231xx/cx231xx-video.c
+++ b/drivers/media/video/cx231xx/cx231xx-video.c
@@ -923,8 +923,8 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 
         f->fmt.pix.width = dev->width;
         f->fmt.pix.height = dev->height;
-        f->fmt.pix.pixelformat = dev->format->fourcc;;
-        f->fmt.pix.bytesperline = (dev->width * dev->format->depth + 7) >> 3;;
+        f->fmt.pix.pixelformat = dev->format->fourcc;
+        f->fmt.pix.bytesperline = (dev->width * dev->format->depth + 7) >> 3;
         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * dev->height;
         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 
diff --git a/drivers/media/video/cx231xx/cx231xx.h b/drivers/media/video/cx231xx/cx231xx.h
index a0f823ac6b8d..64e2ddd3c401 100644
--- a/drivers/media/video/cx231xx/cx231xx.h
+++ b/drivers/media/video/cx231xx/cx231xx.h
@@ -282,7 +282,7 @@ struct cx231xx_board {
 
         struct cx231xx_input input[MAX_CX231XX_INPUT];
         struct cx231xx_input radio;
-        IR_KEYTAB_TYPE *ir_codes;
+        struct ir_scancode_table *ir_codes;
 };
 
 /* device states */
diff --git a/drivers/media/video/cx23885/cimax2.c b/drivers/media/video/cx23885/cimax2.c
index 08582e58bdbf..0316257b7345 100644
--- a/drivers/media/video/cx23885/cimax2.c
+++ b/drivers/media/video/cx23885/cimax2.c
@@ -443,6 +443,7 @@ int netup_ci_init(struct cx23885_tsport *port)
                 goto err;
 
         INIT_WORK(&state->work, netup_read_ci_status);
+        schedule_work(&state->work);
 
         ci_dbg_print("%s: CI initialized!\n", __func__);
 
diff --git a/drivers/media/video/cx23885/cx23885-417.c b/drivers/media/video/cx23885/cx23885-417.c
index 1a1048b18f70..6c3b51ce3372 100644
--- a/drivers/media/video/cx23885/cx23885-417.c
+++ b/drivers/media/video/cx23885/cx23885-417.c
@@ -630,6 +630,39 @@ int mc417_memory_read(struct cx23885_dev *dev, u32 address, u32 *value)
         return retval;
 }
 
+void mc417_gpio_set(struct cx23885_dev *dev, u32 mask)
+{
+        u32 val;
+
+        /* Set the gpio value */
+        mc417_register_read(dev, 0x900C, &val);
+        val |= (mask & 0x000ffff);
+        mc417_register_write(dev, 0x900C, val);
+}
+
+void mc417_gpio_clear(struct cx23885_dev *dev, u32 mask)
+{
+        u32 val;
+
+        /* Clear the gpio value */
+        mc417_register_read(dev, 0x900C, &val);
+        val &= ~(mask & 0x0000ffff);
+        mc417_register_write(dev, 0x900C, val);
+}
+
+void mc417_gpio_enable(struct cx23885_dev *dev, u32 mask, int asoutput)
+{
+        u32 val;
+
+        /* Enable GPIO direction bits */
+        mc417_register_read(dev, 0x9020, &val);
+        if (asoutput)
+                val |= (mask & 0x0000ffff);
+        else
+                val &= ~(mask & 0x0000ffff);
+
+        mc417_register_write(dev, 0x9020, val);
+}
 /* ------------------------------------------------------------------ */
 
 /* MPEG encoder API */
@@ -955,25 +988,8 @@ static int cx23885_load_firmware(struct cx23885_dev *dev)
         retval |= mc417_register_write(dev, IVTV_REG_HW_BLOCKS,
                 IVTV_CMD_HW_BLOCKS_RST);
 
-        /* Restore GPIO settings, make sure EIO14 is enabled as an output. */
-        dprintk(2, "%s: GPIO output EIO 0-15 was = 0x%x\n",
-                __func__, gpio_output);
-        /* Power-up seems to have GPIOs AFU. This was causing digital side
-         * to fail at power-up. Seems GPIOs should be set to 0x10ff0411 at
-         * power-up.
-         * gpio_output |= (1<<14);
-         */
-        /* Note: GPIO14 is specific to the HVR1800 here */
-        gpio_output = 0x10ff0411 | (1<<14);
-        retval |= mc417_register_write(dev, 0x9020, gpio_output | (1<<14));
-        dprintk(2, "%s: GPIO output EIO 0-15 now = 0x%x\n",
-                __func__, gpio_output);
-
-        dprintk(1, "%s: GPIO value  EIO 0-15 was = 0x%x\n",
-                __func__, value);
-        value |= (1<<14);
-        dprintk(1, "%s: GPIO value  EIO 0-15 now = 0x%x\n",
-                __func__, value);
+        /* F/W power up disturbs the GPIOs, restore state */
+        retval |= mc417_register_write(dev, 0x9020, gpio_output);
         retval |= mc417_register_write(dev, 0x900C, value);
 
         retval |= mc417_register_read(dev, IVTV_REG_VPU, &value);
@@ -1788,9 +1804,6 @@ int cx23885_417_register(struct cx23885_dev *dev)
                 return err;
         }
 
-        /* Initialize MC417 registers */
-        cx23885_mc417_init(dev);
-
         printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
                dev->name, dev->v4l_device->num);
 
diff --git a/drivers/media/video/cx23885/cx23885-cards.c b/drivers/media/video/cx23885/cx23885-cards.c
index ce29b5e34a11..3143d85ef31d 100644
--- a/drivers/media/video/cx23885/cx23885-cards.c
+++ b/drivers/media/video/cx23885/cx23885-cards.c
@@ -201,6 +201,15 @@ struct cx23885_board cx23885_boards[] = {
                 .name           = "Mygica X8506 DMB-TH",
                 .portb          = CX23885_MPEG_DVB,
         },
+        [CX23885_BOARD_MAGICPRO_PROHDTVE2] = {
+                .name           = "Magic-Pro ProHDTV Extreme 2",
+                .portb          = CX23885_MPEG_DVB,
+        },
+        [CX23885_BOARD_HAUPPAUGE_HVR1850] = {
+                .name           = "Hauppauge WinTV-HVR1850",
+                .portb          = CX23885_MPEG_ENCODER,
+                .portc          = CX23885_MPEG_DVB,
+        },
 };
 const unsigned int cx23885_bcount = ARRAY_SIZE(cx23885_boards);
 
@@ -324,6 +333,14 @@ struct cx23885_subid cx23885_subids[] = {
                 .subvendor = 0x14f1,
                 .subdevice = 0x8651,
                 .card      = CX23885_BOARD_MYGICA_X8506,
+        }, {
+                .subvendor = 0x14f1,
+                .subdevice = 0x8657,
+                .card      = CX23885_BOARD_MAGICPRO_PROHDTVE2,
+        }, {
+                .subvendor = 0x0070,
+                .subdevice = 0x8541,
+                .card      = CX23885_BOARD_HAUPPAUGE_HVR1850,
         },
 };
 const unsigned int cx23885_idcount = ARRAY_SIZE(cx23885_subids);
@@ -483,8 +500,13 @@ static void hauppauge_eeprom(struct cx23885_dev *dev, u8 *eeprom_data)
                 /* WinTV-HVR1700 (PCIe, OEM, No IR, full height)
                  * DVB-T and MPEG2 HW Encoder */
                 break;
+        case 85021:
+                /* WinTV-HVR1850 (PCIe, OEM, RCA in, IR, FM,
+                        Dual channel ATSC and MPEG2 HW Encoder */
+                break;
         default:
-                printk(KERN_WARNING "%s: warning: unknown hauppauge model #%d\n",
+                printk(KERN_WARNING "%s: warning: "
+                        "unknown hauppauge model #%d\n",
                         dev->name, tv.model);
                 break;
         }
@@ -574,13 +596,23 @@ void cx23885_gpio_setup(struct cx23885_dev *dev)
                 /* CX23417 GPIO's */
                 /* EIO15 Zilog Reset */
                 /* EIO14 S5H1409/CX24227 Reset */
+                mc417_gpio_enable(dev, GPIO_15 | GPIO_14, 1);
+
+                /* Put the demod into reset and protect the eeprom */
+                mc417_gpio_clear(dev, GPIO_15 | GPIO_14);
+                mdelay(100);
+
+                /* Bring the demod and blaster out of reset */
+                mc417_gpio_set(dev, GPIO_15 | GPIO_14);
+                mdelay(100);
 
                 /* Force the TDA8295A into reset and back */
-                cx_set(GP0_IO, 0x00040004);
+                cx23885_gpio_enable(dev, GPIO_2, 1);
+                cx23885_gpio_set(dev, GPIO_2);
                 mdelay(20);
-                cx_clear(GP0_IO, 0x00000004);
+                cx23885_gpio_clear(dev, GPIO_2);
                 mdelay(20);
-                cx_set(GP0_IO, 0x00040004);
+                cx23885_gpio_set(dev, GPIO_2);
                 mdelay(20);
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1200:
@@ -715,14 +747,45 @@ void cx23885_gpio_setup(struct cx23885_dev *dev)
                 cx23885_gpio_set(dev, GPIO_9);
                 break;
         case CX23885_BOARD_MYGICA_X8506:
+        case CX23885_BOARD_MAGICPRO_PROHDTVE2:
                 /* GPIO-1 reset XC5000 */
-                /* GPIO-2 reset LGS8GL5 */
+                /* GPIO-2 reset LGS8GL5 / LGS8G75 */
                 cx_set(GP0_IO, 0x00060000);
                 cx_clear(GP0_IO, 0x00000006);
                 mdelay(100);
                 cx_set(GP0_IO, 0x00060006);
                 mdelay(100);
                 break;
+        case CX23885_BOARD_HAUPPAUGE_HVR1850:
+                /* GPIO-0 656_CLK */
+                /* GPIO-1 656_D0 */
+                /* GPIO-2 Wake# */
+                /* GPIO-3-10 cx23417 data0-7 */
+                /* GPIO-11-14 cx23417 addr0-3 */
+                /* GPIO-15-18 cx23417 READY, CS, RD, WR */
+                /* GPIO-19 IR_RX */
+                /* GPIO-20 C_IR_TX */
+                /* GPIO-21 I2S DAT */
+                /* GPIO-22 I2S WCLK */
+                /* GPIO-23 I2S BCLK */
+                /* ALT GPIO: EXP GPIO LATCH */
+
+                /* CX23417 GPIO's */
+                /* GPIO-14 S5H1411/CX24228 Reset */
+                /* GPIO-13 EEPROM write protect */
+                mc417_gpio_enable(dev, GPIO_14 | GPIO_13, 1);
+
+                /* Put the demod into reset and protect the eeprom */
+                mc417_gpio_clear(dev, GPIO_14 | GPIO_13);
+                mdelay(100);
+
+                /* Bring the demod out of reset */
+                mc417_gpio_set(dev, GPIO_14);
+                mdelay(100);
+
+                /* CX24228 GPIO */
+                /* Connected to IF / Mux */
+                break;
         }
 }
 
@@ -739,6 +802,7 @@ int cx23885_ir_init(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
+        case CX23885_BOARD_HAUPPAUGE_HVR1850:
                 /* FIXME: Implement me */
                 break;
         case CX23885_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL_EXP:
@@ -778,6 +842,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
+        case CX23885_BOARD_HAUPPAUGE_HVR1850:
                 if (dev->i2c_bus[0].i2c_rc == 0)
                         hauppauge_eeprom(dev, eeprom+0xc0);
                 break;
@@ -827,6 +892,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
                 ts2->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
                 break;
         case CX23885_BOARD_MYGICA_X8506:
+        case CX23885_BOARD_MAGICPRO_PROHDTVE2:
                 ts1->gen_ctrl_val  = 0x5; /* Parallel */
                 ts1->ts_clk_en_val = 0x1; /* Enable TS_CLK */
                 ts1->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
@@ -844,6 +910,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
+        case CX23885_BOARD_HAUPPAUGE_HVR1850:
         default:
                 ts2->gen_ctrl_val  = 0xc; /* Serial bus + punctured clock */
                 ts2->ts_clk_en_val = 0x1; /* Enable TS_CLK */
diff --git a/drivers/media/video/cx23885/cx23885-core.c b/drivers/media/video/cx23885/cx23885-core.c
index bf7bb1c412fb..40d438d7234d 100644
--- a/drivers/media/video/cx23885/cx23885-core.c
+++ b/drivers/media/video/cx23885/cx23885-core.c
@@ -713,12 +713,26 @@ static void cx23885_dev_checkrevision(struct cx23885_dev *dev)
                 dev->hwrevision = 0xa1;
                 break;
         case 0x02:
-                /* CX23885-13Z */
+                /* CX23885-13Z/14Z */
                 dev->hwrevision = 0xb0;
                 break;
         case 0x03:
-                /* CX23888-22Z */
-                dev->hwrevision = 0xc0;
+                if (dev->pci->device == 0x8880) {
+                        /* CX23888-21Z/22Z */
+                        dev->hwrevision = 0xc0;
+                } else {
+                        /* CX23885-14Z */
+                        dev->hwrevision = 0xa4;
+                }
+                break;
+        case 0x04:
+                if (dev->pci->device == 0x8880) {
+                        /* CX23888-31Z */
+                        dev->hwrevision = 0xd0;
+                } else {
+                        /* CX23885-15Z, CX23888-31Z */
+                        dev->hwrevision = 0xa5;
+                }
                 break;
         case 0x0e:
                 /* CX23887-15Z */
@@ -756,6 +770,7 @@ static int cx23885_dev_setup(struct cx23885_dev *dev)
 
         /* Configure the internal memory */
         if (dev->pci->device == 0x8880) {
+                /* Could be 887 or 888, assume a default */
                 dev->bridge = CX23885_BRIDGE_887;
                 /* Apply a sensible clock frequency for the PCIe bridge */
                 dev->clk_freq = 25000000;
@@ -868,6 +883,14 @@ static int cx23885_dev_setup(struct cx23885_dev *dev)
         dprintk(1, "%s() radio_type = 0x%x radio_addr = 0x%x\n",
                 __func__, dev->radio_type, dev->radio_addr);
 
+        /* The cx23417 encoder has GPIO's that need to be initialised
+         * before DVB, so that demodulators and tuners are out of
+         * reset before DVB uses them.
+         */
+        if ((cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) ||
+                (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER))
+                        cx23885_mc417_init(dev);
+
         /* init hardware */
         cx23885_reset(dev);
 
@@ -1250,6 +1273,7 @@ static int cx23885_start_dma(struct cx23885_tsport *port,
         switch (dev->bridge) {
         case CX23885_BRIDGE_885:
         case CX23885_BRIDGE_887:
+        case CX23885_BRIDGE_888:
                 /* enable irqs */
                 dprintk(1, "%s() enabling TS int's and DMA\n", __func__);
                 cx_set(port->reg_ts_int_msk,  port->ts_int_msk_val);
diff --git a/drivers/media/video/cx23885/cx23885-dvb.c b/drivers/media/video/cx23885/cx23885-dvb.c
index 86ac529e62be..022fad798fc2 100644
--- a/drivers/media/video/cx23885/cx23885-dvb.c
+++ b/drivers/media/video/cx23885/cx23885-dvb.c
@@ -396,7 +396,7 @@ static struct stv0900_reg stv0900_ts_regs[] = {
 
 static struct stv0900_config netup_stv0900_config = {
         .demod_address = 0x68,
-        .xtal = 27000000,
+        .xtal = 8000000,
         .clkmode = 3,/* 0-CLKI, 2-XTALI, else AUTO */
         .diseqc_mode = 2,/* 2/3 PWM */
         .ts_config_regs = stv0900_ts_regs,
@@ -408,14 +408,14 @@ static struct stv0900_config netup_stv0900_config = {
 
 static struct stv6110_config netup_stv6110_tunerconfig_a = {
         .i2c_address = 0x60,
-        .mclk = 27000000,
-        .iq_wiring = 0,
+        .mclk = 16000000,
+        .clk_div = 1,
 };
 
 static struct stv6110_config netup_stv6110_tunerconfig_b = {
         .i2c_address = 0x63,
-        .mclk = 27000000,
-        .iq_wiring = 1,
+        .mclk = 16000000,
+        .clk_div = 1,
 };
 
 static int tbs_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
@@ -487,6 +487,26 @@ static int cx23885_dvb_set_frontend(struct dvb_frontend *fe,
                 port->set_frontend_save(fe, param) : -ENODEV;
 }
 
+static struct lgs8gxx_config magicpro_prohdtve2_lgs8g75_config = {
+        .prod = LGS8GXX_PROD_LGS8G75,
+        .demod_address = 0x19,
+        .serial_ts = 0,
+        .ts_clk_pol = 1,
+        .ts_clk_gated = 1,
+        .if_clk_freq = 30400, /* 30.4 MHz */
+        .if_freq = 6500, /* 6.50 MHz */
+        .if_neg_center = 1,
+        .ext_adc = 0,
+        .adc_signed = 1,
+        .adc_vpp = 2, /* 1.6 Vpp */
+        .if_neg_edge = 1,
+};
+
+static struct xc5000_config magicpro_prohdtve2_xc5000_config = {
+        .i2c_address = 0x61,
+        .if_khz = 6500,
+};
+
 static int dvb_register(struct cx23885_tsport *port)
 {
         struct cx23885_dev *dev = port->dev;
@@ -833,6 +853,30 @@ static int dvb_register(struct cx23885_tsport *port)
                                 &mygica_x8506_xc5000_config);
                 }
                 break;
+        case CX23885_BOARD_MAGICPRO_PROHDTVE2:
+                i2c_bus = &dev->i2c_bus[0];
+                i2c_bus2 = &dev->i2c_bus[1];
+                fe0->dvb.frontend = dvb_attach(lgs8gxx_attach,
+                        &magicpro_prohdtve2_lgs8g75_config,
+                        &i2c_bus->i2c_adap);
+                if (fe0->dvb.frontend != NULL) {
+                        dvb_attach(xc5000_attach,
+                                fe0->dvb.frontend,
+                                &i2c_bus2->i2c_adap,
+                                &magicpro_prohdtve2_xc5000_config);
+                }
+                break;
+        case CX23885_BOARD_HAUPPAUGE_HVR1850:
+                i2c_bus = &dev->i2c_bus[0];
+                fe0->dvb.frontend = dvb_attach(s5h1411_attach,
+                        &hcw_s5h1411_config,
+                        &i2c_bus->i2c_adap);
+                if (fe0->dvb.frontend != NULL)
+                        dvb_attach(tda18271_attach, fe0->dvb.frontend,
+                                0x60, &dev->i2c_bus[0].i2c_adap,
+                                &hauppauge_tda18271_config);
+                break;
+
         default:
                 printk(KERN_INFO "%s: The frontend of your DVB/ATSC card "
                         " isn't supported yet\n",
diff --git a/drivers/media/video/cx23885/cx23885-i2c.c b/drivers/media/video/cx23885/cx23885-i2c.c
index 384dec34134f..4172cb387420 100644
--- a/drivers/media/video/cx23885/cx23885-i2c.c
+++ b/drivers/media/video/cx23885/cx23885-i2c.c
@@ -283,7 +283,6 @@ static struct i2c_algorithm cx23885_i2c_algo_template = {
 static struct i2c_adapter cx23885_i2c_adap_template = {
         .name              = "cx23885",
         .owner             = THIS_MODULE,
-        .id                = I2C_HW_B_CX23885,
         .algo              = &cx23885_i2c_algo_template,
 };
 
diff --git a/drivers/media/video/cx23885/cx23885.h b/drivers/media/video/cx23885/cx23885.h
index 214a55e943b7..86f26947bb78 100644
--- a/drivers/media/video/cx23885/cx23885.h
+++ b/drivers/media/video/cx23885/cx23885.h
@@ -76,6 +76,8 @@
 #define CX23885_BOARD_HAUPPAUGE_HVR1255        20
 #define CX23885_BOARD_HAUPPAUGE_HVR1210        21
 #define CX23885_BOARD_MYGICA_X8506             22
+#define CX23885_BOARD_MAGICPRO_PROHDTVE2       23
+#define CX23885_BOARD_HAUPPAUGE_HVR1850        24
 
 #define GPIO_0 0x00000001
 #define GPIO_1 0x00000002
@@ -87,6 +89,12 @@
 #define GPIO_7 0x00000080
 #define GPIO_8 0x00000100
 #define GPIO_9 0x00000200
+#define GPIO_10 0x00000400
+#define GPIO_11 0x00000800
+#define GPIO_12 0x00001000
+#define GPIO_13 0x00002000
+#define GPIO_14 0x00004000
+#define GPIO_15 0x00008000
 
 /* Currently unsupported by the driver: PAL/H, NTSC/Kr, SECAM B/G/H/LC */
 #define CX23885_NORMS (\
@@ -331,6 +339,7 @@ struct cx23885_dev {
                 CX23885_BRIDGE_UNDEFINED = 0,
                 CX23885_BRIDGE_885 = 885,
                 CX23885_BRIDGE_887 = 887,
+                CX23885_BRIDGE_888 = 888,
         } bridge;
 
         /* Analog video */
@@ -395,7 +404,7 @@ struct sram_channel {
         u32  cmds_start;
         u32  ctrl_start;
         u32  cdt;
-        u32  fifo_start;;
+        u32  fifo_start;
         u32  fifo_size;
         u32  ptr1_reg;
         u32  ptr2_reg;
@@ -504,6 +513,9 @@ extern void cx23885_417_check_encoder(struct cx23885_dev *dev);
 extern void cx23885_mc417_init(struct cx23885_dev *dev);
 extern int mc417_memory_read(struct cx23885_dev *dev, u32 address, u32 *value);
 extern int mc417_memory_write(struct cx23885_dev *dev, u32 address, u32 value);
+extern void mc417_gpio_set(struct cx23885_dev *dev, u32 mask);
+extern void mc417_gpio_clear(struct cx23885_dev *dev, u32 mask);
+extern void mc417_gpio_enable(struct cx23885_dev *dev, u32 mask, int asoutput);
 
 
 /* ----------------------------------------------------------- */
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index 0be51b65f098..1aeaf18a9bea 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -321,6 +321,15 @@ static void cx23885_initialize(struct i2c_client *client)
         /* Select AFE clock pad output source */
         cx25840_write(client, 0x144, 0x05);
 
+        /* Drive GPIO2 direction and values for HVR1700
+         * where an onboard mux selects the output of demodulator
+         * vs the 417. Failure to set this results in no DTV.
+         * It's safe to set this across all Hauppauge boards
+         * currently, regardless of the board type.
+         */
+        cx25840_write(client, 0x160, 0x1d);
+        cx25840_write(client, 0x164, 0x00);
+
         /* Do the firmware load in a work handler to prevent.
            Otherwise the kernel is blocked waiting for the
            bit-banging i2c interface to finish uploading the
@@ -1578,12 +1587,6 @@ static int cx25840_probe(struct i2c_client *client,
         state->id = id;
         state->rev = device_id;
 
-        if (state->is_cx23885) {
-                /* Drive GPIO2 direction and values */
-                cx25840_write(client, 0x160, 0x1d);
-                cx25840_write(client, 0x164, 0x00);
-        }
-
         return 0;
 }
 
diff --git a/drivers/media/video/cx25840/cx25840-firmware.c b/drivers/media/video/cx25840/cx25840-firmware.c
index 0df53b0d75d9..1f483c1d0dbe 100644
--- a/drivers/media/video/cx25840/cx25840-firmware.c
+++ b/drivers/media/video/cx25840/cx25840-firmware.c
@@ -23,10 +23,6 @@
 
 #include "cx25840-core.h"
 
-#define FWFILE "v4l-cx25840.fw"
-#define FWFILE_CX23885 "v4l-cx23885-avcore-01.fw"
-#define FWFILE_CX231XX "v4l-cx231xx-avcore-01.fw"
-
 /*
  * Mike Isely <isely@pobox.com> - The FWSEND parameter controls the
  * size of the firmware chunks sent down the I2C bus to the chip.
@@ -40,11 +36,11 @@
 
 #define FWDEV(x) &((x)->dev)
 
-static char *firmware = FWFILE;
+static char *firmware = "";
 
 module_param(firmware, charp, 0444);
 
-MODULE_PARM_DESC(firmware, "Firmware image [default: " FWFILE "]");
+MODULE_PARM_DESC(firmware, "Firmware image to load");
 
 static void start_fw_load(struct i2c_client *client)
 {
@@ -65,6 +61,19 @@ static void end_fw_load(struct i2c_client *client)
         cx25840_write(client, 0x803, 0x03);
 }
 
+static const char *get_fw_name(struct i2c_client *client)
+{
+        struct cx25840_state *state = to_state(i2c_get_clientdata(client));
+
+        if (firmware[0])
+                return firmware;
+        if (state->is_cx23885)
+                return "v4l-cx23885-avcore-01.fw";
+        if (state->is_cx231xx)
+                return "v4l-cx231xx-avcore-01.fw";
+        return "v4l-cx25840.fw";
+}
+
 static int check_fw_load(struct i2c_client *client, int size)
 {
         /* DL_ADDR_HB DL_ADDR_LB */
@@ -72,11 +81,13 @@ static int check_fw_load(struct i2c_client *client, int size)
         s |= cx25840_read(client, 0x800);
 
         if (size != s) {
-                v4l_err(client, "firmware %s load failed\n", firmware);
+                v4l_err(client, "firmware %s load failed\n",
+                                get_fw_name(client));
                 return -EINVAL;
         }
 
-        v4l_info(client, "loaded %s firmware (%d bytes)\n", firmware, size);
+        v4l_info(client, "loaded %s firmware (%d bytes)\n",
+                        get_fw_name(client), size);
         return 0;
 }
 
@@ -96,21 +107,24 @@ int cx25840_loadfw(struct i2c_client *client)
         const struct firmware *fw = NULL;
         u8 buffer[FWSEND];
         const u8 *ptr;
+        const char *fwname = get_fw_name(client);
         int size, retval;
         int MAX_BUF_SIZE = FWSEND;
+        u32 gpio_oe = 0, gpio_da = 0;
 
-        if (state->is_cx23885)
-                firmware = FWFILE_CX23885;
-        else if (state->is_cx231xx)
-                firmware = FWFILE_CX231XX;
+        if (state->is_cx23885) {
+                /* Preserve the GPIO OE and output bits */
+                gpio_oe = cx25840_read(client, 0x160);
+                gpio_da = cx25840_read(client, 0x164);
+        }
 
         if ((state->is_cx231xx) && MAX_BUF_SIZE > 16) {
                 v4l_err(client, " Firmware download size changed to 16 bytes max length\n");
                 MAX_BUF_SIZE = 16;  /* cx231xx cannot accept more than 16 bytes at a time */
         }
 
-        if (request_firmware(&fw, firmware, FWDEV(client)) != 0) {
-                v4l_err(client, "unable to open firmware %s\n", firmware);
+        if (request_firmware(&fw, fwname, FWDEV(client)) != 0) {
+                v4l_err(client, "unable to open firmware %s\n", fwname);
                 return -EINVAL;
         }
 
@@ -142,5 +156,11 @@ int cx25840_loadfw(struct i2c_client *client)
         size = fw->size;
         release_firmware(fw);
 
+        if (state->is_cx23885) {
+                /* Restore GPIO configuration after f/w load */
+                cx25840_write(client, 0x160, gpio_oe);
+                cx25840_write(client, 0x164, gpio_da);
+        }
+
         return check_fw_load(client, size);
 }
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c
index 39465301ec94..e5f07fbd5a35 100644
--- a/drivers/media/video/cx88/cx88-cards.c
+++ b/drivers/media/video/cx88/cx88-cards.c
@@ -1283,6 +1283,51 @@ static const struct cx88_board cx88_boards[] = {
                 },
                 .mpeg           = CX88_MPEG_DVB,
         },
+        [CX88_BOARD_WINFAST_DTV2000H_J] = {
+                .name           = "WinFast DTV2000 H rev. J",
+                .tuner_type     = TUNER_PHILIPS_FMD1216ME_MK3,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .tda9887_conf   = TDA9887_PRESENT,
+                .input          = {{
+                        .type   = CX88_VMUX_TELEVISION,
+                        .vmux   = 0,
+                        .gpio0  = 0x00017300,
+                        .gpio1  = 0x00008207,
+                        .gpio2  = 0x00000000,
+                        .gpio3  = 0x02000000,
+                },{
+                        .type   = CX88_VMUX_TELEVISION,
+                        .vmux   = 0,
+                        .gpio0  = 0x00018300,
+                        .gpio1  = 0x0000f207,
+                        .gpio2  = 0x00017304,
+                        .gpio3  = 0x02000000,
+                },{
+                        .type   = CX88_VMUX_COMPOSITE1,
+                        .vmux   = 1,
+                        .gpio0  = 0x00018301,
+                        .gpio1  = 0x0000f207,
+                        .gpio2  = 0x00017304,
+                        .gpio3  = 0x02000000,
+                },{
+                        .type   = CX88_VMUX_SVIDEO,
+                        .vmux   = 2,
+                        .gpio0  = 0x00018301,
+                        .gpio1  = 0x0000f207,
+                        .gpio2  = 0x00017304,
+                        .gpio3  = 0x02000000,
+                }},
+                .radio = {
+                         .type  = CX88_RADIO,
+                         .gpio0 = 0x00015702,
+                         .gpio1 = 0x0000f207,
+                         .gpio2 = 0x00015702,
+                         .gpio3 = 0x02000000,
+                },
+                .mpeg           = CX88_MPEG_DVB,
+        },
         [CX88_BOARD_GENIATECH_DVBS] = {
                 .name          = "Geniatech DVB-S",
                 .tuner_type    = TUNER_ABSENT,
@@ -1908,7 +1953,8 @@ static const struct cx88_board cx88_boards[] = {
                 .radio_addr     = ADDR_UNSET,
                 .input          = {{
                         .type   = CX88_VMUX_DVB,
-                        .vmux   = 1,
+                        .vmux   = 0,
+                        .gpio0  = 0x8080,
                 } },
                 .mpeg           = CX88_MPEG_DVB,
         },
@@ -2282,6 +2328,10 @@ static const struct cx88_subid cx88_subids[] = {
                 .subdevice = 0x665e,
                 .card      = CX88_BOARD_WINFAST_DTV2000H,
         },{
+                .subvendor = 0x107d,
+                .subdevice = 0x6f2b,
+                .card      = CX88_BOARD_WINFAST_DTV2000H_J,
+        },{
                 .subvendor = 0x18ac,
                 .subdevice = 0xd800, /* FusionHDTV 3 Gold (original revision) */
                 .card      = CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_Q,
@@ -3162,7 +3212,11 @@ static void cx88_card_setup(struct cx88_core *core)
         case  CX88_BOARD_PROF_6200:
         case  CX88_BOARD_PROF_7300:
         case  CX88_BOARD_SATTRADE_ST4200:
+                cx_write(MO_GP0_IO, 0x8000);
+                msleep(100);
                 cx_write(MO_SRST_IO, 0);
+                msleep(10);
+                cx_write(MO_GP0_IO, 0x8080);
                 msleep(100);
                 cx_write(MO_SRST_IO, 1);
                 msleep(100);
diff --git a/drivers/media/video/cx88/cx88-dvb.c b/drivers/media/video/cx88/cx88-dvb.c
index e237b507659b..6e5d142b5b00 100644
--- a/drivers/media/video/cx88/cx88-dvb.c
+++ b/drivers/media/video/cx88/cx88-dvb.c
@@ -424,17 +424,16 @@ static int tevii_dvbs_set_voltage(struct dvb_frontend *fe,
         struct cx8802_dev *dev= fe->dvb->priv;
         struct cx88_core *core = dev->core;
 
+        cx_set(MO_GP0_IO, 0x6040);
         switch (voltage) {
                 case SEC_VOLTAGE_13:
-                        printk("LNB Voltage SEC_VOLTAGE_13\n");
-                        cx_write(MO_GP0_IO, 0x00006040);
+                        cx_clear(MO_GP0_IO, 0x20);
                         break;
                 case SEC_VOLTAGE_18:
-                        printk("LNB Voltage SEC_VOLTAGE_18\n");
-                        cx_write(MO_GP0_IO, 0x00006060);
+                        cx_set(MO_GP0_IO, 0x20);
                         break;
                 case SEC_VOLTAGE_OFF:
-                        printk("LNB Voltage SEC_VOLTAGE_off\n");
+                        cx_clear(MO_GP0_IO, 0x20);
                         break;
         }
 
@@ -499,9 +498,9 @@ static struct zl10353_config cx88_pinnacle_hybrid_pctv = {
 };
 
 static struct zl10353_config cx88_geniatech_x8000_mt = {
-       .demod_address = (0x1e >> 1),
-       .no_tuner = 1,
-       .disable_i2c_gate_ctrl = 1,
+        .demod_address = (0x1e >> 1),
+        .no_tuner = 1,
+        .disable_i2c_gate_ctrl = 1,
 };
 
 static struct s5h1411_config dvico_fusionhdtv7_config = {
@@ -696,6 +695,7 @@ static int dvb_register(struct cx8802_dev *dev)
                 }
                 break;
         case CX88_BOARD_WINFAST_DTV2000H:
+        case CX88_BOARD_WINFAST_DTV2000H_J:
         case CX88_BOARD_HAUPPAUGE_HVR1100:
         case CX88_BOARD_HAUPPAUGE_HVR1100LP:
         case CX88_BOARD_HAUPPAUGE_HVR1300:
diff --git a/drivers/media/video/cx88/cx88-input.c b/drivers/media/video/cx88/cx88-input.c
index d91f5c51206d..78b3635178af 100644
--- a/drivers/media/video/cx88/cx88-input.c
+++ b/drivers/media/video/cx88/cx88-input.c
@@ -23,7 +23,7 @@
  */
 
 #include <linux/init.h>
-#include <linux/delay.h>
+#include <linux/hrtimer.h>
 #include <linux/input.h>
 #include <linux/pci.h>
 #include <linux/module.h>
@@ -48,7 +48,7 @@ struct cx88_IR {
 
         /* poll external decoder */
         int polling;
-        struct delayed_work work;
+        struct hrtimer timer;
         u32 gpio_addr;
         u32 last_gpio;
         u32 mask_keycode;
@@ -144,19 +144,28 @@ static void cx88_ir_handle_key(struct cx88_IR *ir)
         }
 }
 
-static void cx88_ir_work(struct work_struct *work)
+static enum hrtimer_restart cx88_ir_work(struct hrtimer *timer)
 {
-        struct cx88_IR *ir = container_of(work, struct cx88_IR, work.work);
+        unsigned long missed;
+        struct cx88_IR *ir = container_of(timer, struct cx88_IR, timer);
 
         cx88_ir_handle_key(ir);
-        schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
+        missed = hrtimer_forward_now(&ir->timer,
+                                     ktime_set(0, ir->polling * 1000000));
+        if (missed > 1)
+                ir_dprintk("Missed ticks %ld\n", missed - 1);
+
+        return HRTIMER_RESTART;
 }
 
 void cx88_ir_start(struct cx88_core *core, struct cx88_IR *ir)
 {
         if (ir->polling) {
-                INIT_DELAYED_WORK(&ir->work, cx88_ir_work);
-                schedule_delayed_work(&ir->work, 0);
+                hrtimer_init(&ir->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+                ir->timer.function = cx88_ir_work;
+                hrtimer_start(&ir->timer,
+                              ktime_set(0, ir->polling * 1000000),
+                              HRTIMER_MODE_REL);
         }
         if (ir->sampling) {
                 core->pci_irqmask |= PCI_INT_IR_SMPINT;
@@ -173,7 +182,7 @@ void cx88_ir_stop(struct cx88_core *core, struct cx88_IR *ir)
         }
 
         if (ir->polling)
-                cancel_delayed_work_sync(&ir->work);
+                hrtimer_cancel(&ir->timer);
 }
 
 /* ---------------------------------------------------------------------- */
@@ -182,7 +191,7 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
 {
         struct cx88_IR *ir;
         struct input_dev *input_dev;
-        IR_KEYTAB_TYPE *ir_codes = NULL;
+        struct ir_scancode_table *ir_codes = NULL;
         int ir_type = IR_TYPE_OTHER;
         int err = -ENOMEM;
 
@@ -198,14 +207,14 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
         case CX88_BOARD_DNTV_LIVE_DVB_T:
         case CX88_BOARD_KWORLD_DVB_T:
         case CX88_BOARD_KWORLD_DVB_T_CX22702:
-                ir_codes = ir_codes_dntv_live_dvb_t;
+                ir_codes = &ir_codes_dntv_live_dvb_t_table;
                 ir->gpio_addr = MO_GP1_IO;
                 ir->mask_keycode = 0x1f;
                 ir->mask_keyup = 0x60;
                 ir->polling = 50; /* ms */
                 break;
         case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1:
-                ir_codes = ir_codes_cinergy_1400;
+                ir_codes = &ir_codes_cinergy_1400_table;
                 ir_type = IR_TYPE_PD;
                 ir->sampling = 0xeb04; /* address */
                 break;
@@ -220,13 +229,14 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
         case CX88_BOARD_PCHDTV_HD3000:
         case CX88_BOARD_PCHDTV_HD5500:
         case CX88_BOARD_HAUPPAUGE_IRONLY:
-                ir_codes = ir_codes_hauppauge_new;
+                ir_codes = &ir_codes_hauppauge_new_table;
                 ir_type = IR_TYPE_RC5;
                 ir->sampling = 1;
                 break;
         case CX88_BOARD_WINFAST_DTV2000H:
+        case CX88_BOARD_WINFAST_DTV2000H_J:
         case CX88_BOARD_WINFAST_DTV1800H:
-                ir_codes = ir_codes_winfast;
+                ir_codes = &ir_codes_winfast_table;
                 ir->gpio_addr = MO_GP0_IO;
                 ir->mask_keycode = 0x8f8;
                 ir->mask_keyup = 0x100;
@@ -235,14 +245,14 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
         case CX88_BOARD_WINFAST2000XP_EXPERT:
         case CX88_BOARD_WINFAST_DTV1000:
         case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL:
-                ir_codes = ir_codes_winfast;
+                ir_codes = &ir_codes_winfast_table;
                 ir->gpio_addr = MO_GP0_IO;
                 ir->mask_keycode = 0x8f8;
                 ir->mask_keyup = 0x100;
                 ir->polling = 1; /* ms */
                 break;
         case CX88_BOARD_IODATA_GVBCTV7E:
-                ir_codes = ir_codes_iodata_bctv7e;
+                ir_codes = &ir_codes_iodata_bctv7e_table;
                 ir->gpio_addr = MO_GP0_IO;
                 ir->mask_keycode = 0xfd;
                 ir->mask_keydown = 0x02;
@@ -250,7 +260,7 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
                 break;
         case CX88_BOARD_PROLINK_PLAYTVPVR:
         case CX88_BOARD_PIXELVIEW_PLAYTV_ULTRA_PRO:
-                ir_codes = ir_codes_pixelview;
+                ir_codes = &ir_codes_pixelview_table;
                 ir->gpio_addr = MO_GP1_IO;
                 ir->mask_keycode = 0x1f;
                 ir->mask_keyup = 0x80;
@@ -258,28 +268,28 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
                 break;
         case CX88_BOARD_PROLINK_PV_8000GT:
         case CX88_BOARD_PROLINK_PV_GLOBAL_XTREME:
-                ir_codes = ir_codes_pixelview_new;
+                ir_codes = &ir_codes_pixelview_new_table;
                 ir->gpio_addr = MO_GP1_IO;
                 ir->mask_keycode = 0x3f;
                 ir->mask_keyup = 0x80;
                 ir->polling = 1; /* ms */
                 break;
         case CX88_BOARD_KWORLD_LTV883:
-                ir_codes = ir_codes_pixelview;
+                ir_codes = &ir_codes_pixelview_table;
                 ir->gpio_addr = MO_GP1_IO;
                 ir->mask_keycode = 0x1f;
                 ir->mask_keyup = 0x60;
                 ir->polling = 1; /* ms */
                 break;
         case CX88_BOARD_ADSTECH_DVB_T_PCI:
-                ir_codes = ir_codes_adstech_dvb_t_pci;
+                ir_codes = &ir_codes_adstech_dvb_t_pci_table;
                 ir->gpio_addr = MO_GP1_IO;
                 ir->mask_keycode = 0xbf;
                 ir->mask_keyup = 0x40;
                 ir->polling = 50; /* ms */
                 break;
         case CX88_BOARD_MSI_TVANYWHERE_MASTER:
-                ir_codes = ir_codes_msi_tvanywhere;
+                ir_codes = &ir_codes_msi_tvanywhere_table;
                 ir->gpio_addr = MO_GP1_IO;
                 ir->mask_keycode = 0x1f;
                 ir->mask_keyup = 0x40;
@@ -287,40 +297,40 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
                 break;
         case CX88_BOARD_AVERTV_303:
         case CX88_BOARD_AVERTV_STUDIO_303:
-                ir_codes         = ir_codes_avertv_303;
+                ir_codes         = &ir_codes_avertv_303_table;
                 ir->gpio_addr    = MO_GP2_IO;
                 ir->mask_keycode = 0xfb;
                 ir->mask_keydown = 0x02;
                 ir->polling      = 50; /* ms */
                 break;
         case CX88_BOARD_DNTV_LIVE_DVB_T_PRO:
-                ir_codes = ir_codes_dntv_live_dvbt_pro;
-                ir_type = IR_TYPE_PD;
-                ir->sampling = 0xff00; /* address */
+                ir_codes         = &ir_codes_dntv_live_dvbt_pro_table;
+                ir_type          = IR_TYPE_PD;
+                ir->sampling     = 0xff00; /* address */
                 break;
         case CX88_BOARD_NORWOOD_MICRO:
-                ir_codes         = ir_codes_norwood;
+                ir_codes         = &ir_codes_norwood_table;
                 ir->gpio_addr    = MO_GP1_IO;
                 ir->mask_keycode = 0x0e;
                 ir->mask_keyup   = 0x80;
                 ir->polling      = 50; /* ms */
                 break;
         case CX88_BOARD_NPGTECH_REALTV_TOP10FM:
-                ir_codes = ir_codes_npgtech;
-                ir->gpio_addr = MO_GP0_IO;
+                ir_codes         = &ir_codes_npgtech_table;
+                ir->gpio_addr    = MO_GP0_IO;
                 ir->mask_keycode = 0xfa;
-                ir->polling = 50; /* ms */
+                ir->polling      = 50; /* ms */
                 break;
         case CX88_BOARD_PINNACLE_PCTV_HD_800i:
-                ir_codes = ir_codes_pinnacle_pctv_hd;
-                ir_type = IR_TYPE_RC5;
-                ir->sampling = 1;
+                ir_codes         = &ir_codes_pinnacle_pctv_hd_table;
+                ir_type          = IR_TYPE_RC5;
+                ir->sampling     = 1;
                 break;
         case CX88_BOARD_POWERCOLOR_REAL_ANGEL:
-                ir_codes = ir_codes_powercolor_real_angel;
-                ir->gpio_addr = MO_GP2_IO;
+                ir_codes         = &ir_codes_powercolor_real_angel_table;
+                ir->gpio_addr    = MO_GP2_IO;
                 ir->mask_keycode = 0x7e;
-                ir->polling = 100; /* ms */
+                ir->polling      = 100; /* ms */
                 break;
         }
 
diff --git a/drivers/media/video/cx88/cx88.h b/drivers/media/video/cx88/cx88.h
index 9d83762163f5..d5cea41f4207 100644
--- a/drivers/media/video/cx88/cx88.h
+++ b/drivers/media/video/cx88/cx88.h
@@ -237,6 +237,7 @@ extern struct sram_channel cx88_sram_channels[];
 #define CX88_BOARD_TERRATEC_CINERGY_HT_PCI_MKII 79
 #define CX88_BOARD_HAUPPAUGE_IRONLY        80
 #define CX88_BOARD_WINFAST_DTV1800H        81
+#define CX88_BOARD_WINFAST_DTV2000H_J      82
 
 enum cx88_itype {
         CX88_VMUX_COMPOSITE1 = 1,
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index 1c2e544eda73..7e3c78239fa9 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -299,6 +299,7 @@ struct em28xx_board em28xx_boards[] = {
         [EM2820_BOARD_TERRATEC_CINERGY_250] = {
                 .name         = "Terratec Cinergy 250 USB",
                 .tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+                .has_ir_i2c   = 1,
                 .tda9887_conf = TDA9887_PRESENT,
                 .decoder      = EM28XX_SAA711X,
                 .input        = { {
@@ -318,6 +319,7 @@ struct em28xx_board em28xx_boards[] = {
         [EM2820_BOARD_PINNACLE_USB_2] = {
                 .name         = "Pinnacle PCTV USB 2",
                 .tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+                .has_ir_i2c   = 1,
                 .tda9887_conf = TDA9887_PRESENT,
                 .decoder      = EM28XX_SAA711X,
                 .input        = { {
@@ -342,6 +344,7 @@ struct em28xx_board em28xx_boards[] = {
                                 TDA9887_PORT2_ACTIVE,
                 .decoder      = EM28XX_TVP5150,
                 .has_msp34xx  = 1,
+                .has_ir_i2c   = 1,
                 .input        = { {
                         .type     = EM28XX_VMUX_TELEVISION,
                         .vmux     = TVP5150_COMPOSITE0,
@@ -558,6 +561,27 @@ struct em28xx_board em28xx_boards[] = {
                         .amux     = EM28XX_AMUX_LINE_IN,
                 } },
         },
+        [EM2861_BOARD_GADMEI_UTV330PLUS] = {
+                .name         = "Gadmei UTV330+",
+                .tuner_type   = TUNER_TNF_5335MF,
+                .tda9887_conf = TDA9887_PRESENT,
+                .ir_codes     = &ir_codes_gadmei_rm008z_table,
+                .decoder      = EM28XX_SAA711X,
+                .xclk         = EM28XX_XCLK_FREQUENCY_12MHZ,
+                .input        = { {
+                        .type     = EM28XX_VMUX_TELEVISION,
+                        .vmux     = SAA7115_COMPOSITE2,
+                        .amux     = EM28XX_AMUX_VIDEO,
+                }, {
+                        .type     = EM28XX_VMUX_COMPOSITE1,
+                        .vmux     = SAA7115_COMPOSITE0,
+                        .amux     = EM28XX_AMUX_LINE_IN,
+                }, {
+                        .type     = EM28XX_VMUX_SVIDEO,
+                        .vmux     = SAA7115_SVIDEO3,
+                        .amux     = EM28XX_AMUX_LINE_IN,
+                } },
+        },
         [EM2860_BOARD_TERRATEC_HYBRID_XS] = {
                 .name         = "Terratec Cinergy A Hybrid XS",
                 .valid        = EM28XX_BOARD_NOT_VALIDATED,
@@ -715,7 +739,7 @@ struct em28xx_board em28xx_boards[] = {
                 .mts_firmware = 1,
                 .has_dvb      = 1,
                 .dvb_gpio     = hauppauge_wintv_hvr_900_digital,
-                .ir_codes     = ir_codes_hauppauge_new,
+                .ir_codes     = &ir_codes_hauppauge_new_table,
                 .decoder      = EM28XX_TVP5150,
                 .input        = { {
                         .type     = EM28XX_VMUX_TELEVISION,
@@ -740,7 +764,7 @@ struct em28xx_board em28xx_boards[] = {
                 .tuner_type   = TUNER_XC2028,
                 .tuner_gpio   = default_tuner_gpio,
                 .mts_firmware = 1,
-                .ir_codes     = ir_codes_hauppauge_new,
+                .ir_codes     = &ir_codes_hauppauge_new_table,
                 .decoder      = EM28XX_TVP5150,
                 .input        = { {
                         .type     = EM28XX_VMUX_TELEVISION,
@@ -766,7 +790,7 @@ struct em28xx_board em28xx_boards[] = {
                 .mts_firmware   = 1,
                 .has_dvb        = 1,
                 .dvb_gpio       = hauppauge_wintv_hvr_900_digital,
-                .ir_codes       = ir_codes_hauppauge_new,
+                .ir_codes       = &ir_codes_hauppauge_new_table,
                 .decoder        = EM28XX_TVP5150,
                 .input          = { {
                         .type     = EM28XX_VMUX_TELEVISION,
@@ -792,7 +816,7 @@ struct em28xx_board em28xx_boards[] = {
                 .mts_firmware   = 1,
                 .has_dvb        = 1,
                 .dvb_gpio       = hauppauge_wintv_hvr_900_digital,
-                .ir_codes       = ir_codes_hauppauge_new,
+                .ir_codes       = &ir_codes_hauppauge_new_table,
                 .decoder        = EM28XX_TVP5150,
                 .input          = { {
                         .type     = EM28XX_VMUX_TELEVISION,
@@ -818,7 +842,7 @@ struct em28xx_board em28xx_boards[] = {
                 .mts_firmware   = 1,
                 .has_dvb        = 1,
                 .dvb_gpio       = hauppauge_wintv_hvr_900_digital,
-                .ir_codes       = ir_codes_pinnacle_pctv_hd,
+                .ir_codes       = &ir_codes_pinnacle_pctv_hd_table,
                 .decoder        = EM28XX_TVP5150,
                 .input          = { {
                         .type     = EM28XX_VMUX_TELEVISION,
@@ -844,7 +868,7 @@ struct em28xx_board em28xx_boards[] = {
                 .mts_firmware   = 1,
                 .has_dvb        = 1,
                 .dvb_gpio       = hauppauge_wintv_hvr_900_digital,
-                .ir_codes       = ir_codes_ati_tv_wonder_hd_600,
+                .ir_codes       = &ir_codes_ati_tv_wonder_hd_600_table,
                 .decoder        = EM28XX_TVP5150,
                 .input          = { {
                         .type     = EM28XX_VMUX_TELEVISION,
@@ -870,6 +894,8 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder        = EM28XX_TVP5150,
                 .has_dvb        = 1,
                 .dvb_gpio       = default_digital,
+                .ir_codes       = &ir_codes_terratec_cinergy_xs_table,
+                .xclk           = EM28XX_XCLK_FREQUENCY_12MHZ, /* NEC IR */
                 .input          = { {
                         .type     = EM28XX_VMUX_TELEVISION,
                         .vmux     = TVP5150_COMPOSITE0,
@@ -937,6 +963,7 @@ struct em28xx_board em28xx_boards[] = {
         [EM2800_BOARD_TERRATEC_CINERGY_200] = {
                 .name         = "Terratec Cinergy 200 USB",
                 .is_em2800    = 1,
+                .has_ir_i2c   = 1,
                 .tuner_type   = TUNER_LG_PAL_NEW_TAPC,
                 .tda9887_conf = TDA9887_PRESENT,
                 .decoder      = EM28XX_SAA711X,
@@ -1010,7 +1037,8 @@ struct em28xx_board em28xx_boards[] = {
                 } },
         },
         [EM2820_BOARD_PINNACLE_DVC_90] = {
-                .name         = "Pinnacle Dazzle DVC 90/100/101/107 / Kaiser Baas Video to DVD maker",
+                .name         = "Pinnacle Dazzle DVC 90/100/101/107 / Kaiser Baas Video to DVD maker "
+                                "/ Kworld DVD Maker 2",
                 .tuner_type   = TUNER_ABSENT, /* capture only board */
                 .decoder      = EM28XX_SAA711X,
                 .input        = { {
@@ -1420,7 +1448,7 @@ struct em28xx_board em28xx_boards[] = {
                 .mts_firmware = 1,
                 .decoder      = EM28XX_TVP5150,
                 .tuner_gpio   = default_tuner_gpio,
-                .ir_codes     = ir_codes_kaiomy,
+                .ir_codes     = &ir_codes_kaiomy_table,
                 .input          = { {
                         .type     = EM28XX_VMUX_TELEVISION,
                         .vmux     = TVP5150_COMPOSITE0,
@@ -1520,7 +1548,7 @@ struct em28xx_board em28xx_boards[] = {
                 .mts_firmware = 1,
                 .has_dvb      = 1,
                 .dvb_gpio     = evga_indtube_digital,
-                .ir_codes     = ir_codes_evga_indtube,
+                .ir_codes     = &ir_codes_evga_indtube_table,
                 .input        = { {
                         .type     = EM28XX_VMUX_TELEVISION,
                         .vmux     = TVP5150_COMPOSITE0,
@@ -1591,6 +1619,8 @@ struct usb_device_id em28xx_id_table[] = {
                         .driver_info = EM2870_BOARD_KWORLD_355U },
         { USB_DEVICE(0x1b80, 0xe302),
                         .driver_info = EM2820_BOARD_PINNACLE_DVC_90 }, /* Kaiser Baas Video to DVD maker */
+        { USB_DEVICE(0x1b80, 0xe304),
+                        .driver_info = EM2820_BOARD_PINNACLE_DVC_90 }, /* Kworld DVD Maker 2 */
         { USB_DEVICE(0x0ccd, 0x0036),
                         .driver_info = EM2820_BOARD_TERRATEC_CINERGY_250 },
         { USB_DEVICE(0x0ccd, 0x004c),
@@ -1649,6 +1679,8 @@ struct usb_device_id em28xx_id_table[] = {
                         .driver_info = EM2861_BOARD_PLEXTOR_PX_TV100U },
         { USB_DEVICE(0x04bb, 0x0515),
                         .driver_info = EM2820_BOARD_IODATA_GVMVP_SZ },
+        { USB_DEVICE(0xeb1a, 0x50a6),
+                        .driver_info = EM2860_BOARD_GADMEI_UTV330 },
         { },
 };
 MODULE_DEVICE_TABLE(usb, em28xx_id_table);
@@ -1661,7 +1693,7 @@ static struct em28xx_hash_table em28xx_eeprom_hash[] = {
         {0x6ce05a8f, EM2820_BOARD_PROLINK_PLAYTV_USB2, TUNER_YMEC_TVF_5533MF},
         {0x72cc5a8b, EM2820_BOARD_PROLINK_PLAYTV_BOX4_USB2, TUNER_YMEC_TVF_5533MF},
         {0x966a0441, EM2880_BOARD_KWORLD_DVB_310U, TUNER_XC2028},
-        {0x9567eb1a, EM2880_BOARD_EMPIRE_DUAL_TV, TUNER_XC2028},
+        {0x166a0441, EM2880_BOARD_EMPIRE_DUAL_TV, TUNER_XC2028},
         {0xcee44a99, EM2882_BOARD_EVGA_INDTUBE, TUNER_XC2028},
         {0xb8846b20, EM2881_BOARD_PINNACLE_HYBRID_PRO, TUNER_XC2028},
 };
@@ -1672,6 +1704,7 @@ static struct em28xx_hash_table em28xx_i2c_hash[] = {
         {0xf51200e3, EM2800_BOARD_VGEAR_POCKETTV, TUNER_LG_PAL_NEW_TAPC},
         {0x1ba50080, EM2860_BOARD_SAA711X_REFERENCE_DESIGN, TUNER_ABSENT},
         {0xc51200e3, EM2820_BOARD_GADMEI_TVR200, TUNER_LG_PAL_NEW_TAPC},
+        {0x4ba50080, EM2861_BOARD_GADMEI_UTV330PLUS, TUNER_TNF_5335MF},
 };
 
 /* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */
@@ -2170,8 +2203,6 @@ static int em28xx_hint_board(struct em28xx *dev)
 /* ----------------------------------------------------------------------- */
 void em28xx_register_i2c_ir(struct em28xx *dev)
 {
-        struct i2c_board_info info;
-        struct IR_i2c_init_data init_data;
         const unsigned short addr_list[] = {
                  0x30, 0x47, I2C_CLIENT_END
         };
@@ -2179,45 +2210,33 @@ void em28xx_register_i2c_ir(struct em28xx *dev)
         if (disable_ir)
                 return;
 
-        memset(&info, 0, sizeof(struct i2c_board_info));
-        memset(&init_data, 0, sizeof(struct IR_i2c_init_data));
-        strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
+        memset(&dev->info, 0, sizeof(&dev->info));
+        memset(&dev->init_data, 0, sizeof(dev->init_data));
+        strlcpy(dev->info.type, "ir_video", I2C_NAME_SIZE);
 
         /* detect & configure */
         switch (dev->model) {
-        case (EM2800_BOARD_UNKNOWN):
-                break;
-        case (EM2820_BOARD_UNKNOWN):
-                break;
-        case (EM2800_BOARD_TERRATEC_CINERGY_200):
-        case (EM2820_BOARD_TERRATEC_CINERGY_250):
-                init_data.ir_codes = ir_codes_em_terratec;
-                init_data.get_key = em28xx_get_key_terratec;
-                init_data.name = "i2c IR (EM28XX Terratec)";
-                break;
-        case (EM2820_BOARD_PINNACLE_USB_2):
-                init_data.ir_codes = ir_codes_pinnacle_grey;
-                init_data.get_key = em28xx_get_key_pinnacle_usb_grey;
-                init_data.name = "i2c IR (EM28XX Pinnacle PCTV)";
-                break;
-        case (EM2820_BOARD_HAUPPAUGE_WINTV_USB_2):
-                init_data.ir_codes = ir_codes_hauppauge_new;
-                init_data.get_key = em28xx_get_key_em_haup;
-                init_data.name = "i2c IR (EM2840 Hauppauge)";
+        case EM2800_BOARD_TERRATEC_CINERGY_200:
+        case EM2820_BOARD_TERRATEC_CINERGY_250:
+                dev->init_data.ir_codes = &ir_codes_em_terratec_table;
+                dev->init_data.get_key = em28xx_get_key_terratec;
+                dev->init_data.name = "i2c IR (EM28XX Terratec)";
                 break;
-        case (EM2820_BOARD_MSI_VOX_USB_2):
+        case EM2820_BOARD_PINNACLE_USB_2:
+                dev->init_data.ir_codes = &ir_codes_pinnacle_grey_table;
+                dev->init_data.get_key = em28xx_get_key_pinnacle_usb_grey;
+                dev->init_data.name = "i2c IR (EM28XX Pinnacle PCTV)";
                 break;
-        case (EM2800_BOARD_LEADTEK_WINFAST_USBII):
-                break;
-        case (EM2800_BOARD_KWORLD_USB2800):
-                break;
-        case (EM2800_BOARD_GRABBEEX_USB2800):
+        case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
+                dev->init_data.ir_codes = &ir_codes_hauppauge_new_table;
+                dev->init_data.get_key = em28xx_get_key_em_haup;
+                dev->init_data.name = "i2c IR (EM2840 Hauppauge)";
                 break;
         }
 
-        if (init_data.name)
-                info.platform_data = &init_data;
-        i2c_new_probed_device(&dev->i2c_adap, &info, addr_list);
+        if (dev->init_data.name)
+                dev->info.platform_data = &dev->init_data;
+        i2c_new_probed_device(&dev->i2c_adap, &dev->info, addr_list);
 }
 
 void em28xx_card_setup(struct em28xx *dev)
@@ -2253,7 +2272,7 @@ void em28xx_card_setup(struct em28xx *dev)
         case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
         {
                 struct tveeprom tv;
-#ifdef CONFIG_MODULES
+#if defined(CONFIG_MODULES) && defined(MODULE)
                 request_module("tveeprom");
 #endif
                 /* Call first TVeeprom */
@@ -2267,10 +2286,6 @@ void em28xx_card_setup(struct em28xx *dev)
                         dev->i2s_speed = 2048000;
                         dev->board.has_msp34xx = 1;
                 }
-#ifdef CONFIG_MODULES
-                if (tv.has_ir)
-                        request_module("ir-kbd-i2c");
-#endif
                 break;
         }
         case EM2882_BOARD_KWORLD_ATSC_315U:
@@ -2311,6 +2326,10 @@ void em28xx_card_setup(struct em28xx *dev)
                 break;
         }
 
+#if defined(CONFIG_MODULES) && defined(MODULE)
+        if (dev->board.has_ir_i2c && !disable_ir)
+                request_module("ir-kbd-i2c");
+#endif
         if (dev->board.has_snapshot_button)
                 em28xx_register_snapshot_button(dev);
 
diff --git a/drivers/media/video/em28xx/em28xx-i2c.c b/drivers/media/video/em28xx/em28xx-i2c.c
index 27e33a287dfc..71474d31e155 100644
--- a/drivers/media/video/em28xx/em28xx-i2c.c
+++ b/drivers/media/video/em28xx/em28xx-i2c.c
@@ -459,7 +459,6 @@ static struct i2c_algorithm em28xx_algo = {
 static struct i2c_adapter em28xx_adap_template = {
         .owner = THIS_MODULE,
         .name = "em28xx",
-        .id = I2C_HW_B_EM28XX,
         .algo = &em28xx_algo,
 };
 
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index ab079d9256c4..a6bdbc21410e 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -124,7 +124,7 @@ static struct em28xx_fmt format[] = {
 
 /* supported controls */
 /* Common to all boards */
-static struct v4l2_queryctrl em28xx_qctrl[] = {
+static struct v4l2_queryctrl ac97_qctrl[] = {
         {
                 .id = V4L2_CID_AUDIO_VOLUME,
                 .type = V4L2_CTRL_TYPE_INTEGER,
@@ -133,7 +133,7 @@ static struct v4l2_queryctrl em28xx_qctrl[] = {
                 .maximum = 0x1f,
                 .step = 0x1,
                 .default_value = 0x1f,
-                .flags = 0,
+                .flags = V4L2_CTRL_FLAG_SLIDER,
         }, {
                 .id = V4L2_CID_AUDIO_MUTE,
                 .type = V4L2_CTRL_TYPE_BOOLEAN,
@@ -609,10 +609,29 @@ static void res_free(struct em28xx_fh *fh)
 }
 
 /*
- * em28xx_get_ctrl()
- * return the current saturation, brightness or contrast, mute state
+ * ac97_queryctrl()
+ * return the ac97 supported controls
  */
-static int em28xx_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
+static int ac97_queryctrl(struct v4l2_queryctrl *qc)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++) {
+                if (qc->id && qc->id == ac97_qctrl[i].id) {
+                        memcpy(qc, &(ac97_qctrl[i]), sizeof(*qc));
+                        return 0;
+                }
+        }
+
+        /* Control is not ac97 related */
+        return 1;
+}
+
+/*
+ * ac97_get_ctrl()
+ * return the current values for ac97 mute and volume
+ */
+static int ac97_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
 {
         switch (ctrl->id) {
         case V4L2_CID_AUDIO_MUTE:
@@ -622,29 +641,41 @@ static int em28xx_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
                 ctrl->value = dev->volume;
                 return 0;
         default:
-                return -EINVAL;
+                /* Control is not ac97 related */
+                return 1;
         }
 }
 
 /*
- * em28xx_set_ctrl()
- * mute or set new saturation, brightness or contrast
+ * ac97_set_ctrl()
+ * set values for ac97 mute and volume
  */
-static int em28xx_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
+static int ac97_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
 {
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++)
+                if (ctrl->id == ac97_qctrl[i].id)
+                        goto handle;
+
+        /* Announce that hasn't handle it */
+        return 1;
+
+handle:
+        if (ctrl->value < ac97_qctrl[i].minimum ||
+            ctrl->value > ac97_qctrl[i].maximum)
+                return -ERANGE;
+
         switch (ctrl->id) {
         case V4L2_CID_AUDIO_MUTE:
-                if (ctrl->value != dev->mute) {
-                        dev->mute = ctrl->value;
-                        return em28xx_audio_analog_set(dev);
-                }
-                return 0;
+                dev->mute = ctrl->value;
+                break;
         case V4L2_CID_AUDIO_VOLUME:
                 dev->volume = ctrl->value;
-                return em28xx_audio_analog_set(dev);
-        default:
-                return -EINVAL;
+                break;
         }
+
+        return em28xx_audio_analog_set(dev);
 }
 
 static int check_dev(struct em28xx *dev)
@@ -974,6 +1005,9 @@ static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
         struct em28xx_fh   *fh    = priv;
         struct em28xx      *dev   = fh->dev;
 
+        if (!dev->audio_mode.has_audio)
+                return -EINVAL;
+
         switch (a->index) {
         case EM28XX_AMUX_VIDEO:
                 strcpy(a->name, "Television");
@@ -1015,6 +1049,9 @@ static int vidioc_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
         struct em28xx      *dev = fh->dev;
 
 
+        if (!dev->audio_mode.has_audio)
+                return -EINVAL;
+
         if (a->index >= MAX_EM28XX_INPUT)
                 return -EINVAL;
         if (0 == INPUT(a->index)->type)
@@ -1038,7 +1075,6 @@ static int vidioc_queryctrl(struct file *file, void *priv,
         struct em28xx_fh      *fh  = priv;
         struct em28xx         *dev = fh->dev;
         int                   id  = qc->id;
-        int                   i;
         int                   rc;
 
         rc = check_dev(dev);
@@ -1049,15 +1085,14 @@ static int vidioc_queryctrl(struct file *file, void *priv,
 
         qc->id = id;
 
-        if (!dev->board.has_msp34xx) {
-                for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
-                        if (qc->id && qc->id == em28xx_qctrl[i].id) {
-                                memcpy(qc, &(em28xx_qctrl[i]), sizeof(*qc));
-                                return 0;
-                        }
-                }
+        /* enumberate AC97 controls */
+        if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
+                rc = ac97_queryctrl(qc);
+                if (!rc)
+                        return 0;
         }
 
+        /* enumberate V4L2 device controls */
         mutex_lock(&dev->lock);
         v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, qc);
         mutex_unlock(&dev->lock);
@@ -1082,14 +1117,16 @@ static int vidioc_g_ctrl(struct file *file, void *priv,
 
         mutex_lock(&dev->lock);
 
-        if (dev->board.has_msp34xx)
+        /* Set an AC97 control */
+        if (dev->audio_mode.ac97 != EM28XX_NO_AC97)
+                rc = ac97_get_ctrl(dev, ctrl);
+        else
+                rc = 1;
+
+        /* It were not an AC97 control. Sends it to the v4l2 dev interface */
+        if (rc == 1) {
                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_ctrl, ctrl);
-        else {
-                rc = em28xx_get_ctrl(dev, ctrl);
-                if (rc < 0) {
-                        v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_ctrl, ctrl);
-                        rc = 0;
-                }
+                rc = 0;
         }
 
         mutex_unlock(&dev->lock);
@@ -1101,7 +1138,6 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
 {
         struct em28xx_fh      *fh  = priv;
         struct em28xx         *dev = fh->dev;
-        u8                    i;
         int                   rc;
 
         rc = check_dev(dev);
@@ -1110,28 +1146,31 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
 
         mutex_lock(&dev->lock);
 
-        if (dev->board.has_msp34xx)
-                v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_ctrl, ctrl);
-        else {
+        /* Set an AC97 control */
+        if (dev->audio_mode.ac97 != EM28XX_NO_AC97)
+                rc = ac97_set_ctrl(dev, ctrl);
+        else
                 rc = 1;
-                for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
-                        if (ctrl->id == em28xx_qctrl[i].id) {
-                                if (ctrl->value < em28xx_qctrl[i].minimum ||
-                                    ctrl->value > em28xx_qctrl[i].maximum) {
-                                        rc = -ERANGE;
-                                        break;
-                                }
-
-                                rc = em28xx_set_ctrl(dev, ctrl);
-                                break;
-                        }
-                }
-        }
 
-        /* Control not found - try to send it to the attached devices */
+        /* It isn't an AC97 control. Sends it to the v4l2 dev interface */
         if (rc == 1) {
                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_ctrl, ctrl);
-                rc = 0;
+
+                /*
+                 * In the case of non-AC97 volume controls, we still need
+                 * to do some setups at em28xx, in order to mute/unmute
+                 * and to adjust audio volume. However, the value ranges
+                 * should be checked by the corresponding V4L subdriver.
+                 */
+                switch (ctrl->id) {
+                case V4L2_CID_AUDIO_MUTE:
+                        dev->mute = ctrl->value;
+                        rc = em28xx_audio_analog_set(dev);
+                        break;
+                case V4L2_CID_AUDIO_VOLUME:
+                        dev->volume = ctrl->value;
+                        rc = em28xx_audio_analog_set(dev);
+                }
         }
 
         mutex_unlock(&dev->lock);
@@ -1275,8 +1314,9 @@ static int vidioc_g_register(struct file *file, void *priv,
                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
                 return 0;
         case V4L2_CHIP_MATCH_I2C_ADDR:
-                /* Not supported yet */
-                return -EINVAL;
+                /* TODO: is this correct? */
+                v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
+                return 0;
         default:
                 if (!v4l2_chip_match_host(&reg->match))
                         return -EINVAL;
@@ -1327,8 +1367,9 @@ static int vidioc_s_register(struct file *file, void *priv,
                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
                 return 0;
         case V4L2_CHIP_MATCH_I2C_ADDR:
-                /* Not supported yet */
-                return -EINVAL;
+                /* TODO: is this correct? */
+                v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
+                return 0;
         default:
                 if (!v4l2_chip_match_host(&reg->match))
                         return -EINVAL;
@@ -1431,9 +1472,11 @@ static int vidioc_querycap(struct file *file, void  *priv,
         cap->capabilities =
                         V4L2_CAP_SLICED_VBI_CAPTURE |
                         V4L2_CAP_VIDEO_CAPTURE |
-                        V4L2_CAP_AUDIO |
                         V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
 
+        if (dev->audio_mode.has_audio)
+                cap->capabilities |= V4L2_CAP_AUDIO;
+
         if (dev->tuner_type != TUNER_ABSENT)
                 cap->capabilities |= V4L2_CAP_TUNER;
 
@@ -1654,9 +1697,9 @@ static int radio_queryctrl(struct file *file, void *priv,
                 qc->id >= V4L2_CID_LASTP1)
                 return -EINVAL;
 
-        for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
-                if (qc->id && qc->id == em28xx_qctrl[i].id) {
-                        memcpy(qc, &(em28xx_qctrl[i]), sizeof(*qc));
+        for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++) {
+                if (qc->id && qc->id == ac97_qctrl[i].id) {
+                        memcpy(qc, &(ac97_qctrl[i]), sizeof(*qc));
                         return 0;
                 }
         }
diff --git a/drivers/media/video/em28xx/em28xx.h b/drivers/media/video/em28xx/em28xx.h
index a2add61f7d59..0f2ba9a40d17 100644
--- a/drivers/media/video/em28xx/em28xx.h
+++ b/drivers/media/video/em28xx/em28xx.h
@@ -108,6 +108,7 @@
 #define EM2882_BOARD_KWORLD_ATSC_315U             69
 #define EM2882_BOARD_EVGA_INDTUBE                 70
 #define EM2820_BOARD_SILVERCREST_WEBCAM           71
+#define EM2861_BOARD_GADMEI_UTV330PLUS           72
 
 /* Limits minimum and default number of buffers */
 #define EM28XX_MIN_BUF 4
@@ -398,6 +399,7 @@ struct em28xx_board {
         unsigned int has_snapshot_button:1;
         unsigned int is_webcam:1;
         unsigned int valid:1;
+        unsigned int has_ir_i2c:1;
 
         unsigned char xclk, i2c_speed;
         unsigned char radio_addr;
@@ -408,7 +410,7 @@ struct em28xx_board {
 
         struct em28xx_input       input[MAX_EM28XX_INPUT];
         struct em28xx_input       radio;
-        IR_KEYTAB_TYPE            *ir_codes;
+        struct ir_scancode_table  *ir_codes;
 };
 
 struct em28xx_eeprom {
@@ -595,6 +597,10 @@ struct em28xx {
         struct delayed_work sbutton_query_work;
 
         struct em28xx_dvb *dvb;
+
+        /* I2C keyboard data */
+        struct i2c_board_info info;
+        struct IR_i2c_init_data init_data;
 };
 
 struct em28xx_ops {
diff --git a/drivers/media/video/gspca/Kconfig b/drivers/media/video/gspca/Kconfig
index e994dcac43ff..8897283b0bb4 100644
--- a/drivers/media/video/gspca/Kconfig
+++ b/drivers/media/video/gspca/Kconfig
@@ -47,6 +47,15 @@ config USB_GSPCA_FINEPIX
           To compile this driver as a module, choose M here: the
           module will be called gspca_finepix.
 
+config USB_GSPCA_JEILINJ
+        tristate "Jeilin JPEG USB V4L2 driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for cameras based on this Jeilin chip.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_jeilinj.
+
 config USB_GSPCA_MARS
         tristate "Mars USB Camera Driver"
         depends on VIDEO_V4L2 && USB_GSPCA
@@ -103,9 +112,9 @@ config USB_GSPCA_PAC7311
           module will be called gspca_pac7311.
 
 config USB_GSPCA_SN9C20X
-       tristate "SN9C20X USB Camera Driver"
-       depends on VIDEO_V4L2 && USB_GSPCA
-       help
+        tristate "SN9C20X USB Camera Driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
          Say Y here if you want support for cameras based on the
          sn9c20x chips (SN9C201 and SN9C202).
 
@@ -113,10 +122,10 @@ config USB_GSPCA_SN9C20X
          module will be called gspca_sn9c20x.
 
 config USB_GSPCA_SN9C20X_EVDEV
-       bool "Enable evdev support"
+        bool "Enable evdev support"
         depends on USB_GSPCA_SN9C20X && INPUT
-       ---help---
-         Say Y here in order to enable evdev support for sn9c20x webcam button.
+        ---help---
+          Say Y here in order to enable evdev support for sn9c20x webcam button.
 
 config USB_GSPCA_SONIXB
         tristate "SONIX Bayer USB Camera Driver"
diff --git a/drivers/media/video/gspca/Makefile b/drivers/media/video/gspca/Makefile
index f6d3b86e9ad5..035616b5e867 100644
--- a/drivers/media/video/gspca/Makefile
+++ b/drivers/media/video/gspca/Makefile
@@ -2,6 +2,7 @@ obj-$(CONFIG_USB_GSPCA)          += gspca_main.o
 obj-$(CONFIG_USB_GSPCA_CONEX)    += gspca_conex.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_MARS)     += gspca_mars.o
 obj-$(CONFIG_USB_GSPCA_MR97310A) += gspca_mr97310a.o
 obj-$(CONFIG_USB_GSPCA_OV519)    += gspca_ov519.o
@@ -30,6 +31,7 @@ gspca_main-objs     := gspca.o
 gspca_conex-objs    := conex.o
 gspca_etoms-objs    := etoms.o
 gspca_finepix-objs  := finepix.o
+gspca_jeilinj-objs  := jeilinj.o
 gspca_mars-objs     := mars.o
 gspca_mr97310a-objs := mr97310a.o
 gspca_ov519-objs    := ov519.o
diff --git a/drivers/media/video/gspca/conex.c b/drivers/media/video/gspca/conex.c
index 8d48ea1742c2..eca003566ae3 100644
--- a/drivers/media/video/gspca/conex.c
+++ b/drivers/media/video/gspca/conex.c
@@ -820,7 +820,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         cam = &gspca_dev->cam;
         cam->cam_mode = vga_mode;
-        cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
+        cam->nmodes = ARRAY_SIZE(vga_mode);
 
         sd->brightness = BRIGHTNESS_DEF;
         sd->contrast = CONTRAST_DEF;
diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c
index 2c20d06a03e8..c1461e63647f 100644
--- a/drivers/media/video/gspca/etoms.c
+++ b/drivers/media/video/gspca/etoms.c
@@ -635,10 +635,10 @@ static int sd_config(struct gspca_dev *gspca_dev,
         sd->sensor = id->driver_info;
         if (sd->sensor == SENSOR_PAS106) {
                 cam->cam_mode = sif_mode;
-                cam->nmodes = sizeof sif_mode / sizeof sif_mode[0];
+                cam->nmodes = ARRAY_SIZE(sif_mode);
         } else {
                 cam->cam_mode = vga_mode;
-                cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
+                cam->nmodes = ARRAY_SIZE(vga_mode);
                 gspca_dev->ctrl_dis = (1 << COLOR_IDX);
         }
         sd->brightness = BRIGHTNESS_DEF;
diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c
index b8561dfb6c8c..cf6540da1e42 100644
--- a/drivers/media/video/gspca/gspca.c
+++ b/drivers/media/video/gspca/gspca.c
@@ -47,7 +47,7 @@ MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
 MODULE_DESCRIPTION("GSPCA USB Camera Driver");
 MODULE_LICENSE("GPL");
 
-#define DRIVER_VERSION_NUMBER   KERNEL_VERSION(2, 6, 0)
+#define DRIVER_VERSION_NUMBER   KERNEL_VERSION(2, 7, 0)
 
 #ifdef GSPCA_DEBUG
 int gspca_debug = D_ERR | D_PROBE;
@@ -486,6 +486,7 @@ static struct usb_host_endpoint *get_ep(struct gspca_dev *gspca_dev)
         }
         PDEBUG(D_STREAM, "use alt %d ep 0x%02x",
                         i, ep->desc.bEndpointAddress);
+        gspca_dev->alt = i;             /* memorize the current alt setting */
         if (gspca_dev->nbalt > 1) {
                 ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, i);
                 if (ret < 0) {
@@ -493,7 +494,6 @@ static struct usb_host_endpoint *get_ep(struct gspca_dev *gspca_dev)
                         return NULL;
                 }
         }
-        gspca_dev->alt = i;             /* memorize the current alt setting */
         return ep;
 }
 
@@ -512,7 +512,10 @@ static int create_urbs(struct gspca_dev *gspca_dev,
         if (!gspca_dev->cam.bulk) {             /* isoc */
 
                 /* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */
-                psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
+                if (gspca_dev->pkt_size == 0)
+                        psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
+                else
+                        psize = gspca_dev->pkt_size;
                 npkt = gspca_dev->cam.npkt;
                 if (npkt == 0)
                         npkt = 32;              /* default value */
@@ -597,13 +600,18 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
         /* set the higher alternate setting and
          * loop until urb submit succeeds */
         gspca_dev->alt = gspca_dev->nbalt;
+        if (gspca_dev->sd_desc->isoc_init) {
+                ret = gspca_dev->sd_desc->isoc_init(gspca_dev);
+                if (ret < 0)
+                        goto out;
+        }
+        ep = get_ep(gspca_dev);
+        if (ep == NULL) {
+                ret = -EIO;
+                goto out;
+        }
         for (;;) {
                 PDEBUG(D_STREAM, "init transfer alt %d", gspca_dev->alt);
-                ep = get_ep(gspca_dev);
-                if (ep == NULL) {
-                        ret = -EIO;
-                        goto out;
-                }
                 ret = create_urbs(gspca_dev, ep);
                 if (ret < 0)
                         goto out;
@@ -628,21 +636,32 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
                 /* submit the URBs */
                 for (n = 0; n < gspca_dev->nurbs; n++) {
                         ret = usb_submit_urb(gspca_dev->urb[n], GFP_KERNEL);
-                        if (ret < 0) {
-                                PDEBUG(D_ERR|D_STREAM,
-                                        "usb_submit_urb [%d] err %d", n, ret);
-                                gspca_dev->streaming = 0;
-                                destroy_urbs(gspca_dev);
-                                if (ret == -ENOSPC) {
-                                        msleep(20);     /* wait for kill
-                                                         * complete */
-                                        break;  /* try the previous alt */
-                                }
-                                goto out;
-                        }
+                        if (ret < 0)
+                                break;
                 }
                 if (ret >= 0)
                         break;
+                PDEBUG(D_ERR|D_STREAM,
+                        "usb_submit_urb alt %d err %d", gspca_dev->alt, ret);
+                gspca_dev->streaming = 0;
+                destroy_urbs(gspca_dev);
+                if (ret != -ENOSPC)
+                        goto out;
+
+                /* the bandwidth is not wide enough
+                 * negociate or try a lower alternate setting */
+                msleep(20);     /* wait for kill complete */
+                if (gspca_dev->sd_desc->isoc_nego) {
+                        ret = gspca_dev->sd_desc->isoc_nego(gspca_dev);
+                        if (ret < 0)
+                                goto out;
+                } else {
+                        ep = get_ep(gspca_dev);
+                        if (ep == NULL) {
+                                ret = -EIO;
+                                goto out;
+                        }
+                }
         }
 out:
         mutex_unlock(&gspca_dev->usb_lock);
@@ -1473,12 +1492,6 @@ static int vidioc_s_parm(struct file *filp, void *priv,
         return 0;
 }
 
-static int vidioc_s_std(struct file *filp, void *priv,
-                        v4l2_std_id *parm)
-{
-        return 0;
-}
-
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 static int vidiocgmbuf(struct file *file, void *priv,
                         struct video_mbuf *mbuf)
@@ -1949,7 +1962,6 @@ static const struct v4l2_ioctl_ops dev_ioctl_ops = {
         .vidioc_s_jpegcomp      = vidioc_s_jpegcomp,
         .vidioc_g_parm          = vidioc_g_parm,
         .vidioc_s_parm          = vidioc_s_parm,
-        .vidioc_s_std           = vidioc_s_std,
         .vidioc_enum_framesizes = vidioc_enum_framesizes,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
         .vidioc_g_register      = vidioc_g_register,
diff --git a/drivers/media/video/gspca/gspca.h b/drivers/media/video/gspca/gspca.h
index 46c4effdfcd5..70b1fd830876 100644
--- a/drivers/media/video/gspca/gspca.h
+++ b/drivers/media/video/gspca/gspca.h
@@ -98,9 +98,11 @@ struct sd_desc {
 /* mandatory operations */
         cam_cf_op config;       /* called on probe */
         cam_op init;            /* called on probe and resume */
-        cam_op start;           /* called on stream on */
+        cam_op start;           /* called on stream on after URBs creation */
         cam_pkt_op pkt_scan;
 /* optional operations */
+        cam_op isoc_init;       /* called on stream on before getting the EP */
+        cam_op isoc_nego;       /* called when URB submit failed with NOSPC */
         cam_v_op stopN;         /* called on stream off - main alt */
         cam_v_op stop0;         /* called on stream off & disconnect - alt 0 */
         cam_v_op dq_callback;   /* called when a frame has been dequeued */
@@ -178,6 +180,7 @@ struct gspca_dev {
         __u8 iface;                     /* USB interface number */
         __u8 alt;                       /* USB alternate setting */
         __u8 nbalt;                     /* number of USB alternate settings */
+        u16 pkt_size;                   /* ISOC packet size */
 };
 
 int gspca_dev_probe(struct usb_interface *intf,
diff --git a/drivers/media/video/gspca/jeilinj.c b/drivers/media/video/gspca/jeilinj.c
new file mode 100644
index 000000000000..dbfa3ed6e8ef
--- /dev/null
+++ b/drivers/media/video/gspca/jeilinj.c
@@ -0,0 +1,388 @@
+/*
+ * Jeilinj subdriver
+ *
+ * Supports some Jeilin dual-mode cameras which use bulk transport and
+ * download raw JPEG data.
+ *
+ * Copyright (C) 2009 Theodore Kilgore
+ *
+ * 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 "jeilinj"
+
+#include <linux/workqueue.h>
+#include "gspca.h"
+#include "jpeg.h"
+
+MODULE_AUTHOR("Theodore Kilgore <kilgota@auburn.edu>");
+MODULE_DESCRIPTION("GSPCA/JEILINJ USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+/* Default timeouts, in ms */
+#define JEILINJ_CMD_TIMEOUT 500
+#define JEILINJ_DATA_TIMEOUT 1000
+
+/* Maximum transfer size to use. */
+#define JEILINJ_MAX_TRANSFER 0x200
+
+#define FRAME_HEADER_LEN 0x10
+
+/* Structure to hold all of our device specific stuff */
+struct sd {
+        struct gspca_dev gspca_dev;     /* !! must be the first item */
+        const struct v4l2_pix_format *cap_mode;
+        /* Driver stuff */
+        struct work_struct work_struct;
+        struct workqueue_struct *work_thread;
+        u8 quality;                              /* image quality */
+        u8 jpegqual;                            /* webcam quality */
+        u8 *jpeg_hdr;
+};
+
+        struct jlj_command {
+                unsigned char instruction[2];
+                unsigned char ack_wanted;
+        };
+
+/* AFAICT these cameras will only do 320x240. */
+static struct v4l2_pix_format jlj_mode[] = {
+        { 320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 0}
+};
+
+/*
+ * cam uses endpoint 0x03 to send commands, 0x84 for read commands,
+ * and 0x82 for bulk transfer.
+ */
+
+/* All commands are two bytes only */
+static int jlj_write2(struct gspca_dev *gspca_dev, unsigned char *command)
+{
+        int retval;
+
+        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",
+                                gspca_dev->usb_buf[0], retval);
+        return retval;
+}
+
+/* Responses are one byte only */
+static int jlj_read1(struct gspca_dev *gspca_dev, unsigned char response)
+{
+        int retval;
+
+        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",
+                                gspca_dev->usb_buf[0], retval);
+        return retval;
+}
+
+static int jlj_start(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}
+        };
+        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;
+}
+
+static int jlj_stop(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}
+        };
+        for (i = 0; i < ARRAY_SIZE(stop_commands); i++) {
+                retval = jlj_write2(gspca_dev, stop_commands[i].instruction);
+                if (retval < 0)
+                        return retval;
+        }
+        return retval;
+}
+
+/* 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)
+{
+        struct sd *dev = container_of(work, struct sd, work_struct);
+        struct gspca_dev *gspca_dev = &dev->gspca_dev;
+        struct gspca_frame *frame;
+        int blocks_left; /* 0x200-sized blocks remaining in current frame. */
+        int size_in_blocks;
+        int act_len;
+        int discarding = 0; /* true if we failed to get space for frame. */
+        int packet_type;
+        int ret;
+        u8 *buffer;
+
+        buffer = kmalloc(JEILINJ_MAX_TRANSFER, GFP_KERNEL | GFP_DMA);
+        if (!buffer) {
+                PDEBUG(D_ERR, "Couldn't allocate USB buffer");
+                goto quit_stream;
+        }
+        while (gspca_dev->present && gspca_dev->streaming) {
+                if (!gspca_dev->present)
+                        goto quit_stream;
+                /* Start a new frame, and add the JPEG header, first thing */
+                frame = gspca_get_i_frame(gspca_dev);
+                if (frame && !discarding)
+                        gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                                        dev->jpeg_hdr, JPEG_HDR_SZ);
+                 else
+                        discarding = 1;
+                /*
+                 * 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);
+                packet_type = INTER_PACKET;
+                if (frame && !discarding)
+                        /* Toss line 0 of data block 0, keep the rest. */
+                        gspca_frame_add(gspca_dev, packet_type,
+                                frame, buffer + FRAME_HEADER_LEN,
+                                JEILINJ_MAX_TRANSFER - FRAME_HEADER_LEN);
+                        else
+                                discarding = 1;
+                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;
+                        if (frame && !discarding)
+                                gspca_frame_add(gspca_dev, packet_type,
+                                                frame, buffer,
+                                                JEILINJ_MAX_TRANSFER);
+                        else
+                                discarding = 1;
+                }
+        }
+quit_stream:
+        mutex_lock(&gspca_dev->usb_lock);
+        if (gspca_dev->present)
+                jlj_stop(gspca_dev);
+        mutex_unlock(&gspca_dev->usb_lock);
+        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 *dev  = (struct sd *) gspca_dev;
+
+        dev->quality  = 85;
+        dev->jpegqual = 85;
+        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->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);
+        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 jlj_dostream to finish */
+        destroy_workqueue(dev->work_thread);
+        dev->work_thread = NULL;
+        mutex_lock(&gspca_dev->usb_lock);
+        kfree(dev->jpeg_hdr);
+}
+
+/* this function is called at probe and resume time */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+        return 0;
+}
+
+/* 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 */
+        dev->jpeg_hdr = kmalloc(JPEG_HDR_SZ, GFP_KERNEL);
+        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;
+}
+
+/* Table of supported USB devices */
+static const __devinitdata struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x0979, 0x0280)},
+        {}
+};
+
+MODULE_DEVICE_TABLE(usb, device_table);
+
+/* sub-driver description */
+static const struct sd_desc sd_desc = {
+        .name   = MODULE_NAME,
+        .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)
+{
+        int ret;
+
+        ret = usb_register(&sd_driver);
+        if (ret < 0)
+                return ret;
+        PDEBUG(D_PROBE, "registered");
+        return 0;
+}
+
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+        PDEBUG(D_PROBE, "deregistered");
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
diff --git a/drivers/media/video/gspca/m5602/m5602_s5k83a.c b/drivers/media/video/gspca/m5602/m5602_s5k83a.c
index 7127321ace8c..6b89f33a4ce0 100644
--- a/drivers/media/video/gspca/m5602/m5602_s5k83a.c
+++ b/drivers/media/video/gspca/m5602/m5602_s5k83a.c
@@ -178,8 +178,10 @@ sensor_found:
 
         sens_priv->settings =
         kmalloc(sizeof(s32)*ARRAY_SIZE(s5k83a_ctrls), GFP_KERNEL);
-        if (!sens_priv->settings)
+        if (!sens_priv->settings) {
+                kfree(sens_priv);
                 return -ENOMEM;
+        }
 
         sd->gspca_dev.cam.cam_mode = s5k83a_modes;
         sd->gspca_dev.cam.nmodes = ARRAY_SIZE(s5k83a_modes);
diff --git a/drivers/media/video/gspca/mr97310a.c b/drivers/media/video/gspca/mr97310a.c
index 30132513400c..140c8f320e47 100644
--- a/drivers/media/video/gspca/mr97310a.c
+++ b/drivers/media/video/gspca/mr97310a.c
@@ -3,6 +3,21 @@
  *
  * Copyright (C) 2009 Kyle Guinn <elyk03@gmail.com>
  *
+ * Support for the MR97310A cameras in addition to the Aiptek Pencam VGA+
+ * and for the routines for detecting and classifying these various cameras,
+ *
+ * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
+ *
+ * Acknowledgements:
+ *
+ * The MR97311A support in gspca/mars.c has been helpful in understanding some
+ * of the registers in these cameras.
+ *
+ * Hans de Goede <hdgoede@redhat.com> and
+ * Thomas Kaiser <thomas@kaiser-linux.li>
+ * have assisted with their experience. Each of them has also helped by
+ * testing a previously unsupported camera.
+ *
  * 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
@@ -22,18 +37,108 @@
 
 #include "gspca.h"
 
-MODULE_AUTHOR("Kyle Guinn <elyk03@gmail.com>");
+#define CAM_TYPE_CIF                    0
+#define CAM_TYPE_VGA                    1
+
+#define MR97310A_BRIGHTNESS_MIN         -254
+#define MR97310A_BRIGHTNESS_MAX         255
+#define MR97310A_BRIGHTNESS_DEFAULT     0
+
+#define MR97310A_EXPOSURE_MIN           300
+#define MR97310A_EXPOSURE_MAX           4095
+#define MR97310A_EXPOSURE_DEFAULT       1000
+
+#define MR97310A_GAIN_MIN               0
+#define MR97310A_GAIN_MAX               31
+#define MR97310A_GAIN_DEFAULT           25
+
+MODULE_AUTHOR("Kyle Guinn <elyk03@gmail.com>,"
+              "Theodore Kilgore <kilgota@auburn.edu>");
 MODULE_DESCRIPTION("GSPCA/Mars-Semi MR97310A USB Camera Driver");
 MODULE_LICENSE("GPL");
 
+/* global parameters */
+int force_sensor_type = -1;
+module_param(force_sensor_type, int, 0644);
+MODULE_PARM_DESC(force_sensor_type, "Force sensor type (-1 (auto), 0 or 1)");
+
 /* specific webcam descriptor */
 struct sd {
         struct gspca_dev gspca_dev;  /* !! must be the first item */
         u8 sof_read;
+        u8 cam_type;    /* 0 is CIF and 1 is VGA */
+        u8 sensor_type; /* We use 0 and 1 here, too. */
+        u8 do_lcd_stop;
+
+        int brightness;
+        u16 exposure;
+        u8 gain;
+};
+
+struct sensor_w_data {
+        u8 reg;
+        u8 flags;
+        u8 data[16];
+        int len;
 };
 
+static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
+static void setbrightness(struct gspca_dev *gspca_dev);
+static void setexposure(struct gspca_dev *gspca_dev);
+static void setgain(struct gspca_dev *gspca_dev);
+
 /* V4L2 controls supported by the driver */
 static struct ctrl sd_ctrls[] = {
+        {
+#define BRIGHTNESS_IDX 0
+                {
+                        .id = V4L2_CID_BRIGHTNESS,
+                        .type = V4L2_CTRL_TYPE_INTEGER,
+                        .name = "Brightness",
+                        .minimum = MR97310A_BRIGHTNESS_MIN,
+                        .maximum = MR97310A_BRIGHTNESS_MAX,
+                        .step = 1,
+                        .default_value = MR97310A_BRIGHTNESS_DEFAULT,
+                        .flags = 0,
+                },
+                .set = sd_setbrightness,
+                .get = sd_getbrightness,
+        },
+        {
+#define EXPOSURE_IDX 1
+                {
+                        .id = V4L2_CID_EXPOSURE,
+                        .type = V4L2_CTRL_TYPE_INTEGER,
+                        .name = "Exposure",
+                        .minimum = MR97310A_EXPOSURE_MIN,
+                        .maximum = MR97310A_EXPOSURE_MAX,
+                        .step = 1,
+                        .default_value = MR97310A_EXPOSURE_DEFAULT,
+                        .flags = 0,
+                },
+                .set = sd_setexposure,
+                .get = sd_getexposure,
+        },
+        {
+#define GAIN_IDX 2
+                {
+                        .id = V4L2_CID_GAIN,
+                        .type = V4L2_CTRL_TYPE_INTEGER,
+                        .name = "Gain",
+                        .minimum = MR97310A_GAIN_MIN,
+                        .maximum = MR97310A_GAIN_MAX,
+                        .step = 1,
+                        .default_value = MR97310A_GAIN_DEFAULT,
+                        .flags = 0,
+                },
+                .set = sd_setgain,
+                .get = sd_getgain,
+        },
 };
 
 static const struct v4l2_pix_format vga_mode[] = {
@@ -65,7 +170,7 @@ static const struct v4l2_pix_format vga_mode[] = {
 };
 
 /* the bytes to write are in gspca_dev->usb_buf */
-static int reg_w(struct gspca_dev *gspca_dev, int len)
+static int mr_write(struct gspca_dev *gspca_dev, int len)
 {
         int rc;
 
@@ -78,15 +183,249 @@ static int reg_w(struct gspca_dev *gspca_dev, int len)
         return rc;
 }
 
+/* the bytes are read into gspca_dev->usb_buf */
+static int mr_read(struct gspca_dev *gspca_dev, int len)
+{
+        int rc;
+
+        rc = usb_bulk_msg(gspca_dev->dev,
+                          usb_rcvbulkpipe(gspca_dev->dev, 3),
+                          gspca_dev->usb_buf, len, NULL, 500);
+        if (rc < 0)
+                PDEBUG(D_ERR, "reg read [%02x] error %d",
+                       gspca_dev->usb_buf[0], rc);
+        return rc;
+}
+
+static int sensor_write_reg(struct gspca_dev *gspca_dev, u8 reg, u8 flags,
+        const u8 *data, int len)
+{
+        gspca_dev->usb_buf[0] = 0x1f;
+        gspca_dev->usb_buf[1] = flags;
+        gspca_dev->usb_buf[2] = reg;
+        memcpy(gspca_dev->usb_buf + 3, data, len);
+
+        return mr_write(gspca_dev, len + 3);
+}
+
+static int sensor_write_regs(struct gspca_dev *gspca_dev,
+        const struct sensor_w_data *data, int len)
+{
+        int i, rc;
+
+        for (i = 0; i < len; i++) {
+                rc = sensor_write_reg(gspca_dev, data[i].reg, data[i].flags,
+                                          data[i].data, data[i].len);
+                if (rc < 0)
+                        return rc;
+        }
+
+        return 0;
+}
+
+static int sensor_write1(struct gspca_dev *gspca_dev, u8 reg, u8 data)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 buf, confirm_reg;
+        int rc;
+
+        buf = data;
+        rc = sensor_write_reg(gspca_dev, reg, 0x01, &buf, 1);
+        if (rc < 0)
+                return rc;
+
+        buf = 0x01;
+        confirm_reg = sd->sensor_type ? 0x13 : 0x11;
+        rc = sensor_write_reg(gspca_dev, confirm_reg, 0x00, &buf, 1);
+        if (rc < 0)
+                return rc;
+
+        return 0;
+}
+
+static int cam_get_response16(struct gspca_dev *gspca_dev)
+{
+        __u8 *data = gspca_dev->usb_buf;
+        int err_code;
+
+        data[0] = 0x21;
+        err_code = mr_write(gspca_dev, 1);
+        if (err_code < 0)
+                return err_code;
+
+        err_code = mr_read(gspca_dev, 16);
+        return err_code;
+}
+
+static int zero_the_pointer(struct gspca_dev *gspca_dev)
+{
+        __u8 *data = gspca_dev->usb_buf;
+        int err_code;
+        u8 status = 0;
+        int tries = 0;
+
+        err_code = cam_get_response16(gspca_dev);
+        if (err_code < 0)
+                return err_code;
+
+        err_code = mr_write(gspca_dev, 1);
+        data[0] = 0x19;
+        data[1] = 0x51;
+        err_code = mr_write(gspca_dev, 2);
+        if (err_code < 0)
+                return err_code;
+
+        err_code = cam_get_response16(gspca_dev);
+        if (err_code < 0)
+                return err_code;
+
+        data[0] = 0x19;
+        data[1] = 0xba;
+        err_code = mr_write(gspca_dev, 2);
+        if (err_code < 0)
+                return err_code;
+
+        err_code = cam_get_response16(gspca_dev);
+        if (err_code < 0)
+                return err_code;
+
+        data[0] = 0x19;
+        data[1] = 0x00;
+        err_code = mr_write(gspca_dev, 2);
+        if (err_code < 0)
+                return err_code;
+
+        err_code = cam_get_response16(gspca_dev);
+        if (err_code < 0)
+                return err_code;
+
+        data[0] = 0x19;
+        data[1] = 0x00;
+        err_code = mr_write(gspca_dev, 2);
+        if (err_code < 0)
+                return err_code;
+
+        while (status != 0x0a && tries < 256) {
+                err_code = cam_get_response16(gspca_dev);
+                status = data[0];
+                tries++;
+                if (err_code < 0)
+                        return err_code;
+        }
+        if (status != 0x0a)
+                PDEBUG(D_ERR, "status is %02x", status);
+
+        tries = 0;
+        while (tries < 4) {
+                data[0] = 0x19;
+                data[1] = 0x00;
+                err_code = mr_write(gspca_dev, 2);
+                if (err_code < 0)
+                        return err_code;
+
+                err_code = cam_get_response16(gspca_dev);
+                status = data[0];
+                tries++;
+                if (err_code < 0)
+                        return err_code;
+        }
+
+        data[0] = 0x19;
+        err_code = mr_write(gspca_dev, 1);
+        if (err_code < 0)
+                return err_code;
+
+        err_code = mr_read(gspca_dev, 16);
+        if (err_code < 0)
+                return err_code;
+
+        return 0;
+}
+
+static u8 get_sensor_id(struct gspca_dev *gspca_dev)
+{
+        int err_code;
+
+        gspca_dev->usb_buf[0] = 0x1e;
+        err_code = mr_write(gspca_dev, 1);
+        if (err_code < 0)
+                return err_code;
+
+        err_code = mr_read(gspca_dev, 16);
+        if (err_code < 0)
+                return err_code;
+
+        PDEBUG(D_PROBE, "Byte zero reported is %01x", gspca_dev->usb_buf[0]);
+
+        return gspca_dev->usb_buf[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;
+        __u8 *data = gspca_dev->usb_buf;
+        int err_code;
 
         cam = &gspca_dev->cam;
         cam->cam_mode = vga_mode;
         cam->nmodes = ARRAY_SIZE(vga_mode);
+
+        if (id->idProduct == 0x010e) {
+                sd->cam_type = CAM_TYPE_CIF;
+                cam->nmodes--;
+
+                data[0] = 0x01;
+                data[1] = 0x01;
+                err_code = mr_write(gspca_dev, 2);
+                if (err_code < 0)
+                        return err_code;
+
+                msleep(200);
+                data[0] = get_sensor_id(gspca_dev);
+                /*
+                 * Known CIF cameras. If you have another to report, please do
+                 *
+                 * Name                 byte just read          sd->sensor_type
+                 *                                      reported by
+                 * Sakar Spy-shot       0x28            T. Kilgore      0
+                 * Innovage             0xf5 (unstable) T. Kilgore      0
+                 * Vivitar Mini         0x53            H. De Goede     0
+                 * Vivitar Mini         0x04 / 0x24     E. Rodriguez    0
+                 * Vivitar Mini         0x08            T. Kilgore      1
+                 * Elta-Media 8212dc    0x23            T. Kaiser       1
+                 * Philips dig. keych.  0x37            T. Kilgore      1
+                 */
+                if ((data[0] & 0x78) == 8 ||
+                    ((data[0] & 0x2) == 0x2 && data[0] != 0x53))
+                        sd->sensor_type = 1;
+                else
+                        sd->sensor_type = 0;
+
+                PDEBUG(D_PROBE, "MR97310A CIF camera detected, sensor: %d",
+                       sd->sensor_type);
+
+                if (force_sensor_type != -1) {
+                        sd->sensor_type = !! force_sensor_type;
+                        PDEBUG(D_PROBE, "Forcing sensor type to: %d",
+                               sd->sensor_type);
+                }
+
+                if (sd->sensor_type == 0)
+                        gspca_dev->ctrl_dis = (1 << BRIGHTNESS_IDX);
+        } else {
+                sd->cam_type = CAM_TYPE_VGA;
+                PDEBUG(D_PROBE, "MR97310A VGA camera detected");
+                gspca_dev->ctrl_dis = (1 << BRIGHTNESS_IDX) |
+                                      (1 << EXPOSURE_IDX) | (1 << GAIN_IDX);
+        }
+
+        sd->brightness = MR97310A_BRIGHTNESS_DEFAULT;
+        sd->exposure = MR97310A_EXPOSURE_DEFAULT;
+        sd->gain = MR97310A_GAIN_DEFAULT;
+
         return 0;
 }
 
@@ -96,183 +435,462 @@ static int sd_init(struct gspca_dev *gspca_dev)
         return 0;
 }
 
-static int sd_start(struct gspca_dev *gspca_dev)
+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;
-
-        sd->sof_read = 0;
-
-        /* Note:  register descriptions guessed from MR97113A driver */
-
+        const __u8 startup_string[] = {
+                0x00,
+                0x0d,
+                0x01,
+                0x00, /* Hsize/8 for 352 or 320 */
+                0x00, /* Vsize/4 for 288 or 240 */
+                0x13, /* or 0xbb, depends on sensor */
+                0x00, /* Hstart, depends on res. */
+                0x00, /* reserved ? */
+                0x00, /* Vstart, depends on res. and sensor */
+                0x50, /* 0x54 to get 176 or 160 */
+                0xc0
+        };
+
+        /* Note: Some of the above descriptions guessed from MR97113A driver */
         data[0] = 0x01;
         data[1] = 0x01;
-        err_code = reg_w(gspca_dev, 2);
+        err_code = mr_write(gspca_dev, 2);
         if (err_code < 0)
                 return err_code;
 
-        data[0] = 0x00;
-        data[1] = 0x0d;
-        data[2] = 0x01;
-        data[5] = 0x2b;
-        data[7] = 0x00;
-        data[9] = 0x50;  /* reg 8, no scale down */
-        data[10] = 0xc0;
+        memcpy(data, startup_string, 11);
+        if (sd->sensor_type)
+                data[5] = 0xbb;
 
         switch (gspca_dev->width) {
         case 160:
-                data[9] |= 0x0c;  /* reg 8, 4:1 scale down */
+                data[9] |= 0x04;  /* reg 8, 2:1 scale down from 320 */
                 /* fall thru */
         case 320:
-                data[9] |= 0x04;  /* reg 8, 2:1 scale down */
-                /* fall thru */
-        case 640:
         default:
-                data[3] = 0x50;  /* reg 2, H size */
-                data[4] = 0x78;  /* reg 3, V size */
-                data[6] = 0x04;  /* reg 5, H start */
-                data[8] = 0x03;  /* reg 7, V start */
+                data[3] = 0x28;                    /* reg 2, H size/8 */
+                data[4] = 0x3c;                    /* reg 3, V size/4 */
+                data[6] = 0x14;                    /* reg 5, H start  */
+                data[8] = 0x1a + sd->sensor_type;  /* reg 7, V start  */
                 break;
-
         case 176:
-                data[9] |= 0x04;  /* reg 8, 2:1 scale down */
+                data[9] |= 0x04;  /* reg 8, 2:1 scale down from 352 */
                 /* fall thru */
         case 352:
-                data[3] = 0x2c;  /* reg 2, H size */
-                data[4] = 0x48;  /* reg 3, V size */
-                data[6] = 0x94;  /* reg 5, H start */
-                data[8] = 0x63;  /* reg 7, V start */
+                data[3] = 0x2c;                    /* reg 2, H size/8 */
+                data[4] = 0x48;                    /* reg 3, V size/4 */
+                data[6] = 0x06;                    /* reg 5, H start  */
+                data[8] = 0x06 + sd->sensor_type;  /* reg 7, V start  */
                 break;
         }
-
-        err_code = reg_w(gspca_dev, 11);
+        err_code = mr_write(gspca_dev, 11);
         if (err_code < 0)
                 return err_code;
 
-        data[0] = 0x0a;
-        data[1] = 0x80;
-        err_code = reg_w(gspca_dev, 2);
+        if (!sd->sensor_type) {
+                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},
+                        {0x12, 0x00, {0x07}, 1},
+                        {0x1f, 0x00, {0x06}, 1},
+                        {0x27, 0x00, {0x04}, 1},
+                        {0x29, 0x00, {0x0c}, 1},
+                        {0x40, 0x00, {0x40, 0x00, 0x04}, 3},
+                        {0x50, 0x00, {0x60}, 1},
+                        {0x60, 0x00, {0x06}, 1},
+                        {0x6b, 0x00, {0x85, 0x85, 0xc8, 0xc8, 0xc8, 0xc8}, 6},
+                        {0x72, 0x00, {0x1e, 0x56}, 2},
+                        {0x75, 0x00, {0x58, 0x40, 0xa2, 0x02, 0x31, 0x02,
+                                      0x31, 0x80, 0x00}, 9},
+                        {0x11, 0x00, {0x01}, 1},
+                        {0, 0, {0}, 0}
+                };
+                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[] = {
+                        /* 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 */
+                        {0x06, 0x01, {0x00}, 1},
+                        {0x09, 0x02, {0x0e}, 1},
+                        {0x0a, 0x02, {0x05}, 1},
+                        {0x0b, 0x02, {0x05}, 1},
+                        {0x0c, 0x02, {0x0f}, 1},
+                        {0x0d, 0x02, {0x07}, 1},
+                        {0x0e, 0x02, {0x0c}, 1},
+                        {0x0f, 0x00, {0x00}, 1},
+                        {0x10, 0x00, {0x06}, 1},
+                        {0x11, 0x00, {0x07}, 1},
+                        {0x12, 0x00, {0x00}, 1},
+                        {0x13, 0x00, {0x01}, 1},
+                        {0, 0, {0}, 0}
+                };
+                err_code = sensor_write_regs(gspca_dev, cif_sensor1_init_data,
+                                         ARRAY_SIZE(cif_sensor1_init_data));
+        }
         if (err_code < 0)
                 return err_code;
 
-        data[0] = 0x14;
-        data[1] = 0x0a;
-        err_code = reg_w(gspca_dev, 2);
-        if (err_code < 0)
-                return err_code;
+        setbrightness(gspca_dev);
+        setexposure(gspca_dev);
+        setgain(gspca_dev);
 
-        data[0] = 0x1b;
-        data[1] = 0x00;
-        err_code = reg_w(gspca_dev, 2);
-        if (err_code < 0)
-                return err_code;
+        msleep(200);
 
-        data[0] = 0x15;
-        data[1] = 0x16;
-        err_code = reg_w(gspca_dev, 2);
+        data[0] = 0x00;
+        data[1] = 0x4d;  /* ISOC transfering enable... */
+        err_code = mr_write(gspca_dev, 2);
         if (err_code < 0)
                 return err_code;
 
-        data[0] = 0x16;
-        data[1] = 0x10;
-        err_code = reg_w(gspca_dev, 2);
-        if (err_code < 0)
-                return err_code;
+        return 0;
+}
 
-        data[0] = 0x17;
-        data[1] = 0x3a;
-        err_code = reg_w(gspca_dev, 2);
-        if (err_code < 0)
-                return err_code;
+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};
 
-        data[0] = 0x18;
-        data[1] = 0x68;
-        err_code = reg_w(gspca_dev, 2);
-        if (err_code < 0)
-                return err_code;
+        /* What some of these mean is explained in start_cif_cam(), above */
+        sd->sof_read = 0;
 
-        data[0] = 0x1f;
-        data[1] = 0x00;
-        data[2] = 0x02;
-        data[3] = 0x06;
-        data[4] = 0x59;
-        data[5] = 0x0c;
-        data[6] = 0x16;
-        data[7] = 0x00;
-        data[8] = 0x07;
-        data[9] = 0x00;
-        data[10] = 0x01;
-        err_code = reg_w(gspca_dev, 11);
+        /*
+         * We have to know which camera we have, because the register writes
+         * depend upon the camera. This test, run before we actually enter
+         * the initialization routine, distinguishes most of the cameras, If
+         * needed, another routine is done later, too.
+         */
+        memset(data, 0, 16);
+        data[0] = 0x20;
+        err_code = mr_write(gspca_dev, 1);
         if (err_code < 0)
                 return err_code;
 
-        data[0] = 0x1f;
-        data[1] = 0x04;
-        data[2] = 0x11;
-        data[3] = 0x01;
-        err_code = reg_w(gspca_dev, 4);
+        err_code = mr_read(gspca_dev, 16);
         if (err_code < 0)
                 return err_code;
 
-        data[0] = 0x1f;
-        data[1] = 0x00;
-        data[2] = 0x0a;
-        data[3] = 0x00;
-        data[4] = 0x01;
-        data[5] = 0x00;
-        data[6] = 0x00;
-        data[7] = 0x01;
-        data[8] = 0x00;
-        data[9] = 0x0a;
-        err_code = reg_w(gspca_dev, 10);
-        if (err_code < 0)
-                return err_code;
+        PDEBUG(D_PROBE, "Byte reported is %02x", data[0]);
+
+        msleep(200);
+        /*
+         * Known VGA cameras. If you have another to report, please do
+         *
+         * Name                 byte just read          sd->sensor_type
+         *                              sd->do_lcd_stop
+         * Aiptek Pencam VGA+   0x31            0       1
+         * ION digital          0x31            0       1
+         * Argus DC-1620        0x30            1       0
+         * Argus QuickClix      0x30            1       1 (not caught here)
+         */
+        sd->sensor_type = data[0] & 1;
+        sd->do_lcd_stop = (~data[0]) & 1;
+
+
 
-        data[0] = 0x1f;
-        data[1] = 0x04;
-        data[2] = 0x11;
-        data[3] = 0x01;
-        err_code = reg_w(gspca_dev, 4);
+        /* Streaming setup begins here. */
+
+
+        data[0] = 0x01;
+        data[1] = 0x01;
+        err_code = mr_write(gspca_dev, 2);
         if (err_code < 0)
                 return err_code;
 
-        data[0] = 0x1f;
-        data[1] = 0x00;
-        data[2] = 0x12;
-        data[3] = 0x00;
-        data[4] = 0x63;
-        data[5] = 0x00;
-        data[6] = 0x70;
-        data[7] = 0x00;
-        data[8] = 0x00;
-        err_code = reg_w(gspca_dev, 9);
+        /*
+         * A second test can now resolve any remaining ambiguity in the
+         * identification of the camera type,
+         */
+        if (!sd->sensor_type) {
+                data[0] = get_sensor_id(gspca_dev);
+                if (data[0] == 0x7f) {
+                        sd->sensor_type = 1;
+                        PDEBUG(D_PROBE, "sensor_type corrected to 1");
+                }
+                msleep(200);
+        }
+
+        if (force_sensor_type != -1) {
+                sd->sensor_type = !! force_sensor_type;
+                PDEBUG(D_PROBE, "Forcing sensor type to: %d",
+                       sd->sensor_type);
+        }
+
+        /*
+         * Known VGA cameras.
+         * This test is only run if the previous test returned 0x30, but
+         * here is the information for all others, too, just for reference.
+         *
+         * Name                 byte just read          sd->sensor_type
+         *
+         * Aiptek Pencam VGA+   0xfb    (this test not run)     1
+         * ION digital          0xbd    (this test not run)     1
+         * Argus DC-1620        0xe5    (no change)             0
+         * Argus QuickClix      0x7f    (reclassified)          1
+         */
+        memcpy(data, startup_string, 11);
+        if (!sd->sensor_type) {
+                data[5]  = 0x00;
+                data[10] = 0x91;
+        }
+
+        switch (gspca_dev->width) {
+        case 160:
+                data[9] |= 0x0c;  /* reg 8, 4:1 scale down */
+                /* fall thru */
+        case 320:
+                data[9] |= 0x04;  /* reg 8, 2:1 scale down */
+                /* fall thru */
+        case 640:
+        default:
+                data[3] = 0x50;  /* reg 2, H size/8 */
+                data[4] = 0x78;  /* reg 3, V size/4 */
+                data[6] = 0x04;  /* reg 5, H start */
+                data[8] = 0x03;  /* reg 7, V start */
+                if (sd->do_lcd_stop)
+                        data[8] = 0x04;  /* Bayer tile shifted */
+                break;
+
+        case 176:
+                data[9] |= 0x04;  /* reg 8, 2:1 scale down */
+                /* fall thru */
+        case 352:
+                data[3] = 0x2c;  /* reg 2, H size */
+                data[4] = 0x48;  /* reg 3, V size */
+                data[6] = 0x94;  /* reg 5, H start */
+                data[8] = 0x63;  /* reg 7, V start */
+                if (sd->do_lcd_stop)
+                        data[8] = 0x64;  /* Bayer tile shifted */
+                break;
+        }
+
+        err_code = mr_write(gspca_dev, 11);
         if (err_code < 0)
                 return err_code;
 
-        data[0] = 0x1f;
-        data[1] = 0x04;
-        data[2] = 0x11;
-        data[3] = 0x01;
-        err_code = reg_w(gspca_dev, 4);
+        if (!sd->sensor_type) {
+                /* The only known sensor_type 0 cam is the Argus DC-1620 */
+                const struct sensor_w_data vga_sensor0_init_data[] = {
+                        {0x01, 0x00, {0x0c, 0x00, 0x04}, 3},
+                        {0x14, 0x00, {0x01, 0xe4, 0x02, 0x84}, 4},
+                        {0x20, 0x00, {0x00, 0x80, 0x00, 0x08}, 4},
+                        {0x25, 0x00, {0x03, 0xa9, 0x80}, 3},
+                        {0x30, 0x00, {0x30, 0x18, 0x10, 0x18}, 4},
+                        {0, 0, {0}, 0}
+                };
+                err_code = sensor_write_regs(gspca_dev, vga_sensor0_init_data,
+                                         ARRAY_SIZE(vga_sensor0_init_data));
+        } else {        /* sd->sensor_type = 1 */
+                const struct sensor_w_data vga_sensor1_init_data[] = {
+                        {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
+                                0x07, 0x00, 0x01}, 8},
+                        {0x11, 0x04, {0x01}, 1},
+                        /*{0x0a, 0x00, {0x00, 0x01, 0x00, 0x00, 0x01, */
+                        {0x0a, 0x00, {0x01, 0x06, 0x00, 0x00, 0x01,
+                                0x00, 0x0a}, 7},
+                        {0x11, 0x04, {0x01}, 1},
+                        {0x12, 0x00, {0x00, 0x63, 0x00, 0x70, 0x00, 0x00}, 6},
+                        {0x11, 0x04, {0x01}, 1},
+                        {0, 0, {0}, 0}
+                };
+                err_code = sensor_write_regs(gspca_dev, vga_sensor1_init_data,
+                                         ARRAY_SIZE(vga_sensor1_init_data));
+        }
         if (err_code < 0)
                 return err_code;
 
+        msleep(200);
         data[0] = 0x00;
         data[1] = 0x4d;  /* ISOC transfering enable... */
-        err_code = reg_w(gspca_dev, 2);
+        err_code = mr_write(gspca_dev, 2);
+
+        return err_code;
+}
+
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int err_code;
+        struct cam *cam;
+
+        cam = &gspca_dev->cam;
+        sd->sof_read = 0;
+        /*
+         * Some of the supported cameras require the memory pointer to be
+         * set to 0, or else they will not stream.
+         */
+        zero_the_pointer(gspca_dev);
+        msleep(200);
+        if (sd->cam_type == CAM_TYPE_CIF) {
+                err_code = start_cif_cam(gspca_dev);
+        } else {
+                err_code = start_vga_cam(gspca_dev);
+        }
         return err_code;
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
+        struct sd *sd = (struct sd *) gspca_dev;
         int result;
 
         gspca_dev->usb_buf[0] = 1;
         gspca_dev->usb_buf[1] = 0;
-        result = reg_w(gspca_dev, 2);
+        result = mr_write(gspca_dev, 2);
         if (result < 0)
                 PDEBUG(D_ERR, "Camera Stop failed");
+
+        /* Not all the cams need this, but even if not, probably a good idea */
+        zero_the_pointer(gspca_dev);
+        if (sd->do_lcd_stop) {
+                gspca_dev->usb_buf[0] = 0x19;
+                gspca_dev->usb_buf[1] = 0x54;
+                result = mr_write(gspca_dev, 2);
+                if (result < 0)
+                        PDEBUG(D_ERR, "Camera Stop failed");
+        }
+}
+
+static void setbrightness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 val;
+
+        if (gspca_dev->ctrl_dis & (1 << BRIGHTNESS_IDX))
+                return;
+
+        /* Note register 7 is also seen as 0x8x or 0xCx in dumps */
+        if (sd->brightness > 0) {
+                sensor_write1(gspca_dev, 7, 0x00);
+                val = sd->brightness;
+        } else {
+                sensor_write1(gspca_dev, 7, 0x01);
+                val = 257 - sd->brightness;
+        }
+        sensor_write1(gspca_dev, 8, val);
+}
+
+static void setexposure(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 val;
+
+        if (gspca_dev->ctrl_dis & (1 << EXPOSURE_IDX))
+                return;
+
+        if (sd->sensor_type) {
+                val = sd->exposure >> 4;
+                sensor_write1(gspca_dev, 3, val);
+                val = sd->exposure & 0xf;
+                sensor_write1(gspca_dev, 4, val);
+        } else {
+                u8 clockdiv;
+                int exposure;
+
+                /* We have both a clock divider and an exposure register.
+                   We first calculate the clock divider, as that determines
+                   the maximum exposure and then we calculayte the exposure
+                   register setting (which goes from 0 - 511).
+
+                   Note our 0 - 4095 exposure is mapped to 0 - 511
+                   milliseconds exposure time */
+                clockdiv = (60 * sd->exposure + 7999) / 8000;
+
+                /* Limit framerate to not exceed usb bandwidth */
+                if (clockdiv < 3 && gspca_dev->width >= 320)
+                        clockdiv = 3;
+                else if (clockdiv < 2)
+                        clockdiv = 2;
+
+                /* Frame exposure time in ms = 1000 * clockdiv / 60 ->
+                exposure = (sd->exposure / 8) * 511 / (1000 * clockdiv / 60) */
+                exposure = (60 * 511 * sd->exposure) / (8000 * clockdiv);
+                if (exposure > 511)
+                        exposure = 511;
+
+                /* exposure register value is reversed! */
+                exposure = 511 - exposure;
+
+                sensor_write1(gspca_dev, 0x02, clockdiv);
+                sensor_write1(gspca_dev, 0x0e, exposure & 0xff);
+                sensor_write1(gspca_dev, 0x0f, exposure >> 8);
+        }
+}
+
+static void setgain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (gspca_dev->ctrl_dis & (1 << GAIN_IDX))
+                return;
+
+        if (sd->sensor_type) {
+                sensor_write1(gspca_dev, 0x0e, sd->gain);
+        } else {
+                sensor_write1(gspca_dev, 0x10, sd->gain);
+        }
+}
+
+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_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_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;
 }
 
 /* Include pac common sof detection functions */
@@ -320,8 +938,9 @@ static const struct sd_desc sd_desc = {
 
 /* -- module initialisation -- */
 static const __devinitdata struct usb_device_id device_table[] = {
-        {USB_DEVICE(0x08ca, 0x0111)},
-        {USB_DEVICE(0x093a, 0x010f)},
+        {USB_DEVICE(0x08ca, 0x0111)},   /* Aiptek Pencam VGA+ */
+        {USB_DEVICE(0x093a, 0x010f)},   /* All other known MR97310A VGA cams */
+        {USB_DEVICE(0x093a, 0x010e)},   /* All known MR97310A CIF cams */
         {}
 };
 MODULE_DEVICE_TABLE(usb, device_table);
diff --git a/drivers/media/video/gspca/pac207.c b/drivers/media/video/gspca/pac207.c
index 95a97ab684cd..96659433d248 100644
--- a/drivers/media/video/gspca/pac207.c
+++ b/drivers/media/video/gspca/pac207.c
@@ -35,25 +35,17 @@ MODULE_LICENSE("GPL");
 
 #define PAC207_BRIGHTNESS_MIN           0
 #define PAC207_BRIGHTNESS_MAX           255
-#define PAC207_BRIGHTNESS_DEFAULT       4 /* power on default: 4 */
-
-/* An exposure value of 4 also works (3 does not) but then we need to lower
-   the compression balance setting when in 352x288 mode, otherwise the usb
-   bandwidth is not enough and packets get dropped resulting in corrupt
-   frames. The problem with this is that when the compression balance gets
-   lowered below 0x80, the pac207 starts using a different compression
-   algorithm for some lines, these lines get prefixed with a 0x2dd2 prefix
-   and currently we do not know how to decompress these lines, so for now
-   we use a minimum exposure value of 5 */
-#define PAC207_EXPOSURE_MIN             5
+#define PAC207_BRIGHTNESS_DEFAULT       46
+
+#define PAC207_EXPOSURE_MIN             3
 #define PAC207_EXPOSURE_MAX             26
-#define PAC207_EXPOSURE_DEFAULT         5 /* power on default: 3 ?? */
-#define PAC207_EXPOSURE_KNEE            11 /* 4 = 30 fps, 11 = 8, 15 = 6 */
+#define PAC207_EXPOSURE_DEFAULT         5 /* power on default: 3 */
+#define PAC207_EXPOSURE_KNEE            8 /* 4 = 30 fps, 11 = 8, 15 = 6 */
 
 #define PAC207_GAIN_MIN                 0
 #define PAC207_GAIN_MAX                 31
 #define PAC207_GAIN_DEFAULT             9 /* power on default: 9 */
-#define PAC207_GAIN_KNEE                20
+#define PAC207_GAIN_KNEE                31
 
 #define PAC207_AUTOGAIN_DEADZONE        30
 
@@ -166,16 +158,12 @@ static const struct v4l2_pix_format sif_mode[] = {
 };
 
 static const __u8 pac207_sensor_init[][8] = {
-        {0x10, 0x12, 0x0d, 0x12, 0x0c, 0x01, 0x29, 0xf0},
-        {0x00, 0x64, 0x64, 0x64, 0x04, 0x10, 0xf0, 0x30},
+        {0x10, 0x12, 0x0d, 0x12, 0x0c, 0x01, 0x29, 0x84},
+        {0x49, 0x64, 0x64, 0x64, 0x04, 0x10, 0xf0, 0x30},
         {0x00, 0x00, 0x00, 0x70, 0xa0, 0xf8, 0x00, 0x00},
-        {0x00, 0x00, 0x32, 0x00, 0x96, 0x00, 0xa2, 0x02},
         {0x32, 0x00, 0x96, 0x00, 0xA2, 0x02, 0xaf, 0x00},
 };
 
-                        /* 48 reg_72 Rate Control end BalSize_4a =0x36 */
-static const __u8 PacReg72[] = { 0x00, 0x00, 0x36, 0x00 };
-
 static int pac207_write_regs(struct gspca_dev *gspca_dev, u16 index,
         const u8 *buffer, u16 length)
 {
@@ -274,7 +262,6 @@ static int sd_init(struct gspca_dev *gspca_dev)
                                  * Bit_1=LED,
                                  * Bit_2=Compression test mode enable */
         pac207_write_reg(gspca_dev, 0x0f, 0x00); /* Power Control */
-        pac207_write_reg(gspca_dev, 0x11, 0x30); /* Analog Bias */
 
         return 0;
 }
@@ -289,15 +276,13 @@ static int sd_start(struct gspca_dev *gspca_dev)
         pac207_write_regs(gspca_dev, 0x0002, pac207_sensor_init[0], 8);
         pac207_write_regs(gspca_dev, 0x000a, pac207_sensor_init[1], 8);
         pac207_write_regs(gspca_dev, 0x0012, pac207_sensor_init[2], 8);
-        pac207_write_regs(gspca_dev, 0x0040, pac207_sensor_init[3], 8);
-        pac207_write_regs(gspca_dev, 0x0042, pac207_sensor_init[4], 8);
-        pac207_write_regs(gspca_dev, 0x0048, PacReg72, 4);
+        pac207_write_regs(gspca_dev, 0x0042, pac207_sensor_init[3], 8);
 
         /* Compression Balance */
         if (gspca_dev->width == 176)
                 pac207_write_reg(gspca_dev, 0x4a, 0xff);
         else
-                pac207_write_reg(gspca_dev, 0x4a, 0x88);
+                pac207_write_reg(gspca_dev, 0x4a, 0x30);
         pac207_write_reg(gspca_dev, 0x4b, 0x00); /* Sram test value */
         pac207_write_reg(gspca_dev, 0x08, sd->brightness);
 
@@ -346,7 +331,7 @@ static void pac207_do_auto_gain(struct gspca_dev *gspca_dev)
         if (sd->autogain_ignore_frames > 0)
                 sd->autogain_ignore_frames--;
         else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
-                        100 + sd->brightness / 2, PAC207_AUTOGAIN_DEADZONE,
+                        100, PAC207_AUTOGAIN_DEADZONE,
                         PAC207_GAIN_KNEE, PAC207_EXPOSURE_KNEE))
                 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
 }
diff --git a/drivers/media/video/gspca/pac7311.c b/drivers/media/video/gspca/pac7311.c
index e1e3a3a50484..052714484e83 100644
--- a/drivers/media/video/gspca/pac7311.c
+++ b/drivers/media/video/gspca/pac7311.c
@@ -1057,6 +1057,7 @@ static struct sd_desc sd_desc = {
 
 /* -- module initialisation -- */
 static __devinitdata struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x06f8, 0x3009), .driver_info = SENSOR_PAC7302},
         {USB_DEVICE(0x093a, 0x2600), .driver_info = SENSOR_PAC7311},
         {USB_DEVICE(0x093a, 0x2601), .driver_info = SENSOR_PAC7311},
         {USB_DEVICE(0x093a, 0x2603), .driver_info = SENSOR_PAC7311},
@@ -1068,6 +1069,7 @@ static __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x093a, 0x2622), .driver_info = SENSOR_PAC7302},
         {USB_DEVICE(0x093a, 0x2624), .driver_info = SENSOR_PAC7302},
         {USB_DEVICE(0x093a, 0x2626), .driver_info = SENSOR_PAC7302},
+        {USB_DEVICE(0x093a, 0x2629), .driver_info = SENSOR_PAC7302},
         {USB_DEVICE(0x093a, 0x262a), .driver_info = SENSOR_PAC7302},
         {USB_DEVICE(0x093a, 0x262c), .driver_info = SENSOR_PAC7302},
         {}
diff --git a/drivers/media/video/gspca/sn9c20x.c b/drivers/media/video/gspca/sn9c20x.c
index fcfbbd329b4c..cdad3db33367 100644
--- a/drivers/media/video/gspca/sn9c20x.c
+++ b/drivers/media/video/gspca/sn9c20x.c
@@ -94,6 +94,16 @@ struct sd {
 #endif
 };
 
+struct i2c_reg_u8 {
+        u8 reg;
+        u8 val;
+};
+
+struct i2c_reg_u16 {
+        u8 reg;
+        u16 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);
@@ -403,7 +413,7 @@ static const struct v4l2_pix_format sxga_mode[] = {
                 .priv = 3 | MODE_RAW | MODE_SXGA},
 };
 
-static const int hsv_red_x[] = {
+static const s16 hsv_red_x[] = {
         41,  44,  46,  48,  50,  52,  54,  56,
         58,  60,  62,  64,  66,  68,  70,  72,
         74,  76,  78,  80,  81,  83,  85,  87,
@@ -451,7 +461,7 @@ static const int hsv_red_x[] = {
         24,  26,  28,  30,  33,  35,  37,  39, 41
 };
 
-static const int hsv_red_y[] = {
+static const s16 hsv_red_y[] = {
         82,  80,  78,  76,  74,  73,  71,  69,
         67,  65,  63,  61,  58,  56,  54,  52,
         50,  48,  46,  44,  41,  39,  37,  35,
@@ -499,7 +509,7 @@ static const int hsv_red_y[] = {
         96, 94, 92, 91, 89, 87, 85, 84, 82
 };
 
-static const int hsv_green_x[] = {
+static const s16 hsv_green_x[] = {
         -124, -124, -125, -125, -125, -125, -125, -125,
         -125, -126, -126, -125, -125, -125, -125, -125,
         -125, -124, -124, -124, -123, -123, -122, -122,
@@ -547,7 +557,7 @@ static const int hsv_green_x[] = {
         -120, -120, -121, -122, -122, -123, -123, -124, -124
 };
 
-static const int hsv_green_y[] = {
+static const s16 hsv_green_y[] = {
         -100, -99, -98, -97, -95, -94, -93, -91,
         -90, -89, -87, -86, -84, -83, -81, -80,
         -78, -76, -75, -73, -71, -70, -68, -66,
@@ -595,7 +605,7 @@ static const int hsv_green_y[] = {
         -109, -108, -107, -106, -105, -104, -103, -102, -100
 };
 
-static const int hsv_blue_x[] = {
+static const s16 hsv_blue_x[] = {
         112, 113, 114, 114, 115, 116, 117, 117,
         118, 118, 119, 119, 120, 120, 120, 121,
         121, 121, 122, 122, 122, 122, 122, 122,
@@ -643,7 +653,7 @@ static const int hsv_blue_x[] = {
         104, 105, 106, 107, 108, 109, 110, 111, 112
 };
 
-static const int hsv_blue_y[] = {
+static const s16 hsv_blue_y[] = {
         -11, -13, -15, -17, -19, -21, -23, -25,
         -27, -29, -31, -33, -35, -37, -39, -41,
         -43, -45, -46, -48, -50, -52, -54, -55,
@@ -792,21 +802,21 @@ static u8 hv7131r_gain[] = {
         0x78 /* 8x */
 };
 
-static u8 soi968_init[][2] = {
+static struct i2c_reg_u8 soi968_init[] = {
         {0x12, 0x80}, {0x0c, 0x00}, {0x0f, 0x1f},
         {0x11, 0x80}, {0x38, 0x52}, {0x1e, 0x00},
         {0x33, 0x08}, {0x35, 0x8c}, {0x36, 0x0c},
         {0x37, 0x04}, {0x45, 0x04}, {0x47, 0xff},
         {0x3e, 0x00}, {0x3f, 0x00}, {0x3b, 0x20},
         {0x3a, 0x96}, {0x3d, 0x0a}, {0x14, 0x8e},
-        {0x13, 0x8a}, {0x12, 0x40}, {0x17, 0x13},
+        {0x13, 0x8b}, {0x12, 0x40}, {0x17, 0x13},
         {0x18, 0x63}, {0x19, 0x01}, {0x1a, 0x79},
         {0x32, 0x24}, {0x03, 0x00}, {0x11, 0x40},
         {0x2a, 0x10}, {0x2b, 0xe0}, {0x10, 0x32},
         {0x00, 0x00}, {0x01, 0x80}, {0x02, 0x80},
 };
 
-static u8 ov7660_init[][2] = {
+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},
@@ -815,7 +825,7 @@ static u8 ov7660_init[][2] = {
         {0x2e, 0x0b}, {0x01, 0x78}, {0x02, 0x50},
 };
 
-static u8 ov7670_init[][2] = {
+static struct i2c_reg_u8 ov7670_init[] = {
         {0x12, 0x80}, {0x11, 0x80}, {0x3a, 0x04}, {0x12, 0x01},
         {0x32, 0xb6}, {0x03, 0x0a}, {0x0c, 0x00}, {0x3e, 0x00},
         {0x70, 0x3a}, {0x71, 0x35}, {0x72, 0x11}, {0x73, 0xf0},
@@ -872,7 +882,7 @@ static u8 ov7670_init[][2] = {
         {0x93, 0x00},
 };
 
-static u8 ov9650_init[][2] = {
+static struct i2c_reg_u8 ov9650_init[] = {
         {0x12, 0x80}, {0x00, 0x00}, {0x01, 0x78},
         {0x02, 0x78}, {0x03, 0x36}, {0x04, 0x03},
         {0x05, 0x00}, {0x06, 0x00}, {0x08, 0x00},
@@ -902,7 +912,7 @@ static u8 ov9650_init[][2] = {
         {0xaa, 0x92}, {0xab, 0x0a},
 };
 
-static u8 ov9655_init[][2] = {
+static struct i2c_reg_u8 ov9655_init[] = {
         {0x12, 0x80}, {0x12, 0x01}, {0x0d, 0x00}, {0x0e, 0x61},
         {0x11, 0x80}, {0x13, 0xba}, {0x14, 0x2e}, {0x16, 0x24},
         {0x1e, 0x04}, {0x1e, 0x04}, {0x1e, 0x04}, {0x27, 0x08},
@@ -939,7 +949,7 @@ static u8 ov9655_init[][2] = {
         {0x00, 0x03}, {0x00, 0x0a}, {0x00, 0x10}, {0x00, 0x13},
 };
 
-static u16 mt9v112_init[][2] = {
+static struct i2c_reg_u16 mt9v112_init[] = {
         {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0020},
         {0x34, 0xc019}, {0x0a, 0x0011}, {0x0b, 0x000b},
         {0x20, 0x0703}, {0x35, 0x2022}, {0xf0, 0x0001},
@@ -958,7 +968,7 @@ static u16 mt9v112_init[][2] = {
         {0x2c, 0x00ae}, {0x2d, 0x00ae}, {0x2e, 0x00ae},
 };
 
-static u16 mt9v111_init[][2] = {
+static struct i2c_reg_u16 mt9v111_init[] = {
         {0x01, 0x0004}, {0x0d, 0x0001}, {0x0d, 0x0000},
         {0x01, 0x0001}, {0x02, 0x0016}, {0x03, 0x01e1},
         {0x04, 0x0281}, {0x05, 0x0004}, {0x07, 0x3002},
@@ -985,7 +995,7 @@ static u16 mt9v111_init[][2] = {
         {0x0e, 0x0008}, {0x06, 0x002d}, {0x05, 0x0004},
 };
 
-static u16 mt9v011_init[][2] = {
+static struct i2c_reg_u16 mt9v011_init[] = {
         {0x07, 0x0002}, {0x0d, 0x0001}, {0x0d, 0x0000},
         {0x01, 0x0008}, {0x02, 0x0016}, {0x03, 0x01e1},
         {0x04, 0x0281}, {0x05, 0x0083}, {0x06, 0x0006},
@@ -1012,7 +1022,7 @@ static u16 mt9v011_init[][2] = {
         {0x06, 0x0029}, {0x05, 0x0009},
 };
 
-static u16 mt9m001_init[][2] = {
+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},
@@ -1025,14 +1035,14 @@ static u16 mt9m001_init[][2] = {
         {0x2e, 0x0029}, {0x07, 0x0002},
 };
 
-static u16 mt9m111_init[][2] = {
-        {0xf0, 0x0000}, {0x0d, 0x0008}, {0x0d, 0x0009},
-        {0x0d, 0x0008}, {0xf0, 0x0001}, {0x3a, 0x4300},
-        {0x9b, 0x4300}, {0xa1, 0x0280}, {0xa4, 0x0200},
-        {0x06, 0x308e}, {0xf0, 0x0000},
+static struct i2c_reg_u16 mt9m111_init[] = {
+        {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0008},
+        {0xf0, 0x0001}, {0x3a, 0x4300}, {0x9b, 0x4300},
+        {0x06, 0x708e}, {0xf0, 0x0002}, {0x2e, 0x0a1e},
+        {0xf0, 0x0000},
 };
 
-static u8 hv7131r_init[][2] = {
+static struct i2c_reg_u8 hv7131r_init[] = {
         {0x02, 0x08}, {0x02, 0x00}, {0x01, 0x08},
         {0x02, 0x00}, {0x20, 0x00}, {0x21, 0xd0},
         {0x22, 0x00}, {0x23, 0x09}, {0x01, 0x08},
@@ -1043,7 +1053,7 @@ static u8 hv7131r_init[][2] = {
         {0x23, 0x09}, {0x01, 0x08},
 };
 
-int reg_r(struct gspca_dev *gspca_dev, u16 reg, u16 length)
+static int reg_r(struct gspca_dev *gspca_dev, u16 reg, u16 length)
 {
         struct usb_device *dev = gspca_dev->dev;
         int result;
@@ -1062,7 +1072,8 @@ int reg_r(struct gspca_dev *gspca_dev, u16 reg, u16 length)
         return 0;
 }
 
-int reg_w(struct gspca_dev *gspca_dev, u16 reg, const u8 *buffer, int length)
+static int reg_w(struct gspca_dev *gspca_dev, u16 reg,
+                 const u8 *buffer, int length)
 {
         struct usb_device *dev = gspca_dev->dev;
         int result;
@@ -1082,13 +1093,13 @@ int reg_w(struct gspca_dev *gspca_dev, u16 reg, const u8 *buffer, int length)
         return 0;
 }
 
-int reg_w1(struct gspca_dev *gspca_dev, u16 reg, const u8 value)
+static int reg_w1(struct gspca_dev *gspca_dev, u16 reg, const u8 value)
 {
         u8 data[1] = {value};
         return reg_w(gspca_dev, reg, data, 1);
 }
 
-int i2c_w(struct gspca_dev *gspca_dev, const u8 *buffer)
+static int i2c_w(struct gspca_dev *gspca_dev, const u8 *buffer)
 {
         int i;
         reg_w(gspca_dev, 0x10c0, buffer, 8);
@@ -1096,15 +1107,15 @@ int i2c_w(struct gspca_dev *gspca_dev, const u8 *buffer)
                 reg_r(gspca_dev, 0x10c0, 1);
                 if (gspca_dev->usb_buf[0] & 0x04) {
                         if (gspca_dev->usb_buf[0] & 0x08)
-                                return -1;
+                                return -EIO;
                         return 0;
                 }
                 msleep(1);
         }
-        return -1;
+        return -EIO;
 }
 
-int i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
+static int i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
@@ -1126,7 +1137,7 @@ int i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
         return i2c_w(gspca_dev, row);
 }
 
-int i2c_w2(struct gspca_dev *gspca_dev, u8 reg, u16 val)
+static int i2c_w2(struct gspca_dev *gspca_dev, u8 reg, u16 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         u8 row[8];
@@ -1152,7 +1163,7 @@ int i2c_r1(struct gspca_dev *gspca_dev, u8 reg, u8 *val)
         struct sd *sd = (struct sd *) gspca_dev;
         u8 row[8];
 
-        row[0] = 0x81 | 0x10;
+        row[0] = 0x81 | (1 << 4);
         row[1] = sd->i2c_addr;
         row[2] = reg;
         row[3] = 0;
@@ -1160,14 +1171,15 @@ int i2c_r1(struct gspca_dev *gspca_dev, u8 reg, u8 *val)
         row[5] = 0;
         row[6] = 0;
         row[7] = 0x10;
-        reg_w(gspca_dev, 0x10c0, row, 8);
-        msleep(1);
-        row[0] = 0x81 | (2 << 4) | 0x02;
+        if (i2c_w(gspca_dev, row) < 0)
+                return -EIO;
+        row[0] = 0x81 | (1 << 4) | 0x02;
         row[2] = 0;
-        reg_w(gspca_dev, 0x10c0, row, 8);
-        msleep(1);
-        reg_r(gspca_dev, 0x10c2, 5);
-        *val = gspca_dev->usb_buf[3];
+        if (i2c_w(gspca_dev, row) < 0)
+                return -EIO;
+        if (reg_r(gspca_dev, 0x10c2, 5) < 0)
+                return -EIO;
+        *val = gspca_dev->usb_buf[4];
         return 0;
 }
 
@@ -1176,7 +1188,7 @@ int i2c_r2(struct gspca_dev *gspca_dev, u8 reg, u16 *val)
         struct sd *sd = (struct sd *) gspca_dev;
         u8 row[8];
 
-        row[0] = 0x81 | 0x10;
+        row[0] = 0x81 | (1 << 4);
         row[1] = sd->i2c_addr;
         row[2] = reg;
         row[3] = 0;
@@ -1184,14 +1196,15 @@ int i2c_r2(struct gspca_dev *gspca_dev, u8 reg, u16 *val)
         row[5] = 0;
         row[6] = 0;
         row[7] = 0x10;
-        reg_w(gspca_dev, 0x10c0, row, 8);
-        msleep(1);
-        row[0] = 0x81 | (3 << 4) | 0x02;
+        if (i2c_w(gspca_dev, row) < 0)
+                return -EIO;
+        row[0] = 0x81 | (2 << 4) | 0x02;
         row[2] = 0;
-        reg_w(gspca_dev, 0x10c0, row, 8);
-        msleep(1);
-        reg_r(gspca_dev, 0x10c2, 5);
-        *val = (gspca_dev->usb_buf[2] << 8) | gspca_dev->usb_buf[3];
+        if (i2c_w(gspca_dev, row) < 0)
+                return -EIO;
+        if (reg_r(gspca_dev, 0x10c2, 5) < 0)
+                return -EIO;
+        *val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
         return 0;
 }
 
@@ -1201,8 +1214,8 @@ static int ov9650_init_sensor(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
 
         for (i = 0; i < ARRAY_SIZE(ov9650_init); i++) {
-                if (i2c_w1(gspca_dev, ov9650_init[i][0],
-                                ov9650_init[i][1]) < 0) {
+                if (i2c_w1(gspca_dev, ov9650_init[i].reg,
+                                ov9650_init[i].val) < 0) {
                         err("OV9650 sensor initialization failed");
                         return -ENODEV;
                 }
@@ -1218,8 +1231,8 @@ static int ov9655_init_sensor(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
 
         for (i = 0; i < ARRAY_SIZE(ov9655_init); i++) {
-                if (i2c_w1(gspca_dev, ov9655_init[i][0],
-                                ov9655_init[i][1]) < 0) {
+                if (i2c_w1(gspca_dev, ov9655_init[i].reg,
+                                ov9655_init[i].val) < 0) {
                         err("OV9655 sensor initialization failed");
                         return -ENODEV;
                 }
@@ -1237,14 +1250,14 @@ static int soi968_init_sensor(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
 
         for (i = 0; i < ARRAY_SIZE(soi968_init); i++) {
-                if (i2c_w1(gspca_dev, soi968_init[i][0],
-                                soi968_init[i][1]) < 0) {
+                if (i2c_w1(gspca_dev, soi968_init[i].reg,
+                                soi968_init[i].val) < 0) {
                         err("SOI968 sensor initialization failed");
                         return -ENODEV;
                 }
         }
         /* disable hflip and vflip */
-        gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX);
+        gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << EXPOSURE_IDX);
         sd->hstart = 60;
         sd->vstart = 11;
         return 0;
@@ -1256,8 +1269,8 @@ static int ov7660_init_sensor(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
 
         for (i = 0; i < ARRAY_SIZE(ov7660_init); i++) {
-                if (i2c_w1(gspca_dev, ov7660_init[i][0],
-                                ov7660_init[i][1]) < 0) {
+                if (i2c_w1(gspca_dev, ov7660_init[i].reg,
+                                ov7660_init[i].val) < 0) {
                         err("OV7660 sensor initialization failed");
                         return -ENODEV;
                 }
@@ -1275,8 +1288,8 @@ static int ov7670_init_sensor(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
 
         for (i = 0; i < ARRAY_SIZE(ov7670_init); i++) {
-                if (i2c_w1(gspca_dev, ov7670_init[i][0],
-                                ov7670_init[i][1]) < 0) {
+                if (i2c_w1(gspca_dev, ov7670_init[i].reg,
+                                ov7670_init[i].val) < 0) {
                         err("OV7670 sensor initialization failed");
                         return -ENODEV;
                 }
@@ -1299,8 +1312,8 @@ static int mt9v_init_sensor(struct gspca_dev *gspca_dev)
         ret = i2c_r2(gspca_dev, 0xff, &value);
         if ((ret == 0) && (value == 0x8243)) {
                 for (i = 0; i < ARRAY_SIZE(mt9v011_init); i++) {
-                        if (i2c_w2(gspca_dev, mt9v011_init[i][0],
-                                        mt9v011_init[i][1]) < 0) {
+                        if (i2c_w2(gspca_dev, mt9v011_init[i].reg,
+                                        mt9v011_init[i].val) < 0) {
                                 err("MT9V011 sensor initialization failed");
                                 return -ENODEV;
                         }
@@ -1317,8 +1330,8 @@ static int mt9v_init_sensor(struct gspca_dev *gspca_dev)
         ret = i2c_r2(gspca_dev, 0xff, &value);
         if ((ret == 0) && (value == 0x823a)) {
                 for (i = 0; i < ARRAY_SIZE(mt9v111_init); i++) {
-                        if (i2c_w2(gspca_dev, mt9v111_init[i][0],
-                                        mt9v111_init[i][1]) < 0) {
+                        if (i2c_w2(gspca_dev, mt9v111_init[i].reg,
+                                        mt9v111_init[i].val) < 0) {
                                 err("MT9V111 sensor initialization failed");
                                 return -ENODEV;
                         }
@@ -1339,8 +1352,8 @@ static int mt9v_init_sensor(struct gspca_dev *gspca_dev)
         ret = i2c_r2(gspca_dev, 0x00, &value);
         if ((ret == 0) && (value == 0x1229)) {
                 for (i = 0; i < ARRAY_SIZE(mt9v112_init); i++) {
-                        if (i2c_w2(gspca_dev, mt9v112_init[i][0],
-                                        mt9v112_init[i][1]) < 0) {
+                        if (i2c_w2(gspca_dev, mt9v112_init[i].reg,
+                                        mt9v112_init[i].val) < 0) {
                                 err("MT9V112 sensor initialization failed");
                                 return -ENODEV;
                         }
@@ -1360,12 +1373,13 @@ static int mt9m111_init_sensor(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         int i;
         for (i = 0; i < ARRAY_SIZE(mt9m111_init); i++) {
-                if (i2c_w2(gspca_dev, mt9m111_init[i][0],
-                                mt9m111_init[i][1]) < 0) {
+                if (i2c_w2(gspca_dev, mt9m111_init[i].reg,
+                                mt9m111_init[i].val) < 0) {
                         err("MT9M111 sensor initialization failed");
                         return -ENODEV;
                 }
         }
+        gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX) | (1 << GAIN_IDX);
         sd->hstart = 0;
         sd->vstart = 2;
         return 0;
@@ -1376,8 +1390,8 @@ static int mt9m001_init_sensor(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         int i;
         for (i = 0; i < ARRAY_SIZE(mt9m001_init); i++) {
-                if (i2c_w2(gspca_dev, mt9m001_init[i][0],
-                                mt9m001_init[i][1]) < 0) {
+                if (i2c_w2(gspca_dev, mt9m001_init[i].reg,
+                                mt9m001_init[i].val) < 0) {
                         err("MT9M001 sensor initialization failed");
                         return -ENODEV;
                 }
@@ -1395,8 +1409,8 @@ static int hv7131r_init_sensor(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
 
         for (i = 0; i < ARRAY_SIZE(hv7131r_init); i++) {
-                if (i2c_w1(gspca_dev, hv7131r_init[i][0],
-                                hv7131r_init[i][1]) < 0) {
+                if (i2c_w1(gspca_dev, hv7131r_init[i].reg,
+                                hv7131r_init[i].val) < 0) {
                         err("HV7131R Sensor initialization failed");
                         return -ENODEV;
                 }
@@ -1620,7 +1634,6 @@ static int set_exposure(struct gspca_dev *gspca_dev)
         switch (sd->sensor) {
         case SENSOR_OV7660:
         case SENSOR_OV7670:
-        case SENSOR_SOI968:
         case SENSOR_OV9655:
         case SENSOR_OV9650:
                 exp[0] |= (3 << 4);
@@ -1629,7 +1642,6 @@ static int set_exposure(struct gspca_dev *gspca_dev)
                 exp[4] = sd->exposure >> 8;
                 break;
         case SENSOR_MT9M001:
-        case SENSOR_MT9M111:
         case SENSOR_MT9V112:
         case SENSOR_MT9V111:
         case SENSOR_MT9V011:
@@ -1645,6 +1657,8 @@ static int set_exposure(struct gspca_dev *gspca_dev)
                 exp[4] = ((sd->exposure * 0xffffff) / 0xffff) >> 8;
                 exp[5] = ((sd->exposure * 0xffffff) / 0xffff) & 0xff;
                 break;
+        default:
+                return 0;
         }
         i2c_w(gspca_dev, exp);
         return 0;
@@ -1671,7 +1685,6 @@ static int set_gain(struct gspca_dev *gspca_dev)
                 gain[4] = micron1_gain[sd->gain] & 0xff;
                 break;
         case SENSOR_MT9V112:
-        case SENSOR_MT9M111:
                 gain[0] |= (3 << 4);
                 gain[2] = 0x2f;
                 gain[3] = micron1_gain[sd->gain] >> 8;
@@ -1688,6 +1701,8 @@ static int set_gain(struct gspca_dev *gspca_dev)
                 gain[2] = 0x30;
                 gain[3] = hv7131r_gain[sd->gain];
                 break;
+        default:
+                return 0;
         }
         i2c_w(gspca_dev, gain);
         return 0;
@@ -1990,7 +2005,9 @@ static int sd_config(struct gspca_dev *gspca_dev,
         sd->i2c_addr = id->driver_info & 0xff;
 
         switch (sd->sensor) {
+        case SENSOR_MT9M111:
         case SENSOR_OV9650:
+        case SENSOR_SOI968:
                 cam->cam_mode = sxga_mode;
                 cam->nmodes = ARRAY_SIZE(sxga_mode);
                 break;
@@ -2106,6 +2123,25 @@ static void configure_sensor_output(struct gspca_dev *gspca_dev, int mode)
         struct sd *sd = (struct sd *) gspca_dev;
         u8 value;
         switch (sd->sensor) {
+        case SENSOR_SOI968:
+                if (mode & MODE_SXGA) {
+                        i2c_w1(gspca_dev, 0x17, 0x1d);
+                        i2c_w1(gspca_dev, 0x18, 0xbd);
+                        i2c_w1(gspca_dev, 0x19, 0x01);
+                        i2c_w1(gspca_dev, 0x1a, 0x81);
+                        i2c_w1(gspca_dev, 0x12, 0x00);
+                        sd->hstart = 140;
+                        sd->vstart = 19;
+                } else {
+                        i2c_w1(gspca_dev, 0x17, 0x13);
+                        i2c_w1(gspca_dev, 0x18, 0x63);
+                        i2c_w1(gspca_dev, 0x19, 0x01);
+                        i2c_w1(gspca_dev, 0x1a, 0x79);
+                        i2c_w1(gspca_dev, 0x12, 0x40);
+                        sd->hstart = 60;
+                        sd->vstart = 11;
+                }
+                break;
         case SENSOR_OV9650:
                 if (mode & MODE_SXGA) {
                         i2c_w1(gspca_dev, 0x17, 0x1b);
@@ -2123,6 +2159,17 @@ static void configure_sensor_output(struct gspca_dev *gspca_dev, int mode)
                         i2c_w1(gspca_dev, 0x12, (value & 0x7) | 0x40);
                 }
                 break;
+        case SENSOR_MT9M111:
+                if (mode & MODE_SXGA) {
+                        i2c_w2(gspca_dev, 0xf0, 0x0002);
+                        i2c_w2(gspca_dev, 0xc8, 0x970b);
+                        i2c_w2(gspca_dev, 0xf0, 0x0000);
+                } else {
+                        i2c_w2(gspca_dev, 0xf0, 0x0002);
+                        i2c_w2(gspca_dev, 0xc8, 0x8000);
+                        i2c_w2(gspca_dev, 0xf0, 0x0000);
+                }
+                break;
         }
 }
 
@@ -2211,15 +2258,10 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
         kfree(sd->jpeg_hdr);
 }
 
-static void do_autoexposure(struct gspca_dev *gspca_dev)
+static void do_autoexposure(struct gspca_dev *gspca_dev, u16 avg_lum)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int avg_lum, new_exp;
-
-        if (!sd->auto_exposure)
-                return;
-
-        avg_lum = atomic_read(&sd->avg_lum);
+        s16 new_exp;
 
         /*
          * some hardcoded values are present
@@ -2266,6 +2308,39 @@ static void do_autoexposure(struct gspca_dev *gspca_dev)
         }
 }
 
+static void do_autogain(struct gspca_dev *gspca_dev, u16 avg_lum)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (avg_lum < MIN_AVG_LUM) {
+                if (sd->gain + 1 <= 28) {
+                        sd->gain++;
+                        set_gain(gspca_dev);
+                }
+        }
+        if (avg_lum > MAX_AVG_LUM) {
+                if (sd->gain - 1 >= 0) {
+                        sd->gain--;
+                        set_gain(gspca_dev);
+                }
+        }
+}
+
+static void sd_dqcallback(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int avg_lum;
+
+        if (!sd->auto_exposure)
+                return;
+
+        avg_lum = atomic_read(&sd->avg_lum);
+        if (sd->sensor == SENSOR_SOI968)
+                do_autogain(gspca_dev, avg_lum);
+        else
+                do_autoexposure(gspca_dev, avg_lum);
+}
+
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                         struct gspca_frame *frame,      /* target */
                         u8 *data,                       /* isoc packet */
@@ -2333,7 +2408,7 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .stop0 = sd_stop0,
         .pkt_scan = sd_pkt_scan,
-        .dq_callback = do_autoexposure,
+        .dq_callback = sd_dqcallback,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
         .set_register = sd_dbg_s_register,
         .get_register = sd_dbg_g_register,
diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c
index d6332ab80669..33f4d0a1f6fd 100644
--- a/drivers/media/video/gspca/sonixj.c
+++ b/drivers/media/video/gspca/sonixj.c
@@ -727,7 +727,7 @@ static const u8 ov7660_sensor_init[][8] = {
         {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
                                                 /* Outformat = rawRGB */
         {0xa1, 0x21, 0x13, 0xb8, 0x00, 0x00, 0x00, 0x10}, /* init COM8 */
-        {0xd1, 0x21, 0x00, 0x01, 0x74, 0x74, 0x00, 0x10},
+        {0xd1, 0x21, 0x00, 0x01, 0x74, 0x92, 0x00, 0x10},
                                                 /* GAIN BLUE RED VREF */
         {0xd1, 0x21, 0x04, 0x00, 0x7d, 0x62, 0x00, 0x10},
                                                 /* COM 1 BAVE GEAVE AECHH */
@@ -783,7 +783,7 @@ static const u8 ov7660_sensor_init[][8] = {
         {0xc1, 0x21, 0x88, 0xaf, 0xc7, 0xdf, 0x00, 0x10}, /* gamma curve */
         {0xc1, 0x21, 0x8b, 0x99, 0x99, 0xcf, 0x00, 0x10}, /* reserved */
         {0xb1, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x10}, /* DM_LNL/H */
-        {0xb1, 0x21, 0xa1, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xa1, 0x21, 0xa1, 0x00, 0x00, 0x00, 0x00, 0x10},
 /****** (some exchanges in the win trace) ******/
         {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10}, /* MVFP */
                                                 /* bits[3..0]reserved */
@@ -1145,17 +1145,12 @@ static int configure_gpio(struct gspca_dev *gspca_dev,
                 reg_w1(gspca_dev, 0x01, 0x42);
                 break;
         case SENSOR_OV7660:
-                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_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);
-                mdelay(100);
+                msleep(100);
                 reg_w1(gspca_dev, 0x02, 0x62);
                 break;
 /*      case SENSOR_HV7131R: */
@@ -1624,6 +1619,8 @@ static void setvflip(struct sd *sd)
 
 static void setinfrared(struct sd *sd)
 {
+        if (sd->gspca_dev.ctrl_dis & (1 << INFRARED_IDX))
+                return;
 /*fixme: different sequence for StarCam Clip and StarCam 370i */
 /* Clip */
         i2c_w1(&sd->gspca_dev, 0x02,                    /* gpio */
@@ -1637,16 +1634,19 @@ static void setfreq(struct gspca_dev *gspca_dev)
         if (gspca_dev->ctrl_dis & (1 << FREQ_IDX))
                 return;
         if (sd->sensor == SENSOR_OV7660) {
+                u8 com8;
+
+                com8 = 0xdf;            /* auto gain/wb/expo */
                 switch (sd->freq) {
                 case 0: /* Banding filter disabled */
-                        i2c_w1(gspca_dev, 0x13, 0xdf);
+                        i2c_w1(gspca_dev, 0x13, com8 | 0x20);
                         break;
                 case 1: /* 50 hz */
-                        i2c_w1(gspca_dev, 0x13, 0xff);
+                        i2c_w1(gspca_dev, 0x13, com8);
                         i2c_w1(gspca_dev, 0x3b, 0x0a);
                         break;
                 case 2: /* 60 hz */
-                        i2c_w1(gspca_dev, 0x13, 0xff);
+                        i2c_w1(gspca_dev, 0x13, com8);
                         i2c_w1(gspca_dev, 0x3b, 0x02);
                         break;
                 }
@@ -1796,12 +1796,6 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 reg_w1(gspca_dev, 0x99, 0x60);
                 break;
         case SENSOR_OV7660:
-                reg_w1(gspca_dev, 0x9a, 0x05);
-                if (sd->bridge == BRIDGE_SN9C105)
-                        reg_w1(gspca_dev, 0x99, 0xff);
-                else
-                        reg_w1(gspca_dev, 0x99, 0x5b);
-                break;
         case SENSOR_SP80708:
                 reg_w1(gspca_dev, 0x9a, 0x05);
                 reg_w1(gspca_dev, 0x99, 0x59);
@@ -2325,18 +2319,19 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0c45, 0x607c), BSI(SN9C102P, HV7131R, 0x11)},
 /*      {USB_DEVICE(0x0c45, 0x607e), BSI(SN9C102P, OV7630, 0x??)}, */
         {USB_DEVICE(0x0c45, 0x60c0), BSI(SN9C105, MI0360, 0x5d)},
-/*      {USB_DEVICE(0x0c45, 0x60c8), BSI(SN9C105, OM6801, 0x??)}, */
+/*      {USB_DEVICE(0x0c45, 0x60c8), BSI(SN9C105, OM6802, 0x??)}, */
 /*      {USB_DEVICE(0x0c45, 0x60cc), BSI(SN9C105, HV7131GP, 0x??)}, */
         {USB_DEVICE(0x0c45, 0x60ec), BSI(SN9C105, MO4000, 0x21)},
 /*      {USB_DEVICE(0x0c45, 0x60ef), BSI(SN9C105, ICM105C, 0x??)}, */
 /*      {USB_DEVICE(0x0c45, 0x60fa), BSI(SN9C105, OV7648, 0x??)}, */
         {USB_DEVICE(0x0c45, 0x60fb), BSI(SN9C105, OV7660, 0x21)},
-        {USB_DEVICE(0x0c45, 0x60fc), BSI(SN9C105, HV7131R, 0x11)},
 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
+        {USB_DEVICE(0x0c45, 0x60fc), BSI(SN9C105, HV7131R, 0x11)},
         {USB_DEVICE(0x0c45, 0x60fe), BSI(SN9C105, OV7630, 0x21)},
 #endif
         {USB_DEVICE(0x0c45, 0x6100), BSI(SN9C120, MI0360, 0x5d)}, /*sn9c128*/
-/*      {USB_DEVICE(0x0c45, 0x6108), BSI(SN9C120, OM6801, 0x??)}, */
+/*      {USB_DEVICE(0x0c45, 0x6102), BSI(SN9C120, PO2030N, ??)}, */
+/*      {USB_DEVICE(0x0c45, 0x6108), BSI(SN9C120, OM6802, 0x21)}, */
         {USB_DEVICE(0x0c45, 0x610a), BSI(SN9C120, OV7648, 0x21)}, /*sn9c128*/
         {USB_DEVICE(0x0c45, 0x610b), BSI(SN9C120, OV7660, 0x21)}, /*sn9c128*/
         {USB_DEVICE(0x0c45, 0x610c), BSI(SN9C120, HV7131R, 0x11)}, /*sn9c128*/
@@ -2352,6 +2347,7 @@ static const __devinitdata struct usb_device_id device_table[] = {
 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
         {USB_DEVICE(0x0c45, 0x6130), BSI(SN9C120, MI0360, 0x5d)},
 #endif
+/*      {USB_DEVICE(0x0c45, 0x6132), BSI(SN9C120, OV7670, 0x21)}, */
         {USB_DEVICE(0x0c45, 0x6138), BSI(SN9C120, MO4000, 0x21)},
         {USB_DEVICE(0x0c45, 0x613a), BSI(SN9C120, OV7648, 0x21)},
 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
@@ -2359,7 +2355,9 @@ static const __devinitdata struct usb_device_id device_table[] = {
 #endif
         {USB_DEVICE(0x0c45, 0x613c), BSI(SN9C120, HV7131R, 0x11)},
         {USB_DEVICE(0x0c45, 0x613e), BSI(SN9C120, OV7630, 0x21)},
-        {USB_DEVICE(0x0c45, 0x6143), BSI(SN9C120, SP80708, 0x18)},
+/*      {USB_DEVICE(0x0c45, 0x6142), BSI(SN9C120, PO2030N, ??)}, *sn9c120b*/
+        {USB_DEVICE(0x0c45, 0x6143), BSI(SN9C120, SP80708, 0x18)}, /*sn9c120b*/
+        {USB_DEVICE(0x0c45, 0x6148), BSI(SN9C120, OM6802, 0x21)}, /*sn9c120b*/
         {}
 };
 MODULE_DEVICE_TABLE(usb, device_table);
diff --git a/drivers/media/video/gspca/spca501.c b/drivers/media/video/gspca/spca501.c
index d48b27c648ca..b74a34218da0 100644
--- a/drivers/media/video/gspca/spca501.c
+++ b/drivers/media/video/gspca/spca501.c
@@ -1923,7 +1923,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         cam = &gspca_dev->cam;
         cam->cam_mode = vga_mode;
-        cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
+        cam->nmodes = ARRAY_SIZE(vga_mode);
         sd->subtype = id->driver_info;
         sd->brightness = sd_ctrls[MY_BRIGHTNESS].qctrl.default_value;
         sd->contrast = sd_ctrls[MY_CONTRAST].qctrl.default_value;
diff --git a/drivers/media/video/gspca/spca506.c b/drivers/media/video/gspca/spca506.c
index 3a0c893f942d..a199298a6419 100644
--- a/drivers/media/video/gspca/spca506.c
+++ b/drivers/media/video/gspca/spca506.c
@@ -286,7 +286,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         cam = &gspca_dev->cam;
         cam->cam_mode = vga_mode;
-        cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
+        cam->nmodes = ARRAY_SIZE(vga_mode);
         sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
         sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
         sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
diff --git a/drivers/media/video/gspca/spca508.c b/drivers/media/video/gspca/spca508.c
index 2ed2669bac3e..9696c4caf5c9 100644
--- a/drivers/media/video/gspca/spca508.c
+++ b/drivers/media/video/gspca/spca508.c
@@ -1304,19 +1304,70 @@ static int reg_read(struct gspca_dev *gspca_dev,
         return gspca_dev->usb_buf[0];
 }
 
+/* send 1 or 2 bytes to the sensor via the Synchronous Serial Interface */
+static int ssi_w(struct gspca_dev *gspca_dev,
+                u16 reg, u16 val)
+{
+        struct usb_device *dev = gspca_dev->dev;
+        int ret, retry;
+
+        ret = reg_write(dev, 0x8802, reg >> 8);
+        if (ret < 0)
+                goto out;
+        ret = reg_write(dev, 0x8801, reg & 0x00ff);
+        if (ret < 0)
+                goto out;
+        if ((reg & 0xff00) == 0x1000) {         /* if 2 bytes */
+                ret = reg_write(dev, 0x8805, val & 0x00ff);
+                if (ret < 0)
+                        goto out;
+                val >>= 8;
+        }
+        ret = reg_write(dev, 0x8800, val);
+        if (ret < 0)
+                goto out;
+
+        /* poll until not busy */
+        retry = 10;
+        for (;;) {
+                ret = reg_read(gspca_dev, 0x8803);
+                if (ret < 0)
+                        break;
+                if (gspca_dev->usb_buf[0] == 0)
+                        break;
+                if (--retry <= 0) {
+                        PDEBUG(D_ERR, "ssi_w busy %02x",
+                                        gspca_dev->usb_buf[0]);
+                        ret = -1;
+                        break;
+                }
+                msleep(8);
+        }
+
+out:
+        return ret;
+}
+
 static int write_vector(struct gspca_dev *gspca_dev,
                         const u16 (*data)[2])
 {
         struct usb_device *dev = gspca_dev->dev;
-        int ret;
+        int ret = 0;
 
         while ((*data)[1] != 0) {
-                ret = reg_write(dev, (*data)[1], (*data)[0]);
+                if ((*data)[1] & 0x8000) {
+                        if ((*data)[1] == 0xdd00)       /* delay */
+                                msleep((*data)[0]);
+                        else
+                                ret = reg_write(dev, (*data)[1], (*data)[0]);
+                } else {
+                        ret = ssi_w(gspca_dev, (*data)[1], (*data)[0]);
+                }
                 if (ret < 0)
-                        return ret;
+                        break;
                 data++;
         }
-        return 0;
+        return ret;
 }
 
 /* this function is called at probe time */
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx.c b/drivers/media/video/gspca/stv06xx/stv06xx.c
index 0da8e0de0456..7af511b5e9c2 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx.c
@@ -130,8 +130,8 @@ int stv06xx_write_sensor_bytes(struct sd *sd, const u8 *data, u8 len)
                                       STV06XX_URB_MSG_TIMEOUT);
                                       if (err < 0)
                                         return err;
-       }
-       return stv06xx_write_sensor_finish(sd);
+        }
+        return stv06xx_write_sensor_finish(sd);
 }
 
 int stv06xx_write_sensor_words(struct sd *sd, const u16 *data, u8 len)
diff --git a/drivers/media/video/gspca/sunplus.c b/drivers/media/video/gspca/sunplus.c
index 5127bbf9dd26..aa8f995ce04e 100644
--- a/drivers/media/video/gspca/sunplus.c
+++ b/drivers/media/video/gspca/sunplus.c
@@ -32,26 +32,27 @@ MODULE_LICENSE("GPL");
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
 
-        unsigned char brightness;
-        unsigned char contrast;
-        unsigned char colors;
-        unsigned char autogain;
+        s8 brightness;
+        u8 contrast;
+        u8 colors;
+        u8 autogain;
         u8 quality;
 #define QUALITY_MIN 70
 #define QUALITY_MAX 95
 #define QUALITY_DEF 85
 
-        char bridge;
+        u8 bridge;
 #define BRIDGE_SPCA504 0
 #define BRIDGE_SPCA504B 1
 #define BRIDGE_SPCA504C 2
 #define BRIDGE_SPCA533 3
 #define BRIDGE_SPCA536 4
-        char subtype;
+        u8 subtype;
 #define AiptekMiniPenCam13 1
 #define LogitechClickSmart420 2
 #define LogitechClickSmart820 3
 #define MegapixV4 4
+#define MegaImageVI 5
 
         u8 *jpeg_hdr;
 };
@@ -67,21 +68,20 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
 
 static struct ctrl sd_ctrls[] = {
-#define SD_BRIGHTNESS 0
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
                 .name    = "Brightness",
-                .minimum = 0,
-                .maximum = 0xff,
+                .minimum = -128,
+                .maximum = 127,
                 .step    = 1,
-                .default_value = 0,
+#define BRIGHTNESS_DEF 0
+                .default_value = BRIGHTNESS_DEF,
             },
             .set = sd_setbrightness,
             .get = sd_getbrightness,
         },
-#define SD_CONTRAST 1
         {
             {
                 .id      = V4L2_CID_CONTRAST,
@@ -90,12 +90,12 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 0xff,
                 .step    = 1,
-                .default_value = 0x20,
+#define CONTRAST_DEF 0x20
+                .default_value = CONTRAST_DEF,
             },
             .set = sd_setcontrast,
             .get = sd_getcontrast,
         },
-#define SD_COLOR 2
         {
             {
                 .id      = V4L2_CID_SATURATION,
@@ -104,12 +104,12 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 0xff,
                 .step    = 1,
-                .default_value = 0x1a,
+#define COLOR_DEF 0x1a
+                .default_value = COLOR_DEF,
             },
             .set = sd_setcolors,
             .get = sd_getcolors,
         },
-#define SD_AUTOGAIN 3
         {
             {
                 .id      = V4L2_CID_AUTOGAIN,
@@ -118,7 +118,8 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-                .default_value = 1,
+#define AUTOGAIN_DEF 1
+                .default_value = AUTOGAIN_DEF,
             },
             .set = sd_setautogain,
             .get = sd_getautogain,
@@ -180,14 +181,20 @@ static const struct v4l2_pix_format vga_mode2[] = {
 #define SPCA504_PCCAM600_OFFSET_MODE     5
 #define SPCA504_PCCAM600_OFFSET_DATA     14
  /* Frame packet header offsets for the spca533 */
-#define SPCA533_OFFSET_DATA      16
+#define SPCA533_OFFSET_DATA     16
 #define SPCA533_OFFSET_FRAMSEQ  15
 /* Frame packet header offsets for the spca536 */
-#define SPCA536_OFFSET_DATA      4
-#define SPCA536_OFFSET_FRAMSEQ   1
+#define SPCA536_OFFSET_DATA     4
+#define SPCA536_OFFSET_FRAMSEQ  1
+
+struct cmd {
+        u8 req;
+        u16 val;
+        u16 idx;
+};
 
 /* Initialisation data for the Creative PC-CAM 600 */
-static const __u16 spca504_pccam600_init_data[][3] = {
+static const struct cmd spca504_pccam600_init_data[] = {
 /*      {0xa0, 0x0000, 0x0503},  * capture mode */
         {0x00, 0x0000, 0x2000},
         {0x00, 0x0013, 0x2301},
@@ -211,22 +218,20 @@ static const __u16 spca504_pccam600_init_data[][3] = {
         {0x00, 0x0003, 0x2000},
         {0x00, 0x0013, 0x2301},
         {0x00, 0x0003, 0x2000},
-        {}
 };
 
 /* Creative PC-CAM 600 specific open data, sent before using the
  * generic initialisation data from spca504_open_data.
  */
-static const __u16 spca504_pccam600_open_data[][3] = {
+static const struct cmd spca504_pccam600_open_data[] = {
         {0x00, 0x0001, 0x2501},
         {0x20, 0x0500, 0x0001}, /* snapshot mode */
         {0x00, 0x0003, 0x2880},
         {0x00, 0x0001, 0x2881},
-        {}
 };
 
 /* Initialisation data for the logitech clicksmart 420 */
-static const __u16 spca504A_clicksmart420_init_data[][3] = {
+static const struct cmd spca504A_clicksmart420_init_data[] = {
 /*      {0xa0, 0x0000, 0x0503},  * capture mode */
         {0x00, 0x0000, 0x2000},
         {0x00, 0x0013, 0x2301},
@@ -243,7 +248,7 @@ static const __u16 spca504A_clicksmart420_init_data[][3] = {
         {0xb0, 0x0001, 0x0000},
 
 
-        {0x0a1, 0x0080, 0x0001},
+        {0xa1, 0x0080, 0x0001},
         {0x30, 0x0049, 0x0000},
         {0x30, 0x0060, 0x0005},
         {0x0c, 0x0004, 0x0000},
@@ -253,11 +258,10 @@ static const __u16 spca504A_clicksmart420_init_data[][3] = {
         {0x00, 0x0003, 0x2000},
         {0x00, 0x0000, 0x2000},
 
-        {}
 };
 
 /* clicksmart 420 open data ? */
-static const __u16 spca504A_clicksmart420_open_data[][3] = {
+static const struct cmd spca504A_clicksmart420_open_data[] = {
         {0x00, 0x0001, 0x2501},
         {0x20, 0x0502, 0x0000},
         {0x06, 0x0000, 0x0000},
@@ -401,10 +405,9 @@ static const __u16 spca504A_clicksmart420_open_data[][3] = {
         {0x00, 0x0028, 0x287f},
 
         {0xa0, 0x0000, 0x0503},
-        {}
 };
 
-static const __u8 qtable_creative_pccam[2][64] = {
+static const u8 qtable_creative_pccam[2][64] = {
         {                               /* Q-table Y-components */
          0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
          0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
@@ -429,7 +432,7 @@ static const __u8 qtable_creative_pccam[2][64] = {
  *              except for one byte. Possibly a typo?
  *              NWG: 18/05/2003.
  */
-static const __u8 qtable_spca504_default[2][64] = {
+static const u8 qtable_spca504_default[2][64] = {
         {                               /* Q-table Y-components */
          0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
          0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
@@ -453,9 +456,9 @@ static const __u8 qtable_spca504_default[2][64] = {
 
 /* read <len> bytes to gspca_dev->usb_buf */
 static void reg_r(struct gspca_dev *gspca_dev,
-                  __u16 req,
-                  __u16 index,
-                  __u16 len)
+                  u8 req,
+                  u16 index,
+                  u16 len)
 {
 #ifdef GSPCA_DEBUG
         if (len > USB_BUF_SZ) {
@@ -473,31 +476,26 @@ static void reg_r(struct gspca_dev *gspca_dev,
                         500);
 }
 
-/* write <len> bytes from gspca_dev->usb_buf */
-static void reg_w(struct gspca_dev *gspca_dev,
-                   __u16 req,
-                   __u16 value,
-                   __u16 index,
-                   __u16 len)
+/* write one byte */
+static void reg_w_1(struct gspca_dev *gspca_dev,
+                   u8 req,
+                   u16 value,
+                   u16 index,
+                   u16 byte)
 {
-#ifdef GSPCA_DEBUG
-        if (len > USB_BUF_SZ) {
-                err("reg_w: buffer overflow");
-                return;
-        }
-#endif
+        gspca_dev->usb_buf[0] = byte;
         usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
                         req,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         value, index,
-                        len ? gspca_dev->usb_buf : NULL, len,
+                        gspca_dev->usb_buf, 1,
                         500);
 }
 
 /* write req / index / value */
 static int reg_w_riv(struct usb_device *dev,
-                     __u16 req, __u16 index, __u16 value)
+                     u8 req, u16 index, u16 value)
 {
         int ret;
 
@@ -515,7 +513,7 @@ static int reg_w_riv(struct usb_device *dev,
 
 /* read 1 byte */
 static int reg_r_1(struct gspca_dev *gspca_dev,
-                        __u16 value)    /* wValue */
+                        u16 value)      /* wValue */
 {
         int ret;
 
@@ -536,9 +534,9 @@ static int reg_r_1(struct gspca_dev *gspca_dev,
 
 /* read 1 or 2 bytes - returns < 0 if error */
 static int reg_r_12(struct gspca_dev *gspca_dev,
-                        __u16 req,      /* bRequest */
-                        __u16 index,    /* wIndex */
-                        __u16 length)   /* wLength (1 or 2 only) */
+                        u8 req,         /* bRequest */
+                        u16 index,      /* wIndex */
+                        u16 length)     /* wLength (1 or 2 only) */
 {
         int ret;
 
@@ -559,43 +557,40 @@ static int reg_r_12(struct gspca_dev *gspca_dev,
 }
 
 static int write_vector(struct gspca_dev *gspca_dev,
-                        const __u16 data[][3])
+                        const struct cmd *data, int ncmds)
 {
         struct usb_device *dev = gspca_dev->dev;
-        int ret, i = 0;
+        int ret;
 
-        while (data[i][0] != 0 || data[i][1] != 0 || data[i][2] != 0) {
-                ret = reg_w_riv(dev, data[i][0], data[i][2], data[i][1]);
+        while (--ncmds >= 0) {
+                ret = reg_w_riv(dev, data->req, data->idx, data->val);
                 if (ret < 0) {
                         PDEBUG(D_ERR,
-                                "Register write failed for 0x%x,0x%x,0x%x",
-                                data[i][0], data[i][1], data[i][2]);
+                           "Register write failed for 0x%02x, 0x%04x, 0x%04x",
+                                data->req, data->val, data->idx);
                         return ret;
                 }
-                i++;
+                data++;
         }
         return 0;
 }
 
 static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
-                                unsigned int request,
-                                unsigned int ybase,
-                                unsigned int cbase,
-                                const __u8 qtable[2][64])
+                                const u8 qtable[2][64])
 {
         struct usb_device *dev = gspca_dev->dev;
         int i, err;
 
         /* loop over y components */
         for (i = 0; i < 64; i++) {
-                err = reg_w_riv(dev, request, ybase + i, qtable[0][i]);
+                err = reg_w_riv(dev, 0x00, 0x2800 + i, qtable[0][i]);
                 if (err < 0)
                         return err;
         }
 
         /* loop over c components */
         for (i = 0; i < 64; i++) {
-                err = reg_w_riv(dev, request, cbase + i, qtable[1][i]);
+                err = reg_w_riv(dev, 0x00, 0x2840 + i, qtable[1][i]);
                 if (err < 0)
                         return err;
         }
@@ -603,34 +598,34 @@ static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
 }
 
 static void spca504_acknowledged_command(struct gspca_dev *gspca_dev,
-                             __u16 req, __u16 idx, __u16 val)
+                             u8 req, u16 idx, u16 val)
 {
         struct usb_device *dev = gspca_dev->dev;
-        __u8 notdone;
+        int notdone;
 
         reg_w_riv(dev, req, idx, val);
         notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
         reg_w_riv(dev, req, idx, val);
 
-        PDEBUG(D_FRAM, "before wait 0x%x", notdone);
+        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%x", notdone);
+        PDEBUG(D_FRAM, "after wait 0x%04x", notdone);
 }
 
 static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
-                        __u16 req,
-                        __u16 idx, __u16 val, __u8 stat, __u8 count)
+                        u8 req,
+                        u16 idx, u16 val, u8 stat, u8 count)
 {
         struct usb_device *dev = gspca_dev->dev;
-        __u8 status;
-        __u8 endcode;
+        int status;
+        u8 endcode;
 
         reg_w_riv(dev, req, idx, val);
         status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
         endcode = stat;
-        PDEBUG(D_FRAM, "Status 0x%x Need 0x%x", status, stat);
+        PDEBUG(D_FRAM, "Status 0x%x Need 0x%04x", status, stat);
         if (!count)
                 return;
         count = 200;
@@ -640,7 +635,7 @@ static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
 /*              reg_w_riv(dev, req, idx, val); */
                 status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
                 if (status == endcode) {
-                        PDEBUG(D_FRAM, "status 0x%x after wait 0x%x",
+                        PDEBUG(D_FRAM, "status 0x%04x after wait %d",
                                 status, 200 - count);
                                 break;
                 }
@@ -667,8 +662,7 @@ static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
         while (--count > 0) {
                 reg_r(gspca_dev, 0x21, 1, 1);
                 if (gspca_dev->usb_buf[0] != 0) {
-                        gspca_dev->usb_buf[0] = 0;
-                        reg_w(gspca_dev, 0x21, 0, 1, 1);
+                        reg_w_1(gspca_dev, 0x21, 0, 1, 0);
                         reg_r(gspca_dev, 0x21, 1, 1);
                         spca504B_PollingDataReady(gspca_dev);
                         break;
@@ -679,7 +673,7 @@ static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
 
 static void spca50x_GetFirmware(struct gspca_dev *gspca_dev)
 {
-        __u8 *data;
+        u8 *data;
 
         data = gspca_dev->usb_buf;
         reg_r(gspca_dev, 0x20, 0, 5);
@@ -693,41 +687,34 @@ static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
-        __u8 Size;
-        __u8 Type;
+        u8 Size;
         int rc;
 
-        Size = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
-        Type = 0;
+        Size = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
         switch (sd->bridge) {
         case BRIDGE_SPCA533:
-                reg_w(gspca_dev, 0x31, 0, 0, 0);
+                reg_w_riv(dev, 0x31, 0, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
                 rc = spca504B_PollingDataReady(gspca_dev);
                 spca50x_GetFirmware(gspca_dev);
-                gspca_dev->usb_buf[0] = 2;                      /* type */
-                reg_w(gspca_dev, 0x24, 0, 8, 1);
+                reg_w_1(gspca_dev, 0x24, 0, 8, 2);              /* type */
                 reg_r(gspca_dev, 0x24, 8, 1);
 
-                gspca_dev->usb_buf[0] = Size;
-                reg_w(gspca_dev, 0x25, 0, 4, 1);
+                reg_w_1(gspca_dev, 0x25, 0, 4, Size);
                 reg_r(gspca_dev, 0x25, 4, 1);                   /* size */
                 rc = spca504B_PollingDataReady(gspca_dev);
 
                 /* Init the cam width height with some values get on init ? */
-                reg_w(gspca_dev, 0x31, 0, 4, 0);
+                reg_w_riv(dev, 0x31, 0, 0x04);
                 spca504B_WaitCmdStatus(gspca_dev);
                 rc = spca504B_PollingDataReady(gspca_dev);
                 break;
         default:
 /* case BRIDGE_SPCA504B: */
 /* case BRIDGE_SPCA536: */
-                gspca_dev->usb_buf[0] = Size;
-                reg_w(gspca_dev, 0x25, 0, 4, 1);
+                reg_w_1(gspca_dev, 0x25, 0, 4, Size);
                 reg_r(gspca_dev, 0x25, 4, 1);                   /* size */
-                Type = 6;
-                gspca_dev->usb_buf[0] = Type;
-                reg_w(gspca_dev, 0x27, 0, 0, 1);
+                reg_w_1(gspca_dev, 0x27, 0, 0, 6);
                 reg_r(gspca_dev, 0x27, 0, 1);                   /* type */
                 rc = spca504B_PollingDataReady(gspca_dev);
                 break;
@@ -767,17 +754,51 @@ static void spca504_wait_status(struct gspca_dev *gspca_dev)
 
 static void spca504B_setQtable(struct gspca_dev *gspca_dev)
 {
-        gspca_dev->usb_buf[0] = 3;
-        reg_w(gspca_dev, 0x26, 0, 0, 1);
+        reg_w_1(gspca_dev, 0x26, 0, 0, 3);
         reg_r(gspca_dev, 0x26, 0, 1);
         spca504B_PollingDataReady(gspca_dev);
 }
 
-static void sp5xx_initContBrigHueRegisters(struct gspca_dev *gspca_dev)
+static void setbrightness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct usb_device *dev = gspca_dev->dev;
+        u16 reg;
+
+        reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f0 : 0x21a7;
+        reg_w_riv(dev, 0x00, reg, sd->brightness);
+}
+
+static void setcontrast(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct usb_device *dev = gspca_dev->dev;
+        u16 reg;
+
+        reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f1 : 0x21a8;
+        reg_w_riv(dev, 0x00, reg, sd->contrast);
+}
+
+static void setcolors(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct usb_device *dev = gspca_dev->dev;
+        u16 reg;
+
+        reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f6 : 0x21ae;
+        reg_w_riv(dev, 0x00, reg, sd->colors);
+}
+
+static void init_ctl_reg(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        struct usb_device *dev = gspca_dev->dev;
         int pollreg = 1;
 
+        setbrightness(gspca_dev);
+        setcontrast(gspca_dev);
+        setcolors(gspca_dev);
+
         switch (sd->bridge) {
         case BRIDGE_SPCA504:
         case BRIDGE_SPCA504C:
@@ -786,20 +807,14 @@ static void sp5xx_initContBrigHueRegisters(struct gspca_dev *gspca_dev)
         default:
 /*      case BRIDGE_SPCA533: */
 /*      case BRIDGE_SPCA504B: */
-                reg_w(gspca_dev, 0, 0, 0x21a7, 0);      /* brightness */
-                reg_w(gspca_dev, 0, 0x20, 0x21a8, 0);   /* contrast */
-                reg_w(gspca_dev, 0, 0, 0x21ad, 0);      /* hue */
-                reg_w(gspca_dev, 0, 1, 0x21ac, 0);      /* sat/hue */
-                reg_w(gspca_dev, 0, 0x20, 0x21ae, 0);   /* saturation */
-                reg_w(gspca_dev, 0, 0, 0x21a3, 0);      /* gamma */
+                reg_w_riv(dev, 0, 0x00, 0x21ad);        /* hue */
+                reg_w_riv(dev, 0, 0x01, 0x21ac);        /* sat/hue */
+                reg_w_riv(dev, 0, 0x00, 0x21a3);        /* gamma */
                 break;
         case BRIDGE_SPCA536:
-                reg_w(gspca_dev, 0, 0, 0x20f0, 0);
-                reg_w(gspca_dev, 0, 0x21, 0x20f1, 0);
-                reg_w(gspca_dev, 0, 0x40, 0x20f5, 0);
-                reg_w(gspca_dev, 0, 1, 0x20f4, 0);
-                reg_w(gspca_dev, 0, 0x40, 0x20f6, 0);
-                reg_w(gspca_dev, 0, 0, 0x2089, 0);
+                reg_w_riv(dev, 0, 0x40, 0x20f5);
+                reg_w_riv(dev, 0, 0x01, 0x20f4);
+                reg_w_riv(dev, 0, 0x00, 0x2089);
                 break;
         }
         if (pollreg)
@@ -840,20 +855,24 @@ static int sd_config(struct gspca_dev *gspca_dev,
 /*      case BRIDGE_SPCA504: */
 /*      case BRIDGE_SPCA536: */
                 cam->cam_mode = vga_mode;
-                cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
+                cam->nmodes =ARRAY_SIZE(vga_mode);
                 break;
         case BRIDGE_SPCA533:
                 cam->cam_mode = custom_mode;
-                cam->nmodes = sizeof custom_mode / sizeof custom_mode[0];
+                if (sd->subtype == MegaImageVI)         /* 320x240 only */
+                        cam->nmodes = ARRAY_SIZE(custom_mode) - 1;
+                else
+                        cam->nmodes = ARRAY_SIZE(custom_mode);
                 break;
         case BRIDGE_SPCA504C:
                 cam->cam_mode = vga_mode2;
-                cam->nmodes = sizeof vga_mode2 / sizeof vga_mode2[0];
+                cam->nmodes = ARRAY_SIZE(vga_mode2);
                 break;
         }
-        sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
-        sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
-        sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
+        sd->brightness = BRIGHTNESS_DEF;
+        sd->contrast = CONTRAST_DEF;
+        sd->colors = COLOR_DEF;
+        sd->autogain = AUTOGAIN_DEF;
         sd->quality = QUALITY_DEF;
         return 0;
 }
@@ -863,32 +882,29 @@ static int sd_init(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
-        int rc;
-        __u8 i;
-        __u8 info[6];
-        int err_code;
+        int i, err_code;
+        u8 info[6];
 
         switch (sd->bridge) {
         case BRIDGE_SPCA504B:
-                reg_w(gspca_dev, 0x1d, 0, 0, 0);
-                reg_w(gspca_dev, 0, 1, 0x2306, 0);
-                reg_w(gspca_dev, 0, 0, 0x0d04, 0);
-                reg_w(gspca_dev, 0, 0, 0x2000, 0);
-                reg_w(gspca_dev, 0, 0x13, 0x2301, 0);
-                reg_w(gspca_dev, 0, 0, 0x2306, 0);
+                reg_w_riv(dev, 0x1d, 0x00, 0);
+                reg_w_riv(dev, 0, 0x01, 0x2306);
+                reg_w_riv(dev, 0, 0x00, 0x0d04);
+                reg_w_riv(dev, 0, 0x00, 0x2000);
+                reg_w_riv(dev, 0, 0x13, 0x2301);
+                reg_w_riv(dev, 0, 0x00, 0x2306);
                 /* fall thru */
         case BRIDGE_SPCA533:
-                rc = spca504B_PollingDataReady(gspca_dev);
+                spca504B_PollingDataReady(gspca_dev);
                 spca50x_GetFirmware(gspca_dev);
                 break;
         case BRIDGE_SPCA536:
                 spca50x_GetFirmware(gspca_dev);
                 reg_r(gspca_dev, 0x00, 0x5002, 1);
-                gspca_dev->usb_buf[0] = 0;
-                reg_w(gspca_dev, 0x24, 0, 0, 1);
+                reg_w_1(gspca_dev, 0x24, 0, 0, 0);
                 reg_r(gspca_dev, 0x24, 0, 1);
-                rc = spca504B_PollingDataReady(gspca_dev);
-                reg_w(gspca_dev, 0x34, 0, 0, 0);
+                spca504B_PollingDataReady(gspca_dev);
+                reg_w_riv(dev, 0x34, 0, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
                 break;
         case BRIDGE_SPCA504C:   /* pccam600 */
@@ -898,12 +914,13 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 spca504_wait_status(gspca_dev);
                 if (sd->subtype == LogitechClickSmart420)
                         write_vector(gspca_dev,
-                                        spca504A_clicksmart420_open_data);
+                                spca504A_clicksmart420_open_data,
+                                ARRAY_SIZE(spca504A_clicksmart420_open_data));
                 else
-                        write_vector(gspca_dev, spca504_pccam600_open_data);
+                        write_vector(gspca_dev, spca504_pccam600_open_data,
+                                ARRAY_SIZE(spca504_pccam600_open_data));
                 err_code = spca50x_setup_qtable(gspca_dev,
-                                                0x00, 0x2800,
-                                                0x2840, qtable_creative_pccam);
+                                                qtable_creative_pccam);
                 if (err_code < 0) {
                         PDEBUG(D_ERR|D_STREAM, "spca50x_setup_qtable failed");
                         return err_code;
@@ -941,8 +958,8 @@ static int sd_init(struct gspca_dev *gspca_dev)
                                                         6, 0, 0x86, 1); */
 /*                      spca504A_acknowledged_command (gspca_dev, 0x24,
                                                         0, 0, 0x9D, 1); */
-                        reg_w_riv(dev, 0x0, 0x270c, 0x05); /* L92 sno1t.txt */
-                        reg_w_riv(dev, 0x0, 0x2310, 0x05);
+                        reg_w_riv(dev, 0x00, 0x270c, 0x05); /* L92 sno1t.txt */
+                        reg_w_riv(dev, 0x00, 0x2310, 0x05);
                         spca504A_acknowledged_command(gspca_dev, 0x01,
                                                         0x0f, 0, 0xff, 0);
                 }
@@ -950,8 +967,6 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 reg_w_riv(dev, 0, 0x2000, 0);
                 reg_w_riv(dev, 0, 0x2883, 1);
                 err_code = spca50x_setup_qtable(gspca_dev,
-                                                0x00, 0x2800,
-                                                0x2840,
                                                 qtable_spca504_default);
                 if (err_code < 0) {
                         PDEBUG(D_ERR, "spca50x_setup_qtable failed");
@@ -966,10 +981,9 @@ static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
-        int rc;
         int enable;
-        __u8 i;
-        __u8 info[6];
+        int i;
+        u8 info[6];
 
         /* create the JPEG header */
         sd->jpeg_hdr = kmalloc(JPEG_HDR_SZ, GFP_KERNEL);
@@ -987,16 +1001,20 @@ static int sd_start(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA504B: */
 /*      case BRIDGE_SPCA533: */
 /*      case BRIDGE_SPCA536: */
-                if (sd->subtype == MegapixV4 ||
-                    sd->subtype == LogitechClickSmart820) {
-                        reg_w(gspca_dev, 0xf0, 0, 0, 0);
+                switch (sd->subtype) {
+                case MegapixV4:
+                case LogitechClickSmart820:
+                case MegaImageVI:
+                        reg_w_riv(dev, 0xf0, 0, 0);
                         spca504B_WaitCmdStatus(gspca_dev);
                         reg_r(gspca_dev, 0xf0, 4, 0);
                         spca504B_WaitCmdStatus(gspca_dev);
-                } else {
-                        reg_w(gspca_dev, 0x31, 0, 4, 0);
+                        break;
+                default:
+                        reg_w_riv(dev, 0x31, 0, 0x04);
                         spca504B_WaitCmdStatus(gspca_dev);
-                        rc = spca504B_PollingDataReady(gspca_dev);
+                        spca504B_PollingDataReady(gspca_dev);
+                        break;
                 }
                 break;
         case BRIDGE_SPCA504:
@@ -1030,15 +1048,17 @@ static int sd_start(struct gspca_dev *gspca_dev)
                         spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
                 }
                 spca504B_SetSizeType(gspca_dev);
-                reg_w_riv(dev, 0x0, 0x270c, 0x05);      /* L92 sno1t.txt */
-                reg_w_riv(dev, 0x0, 0x2310, 0x05);
+                reg_w_riv(dev, 0x00, 0x270c, 0x05);     /* L92 sno1t.txt */
+                reg_w_riv(dev, 0x00, 0x2310, 0x05);
                 break;
         case BRIDGE_SPCA504C:
                 if (sd->subtype == LogitechClickSmart420) {
                         write_vector(gspca_dev,
-                                        spca504A_clicksmart420_init_data);
+                                spca504A_clicksmart420_init_data,
+                                ARRAY_SIZE(spca504A_clicksmart420_init_data));
                 } else {
-                        write_vector(gspca_dev, spca504_pccam600_init_data);
+                        write_vector(gspca_dev, spca504_pccam600_init_data,
+                                ARRAY_SIZE(spca504_pccam600_init_data));
                 }
                 enable = (sd->autogain ? 0x04 : 0x01);
                 reg_w_riv(dev, 0x0c, 0x0000, enable);   /* auto exposure */
@@ -1050,7 +1070,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 spca504B_SetSizeType(gspca_dev);
                 break;
         }
-        sp5xx_initContBrigHueRegisters(gspca_dev);
+        init_ctl_reg(gspca_dev);
         return 0;
 }
 
@@ -1064,7 +1084,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA533: */
 /*      case BRIDGE_SPCA536: */
 /*      case BRIDGE_SPCA504B: */
-                reg_w(gspca_dev, 0x31, 0, 0, 0);
+                reg_w_riv(dev, 0x31, 0, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
                 spca504B_PollingDataReady(gspca_dev);
                 break;
@@ -1082,7 +1102,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
                                                         0x0f, 0x00, 0xff, 1);
                 } else {
                         spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
-                        reg_w_riv(dev, 0x01, 0x000f, 0x00);
+                        reg_w_riv(dev, 0x01, 0x000f, 0x0000);
                 }
                 break;
         }
@@ -1097,12 +1117,12 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                         struct gspca_frame *frame,      /* target */
-                        __u8 *data,                     /* isoc packet */
+                        u8 *data,                       /* isoc packet */
                         int len)                        /* iso packet length */
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int i, sof = 0;
-        static unsigned char ffd9[] = {0xff, 0xd9};
+        static u8 ffd9[] = {0xff, 0xd9};
 
 /* frames are jpeg 4.1.1 without 0xff escape */
         switch (sd->bridge) {
@@ -1190,63 +1210,6 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
 }
 
-static void setbrightness(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        struct usb_device *dev = gspca_dev->dev;
-
-        switch (sd->bridge) {
-        default:
-/*      case BRIDGE_SPCA533: */
-/*      case BRIDGE_SPCA504B: */
-/*      case BRIDGE_SPCA504: */
-/*      case BRIDGE_SPCA504C: */
-                reg_w_riv(dev, 0x0, 0x21a7, sd->brightness);
-                break;
-        case BRIDGE_SPCA536:
-                reg_w_riv(dev, 0x0, 0x20f0, sd->brightness);
-                break;
-        }
-}
-
-static void setcontrast(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        struct usb_device *dev = gspca_dev->dev;
-
-        switch (sd->bridge) {
-        default:
-/*      case BRIDGE_SPCA533: */
-/*      case BRIDGE_SPCA504B: */
-/*      case BRIDGE_SPCA504: */
-/*      case BRIDGE_SPCA504C: */
-                reg_w_riv(dev, 0x0, 0x21a8, sd->contrast);
-                break;
-        case BRIDGE_SPCA536:
-                reg_w_riv(dev, 0x0, 0x20f1, sd->contrast);
-                break;
-        }
-}
-
-static void setcolors(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        struct usb_device *dev = gspca_dev->dev;
-
-        switch (sd->bridge) {
-        default:
-/*      case BRIDGE_SPCA533: */
-/*      case BRIDGE_SPCA504B: */
-/*      case BRIDGE_SPCA504: */
-/*      case BRIDGE_SPCA504C: */
-                reg_w_riv(dev, 0x0, 0x21ae, sd->colors);
-                break;
-        case BRIDGE_SPCA536:
-                reg_w_riv(dev, 0x0, 0x20f6, sd->colors);
-                break;
-        }
-}
-
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -1384,6 +1347,7 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x04fc, 0x5360), BS(SPCA536, 0)},
         {USB_DEVICE(0x04fc, 0xffff), BS(SPCA504B, 0)},
         {USB_DEVICE(0x052b, 0x1513), BS(SPCA533, MegapixV4)},
+        {USB_DEVICE(0x052b, 0x1803), BS(SPCA533, MegaImageVI)},
         {USB_DEVICE(0x0546, 0x3155), BS(SPCA533, 0)},
         {USB_DEVICE(0x0546, 0x3191), BS(SPCA504B, 0)},
         {USB_DEVICE(0x0546, 0x3273), BS(SPCA504B, 0)},
diff --git a/drivers/media/video/gspca/t613.c b/drivers/media/video/gspca/t613.c
index 404214b8cd2b..1d321c30d22f 100644
--- a/drivers/media/video/gspca/t613.c
+++ b/drivers/media/video/gspca/t613.c
@@ -264,6 +264,10 @@ static const struct v4l2_pix_format vga_mode_t16[] = {
 
 /* sensor specific data */
 struct additional_sensor_data {
+        const u8 n3[6];
+        const u8 *n4, n4sz;
+        const u8 reg80, reg8e;
+        const u8 nset8[6];
         const u8 data1[10];
         const u8 data2[9];
         const u8 data3[9];
@@ -272,14 +276,55 @@ struct additional_sensor_data {
         const u8 stream[4];
 };
 
+static const u8 n4_om6802[] = {
+        0x09, 0x01, 0x12, 0x04, 0x66, 0x8a, 0x80, 0x3c,
+        0x81, 0x22, 0x84, 0x50, 0x8a, 0x78, 0x8b, 0x68,
+        0x8c, 0x88, 0x8e, 0x33, 0x8f, 0x24, 0xaa, 0xb1,
+        0xa2, 0x60, 0xa5, 0x30, 0xa6, 0x3a, 0xa8, 0xe8,
+        0xae, 0x05, 0xb1, 0x00, 0xbb, 0x04, 0xbc, 0x48,
+        0xbe, 0x36, 0xc6, 0x88, 0xe9, 0x00, 0xc5, 0xc0,
+        0x65, 0x0a, 0xbb, 0x86, 0xaf, 0x58, 0xb0, 0x68,
+        0x87, 0x40, 0x89, 0x2b, 0x8d, 0xff, 0x83, 0x40,
+        0xac, 0x84, 0xad, 0x86, 0xaf, 0x46
+};
+static const u8 n4_other[] = {
+        0x66, 0x00, 0x7f, 0x00, 0x80, 0xac, 0x81, 0x69,
+        0x84, 0x40, 0x85, 0x70, 0x86, 0x20, 0x8a, 0x68,
+        0x8b, 0x58, 0x8c, 0x88, 0x8d, 0xff, 0x8e, 0xb8,
+        0x8f, 0x28, 0xa2, 0x60, 0xa5, 0x40, 0xa8, 0xa8,
+        0xac, 0x84, 0xad, 0x84, 0xae, 0x24, 0xaf, 0x56,
+        0xb0, 0x68, 0xb1, 0x00, 0xb2, 0x88, 0xbb, 0xc5,
+        0xbc, 0x4a, 0xbe, 0x36, 0xc2, 0x88, 0xc5, 0xc0,
+        0xc6, 0xda, 0xe9, 0x26, 0xeb, 0x00
+};
+static const u8 n4_tas5130a[] = {
+        0x80, 0x3c, 0x81, 0x68, 0x83, 0xa0, 0x84, 0x20,
+        0x8a, 0x68, 0x8b, 0x58, 0x8c, 0x88, 0x8e, 0xb4,
+        0x8f, 0x24, 0xa1, 0xb1, 0xa2, 0x30, 0xa5, 0x10,
+        0xa6, 0x4a, 0xae, 0x03, 0xb1, 0x44, 0xb2, 0x08,
+        0xb7, 0x06, 0xb9, 0xe7, 0xbb, 0xc4, 0xbc, 0x4a,
+        0xbe, 0x36, 0xbf, 0xff, 0xc2, 0x88, 0xc5, 0xc8,
+        0xc6, 0xda
+};
+
 static const struct additional_sensor_data sensor_data[] = {
-    {                           /* OM6802 */
+    {                           /* 0: OM6802 */
+        .n3 =
+                {0x61, 0x68, 0x65, 0x0a, 0x60, 0x04},
+        .n4 = n4_om6802,
+        .n4sz = sizeof n4_om6802,
+        .reg80 = 0x3c,
+        .reg8e = 0x33,
+        .nset8 = {0xa8, 0xf0, 0xc6, 0x88, 0xc0, 0x00},
         .data1 =
                 {0xc2, 0x28, 0x0f, 0x22, 0xcd, 0x27, 0x2c, 0x06,
                  0xb3, 0xfc},
         .data2 =
                 {0x80, 0xff, 0xff, 0x80, 0xff, 0xff, 0x80, 0xff,
                  0xff},
+        .data3 =
+                {0x80, 0xff, 0xff, 0x80, 0xff, 0xff, 0x80, 0xff,
+                 0xff},
         .data4 =        /*Freq (50/60Hz). Splitted for test purpose */
                 {0x66, 0xca, 0xa8, 0xf0},
         .data5 =        /* this could be removed later */
@@ -287,13 +332,23 @@ static const struct additional_sensor_data sensor_data[] = {
         .stream =
                 {0x0b, 0x04, 0x0a, 0x78},
     },
-    {                           /* OTHER */
+    {                           /* 1: OTHER */
+        .n3 =
+                {0x61, 0xc2, 0x65, 0x88, 0x60, 0x00},
+        .n4 = n4_other,
+        .n4sz = sizeof n4_other,
+        .reg80 = 0xac,
+        .reg8e = 0xb8,
+        .nset8 = {0xa8, 0xa8, 0xc6, 0xda, 0xc0, 0x00},
         .data1 =
                 {0xc1, 0x48, 0x04, 0x1b, 0xca, 0x2e, 0x33, 0x3a,
                  0xe8, 0xfc},
         .data2 =
                 {0x4e, 0x9c, 0xec, 0x40, 0x80, 0xc0, 0x48, 0x96,
                  0xd9},
+        .data3 =
+                {0x4e, 0x9c, 0xec, 0x40, 0x80, 0xc0, 0x48, 0x96,
+                 0xd9},
         .data4 =
                 {0x66, 0x00, 0xa8, 0xa8},
         .data5 =
@@ -301,13 +356,23 @@ static const struct additional_sensor_data sensor_data[] = {
         .stream =
                 {0x0b, 0x04, 0x0a, 0x00},
     },
-    {                           /* TAS5130A */
+    {                           /* 2: TAS5130A */
+        .n3 =
+                {0x61, 0xc2, 0x65, 0x0d, 0x60, 0x08},
+        .n4 = n4_tas5130a,
+        .n4sz = sizeof n4_tas5130a,
+        .reg80 = 0x3c,
+        .reg8e = 0xb4,
+        .nset8 = {0xa8, 0xf0, 0xc6, 0xda, 0xc0, 0x00},
         .data1 =
                 {0xbb, 0x28, 0x10, 0x10, 0xbb, 0x28, 0x1e, 0x27,
                  0xc8, 0xfc},
         .data2 =
                 {0x60, 0xa8, 0xe0, 0x60, 0xa8, 0xe0, 0x60, 0xa8,
                  0xe0},
+        .data3 =
+                {0x60, 0xa8, 0xe0, 0x60, 0xa8, 0xe0, 0x60, 0xa8,
+                 0xe0},
         .data4 =        /* Freq (50/60Hz). Splitted for test purpose */
                 {0x66, 0x00, 0xa8, 0xe8},
         .data5 =
@@ -364,7 +429,7 @@ static const u8 gamma_table[GAMMA_MAX][17] = {
         {0x00, 0x18, 0x2b, 0x44, 0x60, 0x70, 0x80, 0x8e,        /* 10 */
          0x9c, 0xaa, 0xb7, 0xc4, 0xd0, 0xd8, 0xe2, 0xf0,
          0xff},
-        {0x00, 0x1a, 0x34, 0x52, 0x66, 0x7e, 0x8D, 0x9B,        /* 11 */
+        {0x00, 0x1a, 0x34, 0x52, 0x66, 0x7e, 0x8d, 0x9b,        /* 11 */
          0xa8, 0xb4, 0xc0, 0xcb, 0xd6, 0xe1, 0xeb, 0xf5,
          0xff},
         {0x00, 0x3f, 0x5a, 0x6e, 0x7f, 0x8e, 0x9c, 0xa8,        /* 12 */
@@ -385,8 +450,6 @@ static const u8 tas5130a_sensor_init[][8] = {
         {0x62, 0x08, 0x63, 0x70, 0x64, 0x1d, 0x60, 0x09},
         {0x62, 0x20, 0x63, 0x01, 0x64, 0x02, 0x60, 0x09},
         {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09},
-        {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09},
-        {},
 };
 
 static u8 sensor_reset[] = {0x61, 0x68, 0x62, 0xff, 0x60, 0x07};
@@ -633,10 +696,10 @@ static int sd_init(struct gspca_dev *gspca_dev)
          * but wont hurt anyway, and can help someone with similar webcam
          * to see the initial parameters.*/
         struct sd *sd = (struct sd *) gspca_dev;
+        const struct additional_sensor_data *sensor;
         int i;
         u16 sensor_id;
         u8 test_byte = 0;
-        u16 reg80, reg8e;
 
         static const u8 read_indexs[] =
                 { 0x0a, 0x0b, 0x66, 0x80, 0x81, 0x8e, 0x8f, 0xa5,
@@ -645,37 +708,6 @@ static int sd_init(struct gspca_dev *gspca_dev)
                         {0x08, 0x03, 0x09, 0x03, 0x12, 0x04};
         static const u8 n2[] =
                         {0x08, 0x00};
-        static const u8 n3[6] =
-                        {0x61, 0x68, 0x65, 0x0a, 0x60, 0x04};
-        static const u8 n3_other[6] =
-                        {0x61, 0xc2, 0x65, 0x88, 0x60, 0x00};
-        static const u8 n4[] =
-                {0x09, 0x01, 0x12, 0x04, 0x66, 0x8a, 0x80, 0x3c,
-                 0x81, 0x22, 0x84, 0x50, 0x8a, 0x78, 0x8b, 0x68,
-                 0x8c, 0x88, 0x8e, 0x33, 0x8f, 0x24, 0xaa, 0xb1,
-                 0xa2, 0x60, 0xa5, 0x30, 0xa6, 0x3a, 0xa8, 0xe8,
-                 0xae, 0x05, 0xb1, 0x00, 0xbb, 0x04, 0xbc, 0x48,
-                 0xbe, 0x36, 0xc6, 0x88, 0xe9, 0x00, 0xc5, 0xc0,
-                 0x65, 0x0a, 0xbb, 0x86, 0xaf, 0x58, 0xb0, 0x68,
-                 0x87, 0x40, 0x89, 0x2b, 0x8d, 0xff, 0x83, 0x40,
-                 0xac, 0x84, 0xad, 0x86, 0xaf, 0x46};
-        static const u8 n4_other[] =
-                {0x66, 0x00, 0x7f, 0x00, 0x80, 0xac, 0x81, 0x69,
-                 0x84, 0x40, 0x85, 0x70, 0x86, 0x20, 0x8a, 0x68,
-                 0x8b, 0x58, 0x8c, 0x88, 0x8d, 0xff, 0x8e, 0xb8,
-                 0x8f, 0x28, 0xa2, 0x60, 0xa5, 0x40, 0xa8, 0xa8,
-                 0xac, 0x84, 0xad, 0x84, 0xae, 0x24, 0xaf, 0x56,
-                 0xb0, 0x68, 0xb1, 0x00, 0xb2, 0x88, 0xbb, 0xc5,
-                 0xbc, 0x4a, 0xbe, 0x36, 0xc2, 0x88, 0xc5, 0xc0,
-                 0xc6, 0xda, 0xe9, 0x26, 0xeb, 0x00};
-        static const u8 nset8[6] =
-                        { 0xa8, 0xf0, 0xc6, 0x88, 0xc0, 0x00 };
-        static const u8 nset8_other[6] =
-                        { 0xa8, 0xa8, 0xc6, 0xda, 0xc0, 0x00 };
-        static const u8 nset9[4] =
-                        { 0x0b, 0x04, 0x0a, 0x78 };
-        static const u8 nset9_other[4] =
-                        { 0x0b, 0x04, 0x0a, 0x00 };
 
         sensor_id = (reg_r(gspca_dev, 0x06) << 8)
                         | reg_r(gspca_dev, 0x07);
@@ -709,8 +741,7 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 }
                 if (i < 0) {
                         err("Bad sensor reset %02x", test_byte);
-/*                      return -EIO; */
-/*fixme: test - continue */
+                        return -EIO;
                 }
                 reg_w_buf(gspca_dev, n2, sizeof n2);
         }
@@ -723,31 +754,17 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 i++;
         }
 
-        if (sd->sensor != SENSOR_OTHER) {
-                reg_w_buf(gspca_dev, n3, sizeof n3);
-                reg_w_buf(gspca_dev, n4, sizeof n4);
-                reg_r(gspca_dev, 0x0080);
-                reg_w(gspca_dev, 0x2c80);
-                reg80 = 0x3880;
-                reg8e = 0x338e;
-        } else {
-                reg_w_buf(gspca_dev, n3_other, sizeof n3_other);
-                reg_w_buf(gspca_dev, n4_other, sizeof n4_other);
-                sd->gamma = 5;
-                reg80 = 0xac80;
-                reg8e = 0xb88e;
-        }
+        sensor = &sensor_data[sd->sensor];
+        reg_w_buf(gspca_dev, sensor->n3, sizeof sensor->n3);
+        reg_w_buf(gspca_dev, sensor->n4, sensor->n4sz);
 
-        reg_w_ixbuf(gspca_dev, 0xd0, sensor_data[sd->sensor].data1,
-                        sizeof sensor_data[sd->sensor].data1);
-        reg_w_ixbuf(gspca_dev, 0xc7, sensor_data[sd->sensor].data2,
-                        sizeof sensor_data[sd->sensor].data2);
-        reg_w_ixbuf(gspca_dev, 0xe0, sensor_data[sd->sensor].data2,
-                        sizeof sensor_data[sd->sensor].data2);
+        reg_w_ixbuf(gspca_dev, 0xd0, sensor->data1, sizeof sensor->data1);
+        reg_w_ixbuf(gspca_dev, 0xc7, sensor->data2, sizeof sensor->data2);
+        reg_w_ixbuf(gspca_dev, 0xe0, sensor->data3, sizeof sensor->data3);
 
-        reg_w(gspca_dev, reg80);
-        reg_w(gspca_dev, reg80);
-        reg_w(gspca_dev, reg8e);
+        reg_w(gspca_dev, (sensor->reg80 << 8) + 0x80);
+        reg_w(gspca_dev, (sensor->reg80 << 8) + 0x80);
+        reg_w(gspca_dev, (sensor->reg8e << 8) + 0x8e);
 
         setbrightness(gspca_dev);
         setcontrast(gspca_dev);
@@ -760,25 +777,14 @@ static int sd_init(struct gspca_dev *gspca_dev)
         reg_w(gspca_dev, 0x2088);
         reg_w(gspca_dev, 0x2089);
 
-        reg_w_buf(gspca_dev, sensor_data[sd->sensor].data4,
-                        sizeof sensor_data[sd->sensor].data4);
-        reg_w_buf(gspca_dev, sensor_data[sd->sensor].data5,
-                        sizeof sensor_data[sd->sensor].data5);
-        if (sd->sensor != SENSOR_OTHER) {
-                reg_w_buf(gspca_dev, nset8, sizeof nset8);
-                reg_w_buf(gspca_dev, nset9, sizeof nset9);
-                reg_w(gspca_dev, 0x2880);
-        } else {
-                reg_w_buf(gspca_dev, nset8_other, sizeof nset8_other);
-                reg_w_buf(gspca_dev, nset9_other, sizeof nset9_other);
-        }
+        reg_w_buf(gspca_dev, sensor->data4, sizeof sensor->data4);
+        reg_w_buf(gspca_dev, sensor->data5, sizeof sensor->data5);
+        reg_w_buf(gspca_dev, sensor->nset8, sizeof sensor->nset8);
+        reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream);
 
-        reg_w_ixbuf(gspca_dev, 0xd0, sensor_data[sd->sensor].data1,
-                        sizeof sensor_data[sd->sensor].data1);
-        reg_w_ixbuf(gspca_dev, 0xc7, sensor_data[sd->sensor].data2,
-                        sizeof sensor_data[sd->sensor].data2);
-        reg_w_ixbuf(gspca_dev, 0xe0, sensor_data[sd->sensor].data2,
-                        sizeof sensor_data[sd->sensor].data2);
+        reg_w_ixbuf(gspca_dev, 0xd0, sensor->data1, sizeof sensor->data1);
+        reg_w_ixbuf(gspca_dev, 0xc7, sensor->data2, sizeof sensor->data2);
+        reg_w_ixbuf(gspca_dev, 0xe0, sensor->data3, sizeof sensor->data3);
 
         return 0;
 }
@@ -828,7 +834,6 @@ static void setlightfreq(struct gspca_dev *gspca_dev)
  * i added some module parameters for test with some users */
 static void poll_sensor(struct gspca_dev *gspca_dev)
 {
-        struct sd *sd = (struct sd *) gspca_dev;
         static const u8 poll1[] =
                 {0x67, 0x05, 0x68, 0x81, 0x69, 0x80, 0x6a, 0x82,
                  0x6b, 0x68, 0x6c, 0x69, 0x72, 0xd9, 0x73, 0x34,
@@ -844,24 +849,23 @@ static void poll_sensor(struct gspca_dev *gspca_dev)
                  0xa1, 0xb1, 0xda, 0x6b, 0xdb, 0x98, 0xdf, 0x0c,
                  0xc2, 0x80, 0xc3, 0x10};
 
-        if (sd->sensor == SENSOR_OM6802) {
-                PDEBUG(D_STREAM, "[Sensor requires polling]");
-                reg_w_buf(gspca_dev, poll1, sizeof poll1);
-                reg_w_buf(gspca_dev, poll2, sizeof poll2);
-                reg_w_buf(gspca_dev, poll3, sizeof poll3);
-                reg_w_buf(gspca_dev, poll4, sizeof poll4);
-        }
+        PDEBUG(D_STREAM, "[Sensor requires polling]");
+        reg_w_buf(gspca_dev, poll1, sizeof poll1);
+        reg_w_buf(gspca_dev, poll2, sizeof poll2);
+        reg_w_buf(gspca_dev, poll3, sizeof poll3);
+        reg_w_buf(gspca_dev, poll4, sizeof poll4);
 }
 
 static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        const struct additional_sensor_data *sensor;
         int i, mode;
         u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 };
         static const u8 t3[] =
                 { 0x07, 0x00, 0x88, 0x02, 0x06, 0x00, 0xe7, 0x01 };
 
-        mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode]. priv;
+        mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
         switch (mode) {
         case 0:         /* 640x480 (0x00) */
                 break;
@@ -889,34 +893,33 @@ static int sd_start(struct gspca_dev *gspca_dev)
         default:
 /*      case SENSOR_TAS5130A: */
                 i = 0;
-                while (tas5130a_sensor_init[i][0] != 0) {
+                for (;;) {
                         reg_w_buf(gspca_dev, tas5130a_sensor_init[i],
                                          sizeof tas5130a_sensor_init[0]);
+                        if (i >= ARRAY_SIZE(tas5130a_sensor_init) - 1)
+                                break;
                         i++;
                 }
                 reg_w(gspca_dev, 0x3c80);
                 /* just in case and to keep sync with logs (for mine) */
-                reg_w_buf(gspca_dev, tas5130a_sensor_init[3],
+                reg_w_buf(gspca_dev, tas5130a_sensor_init[i],
                                  sizeof tas5130a_sensor_init[0]);
                 reg_w(gspca_dev, 0x3c80);
                 break;
         }
-        reg_w_buf(gspca_dev, sensor_data[sd->sensor].data4,
-                        sizeof sensor_data[sd->sensor].data4);
+        sensor = &sensor_data[sd->sensor];
+        reg_w_buf(gspca_dev, sensor->data4, sizeof sensor->data4);
         reg_r(gspca_dev, 0x0012);
         reg_w_buf(gspca_dev, t2, sizeof t2);
         reg_w_ixbuf(gspca_dev, 0xb3, t3, sizeof t3);
         reg_w(gspca_dev, 0x0013);
         msleep(15);
-        reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
-                        sizeof sensor_data[sd->sensor].stream);
-        poll_sensor(gspca_dev);
+        reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream);
+        reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream);
+
+        if (sd->sensor == SENSOR_OM6802)
+                poll_sensor(gspca_dev);
 
-        /* restart on each start, just in case, sometimes regs goes wrong
-         * when using controls from app */
-        setbrightness(gspca_dev);
-        setcontrast(gspca_dev);
-        setcolors(gspca_dev);
         return 0;
 }
 
@@ -926,10 +929,9 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
 
         reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
                         sizeof sensor_data[sd->sensor].stream);
-        msleep(20);
         reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
                         sizeof sensor_data[sd->sensor].stream);
-        if (sd->sensor != SENSOR_OTHER) {
+        if (sd->sensor == SENSOR_OM6802) {
                 msleep(20);
                 reg_w(gspca_dev, 0x0309);
         }
diff --git a/drivers/media/video/gspca/tv8532.c b/drivers/media/video/gspca/tv8532.c
index 9f243d7e3110..4b44dde9f8b8 100644
--- a/drivers/media/video/gspca/tv8532.c
+++ b/drivers/media/video/gspca/tv8532.c
@@ -426,7 +426,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         gspca_frame_add(gspca_dev, packet_type0,
                         frame, data + 2, gspca_dev->width);
         gspca_frame_add(gspca_dev, packet_type1,
-                        frame, data + gspca_dev->width + 6, gspca_dev->width);
+                        frame, data + gspca_dev->width + 5, gspca_dev->width);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
diff --git a/drivers/media/video/gspca/vc032x.c b/drivers/media/video/gspca/vc032x.c
index 26dd155efcc3..619250e70718 100644
--- a/drivers/media/video/gspca/vc032x.c
+++ b/drivers/media/video/gspca/vc032x.c
@@ -32,14 +32,14 @@ MODULE_LICENSE("GPL");
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
 
-        __u8 hflip;
-        __u8 vflip;
-        __u8 lightfreq;
-        __u8 sharpness;
+        u8 hflip;
+        u8 vflip;
+        u8 lightfreq;
+        u8 sharpness;
 
         u8 image_offset;
 
-        char bridge;
+        u8 bridge;
 #define BRIDGE_VC0321 0
 #define BRIDGE_VC0323 1
         u8 sensor;
@@ -52,6 +52,10 @@ struct sd {
 #define SENSOR_OV7670 6
 #define SENSOR_PO1200 7
 #define SENSOR_PO3130NC 8
+        u8 flags;
+#define FL_SAMSUNG 0x01         /* SamsungQ1 (2 sensors) */
+#define FL_HFLIP 0x02           /* mirrored by default */
+#define FL_VFLIP 0x04           /* vertical flipped by default */
 };
 
 /* V4L2 controls supported by the driver */
@@ -65,7 +69,7 @@ static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
 
 static struct ctrl sd_ctrls[] = {
-/* next 2 controls work with ov7660 and ov7670 only */
+/* next 2 controls work with some sensors only */
 #define HFLIP_IDX 0
         {
             {
@@ -152,9 +156,9 @@ static const struct v4l2_pix_format vc0323_mode[] = {
                 .sizeimage = 640 * 480 * 3 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 0},
-        {1280, 1024, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, /* mi13x0_soc only */
+        {1280, 960, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, /* mi1310_soc only */
                 .bytesperline = 1280,
-                .sizeimage = 1280 * 1024 * 1 / 4 + 590,
+                .sizeimage = 1280 * 960 * 3 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 2},
 };
@@ -188,11 +192,11 @@ static const struct v4l2_pix_format svga_mode[] = {
 #define OV7660_MVFP_MIRROR      0x20
 #define OV7660_MVFP_VFLIP       0x10
 
-static const __u8 mi0360_matrix[9] = {
+static const u8 mi0360_matrix[9] = {
         0x50, 0xf8, 0xf8, 0xf5, 0x50, 0xfb, 0xff, 0xf1, 0x50
 };
 
-static const __u8 mi0360_initVGA_JPG[][4] = {
+static const u8 mi0360_initVGA_JPG[][4] = {
         {0xb0, 0x03, 0x19, 0xcc},
         {0xb0, 0x04, 0x02, 0xcc},
         {0xb3, 0x00, 0x24, 0xcc},
@@ -301,7 +305,7 @@ static const __u8 mi0360_initVGA_JPG[][4] = {
         {0xb3, 0x5c, 0x01, 0xcc},
         {}
 };
-static const __u8 mi0360_initQVGA_JPG[][4] = {
+static const u8 mi0360_initQVGA_JPG[][4] = {
         {0xb0, 0x03, 0x19, 0xcc},
         {0xb0, 0x04, 0x02, 0xcc},
         {0xb3, 0x00, 0x24, 0xcc},
@@ -421,211 +425,95 @@ static const __u8 mi0360_initQVGA_JPG[][4] = {
         {}
 };
 
-static const __u8 mi1310_socinitVGA_JPG[][4] = {
+static const u8 mi1310_socinitVGA_JPG[][4] = {
         {0xb0, 0x03, 0x19, 0xcc},
         {0xb0, 0x04, 0x02, 0xcc},
-        {0xb3, 0x00, 0x24, 0xcc},
-        {0xb3, 0x00, 0x25, 0xcc},
-        {0xb3, 0x05, 0x01, 0xcc},
-        {0xb3, 0x06, 0x03, 0xcc},
-        {0xb3, 0x5c, 0x01, 0xcc},
+        {0xb3, 0x00, 0x64, 0xcc},
+        {0xb3, 0x00, 0x65, 0xcc},
+        {0xb3, 0x05, 0x00, 0xcc},
+        {0xb3, 0x06, 0x00, 0xcc},
         {0xb3, 0x08, 0x01, 0xcc},
         {0xb3, 0x09, 0x0c, 0xcc},
         {0xb3, 0x34, 0x02, 0xcc},
         {0xb3, 0x35, 0xdd, 0xcc},
+        {0xb3, 0x02, 0x00, 0xcc},
         {0xb3, 0x03, 0x0a, 0xcc},
-        {0xb3, 0x04, 0x0d, 0xcc},
+        {0xb3, 0x04, 0x05, 0xcc},
         {0xb3, 0x20, 0x00, 0xcc},
         {0xb3, 0x21, 0x00, 0xcc},
-        {0xb3, 0x22, 0x01, 0xcc},
-        {0xb3, 0x23, 0xe0, 0xcc},
+        {0xb3, 0x22, 0x03, 0xcc},
+        {0xb3, 0x23, 0xc0, 0xcc},
         {0xb3, 0x14, 0x00, 0xcc},
         {0xb3, 0x15, 0x00, 0xcc},
-        {0xb3, 0x16, 0x02, 0xcc},
-        {0xb3, 0x17, 0x7f, 0xcc},
-        {0xb8, 0x01, 0x7d, 0xcc},
-        {0xb8, 0x81, 0x09, 0xcc},
-        {0xb8, 0x27, 0x20, 0xcc},
-        {0xb8, 0x26, 0x80, 0xcc},
-        {0xb3, 0x00, 0x25, 0xcc},
-        {0xb8, 0x00, 0x13, 0xcc},
-        {0xbc, 0x00, 0x71, 0xcc},
-        {0xb8, 0x81, 0x01, 0xcc},
-        {0xb8, 0x2c, 0x5a, 0xcc},
-        {0xb8, 0x2d, 0xff, 0xcc},
-        {0xb8, 0x2e, 0xee, 0xcc},
-        {0xb8, 0x2f, 0xfb, 0xcc},
-        {0xb8, 0x30, 0x52, 0xcc},
-        {0xb8, 0x31, 0xf8, 0xcc},
-        {0xb8, 0x32, 0xf1, 0xcc},
-        {0xb8, 0x33, 0xff, 0xcc},
-        {0xb8, 0x34, 0x54, 0xcc},
-        {0xb8, 0x35, 0x00, 0xcc},
-        {0xb8, 0x36, 0x00, 0xcc},
-        {0xb8, 0x37, 0x00, 0xcc},
+        {0xb3, 0x16, 0x04, 0xcc},
+        {0xb3, 0x17, 0xff, 0xcc},
+        {0xb3, 0x00, 0x65, 0xcc},
+        {0xb8, 0x00, 0x00, 0xcc},
+        {0xbc, 0x00, 0xd0, 0xcc},
+        {0xbc, 0x01, 0x01, 0xcc},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0xc8, 0x9f, 0x0b, 0xbb},
+        {0x5b, 0x00, 0x01, 0xbb},
+        {0x2f, 0xde, 0x20, 0xbb},
         {0xf0, 0x00, 0x00, 0xbb},
-        {0x00, 0x01, 0x00, 0xdd},
-        {0x0d, 0x00, 0x09, 0xbb},
-        {0x0d, 0x00, 0x08, 0xbb},
+        {0x20, 0x03, 0x02, 0xbb},       /* h/v flip */
         {0xf0, 0x00, 0x01, 0xbb},
-        {0x00, 0x01, 0x00, 0xdd},
-        {0x06, 0x00, 0x14, 0xbb},
-        {0x3a, 0x10, 0x00, 0xbb},
-        {0x00, 0x00, 0x10, 0xdd},
-        {0x9b, 0x10, 0x00, 0xbb},
-        {0x00, 0x00, 0x10, 0xdd},
+        {0x05, 0x00, 0x07, 0xbb},
+        {0x34, 0x00, 0x00, 0xbb},
+        {0x35, 0xff, 0x00, 0xbb},
+        {0xdc, 0x07, 0x02, 0xbb},
+        {0xdd, 0x3c, 0x18, 0xbb},
+        {0xde, 0x92, 0x6d, 0xbb},
+        {0xdf, 0xcd, 0xb1, 0xbb},
+        {0xe0, 0xff, 0xe7, 0xbb},
+        {0x06, 0xf0, 0x0d, 0xbb},
+        {0x06, 0x70, 0x0e, 0xbb},
+        {0x4c, 0x00, 0x01, 0xbb},
+        {0x4d, 0x00, 0x01, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x2e, 0x0c, 0x55, 0xbb},
+        {0x21, 0xb6, 0x6e, 0xbb},
+        {0x36, 0x30, 0x10, 0xbb},
+        {0x37, 0x00, 0xc1, 0xbb},
         {0xf0, 0x00, 0x00, 0xbb},
-        {0x00, 0x01, 0x00, 0xdd},
-        {0x2b, 0x00, 0x28, 0xbb},
-        {0x2c, 0x00, 0x30, 0xbb},
-        {0x2d, 0x00, 0x30, 0xbb},
-        {0x2e, 0x00, 0x28, 0xbb},
-        {0x41, 0x00, 0xd7, 0xbb},
-        {0x09, 0x02, 0x3a, 0xbb},
-        {0x0c, 0x00, 0x00, 0xbb},
-        {0x20, 0x00, 0x00, 0xbb},
-        {0x05, 0x00, 0x8c, 0xbb},
-        {0x06, 0x00, 0x32, 0xbb},
-        {0x07, 0x00, 0xc6, 0xbb},
-        {0x08, 0x00, 0x19, 0xbb},
-        {0x24, 0x80, 0x6f, 0xbb},
-        {0xc8, 0x00, 0x0f, 0xbb},
-        {0x20, 0x00, 0x0f, 0xbb},
+        {0x07, 0x00, 0x84, 0xbb},
+        {0x08, 0x02, 0x4a, 0xbb},
+        {0x05, 0x01, 0x10, 0xbb},
+        {0x06, 0x00, 0x39, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x58, 0x02, 0x67, 0xbb},
+        {0x57, 0x02, 0x00, 0xbb},
+        {0x5a, 0x02, 0x67, 0xbb},
+        {0x59, 0x02, 0x00, 0xbb},
+        {0x5c, 0x12, 0x0d, 0xbb},
+        {0x5d, 0x16, 0x11, 0xbb},
+        {0x39, 0x06, 0x18, 0xbb},
+        {0x3a, 0x06, 0x18, 0xbb},
+        {0x3b, 0x06, 0x18, 0xbb},
+        {0x3c, 0x06, 0x18, 0xbb},
+        {0x64, 0x7b, 0x5b, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x36, 0x30, 0x10, 0xbb},
+        {0x37, 0x00, 0xc0, 0xbb},
+        {0xbc, 0x0e, 0x00, 0xcc},
+        {0xbc, 0x0f, 0x05, 0xcc},
+        {0xbc, 0x10, 0xc0, 0xcc},
+        {0xbc, 0x11, 0x03, 0xcc},
         {0xb6, 0x00, 0x00, 0xcc},
         {0xb6, 0x03, 0x02, 0xcc},
         {0xb6, 0x02, 0x80, 0xcc},
         {0xb6, 0x05, 0x01, 0xcc},
         {0xb6, 0x04, 0xe0, 0xcc},
-        {0xb6, 0x12, 0x78, 0xcc},
+        {0xb6, 0x12, 0xf8, 0xcc},
+        {0xb6, 0x13, 0x25, 0xcc},
         {0xb6, 0x18, 0x02, 0xcc},
         {0xb6, 0x17, 0x58, 0xcc},
         {0xb6, 0x16, 0x00, 0xcc},
         {0xb6, 0x22, 0x12, 0xcc},
         {0xb6, 0x23, 0x0b, 0xcc},
-        {0xb3, 0x02, 0x02, 0xcc},
-        {0xbf, 0xc0, 0x39, 0xcc},
-        {0xbf, 0xc1, 0x04, 0xcc},
-        {0xbf, 0xcc, 0x10, 0xcc},
-        {0xb9, 0x12, 0x00, 0xcc},
-        {0xb9, 0x13, 0x0a, 0xcc},
-        {0xb9, 0x14, 0x0a, 0xcc},
-        {0xb9, 0x15, 0x0a, 0xcc},
-        {0xb9, 0x16, 0x0a, 0xcc},
-        {0xb9, 0x18, 0x00, 0xcc},
-        {0xb9, 0x19, 0x0f, 0xcc},
-        {0xb9, 0x1a, 0x0f, 0xcc},
-        {0xb9, 0x1b, 0x0f, 0xcc},
-        {0xb9, 0x1c, 0x0f, 0xcc},
-        {0xb8, 0x8e, 0x00, 0xcc},
-        {0xb8, 0x8f, 0xff, 0xcc},
-        {0xb3, 0x01, 0x41, 0xcc},
-        {0x03, 0x03, 0xc0, 0xbb},
-        {0x06, 0x00, 0x10, 0xbb},
-        {0xb6, 0x12, 0xf8, 0xcc},
-        {0xb8, 0x0c, 0x20, 0xcc},
-        {0xb8, 0x0d, 0x70, 0xcc},
-        {0xb6, 0x13, 0x13, 0xcc},
-        {0x2f, 0x00, 0xC0, 0xbb},
-        {0xb8, 0xa0, 0x12, 0xcc},
-        {},
-};
-static const __u8 mi1310_socinitQVGA_JPG[][4] = {
-        {0xb0, 0x03, 0x19, 0xcc},
-        {0xb0, 0x04, 0x02, 0xcc},
-        {0xb3, 0x00, 0x24, 0xcc},
-        {0xb3, 0x00, 0x25, 0xcc},
-        {0xb3, 0x05, 0x01, 0xcc},
-        {0xb3, 0x06, 0x03, 0xcc},
-        {0xb3, 0x5c, 0x01, 0xcc},
-        {0xb3, 0x08, 0x01, 0xcc},
-        {0xb3, 0x09, 0x0c, 0xcc},
-        {0xb3, 0x34, 0x02, 0xcc},
-        {0xb3, 0x35, 0xdd, 0xcc},
-        {0xb3, 0x03, 0x0a, 0xcc},
-        {0xb3, 0x04, 0x0d, 0xcc},
-        {0xb3, 0x20, 0x00, 0xcc},
-        {0xb3, 0x21, 0x00, 0xcc},
-        {0xb3, 0x22, 0x01, 0xcc},
-        {0xb3, 0x23, 0xe0, 0xcc},
-        {0xb3, 0x14, 0x00, 0xcc},
-        {0xb3, 0x15, 0x00, 0xcc},
-        {0xb3, 0x16, 0x02, 0xcc},
-        {0xb3, 0x17, 0x7f, 0xcc},
-        {0xb8, 0x01, 0x7d, 0xcc},
-        {0xb8, 0x81, 0x09, 0xcc},
-        {0xb8, 0x27, 0x20, 0xcc},
-        {0xb8, 0x26, 0x80, 0xcc},
-        {0xb3, 0x00, 0x25, 0xcc},
-        {0xb8, 0x00, 0x13, 0xcc},
-        {0xbc, 0x00, 0xd1, 0xcc},
-        {0xb8, 0x81, 0x01, 0xcc},
-        {0xb8, 0x2c, 0x5a, 0xcc},
-        {0xb8, 0x2d, 0xff, 0xcc},
-        {0xb8, 0x2e, 0xee, 0xcc},
-        {0xb8, 0x2f, 0xfb, 0xcc},
-        {0xb8, 0x30, 0x52, 0xcc},
-        {0xb8, 0x31, 0xf8, 0xcc},
-        {0xb8, 0x32, 0xf1, 0xcc},
-        {0xb8, 0x33, 0xff, 0xcc},
-        {0xb8, 0x34, 0x54, 0xcc},
-        {0xb8, 0x35, 0x00, 0xcc},
-        {0xb8, 0x36, 0x00, 0xcc},
-        {0xb8, 0x37, 0x00, 0xcc},
-        {0xf0, 0x00, 0x00, 0xbb},
-        {0x00, 0x01, 0x00, 0xdd},
-        {0x0d, 0x00, 0x09, 0xbb},
-        {0x0d, 0x00, 0x08, 0xbb},
-        {0xf0, 0x00, 0x01, 0xbb},
-        {0x00, 0x01, 0x00, 0xdd},
-        {0x06, 0x00, 0x14, 0xbb},
-        {0x3a, 0x10, 0x00, 0xbb},
-        {0x00, 0x00, 0x10, 0xdd},
-        {0x9b, 0x10, 0x00, 0xbb},
-        {0x00, 0x00, 0x10, 0xdd},
-        {0xf0, 0x00, 0x00, 0xbb},
-        {0x00, 0x01, 0x00, 0xdd},
-        {0x2b, 0x00, 0x28, 0xbb},
-        {0x2c, 0x00, 0x30, 0xbb},
-        {0x2d, 0x00, 0x30, 0xbb},
-        {0x2e, 0x00, 0x28, 0xbb},
-        {0x41, 0x00, 0xd7, 0xbb},
-        {0x09, 0x02, 0x3a, 0xbb},
-        {0x0c, 0x00, 0x00, 0xbb},
-        {0x20, 0x00, 0x00, 0xbb},
-        {0x05, 0x00, 0x8c, 0xbb},
-        {0x06, 0x00, 0x32, 0xbb},
-        {0x07, 0x00, 0xc6, 0xbb},
-        {0x08, 0x00, 0x19, 0xbb},
-        {0x24, 0x80, 0x6f, 0xbb},
-        {0xc8, 0x00, 0x0f, 0xbb},
-        {0x20, 0x00, 0x0f, 0xbb},
-        {0xb6, 0x00, 0x00, 0xcc},
-        {0xb6, 0x03, 0x01, 0xcc},
-        {0xb6, 0x02, 0x40, 0xcc},
-        {0xb6, 0x05, 0x00, 0xcc},
-        {0xb6, 0x04, 0xf0, 0xcc},
-        {0xb6, 0x12, 0x78, 0xcc},
-        {0xb6, 0x18, 0x00, 0xcc},
-        {0xb6, 0x17, 0x96, 0xcc},
-        {0xb6, 0x16, 0x00, 0xcc},
-        {0xb6, 0x22, 0x12, 0xcc},
-        {0xb6, 0x23, 0x0b, 0xcc},
-        {0xb3, 0x02, 0x02, 0xcc},
         {0xbf, 0xc0, 0x39, 0xcc},
         {0xbf, 0xc1, 0x04, 0xcc},
-        {0xbf, 0xcc, 0x10, 0xcc},
-        {0xb9, 0x12, 0x00, 0xcc},
-        {0xb9, 0x13, 0x0a, 0xcc},
-        {0xb9, 0x14, 0x0a, 0xcc},
-        {0xb9, 0x15, 0x0a, 0xcc},
-        {0xb9, 0x16, 0x0a, 0xcc},
-        {0xb9, 0x18, 0x00, 0xcc},
-        {0xb9, 0x19, 0x0f, 0xcc},
-        {0xb9, 0x1a, 0x0f, 0xcc},
-        {0xb9, 0x1b, 0x0f, 0xcc},
-        {0xb9, 0x1c, 0x0f, 0xcc},
-        {0xb8, 0x8e, 0x00, 0xcc},
-        {0xb8, 0x8f, 0xff, 0xcc},
+        {0xbf, 0xcc, 0x00, 0xcc},
         {0xbc, 0x02, 0x18, 0xcc},
         {0xbc, 0x03, 0x50, 0xcc},
         {0xbc, 0x04, 0x18, 0xcc},
@@ -636,133 +524,335 @@ static const __u8 mi1310_socinitQVGA_JPG[][4] = {
         {0xbc, 0x0a, 0x10, 0xcc},
         {0xbc, 0x0b, 0x00, 0xcc},
         {0xbc, 0x0c, 0x00, 0xcc},
+        {0xb3, 0x5c, 0x01, 0xcc},
+        {0xf0, 0x00, 0x01, 0xbb},
+        {0x80, 0x00, 0x03, 0xbb},
+        {0x81, 0xc7, 0x14, 0xbb},
+        {0x82, 0xeb, 0xe8, 0xbb},
+        {0x83, 0xfe, 0xf4, 0xbb},
+        {0x84, 0xcd, 0x10, 0xbb},
+        {0x85, 0xf3, 0xee, 0xbb},
+        {0x86, 0xff, 0xf1, 0xbb},
+        {0x87, 0xcd, 0x10, 0xbb},
+        {0x88, 0xf3, 0xee, 0xbb},
+        {0x89, 0x01, 0xf1, 0xbb},
+        {0x8a, 0xe5, 0x17, 0xbb},
+        {0x8b, 0xe8, 0xe2, 0xbb},
+        {0x8c, 0xf7, 0xed, 0xbb},
+        {0x8d, 0x00, 0xff, 0xbb},
+        {0x8e, 0xec, 0x10, 0xbb},
+        {0x8f, 0xf0, 0xed, 0xbb},
+        {0x90, 0xf9, 0xf2, 0xbb},
+        {0x91, 0x00, 0x00, 0xbb},
+        {0x92, 0xe9, 0x0d, 0xbb},
+        {0x93, 0xf4, 0xf2, 0xbb},
+        {0x94, 0xfb, 0xf5, 0xbb},
+        {0x95, 0x00, 0xff, 0xbb},
+        {0xb6, 0x0f, 0x08, 0xbb},
+        {0xb7, 0x3d, 0x16, 0xbb},
+        {0xb8, 0x0c, 0x04, 0xbb},
+        {0xb9, 0x1c, 0x07, 0xbb},
+        {0xba, 0x0a, 0x03, 0xbb},
+        {0xbb, 0x1b, 0x09, 0xbb},
+        {0xbc, 0x17, 0x0d, 0xbb},
+        {0xbd, 0x23, 0x1d, 0xbb},
+        {0xbe, 0x00, 0x28, 0xbb},
+        {0xbf, 0x11, 0x09, 0xbb},
+        {0xc0, 0x16, 0x15, 0xbb},
+        {0xc1, 0x00, 0x1b, 0xbb},
+        {0xc2, 0x0e, 0x07, 0xbb},
+        {0xc3, 0x14, 0x10, 0xbb},
+        {0xc4, 0x00, 0x17, 0xbb},
+        {0x06, 0x74, 0x8e, 0xbb},
+        {0xf0, 0x00, 0x01, 0xbb},
+        {0x06, 0xf4, 0x8e, 0xbb},
+        {0x00, 0x00, 0x50, 0xdd},
+        {0x06, 0x74, 0x8e, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x24, 0x50, 0x20, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x34, 0x0c, 0x50, 0xbb},
         {0xb3, 0x01, 0x41, 0xcc},
+        {0xf0, 0x00, 0x00, 0xbb},
+        {0x03, 0x03, 0xc0, 0xbb},
+        {},
+};
+static const u8 mi1310_socinitQVGA_JPG[][4] = {
+        {0xb0, 0x03, 0x19, 0xcc},       {0xb0, 0x04, 0x02, 0xcc},
+        {0xb3, 0x00, 0x64, 0xcc},       {0xb3, 0x00, 0x65, 0xcc},
+        {0xb3, 0x05, 0x00, 0xcc},       {0xb3, 0x06, 0x00, 0xcc},
+        {0xb3, 0x08, 0x01, 0xcc},       {0xb3, 0x09, 0x0c, 0xcc},
+        {0xb3, 0x34, 0x02, 0xcc},       {0xb3, 0x35, 0xdd, 0xcc},
+        {0xb3, 0x02, 0x00, 0xcc},       {0xb3, 0x03, 0x0a, 0xcc},
+        {0xb3, 0x04, 0x05, 0xcc},       {0xb3, 0x20, 0x00, 0xcc},
+        {0xb3, 0x21, 0x00, 0xcc},       {0xb3, 0x22, 0x03, 0xcc},
+        {0xb3, 0x23, 0xc0, 0xcc},       {0xb3, 0x14, 0x00, 0xcc},
+        {0xb3, 0x15, 0x00, 0xcc},       {0xb3, 0x16, 0x04, 0xcc},
+        {0xb3, 0x17, 0xff, 0xcc},       {0xb3, 0x00, 0x65, 0xcc},
+        {0xb8, 0x00, 0x00, 0xcc},       {0xbc, 0x00, 0xf0, 0xcc},
+        {0xbc, 0x01, 0x01, 0xcc},       {0xf0, 0x00, 0x02, 0xbb},
+        {0xc8, 0x9f, 0x0b, 0xbb},       {0x5b, 0x00, 0x01, 0xbb},
+        {0x2f, 0xde, 0x20, 0xbb},       {0xf0, 0x00, 0x00, 0xbb},
+        {0x20, 0x03, 0x02, 0xbb},       /* h/v flip */
+        {0xf0, 0x00, 0x01, 0xbb},
+        {0x05, 0x00, 0x07, 0xbb},       {0x34, 0x00, 0x00, 0xbb},
+        {0x35, 0xff, 0x00, 0xbb},       {0xdc, 0x07, 0x02, 0xbb},
+        {0xdd, 0x3c, 0x18, 0xbb},       {0xde, 0x92, 0x6d, 0xbb},
+        {0xdf, 0xcd, 0xb1, 0xbb},       {0xe0, 0xff, 0xe7, 0xbb},
+        {0x06, 0xf0, 0x0d, 0xbb},       {0x06, 0x70, 0x0e, 0xbb},
+        {0x4c, 0x00, 0x01, 0xbb},       {0x4d, 0x00, 0x01, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},       {0x2e, 0x0c, 0x55, 0xbb},
+        {0x21, 0xb6, 0x6e, 0xbb},       {0x36, 0x30, 0x10, 0xbb},
+        {0x37, 0x00, 0xc1, 0xbb},       {0xf0, 0x00, 0x00, 0xbb},
+        {0x07, 0x00, 0x84, 0xbb},       {0x08, 0x02, 0x4a, 0xbb},
+        {0x05, 0x01, 0x10, 0xbb},       {0x06, 0x00, 0x39, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},       {0x58, 0x02, 0x67, 0xbb},
+        {0x57, 0x02, 0x00, 0xbb},       {0x5a, 0x02, 0x67, 0xbb},
+        {0x59, 0x02, 0x00, 0xbb},       {0x5c, 0x12, 0x0d, 0xbb},
+        {0x5d, 0x16, 0x11, 0xbb},       {0x39, 0x06, 0x18, 0xbb},
+        {0x3a, 0x06, 0x18, 0xbb},       {0x3b, 0x06, 0x18, 0xbb},
+        {0x3c, 0x06, 0x18, 0xbb},       {0x64, 0x7b, 0x5b, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},       {0x36, 0x30, 0x10, 0xbb},
+        {0x37, 0x00, 0xc0, 0xbb},       {0xbc, 0x0e, 0x00, 0xcc},
+        {0xbc, 0x0f, 0x05, 0xcc},       {0xbc, 0x10, 0xc0, 0xcc},
+        {0xbc, 0x11, 0x03, 0xcc},       {0xb6, 0x00, 0x00, 0xcc},
+        {0xb6, 0x03, 0x01, 0xcc},       {0xb6, 0x02, 0x40, 0xcc},
+        {0xb6, 0x05, 0x00, 0xcc},       {0xb6, 0x04, 0xf0, 0xcc},
+        {0xb6, 0x12, 0xf8, 0xcc},       {0xb6, 0x13, 0x25, 0xcc},
+        {0xb6, 0x18, 0x00, 0xcc},       {0xb6, 0x17, 0x96, 0xcc},
+        {0xb6, 0x16, 0x00, 0xcc},       {0xb6, 0x22, 0x12, 0xcc},
+        {0xb6, 0x23, 0x0b, 0xcc},       {0xbf, 0xc0, 0x39, 0xcc},
+        {0xbf, 0xc1, 0x04, 0xcc},       {0xbf, 0xcc, 0x00, 0xcc},
+        {0xb3, 0x5c, 0x01, 0xcc},       {0xf0, 0x00, 0x01, 0xbb},
+        {0x80, 0x00, 0x03, 0xbb},       {0x81, 0xc7, 0x14, 0xbb},
+        {0x82, 0xeb, 0xe8, 0xbb},       {0x83, 0xfe, 0xf4, 0xbb},
+        {0x84, 0xcd, 0x10, 0xbb},       {0x85, 0xf3, 0xee, 0xbb},
+        {0x86, 0xff, 0xf1, 0xbb},       {0x87, 0xcd, 0x10, 0xbb},
+        {0x88, 0xf3, 0xee, 0xbb},       {0x89, 0x01, 0xf1, 0xbb},
+        {0x8a, 0xe5, 0x17, 0xbb},       {0x8b, 0xe8, 0xe2, 0xbb},
+        {0x8c, 0xf7, 0xed, 0xbb},       {0x8d, 0x00, 0xff, 0xbb},
+        {0x8e, 0xec, 0x10, 0xbb},       {0x8f, 0xf0, 0xed, 0xbb},
+        {0x90, 0xf9, 0xf2, 0xbb},       {0x91, 0x00, 0x00, 0xbb},
+        {0x92, 0xe9, 0x0d, 0xbb},       {0x93, 0xf4, 0xf2, 0xbb},
+        {0x94, 0xfb, 0xf5, 0xbb},       {0x95, 0x00, 0xff, 0xbb},
+        {0xb6, 0x0f, 0x08, 0xbb},       {0xb7, 0x3d, 0x16, 0xbb},
+        {0xb8, 0x0c, 0x04, 0xbb},       {0xb9, 0x1c, 0x07, 0xbb},
+        {0xba, 0x0a, 0x03, 0xbb},       {0xbb, 0x1b, 0x09, 0xbb},
+        {0xbc, 0x17, 0x0d, 0xbb},       {0xbd, 0x23, 0x1d, 0xbb},
+        {0xbe, 0x00, 0x28, 0xbb},       {0xbf, 0x11, 0x09, 0xbb},
+        {0xc0, 0x16, 0x15, 0xbb},       {0xc1, 0x00, 0x1b, 0xbb},
+        {0xc2, 0x0e, 0x07, 0xbb},       {0xc3, 0x14, 0x10, 0xbb},
+        {0xc4, 0x00, 0x17, 0xbb},       {0x06, 0x74, 0x8e, 0xbb},
+        {0xf0, 0x00, 0x01, 0xbb},       {0x06, 0xf4, 0x8e, 0xbb},
+        {0x00, 0x00, 0x50, 0xdd},       {0x06, 0x74, 0x8e, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},       {0x24, 0x50, 0x20, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},       {0x34, 0x0c, 0x50, 0xbb},
+        {0xb3, 0x01, 0x41, 0xcc},       {0xf0, 0x00, 0x00, 0xbb},
         {0x03, 0x03, 0xc0, 0xbb},
-        {0x06, 0x00, 0x10, 0xbb},
-        {0xb6, 0x12, 0xf8, 0xcc},
-        {0xb8, 0x0c, 0x20, 0xcc},
-        {0xb8, 0x0d, 0x70, 0xcc},
-        {0xb6, 0x13, 0x13, 0xcc},
-        {0x2f, 0x00, 0xC0, 0xbb},
-        {0xb8, 0xa0, 0x12, 0xcc},
         {},
 };
 static const u8 mi1310_soc_InitSXGA_JPG[][4] = {
         {0xb0, 0x03, 0x19, 0xcc},
         {0xb0, 0x04, 0x02, 0xcc},
-        {0xb3, 0x00, 0x24, 0xcc},
-        {0xb3, 0x00, 0x25, 0xcc},
+        {0xb3, 0x00, 0x64, 0xcc},
+        {0xb3, 0x00, 0x65, 0xcc},
         {0xb3, 0x05, 0x00, 0xcc},
-        {0xb3, 0x06, 0x01, 0xcc},
-        {0xb3, 0x5c, 0x01, 0xcc},
+        {0xb3, 0x06, 0x00, 0xcc},
         {0xb3, 0x08, 0x01, 0xcc},
         {0xb3, 0x09, 0x0c, 0xcc},
         {0xb3, 0x34, 0x02, 0xcc},
         {0xb3, 0x35, 0xdd, 0xcc},
+        {0xb3, 0x02, 0x00, 0xcc},
         {0xb3, 0x03, 0x0a, 0xcc},
         {0xb3, 0x04, 0x0d, 0xcc},
         {0xb3, 0x20, 0x00, 0xcc},
         {0xb3, 0x21, 0x00, 0xcc},
-        {0xb3, 0x22, 0x04, 0xcc},
-        {0xb3, 0x23, 0x00, 0xcc},
+        {0xb3, 0x22, 0x03, 0xcc},
+        {0xb3, 0x23, 0xc0, 0xcc},
         {0xb3, 0x14, 0x00, 0xcc},
         {0xb3, 0x15, 0x00, 0xcc},
         {0xb3, 0x16, 0x04, 0xcc},
         {0xb3, 0x17, 0xff, 0xcc},
-        {0xb8, 0x01, 0x7d, 0xcc},
-        {0xb8, 0x81, 0x09, 0xcc},
-        {0xb8, 0x27, 0x20, 0xcc},
-        {0xb8, 0x26, 0x80, 0xcc},
-        {0xb8, 0x06, 0x00, 0xcc},
-        {0xb8, 0x07, 0x05, 0xcc},
-        {0xb8, 0x08, 0x00, 0xcc},
-        {0xb8, 0x09, 0x04, 0xcc},
-        {0xb3, 0x00, 0x25, 0xcc},
-        {0xb8, 0x00, 0x11, 0xcc},
-        {0xbc, 0x00, 0x71, 0xcc},
-        {0xb8, 0x81, 0x01, 0xcc},
-        {0xb8, 0x2c, 0x5a, 0xcc},
-        {0xb8, 0x2d, 0xff, 0xcc},
-        {0xb8, 0x2e, 0xee, 0xcc},
-        {0xb8, 0x2f, 0xfb, 0xcc},
-        {0xb8, 0x30, 0x52, 0xcc},
-        {0xb8, 0x31, 0xf8, 0xcc},
-        {0xb8, 0x32, 0xf1, 0xcc},
-        {0xb8, 0x33, 0xff, 0xcc},
-        {0xb8, 0x34, 0x54, 0xcc},
+        {0xb3, 0x00, 0x65, 0xcc},
+        {0xb8, 0x00, 0x00, 0xcc},
+        {0xbc, 0x00, 0x70, 0xcc},
+        {0xbc, 0x01, 0x01, 0xcc},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0xc8, 0x9f, 0x0b, 0xbb},
+        {0x5b, 0x00, 0x01, 0xbb},
         {0xf0, 0x00, 0x00, 0xbb},
-        {0x00, 0x01, 0x00, 0xdd},
-        {0x0d, 0x00, 0x09, 0xbb},
-        {0x0d, 0x00, 0x08, 0xbb},
+        {0x20, 0x03, 0x02, 0xbb},       /* h/v flip */
         {0xf0, 0x00, 0x01, 0xbb},
-        {0x00, 0x01, 0x00, 0xdd},
-        {0x06, 0x00, 0x14, 0xbb},
-        {0x3a, 0x10, 0x00, 0xbb},
-        {0x00, 0x00, 0x10, 0xdd},
-        {0x9b, 0x10, 0x00, 0xbb},
-        {0x00, 0x00, 0x10, 0xdd},
+        {0x05, 0x00, 0x07, 0xbb},
+        {0x34, 0x00, 0x00, 0xbb},
+        {0x35, 0xff, 0x00, 0xbb},
+        {0xdc, 0x07, 0x02, 0xbb},
+        {0xdd, 0x3c, 0x18, 0xbb},
+        {0xde, 0x92, 0x6d, 0xbb},
+        {0xdf, 0xcd, 0xb1, 0xbb},
+        {0xe0, 0xff, 0xe7, 0xbb},
+        {0x06, 0xf0, 0x0d, 0xbb},
+        {0x06, 0x70, 0x0e, 0xbb},
+        {0x4c, 0x00, 0x01, 0xbb},
+        {0x4d, 0x00, 0x01, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x2e, 0x0c, 0x60, 0xbb},
+        {0x21, 0xb6, 0x6e, 0xbb},
+        {0x37, 0x01, 0x40, 0xbb},
         {0xf0, 0x00, 0x00, 0xbb},
-        {0x00, 0x01, 0x00, 0xdd},
-        {0x2b, 0x00, 0x28, 0xbb},
-        {0x2c, 0x00, 0x30, 0xbb},
-        {0x2d, 0x00, 0x30, 0xbb},
-        {0x2e, 0x00, 0x28, 0xbb},
-        {0x41, 0x00, 0xd7, 0xbb},
-        {0x09, 0x02, 0x3a, 0xbb},
-        {0x0c, 0x00, 0x00, 0xbb},
-        {0x20, 0x00, 0x00, 0xbb},
-        {0x05, 0x00, 0x8c, 0xbb},
-        {0x06, 0x00, 0x32, 0xbb},
-        {0x07, 0x00, 0xc6, 0xbb},
-        {0x08, 0x00, 0x19, 0xbb},
-        {0x24, 0x80, 0x6f, 0xbb},
-        {0xc8, 0x00, 0x0f, 0xbb},
-        {0x20, 0x00, 0x03, 0xbb},
+        {0x07, 0x00, 0x84, 0xbb},
+        {0x08, 0x02, 0x4a, 0xbb},
+        {0x05, 0x01, 0x10, 0xbb},
+        {0x06, 0x00, 0x39, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x58, 0x02, 0x67, 0xbb},
+        {0x57, 0x02, 0x00, 0xbb},
+        {0x5a, 0x02, 0x67, 0xbb},
+        {0x59, 0x02, 0x00, 0xbb},
+        {0x5c, 0x12, 0x0d, 0xbb},
+        {0x5d, 0x16, 0x11, 0xbb},
+        {0x39, 0x06, 0x18, 0xbb},
+        {0x3a, 0x06, 0x18, 0xbb},
+        {0x3b, 0x06, 0x18, 0xbb},
+        {0x3c, 0x06, 0x18, 0xbb},
+        {0x64, 0x7b, 0x5b, 0xbb},
         {0xb6, 0x00, 0x00, 0xcc},
         {0xb6, 0x03, 0x05, 0xcc},
         {0xb6, 0x02, 0x00, 0xcc},
-        {0xb6, 0x05, 0x04, 0xcc},
-        {0xb6, 0x04, 0x00, 0xcc},
+        {0xb6, 0x05, 0x03, 0xcc},
+        {0xb6, 0x04, 0xc0, 0xcc},
         {0xb6, 0x12, 0xf8, 0xcc},
-        {0xb6, 0x18, 0x0a, 0xcc},
-        {0xb6, 0x17, 0x00, 0xcc},
+        {0xb6, 0x13, 0x29, 0xcc},
+        {0xb6, 0x18, 0x09, 0xcc},
+        {0xb6, 0x17, 0x60, 0xcc},
         {0xb6, 0x16, 0x00, 0xcc},
         {0xb6, 0x22, 0x12, 0xcc},
         {0xb6, 0x23, 0x0b, 0xcc},
-        {0xb3, 0x02, 0x02, 0xcc},
         {0xbf, 0xc0, 0x39, 0xcc},
         {0xbf, 0xc1, 0x04, 0xcc},
-        {0xbf, 0xcc, 0x10, 0xcc},
-        {0xb9, 0x12, 0x00, 0xcc},
-        {0xb9, 0x13, 0x14, 0xcc},
-        {0xb9, 0x14, 0x14, 0xcc},
-        {0xb9, 0x15, 0x14, 0xcc},
-        {0xb9, 0x16, 0x14, 0xcc},
-        {0xb9, 0x18, 0x00, 0xcc},
-        {0xb9, 0x19, 0x1e, 0xcc},
-        {0xb9, 0x1a, 0x1e, 0xcc},
-        {0xb9, 0x1b, 0x1e, 0xcc},
-        {0xb9, 0x1c, 0x1e, 0xcc},
+        {0xbf, 0xcc, 0x00, 0xcc},
         {0xb3, 0x01, 0x41, 0xcc},
-        {0xb8, 0x8e, 0x00, 0xcc},
-        {0xb8, 0x8f, 0xff, 0xcc},
-        {0xb6, 0x12, 0xf8, 0xcc},
-        {0xb8, 0x0c, 0x20, 0xcc},
-        {0xb8, 0x0d, 0x70, 0xcc},
-        {0xb6, 0x13, 0x13, 0xcc},
-        {0x2f, 0x00, 0xC0, 0xbb},
-        {0xb8, 0xa0, 0x12, 0xcc},
+        {0x00, 0x00, 0x80, 0xdd},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x00, 0x00, 0x10, 0xdd},
+        {0x22, 0xa0, 0x78, 0xbb},
+        {0x23, 0xa0, 0x78, 0xbb},
+        {0x24, 0x7f, 0x00, 0xbb},
+        {0x28, 0xea, 0x02, 0xbb},
+        {0x29, 0x86, 0x7a, 0xbb},
+        {0x5e, 0x52, 0x4c, 0xbb},
+        {0x5f, 0x20, 0x24, 0xbb},
+        {0x60, 0x00, 0x02, 0xbb},
+        {0x02, 0x00, 0xee, 0xbb},
+        {0x03, 0x39, 0x23, 0xbb},
+        {0x04, 0x07, 0x24, 0xbb},
+        {0x09, 0x00, 0xc0, 0xbb},
+        {0x0a, 0x00, 0x79, 0xbb},
+        {0x0b, 0x00, 0x04, 0xbb},
+        {0x0c, 0x00, 0x5c, 0xbb},
+        {0x0d, 0x00, 0xd9, 0xbb},
+        {0x0e, 0x00, 0x53, 0xbb},
+        {0x0f, 0x00, 0x21, 0xbb},
+        {0x10, 0x00, 0xa4, 0xbb},
+        {0x11, 0x00, 0xe5, 0xbb},
+        {0x15, 0x00, 0x00, 0xbb},
+        {0x16, 0x00, 0x00, 0xbb},
+        {0x17, 0x00, 0x00, 0xbb},
+        {0x18, 0x00, 0x00, 0xbb},
+        {0x19, 0x00, 0x00, 0xbb},
+        {0x1a, 0x00, 0x00, 0xbb},
+        {0x1b, 0x00, 0x00, 0xbb},
+        {0x1c, 0x00, 0x00, 0xbb},
+        {0x1d, 0x00, 0x00, 0xbb},
+        {0x1e, 0x00, 0x00, 0xbb},
+        {0xf0, 0x00, 0x01, 0xbb},
+        {0x00, 0x00, 0x20, 0xdd},
+        {0x06, 0xf0, 0x8e, 0xbb},
+        {0x00, 0x00, 0x80, 0xdd},
+        {0x06, 0x70, 0x8e, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x00, 0x00, 0x20, 0xdd},
+        {0x5e, 0x6a, 0x53, 0xbb},
+        {0x5f, 0x40, 0x2c, 0xbb},
+        {0xf0, 0x00, 0x01, 0xbb},
+        {0x00, 0x00, 0x20, 0xdd},
+        {0x58, 0x00, 0x00, 0xbb},
+        {0x53, 0x09, 0x03, 0xbb},
+        {0x54, 0x31, 0x18, 0xbb},
+        {0x55, 0x8b, 0x5f, 0xbb},
+        {0x56, 0xc0, 0xa9, 0xbb},
+        {0x57, 0xe0, 0xd2, 0xbb},
+        {0xe1, 0x00, 0x00, 0xbb},
+        {0xdc, 0x09, 0x03, 0xbb},
+        {0xdd, 0x31, 0x18, 0xbb},
+        {0xde, 0x8b, 0x5f, 0xbb},
+        {0xdf, 0xc0, 0xa9, 0xbb},
+        {0xe0, 0xe0, 0xd2, 0xbb},
+        {0xb3, 0x5c, 0x01, 0xcc},
+        {0xf0, 0x00, 0x01, 0xbb},
+        {0x06, 0xf0, 0x8e, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x2f, 0xde, 0x20, 0xbb},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x24, 0x50, 0x20, 0xbb},
+        {0xbc, 0x0e, 0x00, 0xcc},
+        {0xbc, 0x0f, 0x05, 0xcc},
+        {0xbc, 0x10, 0xc0, 0xcc},
+        {0xf0, 0x00, 0x02, 0xbb},
+        {0x34, 0x0c, 0x50, 0xbb},
+        {0xbc, 0x11, 0x03, 0xcc},
+        {0xf0, 0x00, 0x01, 0xbb},
+        {0x80, 0x00, 0x03, 0xbb},
+        {0x81, 0xc7, 0x14, 0xbb},
+        {0x82, 0xeb, 0xe8, 0xbb},
+        {0x83, 0xfe, 0xf4, 0xbb},
+        {0x84, 0xcd, 0x10, 0xbb},
+        {0x85, 0xf3, 0xee, 0xbb},
+        {0x86, 0xff, 0xf1, 0xbb},
+        {0x87, 0xcd, 0x10, 0xbb},
+        {0x88, 0xf3, 0xee, 0xbb},
+        {0x89, 0x01, 0xf1, 0xbb},
+        {0x8a, 0xe5, 0x17, 0xbb},
+        {0x8b, 0xe8, 0xe2, 0xbb},
+        {0x8c, 0xf7, 0xed, 0xbb},
+        {0x8d, 0x00, 0xff, 0xbb},
+        {0x8e, 0xec, 0x10, 0xbb},
+        {0x8f, 0xf0, 0xed, 0xbb},
+        {0x90, 0xf9, 0xf2, 0xbb},
+        {0x91, 0x00, 0x00, 0xbb},
+        {0x92, 0xe9, 0x0d, 0xbb},
+        {0x93, 0xf4, 0xf2, 0xbb},
+        {0x94, 0xfb, 0xf5, 0xbb},
+        {0x95, 0x00, 0xff, 0xbb},
+        {0xb6, 0x0f, 0x08, 0xbb},
+        {0xb7, 0x3d, 0x16, 0xbb},
+        {0xb8, 0x0c, 0x04, 0xbb},
+        {0xb9, 0x1c, 0x07, 0xbb},
+        {0xba, 0x0a, 0x03, 0xbb},
+        {0xbb, 0x1b, 0x09, 0xbb},
+        {0xbc, 0x17, 0x0d, 0xbb},
+        {0xbd, 0x23, 0x1d, 0xbb},
+        {0xbe, 0x00, 0x28, 0xbb},
+        {0xbf, 0x11, 0x09, 0xbb},
+        {0xc0, 0x16, 0x15, 0xbb},
+        {0xc1, 0x00, 0x1b, 0xbb},
+        {0xc2, 0x0e, 0x07, 0xbb},
+        {0xc3, 0x14, 0x10, 0xbb},
+        {0xc4, 0x00, 0x17, 0xbb},
+        {0x06, 0x74, 0x8e, 0xbb},
+        {0xf0, 0x00, 0x00, 0xbb},
+        {0x03, 0x03, 0xc0, 0xbb},
         {}
 };
 
-static const __u8 mi1320_gamma[17] = {
+static const u8 mi1320_gamma[17] = {
         0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
         0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
 };
-static const __u8 mi1320_matrix[9] = {
+static const u8 mi1320_matrix[9] = {
         0x54, 0xda, 0x06, 0xf1, 0x50, 0xf4, 0xf7, 0xea, 0x52
 };
-static const __u8 mi1320_initVGA_data[][4] = {
+static const u8 mi1320_initVGA_data[][4] = {
         {0xb3, 0x01, 0x01, 0xcc},       {0x00, 0x00, 0x33, 0xdd},
         {0xb0, 0x03, 0x19, 0xcc},       {0x00, 0x00, 0x33, 0xdd},
         {0xb0, 0x04, 0x02, 0xcc},       {0x00, 0x00, 0x33, 0xdd},
@@ -841,7 +931,7 @@ static const __u8 mi1320_initVGA_data[][4] = {
         {0xb3, 0x5c, 0x01, 0xcc},       {0xb3, 0x01, 0x41, 0xcc},
         {}
 };
-static const __u8 mi1320_initQVGA_data[][4] = {
+static const u8 mi1320_initQVGA_data[][4] = {
         {0xb3, 0x01, 0x01, 0xcc},       {0x00, 0x00, 0x33, 0xdd},
         {0xb0, 0x03, 0x19, 0xcc},       {0x00, 0x00, 0x33, 0xdd},
         {0xb0, 0x04, 0x02, 0xcc},       {0x00, 0x00, 0x33, 0xdd},
@@ -948,7 +1038,7 @@ static const u8 mi1320_soc_InitVGA[][4] = {
         {0x07, 0x00, 0xe0, 0xbb},
         {0x08, 0x00, 0x0b, 0xbb},
         {0x21, 0x00, 0x0c, 0xbb},
-        {0x20, 0x01, 0x03, 0xbb},
+        {0x20, 0x01, 0x03, 0xbb},       /* h/v flip */
         {0xbf, 0xc0, 0x26, 0xcc},
         {0xbf, 0xc1, 0x02, 0xcc},
         {0xbf, 0xcc, 0x04, 0xcc},
@@ -958,7 +1048,7 @@ static const u8 mi1320_soc_InitVGA[][4] = {
         {0x06, 0x00, 0x11, 0xbb},
         {0x07, 0x01, 0x42, 0xbb},
         {0x08, 0x00, 0x11, 0xbb},
-        {0x20, 0x01, 0x03, 0xbb},
+        {0x20, 0x01, 0x03, 0xbb},       /* h/v flip */
         {0x21, 0x80, 0x00, 0xbb},
         {0x22, 0x0d, 0x0f, 0xbb},
         {0x24, 0x80, 0x00, 0xbb},
@@ -1051,7 +1141,7 @@ static const u8 mi1320_soc_InitQVGA[][4] = {
         {0x07, 0x00, 0xe0, 0xbb},
         {0x08, 0x00, 0x0b, 0xbb},
         {0x21, 0x00, 0x0c, 0xbb},
-        {0x20, 0x01, 0x03, 0xbb},
+        {0x20, 0x01, 0x03, 0xbb},       /* h/v flip */
         {0xbf, 0xc0, 0x26, 0xcc},
         {0xbf, 0xc1, 0x02, 0xcc},
         {0xbf, 0xcc, 0x04, 0xcc},
@@ -1071,7 +1161,7 @@ static const u8 mi1320_soc_InitQVGA[][4] = {
         {0x06, 0x00, 0x11, 0xbb},
         {0x07, 0x01, 0x42, 0xbb},
         {0x08, 0x00, 0x11, 0xbb},
-        {0x20, 0x01, 0x03, 0xbb},
+        {0x20, 0x01, 0x03, 0xbb},       /* h/v flip */
         {0x21, 0x80, 0x00, 0xbb},
         {0x22, 0x0d, 0x0f, 0xbb},
         {0x24, 0x80, 0x00, 0xbb},
@@ -1161,7 +1251,7 @@ static const u8 mi1320_soc_InitSXGA[][4] = {
         {0x00, 0x00, 0x20, 0xdd},
         {0xf0, 0x00, 0x00, 0xbb},
         {0x00, 0x00, 0x30, 0xdd},
-        {0x20, 0x01, 0x03, 0xbb},
+        {0x20, 0x01, 0x03, 0xbb},       /* h/v flip */
         {0x00, 0x00, 0x20, 0xdd},
         {0xbf, 0xc0, 0x26, 0xcc},
         {0xbf, 0xc1, 0x02, 0xcc},
@@ -1172,7 +1262,7 @@ static const u8 mi1320_soc_InitSXGA[][4] = {
         {0x06, 0x00, 0x11, 0xbb},
         {0x07, 0x01, 0x42, 0xbb},
         {0x08, 0x00, 0x11, 0xbb},
-        {0x20, 0x01, 0x03, 0xbb},
+        {0x20, 0x01, 0x03, 0xbb},       /* h/v flip */
         {0x21, 0x80, 0x00, 0xbb},
         {0x22, 0x0d, 0x0f, 0xbb},
         {0x24, 0x80, 0x00, 0xbb},
@@ -1230,7 +1320,7 @@ static const u8 mi1320_soc_InitSXGA[][4] = {
         {0x06, 0x00, 0x11, 0xbb},
         {0x07, 0x00, 0x85, 0xbb},
         {0x08, 0x00, 0x27, 0xbb},
-        {0x20, 0x01, 0x03, 0xbb},
+        {0x20, 0x01, 0x03, 0xbb},       /* h/v flip */
         {0x21, 0x80, 0x00, 0xbb},
         {0x22, 0x0d, 0x0f, 0xbb},
         {0x24, 0x80, 0x00, 0xbb},
@@ -1249,15 +1339,15 @@ static const u8 mi1320_soc_InitSXGA[][4] = {
         {0x64, 0x5e, 0x1c, 0xbb},
         {}
 };
-static const __u8 po3130_gamma[17] = {
+static const u8 po3130_gamma[17] = {
         0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
         0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
 };
-static const __u8 po3130_matrix[9] = {
+static const u8 po3130_matrix[9] = {
         0x5f, 0xec, 0xf5, 0xf1, 0x5a, 0xf5, 0xf1, 0xec, 0x63
 };
 
-static const __u8 po3130_initVGA_data[][4] = {
+static const u8 po3130_initVGA_data[][4] = {
         {0xb0, 0x4d, 0x00, 0xcc},       {0xb3, 0x01, 0x01, 0xcc},
         {0x00, 0x00, 0x50, 0xdd},       {0xb0, 0x03, 0x01, 0xcc},
         {0xb3, 0x00, 0x04, 0xcc},       {0xb3, 0x00, 0x24, 0xcc},
@@ -1340,7 +1430,7 @@ static const __u8 po3130_initVGA_data[][4] = {
         {0xb3, 0x5c, 0x00, 0xcc},       {0xb3, 0x01, 0x41, 0xcc},
         {}
 };
-static const __u8 po3130_rundata[][4] = {
+static const u8 po3130_rundata[][4] = {
         {0x00, 0x47, 0x45, 0xaa},       {0x00, 0x48, 0x9b, 0xaa},
         {0x00, 0x49, 0x3a, 0xaa},       {0x00, 0x4a, 0x01, 0xaa},
         {0x00, 0x44, 0x40, 0xaa},
@@ -1355,7 +1445,7 @@ static const __u8 po3130_rundata[][4] = {
         {}
 };
 
-static const __u8 po3130_initQVGA_data[][4] = {
+static const u8 po3130_initQVGA_data[][4] = {
         {0xb0, 0x4d, 0x00, 0xcc},       {0xb3, 0x01, 0x01, 0xcc},
         {0x00, 0x00, 0x50, 0xdd},       {0xb0, 0x03, 0x09, 0xcc},
         {0xb3, 0x00, 0x04, 0xcc},       {0xb3, 0x00, 0x24, 0xcc},
@@ -1441,121 +1531,207 @@ static const __u8 po3130_initQVGA_data[][4] = {
         {}
 };
 
-static const __u8 hv7131r_gamma[17] = {
-/*      0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
- *      0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff */
-        0x04, 0x1a, 0x36, 0x55, 0x6f, 0x87, 0x9d, 0xb0, 0xc1,
-        0xcf, 0xda, 0xe4, 0xec, 0xf3, 0xf8, 0xfd, 0xff
+static const u8 hv7131r_gamma[17] = {
+        0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
+        0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
 };
-static const __u8 hv7131r_matrix[9] = {
+static const u8 hv7131r_matrix[9] = {
         0x5f, 0xec, 0xf5, 0xf1, 0x5a, 0xf5, 0xf1, 0xec, 0x63
 };
-static const __u8 hv7131r_initVGA_data[][4] = {
-        {0xb0, 0x4d, 0x00, 0xcc},       {0xb3, 0x01, 0x01, 0xcc},
-        {0x00, 0x00, 0x50, 0xdd},       {0xb0, 0x03, 0x01, 0xcc},
+static const u8 hv7131r_initVGA_data[][4] = {
+        {0xb3, 0x01, 0x01, 0xcc},
+        {0xb0, 0x03, 0x19, 0xcc},
+        {0xb0, 0x04, 0x02, 0xcc},
+        {0x00, 0x00, 0x20, 0xdd},
         {0xb3, 0x00, 0x24, 0xcc},
-        {0xb3, 0x00, 0x25, 0xcc},       {0xb3, 0x08, 0x01, 0xcc},
-        {0xb3, 0x09, 0x0c, 0xcc},       {0xb3, 0x05, 0x00, 0xcc},
-        {0xb3, 0x06, 0x01, 0xcc},
-        {0xb3, 0x01, 0x45, 0xcc},       {0xb3, 0x03, 0x0b, 0xcc},
-        {0xb3, 0x04, 0x05, 0xcc},       {0xb3, 0x20, 0x00, 0xcc},
+        {0xb3, 0x00, 0x25, 0xcc},
+        {0xb3, 0x08, 0x01, 0xcc},
+        {0xb3, 0x09, 0x0c, 0xcc},
+        {0xb3, 0x05, 0x01, 0xcc},
+        {0xb3, 0x06, 0x03, 0xcc},
+        {0xb3, 0x01, 0x45, 0xcc},
+        {0xb3, 0x03, 0x0b, 0xcc},
+        {0xb3, 0x04, 0x05, 0xcc},
+        {0xb3, 0x20, 0x00, 0xcc},
         {0xb3, 0x21, 0x00, 0xcc},
-        {0xb3, 0x22, 0x01, 0xcc},       {0xb3, 0x23, 0xe0, 0xcc},
-        {0xb3, 0x14, 0x00, 0xcc},       {0xb3, 0x15, 0x00, 0xcc},
+        {0xb3, 0x22, 0x01, 0xcc},
+        {0xb3, 0x23, 0xe0, 0xcc},
+        {0xb3, 0x14, 0x00, 0xcc},
+        {0xb3, 0x15, 0x02, 0xcc},
         {0xb3, 0x16, 0x02, 0xcc},
-        {0xb3, 0x17, 0x7f, 0xcc},       {0xb3, 0x34, 0x01, 0xcc},
-        {0xb3, 0x35, 0x91, 0xcc},       {0xb3, 0x00, 0x27, 0xcc},
+        {0xb3, 0x17, 0x7f, 0xcc},
+        {0xb3, 0x34, 0x01, 0xcc},
+        {0xb3, 0x35, 0x91, 0xcc},
+        {0xb3, 0x00, 0x27, 0xcc},
         {0xbc, 0x00, 0x73, 0xcc},
-        {0xb8, 0x00, 0x23, 0xcc},       {0x00, 0x01, 0x0c, 0xaa},
-        {0x00, 0x14, 0x01, 0xaa},       {0x00, 0x15, 0xe6, 0xaa},
-        {0x00, 0x16, 0x02, 0xaa},
-        {0x00, 0x17, 0x86, 0xaa},       {0x00, 0x23, 0x00, 0xaa},
-        {0x00, 0x25, 0x09, 0xaa},       {0x00, 0x26, 0x27, 0xaa},
-        {0x00, 0x27, 0xc0, 0xaa},
-        {0xb8, 0x2c, 0x60, 0xcc},       {0xb8, 0x2d, 0xf8, 0xcc},
-        {0xb8, 0x2e, 0xf8, 0xcc},       {0xb8, 0x2f, 0xf8, 0xcc},
+        {0xb8, 0x00, 0x23, 0xcc},
+        {0xb8, 0x2c, 0x50, 0xcc},
+        {0xb8, 0x2d, 0xf8, 0xcc},
+        {0xb8, 0x2e, 0xf8, 0xcc},
+        {0xb8, 0x2f, 0xf8, 0xcc},
         {0xb8, 0x30, 0x50, 0xcc},
-        {0xb8, 0x31, 0xf8, 0xcc},       {0xb8, 0x32, 0xf8, 0xcc},
-        {0xb8, 0x33, 0xf8, 0xcc},       {0xb8, 0x34, 0x65, 0xcc},
+        {0xb8, 0x31, 0xf8, 0xcc},
+        {0xb8, 0x32, 0xf8, 0xcc},
+        {0xb8, 0x33, 0xf8, 0xcc},
+        {0xb8, 0x34, 0x58, 0xcc},
         {0xb8, 0x35, 0x00, 0xcc},
-        {0xb8, 0x36, 0x00, 0xcc},       {0xb8, 0x37, 0x00, 0xcc},
-        {0xb8, 0x27, 0x20, 0xcc},       {0xb8, 0x01, 0x7d, 0xcc},
+        {0xb8, 0x36, 0x00, 0xcc},
+        {0xb8, 0x37, 0x00, 0xcc},
+        {0xb8, 0x27, 0x20, 0xcc},
+        {0xb8, 0x01, 0x7d, 0xcc},
         {0xb8, 0x81, 0x09, 0xcc},
-        {0xb3, 0x01, 0x41, 0xcc},       {0xb8, 0xfe, 0x00, 0xcc},
-        {0xb8, 0xff, 0x28, 0xcc},       {0xb9, 0x00, 0x28, 0xcc},
-        {0xb9, 0x01, 0x28, 0xcc},
-        {0xb9, 0x02, 0x28, 0xcc},       {0xb9, 0x03, 0x00, 0xcc},
-        {0xb9, 0x04, 0x00, 0xcc},       {0xb9, 0x05, 0x3c, 0xcc},
-        {0xb9, 0x06, 0x3c, 0xcc},
-        {0xb9, 0x07, 0x3c, 0xcc},       {0xb9, 0x08, 0x3c, 0xcc},
-        {0xb8, 0x8e, 0x00, 0xcc},       {0xb8, 0x8f, 0xff, 0xcc},
+        {0xb3, 0x01, 0x41, 0xcc},
+        {0xb8, 0x8e, 0x00, 0xcc},
+        {0xb8, 0x8f, 0xff, 0xcc},
+        {0x00, 0x01, 0x0c, 0xaa},
+        {0x00, 0x14, 0x01, 0xaa},
+        {0x00, 0x15, 0xe6, 0xaa},
+        {0x00, 0x16, 0x02, 0xaa},
+        {0x00, 0x17, 0x86, 0xaa},
+        {0x00, 0x23, 0x00, 0xaa},
+        {0x00, 0x25, 0x03, 0xaa},
+        {0x00, 0x26, 0xa9, 0xaa},
+        {0x00, 0x27, 0x80, 0xaa},
         {0x00, 0x30, 0x18, 0xaa},
+        {0xb6, 0x00, 0x00, 0xcc},
+        {0xb6, 0x03, 0x02, 0xcc},
+        {0xb6, 0x02, 0x80, 0xcc},
+        {0xb6, 0x05, 0x01, 0xcc},
+        {0xb6, 0x04, 0xe0, 0xcc},
+        {0xb6, 0x12, 0x78, 0xcc},
+        {0xb6, 0x18, 0x02, 0xcc},
+        {0xb6, 0x17, 0x58, 0xcc},
+        {0xb6, 0x16, 0x00, 0xcc},
+        {0xb6, 0x22, 0x12, 0xcc},
+        {0xb6, 0x23, 0x0b, 0xcc},
+        {0xb3, 0x02, 0x02, 0xcc},
+        {0xbf, 0xc0, 0x39, 0xcc},
+        {0xbf, 0xc1, 0x04, 0xcc},
+        {0xbf, 0xcc, 0x10, 0xcc},
+        {0xb6, 0x12, 0xf8, 0xcc},
+        {0xb6, 0x13, 0x13, 0xcc},
+        {0xb9, 0x12, 0x00, 0xcc},
+        {0xb9, 0x13, 0x0a, 0xcc},
+        {0xb9, 0x14, 0x0a, 0xcc},
+        {0xb9, 0x15, 0x0a, 0xcc},
+        {0xb9, 0x16, 0x0a, 0xcc},
+        {0xb8, 0x0c, 0x20, 0xcc},
+        {0xb8, 0x0d, 0x70, 0xcc},
+        {0xb9, 0x18, 0x00, 0xcc},
+        {0xb9, 0x19, 0x0f, 0xcc},
+        {0xb9, 0x1a, 0x0f, 0xcc},
+        {0xb9, 0x1b, 0x0f, 0xcc},
+        {0xb9, 0x1c, 0x0f, 0xcc},
+        {0xb3, 0x5c, 0x01, 0xcc},
         {}
 };
 
-static const __u8 hv7131r_initQVGA_data[][4] = {
-        {0xb0, 0x4d, 0x00, 0xcc},       {0xb3, 0x01, 0x01, 0xcc},
-        {0x00, 0x00, 0x50, 0xdd},       {0xb0, 0x03, 0x01, 0xcc},
+static const u8 hv7131r_initQVGA_data[][4] = {
+        {0xb3, 0x01, 0x01, 0xcc},
+        {0xb0, 0x03, 0x19, 0xcc},
+        {0xb0, 0x04, 0x02, 0xcc},
+        {0x00, 0x00, 0x20, 0xdd},
         {0xb3, 0x00, 0x24, 0xcc},
-        {0xb3, 0x00, 0x25, 0xcc},       {0xb3, 0x08, 0x01, 0xcc},
-        {0xb3, 0x09, 0x0c, 0xcc},       {0xb3, 0x05, 0x00, 0xcc},
-        {0xb3, 0x06, 0x01, 0xcc},
-        {0xb3, 0x03, 0x0b, 0xcc},       {0xb3, 0x04, 0x05, 0xcc},
-        {0xb3, 0x20, 0x00, 0xcc},       {0xb3, 0x21, 0x00, 0xcc},
+        {0xb3, 0x00, 0x25, 0xcc},
+        {0xb3, 0x08, 0x01, 0xcc},
+        {0xb3, 0x09, 0x0c, 0xcc},
+        {0xb3, 0x05, 0x01, 0xcc},
+        {0xb3, 0x06, 0x03, 0xcc},
+        {0xb3, 0x01, 0x45, 0xcc},
+        {0xb3, 0x03, 0x0b, 0xcc},
+        {0xb3, 0x04, 0x05, 0xcc},
+        {0xb3, 0x20, 0x00, 0xcc},
+        {0xb3, 0x21, 0x00, 0xcc},
         {0xb3, 0x22, 0x01, 0xcc},
-        {0xb3, 0x23, 0xe0, 0xcc},       {0xb3, 0x14, 0x00, 0xcc},
-        {0xb3, 0x15, 0x00, 0xcc},       {0xb3, 0x16, 0x02, 0xcc},
+        {0xb3, 0x23, 0xe0, 0xcc},
+        {0xb3, 0x14, 0x00, 0xcc},
+        {0xb3, 0x15, 0x02, 0xcc},
+        {0xb3, 0x16, 0x02, 0xcc},
         {0xb3, 0x17, 0x7f, 0xcc},
-        {0xb3, 0x34, 0x01, 0xcc},       {0xb3, 0x35, 0x91, 0xcc},
-        {0xb3, 0x00, 0x27, 0xcc},       {0xbc, 0x00, 0xd1, 0xcc},
-        {0xb8, 0x00, 0x21, 0xcc},
-        {0x00, 0x01, 0x0c, 0xaa},       {0x00, 0x14, 0x01, 0xaa},
-        {0x00, 0x15, 0xe6, 0xaa},       {0x00, 0x16, 0x02, 0xaa},
-        {0x00, 0x17, 0x86, 0xaa},
-        {0x00, 0x23, 0x00, 0xaa},       {0x00, 0x25, 0x01, 0xaa},
-        {0x00, 0x26, 0xd4, 0xaa},       {0x00, 0x27, 0xc0, 0xaa},
-        {0xbc, 0x02, 0x08, 0xcc},
-        {0xbc, 0x03, 0x70, 0xcc},       {0xbc, 0x04, 0x08, 0xcc},
-        {0xbc, 0x05, 0x00, 0xcc},       {0xbc, 0x06, 0x00, 0xcc},
-        {0xbc, 0x08, 0x3c, 0xcc},
-        {0xbc, 0x09, 0x40, 0xcc},       {0xbc, 0x0a, 0x04, 0xcc},
-        {0xbc, 0x0b, 0x00, 0xcc},       {0xbc, 0x0c, 0x00, 0xcc},
-        {0xb8, 0xfe, 0x02, 0xcc},
-        {0xb8, 0xff, 0x07, 0xcc},       {0xb9, 0x00, 0x14, 0xcc},
-        {0xb9, 0x01, 0x14, 0xcc},       {0xb9, 0x02, 0x14, 0xcc},
-        {0xb9, 0x03, 0x00, 0xcc},
-        {0xb9, 0x04, 0x02, 0xcc},       {0xb9, 0x05, 0x05, 0xcc},
-        {0xb9, 0x06, 0x0f, 0xcc},       {0xb9, 0x07, 0x0f, 0xcc},
-        {0xb9, 0x08, 0x0f, 0xcc},
-        {0xb8, 0x2c, 0x60, 0xcc},       {0xb8, 0x2d, 0xf8, 0xcc},
-        {0xb8, 0x2e, 0xf8, 0xcc},       {0xb8, 0x2f, 0xf8, 0xcc},
+        {0xb3, 0x34, 0x01, 0xcc},
+        {0xb3, 0x35, 0x91, 0xcc},
+        {0xb3, 0x00, 0x27, 0xcc},
+        {0xbc, 0x00, 0xd3, 0xcc},
+        {0xb8, 0x00, 0x23, 0xcc},
+        {0xb8, 0x2c, 0x50, 0xcc},
+        {0xb8, 0x2d, 0xf8, 0xcc},
+        {0xb8, 0x2e, 0xf8, 0xcc},
+        {0xb8, 0x2f, 0xf8, 0xcc},
         {0xb8, 0x30, 0x50, 0xcc},
-        {0xb8, 0x31, 0xf8, 0xcc},       {0xb8, 0x32, 0xf8, 0xcc},
+        {0xb8, 0x31, 0xf8, 0xcc},
+        {0xb8, 0x32, 0xf8, 0xcc},
         {0xb8, 0x33, 0xf8, 0xcc},
-        {0xb8, 0x34, 0x65, 0xcc},       {0xb8, 0x35, 0x00, 0xcc},
-        {0xb8, 0x36, 0x00, 0xcc},       {0xb8, 0x37, 0x00, 0xcc},
+        {0xb8, 0x34, 0x58, 0xcc},
+        {0xb8, 0x35, 0x00, 0xcc},
+        {0xb8, 0x36, 0x00, 0xcc},
+        {0xb8, 0x37, 0x00, 0xcc},
         {0xb8, 0x27, 0x20, 0xcc},
-        {0xb8, 0x01, 0x7d, 0xcc},       {0xb8, 0x81, 0x09, 0xcc},
-        {0xb3, 0x01, 0x41, 0xcc},       {0xb8, 0xfe, 0x00, 0xcc},
-        {0xb8, 0xff, 0x28, 0xcc},
-        {0xb9, 0x00, 0x28, 0xcc},       {0xb9, 0x01, 0x28, 0xcc},
-        {0xb9, 0x02, 0x28, 0xcc},       {0xb9, 0x03, 0x00, 0xcc},
-        {0xb9, 0x04, 0x00, 0xcc},
-        {0xb9, 0x05, 0x3c, 0xcc},       {0xb9, 0x06, 0x3c, 0xcc},
-        {0xb9, 0x07, 0x3c, 0xcc},       {0xb9, 0x08, 0x3c, 0xcc},
+        {0xb8, 0x01, 0x7d, 0xcc},
+        {0xb8, 0x81, 0x09, 0xcc},
+        {0xb3, 0x01, 0x41, 0xcc},
         {0xb8, 0x8e, 0x00, 0xcc},
-        {0xb8, 0x8f, 0xff, 0xcc},       {0x00, 0x30, 0x18, 0xaa},
+        {0xb8, 0x8f, 0xff, 0xcc},
+        {0x00, 0x01, 0x0c, 0xaa},
+        {0x00, 0x14, 0x01, 0xaa},
+        {0x00, 0x15, 0xe6, 0xaa},
+        {0x00, 0x16, 0x02, 0xaa},
+        {0x00, 0x17, 0x86, 0xaa},
+        {0x00, 0x23, 0x00, 0xaa},
+        {0x00, 0x25, 0x03, 0xaa},
+        {0x00, 0x26, 0xa9, 0xaa},
+        {0x00, 0x27, 0x80, 0xaa},
+        {0x00, 0x30, 0x18, 0xaa},
+        {0xb6, 0x00, 0x00, 0xcc},
+        {0xb6, 0x03, 0x01, 0xcc},
+        {0xb6, 0x02, 0x40, 0xcc},
+        {0xb6, 0x05, 0x00, 0xcc},
+        {0xb6, 0x04, 0xf0, 0xcc},
+        {0xb6, 0x12, 0x78, 0xcc},
+        {0xb6, 0x18, 0x00, 0xcc},
+        {0xb6, 0x17, 0x96, 0xcc},
+        {0xb6, 0x16, 0x00, 0xcc},
+        {0xb6, 0x22, 0x12, 0xcc},
+        {0xb6, 0x23, 0x0b, 0xcc},
+        {0xb3, 0x02, 0x02, 0xcc},
+        {0xbf, 0xc0, 0x39, 0xcc},
+        {0xbf, 0xc1, 0x04, 0xcc},
+        {0xbf, 0xcc, 0x10, 0xcc},
+        {0xbc, 0x02, 0x18, 0xcc},
+        {0xbc, 0x03, 0x50, 0xcc},
+        {0xbc, 0x04, 0x18, 0xcc},
+        {0xbc, 0x05, 0x00, 0xcc},
+        {0xbc, 0x06, 0x00, 0xcc},
+        {0xbc, 0x08, 0x30, 0xcc},
+        {0xbc, 0x09, 0x40, 0xcc},
+        {0xbc, 0x0a, 0x10, 0xcc},
+        {0xbc, 0x0b, 0x00, 0xcc},
+        {0xbc, 0x0c, 0x00, 0xcc},
+        {0xb9, 0x12, 0x00, 0xcc},
+        {0xb9, 0x13, 0x0a, 0xcc},
+        {0xb9, 0x14, 0x0a, 0xcc},
+        {0xb9, 0x15, 0x0a, 0xcc},
+        {0xb9, 0x16, 0x0a, 0xcc},
+        {0xb9, 0x18, 0x00, 0xcc},
+        {0xb9, 0x19, 0x0f, 0xcc},
+        {0xb8, 0x0c, 0x20, 0xcc},
+        {0xb8, 0x0d, 0x70, 0xcc},
+        {0xb9, 0x1a, 0x0f, 0xcc},
+        {0xb9, 0x1b, 0x0f, 0xcc},
+        {0xb9, 0x1c, 0x0f, 0xcc},
+        {0xb6, 0x12, 0xf8, 0xcc},
+        {0xb6, 0x13, 0x13, 0xcc},
+        {0xb3, 0x5c, 0x01, 0xcc},
         {}
 };
 
-static const __u8 ov7660_gamma[17] = {
+static const u8 ov7660_gamma[17] = {
         0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
         0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
 };
-static const __u8 ov7660_matrix[9] = {
+static const u8 ov7660_matrix[9] = {
         0x5a, 0xf0, 0xf6, 0xf3, 0x57, 0xf6, 0xf3, 0xef, 0x62
 };
-static const __u8 ov7660_initVGA_data[][4] = {
+static const u8 ov7660_initVGA_data[][4] = {
         {0xb0, 0x4d, 0x00, 0xcc},       {0xb3, 0x01, 0x01, 0xcc},
         {0x00, 0x00, 0x50, 0xdd},
         {0xb0, 0x03, 0x01, 0xcc},
@@ -1613,7 +1789,7 @@ static const __u8 ov7660_initVGA_data[][4] = {
         {0x00, 0x29, 0x3c, 0xaa},       {0xb3, 0x01, 0x45, 0xcc},
         {}
 };
-static const __u8 ov7660_initQVGA_data[][4] = {
+static const u8 ov7660_initQVGA_data[][4] = {
         {0xb0, 0x4d, 0x00, 0xcc},       {0xb3, 0x01, 0x01, 0xcc},
         {0x00, 0x00, 0x50, 0xdd},       {0xb0, 0x03, 0x01, 0xcc},
         {0xb3, 0x00, 0x21, 0xcc},       {0xb3, 0x00, 0x26, 0xcc},
@@ -1682,26 +1858,26 @@ static const __u8 ov7660_initQVGA_data[][4] = {
         {}
 };
 
-static const __u8 ov7660_50HZ[][4] = {
+static const u8 ov7660_50HZ[][4] = {
         {0x00, 0x3b, 0x08, 0xaa},
         {0x00, 0x9d, 0x40, 0xaa},
         {0x00, 0x13, 0xa7, 0xaa},
         {}
 };
 
-static const __u8 ov7660_60HZ[][4] = {
+static const u8 ov7660_60HZ[][4] = {
         {0x00, 0x3b, 0x00, 0xaa},
         {0x00, 0x9e, 0x40, 0xaa},
         {0x00, 0x13, 0xa7, 0xaa},
         {}
 };
 
-static const __u8 ov7660_NoFliker[][4] = {
+static const u8 ov7660_NoFliker[][4] = {
         {0x00, 0x13, 0x87, 0xaa},
         {}
 };
 
-static const __u8 ov7670_initVGA_JPG[][4] = {
+static const u8 ov7670_initVGA_JPG[][4] = {
         {0xb3, 0x01, 0x05, 0xcc},
         {0x00, 0x00, 0x30, 0xdd},       {0xb0, 0x03, 0x19, 0xcc},
         {0x00, 0x00, 0x10, 0xdd},
@@ -1831,7 +2007,7 @@ static const __u8 ov7670_initVGA_JPG[][4] = {
         {},
 };
 
-static const __u8 ov7670_initQVGA_JPG[][4] = {
+static const u8 ov7670_initQVGA_JPG[][4] = {
         {0xb3, 0x01, 0x05, 0xcc},       {0x00, 0x00, 0x30, 0xdd},
         {0xb0, 0x03, 0x19, 0xcc},       {0x00, 0x00, 0x10, 0xdd},
         {0xb0, 0x04, 0x02, 0xcc},       {0x00, 0x00, 0x10, 0xdd},
@@ -1966,14 +2142,14 @@ static const __u8 ov7670_initQVGA_JPG[][4] = {
 };
 
 /* PO1200 - values from usbvm326.inf and ms-win trace */
-static const __u8 po1200_gamma[17] = {
+static const u8 po1200_gamma[17] = {
         0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
         0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
 };
-static const __u8 po1200_matrix[9] = {
+static const u8 po1200_matrix[9] = {
         0x60, 0xf9, 0xe5, 0xe7, 0x50, 0x05, 0xf3, 0xe6, 0x5e
 };
-static const __u8 po1200_initVGA_data[][4] = {
+static const u8 po1200_initVGA_data[][4] = {
         {0xb0, 0x03, 0x19, 0xcc},       /* reset? */
         {0xb0, 0x03, 0x19, 0xcc},
 /*      {0x00, 0x00, 0x33, 0xdd}, */
@@ -2276,9 +2452,9 @@ static const struct sensor_info sensor_info_data[] = {
 
 /* read 'len' bytes in gspca_dev->usb_buf */
 static void reg_r(struct gspca_dev *gspca_dev,
-                  __u16 req,
-                  __u16 index,
-                  __u16 len)
+                  u16 req,
+                  u16 index,
+                  u16 len)
 {
         usb_control_msg(gspca_dev->dev,
                         usb_rcvctrlpipe(gspca_dev->dev, 0),
@@ -2290,9 +2466,9 @@ static void reg_r(struct gspca_dev *gspca_dev,
 }
 
 static void reg_w(struct usb_device *dev,
-                            __u16 req,
-                            __u16 value,
-                            __u16 index)
+                            u16 req,
+                            u16 value,
+                            u16 index)
 {
         usb_control_msg(dev,
                         usb_sndctrlpipe(dev, 0),
@@ -2342,11 +2518,18 @@ static u16 read_sensor_register(struct gspca_dev *gspca_dev,
 
 static int vc032x_probe_sensor(struct gspca_dev *gspca_dev)
 {
+        struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
         int i;
         u16 value;
         const struct sensor_info *ptsensor_info;
 
+/*fixme: should also check the other sensor (back mi1320_soc, front mc501cb)*/
+        if (sd->flags & FL_SAMSUNG) {
+                reg_w(dev, 0xa0, 0x01, 0xb301);
+                reg_w(dev, 0x89, 0xf0ff, 0xffff); /* select the back sensor */
+        }
+
         reg_r(gspca_dev, 0xa1, 0xbfcf, 1);
         PDEBUG(D_PROBE, "check sensor header %02x", gspca_dev->usb_buf[0]);
         for (i = 0; i < ARRAY_SIZE(sensor_info_data); i++) {
@@ -2406,17 +2589,17 @@ static void i2c_write(struct gspca_dev *gspca_dev,
 }
 
 static void put_tab_to_reg(struct gspca_dev *gspca_dev,
-                        const __u8 *tab, __u8 tabsize, __u16 addr)
+                        const u8 *tab, u8 tabsize, u16 addr)
 {
         int j;
-        __u16 ad = addr;
+        u16 ad = addr;
 
         for (j = 0; j < tabsize; j++)
                 reg_w(gspca_dev->dev, 0xa0, tab[j], ad++);
 }
 
 static void usb_exchange(struct gspca_dev *gspca_dev,
-                        const __u8 data[][4])
+                        const u8 data[][4])
 {
         struct usb_device *dev = gspca_dev->dev;
         int i = 0;
@@ -2466,7 +2649,8 @@ static int sd_config(struct gspca_dev *gspca_dev,
         };
 
         cam = &gspca_dev->cam;
-        sd->bridge = id->driver_info;
+        sd->bridge = id->driver_info >> 8;
+        sd->flags = id->driver_info & 0xff;
         sensor = vc032x_probe_sensor(gspca_dev);
         switch (sensor) {
         case -1:
@@ -2519,8 +2703,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 case SENSOR_MI1320_SOC:
                         cam->cam_mode = bi_mode;
                         cam->nmodes = ARRAY_SIZE(bi_mode);
-                        cam->input_flags = V4L2_IN_ST_VFLIP |
-                                           V4L2_IN_ST_HFLIP;
                         break;
                 default:
                         cam->cam_mode = vc0323_mode;
@@ -2532,14 +2714,14 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         sd->hflip = HFLIP_DEF;
         sd->vflip = VFLIP_DEF;
-        if (sd->sensor == SENSOR_OV7670) {
-                sd->hflip = 1;
-                sd->vflip = 1;
-        }
+        if (sd->sensor == SENSOR_OV7670)
+                sd->flags |= FL_HFLIP | FL_VFLIP;
         sd->lightfreq = FREQ_DEF;
         if (sd->sensor != SENSOR_OV7670)
                 gspca_dev->ctrl_dis = (1 << LIGHTFREQ_IDX);
         switch (sd->sensor) {
+        case SENSOR_MI1310_SOC:
+        case SENSOR_MI1320_SOC:
         case SENSOR_OV7660:
         case SENSOR_OV7670:
         case SENSOR_PO1200:
@@ -2568,39 +2750,50 @@ static int sd_init(struct gspca_dev *gspca_dev)
         return 0;
 }
 
-/* for OV7660 and OV7670 only */
+/* some sensors only */
 static void sethvflip(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        __u8 data;
-
+        u8 data[2], hflip, vflip;
+
+        hflip = sd->hflip;
+        if (sd->flags & FL_HFLIP)
+                hflip = !hflip;
+        vflip = sd->vflip;
+        if (sd->flags & FL_VFLIP)
+                vflip = !vflip;
         switch (sd->sensor) {
-        case SENSOR_OV7660:
-                data = 1;
+        case SENSOR_MI1310_SOC:
+        case SENSOR_MI1320_SOC:
+                data[0] = data[1] = 0;          /* select page 0 */
+                i2c_write(gspca_dev, 0xf0, data, 2);
+                data[0] = sd->sensor == SENSOR_MI1310_SOC ? 0x03 : 0x01;
+                data[1] = 0x02 * hflip
+                        | 0x01 * vflip;
+                i2c_write(gspca_dev, 0x20, data, 2);
                 break;
+        case SENSOR_OV7660:
         case SENSOR_OV7670:
-                data = 7;
+                data[0] = sd->sensor == SENSOR_OV7660 ? 0x01 : 0x07;
+                data[0] |= OV7660_MVFP_MIRROR * hflip
+                        | OV7660_MVFP_VFLIP * vflip;
+                i2c_write(gspca_dev, OV7660_REG_MVFP, data, 1);
                 break;
         case SENSOR_PO1200:
-                data = 0;
-                i2c_write(gspca_dev, 0x03, &data, 1);
-                data = 0x80 * sd->hflip
-                        | 0x40 * sd->vflip
+                data[0] = 0;
+                i2c_write(gspca_dev, 0x03, data, 1);
+                data[0] = 0x80 * hflip
+                        | 0x40 * vflip
                         | 0x06;
-                i2c_write(gspca_dev, 0x1e, &data, 1);
-                return;
-        default:
-                return;
+                i2c_write(gspca_dev, 0x1e, data, 1);
+                break;
         }
-        data |= OV7660_MVFP_MIRROR * sd->hflip
-                | OV7660_MVFP_VFLIP * sd->vflip;
-        i2c_write(gspca_dev, OV7660_REG_MVFP, &data, 1);
 }
 
 static void setlightfreq(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        static const __u8 (*ov7660_freq_tb[3])[4] =
+        static const u8 (*ov7660_freq_tb[3])[4] =
                 {ov7660_NoFliker, ov7660_50HZ, ov7660_60HZ};
 
         if (sd->sensor != SENSOR_OV7660)
@@ -2612,7 +2805,7 @@ static void setlightfreq(struct gspca_dev *gspca_dev)
 static void setsharpness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        __u8 data;
+        u8 data;
 
         if (sd->sensor != SENSOR_PO1200)
                 return;
@@ -2625,9 +2818,9 @@ static void setsharpness(struct gspca_dev *gspca_dev)
 static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        const __u8 (*init)[4];
-        const __u8 *GammaT = NULL;
-        const __u8 *MatrixT = NULL;
+        const u8 (*init)[4];
+        const u8 *GammaT = NULL;
+        const u8 *MatrixT = NULL;
         int mode;
         static const u8 (*mi1320_soc_init[])[4] = {
                 mi1320_soc_InitSXGA,
@@ -2635,6 +2828,13 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 mi1320_soc_InitQVGA,
         };
 
+/*fixme: back sensor only*/
+        if (sd->flags & FL_SAMSUNG) {
+                reg_w(gspca_dev->dev, 0x89, 0xf0ff, 0xffff);
+                reg_w(gspca_dev->dev, 0xa9, 0x8348, 0x000e);
+                reg_w(gspca_dev->dev, 0xa9, 0x0000, 0x001a);
+        }
+
         /* Assume start use the good resolution from gspca_dev->mode */
         if (sd->bridge == BRIDGE_VC0321) {
                 reg_w(gspca_dev->dev, 0xa0, 0xff, 0xbfec);
@@ -2737,16 +2937,22 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 put_tab_to_reg(gspca_dev, MatrixT, 9, 0xb82c);
 
                 /* set the led on 0x0892 0x0896 */
-                if (sd->sensor != SENSOR_PO1200) {
-                        reg_w(gspca_dev->dev, 0x89, 0xffff, 0xfdff);
-                        msleep(100);
-                        sethvflip(gspca_dev);
-                        setlightfreq(gspca_dev);
-                } else {
-                        setsharpness(gspca_dev);
-                        sethvflip(gspca_dev);
+                switch (sd->sensor) {
+                case SENSOR_PO1200:
+                case SENSOR_HV7131R:
                         reg_w(gspca_dev->dev, 0x89, 0x0400, 0x1415);
+                        break;
+                case SENSOR_MI1310_SOC:
+                        reg_w(gspca_dev->dev, 0x89, 0x058c, 0x0000);
+                        break;
+                default:
+                        reg_w(gspca_dev->dev, 0x89, 0xffff, 0xfdff);
+                        break;
                 }
+                msleep(100);
+                setsharpness(gspca_dev);
+                sethvflip(gspca_dev);
+                setlightfreq(gspca_dev);
         }
         return 0;
 }
@@ -2754,8 +2960,12 @@ static int sd_start(struct gspca_dev *gspca_dev)
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
         struct usb_device *dev = gspca_dev->dev;
+        struct sd *sd = (struct sd *) gspca_dev;
 
-        reg_w(dev, 0x89, 0xffff, 0xffff);
+        if (sd->sensor == SENSOR_MI1310_SOC)
+                reg_w(dev, 0x89, 0x058c, 0x00ff);
+        else
+                reg_w(dev, 0x89, 0xffff, 0xffff);
         reg_w(dev, 0xa0, 0x01, 0xb301);
         reg_w(dev, 0xa0, 0x09, 0xb003);
 }
@@ -2764,15 +2974,20 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
 static void sd_stop0(struct gspca_dev *gspca_dev)
 {
         struct usb_device *dev = gspca_dev->dev;
+        struct sd *sd = (struct sd *) gspca_dev;
 
         if (!gspca_dev->present)
                 return;
-        reg_w(dev, 0x89, 0xffff, 0xffff);
+/*fixme: is this useful?*/
+        if (sd->sensor == SENSOR_MI1310_SOC)
+                reg_w(dev, 0x89, 0x058c, 0x00ff);
+        else
+                reg_w(dev, 0x89, 0xffff, 0xffff);
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                         struct gspca_frame *frame,      /* target */
-                        __u8 *data,                     /* isoc packet */
+                        u8 *data,                       /* isoc packet */
                         int len)                        /* iso pkt length */
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -2872,21 +3087,12 @@ static int sd_getsharpness(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 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
-                        strcpy((char *) menu->name, "NoFliker");
-                        return 0;
-                case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
-                        strcpy((char *) menu->name, "50 Hz");
-                        return 0;
-                default:
-/*              case 2:          * V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
-                        strcpy((char *) menu->name, "60 Hz");
-                        return 0;
-                }
-                break;
+                strcpy((char *) menu->name, freq_nm[menu->index]);
+                return 0;
         }
         return -EINVAL;
 }
@@ -2906,19 +3112,23 @@ static const struct sd_desc sd_desc = {
 };
 
 /* -- module initialisation -- */
+#define BF(bridge, flags) \
+        .driver_info = (BRIDGE_ ## bridge << 8) \
+                | (flags)
 static const __devinitdata struct usb_device_id device_table[] = {
-        {USB_DEVICE(0x041e, 0x405b), .driver_info = BRIDGE_VC0323},
-        {USB_DEVICE(0x046d, 0x0892), .driver_info = BRIDGE_VC0321},
-        {USB_DEVICE(0x046d, 0x0896), .driver_info = BRIDGE_VC0321},
-        {USB_DEVICE(0x046d, 0x0897), .driver_info = BRIDGE_VC0321},
-        {USB_DEVICE(0x0ac8, 0x0321), .driver_info = BRIDGE_VC0321},
-        {USB_DEVICE(0x0ac8, 0x0323), .driver_info = BRIDGE_VC0323},
-        {USB_DEVICE(0x0ac8, 0x0328), .driver_info = BRIDGE_VC0321},
-        {USB_DEVICE(0x0ac8, 0xc001), .driver_info = BRIDGE_VC0321},
-        {USB_DEVICE(0x0ac8, 0xc002), .driver_info = BRIDGE_VC0321},
-        {USB_DEVICE(0x15b8, 0x6001), .driver_info = BRIDGE_VC0323},
-        {USB_DEVICE(0x15b8, 0x6002), .driver_info = BRIDGE_VC0323},
-        {USB_DEVICE(0x17ef, 0x4802), .driver_info = BRIDGE_VC0323},
+        {USB_DEVICE(0x041e, 0x405b), BF(VC0323, FL_VFLIP)},
+        {USB_DEVICE(0x046d, 0x0892), BF(VC0321, 0)},
+        {USB_DEVICE(0x046d, 0x0896), BF(VC0321, 0)},
+        {USB_DEVICE(0x046d, 0x0897), BF(VC0321, 0)},
+        {USB_DEVICE(0x0ac8, 0x0321), BF(VC0321, 0)},
+        {USB_DEVICE(0x0ac8, 0x0323), BF(VC0323, 0)},
+        {USB_DEVICE(0x0ac8, 0x0328), BF(VC0321, 0)},
+        {USB_DEVICE(0x0ac8, 0xc001), BF(VC0321, 0)},
+        {USB_DEVICE(0x0ac8, 0xc002), BF(VC0321, 0)},
+        {USB_DEVICE(0x0ac8, 0xc301), BF(VC0323, FL_SAMSUNG)},
+        {USB_DEVICE(0x15b8, 0x6001), BF(VC0323, 0)},
+        {USB_DEVICE(0x15b8, 0x6002), BF(VC0323, 0)},
+        {USB_DEVICE(0x17ef, 0x4802), BF(VC0323, 0)},
         {}
 };
 MODULE_DEVICE_TABLE(usb, device_table);
diff --git a/drivers/media/video/gspca/zc3xx.c b/drivers/media/video/gspca/zc3xx.c
index 3d2756f7874a..cdf3357b4c9f 100644
--- a/drivers/media/video/gspca/zc3xx.c
+++ b/drivers/media/video/gspca/zc3xx.c
@@ -7574,7 +7574,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 = sizeof sd_ctrls / sizeof sd_ctrls[0],
+        .nctrls = ARRAY_SIZE(sd_ctrls),
         .config = sd_config,
         .init = sd_init,
         .start = sd_start,
diff --git a/drivers/media/video/hdpvr/hdpvr-control.c b/drivers/media/video/hdpvr/hdpvr-control.c
index 06791749d1a0..5a6b78b8d25d 100644
--- a/drivers/media/video/hdpvr/hdpvr-control.c
+++ b/drivers/media/video/hdpvr/hdpvr-control.c
@@ -178,24 +178,24 @@ error:
 
 int hdpvr_set_options(struct hdpvr_device *dev)
 {
-       hdpvr_config_call(dev, CTRL_VIDEO_STD_TYPE, dev->options.video_std);
+        hdpvr_config_call(dev, CTRL_VIDEO_STD_TYPE, dev->options.video_std);
 
-       hdpvr_config_call(dev, CTRL_VIDEO_INPUT_VALUE,
+        hdpvr_config_call(dev, CTRL_VIDEO_INPUT_VALUE,
                          dev->options.video_input+1);
 
-       hdpvr_set_audio(dev, dev->options.audio_input+1,
+        hdpvr_set_audio(dev, dev->options.audio_input+1,
                        dev->options.audio_codec);
 
-       hdpvr_set_bitrate(dev);
-       hdpvr_config_call(dev, CTRL_BITRATE_MODE_VALUE,
+        hdpvr_set_bitrate(dev);
+        hdpvr_config_call(dev, CTRL_BITRATE_MODE_VALUE,
                          dev->options.bitrate_mode);
-       hdpvr_config_call(dev, CTRL_GOP_MODE_VALUE, dev->options.gop_mode);
+        hdpvr_config_call(dev, CTRL_GOP_MODE_VALUE, dev->options.gop_mode);
 
-       hdpvr_config_call(dev, CTRL_BRIGHTNESS, dev->options.brightness);
-       hdpvr_config_call(dev, CTRL_CONTRAST,   dev->options.contrast);
-       hdpvr_config_call(dev, CTRL_HUE,        dev->options.hue);
-       hdpvr_config_call(dev, CTRL_SATURATION, dev->options.saturation);
-       hdpvr_config_call(dev, CTRL_SHARPNESS,  dev->options.sharpness);
+        hdpvr_config_call(dev, CTRL_BRIGHTNESS, dev->options.brightness);
+        hdpvr_config_call(dev, CTRL_CONTRAST,   dev->options.contrast);
+        hdpvr_config_call(dev, CTRL_HUE,        dev->options.hue);
+        hdpvr_config_call(dev, CTRL_SATURATION, dev->options.saturation);
+        hdpvr_config_call(dev, CTRL_SHARPNESS,  dev->options.sharpness);
 
-       return 0;
+        return 0;
 }
diff --git a/drivers/media/video/hdpvr/hdpvr-core.c b/drivers/media/video/hdpvr/hdpvr-core.c
index 188bd5aea258..1c9bc94c905c 100644
--- a/drivers/media/video/hdpvr/hdpvr-core.c
+++ b/drivers/media/video/hdpvr/hdpvr-core.c
@@ -126,7 +126,7 @@ static int device_authorization(struct hdpvr_device *dev)
         char *print_buf = kzalloc(5*buf_size+1, GFP_KERNEL);
         if (!print_buf) {
                 v4l2_err(&dev->v4l2_dev, "Out of memory\n");
-                goto error;
+                return retval;
         }
 #endif
 
@@ -140,7 +140,7 @@ static int device_authorization(struct hdpvr_device *dev)
         if (ret != 46) {
                 v4l2_err(&dev->v4l2_dev,
                          "unexpected answer of status request, len %d\n", ret);
-                goto error;
+                goto unlock;
         }
 #ifdef HDPVR_DEBUG
         else {
@@ -163,7 +163,7 @@ static int device_authorization(struct hdpvr_device *dev)
                 v4l2_err(&dev->v4l2_dev, "unknown firmware version 0x%x\n",
                         dev->usbc_buf[1]);
                 ret = -EINVAL;
-                goto error;
+                goto unlock;
         }
 
         response = dev->usbc_buf+38;
@@ -188,10 +188,10 @@ static int device_authorization(struct hdpvr_device *dev)
                               10000);
         v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev,
                  "magic request returned %d\n", ret);
-        mutex_unlock(&dev->usbc_mutex);
 
         retval = ret != 8;
-error:
+unlock:
+        mutex_unlock(&dev->usbc_mutex);
         return retval;
 }
 
@@ -350,6 +350,7 @@ static int hdpvr_probe(struct usb_interface *interface,
 
         mutex_lock(&dev->io_mutex);
         if (hdpvr_alloc_buffers(dev, NUM_BUFFERS)) {
+                mutex_unlock(&dev->io_mutex);
                 v4l2_err(&dev->v4l2_dev,
                          "allocating transfer buffers failed\n");
                 goto error;
@@ -381,7 +382,6 @@ static int hdpvr_probe(struct usb_interface *interface,
 
 error:
         if (dev) {
-                mutex_unlock(&dev->io_mutex);
                 /* this frees allocated memory */
                 hdpvr_delete(dev);
         }
diff --git a/drivers/media/video/hdpvr/hdpvr-i2c.c b/drivers/media/video/hdpvr/hdpvr-i2c.c
index c4b5d1515c10..296330a0e1e5 100644
--- a/drivers/media/video/hdpvr/hdpvr-i2c.c
+++ b/drivers/media/video/hdpvr/hdpvr-i2c.c
@@ -127,7 +127,6 @@ int hdpvr_register_i2c_adapter(struct hdpvr_device *dev)
                 sizeof(i2c_adap->name));
         i2c_adap->algo  = &hdpvr_algo;
         i2c_adap->class = I2C_CLASS_TV_ANALOG;
-        i2c_adap->id    = I2C_HW_B_HDPVR;
         i2c_adap->owner = THIS_MODULE;
         i2c_adap->dev.parent = &dev->udev->dev;
 
diff --git a/drivers/media/video/hdpvr/hdpvr-video.c b/drivers/media/video/hdpvr/hdpvr-video.c
index d678765cbba2..2eb9dc2ebe59 100644
--- a/drivers/media/video/hdpvr/hdpvr-video.c
+++ b/drivers/media/video/hdpvr/hdpvr-video.c
@@ -375,6 +375,7 @@ static int hdpvr_open(struct file *file)
          * in resumption */
         mutex_lock(&dev->io_mutex);
         dev->open_count++;
+        mutex_unlock(&dev->io_mutex);
 
         fh->dev = dev;
 
@@ -383,7 +384,6 @@ static int hdpvr_open(struct file *file)
 
         retval = 0;
 err:
-        mutex_unlock(&dev->io_mutex);
         return retval;
 }
 
@@ -519,8 +519,10 @@ static unsigned int hdpvr_poll(struct file *filp, poll_table *wait)
 
         mutex_lock(&dev->io_mutex);
 
-        if (video_is_unregistered(dev->video_dev))
+        if (video_is_unregistered(dev->video_dev)) {
+                mutex_unlock(&dev->io_mutex);
                 return -EIO;
+        }
 
         if (dev->status == STATUS_IDLE) {
                 if (hdpvr_start_streaming(dev)) {
diff --git a/drivers/media/video/ir-kbd-i2c.c b/drivers/media/video/ir-kbd-i2c.c
index 86f2fefe1edf..247d3115a9b7 100644
--- a/drivers/media/video/ir-kbd-i2c.c
+++ b/drivers/media/video/ir-kbd-i2c.c
@@ -122,12 +122,12 @@ static int get_key_haup_common(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
         return 1;
 }
 
-static inline int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 {
         return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
 }
 
-static inline int get_key_haup_xvr(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+static int get_key_haup_xvr(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 {
         return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
 }
@@ -297,7 +297,7 @@ static void ir_work(struct work_struct *work)
 
 static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
 {
-        IR_KEYTAB_TYPE *ir_codes = NULL;
+        struct ir_scancode_table *ir_codes = NULL;
         const char *name = NULL;
         int ir_type;
         struct IR_i2c *ir;
@@ -322,13 +322,13 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
                 name        = "Pixelview";
                 ir->get_key = get_key_pixelview;
                 ir_type     = IR_TYPE_OTHER;
-                ir_codes    = ir_codes_empty;
+                ir_codes    = &ir_codes_empty_table;
                 break;
         case 0x4b:
                 name        = "PV951";
                 ir->get_key = get_key_pv951;
                 ir_type     = IR_TYPE_OTHER;
-                ir_codes    = ir_codes_pv951;
+                ir_codes    = &ir_codes_pv951_table;
                 break;
         case 0x18:
         case 0x1a:
@@ -336,36 +336,38 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
                 ir->get_key = get_key_haup;
                 ir_type     = IR_TYPE_RC5;
                 if (hauppauge == 1) {
-                        ir_codes    = ir_codes_hauppauge_new;
+                        ir_codes    = &ir_codes_hauppauge_new_table;
                 } else {
-                        ir_codes    = ir_codes_rc5_tv;
+                        ir_codes    = &ir_codes_rc5_tv_table;
                 }
                 break;
         case 0x30:
                 name        = "KNC One";
                 ir->get_key = get_key_knc1;
                 ir_type     = IR_TYPE_OTHER;
-                ir_codes    = ir_codes_empty;
+                ir_codes    = &ir_codes_empty_table;
                 break;
         case 0x6b:
                 name        = "FusionHDTV";
                 ir->get_key = get_key_fusionhdtv;
                 ir_type     = IR_TYPE_RC5;
-                ir_codes    = ir_codes_fusionhdtv_mce;
+                ir_codes    = &ir_codes_fusionhdtv_mce_table;
                 break;
         case 0x7a:
         case 0x47:
         case 0x71:
         case 0x2d:
-                if (adap->id == I2C_HW_B_CX2388x) {
+                if (adap->id == I2C_HW_B_CX2388x ||
+                    adap->id == I2C_HW_B_CX2341X) {
                         /* Handled by cx88-input */
-                        name        = "CX2388x remote";
+                        name = adap->id == I2C_HW_B_CX2341X ? "CX2341x remote"
+                                                            : "CX2388x remote";
                         ir_type     = IR_TYPE_RC5;
                         ir->get_key = get_key_haup_xvr;
                         if (hauppauge == 1) {
-                                ir_codes    = ir_codes_hauppauge_new;
+                                ir_codes    = &ir_codes_hauppauge_new_table;
                         } else {
-                                ir_codes    = ir_codes_rc5_tv;
+                                ir_codes    = &ir_codes_rc5_tv_table;
                         }
                 } else {
                         /* Handled by saa7134-input */
@@ -377,7 +379,7 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
                 name        = "AVerMedia Cardbus remote";
                 ir->get_key = get_key_avermedia_cardbus;
                 ir_type     = IR_TYPE_OTHER;
-                ir_codes    = ir_codes_avermedia_cardbus;
+                ir_codes    = &ir_codes_avermedia_cardbus_table;
                 break;
         default:
                 dprintk(1, DEVNAME ": Unsupported i2c address 0x%02x\n", addr);
@@ -392,7 +394,36 @@ static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
 
                 ir_codes = init_data->ir_codes;
                 name = init_data->name;
-                ir->get_key = init_data->get_key;
+                if (init_data->type)
+                        ir_type = init_data->type;
+
+                switch (init_data->internal_get_key_func) {
+                case IR_KBD_GET_KEY_CUSTOM:
+                        /* The bridge driver provided us its own function */
+                        ir->get_key = init_data->get_key;
+                        break;
+                case IR_KBD_GET_KEY_PIXELVIEW:
+                        ir->get_key = get_key_pixelview;
+                        break;
+                case IR_KBD_GET_KEY_PV951:
+                        ir->get_key = get_key_pv951;
+                        break;
+                case IR_KBD_GET_KEY_HAUP:
+                        ir->get_key = get_key_haup;
+                        break;
+                case IR_KBD_GET_KEY_KNC1:
+                        ir->get_key = get_key_knc1;
+                        break;
+                case IR_KBD_GET_KEY_FUSIONHDTV:
+                        ir->get_key = get_key_fusionhdtv;
+                        break;
+                case IR_KBD_GET_KEY_HAUP_XVR:
+                        ir->get_key = get_key_haup_xvr;
+                        break;
+                case IR_KBD_GET_KEY_AVERMEDIA_CARDBUS:
+                        ir->get_key = get_key_avermedia_cardbus;
+                        break;
+                }
         }
 
         /* Make sure we are all setup before going on */
@@ -454,7 +485,8 @@ static int ir_remove(struct i2c_client *client)
 static const struct i2c_device_id ir_kbd_id[] = {
         /* Generic entry for any IR receiver */
         { "ir_video", 0 },
-        /* IR device specific entries could be added here */
+        /* IR device specific entries should be added here */
+        { "ir_rx_z8f0811_haup", 0 },
         { }
 };
 
diff --git a/drivers/media/video/ivtv/ivtv-cards.c b/drivers/media/video/ivtv/ivtv-cards.c
index 2883c8780760..4873b6ca5801 100644
--- a/drivers/media/video/ivtv/ivtv-cards.c
+++ b/drivers/media/video/ivtv/ivtv-cards.c
@@ -977,26 +977,27 @@ static const struct ivtv_card ivtv_card_avertv_mce116 = {
 
 /* ------------------------------------------------------------------------- */
 
-/* AVerMedia PVR-150 Plus (M113) card */
+/* AVerMedia PVR-150 Plus / AVerTV M113 cards with a Daewoo/Partsnic Tuner */
 
 static const struct ivtv_card_pci_info ivtv_pci_aver_pvr150[] = {
-        { PCI_DEVICE_ID_IVTV16, IVTV_PCI_ID_AVERMEDIA, 0xc035 },
+        { PCI_DEVICE_ID_IVTV16, IVTV_PCI_ID_AVERMEDIA, 0xc034 }, /* NTSC */
+        { PCI_DEVICE_ID_IVTV16, IVTV_PCI_ID_AVERMEDIA, 0xc035 }, /* NTSC FM */
         { 0, 0, 0 }
 };
 
 static const struct ivtv_card ivtv_card_aver_pvr150 = {
         .type = IVTV_CARD_AVER_PVR150PLUS,
-        .name = "AVerMedia PVR-150 Plus",
+        .name = "AVerMedia PVR-150 Plus / AVerTV M113 Partsnic (Daewoo) Tuner",
         .v4l2_capabilities = IVTV_CAP_ENCODER,
         .hw_video = IVTV_HW_CX25840,
         .hw_audio = IVTV_HW_CX25840,
         .hw_audio_ctrl = IVTV_HW_CX25840,
         .hw_muxer = IVTV_HW_GPIO,
-        .hw_all = IVTV_HW_CX25840 | IVTV_HW_TUNER,
+        .hw_all = IVTV_HW_CX25840 | IVTV_HW_TUNER |
+                  IVTV_HW_WM8739 | IVTV_HW_GPIO,
         .video_inputs = {
                 { IVTV_CARD_INPUT_VID_TUNER,  0, CX25840_COMPOSITE2 },
-                { IVTV_CARD_INPUT_SVIDEO1,    1,
-                  CX25840_SVIDEO_LUMA3 | CX25840_SVIDEO_CHROMA4 },
+                { IVTV_CARD_INPUT_SVIDEO1,    1, CX25840_SVIDEO3    },
                 { IVTV_CARD_INPUT_COMPOSITE1, 1, CX25840_COMPOSITE1 },
         },
         .audio_inputs = {
@@ -1004,18 +1005,66 @@ static const struct ivtv_card ivtv_card_aver_pvr150 = {
                 { IVTV_CARD_INPUT_LINE_IN1,   CX25840_AUDIO_SERIAL, 1 },
         },
         .radio_input = { IVTV_CARD_INPUT_AUD_TUNER, CX25840_AUDIO_SERIAL, 2 },
-        .gpio_init = { .direction = 0x0800, .initial_value = 0 },
-        .gpio_audio_input  = { .mask = 0x0800, .tuner = 0, .linein = 0, .radio = 0x0800 },
+        /* The 74HC4052 Dual 4:1 multiplexer is controlled by 2 GPIO lines */
+        .gpio_init = { .direction = 0xc000, .initial_value = 0 },
+        .gpio_audio_input  = { .mask   = 0xc000,
+                               .tuner  = 0x0000,
+                               .linein = 0x4000,
+                               .radio  = 0x8000 },
         .tuners = {
-                /* This card has a Partsnic PTI-5NF05 tuner */
-                { .std = V4L2_STD_MN, .tuner = TUNER_TCL_2002N },
+                /* Subsystem ID's 0xc03[45] have a Partsnic PTI-5NF05 tuner */
+                { .std = V4L2_STD_MN, .tuner = TUNER_PARTSNIC_PTI_5NF05 },
         },
         .pci_list = ivtv_pci_aver_pvr150,
+        /* Subsystem ID 0xc035 has a TEA5767(?) FM tuner, 0xc034 does not */
         .i2c = &ivtv_i2c_radio,
 };
 
 /* ------------------------------------------------------------------------- */
 
+/* AVerMedia UltraTV 1500 MCE (newer non-cx88 version, M113 variant) card */
+
+static const struct ivtv_card_pci_info ivtv_pci_aver_ultra1500mce[] = {
+        { PCI_DEVICE_ID_IVTV16, IVTV_PCI_ID_AVERMEDIA, 0xc019 },
+        { 0, 0, 0 }
+};
+
+static const struct ivtv_card ivtv_card_aver_ultra1500mce = {
+        .type = IVTV_CARD_AVER_ULTRA1500MCE,
+        .name = "AVerMedia UltraTV 1500 MCE / AVerTV M113 Philips Tuner",
+        .v4l2_capabilities = IVTV_CAP_ENCODER,
+        .hw_video = IVTV_HW_CX25840,
+        .hw_audio = IVTV_HW_CX25840,
+        .hw_audio_ctrl = IVTV_HW_CX25840,
+        .hw_muxer = IVTV_HW_GPIO,
+        .hw_all = IVTV_HW_CX25840 | IVTV_HW_TUNER |
+                  IVTV_HW_WM8739 | IVTV_HW_GPIO,
+        .video_inputs = {
+                { IVTV_CARD_INPUT_VID_TUNER,  0, CX25840_COMPOSITE2 },
+                { IVTV_CARD_INPUT_SVIDEO1,    1, CX25840_SVIDEO3    },
+                { IVTV_CARD_INPUT_COMPOSITE1, 1, CX25840_COMPOSITE1 },
+        },
+        .audio_inputs = {
+                { IVTV_CARD_INPUT_AUD_TUNER,  CX25840_AUDIO5,       0 },
+                { IVTV_CARD_INPUT_LINE_IN1,   CX25840_AUDIO_SERIAL, 1 },
+        },
+        .radio_input = { IVTV_CARD_INPUT_AUD_TUNER, CX25840_AUDIO_SERIAL, 2 },
+        /* The 74HC4052 Dual 4:1 multiplexer is controlled by 2 GPIO lines */
+        .gpio_init = { .direction = 0xc000, .initial_value = 0 },
+        .gpio_audio_input  = { .mask   = 0xc000,
+                               .tuner  = 0x0000,
+                               .linein = 0x4000,
+                               .radio  = 0x8000 },
+        .tuners = {
+                /* The UltraTV 1500 MCE has a Philips FM1236 MK5 TV/FM tuner */
+                { .std = V4L2_STD_MN, .tuner = TUNER_PHILIPS_FM1236_MK3 },
+        },
+        .pci_list = ivtv_pci_aver_ultra1500mce,
+        .i2c = &ivtv_i2c_std,
+};
+
+/* ------------------------------------------------------------------------- */
+
 /* AVerMedia EZMaker PCI Deluxe card */
 
 static const struct ivtv_card_pci_info ivtv_pci_aver_ezmaker[] = {
@@ -1180,6 +1229,7 @@ static const struct ivtv_card *ivtv_card_list[] = {
         &ivtv_card_aver_ezmaker,
         &ivtv_card_aver_m104,
         &ivtv_card_buffalo,
+        &ivtv_card_aver_ultra1500mce,
 
         /* Variations of standard cards but with the same PCI IDs.
            These cards must come last in this list. */
diff --git a/drivers/media/video/ivtv/ivtv-cards.h b/drivers/media/video/ivtv/ivtv-cards.h
index 0b8fe85fb697..e99a0a255578 100644
--- a/drivers/media/video/ivtv/ivtv-cards.h
+++ b/drivers/media/video/ivtv/ivtv-cards.h
@@ -50,7 +50,8 @@
 #define IVTV_CARD_AVER_EZMAKER       23 /* AVerMedia EZMaker PCI Deluxe */
 #define IVTV_CARD_AVER_M104          24 /* AverMedia M104 miniPCI card */
 #define IVTV_CARD_BUFFALO_MV5L       25 /* Buffalo PC-MV5L/PCI card */
-#define IVTV_CARD_LAST               25
+#define IVTV_CARD_AVER_ULTRA1500MCE  26 /* AVerMedia UltraTV 1500 MCE */
+#define IVTV_CARD_LAST               26
 
 /* Variants of existing cards but with the same PCI IDs. The driver
    detects these based on other device information.
diff --git a/drivers/media/video/ivtv/ivtv-driver.c b/drivers/media/video/ivtv/ivtv-driver.c
index 558f8a837ff4..63ea0fb66063 100644
--- a/drivers/media/video/ivtv/ivtv-driver.c
+++ b/drivers/media/video/ivtv/ivtv-driver.c
@@ -186,6 +186,7 @@ MODULE_PARM_DESC(cardtype,
                  "\t\t\t24 = AverMedia EZMaker PCI Deluxe\n"
                  "\t\t\t25 = AverMedia M104 (not yet working)\n"
                  "\t\t\t26 = Buffalo PC-MV5L/PCI\n"
+                 "\t\t\t27 = AVerMedia UltraTV 1500 MCE\n"
                  "\t\t\t 0 = Autodetect (default)\n"
                  "\t\t\t-1 = Ignore this card\n\t\t");
 MODULE_PARM_DESC(pal, "Set PAL standard: BGH, DK, I, M, N, Nc, 60");
@@ -218,7 +219,7 @@ MODULE_PARM_DESC(ivtv_yuv_mode,
                  "\t\t\tDefault: 0 (interlaced)");
 MODULE_PARM_DESC(ivtv_yuv_threshold,
                  "If ivtv_yuv_mode is 2 (auto) then playback content as\n\t\tprogressive if src height <= ivtv_yuvthreshold\n"
-                 "\t\t\tDefault: 480");;
+                 "\t\t\tDefault: 480");
 MODULE_PARM_DESC(enc_mpg_buffers,
                  "Encoder MPG Buffers (in MB)\n"
                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_MPG_BUFFERS));
diff --git a/drivers/media/video/ivtv/ivtv-gpio.c b/drivers/media/video/ivtv/ivtv-gpio.c
index 85ac707228e7..aede061cae5d 100644
--- a/drivers/media/video/ivtv/ivtv-gpio.c
+++ b/drivers/media/video/ivtv/ivtv-gpio.c
@@ -236,18 +236,6 @@ static int subdev_s_radio(struct v4l2_subdev *sd)
         return 0;
 }
 
-static int subdev_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
-{
-        struct ivtv *itv = sd_to_ivtv(sd);
-        u16 mask, data;
-
-        mask = itv->card->gpio_audio_input.mask;
-        data = itv->card->gpio_audio_input.tuner;
-        if (mask)
-                write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT);
-        return 0;
-}
-
 static int subdev_s_audio_routing(struct v4l2_subdev *sd,
                                   u32 input, u32 output, u32 config)
 {
@@ -344,7 +332,6 @@ static const struct v4l2_subdev_core_ops subdev_core_ops = {
         .g_ctrl = subdev_g_ctrl,
         .s_ctrl = subdev_s_ctrl,
         .queryctrl = subdev_queryctrl,
-        .s_std = subdev_s_std,
 };
 
 static const struct v4l2_subdev_tuner_ops subdev_tuner_ops = {
diff --git a/drivers/media/video/ivtv/ivtv-i2c.c b/drivers/media/video/ivtv/ivtv-i2c.c
index e52aa322b134..8f15a31d3f66 100644
--- a/drivers/media/video/ivtv/ivtv-i2c.c
+++ b/drivers/media/video/ivtv/ivtv-i2c.c
@@ -509,7 +509,6 @@ static struct i2c_algorithm ivtv_algo = {
 /* template for our-bit banger */
 static struct i2c_adapter ivtv_i2c_adap_hw_template = {
         .name = "ivtv i2c driver",
-        .id = I2C_HW_B_CX2341X,
         .algo = &ivtv_algo,
         .algo_data = NULL,                      /* filled from template */
         .owner = THIS_MODULE,
@@ -560,7 +559,6 @@ static int ivtv_getsda_old(void *data)
 /* template for i2c-bit-algo */
 static struct i2c_adapter ivtv_i2c_adap_template = {
         .name = "ivtv i2c driver",
-        .id = I2C_HW_B_CX2341X,
         .algo = NULL,                   /* set by i2c-algo-bit */
         .algo_data = NULL,              /* filled from template */
         .owner = THIS_MODULE,
diff --git a/drivers/media/video/meye.c b/drivers/media/video/meye.c
index 1d66855a379a..d0765bed79c9 100644
--- a/drivers/media/video/meye.c
+++ b/drivers/media/video/meye.c
@@ -1915,8 +1915,7 @@ static void __devexit meye_remove(struct pci_dev *pcidev)
 }
 
 static struct pci_device_id meye_pci_tbl[] = {
-        { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002,
-          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+        { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
         { }
 };
 
diff --git a/drivers/media/video/pvrusb2/pvrusb2-audio.c b/drivers/media/video/pvrusb2/pvrusb2-audio.c
index 416933ca607d..cc06d5e4adcc 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-audio.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-audio.c
@@ -65,9 +65,10 @@ void pvr2_msp3400_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
                 u32 input;
 
                 pvr2_trace(PVR2_TRACE_CHIPS, "subdev msp3400 v4l2 set_stereo");
+                sp = (sid < ARRAY_SIZE(routing_schemes)) ?
+                        routing_schemes[sid] : NULL;
 
-                if ((sid < ARRAY_SIZE(routing_schemes)) &&
-                    ((sp = routing_schemes[sid]) != NULL) &&
+                if ((sp != NULL) &&
                     (hdw->input_val >= 0) &&
                     (hdw->input_val < sp->cnt)) {
                         input = sp->def[hdw->input_val];
diff --git a/drivers/media/video/pvrusb2/pvrusb2-i2c-core.c b/drivers/media/video/pvrusb2/pvrusb2-i2c-core.c
index 610bd848df24..a334b1a966a2 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-i2c-core.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-i2c-core.c
@@ -540,7 +540,6 @@ static struct i2c_algorithm pvr2_i2c_algo_template = {
 static struct i2c_adapter pvr2_i2c_adap_template = {
         .owner         = THIS_MODULE,
         .class         = 0,
-        .id            = I2C_HW_B_BT848,
 };
 
 
diff --git a/drivers/media/video/pwc/pwc-if.c b/drivers/media/video/pwc/pwc-if.c
index 8d17cf613306..f976df452a34 100644
--- a/drivers/media/video/pwc/pwc-if.c
+++ b/drivers/media/video/pwc/pwc-if.c
@@ -1057,7 +1057,8 @@ static int pwc_create_sysfs_files(struct video_device *vdev)
                 goto err;
         if (pdev->features & FEATURE_MOTOR_PANTILT) {
                 rc = device_create_file(&vdev->dev, &dev_attr_pan_tilt);
-                if (rc) goto err_button;
+                if (rc)
+                        goto err_button;
         }
 
         return 0;
@@ -1072,6 +1073,7 @@ err:
 static void pwc_remove_sysfs_files(struct video_device *vdev)
 {
         struct pwc_device *pdev = video_get_drvdata(vdev);
+
         if (pdev->features & FEATURE_MOTOR_PANTILT)
                 device_remove_file(&vdev->dev, &dev_attr_pan_tilt);
         device_remove_file(&vdev->dev, &dev_attr_button);
@@ -1229,13 +1231,11 @@ static void pwc_cleanup(struct pwc_device *pdev)
         video_unregister_device(pdev->vdev);
 
 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
-        if (pdev->button_dev) {
+        if (pdev->button_dev)
                 input_unregister_device(pdev->button_dev);
-                input_free_device(pdev->button_dev);
-                kfree(pdev->button_dev->phys);
-                pdev->button_dev = NULL;
-        }
 #endif
+
+        kfree(pdev);
 }
 
 /* Note that all cleanup is done in the reverse order as in _open */
@@ -1281,8 +1281,6 @@ static int pwc_video_close(struct file *file)
                 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
         } else {
                 pwc_cleanup(pdev);
-                /* Free memory (don't set pdev to 0 just yet) */
-                kfree(pdev);
                 /* search device_hint[] table if we occupy a slot, by any chance */
                 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
                         if (device_hint[hint].pdev == pdev)
@@ -1499,13 +1497,10 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         struct usb_device *udev = interface_to_usbdev(intf);
         struct pwc_device *pdev = NULL;
         int vendor_id, product_id, type_id;
-        int i, hint, rc;
+        int hint, rc;
         int features = 0;
         int video_nr = -1; /* default: use next available device */
         char serial_number[30], *name;
-#ifdef CONFIG_USB_PWC_INPUT_EVDEV
-        char *phys = NULL;
-#endif
 
         vendor_id = le16_to_cpu(udev->descriptor.idVendor);
         product_id = le16_to_cpu(udev->descriptor.idProduct);
@@ -1757,8 +1752,7 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         pdev->vframes = default_fps;
         strcpy(pdev->serial, serial_number);
         pdev->features = features;
-        if (vendor_id == 0x046D && product_id == 0x08B5)
-        {
+        if (vendor_id == 0x046D && product_id == 0x08B5) {
                 /* Logitech QuickCam Orbit
                    The ranges have been determined experimentally; they may differ from cam to cam.
                    Also, the exact ranges left-right and up-down are different for my cam
@@ -1780,8 +1774,8 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         pdev->vdev = video_device_alloc();
         if (!pdev->vdev) {
                 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
-                kfree(pdev);
-                return -ENOMEM;
+                rc = -ENOMEM;
+                goto err_free_mem;
         }
         memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
         pdev->vdev->parent = &intf->dev;
@@ -1806,25 +1800,23 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         }
 
         pdev->vdev->release = video_device_release;
-        i = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
-        if (i < 0) {
-                PWC_ERROR("Failed to register as video device (%d).\n", i);
-                rc = i;
-                goto err;
-        }
-        else {
-                PWC_INFO("Registered as /dev/video%d.\n", pdev->vdev->num);
+        rc = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
+        if (rc < 0) {
+                PWC_ERROR("Failed to register as video device (%d).\n", rc);
+                goto err_video_release;
         }
 
+        PWC_INFO("Registered as /dev/video%d.\n", pdev->vdev->num);
+
         /* occupy slot */
         if (hint < MAX_DEV_HINTS)
                 device_hint[hint].pdev = pdev;
 
         PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
-        usb_set_intfdata (intf, pdev);
+        usb_set_intfdata(intf, pdev);
         rc = pwc_create_sysfs_files(pdev->vdev);
         if (rc)
-                goto err_unreg;
+                goto err_video_unreg;
 
         /* Set the leds off */
         pwc_set_leds(pdev, 0, 0);
@@ -1835,16 +1827,16 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         pdev->button_dev = input_allocate_device();
         if (!pdev->button_dev) {
                 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
-                return -ENOMEM;
+                rc = -ENOMEM;
+                pwc_remove_sysfs_files(pdev->vdev);
+                goto err_video_unreg;
         }
 
+        usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
+        strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
+
         pdev->button_dev->name = "PWC snapshot button";
-        phys = kasprintf(GFP_KERNEL,"usb-%s-%s", pdev->udev->bus->bus_name, pdev->udev->devpath);
-        if (!phys) {
-                input_free_device(pdev->button_dev);
-                return -ENOMEM;
-        }
-        pdev->button_dev->phys = phys;
+        pdev->button_dev->phys = pdev->button_phys;
         usb_to_input_id(pdev->udev, &pdev->button_dev->id);
         pdev->button_dev->dev.parent = &pdev->udev->dev;
         pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
@@ -1853,25 +1845,27 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         rc = input_register_device(pdev->button_dev);
         if (rc) {
                 input_free_device(pdev->button_dev);
-                kfree(pdev->button_dev->phys);
                 pdev->button_dev = NULL;
-                return rc;
+                pwc_remove_sysfs_files(pdev->vdev);
+                goto err_video_unreg;
         }
 #endif
 
         return 0;
 
-err_unreg:
+err_video_unreg:
         if (hint < MAX_DEV_HINTS)
                 device_hint[hint].pdev = NULL;
         video_unregister_device(pdev->vdev);
-err:
-        video_device_release(pdev->vdev); /* Drip... drip... drip... */
-        kfree(pdev); /* Oops, no memory leaks please */
+        pdev->vdev = NULL;      /* So we don't try to release it below */
+err_video_release:
+        video_device_release(pdev->vdev);
+err_free_mem:
+        kfree(pdev);
         return rc;
 }
 
-/* The user janked out the cable... */
+/* The user yanked out the cable... */
 static void usb_pwc_disconnect(struct usb_interface *intf)
 {
         struct pwc_device *pdev;
@@ -1902,7 +1896,7 @@ static void usb_pwc_disconnect(struct usb_interface *intf)
         /* Alert waiting processes */
         wake_up_interruptible(&pdev->frameq);
         /* Wait until device is closed */
-        if(pdev->vopen) {
+        if (pdev->vopen) {
                 mutex_lock(&pdev->modlock);
                 pdev->unplugged = 1;
                 mutex_unlock(&pdev->modlock);
@@ -1911,8 +1905,6 @@ static void usb_pwc_disconnect(struct usb_interface *intf)
                 /* Device is closed, so we can safely unregister it */
                 PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
                 pwc_cleanup(pdev);
-                /* Free memory (don't set pdev to 0 just yet) */
-                kfree(pdev);
 
 disconnect_out:
                 /* search device_hint[] table if we occupy a slot, by any chance */
diff --git a/drivers/media/video/pwc/pwc-v4l.c b/drivers/media/video/pwc/pwc-v4l.c
index 2876ce084510..bdb4ced57496 100644
--- a/drivers/media/video/pwc/pwc-v4l.c
+++ b/drivers/media/video/pwc/pwc-v4l.c
@@ -1033,7 +1033,7 @@ long pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                         if (std->index != 0)
                                 return -EINVAL;
                         std->id = V4L2_STD_UNKNOWN;
-                        strncpy(std->name, "webcam", sizeof(std->name));
+                        strlcpy(std->name, "webcam", sizeof(std->name));
                         return 0;
                 }
 
diff --git a/drivers/media/video/pwc/pwc.h b/drivers/media/video/pwc/pwc.h
index 0b658dee05a4..0902355dfa77 100644
--- a/drivers/media/video/pwc/pwc.h
+++ b/drivers/media/video/pwc/pwc.h
@@ -135,12 +135,6 @@
 #define DEVICE_USE_CODEC3(x) ((x)>=700)
 #define DEVICE_USE_CODEC23(x) ((x)>=675)
 
-
-#ifndef V4L2_PIX_FMT_PWC1
-#define V4L2_PIX_FMT_PWC1       v4l2_fourcc('P','W','C','1')
-#define V4L2_PIX_FMT_PWC2       v4l2_fourcc('P','W','C','2')
-#endif
-
 /* The following structures were based on cpia.h. Why reinvent the wheel? :-) */
 struct pwc_iso_buf
 {
@@ -259,6 +253,7 @@ struct pwc_device
    int snapshot_button_status;          /* set to 1 when the user push the button, reset to 0 when this value is read */
 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
    struct input_dev *button_dev;        /* webcam snapshot button input */
+   char button_phys[64];
 #endif
 
    /*** Misc. data ***/
diff --git a/drivers/media/video/saa6588.c b/drivers/media/video/saa6588.c
index c25e81af5ce0..c3e96f070973 100644
--- a/drivers/media/video/saa6588.c
+++ b/drivers/media/video/saa6588.c
@@ -40,7 +40,7 @@
 /* insmod options */
 static unsigned int debug;
 static unsigned int xtal;
-static unsigned int rbds;
+static unsigned int mmbs;
 static unsigned int plvl;
 static unsigned int bufblocks = 100;
 
@@ -48,8 +48,8 @@ module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "enable debug messages");
 module_param(xtal, int, 0);
 MODULE_PARM_DESC(xtal, "select oscillator frequency (0..3), default 0");
-module_param(rbds, int, 0);
-MODULE_PARM_DESC(rbds, "select mode, 0=RDS, 1=RBDS, default 0");
+module_param(mmbs, int, 0);
+MODULE_PARM_DESC(mmbs, "enable MMBS mode: 0=off (default), 1=on");
 module_param(plvl, int, 0);
 MODULE_PARM_DESC(plvl, "select pause level (0..3), default 0");
 module_param(bufblocks, int, 0);
@@ -78,6 +78,7 @@ struct saa6588 {
         unsigned char last_blocknum;
         wait_queue_head_t read_queue;
         int data_available_for_read;
+        u8 sync;
 };
 
 static inline struct saa6588 *to_saa6588(struct v4l2_subdev *sd)
@@ -261,13 +262,16 @@ static void saa6588_i2c_poll(struct saa6588 *s)
         unsigned char tmp;
 
         /* Although we only need 3 bytes, we have to read at least 6.
-           SAA6588 returns garbage otherwise */
+           SAA6588 returns garbage otherwise. */
         if (6 != i2c_master_recv(client, &tmpbuf[0], 6)) {
                 if (debug > 1)
                         dprintk(PREFIX "read error!\n");
                 return;
         }
 
+        s->sync = tmpbuf[0] & 0x10;
+        if (!s->sync)
+                return;
         blocknum = tmpbuf[0] >> 5;
         if (blocknum == s->last_blocknum) {
                 if (debug > 3)
@@ -286,9 +290,8 @@ static void saa6588_i2c_poll(struct saa6588 *s)
            occurred during reception of this block.
            Bit 6: Corrected bit. Indicates that an error was
            corrected for this data block.
-           Bits 5-3: Received Offset. Indicates the offset received
-           by the sync system.
-           Bits 2-0: Offset Name. Indicates the offset applied to this data.
+           Bits 5-3: Same as bits 0-2.
+           Bits 2-0: Block number.
 
            SAA6588 byte order is Status-MSB-LSB, so we have to swap the
            first and the last of the 3 bytes block.
@@ -298,12 +301,21 @@ static void saa6588_i2c_poll(struct saa6588 *s)
         tmpbuf[2] = tmpbuf[0];
         tmpbuf[0] = tmp;
 
+        /* Map 'Invalid block E' to 'Invalid Block' */
+        if (blocknum == 6)
+                blocknum = V4L2_RDS_BLOCK_INVALID;
+        /* And if are not in mmbs mode, then 'Block E' is also mapped
+           to 'Invalid Block'. As far as I can tell MMBS is discontinued,
+           and if there is ever a need to support E blocks, then please
+           contact the linux-media mailinglist. */
+        else if (!mmbs && blocknum == 5)
+                blocknum = V4L2_RDS_BLOCK_INVALID;
         tmp = blocknum;
         tmp |= blocknum << 3;   /* Received offset == Offset Name (OK ?) */
         if ((tmpbuf[2] & 0x03) == 0x03)
-                tmp |= 0x80;    /* uncorrectable error */
+                tmp |= V4L2_RDS_BLOCK_ERROR;     /* uncorrectable error */
         else if ((tmpbuf[2] & 0x03) != 0x00)
-                tmp |= 0x40;    /* corrected error */
+                tmp |= V4L2_RDS_BLOCK_CORRECTED; /* corrected error */
         tmpbuf[2] = tmp;        /* Is this enough ? Should we also check other bits ? */
 
         spin_lock_irqsave(&s->lock, flags);
@@ -321,14 +333,14 @@ static void saa6588_work(struct work_struct *work)
         schedule_delayed_work(&s->work, msecs_to_jiffies(20));
 }
 
-static int saa6588_configure(struct saa6588 *s)
+static void saa6588_configure(struct saa6588 *s)
 {
         struct i2c_client *client = v4l2_get_subdevdata(&s->sd);
         unsigned char buf[3];
         int rc;
 
         buf[0] = cSyncRestart;
-        if (rbds)
+        if (mmbs)
                 buf[0] |= cProcessingModeRBDS;
 
         buf[1] = cFlywheelDefault;
@@ -374,8 +386,6 @@ static int saa6588_configure(struct saa6588 *s)
         rc = i2c_master_send(client, buf, 3);
         if (rc != 3)
                 printk(PREFIX "i2c i/o error: rc == %d (should be 3)\n", rc);
-
-        return 0;
 }
 
 /* ---------------------------------------------------------------------- */
@@ -416,6 +426,24 @@ static long saa6588_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
         return 0;
 }
 
+static int saa6588_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
+{
+        struct saa6588 *s = to_saa6588(sd);
+
+        vt->capability |= V4L2_TUNER_CAP_RDS;
+        if (s->sync)
+                vt->rxsubchans |= V4L2_TUNER_SUB_RDS;
+        return 0;
+}
+
+static int saa6588_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
+{
+        struct saa6588 *s = to_saa6588(sd);
+
+        saa6588_configure(s);
+        return 0;
+}
+
 static int saa6588_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
@@ -430,8 +458,14 @@ static const struct v4l2_subdev_core_ops saa6588_core_ops = {
         .ioctl = saa6588_ioctl,
 };
 
+static const struct v4l2_subdev_tuner_ops saa6588_tuner_ops = {
+        .g_tuner = saa6588_g_tuner,
+        .s_tuner = saa6588_s_tuner,
+};
+
 static const struct v4l2_subdev_ops saa6588_ops = {
         .core = &saa6588_core_ops,
+        .tuner = &saa6588_tuner_ops,
 };
 
 /* ---------------------------------------------------------------------- */
diff --git a/drivers/media/video/saa7134/Kconfig b/drivers/media/video/saa7134/Kconfig
index 5bcce092e804..22bfd62c9551 100644
--- a/drivers/media/video/saa7134/Kconfig
+++ b/drivers/media/video/saa7134/Kconfig
@@ -47,6 +47,7 @@ config VIDEO_SAA7134_DVB
         select DVB_TDA10048 if !DVB_FE_CUSTOMISE
         select MEDIA_TUNER_TDA18271 if !MEDIA_TUNER_CUSTOMISE
         select MEDIA_TUNER_TDA8290 if !MEDIA_TUNER_CUSTOMISE
+        select DVB_ZL10039 if !DVB_FE_CUSTOMISE
         ---help---
           This adds support for DVB cards based on the
           Philips saa7134 chip.
diff --git a/drivers/media/video/saa7134/saa6752hs.c b/drivers/media/video/saa7134/saa6752hs.c
index 63c4b8f1f541..1eabff6b2456 100644
--- a/drivers/media/video/saa7134/saa6752hs.c
+++ b/drivers/media/video/saa7134/saa6752hs.c
@@ -468,7 +468,7 @@ static int handle_ctrl(int has_ac3, struct saa6752hs_mpeg_params *params,
                 if (set && new != V4L2_MPEG_AUDIO_ENCODING_LAYER_2 &&
                     (!has_ac3 || new != V4L2_MPEG_AUDIO_ENCODING_AC3))
                         return -ERANGE;
-                new = old;
+                params->au_encoding = new;
                 break;
         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
                 old = params->au_l2_bitrate;
diff --git a/drivers/media/video/saa7134/saa7134-alsa.c b/drivers/media/video/saa7134/saa7134-alsa.c
index 8b0b64a89874..d48c450ed77c 100644
--- a/drivers/media/video/saa7134/saa7134-alsa.c
+++ b/drivers/media/video/saa7134/saa7134-alsa.c
@@ -40,6 +40,7 @@ MODULE_PARM_DESC(debug,"enable debug messages [alsa]");
  */
 
 /* defaults */
+#define MIXER_ADDR_UNSELECTED   -1
 #define MIXER_ADDR_TVTUNER      0
 #define MIXER_ADDR_LINE1        1
 #define MIXER_ADDR_LINE2        2
@@ -68,7 +69,9 @@ typedef struct snd_card_saa7134 {
         struct snd_card *card;
         spinlock_t mixer_lock;
         int mixer_volume[MIXER_ADDR_LAST+1][2];
-        int capture_source[MIXER_ADDR_LAST+1][2];
+        int capture_source_addr;
+        int capture_source[2];
+        struct snd_kcontrol *capture_ctl[MIXER_ADDR_LAST+1];
         struct pci_dev *pci;
         struct saa7134_dev *dev;
 
@@ -314,6 +317,115 @@ static int dsp_buffer_free(struct saa7134_dev *dev)
         return 0;
 }
 
+/*
+ * Setting the capture source and updating the ALSA controls
+ */
+static int snd_saa7134_capsrc_set(struct snd_kcontrol *kcontrol,
+                                  int left, int right, bool force_notify)
+{
+        snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol);
+        int change = 0, addr = kcontrol->private_value;
+        int active, old_addr;
+        u32 anabar, xbarin;
+        int analog_io, rate;
+        struct saa7134_dev *dev;
+
+        dev = chip->dev;
+
+        spin_lock_irq(&chip->mixer_lock);
+
+        active = left != 0 || right != 0;
+        old_addr = chip->capture_source_addr;
+
+        /* The active capture source cannot be deactivated */
+        if (active) {
+                change = old_addr != addr ||
+                         chip->capture_source[0] != left ||
+                         chip->capture_source[1] != right;
+
+                chip->capture_source[0] = left;
+                chip->capture_source[1] = right;
+                chip->capture_source_addr = addr;
+                dev->dmasound.input = addr;
+        }
+        spin_unlock_irq(&chip->mixer_lock);
+
+        if (change) {
+                switch (dev->pci->device) {
+
+                case PCI_DEVICE_ID_PHILIPS_SAA7134:
+                        switch (addr) {
+                        case MIXER_ADDR_TVTUNER:
+                                saa_andorb(SAA7134_AUDIO_FORMAT_CTRL,
+                                           0xc0, 0xc0);
+                                saa_andorb(SAA7134_SIF_SAMPLE_FREQ,
+                                           0x03, 0x00);
+                                break;
+                        case MIXER_ADDR_LINE1:
+                        case MIXER_ADDR_LINE2:
+                                analog_io = (MIXER_ADDR_LINE1 == addr) ?
+                                             0x00 : 0x08;
+                                rate = (32000 == dev->dmasound.rate) ?
+                                        0x01 : 0x03;
+                                saa_andorb(SAA7134_ANALOG_IO_SELECT,
+                                           0x08, analog_io);
+                                saa_andorb(SAA7134_AUDIO_FORMAT_CTRL,
+                                           0xc0, 0x80);
+                                saa_andorb(SAA7134_SIF_SAMPLE_FREQ,
+                                           0x03, rate);
+                                break;
+                        }
+
+                        break;
+                case PCI_DEVICE_ID_PHILIPS_SAA7133:
+                case PCI_DEVICE_ID_PHILIPS_SAA7135:
+                        xbarin = 0x03; /* adc */
+                        anabar = 0;
+                        switch (addr) {
+                        case MIXER_ADDR_TVTUNER:
+                                xbarin = 0; /* Demodulator */
+                                anabar = 2; /* DACs */
+                                break;
+                        case MIXER_ADDR_LINE1:
+                                anabar = 0;  /* aux1, aux1 */
+                                break;
+                        case MIXER_ADDR_LINE2:
+                                anabar = 9;  /* aux2, aux2 */
+                                break;
+                        }
+
+                        /* output xbar always main channel */
+                        saa_dsp_writel(dev, SAA7133_DIGITAL_OUTPUT_SEL1,
+                                       0xbbbb10);
+
+                        if (left || right) {
+                                /* We've got data, turn the input on */
+                                saa_dsp_writel(dev, SAA7133_DIGITAL_INPUT_XBAR1,
+                                               xbarin);
+                                saa_writel(SAA7133_ANALOG_IO_SELECT, anabar);
+                        } else {
+                                saa_dsp_writel(dev, SAA7133_DIGITAL_INPUT_XBAR1,
+                                               0);
+                                saa_writel(SAA7133_ANALOG_IO_SELECT, 0);
+                        }
+                        break;
+                }
+        }
+
+        if (change) {
+                if (force_notify)
+                        snd_ctl_notify(chip->card,
+                                       SNDRV_CTL_EVENT_MASK_VALUE,
+                                       &chip->capture_ctl[addr]->id);
+
+                if (old_addr != MIXER_ADDR_UNSELECTED && old_addr != addr)
+                        snd_ctl_notify(chip->card,
+                                       SNDRV_CTL_EVENT_MASK_VALUE,
+                                       &chip->capture_ctl[old_addr]->id);
+        }
+
+        return change;
+}
 
 /*
  * ALSA PCM preparation
@@ -401,6 +513,10 @@ static int snd_card_saa7134_capture_prepare(struct snd_pcm_substream * substream
 
         dev->dmasound.rate = runtime->rate;
 
+        /* Setup and update the card/ALSA controls */
+        snd_saa7134_capsrc_set(saa7134->capture_ctl[dev->dmasound.input], 1, 1,
+                               true);
+
         return 0;
 
 }
@@ -435,6 +551,16 @@ snd_card_saa7134_capture_pointer(struct snd_pcm_substream * substream)
 
 /*
  * ALSA hardware capabilities definition
+ *
+ *  Report only 32kHz for ALSA:
+ *
+ *  - SAA7133/35 uses DDEP (DemDec Easy Programming mode), which works in 32kHz
+ *    only
+ *  - SAA7134 for TV mode uses DemDec mode (32kHz)
+ *  - Radio works in 32kHz only
+ *  - When recording 48kHz from Line1/Line2, switching of capture source to TV
+ *    means
+ *    switching to 32kHz without any frequency translation
  */
 
 static struct snd_pcm_hardware snd_card_saa7134_capture =
@@ -448,9 +574,9 @@ static struct snd_pcm_hardware snd_card_saa7134_capture =
                                 SNDRV_PCM_FMTBIT_U8 | \
                                 SNDRV_PCM_FMTBIT_U16_LE | \
                                 SNDRV_PCM_FMTBIT_U16_BE,
-        .rates =                SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_48000,
+        .rates =                SNDRV_PCM_RATE_32000,
         .rate_min =             32000,
-        .rate_max =             48000,
+        .rate_max =             32000,
         .channels_min =         1,
         .channels_max =         2,
         .buffer_bytes_max =     (256*1024),
@@ -836,8 +962,13 @@ static int snd_saa7134_capsrc_get(struct snd_kcontrol * kcontrol,
         int addr = kcontrol->private_value;
 
         spin_lock_irq(&chip->mixer_lock);
-        ucontrol->value.integer.value[0] = chip->capture_source[addr][0];
-        ucontrol->value.integer.value[1] = chip->capture_source[addr][1];
+        if (chip->capture_source_addr == addr) {
+                ucontrol->value.integer.value[0] = chip->capture_source[0];
+                ucontrol->value.integer.value[1] = chip->capture_source[1];
+        } else {
+                ucontrol->value.integer.value[0] = 0;
+                ucontrol->value.integer.value[1] = 0;
+        }
         spin_unlock_irq(&chip->mixer_lock);
 
         return 0;
@@ -846,87 +977,22 @@ static int snd_saa7134_capsrc_get(struct snd_kcontrol * kcontrol,
 static int snd_saa7134_capsrc_put(struct snd_kcontrol * kcontrol,
                                   struct snd_ctl_elem_value * ucontrol)
 {
-        snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol);
-        int change, addr = kcontrol->private_value;
         int left, right;
-        u32 anabar, xbarin;
-        int analog_io, rate;
-        struct saa7134_dev *dev;
-
-        dev = chip->dev;
-
         left = ucontrol->value.integer.value[0] & 1;
         right = ucontrol->value.integer.value[1] & 1;
-        spin_lock_irq(&chip->mixer_lock);
-
-        change = chip->capture_source[addr][0] != left ||
-                 chip->capture_source[addr][1] != right;
-        chip->capture_source[addr][0] = left;
-        chip->capture_source[addr][1] = right;
-        dev->dmasound.input=addr;
-        spin_unlock_irq(&chip->mixer_lock);
-
-
-        if (change) {
-          switch (dev->pci->device) {
-
-           case PCI_DEVICE_ID_PHILIPS_SAA7134:
-                switch (addr) {
-                        case MIXER_ADDR_TVTUNER:
-                                saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, 0xc0);
-                                saa_andorb(SAA7134_SIF_SAMPLE_FREQ,   0x03, 0x00);
-                                break;
-                        case MIXER_ADDR_LINE1:
-                        case MIXER_ADDR_LINE2:
-                                analog_io = (MIXER_ADDR_LINE1 == addr) ? 0x00 : 0x08;
-                                rate = (32000 == dev->dmasound.rate) ? 0x01 : 0x03;
-                                saa_andorb(SAA7134_ANALOG_IO_SELECT,  0x08, analog_io);
-                                saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, 0x80);
-                                saa_andorb(SAA7134_SIF_SAMPLE_FREQ,   0x03, rate);
-                                break;
-                }
-
-                break;
-           case PCI_DEVICE_ID_PHILIPS_SAA7133:
-           case PCI_DEVICE_ID_PHILIPS_SAA7135:
-                xbarin = 0x03; // adc
-                anabar = 0;
-                switch (addr) {
-                        case MIXER_ADDR_TVTUNER:
-                                xbarin = 0; // Demodulator
-                                anabar = 2; // DACs
-                                break;
-                        case MIXER_ADDR_LINE1:
-                                anabar = 0;  // aux1, aux1
-                                break;
-                        case MIXER_ADDR_LINE2:
-                                anabar = 9;  // aux2, aux2
-                                break;
-                }
-
-                /* output xbar always main channel */
-                saa_dsp_writel(dev, SAA7133_DIGITAL_OUTPUT_SEL1, 0xbbbb10);
 
-                if (left || right) { // We've got data, turn the input on
-                  saa_dsp_writel(dev, SAA7133_DIGITAL_INPUT_XBAR1, xbarin);
-                  saa_writel(SAA7133_ANALOG_IO_SELECT, anabar);
-                } else {
-                  saa_dsp_writel(dev, SAA7133_DIGITAL_INPUT_XBAR1, 0);
-                  saa_writel(SAA7133_ANALOG_IO_SELECT, 0);
-                }
-                break;
-          }
-        }
-
-        return change;
+        return snd_saa7134_capsrc_set(kcontrol, left, right, false);
 }
 
-static struct snd_kcontrol_new snd_saa7134_controls[] = {
+static struct snd_kcontrol_new snd_saa7134_volume_controls[] = {
 SAA713x_VOLUME("Video Volume", 0, MIXER_ADDR_TVTUNER),
-SAA713x_CAPSRC("Video Capture Switch", 0, MIXER_ADDR_TVTUNER),
 SAA713x_VOLUME("Line Volume", 1, MIXER_ADDR_LINE1),
-SAA713x_CAPSRC("Line Capture Switch", 1, MIXER_ADDR_LINE1),
 SAA713x_VOLUME("Line Volume", 2, MIXER_ADDR_LINE2),
+};
+
+static struct snd_kcontrol_new snd_saa7134_capture_controls[] = {
+SAA713x_CAPSRC("Video Capture Switch", 0, MIXER_ADDR_TVTUNER),
+SAA713x_CAPSRC("Line Capture Switch", 1, MIXER_ADDR_LINE1),
 SAA713x_CAPSRC("Line Capture Switch", 2, MIXER_ADDR_LINE2),
 };
 
@@ -941,17 +1007,33 @@ SAA713x_CAPSRC("Line Capture Switch", 2, MIXER_ADDR_LINE2),
 static int snd_card_saa7134_new_mixer(snd_card_saa7134_t * chip)
 {
         struct snd_card *card = chip->card;
+        struct snd_kcontrol *kcontrol;
         unsigned int idx;
-        int err;
+        int err, addr;
 
         if (snd_BUG_ON(!chip))
                 return -EINVAL;
         strcpy(card->mixername, "SAA7134 Mixer");
 
-        for (idx = 0; idx < ARRAY_SIZE(snd_saa7134_controls); idx++) {
-                if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_saa7134_controls[idx], chip))) < 0)
+        for (idx = 0; idx < ARRAY_SIZE(snd_saa7134_volume_controls); idx++) {
+                kcontrol = snd_ctl_new1(&snd_saa7134_volume_controls[idx],
+                                        chip);
+                err = snd_ctl_add(card, kcontrol);
+                if (err < 0)
                         return err;
         }
+
+        for (idx = 0; idx < ARRAY_SIZE(snd_saa7134_capture_controls); idx++) {
+                kcontrol = snd_ctl_new1(&snd_saa7134_capture_controls[idx],
+                                        chip);
+                addr = snd_saa7134_capture_controls[idx].private_value;
+                chip->capture_ctl[addr] = kcontrol;
+                err = snd_ctl_add(card, kcontrol);
+                if (err < 0)
+                        return err;
+        }
+
+        chip->capture_source_addr = MIXER_ADDR_UNSELECTED;
         return 0;
 }
 
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c
index 6eebe3ef97d3..1b29487fd254 100644
--- a/drivers/media/video/saa7134/saa7134-cards.c
+++ b/drivers/media/video/saa7134/saa7134-cards.c
@@ -32,6 +32,7 @@
 #include <media/tveeprom.h>
 #include "tea5767.h"
 #include "tda18271.h"
+#include "xc5000.h"
 
 /* commly used strings */
 static char name_mute[]    = "mute";
@@ -265,6 +266,56 @@ struct saa7134_board saa7134_boards[] = {
                         .gpio = 0x10000,
                 },
         },
+        [SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM] = {
+                /* RoverMedia TV Link Pro FM (LR138 REV:I) */
+                /* Eugene Yudin <Eugene.Yudin@gmail.com> */
+                .name           = "RoverMedia TV Link Pro FM",
+                .audio_clock    = 0x00200000,
+                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3, /* TCL MFPE05 2 */
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .tda9887_conf   = TDA9887_PRESENT,
+                .gpiomask       = 0xe000,
+                .inputs         = { {
+                        .name = name_tv,
+                        .vmux = 1,
+                        .amux = TV,
+                        .gpio = 0x8000,
+                        .tv   = 1,
+                }, {
+                        .name = name_tv_mono,
+                        .vmux = 1,
+                        .amux = LINE2,
+                        .gpio = 0x0000,
+                        .tv   = 1,
+                }, {
+                        .name = name_comp1,
+                        .vmux = 0,
+                        .amux = LINE2,
+                        .gpio = 0x4000,
+                }, {
+                        .name = name_comp2,
+                        .vmux = 3,
+                        .amux = LINE2,
+                        .gpio = 0x4000,
+                }, {
+                        .name = name_svideo,
+                        .vmux = 8,
+                        .amux = LINE2,
+                        .gpio = 0x4000,
+                } },
+                .radio = {
+                        .name = name_radio,
+                        .amux = LINE2,
+                        .gpio = 0x2000,
+                },
+                .mute = {
+                        .name = name_mute,
+                        .amux = TV,
+                        .gpio = 0x8000,
+                },
+        },
         [SAA7134_BOARD_EMPRESS] = {
                 /* "Gert Vervoort" <gert.vervoort@philips.com> */
                 .name           = "EMPRESS",
@@ -1364,6 +1415,42 @@ struct saa7134_board saa7134_boards[] = {
                         .amux = LINE1,
                 },
         },
+        [SAA7134_BOARD_AVERMEDIA_STUDIO_505] = {
+                /* Vasiliy Temnikov <vaka@newmail.ru> */
+                .name           = "AverMedia AverTV Studio 505",
+                .audio_clock    = 0x00187de7,
+                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .tda9887_conf   = TDA9887_PRESENT,
+                .inputs         = { {
+                        .name = name_tv,
+                        .vmux = 1,
+                        .amux = LINE2,
+                        .tv   = 1,
+                }, {
+                        .name = name_comp1,
+                        .vmux = 0,
+                        .amux = LINE2,
+                }, {
+                        .name = name_comp2,
+                        .vmux = 3,
+                        .amux = LINE2,
+                },{
+                        .name = name_svideo,
+                        .vmux = 8,
+                        .amux = LINE2,
+                } },
+                .radio = {
+                        .name = name_radio,
+                        .amux = LINE2,
+                },
+                .mute = {
+                        .name = name_mute,
+                        .amux = LINE1,
+                },
+        },
         [SAA7134_BOARD_UPMOST_PURPLE_TV] = {
                 .name           = "UPMOST PURPLE TV",
                 .audio_clock    = 0x00187de7,
@@ -1633,7 +1720,7 @@ struct saa7134_board saa7134_boards[] = {
                 }},
                 .radio = {
                         .name = name_radio,
-                        .amux = LINE1,
+                        .amux = TV,
                         .gpio = 0x00300001,
                 },
                 .mute = {
@@ -3663,8 +3750,8 @@ struct saa7134_board saa7134_boards[] = {
                         .amux = TV,
                         .gpio = 0x0200000,
                 },
-       },
-       [SAA7134_BOARD_ASUSTeK_P7131_ANALOG] = {
+        },
+        [SAA7134_BOARD_ASUSTeK_P7131_ANALOG] = {
                .name           = "ASUSTeK P7131 Analog",
                .audio_clock    = 0x00187de7,
                .tuner_type     = TUNER_PHILIPS_TDA8290,
@@ -4081,6 +4168,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
+                .rds_addr       = 0x10,
                 .tda9887_conf   = TDA9887_PRESENT,
                 .gpiomask       = 0x00008000,
                 .inputs         = {{
@@ -4145,6 +4233,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
+                .rds_addr       = 0x10,
                 .tda9887_conf   = TDA9887_PRESENT,
                 .gpiomask       = 0x00008000,
                 .inputs         = {{
@@ -4175,6 +4264,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
+                .rds_addr       = 0x10,
                 .tda9887_conf   = TDA9887_PRESENT,
                 .gpiomask       = 0x00008000,
                 .inputs         = {{
@@ -4350,6 +4440,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
+                .rds_addr       = 0x10,
                 .tda9887_conf   = TDA9887_PRESENT,
                 .inputs         = {{
                         .name = name_tv,
@@ -4378,6 +4469,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
+                .rds_addr       = 0x10,
                 .tda9887_conf   = TDA9887_PRESENT,
                 .inputs         = {{
                         .name = name_tv,
@@ -4406,6 +4498,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
+                .rds_addr       = 0x10,
                 .tda9887_conf   = TDA9887_PRESENT,
                 .inputs         = {{
                         .name = name_tv,
@@ -4434,6 +4527,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
+                .rds_addr       = 0x10,
                 .tda9887_conf   = TDA9887_PRESENT,
                 .inputs         = {{
                         .name = name_tv,
@@ -4540,6 +4634,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
+                .rds_addr       = 0x10,
                 .empress_addr   = 0x20,
                 .tda9887_conf   = TDA9887_PRESENT,
                 .inputs         = { {
@@ -4861,7 +4956,7 @@ struct saa7134_board saa7134_boards[] = {
                 /* Igor Kuznetsov <igk@igk.ru> */
                 .name           = "Beholder BeholdTV H6",
                 .audio_clock    = 0x00187de7,
-                .tuner_type     = TUNER_PHILIPS_FMD1216ME_MK3,
+                .tuner_type     = TUNER_PHILIPS_FMD1216MEX_MK3,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -5116,6 +5211,53 @@ struct saa7134_board saa7134_boards[] = {
                         .gpio = 0x00,
                 },
         },
+        [SAA7134_BOARD_VIDEOMATE_S350] = {
+                /* Jan D. Louw <jd.louw@mweb.co.za */
+                .name           = "Compro VideoMate S350/S300",
+                .audio_clock    = 0x00187de7,
+                .tuner_type     = TUNER_ABSENT,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .mpeg           = SAA7134_MPEG_DVB,
+                .inputs = { {
+                        .name   = name_comp1,
+                        .vmux   = 0,
+                        .amux   = LINE1,
+                }, {
+                        .name   = name_svideo,
+                        .vmux   = 8, /* Not tested */
+                        .amux   = LINE1
+                } },
+        },
+        [SAA7134_BOARD_BEHOLD_X7] = {
+                /* Beholder Intl. Ltd. Dmitry Belimov <d.belimov@gmail.com> */
+                .name           = "Beholder BeholdTV X7",
+                .audio_clock    = 0x00187de7,
+                .tuner_type     = TUNER_XC5000,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .inputs         = { {
+                        .name = name_tv,
+                        .vmux = 2,
+                        .amux = TV,
+                        .tv   = 1,
+                }, {
+                        .name = name_comp1,
+                        .vmux = 0,
+                        .amux = LINE1,
+                }, {
+                        .name = name_svideo,
+                        .vmux = 9,
+                        .amux = LINE1,
+                } },
+                .radio = {
+                        .name = name_radio,
+                        .amux = TV,
+                },
+        },
+
 };
 
 const unsigned int saa7134_bcount = ARRAY_SIZE(saa7134_boards);
@@ -5374,6 +5516,12 @@ struct pci_device_id saa7134_pci_tbl[] = {
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
                 .subvendor    = 0x1461, /* Avermedia Technologies Inc */
+                .subdevice    = 0xa115,
+                .driver_data  = SAA7134_BOARD_AVERMEDIA_STUDIO_505,
+        }, {
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
+                .subvendor    = 0x1461, /* Avermedia Technologies Inc */
                 .subdevice    = 0x2108,
                 .driver_data  = SAA7134_BOARD_AVERMEDIA_305,
         },{
@@ -6223,7 +6371,24 @@ struct pci_device_id saa7134_pci_tbl[] = {
                 .subvendor    = 0x1461, /* Avermedia Technologies Inc */
                 .subdevice    = 0xf31d,
                 .driver_data  = SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS,
-
+        }, {
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
+                .subvendor    = 0x185b,
+                .subdevice    = 0xc900,
+                .driver_data  = SAA7134_BOARD_VIDEOMATE_S350,
+        }, {
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
+                .subvendor    = 0x5ace, /* Beholder Intl. Ltd. */
+                .subdevice    = 0x7595,
+                .driver_data  = SAA7134_BOARD_BEHOLD_X7,
+        }, {
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
+                .subvendor    = 0x19d1, /* RoverMedia */
+                .subdevice    = 0x0138, /* LifeView FlyTV Prime30 OEM */
+                .driver_data  = SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM,
         }, {
                 /* --- boards without eeprom + subsystem ID --- */
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
@@ -6310,6 +6475,32 @@ static int saa7134_xc2028_callback(struct saa7134_dev *dev,
         return -EINVAL;
 }
 
+static int saa7134_xc5000_callback(struct saa7134_dev *dev,
+                                   int command, int arg)
+{
+        switch (dev->board) {
+        case SAA7134_BOARD_BEHOLD_X7:
+                if (command == XC5000_TUNER_RESET) {
+                /* Down and UP pheripherial RESET pin for reset all chips */
+                        saa_writeb(SAA7134_SPECIAL_MODE, 0x00);
+                        msleep(10);
+                        saa_writeb(SAA7134_SPECIAL_MODE, 0x01);
+                        msleep(10);
+                }
+                break;
+        default:
+                saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, 0x06e20000, 0x06e20000);
+                saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x06a20000, 0x06a20000);
+                saa_andorl(SAA7133_ANALOG_IO_SELECT >> 2, 0x02, 0x02);
+                saa_andorl(SAA7134_ANALOG_IN_CTRL1 >> 2, 0x81, 0x81);
+                saa_andorl(SAA7134_AUDIO_CLOCK0 >> 2, 0x03187de7, 0x03187de7);
+                saa_andorl(SAA7134_AUDIO_PLL_CTRL >> 2, 0x03, 0x03);
+                saa_andorl(SAA7134_AUDIO_CLOCKS_PER_FIELD0 >> 2,
+                           0x0001e000, 0x0001e000);
+                break;
+        }
+        return 0;
+}
 
 static int saa7134_tda8290_827x_callback(struct saa7134_dev *dev,
                                          int command, int arg)
@@ -6406,6 +6597,8 @@ int saa7134_tuner_callback(void *priv, int component, int command, int arg)
                         return saa7134_tda8290_callback(dev, command, arg);
                 case TUNER_XC2028:
                         return saa7134_xc2028_callback(dev, command, arg);
+                case TUNER_XC5000:
+                        return saa7134_xc5000_callback(dev, command, arg);
                 }
         } else {
                 printk(KERN_ERR "saa7134: Error - device struct undefined.\n");
@@ -6476,6 +6669,7 @@ int saa7134_board_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_KWORLD_VSTREAM_XPERT:
         case SAA7134_BOARD_KWORLD_XPERT:
         case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
+        case SAA7134_BOARD_AVERMEDIA_STUDIO_505:
         case SAA7134_BOARD_AVERMEDIA_305:
         case SAA7134_BOARD_AVERMEDIA_STUDIO_307:
         case SAA7134_BOARD_AVERMEDIA_307:
@@ -6500,7 +6694,7 @@ int saa7134_board_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_FLYDVBT_LR301:
         case SAA7134_BOARD_ASUSTeK_P7131_DUAL:
         case SAA7134_BOARD_ASUSTeK_P7131_HYBRID_LNA:
-       case SAA7134_BOARD_ASUSTeK_P7131_ANALOG:
+        case SAA7134_BOARD_ASUSTeK_P7131_ANALOG:
         case SAA7134_BOARD_FLYDVBTDUO:
         case SAA7134_BOARD_PROTEUS_2309:
         case SAA7134_BOARD_AVERMEDIA_A16AR:
@@ -6525,6 +6719,7 @@ int saa7134_board_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_REAL_ANGEL_220:
         case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
         case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
+        case SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM:
                 dev->has_remote = SAA7134_REMOTE_GPIO;
                 break;
         case SAA7134_BOARD_FLYDVBS_LR300:
@@ -6653,6 +6848,7 @@ int saa7134_board_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_BEHOLD_M63:
         case SAA7134_BOARD_BEHOLD_M6_EXTRA:
         case SAA7134_BOARD_BEHOLD_H6:
+        case SAA7134_BOARD_BEHOLD_X7:
                 dev->has_remote = SAA7134_REMOTE_I2C;
                 break;
         case SAA7134_BOARD_AVERMEDIA_A169_B:
@@ -6673,6 +6869,11 @@ int saa7134_board_init1(struct saa7134_dev *dev)
                 saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   0x80040100, 0x80040100);
                 saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x80040100, 0x00040100);
                 break;
+        case SAA7134_BOARD_VIDEOMATE_S350:
+                dev->has_remote = SAA7134_REMOTE_GPIO;
+                saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   0x00008000, 0x00008000);
+                saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x00008000, 0x00008000);
+                break;
         }
         return 0;
 }
diff --git a/drivers/media/video/saa7134/saa7134-core.c b/drivers/media/video/saa7134/saa7134-core.c
index 94a023a14bbc..cb78c956d810 100644
--- a/drivers/media/video/saa7134/saa7134-core.c
+++ b/drivers/media/video/saa7134/saa7134-core.c
@@ -1012,8 +1012,10 @@ static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
                 sd = v4l2_i2c_new_probed_subdev_addr(&dev->v4l2_dev,
                                 &dev->i2c_adap, "saa6588", "saa6588",
                                 saa7134_boards[dev->board].rds_addr);
-                if (sd)
+                if (sd) {
                         printk(KERN_INFO "%s: found RDS decoder\n", dev->name);
+                        dev->has_rds = 1;
+                }
         }
 
         request_submodules(dev);
diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c
index 98f3efd1e944..ebde21dba7e3 100644
--- a/drivers/media/video/saa7134/saa7134-dvb.c
+++ b/drivers/media/video/saa7134/saa7134-dvb.c
@@ -56,6 +56,7 @@
 #include "zl10353.h"
 
 #include "zl10036.h"
+#include "zl10039.h"
 #include "mt312.h"
 
 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
@@ -968,6 +969,10 @@ static struct zl10036_config avertv_a700_tuner = {
         .tuner_address = 0x60,
 };
 
+static struct mt312_config zl10313_compro_s350_config = {
+        .demod_address = 0x0e,
+};
+
 static struct lgdt3305_config hcw_lgdt3305_config = {
         .i2c_addr           = 0x0e,
         .mpeg_mode          = LGDT3305_MPEG_SERIAL,
@@ -1457,7 +1462,7 @@ static int dvb_init(struct saa7134_dev *dev)
                 if (fe0->dvb.frontend) {
                         dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
                                    &dev->i2c_adap, 0x61,
-                                   TUNER_PHILIPS_FMD1216ME_MK3);
+                                   TUNER_PHILIPS_FMD1216MEX_MK3);
                 }
                 break;
         case SAA7134_BOARD_AVERMEDIA_A700_PRO:
@@ -1473,6 +1478,16 @@ static int dvb_init(struct saa7134_dev *dev)
                         }
                 }
                 break;
+        case SAA7134_BOARD_VIDEOMATE_S350:
+                fe0->dvb.frontend = dvb_attach(mt312_attach,
+                                &zl10313_compro_s350_config, &dev->i2c_adap);
+                if (fe0->dvb.frontend)
+                        if (dvb_attach(zl10039_attach, fe0->dvb.frontend,
+                                        0x60, &dev->i2c_adap) == NULL)
+                                wprintk("%s: No zl10039 found!\n",
+                                        __func__);
+
+                break;
         default:
                 wprintk("Huh? unknown DVB card?\n");
                 break;
diff --git a/drivers/media/video/saa7134/saa7134-input.c b/drivers/media/video/saa7134/saa7134-input.c
index 6e219c2db841..e1e83c7b966e 100644
--- a/drivers/media/video/saa7134/saa7134-input.c
+++ b/drivers/media/video/saa7134/saa7134-input.c
@@ -394,7 +394,7 @@ int saa7134_input_init1(struct saa7134_dev *dev)
 {
         struct card_ir *ir;
         struct input_dev *input_dev;
-        IR_KEYTAB_TYPE *ir_codes = NULL;
+        struct ir_scancode_table *ir_codes = NULL;
         u32 mask_keycode = 0;
         u32 mask_keydown = 0;
         u32 mask_keyup   = 0;
@@ -415,27 +415,28 @@ int saa7134_input_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_FLYVIDEO3000:
         case SAA7134_BOARD_FLYTVPLATINUM_FM:
         case SAA7134_BOARD_FLYTVPLATINUM_MINI2:
-                ir_codes     = ir_codes_flyvideo;
+        case SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM:
+                ir_codes     = &ir_codes_flyvideo_table;
                 mask_keycode = 0xEC00000;
                 mask_keydown = 0x0040000;
                 break;
         case SAA7134_BOARD_CINERGY400:
         case SAA7134_BOARD_CINERGY600:
         case SAA7134_BOARD_CINERGY600_MK3:
-                ir_codes     = ir_codes_cinergy;
+                ir_codes     = &ir_codes_cinergy_table;
                 mask_keycode = 0x00003f;
                 mask_keyup   = 0x040000;
                 break;
         case SAA7134_BOARD_ECS_TVP3XP:
         case SAA7134_BOARD_ECS_TVP3XP_4CB5:
-                ir_codes     = ir_codes_eztv;
+                ir_codes     = &ir_codes_eztv_table;
                 mask_keycode = 0x00017c;
                 mask_keyup   = 0x000002;
                 polling      = 50; // ms
                 break;
         case SAA7134_BOARD_KWORLD_XPERT:
         case SAA7134_BOARD_AVACSSMARTTV:
-                ir_codes     = ir_codes_pixelview;
+                ir_codes     = &ir_codes_pixelview_table;
                 mask_keycode = 0x00001F;
                 mask_keyup   = 0x000020;
                 polling      = 50; // ms
@@ -445,13 +446,14 @@ int saa7134_input_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_AVERMEDIA_305:
         case SAA7134_BOARD_AVERMEDIA_307:
         case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
+        case SAA7134_BOARD_AVERMEDIA_STUDIO_505:
         case SAA7134_BOARD_AVERMEDIA_STUDIO_307:
         case SAA7134_BOARD_AVERMEDIA_STUDIO_507:
         case SAA7134_BOARD_AVERMEDIA_STUDIO_507UA:
         case SAA7134_BOARD_AVERMEDIA_GO_007_FM:
         case SAA7134_BOARD_AVERMEDIA_M102:
         case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
-                ir_codes     = ir_codes_avermedia;
+                ir_codes     = &ir_codes_avermedia_table;
                 mask_keycode = 0x0007C8;
                 mask_keydown = 0x000010;
                 polling      = 50; // ms
@@ -460,14 +462,14 @@ int saa7134_input_init1(struct saa7134_dev *dev)
                 saa_setb(SAA7134_GPIO_GPSTATUS0, 0x4);
                 break;
         case SAA7134_BOARD_AVERMEDIA_M135A:
-                ir_codes     = ir_codes_avermedia_m135a;
+                ir_codes     = &ir_codes_avermedia_m135a_table;
                 mask_keydown = 0x0040000;
                 mask_keycode = 0x00013f;
                 nec_gpio     = 1;
                 break;
         case SAA7134_BOARD_AVERMEDIA_777:
         case SAA7134_BOARD_AVERMEDIA_A16AR:
-                ir_codes     = ir_codes_avermedia;
+                ir_codes     = &ir_codes_avermedia_table;
                 mask_keycode = 0x02F200;
                 mask_keydown = 0x000400;
                 polling      = 50; // ms
@@ -476,7 +478,7 @@ int saa7134_input_init1(struct saa7134_dev *dev)
                 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
                 break;
         case SAA7134_BOARD_AVERMEDIA_A16D:
-                ir_codes     = ir_codes_avermedia_a16d;
+                ir_codes     = &ir_codes_avermedia_a16d_table;
                 mask_keycode = 0x02F200;
                 mask_keydown = 0x000400;
                 polling      = 50; /* ms */
@@ -485,14 +487,14 @@ int saa7134_input_init1(struct saa7134_dev *dev)
                 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
                 break;
         case SAA7134_BOARD_KWORLD_TERMINATOR:
-                ir_codes     = ir_codes_pixelview;
+                ir_codes     = &ir_codes_pixelview_table;
                 mask_keycode = 0x00001f;
                 mask_keyup   = 0x000060;
                 polling      = 50; // ms
                 break;
         case SAA7134_BOARD_MANLI_MTV001:
         case SAA7134_BOARD_MANLI_MTV002:
-                ir_codes     = ir_codes_manli;
+                ir_codes     = &ir_codes_manli_table;
                 mask_keycode = 0x001f00;
                 mask_keyup   = 0x004000;
                 polling      = 50; /* ms */
@@ -511,25 +513,25 @@ int saa7134_input_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_BEHOLD_507_9FM:
         case SAA7134_BOARD_BEHOLD_507RDS_MK3:
         case SAA7134_BOARD_BEHOLD_507RDS_MK5:
-                ir_codes     = ir_codes_manli;
+                ir_codes     = &ir_codes_manli_table;
                 mask_keycode = 0x003f00;
                 mask_keyup   = 0x004000;
                 polling      = 50; /* ms */
                 break;
         case SAA7134_BOARD_BEHOLD_COLUMBUS_TVFM:
-                ir_codes     = ir_codes_behold_columbus;
+                ir_codes     = &ir_codes_behold_columbus_table;
                 mask_keycode = 0x003f00;
                 mask_keyup   = 0x004000;
                 polling      = 50; // ms
                 break;
         case SAA7134_BOARD_SEDNA_PC_TV_CARDBUS:
-                ir_codes     = ir_codes_pctv_sedna;
+                ir_codes     = &ir_codes_pctv_sedna_table;
                 mask_keycode = 0x001f00;
                 mask_keyup   = 0x004000;
                 polling      = 50; // ms
                 break;
         case SAA7134_BOARD_GOTVIEW_7135:
-                ir_codes     = ir_codes_gotview7135;
+                ir_codes     = &ir_codes_gotview7135_table;
                 mask_keycode = 0x0003CC;
                 mask_keydown = 0x000010;
                 polling      = 5; /* ms */
@@ -538,73 +540,78 @@ int saa7134_input_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_VIDEOMATE_TV_PVR:
         case SAA7134_BOARD_VIDEOMATE_GOLD_PLUS:
         case SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII:
-                ir_codes     = ir_codes_videomate_tv_pvr;
+                ir_codes     = &ir_codes_videomate_tv_pvr_table;
                 mask_keycode = 0x00003F;
                 mask_keyup   = 0x400000;
                 polling      = 50; // ms
                 break;
         case SAA7134_BOARD_PROTEUS_2309:
-                ir_codes     = ir_codes_proteus_2309;
+                ir_codes     = &ir_codes_proteus_2309_table;
                 mask_keycode = 0x00007F;
                 mask_keyup   = 0x000080;
                 polling      = 50; // ms
                 break;
         case SAA7134_BOARD_VIDEOMATE_DVBT_300:
         case SAA7134_BOARD_VIDEOMATE_DVBT_200:
-                ir_codes     = ir_codes_videomate_tv_pvr;
+                ir_codes     = &ir_codes_videomate_tv_pvr_table;
                 mask_keycode = 0x003F00;
                 mask_keyup   = 0x040000;
                 break;
         case SAA7134_BOARD_FLYDVBS_LR300:
         case SAA7134_BOARD_FLYDVBT_LR301:
         case SAA7134_BOARD_FLYDVBTDUO:
-                ir_codes     = ir_codes_flydvb;
+                ir_codes     = &ir_codes_flydvb_table;
                 mask_keycode = 0x0001F00;
                 mask_keydown = 0x0040000;
                 break;
         case SAA7134_BOARD_ASUSTeK_P7131_DUAL:
         case SAA7134_BOARD_ASUSTeK_P7131_HYBRID_LNA:
-       case SAA7134_BOARD_ASUSTeK_P7131_ANALOG:
-                ir_codes     = ir_codes_asus_pc39;
+        case SAA7134_BOARD_ASUSTeK_P7131_ANALOG:
+                ir_codes     = &ir_codes_asus_pc39_table;
                 mask_keydown = 0x0040000;
                 rc5_gpio = 1;
                 break;
         case SAA7134_BOARD_ENCORE_ENLTV:
         case SAA7134_BOARD_ENCORE_ENLTV_FM:
-                ir_codes     = ir_codes_encore_enltv;
+                ir_codes     = &ir_codes_encore_enltv_table;
                 mask_keycode = 0x00007f;
                 mask_keyup   = 0x040000;
                 polling      = 50; // ms
                 break;
         case SAA7134_BOARD_ENCORE_ENLTV_FM53:
-                ir_codes     = ir_codes_encore_enltv_fm53;
+                ir_codes     = &ir_codes_encore_enltv_fm53_table;
                 mask_keydown = 0x0040000;
                 mask_keycode = 0x00007f;
                 nec_gpio = 1;
                 break;
         case SAA7134_BOARD_10MOONSTVMASTER3:
-                ir_codes     = ir_codes_encore_enltv;
+                ir_codes     = &ir_codes_encore_enltv_table;
                 mask_keycode = 0x5f80000;
                 mask_keyup   = 0x8000000;
                 polling      = 50; //ms
                 break;
         case SAA7134_BOARD_GENIUS_TVGO_A11MCE:
-                ir_codes     = ir_codes_genius_tvgo_a11mce;
+                ir_codes     = &ir_codes_genius_tvgo_a11mce_table;
                 mask_keycode = 0xff;
                 mask_keydown = 0xf00000;
                 polling = 50; /* ms */
                 break;
         case SAA7134_BOARD_REAL_ANGEL_220:
-                ir_codes     = ir_codes_real_audio_220_32_keys;
+                ir_codes     = &ir_codes_real_audio_220_32_keys_table;
                 mask_keycode = 0x3f00;
                 mask_keyup   = 0x4000;
                 polling = 50; /* ms */
                 break;
         case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
-                ir_codes     = ir_codes_kworld_plus_tv_analog;
+                ir_codes     = &ir_codes_kworld_plus_tv_analog_table;
                 mask_keycode = 0x7f;
                 polling = 40; /* ms */
                 break;
+        case SAA7134_BOARD_VIDEOMATE_S350:
+                ir_codes     = &ir_codes_videomate_s350_table;
+                mask_keycode = 0x003f00;
+                mask_keydown = 0x040000;
+                break;
         }
         if (NULL == ir_codes) {
                 printk("%s: Oops: IR config error [card=%d]\n",
@@ -684,8 +691,6 @@ void saa7134_input_fini(struct saa7134_dev *dev)
 
 void saa7134_probe_i2c_ir(struct saa7134_dev *dev)
 {
-        struct i2c_board_info info;
-        struct IR_i2c_init_data init_data;
         const unsigned short addr_list[] = {
                 0x7a, 0x47, 0x71, 0x2d,
                 I2C_CLIENT_END
@@ -705,32 +710,34 @@ void saa7134_probe_i2c_ir(struct saa7134_dev *dev)
                 return;
         }
 
-        memset(&info, 0, sizeof(struct i2c_board_info));
-        memset(&init_data, 0, sizeof(struct IR_i2c_init_data));
-        strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
+        memset(&dev->info, 0, sizeof(dev->info));
+        memset(&dev->init_data, 0, sizeof(dev->init_data));
+        strlcpy(dev->info.type, "ir_video", I2C_NAME_SIZE);
 
         switch (dev->board) {
         case SAA7134_BOARD_PINNACLE_PCTV_110i:
         case SAA7134_BOARD_PINNACLE_PCTV_310i:
-                init_data.name = "Pinnacle PCTV";
+                dev->init_data.name = "Pinnacle PCTV";
                 if (pinnacle_remote == 0) {
-                        init_data.get_key = get_key_pinnacle_color;
-                        init_data.ir_codes = ir_codes_pinnacle_color;
+                        dev->init_data.get_key = get_key_pinnacle_color;
+                        dev->init_data.ir_codes = &ir_codes_pinnacle_color_table;
+                        dev->info.addr = 0x47;
                 } else {
-                        init_data.get_key = get_key_pinnacle_grey;
-                        init_data.ir_codes = ir_codes_pinnacle_grey;
+                        dev->init_data.get_key = get_key_pinnacle_grey;
+                        dev->init_data.ir_codes = &ir_codes_pinnacle_grey_table;
+                        dev->info.addr = 0x47;
                 }
                 break;
         case SAA7134_BOARD_UPMOST_PURPLE_TV:
-                init_data.name = "Purple TV";
-                init_data.get_key = get_key_purpletv;
-                init_data.ir_codes = ir_codes_purpletv;
+                dev->init_data.name = "Purple TV";
+                dev->init_data.get_key = get_key_purpletv;
+                dev->init_data.ir_codes = &ir_codes_purpletv_table;
                 break;
         case SAA7134_BOARD_MSI_TVATANYWHERE_PLUS:
-                init_data.name = "MSI TV@nywhere Plus";
-                init_data.get_key = get_key_msi_tvanywhere_plus;
-                init_data.ir_codes = ir_codes_msi_tvanywhere_plus;
-                info.addr = 0x30;
+                dev->init_data.name = "MSI TV@nywhere Plus";
+                dev->init_data.get_key = get_key_msi_tvanywhere_plus;
+                dev->init_data.ir_codes = &ir_codes_msi_tvanywhere_plus_table;
+                dev->info.addr = 0x30;
                 /* MSI TV@nywhere Plus controller doesn't seem to
                    respond to probes unless we read something from
                    an existing device. Weird...
@@ -741,9 +748,9 @@ void saa7134_probe_i2c_ir(struct saa7134_dev *dev)
                         (1 == rc) ? "yes" : "no");
                 break;
         case SAA7134_BOARD_HAUPPAUGE_HVR1110:
-                init_data.name = "HVR 1110";
-                init_data.get_key = get_key_hvr1110;
-                init_data.ir_codes = ir_codes_hauppauge_new;
+                dev->init_data.name = "HVR 1110";
+                dev->init_data.get_key = get_key_hvr1110;
+                dev->init_data.ir_codes = &ir_codes_hauppauge_new_table;
                 break;
         case SAA7134_BOARD_BEHOLD_607FM_MK3:
         case SAA7134_BOARD_BEHOLD_607FM_MK5:
@@ -757,26 +764,27 @@ void saa7134_probe_i2c_ir(struct saa7134_dev *dev)
         case SAA7134_BOARD_BEHOLD_M63:
         case SAA7134_BOARD_BEHOLD_M6_EXTRA:
         case SAA7134_BOARD_BEHOLD_H6:
-                init_data.name = "BeholdTV";
-                init_data.get_key = get_key_beholdm6xx;
-                init_data.ir_codes = ir_codes_behold;
+        case SAA7134_BOARD_BEHOLD_X7:
+                dev->init_data.name = "BeholdTV";
+                dev->init_data.get_key = get_key_beholdm6xx;
+                dev->init_data.ir_codes = &ir_codes_behold_table;
                 break;
         case SAA7134_BOARD_AVERMEDIA_CARDBUS_501:
         case SAA7134_BOARD_AVERMEDIA_CARDBUS_506:
-                info.addr = 0x40;
+                dev->info.addr = 0x40;
                 break;
         }
 
-        if (init_data.name)
-                info.platform_data = &init_data;
+        if (dev->init_data.name)
+                dev->info.platform_data = &dev->init_data;
         /* No need to probe if address is known */
-        if (info.addr) {
-                i2c_new_device(&dev->i2c_adap, &info);
+        if (dev->info.addr) {
+                i2c_new_device(&dev->i2c_adap, &dev->info);
                 return;
         }
 
         /* Address not known, fallback to probing */
-        i2c_new_probed_device(&dev->i2c_adap, &info, addr_list);
+        i2c_new_probed_device(&dev->i2c_adap, &dev->info, addr_list);
 }
 
 static int saa7134_rc5_irq(struct saa7134_dev *dev)
diff --git a/drivers/media/video/saa7134/saa7134-video.c b/drivers/media/video/saa7134/saa7134-video.c
index ba87128542e0..da26f476a302 100644
--- a/drivers/media/video/saa7134/saa7134-video.c
+++ b/drivers/media/video/saa7134/saa7134-video.c
@@ -1444,7 +1444,6 @@ video_poll(struct file *file, struct poll_table_struct *wait)
                         fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
                         fh->cap.read_off = 0;
                 }
-                mutex_unlock(&fh->cap.vb_lock);
                 buf = fh->cap.read_buf;
         }
 
@@ -1790,7 +1789,7 @@ static int saa7134_s_input(struct file *file, void *priv, unsigned int i)
         if (0 != err)
                 return err;
 
-        if (i < 0  ||  i >= SAA7134_INPUT_MAX)
+        if (i >= SAA7134_INPUT_MAX)
                 return -EINVAL;
         if (NULL == card_in(dev, i).name)
                 return -EINVAL;
@@ -1819,6 +1818,8 @@ static int saa7134_querycap(struct file *file, void  *priv,
                 V4L2_CAP_READWRITE |
                 V4L2_CAP_STREAMING |
                 V4L2_CAP_TUNER;
+        if (dev->has_rds)
+                cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
         if (saa7134_no_overlay <= 0)
                 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
 
diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h
index fb564f14887c..d18bb9643856 100644
--- a/drivers/media/video/saa7134/saa7134.h
+++ b/drivers/media/video/saa7134/saa7134.h
@@ -292,6 +292,10 @@ struct saa7134_format {
 #define SAA7134_BOARD_BEHOLD_607RDS_MK5     166
 #define SAA7134_BOARD_BEHOLD_609RDS_MK3     167
 #define SAA7134_BOARD_BEHOLD_609RDS_MK5     168
+#define SAA7134_BOARD_VIDEOMATE_S350        169
+#define SAA7134_BOARD_AVERMEDIA_STUDIO_505  170
+#define SAA7134_BOARD_BEHOLD_X7             171
+#define SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM 172
 
 #define SAA7134_MAXBOARDS 32
 #define SAA7134_INPUT_MAX 8
@@ -539,6 +543,7 @@ struct saa7134_dev {
         struct i2c_adapter         i2c_adap;
         struct i2c_client          i2c_client;
         unsigned char              eedata[256];
+        int                        has_rds;
 
         /* video overlay */
         struct v4l2_framebuffer    ovbuf;
@@ -584,6 +589,10 @@ struct saa7134_dev {
         int                        nosignal;
         unsigned int               insuspend;
 
+        /* I2C keyboard data */
+        struct i2c_board_info      info;
+        struct IR_i2c_init_data    init_data;
+
         /* SAA7134_MPEG_* */
         struct saa7134_ts          ts;
         struct saa7134_dmaqueue    ts_q;
diff --git a/drivers/media/video/sn9c102/sn9c102_devtable.h b/drivers/media/video/sn9c102/sn9c102_devtable.h
index 38a716020d7f..36ee43a9ee95 100644
--- a/drivers/media/video/sn9c102/sn9c102_devtable.h
+++ b/drivers/media/video/sn9c102/sn9c102_devtable.h
@@ -123,8 +123,8 @@ static const struct usb_device_id sn9c102_id_table[] = {
         { SN9C102_USB_DEVICE(0x0c45, 0x613b, BRIDGE_SN9C120), },
 #if !defined CONFIG_USB_GSPCA && !defined CONFIG_USB_GSPCA_MODULE
         { SN9C102_USB_DEVICE(0x0c45, 0x613c, BRIDGE_SN9C120), },
-#endif
         { SN9C102_USB_DEVICE(0x0c45, 0x613e, BRIDGE_SN9C120), },
+#endif
         { }
 };
 
diff --git a/drivers/media/video/stk-webcam.c b/drivers/media/video/stk-webcam.c
index b154bd961e3b..0b996ea4134e 100644
--- a/drivers/media/video/stk-webcam.c
+++ b/drivers/media/video/stk-webcam.c
@@ -1400,7 +1400,6 @@ static int stk_camera_probe(struct usb_interface *interface,
         }
 
         stk_create_sysfs_files(&dev->vdev);
-        usb_autopm_enable(dev->interface);
 
         return 0;
 
diff --git a/drivers/media/video/stv680.c b/drivers/media/video/stv680.c
index 8b4e7dafce7b..6a91714125d2 100644
--- a/drivers/media/video/stv680.c
+++ b/drivers/media/video/stv680.c
@@ -734,10 +734,6 @@ static int stv680_start_stream (struct usb_stv *stv680)
         return 0;
 
  nomem_err:
-        for (i = 0; i < STV680_NUMSCRATCH; i++) {
-                kfree(stv680->scratch[i].data);
-                stv680->scratch[i].data = NULL;
-        }
         for (i = 0; i < STV680_NUMSBUF; i++) {
                 usb_kill_urb(stv680->urb[i]);
                 usb_free_urb(stv680->urb[i]);
@@ -745,6 +741,11 @@ static int stv680_start_stream (struct usb_stv *stv680)
                 kfree(stv680->sbuf[i].data);
                 stv680->sbuf[i].data = NULL;
         }
+        /* used in irq, free only as all URBs are dead */
+        for (i = 0; i < STV680_NUMSCRATCH; i++) {
+                kfree(stv680->scratch[i].data);
+                stv680->scratch[i].data = NULL;
+        }
         return -ENOMEM;
 
 }
diff --git a/drivers/media/video/tuner-core.c b/drivers/media/video/tuner-core.c
index 537594211a90..2816f1839230 100644
--- a/drivers/media/video/tuner-core.c
+++ b/drivers/media/video/tuner-core.c
@@ -819,8 +819,8 @@ static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
 
                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
-                        (abs_freq * 2 + 125/2) / 125 :
-                        (abs_freq + 62500/2) / 62500;
+                        DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
+                        DIV_ROUND_CLOSEST(abs_freq, 62500);
                 return 0;
         }
         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
diff --git a/drivers/media/video/tveeprom.c b/drivers/media/video/tveeprom.c
index ac02808106c1..d533ea57e7b1 100644
--- a/drivers/media/video/tveeprom.c
+++ b/drivers/media/video/tveeprom.c
@@ -646,14 +646,14 @@ void tveeprom_hauppauge_analog(struct i2c_client *c, struct tveeprom *tvee,
                 tvee->has_radio = 1;
         }
 
-        if (tuner1 < sizeof(hauppauge_tuner)/sizeof(struct HAUPPAUGE_TUNER)) {
+        if (tuner1 < ARRAY_SIZE(hauppauge_tuner)) {
                 tvee->tuner_type = hauppauge_tuner[tuner1].id;
                 t_name1 = hauppauge_tuner[tuner1].name;
         } else {
                 t_name1 = "unknown";
         }
 
-        if (tuner2 < sizeof(hauppauge_tuner)/sizeof(struct HAUPPAUGE_TUNER)) {
+        if (tuner2 < ARRAY_SIZE(hauppauge_tuner)) {
                 tvee->tuner2_type = hauppauge_tuner[tuner2].id;
                 t_name2 = hauppauge_tuner[tuner2].name;
         } else {
diff --git a/drivers/media/video/uvc/uvc_ctrl.c b/drivers/media/video/uvc/uvc_ctrl.c
index 36a6ba92df27..c3225a561748 100644
--- a/drivers/media/video/uvc/uvc_ctrl.c
+++ b/drivers/media/video/uvc/uvc_ctrl.c
@@ -34,7 +34,7 @@
 static struct uvc_control_info uvc_ctrls[] = {
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_BRIGHTNESS_CONTROL,
+                .selector       = UVC_PU_BRIGHTNESS_CONTROL,
                 .index          = 0,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -42,7 +42,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_CONTRAST_CONTROL,
+                .selector       = UVC_PU_CONTRAST_CONTROL,
                 .index          = 1,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -50,7 +50,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_HUE_CONTROL,
+                .selector       = UVC_PU_HUE_CONTROL,
                 .index          = 2,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -58,7 +58,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_SATURATION_CONTROL,
+                .selector       = UVC_PU_SATURATION_CONTROL,
                 .index          = 3,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -66,7 +66,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_SHARPNESS_CONTROL,
+                .selector       = UVC_PU_SHARPNESS_CONTROL,
                 .index          = 4,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -74,7 +74,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_GAMMA_CONTROL,
+                .selector       = UVC_PU_GAMMA_CONTROL,
                 .index          = 5,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -82,7 +82,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
+                .selector       = UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
                 .index          = 6,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -90,7 +90,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_WHITE_BALANCE_COMPONENT_CONTROL,
+                .selector       = UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL,
                 .index          = 7,
                 .size           = 4,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -98,7 +98,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_BACKLIGHT_COMPENSATION_CONTROL,
+                .selector       = UVC_PU_BACKLIGHT_COMPENSATION_CONTROL,
                 .index          = 8,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -106,7 +106,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_GAIN_CONTROL,
+                .selector       = UVC_PU_GAIN_CONTROL,
                 .index          = 9,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -114,7 +114,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_POWER_LINE_FREQUENCY_CONTROL,
+                .selector       = UVC_PU_POWER_LINE_FREQUENCY_CONTROL,
                 .index          = 10,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -122,7 +122,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_HUE_AUTO_CONTROL,
+                .selector       = UVC_PU_HUE_AUTO_CONTROL,
                 .index          = 11,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
@@ -130,7 +130,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
+                .selector       = UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
                 .index          = 12,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
@@ -138,7 +138,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
+                .selector       = UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
                 .index          = 13,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
@@ -146,7 +146,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_DIGITAL_MULTIPLIER_CONTROL,
+                .selector       = UVC_PU_DIGITAL_MULTIPLIER_CONTROL,
                 .index          = 14,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -154,7 +154,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL,
+                .selector       = UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL,
                 .index          = 15,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -162,21 +162,21 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_ANALOG_VIDEO_STANDARD_CONTROL,
+                .selector       = UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL,
                 .index          = 16,
                 .size           = 1,
                 .flags          = UVC_CONTROL_GET_CUR,
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_ANALOG_LOCK_STATUS_CONTROL,
+                .selector       = UVC_PU_ANALOG_LOCK_STATUS_CONTROL,
                 .index          = 17,
                 .size           = 1,
                 .flags          = UVC_CONTROL_GET_CUR,
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_SCANNING_MODE_CONTROL,
+                .selector       = UVC_CT_SCANNING_MODE_CONTROL,
                 .index          = 0,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
@@ -184,7 +184,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_AE_MODE_CONTROL,
+                .selector       = UVC_CT_AE_MODE_CONTROL,
                 .index          = 1,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
@@ -193,7 +193,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_AE_PRIORITY_CONTROL,
+                .selector       = UVC_CT_AE_PRIORITY_CONTROL,
                 .index          = 2,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
@@ -201,7 +201,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
+                .selector       = UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
                 .index          = 3,
                 .size           = 4,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -209,7 +209,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_EXPOSURE_TIME_RELATIVE_CONTROL,
+                .selector       = UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL,
                 .index          = 4,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
@@ -217,7 +217,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_FOCUS_ABSOLUTE_CONTROL,
+                .selector       = UVC_CT_FOCUS_ABSOLUTE_CONTROL,
                 .index          = 5,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -225,7 +225,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_FOCUS_RELATIVE_CONTROL,
+                .selector       = UVC_CT_FOCUS_RELATIVE_CONTROL,
                 .index          = 6,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -233,7 +233,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_IRIS_ABSOLUTE_CONTROL,
+                .selector       = UVC_CT_IRIS_ABSOLUTE_CONTROL,
                 .index          = 7,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -241,7 +241,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_IRIS_RELATIVE_CONTROL,
+                .selector       = UVC_CT_IRIS_RELATIVE_CONTROL,
                 .index          = 8,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
@@ -249,7 +249,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_ZOOM_ABSOLUTE_CONTROL,
+                .selector       = UVC_CT_ZOOM_ABSOLUTE_CONTROL,
                 .index          = 9,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -257,7 +257,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_ZOOM_RELATIVE_CONTROL,
+                .selector       = UVC_CT_ZOOM_RELATIVE_CONTROL,
                 .index          = 10,
                 .size           = 3,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -265,7 +265,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_PANTILT_ABSOLUTE_CONTROL,
+                .selector       = UVC_CT_PANTILT_ABSOLUTE_CONTROL,
                 .index          = 11,
                 .size           = 8,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -273,7 +273,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_PANTILT_RELATIVE_CONTROL,
+                .selector       = UVC_CT_PANTILT_RELATIVE_CONTROL,
                 .index          = 12,
                 .size           = 4,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -281,7 +281,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_ROLL_ABSOLUTE_CONTROL,
+                .selector       = UVC_CT_ROLL_ABSOLUTE_CONTROL,
                 .index          = 13,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -289,7 +289,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_ROLL_RELATIVE_CONTROL,
+                .selector       = UVC_CT_ROLL_RELATIVE_CONTROL,
                 .index          = 14,
                 .size           = 2,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
@@ -297,7 +297,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_FOCUS_AUTO_CONTROL,
+                .selector       = UVC_CT_FOCUS_AUTO_CONTROL,
                 .index          = 17,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
@@ -305,7 +305,7 @@ static struct uvc_control_info uvc_ctrls[] = {
         },
         {
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_PRIVACY_CONTROL,
+                .selector       = UVC_CT_PRIVACY_CONTROL,
                 .index          = 18,
                 .size           = 1,
                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
@@ -332,13 +332,13 @@ static __s32 uvc_ctrl_get_zoom(struct uvc_control_mapping *mapping,
         __s8 zoom = (__s8)data[0];
 
         switch (query) {
-        case GET_CUR:
+        case UVC_GET_CUR:
                 return (zoom == 0) ? 0 : (zoom > 0 ? data[2] : -data[2]);
 
-        case GET_MIN:
-        case GET_MAX:
-        case GET_RES:
-        case GET_DEF:
+        case UVC_GET_MIN:
+        case UVC_GET_MAX:
+        case UVC_GET_RES:
+        case UVC_GET_DEF:
         default:
                 return data[2];
         }
@@ -356,7 +356,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_BRIGHTNESS,
                 .name           = "Brightness",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_BRIGHTNESS_CONTROL,
+                .selector       = UVC_PU_BRIGHTNESS_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -366,7 +366,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_CONTRAST,
                 .name           = "Contrast",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_CONTRAST_CONTROL,
+                .selector       = UVC_PU_CONTRAST_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -376,7 +376,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_HUE,
                 .name           = "Hue",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_HUE_CONTROL,
+                .selector       = UVC_PU_HUE_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -386,7 +386,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_SATURATION,
                 .name           = "Saturation",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_SATURATION_CONTROL,
+                .selector       = UVC_PU_SATURATION_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -396,7 +396,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_SHARPNESS,
                 .name           = "Sharpness",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_SHARPNESS_CONTROL,
+                .selector       = UVC_PU_SHARPNESS_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -406,7 +406,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_GAMMA,
                 .name           = "Gamma",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_GAMMA_CONTROL,
+                .selector       = UVC_PU_GAMMA_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -416,7 +416,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_BACKLIGHT_COMPENSATION,
                 .name           = "Backlight Compensation",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_BACKLIGHT_COMPENSATION_CONTROL,
+                .selector       = UVC_PU_BACKLIGHT_COMPENSATION_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -426,7 +426,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_GAIN,
                 .name           = "Gain",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_GAIN_CONTROL,
+                .selector       = UVC_PU_GAIN_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -436,7 +436,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_POWER_LINE_FREQUENCY,
                 .name           = "Power Line Frequency",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_POWER_LINE_FREQUENCY_CONTROL,
+                .selector       = UVC_PU_POWER_LINE_FREQUENCY_CONTROL,
                 .size           = 2,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_MENU,
@@ -448,7 +448,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_HUE_AUTO,
                 .name           = "Hue, Auto",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_HUE_AUTO_CONTROL,
+                .selector       = UVC_PU_HUE_AUTO_CONTROL,
                 .size           = 1,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
@@ -458,7 +458,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_EXPOSURE_AUTO,
                 .name           = "Exposure, Auto",
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_AE_MODE_CONTROL,
+                .selector       = UVC_CT_AE_MODE_CONTROL,
                 .size           = 4,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_MENU,
@@ -470,7 +470,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_EXPOSURE_AUTO_PRIORITY,
                 .name           = "Exposure, Auto Priority",
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_AE_PRIORITY_CONTROL,
+                .selector       = UVC_CT_AE_PRIORITY_CONTROL,
                 .size           = 1,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
@@ -480,7 +480,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_EXPOSURE_ABSOLUTE,
                 .name           = "Exposure (Absolute)",
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
+                .selector       = UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
                 .size           = 32,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -490,7 +490,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_AUTO_WHITE_BALANCE,
                 .name           = "White Balance Temperature, Auto",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
+                .selector       = UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
                 .size           = 1,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
@@ -500,7 +500,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
                 .name           = "White Balance Temperature",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
+                .selector       = UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -510,7 +510,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_AUTO_WHITE_BALANCE,
                 .name           = "White Balance Component, Auto",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
+                .selector       = UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
                 .size           = 1,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
@@ -520,7 +520,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_BLUE_BALANCE,
                 .name           = "White Balance Blue Component",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_WHITE_BALANCE_COMPONENT_CONTROL,
+                .selector       = UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -530,7 +530,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_RED_BALANCE,
                 .name           = "White Balance Red Component",
                 .entity         = UVC_GUID_UVC_PROCESSING,
-                .selector       = PU_WHITE_BALANCE_COMPONENT_CONTROL,
+                .selector       = UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL,
                 .size           = 16,
                 .offset         = 16,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -540,7 +540,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_FOCUS_ABSOLUTE,
                 .name           = "Focus (absolute)",
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_FOCUS_ABSOLUTE_CONTROL,
+                .selector       = UVC_CT_FOCUS_ABSOLUTE_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -550,7 +550,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_FOCUS_AUTO,
                 .name           = "Focus, Auto",
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_FOCUS_AUTO_CONTROL,
+                .selector       = UVC_CT_FOCUS_AUTO_CONTROL,
                 .size           = 1,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
@@ -560,7 +560,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_ZOOM_ABSOLUTE,
                 .name           = "Zoom, Absolute",
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_ZOOM_ABSOLUTE_CONTROL,
+                .selector       = UVC_CT_ZOOM_ABSOLUTE_CONTROL,
                 .size           = 16,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -570,7 +570,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_ZOOM_CONTINUOUS,
                 .name           = "Zoom, Continuous",
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_ZOOM_RELATIVE_CONTROL,
+                .selector       = UVC_CT_ZOOM_RELATIVE_CONTROL,
                 .size           = 0,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
@@ -582,7 +582,7 @@ static struct uvc_control_mapping uvc_ctrl_mappings[] = {
                 .id             = V4L2_CID_PRIVACY,
                 .name           = "Privacy",
                 .entity         = UVC_GUID_UVC_CAMERA,
-                .selector       = CT_PRIVACY_CONTROL,
+                .selector       = UVC_CT_PRIVACY_CONTROL,
                 .size           = 1,
                 .offset         = 0,
                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
@@ -675,16 +675,16 @@ static const __u8 uvc_media_transport_input_guid[16] =
 static int uvc_entity_match_guid(struct uvc_entity *entity, __u8 guid[16])
 {
         switch (UVC_ENTITY_TYPE(entity)) {
-        case ITT_CAMERA:
+        case UVC_ITT_CAMERA:
                 return memcmp(uvc_camera_guid, guid, 16) == 0;
 
-        case ITT_MEDIA_TRANSPORT_INPUT:
+        case UVC_ITT_MEDIA_TRANSPORT_INPUT:
                 return memcmp(uvc_media_transport_input_guid, guid, 16) == 0;
 
-        case VC_PROCESSING_UNIT:
+        case UVC_VC_PROCESSING_UNIT:
                 return memcmp(uvc_processing_guid, guid, 16) == 0;
 
-        case VC_EXTENSION_UNIT:
+        case UVC_VC_EXTENSION_UNIT:
                 return memcmp(entity->extension.guidExtensionCode,
                               guid, 16) == 0;
 
@@ -729,7 +729,7 @@ static void __uvc_find_control(struct uvc_entity *entity, __u32 v4l2_id,
         }
 }
 
-struct uvc_control *uvc_find_control(struct uvc_video_device *video,
+struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,
         __u32 v4l2_id, struct uvc_control_mapping **mapping)
 {
         struct uvc_control *ctrl = NULL;
@@ -742,17 +742,17 @@ struct uvc_control *uvc_find_control(struct uvc_video_device *video,
         v4l2_id &= V4L2_CTRL_ID_MASK;
 
         /* Find the control. */
-        __uvc_find_control(video->processing, v4l2_id, mapping, &ctrl, next);
+        __uvc_find_control(chain->processing, v4l2_id, mapping, &ctrl, next);
         if (ctrl && !next)
                 return ctrl;
 
-        list_for_each_entry(entity, &video->iterms, chain) {
+        list_for_each_entry(entity, &chain->iterms, chain) {
                 __uvc_find_control(entity, v4l2_id, mapping, &ctrl, next);
                 if (ctrl && !next)
                         return ctrl;
         }
 
-        list_for_each_entry(entity, &video->extensions, chain) {
+        list_for_each_entry(entity, &chain->extensions, chain) {
                 __uvc_find_control(entity, v4l2_id, mapping, &ctrl, next);
                 if (ctrl && !next)
                         return ctrl;
@@ -765,7 +765,7 @@ struct uvc_control *uvc_find_control(struct uvc_video_device *video,
         return ctrl;
 }
 
-int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
+int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
         struct v4l2_queryctrl *v4l2_ctrl)
 {
         struct uvc_control *ctrl;
@@ -775,7 +775,7 @@ int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
         __u8 *data;
         int ret;
 
-        ctrl = uvc_find_control(video, v4l2_ctrl->id, &mapping);
+        ctrl = uvc_find_control(chain, v4l2_ctrl->id, &mapping);
         if (ctrl == NULL)
                 return -EINVAL;
 
@@ -793,11 +793,13 @@ int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
                 v4l2_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
 
         if (ctrl->info->flags & UVC_CONTROL_GET_DEF) {
-                if ((ret = uvc_query_ctrl(video->dev, GET_DEF, ctrl->entity->id,
-                                video->dev->intfnum, ctrl->info->selector,
-                                data, ctrl->info->size)) < 0)
+                ret = uvc_query_ctrl(chain->dev, UVC_GET_DEF, ctrl->entity->id,
+                                     chain->dev->intfnum, ctrl->info->selector,
+                                     data, ctrl->info->size);
+                if (ret < 0)
                         goto out;
-                v4l2_ctrl->default_value = mapping->get(mapping, GET_DEF, data);
+                v4l2_ctrl->default_value =
+                        mapping->get(mapping, UVC_GET_DEF, data);
         }
 
         switch (mapping->v4l2_type) {
@@ -829,25 +831,28 @@ int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
         }
 
         if (ctrl->info->flags & UVC_CONTROL_GET_MIN) {
-                if ((ret = uvc_query_ctrl(video->dev, GET_MIN, ctrl->entity->id,
-                                video->dev->intfnum, ctrl->info->selector,
-                                data, ctrl->info->size)) < 0)
+                ret = uvc_query_ctrl(chain->dev, UVC_GET_MIN, ctrl->entity->id,
+                                     chain->dev->intfnum, ctrl->info->selector,
+                                     data, ctrl->info->size);
+                if (ret < 0)
                         goto out;
-                v4l2_ctrl->minimum = mapping->get(mapping, GET_MIN, data);
+                v4l2_ctrl->minimum = mapping->get(mapping, UVC_GET_MIN, data);
         }
         if (ctrl->info->flags & UVC_CONTROL_GET_MAX) {
-                if ((ret = uvc_query_ctrl(video->dev, GET_MAX, ctrl->entity->id,
-                                video->dev->intfnum, ctrl->info->selector,
-                                data, ctrl->info->size)) < 0)
+                ret = uvc_query_ctrl(chain->dev, UVC_GET_MAX, ctrl->entity->id,
+                                     chain->dev->intfnum, ctrl->info->selector,
+                                     data, ctrl->info->size);
+                if (ret < 0)
                         goto out;
-                v4l2_ctrl->maximum = mapping->get(mapping, GET_MAX, data);
+                v4l2_ctrl->maximum = mapping->get(mapping, UVC_GET_MAX, data);
         }
         if (ctrl->info->flags & UVC_CONTROL_GET_RES) {
-                if ((ret = uvc_query_ctrl(video->dev, GET_RES, ctrl->entity->id,
-                                video->dev->intfnum, ctrl->info->selector,
-                                data, ctrl->info->size)) < 0)
+                ret = uvc_query_ctrl(chain->dev, UVC_GET_RES, ctrl->entity->id,
+                                     chain->dev->intfnum, ctrl->info->selector,
+                                     data, ctrl->info->size);
+                if (ret < 0)
                         goto out;
-                v4l2_ctrl->step = mapping->get(mapping, GET_RES, data);
+                v4l2_ctrl->step = mapping->get(mapping, UVC_GET_RES, data);
         }
 
         ret = 0;
@@ -881,9 +886,9 @@ out:
  * (UVC_CTRL_DATA_BACKUP) for all dirty controls. Both functions release the
  * control lock.
  */
-int uvc_ctrl_begin(struct uvc_video_device *video)
+int uvc_ctrl_begin(struct uvc_video_chain *chain)
 {
-        return mutex_lock_interruptible(&video->ctrl_mutex) ? -ERESTARTSYS : 0;
+        return mutex_lock_interruptible(&chain->ctrl_mutex) ? -ERESTARTSYS : 0;
 }
 
 static int uvc_ctrl_commit_entity(struct uvc_device *dev,
@@ -912,7 +917,7 @@ static int uvc_ctrl_commit_entity(struct uvc_device *dev,
                         continue;
 
                 if (!rollback)
-                        ret = uvc_query_ctrl(dev, SET_CUR, ctrl->entity->id,
+                        ret = uvc_query_ctrl(dev, UVC_SET_CUR, ctrl->entity->id,
                                 dev->intfnum, ctrl->info->selector,
                                 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
                                 ctrl->info->size);
@@ -933,34 +938,34 @@ static int uvc_ctrl_commit_entity(struct uvc_device *dev,
         return 0;
 }
 
-int __uvc_ctrl_commit(struct uvc_video_device *video, int rollback)
+int __uvc_ctrl_commit(struct uvc_video_chain *chain, int rollback)
 {
         struct uvc_entity *entity;
         int ret = 0;
 
         /* Find the control. */
-        ret = uvc_ctrl_commit_entity(video->dev, video->processing, rollback);
+        ret = uvc_ctrl_commit_entity(chain->dev, chain->processing, rollback);
         if (ret < 0)
                 goto done;
 
-        list_for_each_entry(entity, &video->iterms, chain) {
-                ret = uvc_ctrl_commit_entity(video->dev, entity, rollback);
+        list_for_each_entry(entity, &chain->iterms, chain) {
+                ret = uvc_ctrl_commit_entity(chain->dev, entity, rollback);
                 if (ret < 0)
                         goto done;
         }
 
-        list_for_each_entry(entity, &video->extensions, chain) {
-                ret = uvc_ctrl_commit_entity(video->dev, entity, rollback);
+        list_for_each_entry(entity, &chain->extensions, chain) {
+                ret = uvc_ctrl_commit_entity(chain->dev, entity, rollback);
                 if (ret < 0)
                         goto done;
         }
 
 done:
-        mutex_unlock(&video->ctrl_mutex);
+        mutex_unlock(&chain->ctrl_mutex);
         return ret;
 }
 
-int uvc_ctrl_get(struct uvc_video_device *video,
+int uvc_ctrl_get(struct uvc_video_chain *chain,
         struct v4l2_ext_control *xctrl)
 {
         struct uvc_control *ctrl;
@@ -969,13 +974,13 @@ int uvc_ctrl_get(struct uvc_video_device *video,
         unsigned int i;
         int ret;
 
-        ctrl = uvc_find_control(video, xctrl->id, &mapping);
+        ctrl = uvc_find_control(chain, xctrl->id, &mapping);
         if (ctrl == NULL || (ctrl->info->flags & UVC_CONTROL_GET_CUR) == 0)
                 return -EINVAL;
 
         if (!ctrl->loaded) {
-                ret = uvc_query_ctrl(video->dev, GET_CUR, ctrl->entity->id,
-                                video->dev->intfnum, ctrl->info->selector,
+                ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR, ctrl->entity->id,
+                                chain->dev->intfnum, ctrl->info->selector,
                                 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
                                 ctrl->info->size);
                 if (ret < 0)
@@ -984,7 +989,7 @@ int uvc_ctrl_get(struct uvc_video_device *video,
                 ctrl->loaded = 1;
         }
 
-        xctrl->value = mapping->get(mapping, GET_CUR,
+        xctrl->value = mapping->get(mapping, UVC_GET_CUR,
                 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT));
 
         if (mapping->v4l2_type == V4L2_CTRL_TYPE_MENU) {
@@ -1000,7 +1005,7 @@ int uvc_ctrl_get(struct uvc_video_device *video,
         return 0;
 }
 
-int uvc_ctrl_set(struct uvc_video_device *video,
+int uvc_ctrl_set(struct uvc_video_chain *chain,
         struct v4l2_ext_control *xctrl)
 {
         struct uvc_control *ctrl;
@@ -1008,7 +1013,7 @@ int uvc_ctrl_set(struct uvc_video_device *video,
         s32 value = xctrl->value;
         int ret;
 
-        ctrl = uvc_find_control(video, xctrl->id, &mapping);
+        ctrl = uvc_find_control(chain, xctrl->id, &mapping);
         if (ctrl == NULL || (ctrl->info->flags & UVC_CONTROL_SET_CUR) == 0)
                 return -EINVAL;
 
@@ -1023,8 +1028,8 @@ int uvc_ctrl_set(struct uvc_video_device *video,
                         memset(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
                                 0, ctrl->info->size);
                 } else {
-                        ret = uvc_query_ctrl(video->dev, GET_CUR,
-                                ctrl->entity->id, video->dev->intfnum,
+                        ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR,
+                                ctrl->entity->id, chain->dev->intfnum,
                                 ctrl->info->selector,
                                 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
                                 ctrl->info->size);
@@ -1053,7 +1058,7 @@ int uvc_ctrl_set(struct uvc_video_device *video,
  * Dynamic controls
  */
 
-int uvc_xu_ctrl_query(struct uvc_video_device *video,
+int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
         struct uvc_xu_control *xctrl, int set)
 {
         struct uvc_entity *entity;
@@ -1063,7 +1068,7 @@ int uvc_xu_ctrl_query(struct uvc_video_device *video,
         int ret;
 
         /* Find the extension unit. */
-        list_for_each_entry(entity, &video->extensions, chain) {
+        list_for_each_entry(entity, &chain->extensions, chain) {
                 if (entity->id == xctrl->unit)
                         break;
         }
@@ -1102,7 +1107,7 @@ int uvc_xu_ctrl_query(struct uvc_video_device *video,
             (!set && !(ctrl->info->flags & UVC_CONTROL_GET_CUR)))
                 return -EINVAL;
 
-        if (mutex_lock_interruptible(&video->ctrl_mutex))
+        if (mutex_lock_interruptible(&chain->ctrl_mutex))
                 return -ERESTARTSYS;
 
         memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
@@ -1115,9 +1120,9 @@ int uvc_xu_ctrl_query(struct uvc_video_device *video,
                 goto out;
         }
 
-        ret = uvc_query_ctrl(video->dev, set ? SET_CUR : GET_CUR, xctrl->unit,
-                             video->dev->intfnum, xctrl->selector, data,
-                             xctrl->size);
+        ret = uvc_query_ctrl(chain->dev, set ? UVC_SET_CUR : UVC_GET_CUR,
+                             xctrl->unit, chain->dev->intfnum, xctrl->selector,
+                             data, xctrl->size);
         if (ret < 0)
                 goto out;
 
@@ -1132,7 +1137,7 @@ out:
                        uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
                        xctrl->size);
 
-        mutex_unlock(&video->ctrl_mutex);
+        mutex_unlock(&chain->ctrl_mutex);
         return ret;
 }
 
@@ -1211,7 +1216,7 @@ static void uvc_ctrl_add_ctrl(struct uvc_device *dev,
         if (!found)
                 return;
 
-        if (UVC_ENTITY_TYPE(entity) == VC_EXTENSION_UNIT) {
+        if (UVC_ENTITY_TYPE(entity) == UVC_VC_EXTENSION_UNIT) {
                 /* Check if the device control information and length match
                  * the user supplied information.
                  */
@@ -1219,8 +1224,9 @@ static void uvc_ctrl_add_ctrl(struct uvc_device *dev,
                 __le16 size;
                 __u8 inf;
 
-                if ((ret = uvc_query_ctrl(dev, GET_LEN, ctrl->entity->id,
-                        dev->intfnum, info->selector, (__u8 *)&size, 2)) < 0) {
+                ret = uvc_query_ctrl(dev, UVC_GET_LEN, ctrl->entity->id,
+                        dev->intfnum, info->selector, (__u8 *)&size, 2);
+                if (ret < 0) {
                         uvc_trace(UVC_TRACE_CONTROL, "GET_LEN failed on "
                                 "control " UVC_GUID_FORMAT "/%u (%d).\n",
                                 UVC_GUID_ARGS(info->entity), info->selector,
@@ -1236,8 +1242,9 @@ static void uvc_ctrl_add_ctrl(struct uvc_device *dev,
                         return;
                 }
 
-                if ((ret = uvc_query_ctrl(dev, GET_INFO, ctrl->entity->id,
-                        dev->intfnum, info->selector, &inf, 1)) < 0) {
+                ret = uvc_query_ctrl(dev, UVC_GET_INFO, ctrl->entity->id,
+                        dev->intfnum, info->selector, &inf, 1);
+                if (ret < 0) {
                         uvc_trace(UVC_TRACE_CONTROL, "GET_INFO failed on "
                                 "control " UVC_GUID_FORMAT "/%u (%d).\n",
                                 UVC_GUID_ARGS(info->entity), info->selector,
@@ -1391,7 +1398,7 @@ uvc_ctrl_prune_entity(struct uvc_device *dev, struct uvc_entity *entity)
         unsigned int size;
         unsigned int i;
 
-        if (UVC_ENTITY_TYPE(entity) != VC_PROCESSING_UNIT)
+        if (UVC_ENTITY_TYPE(entity) != UVC_VC_PROCESSING_UNIT)
                 return;
 
         controls = entity->processing.bmControls;
@@ -1427,13 +1434,13 @@ int uvc_ctrl_init_device(struct uvc_device *dev)
                 unsigned int bControlSize = 0, ncontrols = 0;
                 __u8 *bmControls = NULL;
 
-                if (UVC_ENTITY_TYPE(entity) == VC_EXTENSION_UNIT) {
+                if (UVC_ENTITY_TYPE(entity) == UVC_VC_EXTENSION_UNIT) {
                         bmControls = entity->extension.bmControls;
                         bControlSize = entity->extension.bControlSize;
-                } else if (UVC_ENTITY_TYPE(entity) == VC_PROCESSING_UNIT) {
+                } else if (UVC_ENTITY_TYPE(entity) == UVC_VC_PROCESSING_UNIT) {
                         bmControls = entity->processing.bmControls;
                         bControlSize = entity->processing.bControlSize;
-                } else if (UVC_ENTITY_TYPE(entity) == ITT_CAMERA) {
+                } else if (UVC_ENTITY_TYPE(entity) == UVC_ITT_CAMERA) {
                         bmControls = entity->camera.bmControls;
                         bControlSize = entity->camera.bControlSize;
                 }
diff --git a/drivers/media/video/uvc/uvc_driver.c b/drivers/media/video/uvc/uvc_driver.c
index 04b47832fa0a..8756be569154 100644
--- a/drivers/media/video/uvc/uvc_driver.c
+++ b/drivers/media/video/uvc/uvc_driver.c
@@ -249,23 +249,23 @@ static struct uvc_entity *uvc_entity_by_reference(struct uvc_device *dev,
 
         list_for_each_entry_continue(entity, &dev->entities, list) {
                 switch (UVC_ENTITY_TYPE(entity)) {
-                case TT_STREAMING:
+                case UVC_TT_STREAMING:
                         if (entity->output.bSourceID == id)
                                 return entity;
                         break;
 
-                case VC_PROCESSING_UNIT:
+                case UVC_VC_PROCESSING_UNIT:
                         if (entity->processing.bSourceID == id)
                                 return entity;
                         break;
 
-                case VC_SELECTOR_UNIT:
+                case UVC_VC_SELECTOR_UNIT:
                         for (i = 0; i < entity->selector.bNrInPins; ++i)
                                 if (entity->selector.baSourceID[i] == id)
                                         return entity;
                         break;
 
-                case VC_EXTENSION_UNIT:
+                case UVC_VC_EXTENSION_UNIT:
                         for (i = 0; i < entity->extension.bNrInPins; ++i)
                                 if (entity->extension.baSourceID[i] == id)
                                         return entity;
@@ -276,8 +276,20 @@ static struct uvc_entity *uvc_entity_by_reference(struct uvc_device *dev,
         return NULL;
 }
 
+static struct uvc_streaming *uvc_stream_by_id(struct uvc_device *dev, int id)
+{
+        struct uvc_streaming *stream;
+
+        list_for_each_entry(stream, &dev->streams, list) {
+                if (stream->header.bTerminalLink == id)
+                        return stream;
+        }
+
+        return NULL;
+}
+
 /* ------------------------------------------------------------------------
- * Descriptors handling
+ * Descriptors parsing
  */
 
 static int uvc_parse_format(struct uvc_device *dev,
@@ -297,9 +309,9 @@ static int uvc_parse_format(struct uvc_device *dev,
         format->index = buffer[3];
 
         switch (buffer[2]) {
-        case VS_FORMAT_UNCOMPRESSED:
-        case VS_FORMAT_FRAME_BASED:
-                n = buffer[2] == VS_FORMAT_UNCOMPRESSED ? 27 : 28;
+        case UVC_VS_FORMAT_UNCOMPRESSED:
+        case UVC_VS_FORMAT_FRAME_BASED:
+                n = buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED ? 27 : 28;
                 if (buflen < n) {
                         uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
                                "interface %d FORMAT error\n",
@@ -325,16 +337,16 @@ static int uvc_parse_format(struct uvc_device *dev,
                 }
 
                 format->bpp = buffer[21];
-                if (buffer[2] == VS_FORMAT_UNCOMPRESSED) {
-                        ftype = VS_FRAME_UNCOMPRESSED;
+                if (buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED) {
+                        ftype = UVC_VS_FRAME_UNCOMPRESSED;
                 } else {
-                        ftype = VS_FRAME_FRAME_BASED;
+                        ftype = UVC_VS_FRAME_FRAME_BASED;
                         if (buffer[27])
                                 format->flags = UVC_FMT_FLAG_COMPRESSED;
                 }
                 break;
 
-        case VS_FORMAT_MJPEG:
+        case UVC_VS_FORMAT_MJPEG:
                 if (buflen < 11) {
                         uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
                                "interface %d FORMAT error\n",
@@ -347,10 +359,10 @@ static int uvc_parse_format(struct uvc_device *dev,
                 format->fcc = V4L2_PIX_FMT_MJPEG;
                 format->flags = UVC_FMT_FLAG_COMPRESSED;
                 format->bpp = 0;
-                ftype = VS_FRAME_MJPEG;
+                ftype = UVC_VS_FRAME_MJPEG;
                 break;
 
-        case VS_FORMAT_DV:
+        case UVC_VS_FORMAT_DV:
                 if (buflen < 9) {
                         uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
                                "interface %d FORMAT error\n",
@@ -395,8 +407,8 @@ static int uvc_parse_format(struct uvc_device *dev,
                 format->nframes = 1;
                 break;
 
-        case VS_FORMAT_MPEG2TS:
-        case VS_FORMAT_STREAM_BASED:
+        case UVC_VS_FORMAT_MPEG2TS:
+        case UVC_VS_FORMAT_STREAM_BASED:
                 /* Not supported yet. */
         default:
                 uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
@@ -416,7 +428,7 @@ static int uvc_parse_format(struct uvc_device *dev,
          */
         while (buflen > 2 && buffer[2] == ftype) {
                 frame = &format->frame[format->nframes];
-                if (ftype != VS_FRAME_FRAME_BASED)
+                if (ftype != UVC_VS_FRAME_FRAME_BASED)
                         n = buflen > 25 ? buffer[25] : 0;
                 else
                         n = buflen > 21 ? buffer[21] : 0;
@@ -436,7 +448,7 @@ static int uvc_parse_format(struct uvc_device *dev,
                 frame->wHeight = get_unaligned_le16(&buffer[7]);
                 frame->dwMinBitRate = get_unaligned_le32(&buffer[9]);
                 frame->dwMaxBitRate = get_unaligned_le32(&buffer[13]);
-                if (ftype != VS_FRAME_FRAME_BASED) {
+                if (ftype != UVC_VS_FRAME_FRAME_BASED) {
                         frame->dwMaxVideoFrameBufferSize =
                                 get_unaligned_le32(&buffer[17]);
                         frame->dwDefaultFrameInterval =
@@ -491,12 +503,12 @@ static int uvc_parse_format(struct uvc_device *dev,
                 buffer += buffer[0];
         }
 
-        if (buflen > 2 && buffer[2] == VS_STILL_IMAGE_FRAME) {
+        if (buflen > 2 && buffer[2] == UVC_VS_STILL_IMAGE_FRAME) {
                 buflen -= buffer[0];
                 buffer += buffer[0];
         }
 
-        if (buflen > 2 && buffer[2] == VS_COLORFORMAT) {
+        if (buflen > 2 && buffer[2] == UVC_VS_COLORFORMAT) {
                 if (buflen < 6) {
                         uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
                                "interface %d COLORFORMAT error\n",
@@ -530,7 +542,7 @@ static int uvc_parse_streaming(struct uvc_device *dev,
         int ret = -EINVAL;
 
         if (intf->cur_altsetting->desc.bInterfaceSubClass
-                != SC_VIDEOSTREAMING) {
+                != UVC_SC_VIDEOSTREAMING) {
                 uvc_trace(UVC_TRACE_DESCR, "device %d interface %d isn't a "
                         "video streaming interface\n", dev->udev->devnum,
                         intf->altsetting[0].desc.bInterfaceNumber);
@@ -551,6 +563,7 @@ static int uvc_parse_streaming(struct uvc_device *dev,
         }
 
         mutex_init(&streaming->mutex);
+        streaming->dev = dev;
         streaming->intf = usb_get_intf(intf);
         streaming->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;
 
@@ -589,12 +602,12 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 
         /* Parse the header descriptor. */
         switch (buffer[2]) {
-        case VS_OUTPUT_HEADER:
+        case UVC_VS_OUTPUT_HEADER:
                 streaming->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
                 size = 9;
                 break;
 
-        case VS_INPUT_HEADER:
+        case UVC_VS_INPUT_HEADER:
                 streaming->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                 size = 13;
                 break;
@@ -618,7 +631,7 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 
         streaming->header.bNumFormats = p;
         streaming->header.bEndpointAddress = buffer[6];
-        if (buffer[2] == VS_INPUT_HEADER) {
+        if (buffer[2] == UVC_VS_INPUT_HEADER) {
                 streaming->header.bmInfo = buffer[7];
                 streaming->header.bTerminalLink = buffer[8];
                 streaming->header.bStillCaptureMethod = buffer[9];
@@ -644,15 +657,15 @@ static int uvc_parse_streaming(struct uvc_device *dev,
         _buflen = buflen;
 
         /* Count the format and frame descriptors. */
-        while (_buflen > 2 && _buffer[1] == CS_INTERFACE) {
+        while (_buflen > 2 && _buffer[1] == USB_DT_CS_INTERFACE) {
                 switch (_buffer[2]) {
-                case VS_FORMAT_UNCOMPRESSED:
-                case VS_FORMAT_MJPEG:
-                case VS_FORMAT_FRAME_BASED:
+                case UVC_VS_FORMAT_UNCOMPRESSED:
+                case UVC_VS_FORMAT_MJPEG:
+                case UVC_VS_FORMAT_FRAME_BASED:
                         nformats++;
                         break;
 
-                case VS_FORMAT_DV:
+                case UVC_VS_FORMAT_DV:
                         /* DV format has no frame descriptor. We will create a
                          * dummy frame descriptor with a dummy frame interval.
                          */
@@ -661,22 +674,22 @@ static int uvc_parse_streaming(struct uvc_device *dev,
                         nintervals++;
                         break;
 
-                case VS_FORMAT_MPEG2TS:
-                case VS_FORMAT_STREAM_BASED:
+                case UVC_VS_FORMAT_MPEG2TS:
+                case UVC_VS_FORMAT_STREAM_BASED:
                         uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
                                 "interface %d FORMAT %u is not supported.\n",
                                 dev->udev->devnum,
                                 alts->desc.bInterfaceNumber, _buffer[2]);
                         break;
 
-                case VS_FRAME_UNCOMPRESSED:
-                case VS_FRAME_MJPEG:
+                case UVC_VS_FRAME_UNCOMPRESSED:
+                case UVC_VS_FRAME_MJPEG:
                         nframes++;
                         if (_buflen > 25)
                                 nintervals += _buffer[25] ? _buffer[25] : 3;
                         break;
 
-                case VS_FRAME_FRAME_BASED:
+                case UVC_VS_FRAME_FRAME_BASED:
                         nframes++;
                         if (_buflen > 21)
                                 nintervals += _buffer[21] ? _buffer[21] : 3;
@@ -709,12 +722,12 @@ static int uvc_parse_streaming(struct uvc_device *dev,
         streaming->nformats = nformats;
 
         /* Parse the format descriptors. */
-        while (buflen > 2 && buffer[1] == CS_INTERFACE) {
+        while (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE) {
                 switch (buffer[2]) {
-                case VS_FORMAT_UNCOMPRESSED:
-                case VS_FORMAT_MJPEG:
-                case VS_FORMAT_DV:
-                case VS_FORMAT_FRAME_BASED:
+                case UVC_VS_FORMAT_UNCOMPRESSED:
+                case UVC_VS_FORMAT_MJPEG:
+                case UVC_VS_FORMAT_DV:
+                case UVC_VS_FORMAT_FRAME_BASED:
                         format->frame = frame;
                         ret = uvc_parse_format(dev, streaming, format,
                                 &interval, buffer, buflen);
@@ -751,7 +764,7 @@ static int uvc_parse_streaming(struct uvc_device *dev,
                         streaming->maxpsize = psize;
         }
 
-        list_add_tail(&streaming->list, &dev->streaming);
+        list_add_tail(&streaming->list, &dev->streams);
         return 0;
 
 error:
@@ -819,7 +832,7 @@ static int uvc_parse_vendor_control(struct uvc_device *dev,
                         return -ENOMEM;
 
                 unit->id = buffer[3];
-                unit->type = VC_EXTENSION_UNIT;
+                unit->type = UVC_VC_EXTENSION_UNIT;
                 memcpy(unit->extension.guidExtensionCode, &buffer[4], 16);
                 unit->extension.bNumControls = buffer[20];
                 unit->extension.bNrInPins = get_unaligned_le16(&buffer[21]);
@@ -856,7 +869,7 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
         __u16 type;
 
         switch (buffer[2]) {
-        case VC_HEADER:
+        case UVC_VC_HEADER:
                 n = buflen >= 12 ? buffer[11] : 0;
 
                 if (buflen < 12 || buflen < 12 + n) {
@@ -883,7 +896,7 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
                 }
                 break;
 
-        case VC_INPUT_TERMINAL:
+        case UVC_VC_INPUT_TERMINAL:
                 if (buflen < 8) {
                         uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
                                 "interface %d INPUT_TERMINAL error\n",
@@ -908,11 +921,11 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
                 p = 0;
                 len = 8;
 
-                if (type == ITT_CAMERA) {
+                if (type == UVC_ITT_CAMERA) {
                         n = buflen >= 15 ? buffer[14] : 0;
                         len = 15;
 
-                } else if (type == ITT_MEDIA_TRANSPORT_INPUT) {
+                } else if (type == UVC_ITT_MEDIA_TRANSPORT_INPUT) {
                         n = buflen >= 9 ? buffer[8] : 0;
                         p = buflen >= 10 + n ? buffer[9+n] : 0;
                         len = 10;
@@ -932,7 +945,7 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
                 term->id = buffer[3];
                 term->type = type | UVC_TERM_INPUT;
 
-                if (UVC_ENTITY_TYPE(term) == ITT_CAMERA) {
+                if (UVC_ENTITY_TYPE(term) == UVC_ITT_CAMERA) {
                         term->camera.bControlSize = n;
                         term->camera.bmControls = (__u8 *)term + sizeof *term;
                         term->camera.wObjectiveFocalLengthMin =
@@ -942,7 +955,8 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
                         term->camera.wOcularFocalLength =
                                 get_unaligned_le16(&buffer[12]);
                         memcpy(term->camera.bmControls, &buffer[15], n);
-                } else if (UVC_ENTITY_TYPE(term) == ITT_MEDIA_TRANSPORT_INPUT) {
+                } else if (UVC_ENTITY_TYPE(term) ==
+                           UVC_ITT_MEDIA_TRANSPORT_INPUT) {
                         term->media.bControlSize = n;
                         term->media.bmControls = (__u8 *)term + sizeof *term;
                         term->media.bTransportModeSize = p;
@@ -955,9 +969,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
                 if (buffer[7] != 0)
                         usb_string(udev, buffer[7], term->name,
                                    sizeof term->name);
-                else if (UVC_ENTITY_TYPE(term) == ITT_CAMERA)
+                else if (UVC_ENTITY_TYPE(term) == UVC_ITT_CAMERA)
                         sprintf(term->name, "Camera %u", buffer[3]);
-                else if (UVC_ENTITY_TYPE(term) == ITT_MEDIA_TRANSPORT_INPUT)
+                else if (UVC_ENTITY_TYPE(term) == UVC_ITT_MEDIA_TRANSPORT_INPUT)
                         sprintf(term->name, "Media %u", buffer[3]);
                 else
                         sprintf(term->name, "Input %u", buffer[3]);
@@ -965,7 +979,7 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
                 list_add_tail(&term->list, &dev->entities);
                 break;
 
-        case VC_OUTPUT_TERMINAL:
+        case UVC_VC_OUTPUT_TERMINAL:
                 if (buflen < 9) {
                         uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
                                 "interface %d OUTPUT_TERMINAL error\n",
@@ -1002,7 +1016,7 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
                 list_add_tail(&term->list, &dev->entities);
                 break;
 
-        case VC_SELECTOR_UNIT:
+        case UVC_VC_SELECTOR_UNIT:
                 p = buflen >= 5 ? buffer[4] : 0;
 
                 if (buflen < 5 || buflen < 6 + p) {
@@ -1031,7 +1045,7 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
                 list_add_tail(&unit->list, &dev->entities);
                 break;
 
-        case VC_PROCESSING_UNIT:
+        case UVC_VC_PROCESSING_UNIT:
                 n = buflen >= 8 ? buffer[7] : 0;
                 p = dev->uvc_version >= 0x0110 ? 10 : 9;
 
@@ -1066,7 +1080,7 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
                 list_add_tail(&unit->list, &dev->entities);
                 break;
 
-        case VC_EXTENSION_UNIT:
+        case UVC_VC_EXTENSION_UNIT:
                 p = buflen >= 22 ? buffer[21] : 0;
                 n = buflen >= 24 + p ? buffer[22+p] : 0;
 
@@ -1158,43 +1172,40 @@ next_descriptor:
 }
 
 /* ------------------------------------------------------------------------
- * USB probe and disconnect
+ * UVC device scan
  */
 
 /*
- * Unregister the video devices.
- */
-static void uvc_unregister_video(struct uvc_device *dev)
-{
-        if (dev->video.vdev) {
-                if (dev->video.vdev->minor == -1)
-                        video_device_release(dev->video.vdev);
-                else
-                        video_unregister_device(dev->video.vdev);
-                dev->video.vdev = NULL;
-        }
-}
-
-/*
  * Scan the UVC descriptors to locate a chain starting at an Output Terminal
  * and containing the following units:
  *
- * - one Output Terminal (USB Streaming or Display)
+ * - one or more Output Terminals (USB Streaming or Display)
  * - zero or one Processing Unit
- * - zero, one or mode single-input Selector Units
+ * - zero, one or more single-input Selector Units
  * - zero or one multiple-input Selector Units, provided all inputs are
  *   connected to input terminals
  * - zero, one or mode single-input Extension Units
  * - one or more Input Terminals (Camera, External or USB Streaming)
  *
- * A side forward scan is made on each detected entity to check for additional
- * extension units.
+ * The terminal and units must match on of the following structures:
+ *
+ * ITT_*(0) -> +---------+    +---------+    +---------+ -> TT_STREAMING(0)
+ * ...         | SU{0,1} | -> | PU{0,1} | -> | XU{0,n} |    ...
+ * ITT_*(n) -> +---------+    +---------+    +---------+ -> TT_STREAMING(n)
+ *
+ *                 +---------+    +---------+ -> OTT_*(0)
+ * TT_STREAMING -> | PU{0,1} | -> | XU{0,n} |    ...
+ *                 +---------+    +---------+ -> OTT_*(n)
+ *
+ * The Processing Unit and Extension Units can be in any order. Additional
+ * Extension Units connected to the main chain as single-unit branches are
+ * also supported. Single-input Selector Units are ignored.
  */
-static int uvc_scan_chain_entity(struct uvc_video_device *video,
+static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
         struct uvc_entity *entity)
 {
         switch (UVC_ENTITY_TYPE(entity)) {
-        case VC_EXTENSION_UNIT:
+        case UVC_VC_EXTENSION_UNIT:
                 if (uvc_trace_param & UVC_TRACE_PROBE)
                         printk(" <- XU %d", entity->id);
 
@@ -1204,23 +1215,23 @@ static int uvc_scan_chain_entity(struct uvc_video_device *video,
                         return -1;
                 }
 
-                list_add_tail(&entity->chain, &video->extensions);
+                list_add_tail(&entity->chain, &chain->extensions);
                 break;
 
-        case VC_PROCESSING_UNIT:
+        case UVC_VC_PROCESSING_UNIT:
                 if (uvc_trace_param & UVC_TRACE_PROBE)
                         printk(" <- PU %d", entity->id);
 
-                if (video->processing != NULL) {
+                if (chain->processing != NULL) {
                         uvc_trace(UVC_TRACE_DESCR, "Found multiple "
                                 "Processing Units in chain.\n");
                         return -1;
                 }
 
-                video->processing = entity;
+                chain->processing = entity;
                 break;
 
-        case VC_SELECTOR_UNIT:
+        case UVC_VC_SELECTOR_UNIT:
                 if (uvc_trace_param & UVC_TRACE_PROBE)
                         printk(" <- SU %d", entity->id);
 
@@ -1228,25 +1239,25 @@ static int uvc_scan_chain_entity(struct uvc_video_device *video,
                 if (entity->selector.bNrInPins == 1)
                         break;
 
-                if (video->selector != NULL) {
+                if (chain->selector != NULL) {
                         uvc_trace(UVC_TRACE_DESCR, "Found multiple Selector "
                                 "Units in chain.\n");
                         return -1;
                 }
 
-                video->selector = entity;
+                chain->selector = entity;
                 break;
 
-        case ITT_VENDOR_SPECIFIC:
-        case ITT_CAMERA:
-        case ITT_MEDIA_TRANSPORT_INPUT:
+        case UVC_ITT_VENDOR_SPECIFIC:
+        case UVC_ITT_CAMERA:
+        case UVC_ITT_MEDIA_TRANSPORT_INPUT:
                 if (uvc_trace_param & UVC_TRACE_PROBE)
                         printk(" <- IT %d\n", entity->id);
 
-                list_add_tail(&entity->chain, &video->iterms);
+                list_add_tail(&entity->chain, &chain->iterms);
                 break;
 
-        case TT_STREAMING:
+        case UVC_TT_STREAMING:
                 if (uvc_trace_param & UVC_TRACE_PROBE)
                         printk(" <- IT %d\n", entity->id);
 
@@ -1256,14 +1267,7 @@ static int uvc_scan_chain_entity(struct uvc_video_device *video,
                         return -1;
                 }
 
-                if (video->sterm != NULL) {
-                        uvc_trace(UVC_TRACE_DESCR, "Found multiple streaming "
-                                "entities in chain.\n");
-                        return -1;
-                }
-
-                list_add_tail(&entity->chain, &video->iterms);
-                video->sterm = entity;
+                list_add_tail(&entity->chain, &chain->iterms);
                 break;
 
         default:
@@ -1275,7 +1279,7 @@ static int uvc_scan_chain_entity(struct uvc_video_device *video,
         return 0;
 }
 
-static int uvc_scan_chain_forward(struct uvc_video_device *video,
+static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
         struct uvc_entity *entity, struct uvc_entity *prev)
 {
         struct uvc_entity *forward;
@@ -1286,28 +1290,51 @@ static int uvc_scan_chain_forward(struct uvc_video_device *video,
         found = 0;
 
         while (1) {
-                forward = uvc_entity_by_reference(video->dev, entity->id,
+                forward = uvc_entity_by_reference(chain->dev, entity->id,
                         forward);
                 if (forward == NULL)
                         break;
-
-                if (UVC_ENTITY_TYPE(forward) != VC_EXTENSION_UNIT ||
-                    forward == prev)
+                if (forward == prev)
                         continue;
 
-                if (forward->extension.bNrInPins != 1) {
-                        uvc_trace(UVC_TRACE_DESCR, "Extension unit %d has "
-                                "more than 1 input pin.\n", entity->id);
-                        return -1;
-                }
+                switch (UVC_ENTITY_TYPE(forward)) {
+                case UVC_VC_EXTENSION_UNIT:
+                        if (forward->extension.bNrInPins != 1) {
+                                uvc_trace(UVC_TRACE_DESCR, "Extension unit %d "
+                                          "has more than 1 input pin.\n",
+                                          entity->id);
+                                return -EINVAL;
+                        }
+
+                        list_add_tail(&forward->chain, &chain->extensions);
+                        if (uvc_trace_param & UVC_TRACE_PROBE) {
+                                if (!found)
+                                        printk(" (->");
 
-                list_add_tail(&forward->chain, &video->extensions);
-                if (uvc_trace_param & UVC_TRACE_PROBE) {
-                        if (!found)
-                                printk(" (-> XU");
+                                printk(" XU %d", forward->id);
+                                found = 1;
+                        }
+                        break;
+
+                case UVC_OTT_VENDOR_SPECIFIC:
+                case UVC_OTT_DISPLAY:
+                case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
+                case UVC_TT_STREAMING:
+                        if (UVC_ENTITY_IS_ITERM(forward)) {
+                                uvc_trace(UVC_TRACE_DESCR, "Unsupported input "
+                                        "terminal %u.\n", forward->id);
+                                return -EINVAL;
+                        }
 
-                        printk(" %d", forward->id);
-                        found = 1;
+                        list_add_tail(&forward->chain, &chain->oterms);
+                        if (uvc_trace_param & UVC_TRACE_PROBE) {
+                                if (!found)
+                                        printk(" (->");
+
+                                printk(" OT %d", forward->id);
+                                found = 1;
+                        }
+                        break;
                 }
         }
         if (found)
@@ -1316,22 +1343,22 @@ static int uvc_scan_chain_forward(struct uvc_video_device *video,
         return 0;
 }
 
-static int uvc_scan_chain_backward(struct uvc_video_device *video,
+static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
         struct uvc_entity *entity)
 {
         struct uvc_entity *term;
         int id = -1, i;
 
         switch (UVC_ENTITY_TYPE(entity)) {
-        case VC_EXTENSION_UNIT:
+        case UVC_VC_EXTENSION_UNIT:
                 id = entity->extension.baSourceID[0];
                 break;
 
-        case VC_PROCESSING_UNIT:
+        case UVC_VC_PROCESSING_UNIT:
                 id = entity->processing.bSourceID;
                 break;
 
-        case VC_SELECTOR_UNIT:
+        case UVC_VC_SELECTOR_UNIT:
                 /* Single-input selector units are ignored. */
                 if (entity->selector.bNrInPins == 1) {
                         id = entity->selector.baSourceID[0];
@@ -1341,10 +1368,10 @@ static int uvc_scan_chain_backward(struct uvc_video_device *video,
                 if (uvc_trace_param & UVC_TRACE_PROBE)
                         printk(" <- IT");
 
-                video->selector = entity;
+                chain->selector = entity;
                 for (i = 0; i < entity->selector.bNrInPins; ++i) {
                         id = entity->selector.baSourceID[i];
-                        term = uvc_entity_by_id(video->dev, id);
+                        term = uvc_entity_by_id(chain->dev, id);
                         if (term == NULL || !UVC_ENTITY_IS_ITERM(term)) {
                                 uvc_trace(UVC_TRACE_DESCR, "Selector unit %d "
                                         "input %d isn't connected to an "
@@ -1355,8 +1382,8 @@ static int uvc_scan_chain_backward(struct uvc_video_device *video,
                         if (uvc_trace_param & UVC_TRACE_PROBE)
                                 printk(" %d", term->id);
 
-                        list_add_tail(&term->chain, &video->iterms);
-                        uvc_scan_chain_forward(video, term, entity);
+                        list_add_tail(&term->chain, &chain->iterms);
+                        uvc_scan_chain_forward(chain, term, entity);
                 }
 
                 if (uvc_trace_param & UVC_TRACE_PROBE)
@@ -1369,125 +1396,170 @@ static int uvc_scan_chain_backward(struct uvc_video_device *video,
         return id;
 }
 
-static int uvc_scan_chain(struct uvc_video_device *video)
+static int uvc_scan_chain(struct uvc_video_chain *chain,
+                          struct uvc_entity *oterm)
 {
         struct uvc_entity *entity, *prev;
         int id;
 
-        entity = video->oterm;
+        entity = oterm;
+        list_add_tail(&entity->chain, &chain->oterms);
         uvc_trace(UVC_TRACE_PROBE, "Scanning UVC chain: OT %d", entity->id);
 
-        if (UVC_ENTITY_TYPE(entity) == TT_STREAMING)
-                video->sterm = entity;
-
         id = entity->output.bSourceID;
         while (id != 0) {
                 prev = entity;
-                entity = uvc_entity_by_id(video->dev, id);
+                entity = uvc_entity_by_id(chain->dev, id);
                 if (entity == NULL) {
                         uvc_trace(UVC_TRACE_DESCR, "Found reference to "
                                 "unknown entity %d.\n", id);
-                        return -1;
+                        return -EINVAL;
+                }
+
+                if (entity->chain.next || entity->chain.prev) {
+                        uvc_trace(UVC_TRACE_DESCR, "Found reference to "
+                                "entity %d already in chain.\n", id);
+                        return -EINVAL;
                 }
 
                 /* Process entity */
-                if (uvc_scan_chain_entity(video, entity) < 0)
-                        return -1;
+                if (uvc_scan_chain_entity(chain, entity) < 0)
+                        return -EINVAL;
 
                 /* Forward scan */
-                if (uvc_scan_chain_forward(video, entity, prev) < 0)
-                        return -1;
+                if (uvc_scan_chain_forward(chain, entity, prev) < 0)
+                        return -EINVAL;
 
                 /* Stop when a terminal is found. */
-                if (!UVC_ENTITY_IS_UNIT(entity))
+                if (UVC_ENTITY_IS_TERM(entity))
                         break;
 
                 /* Backward scan */
-                id = uvc_scan_chain_backward(video, entity);
+                id = uvc_scan_chain_backward(chain, entity);
                 if (id < 0)
                         return id;
         }
 
-        if (video->sterm == NULL) {
-                uvc_trace(UVC_TRACE_DESCR, "No streaming entity found in "
-                        "chain.\n");
-                return -1;
+        return 0;
+}
+
+static unsigned int uvc_print_terms(struct list_head *terms, char *buffer)
+{
+        struct uvc_entity *term;
+        unsigned int nterms = 0;
+        char *p = buffer;
+
+        list_for_each_entry(term, terms, chain) {
+                p += sprintf(p, "%u", term->id);
+                if (term->chain.next != terms) {
+                        p += sprintf(p, ",");
+                        if (++nterms >= 4) {
+                                p += sprintf(p, "...");
+                                break;
+                        }
+                }
         }
 
-        return 0;
+        return p - buffer;
+}
+
+static const char *uvc_print_chain(struct uvc_video_chain *chain)
+{
+        static char buffer[43];
+        char *p = buffer;
+
+        p += uvc_print_terms(&chain->iterms, p);
+        p += sprintf(p, " -> ");
+        uvc_print_terms(&chain->oterms, p);
+
+        return buffer;
 }
 
 /*
- * Register the video devices.
- *
- * The driver currently supports a single video device per control interface
- * only. The terminal and units must match the following structure:
+ * Scan the device for video chains and register video devices.
  *
- * ITT_* -> VC_PROCESSING_UNIT -> VC_EXTENSION_UNIT{0,n} -> TT_STREAMING
- * TT_STREAMING -> VC_PROCESSING_UNIT -> VC_EXTENSION_UNIT{0,n} -> OTT_*
- *
- * The Extension Units, if present, must have a single input pin. The
- * Processing Unit and Extension Units can be in any order. Additional
- * Extension Units connected to the main chain as single-unit branches are
- * also supported.
+ * Chains are scanned starting at their output terminals and walked backwards.
  */
-static int uvc_register_video(struct uvc_device *dev)
+static int uvc_scan_device(struct uvc_device *dev)
 {
-        struct video_device *vdev;
+        struct uvc_video_chain *chain;
         struct uvc_entity *term;
-        int found = 0, ret;
 
-        /* Check if the control interface matches the structure we expect. */
         list_for_each_entry(term, &dev->entities, list) {
-                struct uvc_streaming *streaming;
-
-                if (!UVC_ENTITY_IS_TERM(term) || !UVC_ENTITY_IS_OTERM(term))
+                if (!UVC_ENTITY_IS_OTERM(term))
                         continue;
 
-                memset(&dev->video, 0, sizeof dev->video);
-                mutex_init(&dev->video.ctrl_mutex);
-                INIT_LIST_HEAD(&dev->video.iterms);
-                INIT_LIST_HEAD(&dev->video.extensions);
-                dev->video.oterm = term;
-                dev->video.dev = dev;
-                if (uvc_scan_chain(&dev->video) < 0)
+                /* If the terminal is already included in a chain, skip it.
+                 * This can happen for chains that have multiple output
+                 * terminals, where all output terminals beside the first one
+                 * will be inserted in the chain in forward scans.
+                 */
+                if (term->chain.next || term->chain.prev)
                         continue;
 
-                list_for_each_entry(streaming, &dev->streaming, list) {
-                        if (streaming->header.bTerminalLink ==
-                            dev->video.sterm->id) {
-                                dev->video.streaming = streaming;
-                                found = 1;
-                                break;
-                        }
+                chain = kzalloc(sizeof(*chain), GFP_KERNEL);
+                if (chain == NULL)
+                        return -ENOMEM;
+
+                INIT_LIST_HEAD(&chain->iterms);
+                INIT_LIST_HEAD(&chain->oterms);
+                INIT_LIST_HEAD(&chain->extensions);
+                mutex_init(&chain->ctrl_mutex);
+                chain->dev = dev;
+
+                if (uvc_scan_chain(chain, term) < 0) {
+                        kfree(chain);
+                        continue;
                 }
 
-                if (found)
-                        break;
+                uvc_trace(UVC_TRACE_PROBE, "Found a valid video chain (%s).\n",
+                          uvc_print_chain(chain));
+
+                list_add_tail(&chain->list, &dev->chains);
         }
 
-        if (!found) {
+        if (list_empty(&dev->chains)) {
                 uvc_printk(KERN_INFO, "No valid video chain found.\n");
                 return -1;
         }
 
-        if (uvc_trace_param & UVC_TRACE_PROBE) {
-                uvc_printk(KERN_INFO, "Found a valid video chain (");
-                list_for_each_entry(term, &dev->video.iterms, chain) {
-                        printk("%d", term->id);
-                        if (term->chain.next != &dev->video.iterms)
-                                printk(",");
-                }
-                printk(" -> %d).\n", dev->video.oterm->id);
+        return 0;
+}
+
+/* ------------------------------------------------------------------------
+ * Video device registration and unregistration
+ */
+
+/*
+ * Unregister the video devices.
+ */
+static void uvc_unregister_video(struct uvc_device *dev)
+{
+        struct uvc_streaming *stream;
+
+        list_for_each_entry(stream, &dev->streams, list) {
+                if (stream->vdev == NULL)
+                        continue;
+
+                if (stream->vdev->minor == -1)
+                        video_device_release(stream->vdev);
+                else
+                        video_unregister_device(stream->vdev);
+                stream->vdev = NULL;
         }
+}
 
-        /* Initialize the video buffers queue. */
-        uvc_queue_init(&dev->video.queue, dev->video.streaming->type);
+static int uvc_register_video(struct uvc_device *dev,
+                struct uvc_streaming *stream)
+{
+        struct video_device *vdev;
+        int ret;
 
         /* Initialize the streaming interface with default streaming
          * parameters.
          */
-        if ((ret = uvc_video_init(&dev->video)) < 0) {
+        ret = uvc_video_init(stream);
+        if (ret < 0) {
                 uvc_printk(KERN_ERR, "Failed to initialize the device "
                         "(%d).\n", ret);
                 return ret;
@@ -1495,8 +1567,11 @@ static int uvc_register_video(struct uvc_device *dev)
 
         /* Register the device with V4L. */
         vdev = video_device_alloc();
-        if (vdev == NULL)
-                return -1;
+        if (vdev == NULL) {
+                uvc_printk(KERN_ERR, "Failed to allocate video device (%d).\n",
+                           ret);
+                return -ENOMEM;
+        }
 
         /* We already hold a reference to dev->udev. The video device will be
          * unregistered before the reference is released, so we don't need to
@@ -1511,19 +1586,74 @@ static int uvc_register_video(struct uvc_device *dev)
         /* Set the driver data before calling video_register_device, otherwise
          * uvc_v4l2_open might race us.
          */
-        dev->video.vdev = vdev;
-        video_set_drvdata(vdev, &dev->video);
-
-        if (video_register_device(vdev, VFL_TYPE_GRABBER, -1) < 0) {
-                dev->video.vdev = NULL;
+        stream->vdev = vdev;
+        video_set_drvdata(vdev, stream);
+
+        ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
+        if (ret < 0) {
+                uvc_printk(KERN_ERR, "Failed to register video device (%d).\n",
+                           ret);
+                stream->vdev = NULL;
                 video_device_release(vdev);
-                return -1;
+                return ret;
         }
 
         return 0;
 }
 
 /*
+ * Register all video devices in all chains.
+ */
+static int uvc_register_terms(struct uvc_device *dev,
+        struct uvc_video_chain *chain, struct list_head *terms)
+{
+        struct uvc_streaming *stream;
+        struct uvc_entity *term;
+        int ret;
+
+        list_for_each_entry(term, terms, chain) {
+                if (UVC_ENTITY_TYPE(term) != UVC_TT_STREAMING)
+                        continue;
+
+                stream = uvc_stream_by_id(dev, term->id);
+                if (stream == NULL) {
+                        uvc_printk(KERN_INFO, "No streaming interface found "
+                                   "for terminal %u.", term->id);
+                        continue;
+                }
+
+                stream->chain = chain;
+                ret = uvc_register_video(dev, stream);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static int uvc_register_chains(struct uvc_device *dev)
+{
+        struct uvc_video_chain *chain;
+        int ret;
+
+        list_for_each_entry(chain, &dev->chains, list) {
+                ret = uvc_register_terms(dev, chain, &chain->iterms);
+                if (ret < 0)
+                        return ret;
+
+                ret = uvc_register_terms(dev, chain, &chain->oterms);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+/* ------------------------------------------------------------------------
+ * USB probe, disconnect, suspend and resume
+ */
+
+/*
  * Delete the UVC device.
  *
  * Called by the kernel when the last reference to the uvc_device structure
@@ -1544,7 +1674,7 @@ void uvc_delete(struct kref *kref)
         struct uvc_device *dev = container_of(kref, struct uvc_device, kref);
         struct list_head *p, *n;
 
-        /* Unregister the video device. */
+        /* Unregister the video devices. */
         uvc_unregister_video(dev);
         usb_put_intf(dev->intf);
         usb_put_dev(dev->udev);
@@ -1552,13 +1682,19 @@ void uvc_delete(struct kref *kref)
         uvc_status_cleanup(dev);
         uvc_ctrl_cleanup_device(dev);
 
+        list_for_each_safe(p, n, &dev->chains) {
+                struct uvc_video_chain *chain;
+                chain = list_entry(p, struct uvc_video_chain, list);
+                kfree(chain);
+        }
+
         list_for_each_safe(p, n, &dev->entities) {
                 struct uvc_entity *entity;
                 entity = list_entry(p, struct uvc_entity, list);
                 kfree(entity);
         }
 
-        list_for_each_safe(p, n, &dev->streaming) {
+        list_for_each_safe(p, n, &dev->streams) {
                 struct uvc_streaming *streaming;
                 streaming = list_entry(p, struct uvc_streaming, list);
                 usb_driver_release_interface(&uvc_driver.driver,
@@ -1592,7 +1728,8 @@ static int uvc_probe(struct usb_interface *intf,
                 return -ENOMEM;
 
         INIT_LIST_HEAD(&dev->entities);
-        INIT_LIST_HEAD(&dev->streaming);
+        INIT_LIST_HEAD(&dev->chains);
+        INIT_LIST_HEAD(&dev->streams);
         kref_init(&dev->kref);
         atomic_set(&dev->users, 0);
 
@@ -1633,8 +1770,12 @@ static int uvc_probe(struct usb_interface *intf,
         if (uvc_ctrl_init_device(dev) < 0)
                 goto error;
 
-        /* Register the video devices. */
-        if (uvc_register_video(dev) < 0)
+        /* Scan the device for video chains. */
+        if (uvc_scan_device(dev) < 0)
+                goto error;
+
+        /* Register video devices. */
+        if (uvc_register_chains(dev) < 0)
                 goto error;
 
         /* Save our data pointer in the interface data. */
@@ -1664,7 +1805,8 @@ static void uvc_disconnect(struct usb_interface *intf)
          */
         usb_set_intfdata(intf, NULL);
 
-        if (intf->cur_altsetting->desc.bInterfaceSubClass == SC_VIDEOSTREAMING)
+        if (intf->cur_altsetting->desc.bInterfaceSubClass ==
+            UVC_SC_VIDEOSTREAMING)
                 return;
 
         /* uvc_v4l2_open() might race uvc_disconnect(). A static driver-wide
@@ -1687,31 +1829,36 @@ static void uvc_disconnect(struct usb_interface *intf)
 static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
 {
         struct uvc_device *dev = usb_get_intfdata(intf);
+        struct uvc_streaming *stream;
 
         uvc_trace(UVC_TRACE_SUSPEND, "Suspending interface %u\n",
                 intf->cur_altsetting->desc.bInterfaceNumber);
 
         /* Controls are cached on the fly so they don't need to be saved. */
-        if (intf->cur_altsetting->desc.bInterfaceSubClass == SC_VIDEOCONTROL)
+        if (intf->cur_altsetting->desc.bInterfaceSubClass ==
+            UVC_SC_VIDEOCONTROL)
                 return uvc_status_suspend(dev);
 
-        if (dev->video.streaming->intf != intf) {
-                uvc_trace(UVC_TRACE_SUSPEND, "Suspend: video streaming USB "
-                                "interface mismatch.\n");
-                return -EINVAL;
+        list_for_each_entry(stream, &dev->streams, list) {
+                if (stream->intf == intf)
+                        return uvc_video_suspend(stream);
         }
 
-        return uvc_video_suspend(&dev->video);
+        uvc_trace(UVC_TRACE_SUSPEND, "Suspend: video streaming USB interface "
+                        "mismatch.\n");
+        return -EINVAL;
 }
 
 static int __uvc_resume(struct usb_interface *intf, int reset)
 {
         struct uvc_device *dev = usb_get_intfdata(intf);
+        struct uvc_streaming *stream;
 
         uvc_trace(UVC_TRACE_SUSPEND, "Resuming interface %u\n",
                 intf->cur_altsetting->desc.bInterfaceNumber);
 
-        if (intf->cur_altsetting->desc.bInterfaceSubClass == SC_VIDEOCONTROL) {
+        if (intf->cur_altsetting->desc.bInterfaceSubClass ==
+            UVC_SC_VIDEOCONTROL) {
                 if (reset) {
                         int ret = uvc_ctrl_resume_device(dev);
 
@@ -1722,13 +1869,14 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
                 return uvc_status_resume(dev);
         }
 
-        if (dev->video.streaming->intf != intf) {
-                uvc_trace(UVC_TRACE_SUSPEND, "Resume: video streaming USB "
-                                "interface mismatch.\n");
-                return -EINVAL;
+        list_for_each_entry(stream, &dev->streams, list) {
+                if (stream->intf == intf)
+                        return uvc_video_resume(stream);
         }
 
-        return uvc_video_resume(&dev->video);
+        uvc_trace(UVC_TRACE_SUSPEND, "Resume: video streaming USB interface "
+                        "mismatch.\n");
+        return -EINVAL;
 }
 
 static int uvc_resume(struct usb_interface *intf)
@@ -1880,7 +2028,8 @@ static struct usb_device_id uvc_ids[] = {
           .bInterfaceClass      = USB_CLASS_VIDEO,
           .bInterfaceSubClass   = 1,
           .bInterfaceProtocol   = 0,
-          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX
+                                | UVC_QUIRK_PROBE_DEF },
         /* Syntek (HP Spartan) */
         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
                                 | USB_DEVICE_ID_MATCH_INT_INFO,
@@ -1943,7 +2092,8 @@ static struct usb_device_id uvc_ids[] = {
           .bInterfaceClass      = USB_CLASS_VIDEO,
           .bInterfaceSubClass   = 1,
           .bInterfaceProtocol   = 0,
-          .driver_info          = UVC_QUIRK_PROBE_EXTRAFIELDS },
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX
+                                | UVC_QUIRK_PROBE_EXTRAFIELDS },
         /* Ecamm Pico iMage */
         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
                                 | USB_DEVICE_ID_MATCH_INT_INFO,
diff --git a/drivers/media/video/uvc/uvc_isight.c b/drivers/media/video/uvc/uvc_isight.c
index 436f462685a0..a9285b570dbe 100644
--- a/drivers/media/video/uvc/uvc_isight.c
+++ b/drivers/media/video/uvc/uvc_isight.c
@@ -99,7 +99,7 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
         return 0;
 }
 
-void uvc_video_decode_isight(struct urb *urb, struct uvc_video_device *video,
+void uvc_video_decode_isight(struct urb *urb, struct uvc_streaming *stream,
                 struct uvc_buffer *buf)
 {
         int ret, i;
@@ -120,7 +120,7 @@ void uvc_video_decode_isight(struct urb *urb, struct uvc_video_device *video,
                  * processes the data of the first payload of the new frame.
                  */
                 do {
-                        ret = isight_decode(&video->queue, buf,
+                        ret = isight_decode(&stream->queue, buf,
                                         urb->transfer_buffer +
                                         urb->iso_frame_desc[i].offset,
                                         urb->iso_frame_desc[i].actual_length);
@@ -130,7 +130,8 @@ void uvc_video_decode_isight(struct urb *urb, struct uvc_video_device *video,
 
                         if (buf->state == UVC_BUF_STATE_DONE ||
                             buf->state == UVC_BUF_STATE_ERROR)
-                                buf = uvc_queue_next_buffer(&video->queue, buf);
+                                buf = uvc_queue_next_buffer(&stream->queue,
+                                                        buf);
                 } while (ret == -EAGAIN);
         }
 }
diff --git a/drivers/media/video/uvc/uvc_v4l2.c b/drivers/media/video/uvc/uvc_v4l2.c
index 5e77cad29690..9e7351569b5d 100644
--- a/drivers/media/video/uvc/uvc_v4l2.c
+++ b/drivers/media/video/uvc/uvc_v4l2.c
@@ -40,7 +40,7 @@
  * table for the controls that can be mapped directly, and handle the others
  * manually.
  */
-static int uvc_v4l2_query_menu(struct uvc_video_device *video,
+static int uvc_v4l2_query_menu(struct uvc_video_chain *chain,
         struct v4l2_querymenu *query_menu)
 {
         struct uvc_menu_info *menu_info;
@@ -49,7 +49,7 @@ static int uvc_v4l2_query_menu(struct uvc_video_device *video,
         u32 index = query_menu->index;
         u32 id = query_menu->id;
 
-        ctrl = uvc_find_control(video, query_menu->id, &mapping);
+        ctrl = uvc_find_control(chain, query_menu->id, &mapping);
         if (ctrl == NULL || mapping->v4l2_type != V4L2_CTRL_TYPE_MENU)
                 return -EINVAL;
 
@@ -103,7 +103,7 @@ static __u32 uvc_try_frame_interval(struct uvc_frame *frame, __u32 interval)
         return interval;
 }
 
-static int uvc_v4l2_try_format(struct uvc_video_device *video,
+static int uvc_v4l2_try_format(struct uvc_streaming *stream,
         struct v4l2_format *fmt, struct uvc_streaming_control *probe,
         struct uvc_format **uvc_format, struct uvc_frame **uvc_frame)
 {
@@ -116,7 +116,7 @@ static int uvc_v4l2_try_format(struct uvc_video_device *video,
         int ret = 0;
         __u8 *fcc;
 
-        if (fmt->type != video->streaming->type)
+        if (fmt->type != stream->type)
                 return -EINVAL;
 
         fcc = (__u8 *)&fmt->fmt.pix.pixelformat;
@@ -126,8 +126,8 @@ static int uvc_v4l2_try_format(struct uvc_video_device *video,
                         fmt->fmt.pix.width, fmt->fmt.pix.height);
 
         /* Check if the hardware supports the requested format. */
-        for (i = 0; i < video->streaming->nformats; ++i) {
-                format = &video->streaming->format[i];
+        for (i = 0; i < stream->nformats; ++i) {
+                format = &stream->format[i];
                 if (format->fcc == fmt->fmt.pix.pixelformat)
                         break;
         }
@@ -191,12 +191,13 @@ static int uvc_v4l2_try_format(struct uvc_video_device *video,
          * developers test their webcams with the Linux driver as well as with
          * the Windows driver).
          */
-        if (video->dev->quirks & UVC_QUIRK_PROBE_EXTRAFIELDS)
+        if (stream->dev->quirks & UVC_QUIRK_PROBE_EXTRAFIELDS)
                 probe->dwMaxVideoFrameSize =
-                        video->streaming->ctrl.dwMaxVideoFrameSize;
+                        stream->ctrl.dwMaxVideoFrameSize;
 
         /* Probe the device. */
-        if ((ret = uvc_probe_video(video, probe)) < 0)
+        ret = uvc_probe_video(stream, probe);
+        if (ret < 0)
                 goto done;
 
         fmt->fmt.pix.width = frame->wWidth;
@@ -216,13 +217,13 @@ done:
         return ret;
 }
 
-static int uvc_v4l2_get_format(struct uvc_video_device *video,
+static int uvc_v4l2_get_format(struct uvc_streaming *stream,
         struct v4l2_format *fmt)
 {
-        struct uvc_format *format = video->streaming->cur_format;
-        struct uvc_frame *frame = video->streaming->cur_frame;
+        struct uvc_format *format = stream->cur_format;
+        struct uvc_frame *frame = stream->cur_frame;
 
-        if (fmt->type != video->streaming->type)
+        if (fmt->type != stream->type)
                 return -EINVAL;
 
         if (format == NULL || frame == NULL)
@@ -233,14 +234,14 @@ static int uvc_v4l2_get_format(struct uvc_video_device *video,
         fmt->fmt.pix.height = frame->wHeight;
         fmt->fmt.pix.field = V4L2_FIELD_NONE;
         fmt->fmt.pix.bytesperline = format->bpp * frame->wWidth / 8;
-        fmt->fmt.pix.sizeimage = video->streaming->ctrl.dwMaxVideoFrameSize;
+        fmt->fmt.pix.sizeimage = stream->ctrl.dwMaxVideoFrameSize;
         fmt->fmt.pix.colorspace = format->colorspace;
         fmt->fmt.pix.priv = 0;
 
         return 0;
 }
 
-static int uvc_v4l2_set_format(struct uvc_video_device *video,
+static int uvc_v4l2_set_format(struct uvc_streaming *stream,
         struct v4l2_format *fmt)
 {
         struct uvc_streaming_control probe;
@@ -248,39 +249,39 @@ static int uvc_v4l2_set_format(struct uvc_video_device *video,
         struct uvc_frame *frame;
         int ret;
 
-        if (fmt->type != video->streaming->type)
+        if (fmt->type != stream->type)
                 return -EINVAL;
 
-        if (uvc_queue_allocated(&video->queue))
+        if (uvc_queue_allocated(&stream->queue))
                 return -EBUSY;
 
-        ret = uvc_v4l2_try_format(video, fmt, &probe, &format, &frame);
+        ret = uvc_v4l2_try_format(stream, fmt, &probe, &format, &frame);
         if (ret < 0)
                 return ret;
 
-        memcpy(&video->streaming->ctrl, &probe, sizeof probe);
-        video->streaming->cur_format = format;
-        video->streaming->cur_frame = frame;
+        memcpy(&stream->ctrl, &probe, sizeof probe);
+        stream->cur_format = format;
+        stream->cur_frame = frame;
 
         return 0;
 }
 
-static int uvc_v4l2_get_streamparm(struct uvc_video_device *video,
+static int uvc_v4l2_get_streamparm(struct uvc_streaming *stream,
                 struct v4l2_streamparm *parm)
 {
         uint32_t numerator, denominator;
 
-        if (parm->type != video->streaming->type)
+        if (parm->type != stream->type)
                 return -EINVAL;
 
-        numerator = video->streaming->ctrl.dwFrameInterval;
+        numerator = stream->ctrl.dwFrameInterval;
         denominator = 10000000;
         uvc_simplify_fraction(&numerator, &denominator, 8, 333);
 
         memset(parm, 0, sizeof *parm);
-        parm->type = video->streaming->type;
+        parm->type = stream->type;
 
-        if (video->streaming->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+        if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
                 parm->parm.capture.capturemode = 0;
                 parm->parm.capture.timeperframe.numerator = numerator;
@@ -297,19 +298,19 @@ static int uvc_v4l2_get_streamparm(struct uvc_video_device *video,
         return 0;
 }
 
-static int uvc_v4l2_set_streamparm(struct uvc_video_device *video,
+static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
                 struct v4l2_streamparm *parm)
 {
-        struct uvc_frame *frame = video->streaming->cur_frame;
+        struct uvc_frame *frame = stream->cur_frame;
         struct uvc_streaming_control probe;
         struct v4l2_fract timeperframe;
         uint32_t interval;
         int ret;
 
-        if (parm->type != video->streaming->type)
+        if (parm->type != stream->type)
                 return -EINVAL;
 
-        if (uvc_queue_streaming(&video->queue))
+        if (uvc_queue_streaming(&stream->queue))
                 return -EBUSY;
 
         if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
@@ -317,7 +318,7 @@ static int uvc_v4l2_set_streamparm(struct uvc_video_device *video,
         else
                 timeperframe = parm->parm.output.timeperframe;
 
-        memcpy(&probe, &video->streaming->ctrl, sizeof probe);
+        memcpy(&probe, &stream->ctrl, sizeof probe);
         interval = uvc_fraction_to_interval(timeperframe.numerator,
                 timeperframe.denominator);
 
@@ -326,10 +327,11 @@ static int uvc_v4l2_set_streamparm(struct uvc_video_device *video,
         probe.dwFrameInterval = uvc_try_frame_interval(frame, interval);
 
         /* Probe the device with the new settings. */
-        if ((ret = uvc_probe_video(video, &probe)) < 0)
+        ret = uvc_probe_video(stream, &probe);
+        if (ret < 0)
                 return ret;
 
-        memcpy(&video->streaming->ctrl, &probe, sizeof probe);
+        memcpy(&stream->ctrl, &probe, sizeof probe);
 
         /* Return the actual frame period. */
         timeperframe.numerator = probe.dwFrameInterval;
@@ -382,8 +384,8 @@ static int uvc_acquire_privileges(struct uvc_fh *handle)
 
         /* Check if the device already has a privileged handle. */
         mutex_lock(&uvc_driver.open_mutex);
-        if (atomic_inc_return(&handle->device->active) != 1) {
-                atomic_dec(&handle->device->active);
+        if (atomic_inc_return(&handle->stream->active) != 1) {
+                atomic_dec(&handle->stream->active);
                 ret = -EBUSY;
                 goto done;
         }
@@ -398,7 +400,7 @@ done:
 static void uvc_dismiss_privileges(struct uvc_fh *handle)
 {
         if (handle->state == UVC_HANDLE_ACTIVE)
-                atomic_dec(&handle->device->active);
+                atomic_dec(&handle->stream->active);
 
         handle->state = UVC_HANDLE_PASSIVE;
 }
@@ -414,45 +416,47 @@ static int uvc_has_privileges(struct uvc_fh *handle)
 
 static int uvc_v4l2_open(struct file *file)
 {
-        struct uvc_video_device *video;
+        struct uvc_streaming *stream;
         struct uvc_fh *handle;
         int ret = 0;
 
         uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_open\n");
         mutex_lock(&uvc_driver.open_mutex);
-        video = video_drvdata(file);
+        stream = video_drvdata(file);
 
-        if (video->dev->state & UVC_DEV_DISCONNECTED) {
+        if (stream->dev->state & UVC_DEV_DISCONNECTED) {
                 ret = -ENODEV;
                 goto done;
         }
 
-        ret = usb_autopm_get_interface(video->dev->intf);
+        ret = usb_autopm_get_interface(stream->dev->intf);
         if (ret < 0)
                 goto done;
 
         /* Create the device handle. */
         handle = kzalloc(sizeof *handle, GFP_KERNEL);
         if (handle == NULL) {
-                usb_autopm_put_interface(video->dev->intf);
+                usb_autopm_put_interface(stream->dev->intf);
                 ret = -ENOMEM;
                 goto done;
         }
 
-        if (atomic_inc_return(&video->dev->users) == 1) {
-                if ((ret = uvc_status_start(video->dev)) < 0) {
-                        usb_autopm_put_interface(video->dev->intf);
-                        atomic_dec(&video->dev->users);
+        if (atomic_inc_return(&stream->dev->users) == 1) {
+                ret = uvc_status_start(stream->dev);
+                if (ret < 0) {
+                        usb_autopm_put_interface(stream->dev->intf);
+                        atomic_dec(&stream->dev->users);
                         kfree(handle);
                         goto done;
                 }
         }
 
-        handle->device = video;
+        handle->chain = stream->chain;
+        handle->stream = stream;
         handle->state = UVC_HANDLE_PASSIVE;
         file->private_data = handle;
 
-        kref_get(&video->dev->kref);
+        kref_get(&stream->dev->kref);
 
 done:
         mutex_unlock(&uvc_driver.open_mutex);
@@ -461,20 +465,20 @@ done:
 
 static int uvc_v4l2_release(struct file *file)
 {
-        struct uvc_video_device *video = video_drvdata(file);
         struct uvc_fh *handle = (struct uvc_fh *)file->private_data;
+        struct uvc_streaming *stream = handle->stream;
 
         uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_release\n");
 
         /* Only free resources if this is a privileged handle. */
         if (uvc_has_privileges(handle)) {
-                uvc_video_enable(video, 0);
+                uvc_video_enable(stream, 0);
 
-                mutex_lock(&video->queue.mutex);
-                if (uvc_free_buffers(&video->queue) < 0)
+                mutex_lock(&stream->queue.mutex);
+                if (uvc_free_buffers(&stream->queue) < 0)
                         uvc_printk(KERN_ERR, "uvc_v4l2_release: Unable to "
                                         "free buffers.\n");
-                mutex_unlock(&video->queue.mutex);
+                mutex_unlock(&stream->queue.mutex);
         }
 
         /* Release the file handle. */
@@ -482,19 +486,20 @@ static int uvc_v4l2_release(struct file *file)
         kfree(handle);
         file->private_data = NULL;
 
-        if (atomic_dec_return(&video->dev->users) == 0)
-                uvc_status_stop(video->dev);
+        if (atomic_dec_return(&stream->dev->users) == 0)
+                uvc_status_stop(stream->dev);
 
-        usb_autopm_put_interface(video->dev->intf);
-        kref_put(&video->dev->kref, uvc_delete);
+        usb_autopm_put_interface(stream->dev->intf);
+        kref_put(&stream->dev->kref, uvc_delete);
         return 0;
 }
 
 static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *vdev = video_devdata(file);
-        struct uvc_video_device *video = video_get_drvdata(vdev);
         struct uvc_fh *handle = (struct uvc_fh *)file->private_data;
+        struct uvc_video_chain *chain = handle->chain;
+        struct uvc_streaming *stream = handle->stream;
         long ret = 0;
 
         switch (cmd) {
@@ -506,10 +511,10 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 memset(cap, 0, sizeof *cap);
                 strlcpy(cap->driver, "uvcvideo", sizeof cap->driver);
                 strlcpy(cap->card, vdev->name, sizeof cap->card);
-                usb_make_path(video->dev->udev,
+                usb_make_path(stream->dev->udev,
                               cap->bus_info, sizeof(cap->bus_info));
                 cap->version = DRIVER_VERSION_NUMBER;
-                if (video->streaming->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
                         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE
                                           | V4L2_CAP_STREAMING;
                 else
@@ -520,7 +525,7 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 
         /* Get, Set & Query control */
         case VIDIOC_QUERYCTRL:
-                return uvc_query_v4l2_ctrl(video, arg);
+                return uvc_query_v4l2_ctrl(chain, arg);
 
         case VIDIOC_G_CTRL:
         {
@@ -530,12 +535,12 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 memset(&xctrl, 0, sizeof xctrl);
                 xctrl.id = ctrl->id;
 
-               ret = uvc_ctrl_begin(video);
-               if (ret < 0)
+                ret = uvc_ctrl_begin(chain);
+                if (ret < 0)
                         return ret;
 
-                ret = uvc_ctrl_get(video, &xctrl);
-                uvc_ctrl_rollback(video);
+                ret = uvc_ctrl_get(chain, &xctrl);
+                uvc_ctrl_rollback(chain);
                 if (ret >= 0)
                         ctrl->value = xctrl.value;
                 break;
@@ -550,21 +555,21 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 xctrl.id = ctrl->id;
                 xctrl.value = ctrl->value;
 
-               ret = uvc_ctrl_begin(video);
-               if (ret < 0)
+                uvc_ctrl_begin(chain);
+                if (ret < 0)
                         return ret;
 
-                ret = uvc_ctrl_set(video, &xctrl);
+                ret = uvc_ctrl_set(chain, &xctrl);
                 if (ret < 0) {
-                        uvc_ctrl_rollback(video);
+                        uvc_ctrl_rollback(chain);
                         return ret;
                 }
-                ret = uvc_ctrl_commit(video);
+                ret = uvc_ctrl_commit(chain);
                 break;
         }
 
         case VIDIOC_QUERYMENU:
-                return uvc_v4l2_query_menu(video, arg);
+                return uvc_v4l2_query_menu(chain, arg);
 
         case VIDIOC_G_EXT_CTRLS:
         {
@@ -572,20 +577,20 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 struct v4l2_ext_control *ctrl = ctrls->controls;
                 unsigned int i;
 
-               ret = uvc_ctrl_begin(video);
-               if (ret < 0)
+                ret = uvc_ctrl_begin(chain);
+                if (ret < 0)
                         return ret;
 
                 for (i = 0; i < ctrls->count; ++ctrl, ++i) {
-                        ret = uvc_ctrl_get(video, ctrl);
+                        ret = uvc_ctrl_get(chain, ctrl);
                         if (ret < 0) {
-                                uvc_ctrl_rollback(video);
+                                uvc_ctrl_rollback(chain);
                                 ctrls->error_idx = i;
                                 return ret;
                         }
                 }
                 ctrls->error_idx = 0;
-                ret = uvc_ctrl_rollback(video);
+                ret = uvc_ctrl_rollback(chain);
                 break;
         }
 
@@ -596,14 +601,14 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 struct v4l2_ext_control *ctrl = ctrls->controls;
                 unsigned int i;
 
-                ret = uvc_ctrl_begin(video);
+                ret = uvc_ctrl_begin(chain);
                 if (ret < 0)
                         return ret;
 
                 for (i = 0; i < ctrls->count; ++ctrl, ++i) {
-                        ret = uvc_ctrl_set(video, ctrl);
+                        ret = uvc_ctrl_set(chain, ctrl);
                         if (ret < 0) {
-                                uvc_ctrl_rollback(video);
+                                uvc_ctrl_rollback(chain);
                                 ctrls->error_idx = i;
                                 return ret;
                         }
@@ -612,31 +617,31 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 ctrls->error_idx = 0;
 
                 if (cmd == VIDIOC_S_EXT_CTRLS)
-                        ret = uvc_ctrl_commit(video);
+                        ret = uvc_ctrl_commit(chain);
                 else
-                        ret = uvc_ctrl_rollback(video);
+                        ret = uvc_ctrl_rollback(chain);
                 break;
         }
 
         /* Get, Set & Enum input */
         case VIDIOC_ENUMINPUT:
         {
-                const struct uvc_entity *selector = video->selector;
+                const struct uvc_entity *selector = chain->selector;
                 struct v4l2_input *input = arg;
                 struct uvc_entity *iterm = NULL;
                 u32 index = input->index;
                 int pin = 0;
 
                 if (selector == NULL ||
-                    (video->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
+                    (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
                         if (index != 0)
                                 return -EINVAL;
-                        iterm = list_first_entry(&video->iterms,
+                        iterm = list_first_entry(&chain->iterms,
                                         struct uvc_entity, chain);
                         pin = iterm->id;
                 } else if (pin < selector->selector.bNrInPins) {
                         pin = selector->selector.baSourceID[index];
-                        list_for_each_entry(iterm, video->iterms.next, chain) {
+                        list_for_each_entry(iterm, chain->iterms.next, chain) {
                                 if (iterm->id == pin)
                                         break;
                         }
@@ -648,7 +653,7 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 memset(input, 0, sizeof *input);
                 input->index = index;
                 strlcpy(input->name, iterm->name, sizeof input->name);
-                if (UVC_ENTITY_TYPE(iterm) == ITT_CAMERA)
+                if (UVC_ENTITY_TYPE(iterm) == UVC_ITT_CAMERA)
                         input->type = V4L2_INPUT_TYPE_CAMERA;
                 break;
         }
@@ -657,15 +662,15 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         {
                 u8 input;
 
-                if (video->selector == NULL ||
-                    (video->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
+                if (chain->selector == NULL ||
+                    (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
                         *(int *)arg = 0;
                         break;
                 }
 
-                ret = uvc_query_ctrl(video->dev, GET_CUR, video->selector->id,
-                        video->dev->intfnum, SU_INPUT_SELECT_CONTROL,
-                        &input, 1);
+                ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR,
+                        chain->selector->id, chain->dev->intfnum,
+                        UVC_SU_INPUT_SELECT_CONTROL, &input, 1);
                 if (ret < 0)
                         return ret;
 
@@ -680,19 +685,19 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 if ((ret = uvc_acquire_privileges(handle)) < 0)
                         return ret;
 
-                if (video->selector == NULL ||
-                    (video->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
+                if (chain->selector == NULL ||
+                    (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
                         if (input != 1)
                                 return -EINVAL;
                         break;
                 }
 
-                if (input == 0 || input > video->selector->selector.bNrInPins)
+                if (input == 0 || input > chain->selector->selector.bNrInPins)
                         return -EINVAL;
 
-                return uvc_query_ctrl(video->dev, SET_CUR, video->selector->id,
-                        video->dev->intfnum, SU_INPUT_SELECT_CONTROL,
-                        &input, 1);
+                return uvc_query_ctrl(chain->dev, UVC_SET_CUR,
+                        chain->selector->id, chain->dev->intfnum,
+                        UVC_SU_INPUT_SELECT_CONTROL, &input, 1);
         }
 
         /* Try, Get, Set & Enum format */
@@ -703,15 +708,15 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 enum v4l2_buf_type type = fmt->type;
                 __u32 index = fmt->index;
 
-                if (fmt->type != video->streaming->type ||
-                    fmt->index >= video->streaming->nformats)
+                if (fmt->type != stream->type ||
+                    fmt->index >= stream->nformats)
                         return -EINVAL;
 
                 memset(fmt, 0, sizeof(*fmt));
                 fmt->index = index;
                 fmt->type = type;
 
-                format = &video->streaming->format[fmt->index];
+                format = &stream->format[fmt->index];
                 fmt->flags = 0;
                 if (format->flags & UVC_FMT_FLAG_COMPRESSED)
                         fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
@@ -729,17 +734,17 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 if ((ret = uvc_acquire_privileges(handle)) < 0)
                         return ret;
 
-                return uvc_v4l2_try_format(video, arg, &probe, NULL, NULL);
+                return uvc_v4l2_try_format(stream, arg, &probe, NULL, NULL);
         }
 
         case VIDIOC_S_FMT:
                 if ((ret = uvc_acquire_privileges(handle)) < 0)
                         return ret;
 
-                return uvc_v4l2_set_format(video, arg);
+                return uvc_v4l2_set_format(stream, arg);
 
         case VIDIOC_G_FMT:
-                return uvc_v4l2_get_format(video, arg);
+                return uvc_v4l2_get_format(stream, arg);
 
         /* Frame size enumeration */
         case VIDIOC_ENUM_FRAMESIZES:
@@ -750,10 +755,10 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 int i;
 
                 /* Look for the given pixel format */
-                for (i = 0; i < video->streaming->nformats; i++) {
-                        if (video->streaming->format[i].fcc ==
+                for (i = 0; i < stream->nformats; i++) {
+                        if (stream->format[i].fcc ==
                                         fsize->pixel_format) {
-                                format = &video->streaming->format[i];
+                                format = &stream->format[i];
                                 break;
                         }
                 }
@@ -779,10 +784,10 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 int i;
 
                 /* Look for the given pixel format and frame size */
-                for (i = 0; i < video->streaming->nformats; i++) {
-                        if (video->streaming->format[i].fcc ==
+                for (i = 0; i < stream->nformats; i++) {
+                        if (stream->format[i].fcc ==
                                         fival->pixel_format) {
-                                format = &video->streaming->format[i];
+                                format = &stream->format[i];
                                 break;
                         }
                 }
@@ -832,21 +837,21 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 
         /* Get & Set streaming parameters */
         case VIDIOC_G_PARM:
-                return uvc_v4l2_get_streamparm(video, arg);
+                return uvc_v4l2_get_streamparm(stream, arg);
 
         case VIDIOC_S_PARM:
                 if ((ret = uvc_acquire_privileges(handle)) < 0)
                         return ret;
 
-                return uvc_v4l2_set_streamparm(video, arg);
+                return uvc_v4l2_set_streamparm(stream, arg);
 
         /* Cropping and scaling */
         case VIDIOC_CROPCAP:
         {
                 struct v4l2_cropcap *ccap = arg;
-                struct uvc_frame *frame = video->streaming->cur_frame;
+                struct uvc_frame *frame = stream->cur_frame;
 
-                if (ccap->type != video->streaming->type)
+                if (ccap->type != stream->type)
                         return -EINVAL;
 
                 ccap->bounds.left = 0;
@@ -870,16 +875,16 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         {
                 struct v4l2_requestbuffers *rb = arg;
                 unsigned int bufsize =
-                        video->streaming->ctrl.dwMaxVideoFrameSize;
+                        stream->ctrl.dwMaxVideoFrameSize;
 
-                if (rb->type != video->streaming->type ||
+                if (rb->type != stream->type ||
                     rb->memory != V4L2_MEMORY_MMAP)
                         return -EINVAL;
 
                 if ((ret = uvc_acquire_privileges(handle)) < 0)
                         return ret;
 
-                ret = uvc_alloc_buffers(&video->queue, rb->count, bufsize);
+                ret = uvc_alloc_buffers(&stream->queue, rb->count, bufsize);
                 if (ret < 0)
                         return ret;
 
@@ -892,39 +897,40 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         {
                 struct v4l2_buffer *buf = arg;
 
-                if (buf->type != video->streaming->type)
+                if (buf->type != stream->type)
                         return -EINVAL;
 
                 if (!uvc_has_privileges(handle))
                         return -EBUSY;
 
-                return uvc_query_buffer(&video->queue, buf);
+                return uvc_query_buffer(&stream->queue, buf);
         }
 
         case VIDIOC_QBUF:
                 if (!uvc_has_privileges(handle))
                         return -EBUSY;
 
-                return uvc_queue_buffer(&video->queue, arg);
+                return uvc_queue_buffer(&stream->queue, arg);
 
         case VIDIOC_DQBUF:
                 if (!uvc_has_privileges(handle))
                         return -EBUSY;
 
-                return uvc_dequeue_buffer(&video->queue, arg,
+                return uvc_dequeue_buffer(&stream->queue, arg,
                         file->f_flags & O_NONBLOCK);
 
         case VIDIOC_STREAMON:
         {
                 int *type = arg;
 
-                if (*type != video->streaming->type)
+                if (*type != stream->type)
                         return -EINVAL;
 
                 if (!uvc_has_privileges(handle))
                         return -EBUSY;
 
-                if ((ret = uvc_video_enable(video, 1)) < 0)
+                ret = uvc_video_enable(stream, 1);
+                if (ret < 0)
                         return ret;
                 break;
         }
@@ -933,13 +939,13 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         {
                 int *type = arg;
 
-                if (*type != video->streaming->type)
+                if (*type != stream->type)
                         return -EINVAL;
 
                 if (!uvc_has_privileges(handle))
                         return -EBUSY;
 
-                return uvc_video_enable(video, 0);
+                return uvc_video_enable(stream, 0);
         }
 
         /* Analog video standards make no sense for digital cameras. */
@@ -1013,10 +1019,10 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         }
 
         case UVCIOC_CTRL_GET:
-                return uvc_xu_ctrl_query(video, arg, 0);
+                return uvc_xu_ctrl_query(chain, arg, 0);
 
         case UVCIOC_CTRL_SET:
-                return uvc_xu_ctrl_query(video, arg, 1);
+                return uvc_xu_ctrl_query(chain, arg, 1);
 
         default:
                 if ((ret = v4l_compat_translate_ioctl(file, cmd, arg,
@@ -1070,7 +1076,9 @@ static struct vm_operations_struct uvc_vm_ops = {
 
 static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct uvc_video_device *video = video_drvdata(file);
+        struct uvc_fh *handle = (struct uvc_fh *)file->private_data;
+        struct uvc_streaming *stream = handle->stream;
+        struct uvc_video_queue *queue = &stream->queue;
         struct uvc_buffer *uninitialized_var(buffer);
         struct page *page;
         unsigned long addr, start, size;
@@ -1082,15 +1090,15 @@ static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
         start = vma->vm_start;
         size = vma->vm_end - vma->vm_start;
 
-        mutex_lock(&video->queue.mutex);
+        mutex_lock(&queue->mutex);
 
-        for (i = 0; i < video->queue.count; ++i) {
-                buffer = &video->queue.buffer[i];
+        for (i = 0; i < queue->count; ++i) {
+                buffer = &queue->buffer[i];
                 if ((buffer->buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)
                         break;
         }
 
-        if (i == video->queue.count || size != video->queue.buf_size) {
+        if (i == queue->count || size != queue->buf_size) {
                 ret = -EINVAL;
                 goto done;
         }
@@ -1101,7 +1109,7 @@ static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
          */
         vma->vm_flags |= VM_IO;
 
-        addr = (unsigned long)video->queue.mem + buffer->buf.m.offset;
+        addr = (unsigned long)queue->mem + buffer->buf.m.offset;
         while (size > 0) {
                 page = vmalloc_to_page((void *)addr);
                 if ((ret = vm_insert_page(vma, start, page)) < 0)
@@ -1117,17 +1125,18 @@ static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
         uvc_vm_open(vma);
 
 done:
-        mutex_unlock(&video->queue.mutex);
+        mutex_unlock(&queue->mutex);
         return ret;
 }
 
 static unsigned int uvc_v4l2_poll(struct file *file, poll_table *wait)
 {
-        struct uvc_video_device *video = video_drvdata(file);
+        struct uvc_fh *handle = (struct uvc_fh *)file->private_data;
+        struct uvc_streaming *stream = handle->stream;
 
         uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_poll\n");
 
-        return uvc_queue_poll(&video->queue, file, wait);
+        return uvc_queue_poll(&stream->queue, file, wait);
 }
 
 const struct v4l2_file_operations uvc_fops = {
diff --git a/drivers/media/video/uvc/uvc_video.c b/drivers/media/video/uvc/uvc_video.c
index 01b633c73480..5b757f32d997 100644
--- a/drivers/media/video/uvc/uvc_video.c
+++ b/drivers/media/video/uvc/uvc_video.c
@@ -61,7 +61,7 @@ int uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
         return 0;
 }
 
-static void uvc_fixup_video_ctrl(struct uvc_video_device *video,
+static void uvc_fixup_video_ctrl(struct uvc_streaming *stream,
         struct uvc_streaming_control *ctrl)
 {
         struct uvc_format *format;
@@ -69,10 +69,10 @@ static void uvc_fixup_video_ctrl(struct uvc_video_device *video,
         unsigned int i;
 
         if (ctrl->bFormatIndex <= 0 ||
-            ctrl->bFormatIndex > video->streaming->nformats)
+            ctrl->bFormatIndex > stream->nformats)
                 return;
 
-        format = &video->streaming->format[ctrl->bFormatIndex - 1];
+        format = &stream->format[ctrl->bFormatIndex - 1];
 
         for (i = 0; i < format->nframes; ++i) {
                 if (format->frame[i].bFrameIndex == ctrl->bFrameIndex) {
@@ -86,12 +86,12 @@ static void uvc_fixup_video_ctrl(struct uvc_video_device *video,
 
         if (!(format->flags & UVC_FMT_FLAG_COMPRESSED) ||
              (ctrl->dwMaxVideoFrameSize == 0 &&
-              video->dev->uvc_version < 0x0110))
+              stream->dev->uvc_version < 0x0110))
                 ctrl->dwMaxVideoFrameSize =
                         frame->dwMaxVideoFrameBufferSize;
 
-        if (video->dev->quirks & UVC_QUIRK_FIX_BANDWIDTH &&
-            video->streaming->intf->num_altsetting > 1) {
+        if (stream->dev->quirks & UVC_QUIRK_FIX_BANDWIDTH &&
+            stream->intf->num_altsetting > 1) {
                 u32 interval;
                 u32 bandwidth;
 
@@ -108,7 +108,7 @@ static void uvc_fixup_video_ctrl(struct uvc_video_device *video,
                 bandwidth = frame->wWidth * frame->wHeight / 8 * format->bpp;
                 bandwidth *= 10000000 / interval + 1;
                 bandwidth /= 1000;
-                if (video->dev->udev->speed == USB_SPEED_HIGH)
+                if (stream->dev->udev->speed == USB_SPEED_HIGH)
                         bandwidth /= 8;
                 bandwidth += 12;
 
@@ -116,40 +116,43 @@ static void uvc_fixup_video_ctrl(struct uvc_video_device *video,
         }
 }
 
-static int uvc_get_video_ctrl(struct uvc_video_device *video,
+static int uvc_get_video_ctrl(struct uvc_streaming *stream,
         struct uvc_streaming_control *ctrl, int probe, __u8 query)
 {
         __u8 *data;
         __u16 size;
         int ret;
 
-        size = video->dev->uvc_version >= 0x0110 ? 34 : 26;
+        size = stream->dev->uvc_version >= 0x0110 ? 34 : 26;
         data = kmalloc(size, GFP_KERNEL);
         if (data == NULL)
                 return -ENOMEM;
 
-        ret = __uvc_query_ctrl(video->dev, query, 0, video->streaming->intfnum,
-                probe ? VS_PROBE_CONTROL : VS_COMMIT_CONTROL, data, size,
-                UVC_CTRL_STREAMING_TIMEOUT);
+        if ((stream->dev->quirks & UVC_QUIRK_PROBE_DEF) && query == UVC_GET_DEF)
+                return -EIO;
+
+        ret = __uvc_query_ctrl(stream->dev, query, 0, stream->intfnum,
+                probe ? UVC_VS_PROBE_CONTROL : UVC_VS_COMMIT_CONTROL, data,
+                size, UVC_CTRL_STREAMING_TIMEOUT);
 
-        if ((query == GET_MIN || query == GET_MAX) && ret == 2) {
+        if ((query == UVC_GET_MIN || query == UVC_GET_MAX) && ret == 2) {
                 /* Some cameras, mostly based on Bison Electronics chipsets,
                  * answer a GET_MIN or GET_MAX request with the wCompQuality
                  * field only.
                  */
-                uvc_warn_once(video->dev, UVC_WARN_MINMAX, "UVC non "
+                uvc_warn_once(stream->dev, UVC_WARN_MINMAX, "UVC non "
                         "compliance - GET_MIN/MAX(PROBE) incorrectly "
                         "supported. Enabling workaround.\n");
                 memset(ctrl, 0, sizeof ctrl);
                 ctrl->wCompQuality = le16_to_cpup((__le16 *)data);
                 ret = 0;
                 goto out;
-        } else if (query == GET_DEF && probe == 1 && ret != size) {
+        } else if (query == UVC_GET_DEF && probe == 1 && ret != size) {
                 /* Many cameras don't support the GET_DEF request on their
                  * video probe control. Warn once and return, the caller will
                  * fall back to GET_CUR.
                  */
-                uvc_warn_once(video->dev, UVC_WARN_PROBE_DEF, "UVC non "
+                uvc_warn_once(stream->dev, UVC_WARN_PROBE_DEF, "UVC non "
                         "compliance - GET_DEF(PROBE) not supported. "
                         "Enabling workaround.\n");
                 ret = -EIO;
@@ -181,7 +184,7 @@ static int uvc_get_video_ctrl(struct uvc_video_device *video,
                 ctrl->bMinVersion = data[32];
                 ctrl->bMaxVersion = data[33];
         } else {
-                ctrl->dwClockFrequency = video->dev->clock_frequency;
+                ctrl->dwClockFrequency = stream->dev->clock_frequency;
                 ctrl->bmFramingInfo = 0;
                 ctrl->bPreferedVersion = 0;
                 ctrl->bMinVersion = 0;
@@ -192,7 +195,7 @@ static int uvc_get_video_ctrl(struct uvc_video_device *video,
          * dwMaxPayloadTransferSize fields. Try to get the value from the
          * format and frame descriptors.
          */
-        uvc_fixup_video_ctrl(video, ctrl);
+        uvc_fixup_video_ctrl(stream, ctrl);
         ret = 0;
 
 out:
@@ -200,14 +203,14 @@ out:
         return ret;
 }
 
-static int uvc_set_video_ctrl(struct uvc_video_device *video,
+static int uvc_set_video_ctrl(struct uvc_streaming *stream,
         struct uvc_streaming_control *ctrl, int probe)
 {
         __u8 *data;
         __u16 size;
         int ret;
 
-        size = video->dev->uvc_version >= 0x0110 ? 34 : 26;
+        size = stream->dev->uvc_version >= 0x0110 ? 34 : 26;
         data = kzalloc(size, GFP_KERNEL);
         if (data == NULL)
                 return -ENOMEM;
@@ -232,10 +235,9 @@ static int uvc_set_video_ctrl(struct uvc_video_device *video,
                 data[33] = ctrl->bMaxVersion;
         }
 
-        ret = __uvc_query_ctrl(video->dev, SET_CUR, 0,
-                video->streaming->intfnum,
-                probe ? VS_PROBE_CONTROL : VS_COMMIT_CONTROL, data, size,
-                UVC_CTRL_STREAMING_TIMEOUT);
+        ret = __uvc_query_ctrl(stream->dev, UVC_SET_CUR, 0, stream->intfnum,
+                probe ? UVC_VS_PROBE_CONTROL : UVC_VS_COMMIT_CONTROL, data,
+                size, UVC_CTRL_STREAMING_TIMEOUT);
         if (ret != size) {
                 uvc_printk(KERN_ERR, "Failed to set UVC %s control : "
                         "%d (exp. %u).\n", probe ? "probe" : "commit",
@@ -247,7 +249,7 @@ static int uvc_set_video_ctrl(struct uvc_video_device *video,
         return ret;
 }
 
-int uvc_probe_video(struct uvc_video_device *video,
+int uvc_probe_video(struct uvc_streaming *stream,
         struct uvc_streaming_control *probe)
 {
         struct uvc_streaming_control probe_min, probe_max;
@@ -255,7 +257,7 @@ int uvc_probe_video(struct uvc_video_device *video,
         unsigned int i;
         int ret;
 
-        mutex_lock(&video->streaming->mutex);
+        mutex_lock(&stream->mutex);
 
         /* Perform probing. The device should adjust the requested values
          * according to its capabilities. However, some devices, namely the
@@ -264,15 +266,16 @@ int uvc_probe_video(struct uvc_video_device *video,
          * that reason, if the needed bandwidth exceeds the maximum available
          * bandwidth, try to lower the quality.
          */
-        if ((ret = uvc_set_video_ctrl(video, probe, 1)) < 0)
+        ret = uvc_set_video_ctrl(stream, probe, 1);
+        if (ret < 0)
                 goto done;
 
         /* Get the minimum and maximum values for compression settings. */
-        if (!(video->dev->quirks & UVC_QUIRK_PROBE_MINMAX)) {
-                ret = uvc_get_video_ctrl(video, &probe_min, 1, GET_MIN);
+        if (!(stream->dev->quirks & UVC_QUIRK_PROBE_MINMAX)) {
+                ret = uvc_get_video_ctrl(stream, &probe_min, 1, UVC_GET_MIN);
                 if (ret < 0)
                         goto done;
-                ret = uvc_get_video_ctrl(video, &probe_max, 1, GET_MAX);
+                ret = uvc_get_video_ctrl(stream, &probe_max, 1, UVC_GET_MAX);
                 if (ret < 0)
                         goto done;
 
@@ -280,18 +283,21 @@ int uvc_probe_video(struct uvc_video_device *video,
         }
 
         for (i = 0; i < 2; ++i) {
-                if ((ret = uvc_set_video_ctrl(video, probe, 1)) < 0 ||
-                    (ret = uvc_get_video_ctrl(video, probe, 1, GET_CUR)) < 0)
+                ret = uvc_set_video_ctrl(stream, probe, 1);
+                if (ret < 0)
+                        goto done;
+                ret = uvc_get_video_ctrl(stream, probe, 1, UVC_GET_CUR);
+                if (ret < 0)
                         goto done;
 
-                if (video->streaming->intf->num_altsetting == 1)
+                if (stream->intf->num_altsetting == 1)
                         break;
 
                 bandwidth = probe->dwMaxPayloadTransferSize;
-                if (bandwidth <= video->streaming->maxpsize)
+                if (bandwidth <= stream->maxpsize)
                         break;
 
-                if (video->dev->quirks & UVC_QUIRK_PROBE_MINMAX) {
+                if (stream->dev->quirks & UVC_QUIRK_PROBE_MINMAX) {
                         ret = -ENOSPC;
                         goto done;
                 }
@@ -304,14 +310,14 @@ int uvc_probe_video(struct uvc_video_device *video,
         }
 
 done:
-        mutex_unlock(&video->streaming->mutex);
+        mutex_unlock(&stream->mutex);
         return ret;
 }
 
-int uvc_commit_video(struct uvc_video_device *video,
+int uvc_commit_video(struct uvc_streaming *stream,
         struct uvc_streaming_control *probe)
 {
-        return uvc_set_video_ctrl(video, probe, 0);
+        return uvc_set_video_ctrl(stream, probe, 0);
 }
 
 /* ------------------------------------------------------------------------
@@ -363,7 +369,7 @@ int uvc_commit_video(struct uvc_video_device *video,
  * to be called with a NULL buf parameter. uvc_video_decode_data and
  * uvc_video_decode_end will never be called with a NULL buffer.
  */
-static int uvc_video_decode_start(struct uvc_video_device *video,
+static int uvc_video_decode_start(struct uvc_streaming *stream,
                 struct uvc_buffer *buf, const __u8 *data, int len)
 {
         __u8 fid;
@@ -389,25 +395,25 @@ static int uvc_video_decode_start(struct uvc_video_device *video,
          * NULL.
          */
         if (buf == NULL) {
-                video->last_fid = fid;
+                stream->last_fid = fid;
                 return -ENODATA;
         }
 
         /* Synchronize to the input stream by waiting for the FID bit to be
          * toggled when the the buffer state is not UVC_BUF_STATE_ACTIVE.
-         * video->last_fid is initialized to -1, so the first isochronous
+         * stream->last_fid is initialized to -1, so the first isochronous
          * frame will always be in sync.
          *
-         * If the device doesn't toggle the FID bit, invert video->last_fid
+         * If the device doesn't toggle the FID bit, invert stream->last_fid
          * when the EOF bit is set to force synchronisation on the next packet.
          */
         if (buf->state != UVC_BUF_STATE_ACTIVE) {
-                if (fid == video->last_fid) {
+                if (fid == stream->last_fid) {
                         uvc_trace(UVC_TRACE_FRAME, "Dropping payload (out of "
                                 "sync).\n");
-                        if ((video->dev->quirks & UVC_QUIRK_STREAM_NO_FID) &&
+                        if ((stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID) &&
                             (data[1] & UVC_STREAM_EOF))
-                                video->last_fid ^= UVC_STREAM_FID;
+                                stream->last_fid ^= UVC_STREAM_FID;
                         return -ENODATA;
                 }
 
@@ -422,7 +428,7 @@ static int uvc_video_decode_start(struct uvc_video_device *video,
          * last payload can be lost anyway). We thus must check if the FID has
          * been toggled.
          *
-         * video->last_fid is initialized to -1, so the first isochronous
+         * stream->last_fid is initialized to -1, so the first isochronous
          * frame will never trigger an end of frame detection.
          *
          * Empty buffers (bytesused == 0) don't trigger end of frame detection
@@ -430,22 +436,22 @@ static int uvc_video_decode_start(struct uvc_video_device *video,
          * avoids detecting end of frame conditions at FID toggling if the
          * previous payload had the EOF bit set.
          */
-        if (fid != video->last_fid && buf->buf.bytesused != 0) {
+        if (fid != stream->last_fid && buf->buf.bytesused != 0) {
                 uvc_trace(UVC_TRACE_FRAME, "Frame complete (FID bit "
                                 "toggled).\n");
                 buf->state = UVC_BUF_STATE_DONE;
                 return -EAGAIN;
         }
 
-        video->last_fid = fid;
+        stream->last_fid = fid;
 
         return data[0];
 }
 
-static void uvc_video_decode_data(struct uvc_video_device *video,
+static void uvc_video_decode_data(struct uvc_streaming *stream,
                 struct uvc_buffer *buf, const __u8 *data, int len)
 {
-        struct uvc_video_queue *queue = &video->queue;
+        struct uvc_video_queue *queue = &stream->queue;
         unsigned int maxlen, nbytes;
         void *mem;
 
@@ -466,7 +472,7 @@ static void uvc_video_decode_data(struct uvc_video_device *video,
         }
 }
 
-static void uvc_video_decode_end(struct uvc_video_device *video,
+static void uvc_video_decode_end(struct uvc_streaming *stream,
                 struct uvc_buffer *buf, const __u8 *data, int len)
 {
         /* Mark the buffer as done if the EOF marker is set. */
@@ -475,8 +481,8 @@ static void uvc_video_decode_end(struct uvc_video_device *video,
                 if (data[0] == len)
                         uvc_trace(UVC_TRACE_FRAME, "EOF in empty payload.\n");
                 buf->state = UVC_BUF_STATE_DONE;
-                if (video->dev->quirks & UVC_QUIRK_STREAM_NO_FID)
-                        video->last_fid ^= UVC_STREAM_FID;
+                if (stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID)
+                        stream->last_fid ^= UVC_STREAM_FID;
         }
 }
 
@@ -491,26 +497,26 @@ static void uvc_video_decode_end(struct uvc_video_device *video,
  * uvc_video_encode_data is called for every URB and copies the data from the
  * video buffer to the transfer buffer.
  */
-static int uvc_video_encode_header(struct uvc_video_device *video,
+static int uvc_video_encode_header(struct uvc_streaming *stream,
                 struct uvc_buffer *buf, __u8 *data, int len)
 {
         data[0] = 2;    /* Header length */
         data[1] = UVC_STREAM_EOH | UVC_STREAM_EOF
-                | (video->last_fid & UVC_STREAM_FID);
+                | (stream->last_fid & UVC_STREAM_FID);
         return 2;
 }
 
-static int uvc_video_encode_data(struct uvc_video_device *video,
+static int uvc_video_encode_data(struct uvc_streaming *stream,
                 struct uvc_buffer *buf, __u8 *data, int len)
 {
-        struct uvc_video_queue *queue = &video->queue;
+        struct uvc_video_queue *queue = &stream->queue;
         unsigned int nbytes;
         void *mem;
 
         /* Copy video data to the URB buffer. */
         mem = queue->mem + buf->buf.m.offset + queue->buf_used;
         nbytes = min((unsigned int)len, buf->buf.bytesused - queue->buf_used);
-        nbytes = min(video->bulk.max_payload_size - video->bulk.payload_size,
+        nbytes = min(stream->bulk.max_payload_size - stream->bulk.payload_size,
                         nbytes);
         memcpy(data, mem, nbytes);
 
@@ -526,8 +532,8 @@ static int uvc_video_encode_data(struct uvc_video_device *video,
 /*
  * Completion handler for video URBs.
  */
-static void uvc_video_decode_isoc(struct urb *urb,
-        struct uvc_video_device *video, struct uvc_buffer *buf)
+static void uvc_video_decode_isoc(struct urb *urb, struct uvc_streaming *stream,
+        struct uvc_buffer *buf)
 {
         u8 *mem;
         int ret, i;
@@ -542,31 +548,32 @@ static void uvc_video_decode_isoc(struct urb *urb,
                 /* Decode the payload header. */
                 mem = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
                 do {
-                        ret = uvc_video_decode_start(video, buf, mem,
+                        ret = uvc_video_decode_start(stream, buf, mem,
                                 urb->iso_frame_desc[i].actual_length);
                         if (ret == -EAGAIN)
-                                buf = uvc_queue_next_buffer(&video->queue, buf);
+                                buf = uvc_queue_next_buffer(&stream->queue,
+                                                            buf);
                 } while (ret == -EAGAIN);
 
                 if (ret < 0)
                         continue;
 
                 /* Decode the payload data. */
-                uvc_video_decode_data(video, buf, mem + ret,
+                uvc_video_decode_data(stream, buf, mem + ret,
                         urb->iso_frame_desc[i].actual_length - ret);
 
                 /* Process the header again. */
-                uvc_video_decode_end(video, buf, mem,
+                uvc_video_decode_end(stream, buf, mem,
                         urb->iso_frame_desc[i].actual_length);
 
                 if (buf->state == UVC_BUF_STATE_DONE ||
                     buf->state == UVC_BUF_STATE_ERROR)
-                        buf = uvc_queue_next_buffer(&video->queue, buf);
+                        buf = uvc_queue_next_buffer(&stream->queue, buf);
         }
 }
 
-static void uvc_video_decode_bulk(struct urb *urb,
-        struct uvc_video_device *video, struct uvc_buffer *buf)
+static void uvc_video_decode_bulk(struct urb *urb, struct uvc_streaming *stream,
+        struct uvc_buffer *buf)
 {
         u8 *mem;
         int len, ret;
@@ -576,24 +583,25 @@ static void uvc_video_decode_bulk(struct urb *urb,
 
         mem = urb->transfer_buffer;
         len = urb->actual_length;
-        video->bulk.payload_size += len;
+        stream->bulk.payload_size += len;
 
         /* If the URB is the first of its payload, decode and save the
          * header.
          */
-        if (video->bulk.header_size == 0 && !video->bulk.skip_payload) {
+        if (stream->bulk.header_size == 0 && !stream->bulk.skip_payload) {
                 do {
-                        ret = uvc_video_decode_start(video, buf, mem, len);
+                        ret = uvc_video_decode_start(stream, buf, mem, len);
                         if (ret == -EAGAIN)
-                                buf = uvc_queue_next_buffer(&video->queue, buf);
+                                buf = uvc_queue_next_buffer(&stream->queue,
+                                                            buf);
                 } while (ret == -EAGAIN);
 
                 /* If an error occured skip the rest of the payload. */
                 if (ret < 0 || buf == NULL) {
-                        video->bulk.skip_payload = 1;
+                        stream->bulk.skip_payload = 1;
                 } else {
-                        memcpy(video->bulk.header, mem, ret);
-                        video->bulk.header_size = ret;
+                        memcpy(stream->bulk.header, mem, ret);
+                        stream->bulk.header_size = ret;
 
                         mem += ret;
                         len -= ret;
@@ -606,33 +614,34 @@ static void uvc_video_decode_bulk(struct urb *urb,
          */
 
         /* Process video data. */
-        if (!video->bulk.skip_payload && buf != NULL)
-                uvc_video_decode_data(video, buf, mem, len);
+        if (!stream->bulk.skip_payload && buf != NULL)
+                uvc_video_decode_data(stream, buf, mem, len);
 
         /* Detect the payload end by a URB smaller than the maximum size (or
          * a payload size equal to the maximum) and process the header again.
          */
         if (urb->actual_length < urb->transfer_buffer_length ||
-            video->bulk.payload_size >= video->bulk.max_payload_size) {
-                if (!video->bulk.skip_payload && buf != NULL) {
-                        uvc_video_decode_end(video, buf, video->bulk.header,
-                                video->bulk.payload_size);
+            stream->bulk.payload_size >= stream->bulk.max_payload_size) {
+                if (!stream->bulk.skip_payload && buf != NULL) {
+                        uvc_video_decode_end(stream, buf, stream->bulk.header,
+                                stream->bulk.payload_size);
                         if (buf->state == UVC_BUF_STATE_DONE ||
                             buf->state == UVC_BUF_STATE_ERROR)
-                                buf = uvc_queue_next_buffer(&video->queue, buf);
+                                buf = uvc_queue_next_buffer(&stream->queue,
+                                                            buf);
                 }
 
-                video->bulk.header_size = 0;
-                video->bulk.skip_payload = 0;
-                video->bulk.payload_size = 0;
+                stream->bulk.header_size = 0;
+                stream->bulk.skip_payload = 0;
+                stream->bulk.payload_size = 0;
         }
 }
 
-static void uvc_video_encode_bulk(struct urb *urb,
-        struct uvc_video_device *video, struct uvc_buffer *buf)
+static void uvc_video_encode_bulk(struct urb *urb, struct uvc_streaming *stream,
+        struct uvc_buffer *buf)
 {
         u8 *mem = urb->transfer_buffer;
-        int len = video->urb_size, ret;
+        int len = stream->urb_size, ret;
 
         if (buf == NULL) {
                 urb->transfer_buffer_length = 0;
@@ -640,40 +649,40 @@ static void uvc_video_encode_bulk(struct urb *urb,
         }
 
         /* If the URB is the first of its payload, add the header. */
-        if (video->bulk.header_size == 0) {
-                ret = uvc_video_encode_header(video, buf, mem, len);
-                video->bulk.header_size = ret;
-                video->bulk.payload_size += ret;
+        if (stream->bulk.header_size == 0) {
+                ret = uvc_video_encode_header(stream, buf, mem, len);
+                stream->bulk.header_size = ret;
+                stream->bulk.payload_size += ret;
                 mem += ret;
                 len -= ret;
         }
 
         /* Process video data. */
-        ret = uvc_video_encode_data(video, buf, mem, len);
+        ret = uvc_video_encode_data(stream, buf, mem, len);
 
-        video->bulk.payload_size += ret;
+        stream->bulk.payload_size += ret;
         len -= ret;
 
-        if (buf->buf.bytesused == video->queue.buf_used ||
-            video->bulk.payload_size == video->bulk.max_payload_size) {
-                if (buf->buf.bytesused == video->queue.buf_used) {
-                        video->queue.buf_used = 0;
+        if (buf->buf.bytesused == stream->queue.buf_used ||
+            stream->bulk.payload_size == stream->bulk.max_payload_size) {
+                if (buf->buf.bytesused == stream->queue.buf_used) {
+                        stream->queue.buf_used = 0;
                         buf->state = UVC_BUF_STATE_DONE;
-                        uvc_queue_next_buffer(&video->queue, buf);
-                        video->last_fid ^= UVC_STREAM_FID;
+                        uvc_queue_next_buffer(&stream->queue, buf);
+                        stream->last_fid ^= UVC_STREAM_FID;
                 }
 
-                video->bulk.header_size = 0;
-                video->bulk.payload_size = 0;
+                stream->bulk.header_size = 0;
+                stream->bulk.payload_size = 0;
         }
 
-        urb->transfer_buffer_length = video->urb_size - len;
+        urb->transfer_buffer_length = stream->urb_size - len;
 }
 
 static void uvc_video_complete(struct urb *urb)
 {
-        struct uvc_video_device *video = urb->context;
-        struct uvc_video_queue *queue = &video->queue;
+        struct uvc_streaming *stream = urb->context;
+        struct uvc_video_queue *queue = &stream->queue;
         struct uvc_buffer *buf = NULL;
         unsigned long flags;
         int ret;
@@ -687,7 +696,7 @@ static void uvc_video_complete(struct urb *urb)
                         "completion handler.\n", urb->status);
 
         case -ENOENT:           /* usb_kill_urb() called. */
-                if (video->frozen)
+                if (stream->frozen)
                         return;
 
         case -ECONNRESET:       /* usb_unlink_urb() called. */
@@ -702,7 +711,7 @@ static void uvc_video_complete(struct urb *urb)
                                        queue);
         spin_unlock_irqrestore(&queue->irqlock, flags);
 
-        video->decode(urb, video, buf);
+        stream->decode(urb, stream, buf);
 
         if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
                 uvc_printk(KERN_ERR, "Failed to resubmit video URB (%d).\n",
@@ -713,19 +722,19 @@ static void uvc_video_complete(struct urb *urb)
 /*
  * Free transfer buffers.
  */
-static void uvc_free_urb_buffers(struct uvc_video_device *video)
+static void uvc_free_urb_buffers(struct uvc_streaming *stream)
 {
         unsigned int i;
 
         for (i = 0; i < UVC_URBS; ++i) {
-                if (video->urb_buffer[i]) {
-                        usb_buffer_free(video->dev->udev, video->urb_size,
-                                video->urb_buffer[i], video->urb_dma[i]);
-                        video->urb_buffer[i] = NULL;
+                if (stream->urb_buffer[i]) {
+                        usb_buffer_free(stream->dev->udev, stream->urb_size,
+                                stream->urb_buffer[i], stream->urb_dma[i]);
+                        stream->urb_buffer[i] = NULL;
                 }
         }
 
-        video->urb_size = 0;
+        stream->urb_size = 0;
 }
 
 /*
@@ -739,15 +748,15 @@ static void uvc_free_urb_buffers(struct uvc_video_device *video)
  *
  * Return the number of allocated packets on success or 0 when out of memory.
  */
-static int uvc_alloc_urb_buffers(struct uvc_video_device *video,
+static int uvc_alloc_urb_buffers(struct uvc_streaming *stream,
         unsigned int size, unsigned int psize, gfp_t gfp_flags)
 {
         unsigned int npackets;
         unsigned int i;
 
         /* Buffers are already allocated, bail out. */
-        if (video->urb_size)
-                return video->urb_size / psize;
+        if (stream->urb_size)
+                return stream->urb_size / psize;
 
         /* Compute the number of packets. Bulk endpoints might transfer UVC
          * payloads accross multiple URBs.
@@ -759,17 +768,17 @@ static int uvc_alloc_urb_buffers(struct uvc_video_device *video,
         /* Retry allocations until one succeed. */
         for (; npackets > 1; npackets /= 2) {
                 for (i = 0; i < UVC_URBS; ++i) {
-                        video->urb_buffer[i] = usb_buffer_alloc(
-                                video->dev->udev, psize * npackets,
-                                gfp_flags | __GFP_NOWARN, &video->urb_dma[i]);
-                        if (!video->urb_buffer[i]) {
-                                uvc_free_urb_buffers(video);
+                        stream->urb_buffer[i] = usb_buffer_alloc(
+                                stream->dev->udev, psize * npackets,
+                                gfp_flags | __GFP_NOWARN, &stream->urb_dma[i]);
+                        if (!stream->urb_buffer[i]) {
+                                uvc_free_urb_buffers(stream);
                                 break;
                         }
                 }
 
                 if (i == UVC_URBS) {
-                        video->urb_size = psize * npackets;
+                        stream->urb_size = psize * npackets;
                         return npackets;
                 }
         }
@@ -780,29 +789,30 @@ static int uvc_alloc_urb_buffers(struct uvc_video_device *video,
 /*
  * Uninitialize isochronous/bulk URBs and free transfer buffers.
  */
-static void uvc_uninit_video(struct uvc_video_device *video, int free_buffers)
+static void uvc_uninit_video(struct uvc_streaming *stream, int free_buffers)
 {
         struct urb *urb;
         unsigned int i;
 
         for (i = 0; i < UVC_URBS; ++i) {
-                if ((urb = video->urb[i]) == NULL)
+                urb = stream->urb[i];
+                if (urb == NULL)
                         continue;
 
                 usb_kill_urb(urb);
                 usb_free_urb(urb);
-                video->urb[i] = NULL;
+                stream->urb[i] = NULL;
         }
 
         if (free_buffers)
-                uvc_free_urb_buffers(video);
+                uvc_free_urb_buffers(stream);
 }
 
 /*
  * Initialize isochronous URBs and allocate transfer buffers. The packet size
  * is given by the endpoint.
  */
-static int uvc_init_video_isoc(struct uvc_video_device *video,
+static int uvc_init_video_isoc(struct uvc_streaming *stream,
         struct usb_host_endpoint *ep, gfp_t gfp_flags)
 {
         struct urb *urb;
@@ -812,9 +822,9 @@ static int uvc_init_video_isoc(struct uvc_video_device *video,
 
         psize = le16_to_cpu(ep->desc.wMaxPacketSize);
         psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
-        size = video->streaming->ctrl.dwMaxVideoFrameSize;
+        size = stream->ctrl.dwMaxVideoFrameSize;
 
-        npackets = uvc_alloc_urb_buffers(video, size, psize, gfp_flags);
+        npackets = uvc_alloc_urb_buffers(stream, size, psize, gfp_flags);
         if (npackets == 0)
                 return -ENOMEM;
 
@@ -823,18 +833,18 @@ static int uvc_init_video_isoc(struct uvc_video_device *video,
         for (i = 0; i < UVC_URBS; ++i) {
                 urb = usb_alloc_urb(npackets, gfp_flags);
                 if (urb == NULL) {
-                        uvc_uninit_video(video, 1);
+                        uvc_uninit_video(stream, 1);
                         return -ENOMEM;
                 }
 
-                urb->dev = video->dev->udev;
-                urb->context = video;
-                urb->pipe = usb_rcvisocpipe(video->dev->udev,
+                urb->dev = stream->dev->udev;
+                urb->context = stream;
+                urb->pipe = usb_rcvisocpipe(stream->dev->udev,
                                 ep->desc.bEndpointAddress);
                 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
                 urb->interval = ep->desc.bInterval;
-                urb->transfer_buffer = video->urb_buffer[i];
-                urb->transfer_dma = video->urb_dma[i];
+                urb->transfer_buffer = stream->urb_buffer[i];
+                urb->transfer_dma = stream->urb_dma[i];
                 urb->complete = uvc_video_complete;
                 urb->number_of_packets = npackets;
                 urb->transfer_buffer_length = size;
@@ -844,7 +854,7 @@ static int uvc_init_video_isoc(struct uvc_video_device *video,
                         urb->iso_frame_desc[j].length = psize;
                 }
 
-                video->urb[i] = urb;
+                stream->urb[i] = urb;
         }
 
         return 0;
@@ -854,7 +864,7 @@ static int uvc_init_video_isoc(struct uvc_video_device *video,
  * Initialize bulk URBs and allocate transfer buffers. The packet size is
  * given by the endpoint.
  */
-static int uvc_init_video_bulk(struct uvc_video_device *video,
+static int uvc_init_video_bulk(struct uvc_streaming *stream,
         struct usb_host_endpoint *ep, gfp_t gfp_flags)
 {
         struct urb *urb;
@@ -863,39 +873,39 @@ static int uvc_init_video_bulk(struct uvc_video_device *video,
         u32 size;
 
         psize = le16_to_cpu(ep->desc.wMaxPacketSize) & 0x07ff;
-        size = video->streaming->ctrl.dwMaxPayloadTransferSize;
-        video->bulk.max_payload_size = size;
+        size = stream->ctrl.dwMaxPayloadTransferSize;
+        stream->bulk.max_payload_size = size;
 
-        npackets = uvc_alloc_urb_buffers(video, size, psize, gfp_flags);
+        npackets = uvc_alloc_urb_buffers(stream, size, psize, gfp_flags);
         if (npackets == 0)
                 return -ENOMEM;
 
         size = npackets * psize;
 
         if (usb_endpoint_dir_in(&ep->desc))
-                pipe = usb_rcvbulkpipe(video->dev->udev,
+                pipe = usb_rcvbulkpipe(stream->dev->udev,
                                        ep->desc.bEndpointAddress);
         else
-                pipe = usb_sndbulkpipe(video->dev->udev,
+                pipe = usb_sndbulkpipe(stream->dev->udev,
                                        ep->desc.bEndpointAddress);
 
-        if (video->streaming->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+        if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
                 size = 0;
 
         for (i = 0; i < UVC_URBS; ++i) {
                 urb = usb_alloc_urb(0, gfp_flags);
                 if (urb == NULL) {
-                        uvc_uninit_video(video, 1);
+                        uvc_uninit_video(stream, 1);
                         return -ENOMEM;
                 }
 
-                usb_fill_bulk_urb(urb, video->dev->udev, pipe,
-                        video->urb_buffer[i], size, uvc_video_complete,
-                        video);
+                usb_fill_bulk_urb(urb, stream->dev->udev, pipe,
+                        stream->urb_buffer[i], size, uvc_video_complete,
+                        stream);
                 urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
-                urb->transfer_dma = video->urb_dma[i];
+                urb->transfer_dma = stream->urb_dma[i];
 
-                video->urb[i] = urb;
+                stream->urb[i] = urb;
         }
 
         return 0;
@@ -904,35 +914,35 @@ static int uvc_init_video_bulk(struct uvc_video_device *video,
 /*
  * Initialize isochronous/bulk URBs and allocate transfer buffers.
  */
-static int uvc_init_video(struct uvc_video_device *video, gfp_t gfp_flags)
+static int uvc_init_video(struct uvc_streaming *stream, gfp_t gfp_flags)
 {
-        struct usb_interface *intf = video->streaming->intf;
+        struct usb_interface *intf = stream->intf;
         struct usb_host_interface *alts;
         struct usb_host_endpoint *ep = NULL;
-        int intfnum = video->streaming->intfnum;
+        int intfnum = stream->intfnum;
         unsigned int bandwidth, psize, i;
         int ret;
 
-        video->last_fid = -1;
-        video->bulk.header_size = 0;
-        video->bulk.skip_payload = 0;
-        video->bulk.payload_size = 0;
+        stream->last_fid = -1;
+        stream->bulk.header_size = 0;
+        stream->bulk.skip_payload = 0;
+        stream->bulk.payload_size = 0;
 
         if (intf->num_altsetting > 1) {
                 /* Isochronous endpoint, select the alternate setting. */
-                bandwidth = video->streaming->ctrl.dwMaxPayloadTransferSize;
+                bandwidth = stream->ctrl.dwMaxPayloadTransferSize;
 
                 if (bandwidth == 0) {
                         uvc_printk(KERN_WARNING, "device %s requested null "
                                 "bandwidth, defaulting to lowest.\n",
-                                video->vdev->name);
+                                stream->dev->name);
                         bandwidth = 1;
                 }
 
                 for (i = 0; i < intf->num_altsetting; ++i) {
                         alts = &intf->altsetting[i];
                         ep = uvc_find_endpoint(alts,
-                                video->streaming->header.bEndpointAddress);
+                                stream->header.bEndpointAddress);
                         if (ep == NULL)
                                 continue;
 
@@ -946,18 +956,19 @@ static int uvc_init_video(struct uvc_video_device *video, gfp_t gfp_flags)
                 if (i >= intf->num_altsetting)
                         return -EIO;
 
-                if ((ret = usb_set_interface(video->dev->udev, intfnum, i)) < 0)
+                ret = usb_set_interface(stream->dev->udev, intfnum, i);
+                if (ret < 0)
                         return ret;
 
-                ret = uvc_init_video_isoc(video, ep, gfp_flags);
+                ret = uvc_init_video_isoc(stream, ep, gfp_flags);
         } else {
                 /* Bulk endpoint, proceed to URB initialization. */
                 ep = uvc_find_endpoint(&intf->altsetting[0],
-                                video->streaming->header.bEndpointAddress);
+                                stream->header.bEndpointAddress);
                 if (ep == NULL)
                         return -EIO;
 
-                ret = uvc_init_video_bulk(video, ep, gfp_flags);
+                ret = uvc_init_video_bulk(stream, ep, gfp_flags);
         }
 
         if (ret < 0)
@@ -965,10 +976,11 @@ static int uvc_init_video(struct uvc_video_device *video, gfp_t gfp_flags)
 
         /* Submit the URBs. */
         for (i = 0; i < UVC_URBS; ++i) {
-                if ((ret = usb_submit_urb(video->urb[i], gfp_flags)) < 0) {
+                ret = usb_submit_urb(stream->urb[i], gfp_flags);
+                if (ret < 0) {
                         uvc_printk(KERN_ERR, "Failed to submit URB %u "
                                         "(%d).\n", i, ret);
-                        uvc_uninit_video(video, 1);
+                        uvc_uninit_video(stream, 1);
                         return ret;
                 }
         }
@@ -987,14 +999,14 @@ static int uvc_init_video(struct uvc_video_device *video, gfp_t gfp_flags)
  * video buffers in any way. We mark the device as frozen to make sure the URB
  * completion handler won't try to cancel the queue when we kill the URBs.
  */
-int uvc_video_suspend(struct uvc_video_device *video)
+int uvc_video_suspend(struct uvc_streaming *stream)
 {
-        if (!uvc_queue_streaming(&video->queue))
+        if (!uvc_queue_streaming(&stream->queue))
                 return 0;
 
-        video->frozen = 1;
-        uvc_uninit_video(video, 0);
-        usb_set_interface(video->dev->udev, video->streaming->intfnum, 0);
+        stream->frozen = 1;
+        uvc_uninit_video(stream, 0);
+        usb_set_interface(stream->dev->udev, stream->intfnum, 0);
         return 0;
 }
 
@@ -1006,22 +1018,24 @@ int uvc_video_suspend(struct uvc_video_device *video)
  * buffers, making sure userspace applications are notified of the problem
  * instead of waiting forever.
  */
-int uvc_video_resume(struct uvc_video_device *video)
+int uvc_video_resume(struct uvc_streaming *stream)
 {
         int ret;
 
-        video->frozen = 0;
+        stream->frozen = 0;
 
-        if ((ret = uvc_commit_video(video, &video->streaming->ctrl)) < 0) {
-                uvc_queue_enable(&video->queue, 0);
+        ret = uvc_commit_video(stream, &stream->ctrl);
+        if (ret < 0) {
+                uvc_queue_enable(&stream->queue, 0);
                 return ret;
         }
 
-        if (!uvc_queue_streaming(&video->queue))
+        if (!uvc_queue_streaming(&stream->queue))
                 return 0;
 
-        if ((ret = uvc_init_video(video, GFP_NOIO)) < 0)
-                uvc_queue_enable(&video->queue, 0);
+        ret = uvc_init_video(stream, GFP_NOIO);
+        if (ret < 0)
+                uvc_queue_enable(&stream->queue, 0);
 
         return ret;
 }
@@ -1040,47 +1054,53 @@ int uvc_video_resume(struct uvc_video_device *video)
  *
  * This function is called before registering the device with V4L.
  */
-int uvc_video_init(struct uvc_video_device *video)
+int uvc_video_init(struct uvc_streaming *stream)
 {
-        struct uvc_streaming_control *probe = &video->streaming->ctrl;
+        struct uvc_streaming_control *probe = &stream->ctrl;
         struct uvc_format *format = NULL;
         struct uvc_frame *frame = NULL;
         unsigned int i;
         int ret;
 
-        if (video->streaming->nformats == 0) {
+        if (stream->nformats == 0) {
                 uvc_printk(KERN_INFO, "No supported video formats found.\n");
                 return -EINVAL;
         }
 
+        atomic_set(&stream->active, 0);
+
+        /* Initialize the video buffers queue. */
+        uvc_queue_init(&stream->queue, stream->type);
+
         /* Alternate setting 0 should be the default, yet the XBox Live Vision
          * Cam (and possibly other devices) crash or otherwise misbehave if
          * they don't receive a SET_INTERFACE request before any other video
          * control request.
          */
-        usb_set_interface(video->dev->udev, video->streaming->intfnum, 0);
+        usb_set_interface(stream->dev->udev, stream->intfnum, 0);
 
         /* Set the streaming probe control with default streaming parameters
          * retrieved from the device. Webcams that don't suport GET_DEF
          * requests on the probe control will just keep their current streaming
          * parameters.
          */
-        if (uvc_get_video_ctrl(video, probe, 1, GET_DEF) == 0)
-                uvc_set_video_ctrl(video, probe, 1);
+        if (uvc_get_video_ctrl(stream, probe, 1, UVC_GET_DEF) == 0)
+                uvc_set_video_ctrl(stream, probe, 1);
 
         /* Initialize the streaming parameters with the probe control current
          * value. This makes sure SET_CUR requests on the streaming commit
          * control will always use values retrieved from a successful GET_CUR
          * request on the probe control, as required by the UVC specification.
          */
-        if ((ret = uvc_get_video_ctrl(video, probe, 1, GET_CUR)) < 0)
+        ret = uvc_get_video_ctrl(stream, probe, 1, UVC_GET_CUR);
+        if (ret < 0)
                 return ret;
 
         /* Check if the default format descriptor exists. Use the first
          * available format otherwise.
          */
-        for (i = video->streaming->nformats; i > 0; --i) {
-                format = &video->streaming->format[i-1];
+        for (i = stream->nformats; i > 0; --i) {
+                format = &stream->format[i-1];
                 if (format->index == probe->bFormatIndex)
                         break;
         }
@@ -1105,21 +1125,20 @@ int uvc_video_init(struct uvc_video_device *video)
         probe->bFormatIndex = format->index;
         probe->bFrameIndex = frame->bFrameIndex;
 
-        video->streaming->cur_format = format;
-        video->streaming->cur_frame = frame;
-        atomic_set(&video->active, 0);
+        stream->cur_format = format;
+        stream->cur_frame = frame;
 
         /* Select the video decoding function */
-        if (video->streaming->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                if (video->dev->quirks & UVC_QUIRK_BUILTIN_ISIGHT)
-                        video->decode = uvc_video_decode_isight;
-                else if (video->streaming->intf->num_altsetting > 1)
-                        video->decode = uvc_video_decode_isoc;
+        if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                if (stream->dev->quirks & UVC_QUIRK_BUILTIN_ISIGHT)
+                        stream->decode = uvc_video_decode_isight;
+                else if (stream->intf->num_altsetting > 1)
+                        stream->decode = uvc_video_decode_isoc;
                 else
-                        video->decode = uvc_video_decode_bulk;
+                        stream->decode = uvc_video_decode_bulk;
         } else {
-                if (video->streaming->intf->num_altsetting == 1)
-                        video->decode = uvc_video_encode_bulk;
+                if (stream->intf->num_altsetting == 1)
+                        stream->decode = uvc_video_encode_bulk;
                 else {
                         uvc_printk(KERN_INFO, "Isochronous endpoints are not "
                                 "supported for video output devices.\n");
@@ -1133,31 +1152,32 @@ int uvc_video_init(struct uvc_video_device *video)
 /*
  * Enable or disable the video stream.
  */
-int uvc_video_enable(struct uvc_video_device *video, int enable)
+int uvc_video_enable(struct uvc_streaming *stream, int enable)
 {
         int ret;
 
         if (!enable) {
-                uvc_uninit_video(video, 1);
-                usb_set_interface(video->dev->udev,
-                        video->streaming->intfnum, 0);
-                uvc_queue_enable(&video->queue, 0);
+                uvc_uninit_video(stream, 1);
+                usb_set_interface(stream->dev->udev, stream->intfnum, 0);
+                uvc_queue_enable(&stream->queue, 0);
                 return 0;
         }
 
-        if ((video->streaming->cur_format->flags & UVC_FMT_FLAG_COMPRESSED) ||
+        if ((stream->cur_format->flags & UVC_FMT_FLAG_COMPRESSED) ||
             uvc_no_drop_param)
-                video->queue.flags &= ~UVC_QUEUE_DROP_INCOMPLETE;
+                stream->queue.flags &= ~UVC_QUEUE_DROP_INCOMPLETE;
         else
-                video->queue.flags |= UVC_QUEUE_DROP_INCOMPLETE;
+                stream->queue.flags |= UVC_QUEUE_DROP_INCOMPLETE;
 
-        if ((ret = uvc_queue_enable(&video->queue, 1)) < 0)
+        ret = uvc_queue_enable(&stream->queue, 1);
+        if (ret < 0)
                 return ret;
 
         /* Commit the streaming parameters. */
-        if ((ret = uvc_commit_video(video, &video->streaming->ctrl)) < 0)
+        ret = uvc_commit_video(stream, &stream->ctrl);
+        if (ret < 0)
                 return ret;
 
-        return uvc_init_video(video, GFP_KERNEL);
+        return uvc_init_video(stream, GFP_KERNEL);
 }
 
diff --git a/drivers/media/video/uvc/uvcvideo.h b/drivers/media/video/uvc/uvcvideo.h
index 3c78d3c1e4c0..e7958aa454ce 100644
--- a/drivers/media/video/uvc/uvcvideo.h
+++ b/drivers/media/video/uvc/uvcvideo.h
@@ -67,155 +67,12 @@ struct uvc_xu_control {
 #ifdef __KERNEL__
 
 #include <linux/poll.h>
+#include <linux/usb/video.h>
 
 /* --------------------------------------------------------------------------
  * UVC constants
  */
 
-#define SC_UNDEFINED                    0x00
-#define SC_VIDEOCONTROL                 0x01
-#define SC_VIDEOSTREAMING               0x02
-#define SC_VIDEO_INTERFACE_COLLECTION   0x03
-
-#define PC_PROTOCOL_UNDEFINED           0x00
-
-#define CS_UNDEFINED                    0x20
-#define CS_DEVICE                       0x21
-#define CS_CONFIGURATION                0x22
-#define CS_STRING                       0x23
-#define CS_INTERFACE                    0x24
-#define CS_ENDPOINT                     0x25
-
-/* VideoControl class specific interface descriptor */
-#define VC_DESCRIPTOR_UNDEFINED         0x00
-#define VC_HEADER                       0x01
-#define VC_INPUT_TERMINAL               0x02
-#define VC_OUTPUT_TERMINAL              0x03
-#define VC_SELECTOR_UNIT                0x04
-#define VC_PROCESSING_UNIT              0x05
-#define VC_EXTENSION_UNIT               0x06
-
-/* VideoStreaming class specific interface descriptor */
-#define VS_UNDEFINED                    0x00
-#define VS_INPUT_HEADER                 0x01
-#define VS_OUTPUT_HEADER                0x02
-#define VS_STILL_IMAGE_FRAME            0x03
-#define VS_FORMAT_UNCOMPRESSED          0x04
-#define VS_FRAME_UNCOMPRESSED           0x05
-#define VS_FORMAT_MJPEG                 0x06
-#define VS_FRAME_MJPEG                  0x07
-#define VS_FORMAT_MPEG2TS               0x0a
-#define VS_FORMAT_DV                    0x0c
-#define VS_COLORFORMAT                  0x0d
-#define VS_FORMAT_FRAME_BASED           0x10
-#define VS_FRAME_FRAME_BASED            0x11
-#define VS_FORMAT_STREAM_BASED          0x12
-
-/* Endpoint type */
-#define EP_UNDEFINED                    0x00
-#define EP_GENERAL                      0x01
-#define EP_ENDPOINT                     0x02
-#define EP_INTERRUPT                    0x03
-
-/* Request codes */
-#define RC_UNDEFINED                    0x00
-#define SET_CUR                         0x01
-#define GET_CUR                         0x81
-#define GET_MIN                         0x82
-#define GET_MAX                         0x83
-#define GET_RES                         0x84
-#define GET_LEN                         0x85
-#define GET_INFO                        0x86
-#define GET_DEF                         0x87
-
-/* VideoControl interface controls */
-#define VC_CONTROL_UNDEFINED            0x00
-#define VC_VIDEO_POWER_MODE_CONTROL     0x01
-#define VC_REQUEST_ERROR_CODE_CONTROL   0x02
-
-/* Terminal controls */
-#define TE_CONTROL_UNDEFINED            0x00
-
-/* Selector Unit controls */
-#define SU_CONTROL_UNDEFINED            0x00
-#define SU_INPUT_SELECT_CONTROL         0x01
-
-/* Camera Terminal controls */
-#define CT_CONTROL_UNDEFINED                            0x00
-#define CT_SCANNING_MODE_CONTROL                        0x01
-#define CT_AE_MODE_CONTROL                              0x02
-#define CT_AE_PRIORITY_CONTROL                          0x03
-#define CT_EXPOSURE_TIME_ABSOLUTE_CONTROL               0x04
-#define CT_EXPOSURE_TIME_RELATIVE_CONTROL               0x05
-#define CT_FOCUS_ABSOLUTE_CONTROL                       0x06
-#define CT_FOCUS_RELATIVE_CONTROL                       0x07
-#define CT_FOCUS_AUTO_CONTROL                           0x08
-#define CT_IRIS_ABSOLUTE_CONTROL                        0x09
-#define CT_IRIS_RELATIVE_CONTROL                        0x0a
-#define CT_ZOOM_ABSOLUTE_CONTROL                        0x0b
-#define CT_ZOOM_RELATIVE_CONTROL                        0x0c
-#define CT_PANTILT_ABSOLUTE_CONTROL                     0x0d
-#define CT_PANTILT_RELATIVE_CONTROL                     0x0e
-#define CT_ROLL_ABSOLUTE_CONTROL                        0x0f
-#define CT_ROLL_RELATIVE_CONTROL                        0x10
-#define CT_PRIVACY_CONTROL                              0x11
-
-/* Processing Unit controls */
-#define PU_CONTROL_UNDEFINED                            0x00
-#define PU_BACKLIGHT_COMPENSATION_CONTROL               0x01
-#define PU_BRIGHTNESS_CONTROL                           0x02
-#define PU_CONTRAST_CONTROL                             0x03
-#define PU_GAIN_CONTROL                                 0x04
-#define PU_POWER_LINE_FREQUENCY_CONTROL                 0x05
-#define PU_HUE_CONTROL                                  0x06
-#define PU_SATURATION_CONTROL                           0x07
-#define PU_SHARPNESS_CONTROL                            0x08
-#define PU_GAMMA_CONTROL                                0x09
-#define PU_WHITE_BALANCE_TEMPERATURE_CONTROL            0x0a
-#define PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL       0x0b
-#define PU_WHITE_BALANCE_COMPONENT_CONTROL              0x0c
-#define PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL         0x0d
-#define PU_DIGITAL_MULTIPLIER_CONTROL                   0x0e
-#define PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL             0x0f
-#define PU_HUE_AUTO_CONTROL                             0x10
-#define PU_ANALOG_VIDEO_STANDARD_CONTROL                0x11
-#define PU_ANALOG_LOCK_STATUS_CONTROL                   0x12
-
-#define LXU_MOTOR_PANTILT_RELATIVE_CONTROL              0x01
-#define LXU_MOTOR_PANTILT_RESET_CONTROL                 0x02
-#define LXU_MOTOR_FOCUS_MOTOR_CONTROL                   0x03
-
-/* VideoStreaming interface controls */
-#define VS_CONTROL_UNDEFINED            0x00
-#define VS_PROBE_CONTROL                0x01
-#define VS_COMMIT_CONTROL               0x02
-#define VS_STILL_PROBE_CONTROL          0x03
-#define VS_STILL_COMMIT_CONTROL         0x04
-#define VS_STILL_IMAGE_TRIGGER_CONTROL  0x05
-#define VS_STREAM_ERROR_CODE_CONTROL    0x06
-#define VS_GENERATE_KEY_FRAME_CONTROL   0x07
-#define VS_UPDATE_FRAME_SEGMENT_CONTROL 0x08
-#define VS_SYNC_DELAY_CONTROL           0x09
-
-#define TT_VENDOR_SPECIFIC              0x0100
-#define TT_STREAMING                    0x0101
-
-/* Input Terminal types */
-#define ITT_VENDOR_SPECIFIC             0x0200
-#define ITT_CAMERA                      0x0201
-#define ITT_MEDIA_TRANSPORT_INPUT       0x0202
-
-/* Output Terminal types */
-#define OTT_VENDOR_SPECIFIC             0x0300
-#define OTT_DISPLAY                     0x0301
-#define OTT_MEDIA_TRANSPORT_OUTPUT      0x0302
-
-/* External Terminal types */
-#define EXTERNAL_VENDOR_SPECIFIC        0x0400
-#define COMPOSITE_CONNECTOR             0x0401
-#define SVIDEO_CONNECTOR                0x0402
-#define COMPONENT_CONNECTOR             0x0403
-
 #define UVC_TERM_INPUT                  0x0000
 #define UVC_TERM_OUTPUT                 0x8000
 
@@ -223,12 +80,12 @@ struct uvc_xu_control {
 #define UVC_ENTITY_IS_UNIT(entity)      (((entity)->type & 0xff00) == 0)
 #define UVC_ENTITY_IS_TERM(entity)      (((entity)->type & 0xff00) != 0)
 #define UVC_ENTITY_IS_ITERM(entity) \
-        (((entity)->type & 0x8000) == UVC_TERM_INPUT)
+        (UVC_ENTITY_IS_TERM(entity) && \
+        ((entity)->type & 0x8000) == UVC_TERM_INPUT)
 #define UVC_ENTITY_IS_OTERM(entity) \
-        (((entity)->type & 0x8000) == UVC_TERM_OUTPUT)
+        (UVC_ENTITY_IS_TERM(entity) && \
+        ((entity)->type & 0x8000) == UVC_TERM_OUTPUT)
 
-#define UVC_STATUS_TYPE_CONTROL         1
-#define UVC_STATUS_TYPE_STREAMING       2
 
 /* ------------------------------------------------------------------------
  * GUIDs
@@ -249,19 +106,6 @@ struct uvc_xu_control {
         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02}
 
-#define UVC_GUID_LOGITECH_DEV_INFO \
-        {0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
-         0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x1e}
-#define UVC_GUID_LOGITECH_USER_HW \
-        {0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
-         0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x1f}
-#define UVC_GUID_LOGITECH_VIDEO \
-        {0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
-         0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x50}
-#define UVC_GUID_LOGITECH_MOTOR \
-        {0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
-         0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x56}
-
 #define UVC_GUID_FORMAT_MJPEG \
         { 'M',  'J',  'P',  'G', 0x00, 0x00, 0x10, 0x00, \
          0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
@@ -314,6 +158,7 @@ struct uvc_xu_control {
 #define UVC_QUIRK_STREAM_NO_FID         0x00000010
 #define UVC_QUIRK_IGNORE_SELECTOR_UNIT  0x00000020
 #define UVC_QUIRK_FIX_BANDWIDTH         0x00000080
+#define UVC_QUIRK_PROBE_DEF             0x00000100
 
 /* Format flags */
 #define UVC_FMT_FLAG_COMPRESSED         0x00000001
@@ -518,26 +363,6 @@ struct uvc_streaming_header {
         __u8 bTriggerUsage;
 };
 
-struct uvc_streaming {
-        struct list_head list;
-
-        struct usb_interface *intf;
-        int intfnum;
-        __u16 maxpsize;
-
-        struct uvc_streaming_header header;
-        enum v4l2_buf_type type;
-
-        unsigned int nformats;
-        struct uvc_format *format;
-
-        struct uvc_streaming_control ctrl;
-        struct uvc_format *cur_format;
-        struct uvc_frame *cur_frame;
-
-        struct mutex mutex;
-};
-
 enum uvc_buffer_state {
         UVC_BUF_STATE_IDLE      = 0,
         UVC_BUF_STATE_QUEUED    = 1,
@@ -579,26 +404,45 @@ struct uvc_video_queue {
         struct list_head irqqueue;
 };
 
-struct uvc_video_device {
+struct uvc_video_chain {
         struct uvc_device *dev;
-        struct video_device *vdev;
-        atomic_t active;
-        unsigned int frozen : 1;
+        struct list_head list;
 
         struct list_head iterms;                /* Input terminals */
-        struct uvc_entity *oterm;               /* Output terminal */
-        struct uvc_entity *sterm;               /* USB streaming terminal */
-        struct uvc_entity *processing;
-        struct uvc_entity *selector;
-        struct list_head extensions;
+        struct list_head oterms;                /* Output terminals */
+        struct uvc_entity *processing;          /* Processing unit */
+        struct uvc_entity *selector;            /* Selector unit */
+        struct list_head extensions;            /* Extension units */
+
         struct mutex ctrl_mutex;
+};
 
-        struct uvc_video_queue queue;
+struct uvc_streaming {
+        struct list_head list;
+        struct uvc_device *dev;
+        struct video_device *vdev;
+        struct uvc_video_chain *chain;
+        atomic_t active;
 
-        /* Video streaming object, must always be non-NULL. */
-        struct uvc_streaming *streaming;
+        struct usb_interface *intf;
+        int intfnum;
+        __u16 maxpsize;
 
-        void (*decode) (struct urb *urb, struct uvc_video_device *video,
+        struct uvc_streaming_header header;
+        enum v4l2_buf_type type;
+
+        unsigned int nformats;
+        struct uvc_format *format;
+
+        struct uvc_streaming_control ctrl;
+        struct uvc_format *cur_format;
+        struct uvc_frame *cur_frame;
+
+        struct mutex mutex;
+
+        unsigned int frozen : 1;
+        struct uvc_video_queue queue;
+        void (*decode) (struct urb *urb, struct uvc_streaming *video,
                         struct uvc_buffer *buf);
 
         /* Context data used by the bulk completion handler. */
@@ -640,8 +484,10 @@ struct uvc_device {
         __u32 clock_frequency;
 
         struct list_head entities;
+        struct list_head chains;
 
-        struct uvc_video_device video;
+        /* Video Streaming interfaces */
+        struct list_head streams;
 
         /* Status Interrupt Endpoint */
         struct usb_host_endpoint *int_ep;
@@ -649,9 +495,6 @@ struct uvc_device {
         __u8 *status;
         struct input_dev *input;
         char input_phys[64];
-
-        /* Video Streaming interfaces */
-        struct list_head streaming;
 };
 
 enum uvc_handle_state {
@@ -660,7 +503,8 @@ enum uvc_handle_state {
 };
 
 struct uvc_fh {
-        struct uvc_video_device *device;
+        struct uvc_video_chain *chain;
+        struct uvc_streaming *stream;
         enum uvc_handle_state state;
 };
 
@@ -757,13 +601,13 @@ static inline int uvc_queue_streaming(struct uvc_video_queue *queue)
 extern const struct v4l2_file_operations uvc_fops;
 
 /* Video */
-extern int uvc_video_init(struct uvc_video_device *video);
-extern int uvc_video_suspend(struct uvc_video_device *video);
-extern int uvc_video_resume(struct uvc_video_device *video);
-extern int uvc_video_enable(struct uvc_video_device *video, int enable);
-extern int uvc_probe_video(struct uvc_video_device *video,
+extern int uvc_video_init(struct uvc_streaming *stream);
+extern int uvc_video_suspend(struct uvc_streaming *stream);
+extern int uvc_video_resume(struct uvc_streaming *stream);
+extern int uvc_video_enable(struct uvc_streaming *stream, int enable);
+extern int uvc_probe_video(struct uvc_streaming *stream,
                 struct uvc_streaming_control *probe);
-extern int uvc_commit_video(struct uvc_video_device *video,
+extern int uvc_commit_video(struct uvc_streaming *stream,
                 struct uvc_streaming_control *ctrl);
 extern int uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
                 __u8 intfnum, __u8 cs, void *data, __u16 size);
@@ -777,9 +621,9 @@ extern int uvc_status_suspend(struct uvc_device *dev);
 extern int uvc_status_resume(struct uvc_device *dev);
 
 /* Controls */
-extern struct uvc_control *uvc_find_control(struct uvc_video_device *video,
+extern struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,
                 __u32 v4l2_id, struct uvc_control_mapping **mapping);
-extern int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
+extern int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
                 struct v4l2_queryctrl *v4l2_ctrl);
 
 extern int uvc_ctrl_add_info(struct uvc_control_info *info);
@@ -789,23 +633,23 @@ extern void uvc_ctrl_cleanup_device(struct uvc_device *dev);
 extern int uvc_ctrl_resume_device(struct uvc_device *dev);
 extern void uvc_ctrl_init(void);
 
-extern int uvc_ctrl_begin(struct uvc_video_device *video);
-extern int __uvc_ctrl_commit(struct uvc_video_device *video, int rollback);
-static inline int uvc_ctrl_commit(struct uvc_video_device *video)
+extern int uvc_ctrl_begin(struct uvc_video_chain *chain);
+extern int __uvc_ctrl_commit(struct uvc_video_chain *chain, int rollback);
+static inline int uvc_ctrl_commit(struct uvc_video_chain *chain)
 {
-        return __uvc_ctrl_commit(video, 0);
+        return __uvc_ctrl_commit(chain, 0);
 }
-static inline int uvc_ctrl_rollback(struct uvc_video_device *video)
+static inline int uvc_ctrl_rollback(struct uvc_video_chain *chain)
 {
-        return __uvc_ctrl_commit(video, 1);
+        return __uvc_ctrl_commit(chain, 1);
 }
 
-extern int uvc_ctrl_get(struct uvc_video_device *video,
+extern int uvc_ctrl_get(struct uvc_video_chain *chain,
                 struct v4l2_ext_control *xctrl);
-extern int uvc_ctrl_set(struct uvc_video_device *video,
+extern int uvc_ctrl_set(struct uvc_video_chain *chain,
                 struct v4l2_ext_control *xctrl);
 
-extern int uvc_xu_ctrl_query(struct uvc_video_device *video,
+extern int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
                 struct uvc_xu_control *ctrl, int set);
 
 /* Utility functions */
@@ -817,7 +661,7 @@ extern struct usb_host_endpoint *uvc_find_endpoint(
                 struct usb_host_interface *alts, __u8 epaddr);
 
 /* Quirks support */
-void uvc_video_decode_isight(struct urb *urb, struct uvc_video_device *video,
+void uvc_video_decode_isight(struct urb *urb, struct uvc_streaming *stream,
                 struct uvc_buffer *buf);
 
 #endif /* __KERNEL__ */
diff --git a/drivers/media/video/v4l1-compat.c b/drivers/media/video/v4l1-compat.c
index 02f2a6d18b45..761fbd64db58 100644
--- a/drivers/media/video/v4l1-compat.c
+++ b/drivers/media/video/v4l1-compat.c
@@ -76,9 +76,8 @@ get_v4l_control(struct file             *file,
                         dprintk("VIDIOC_G_CTRL: %d\n", err);
                         return 0;
                 }
-                return ((ctrl2.value - qctrl2.minimum) * 65535
-                         + (qctrl2.maximum - qctrl2.minimum) / 2)
-                        / (qctrl2.maximum - qctrl2.minimum);
+                return DIV_ROUND_CLOSEST((ctrl2.value-qctrl2.minimum) * 65535,
+                                         qctrl2.maximum - qctrl2.minimum);
         }
         return 0;
 }
diff --git a/drivers/media/video/v4l2-common.c b/drivers/media/video/v4l2-common.c
index b91d66a767d7..3a0c64935b0e 100644
--- a/drivers/media/video/v4l2-common.c
+++ b/drivers/media/video/v4l2-common.c
@@ -156,6 +156,8 @@ int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
                 return -EINVAL;
         if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
                 return -EBUSY;
+        if (qctrl->type == V4L2_CTRL_TYPE_STRING)
+                return 0;
         if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
             qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
             qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
@@ -340,6 +342,12 @@ const char **v4l2_ctrl_get_menu(u32 id)
                 "Sepia",
                 NULL
         };
+        static const char *tune_preemphasis[] = {
+                "No preemphasis",
+                "50 useconds",
+                "75 useconds",
+                NULL,
+        };
 
         switch (id) {
                 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
@@ -378,6 +386,8 @@ const char **v4l2_ctrl_get_menu(u32 id)
                         return camera_exposure_auto;
                 case V4L2_CID_COLORFX:
                         return colorfx;
+                case V4L2_CID_TUNE_PREEMPHASIS:
+                        return tune_preemphasis;
                 default:
                         return NULL;
         }
@@ -476,6 +486,28 @@ const char *v4l2_ctrl_get_name(u32 id)
         case V4L2_CID_ZOOM_CONTINUOUS:          return "Zoom, Continuous";
         case V4L2_CID_PRIVACY:                  return "Privacy";
 
+        /* FM Radio Modulator control */
+        case V4L2_CID_FM_TX_CLASS:              return "FM Radio Modulator Controls";
+        case V4L2_CID_RDS_TX_DEVIATION:         return "RDS Signal Deviation";
+        case V4L2_CID_RDS_TX_PI:                return "RDS Program ID";
+        case V4L2_CID_RDS_TX_PTY:               return "RDS Program Type";
+        case V4L2_CID_RDS_TX_PS_NAME:           return "RDS PS Name";
+        case V4L2_CID_RDS_TX_RADIO_TEXT:        return "RDS Radio Text";
+        case V4L2_CID_AUDIO_LIMITER_ENABLED:    return "Audio Limiter Feature Enabled";
+        case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
+        case V4L2_CID_AUDIO_LIMITER_DEVIATION:  return "Audio Limiter Deviation";
+        case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Feature Enabled";
+        case V4L2_CID_AUDIO_COMPRESSION_GAIN:   return "Audio Compression Gain";
+        case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
+        case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
+        case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
+        case V4L2_CID_PILOT_TONE_ENABLED:       return "Pilot Tone Feature Enabled";
+        case V4L2_CID_PILOT_TONE_DEVIATION:     return "Pilot Tone Deviation";
+        case V4L2_CID_PILOT_TONE_FREQUENCY:     return "Pilot Tone Frequency";
+        case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-emphasis settings";
+        case V4L2_CID_TUNE_POWER_LEVEL:         return "Tune Power Level";
+        case V4L2_CID_TUNE_ANTENNA_CAPACITOR:   return "Tune Antenna Capacitor";
+
         default:
                 return NULL;
         }
@@ -508,6 +540,9 @@ int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 ste
         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
         case V4L2_CID_FOCUS_AUTO:
         case V4L2_CID_PRIVACY:
+        case V4L2_CID_AUDIO_LIMITER_ENABLED:
+        case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
+        case V4L2_CID_PILOT_TONE_ENABLED:
                 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
                 min = 0;
                 max = step = 1;
@@ -536,12 +571,18 @@ int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 ste
         case V4L2_CID_MPEG_STREAM_VBI_FMT:
         case V4L2_CID_EXPOSURE_AUTO:
         case V4L2_CID_COLORFX:
+        case V4L2_CID_TUNE_PREEMPHASIS:
                 qctrl->type = V4L2_CTRL_TYPE_MENU;
                 step = 1;
                 break;
+        case V4L2_CID_RDS_TX_PS_NAME:
+        case V4L2_CID_RDS_TX_RADIO_TEXT:
+                qctrl->type = V4L2_CTRL_TYPE_STRING;
+                break;
         case V4L2_CID_USER_CLASS:
         case V4L2_CID_CAMERA_CLASS:
         case V4L2_CID_MPEG_CLASS:
+        case V4L2_CID_FM_TX_CLASS:
                 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
                 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
                 min = max = step = def = 0;
@@ -570,6 +611,17 @@ int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 ste
         case V4L2_CID_BLUE_BALANCE:
         case V4L2_CID_GAMMA:
         case V4L2_CID_SHARPNESS:
+        case V4L2_CID_RDS_TX_DEVIATION:
+        case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
+        case V4L2_CID_AUDIO_LIMITER_DEVIATION:
+        case V4L2_CID_AUDIO_COMPRESSION_GAIN:
+        case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
+        case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
+        case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
+        case V4L2_CID_PILOT_TONE_DEVIATION:
+        case V4L2_CID_PILOT_TONE_FREQUENCY:
+        case V4L2_CID_TUNE_POWER_LEVEL:
+        case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
                 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
                 break;
         case V4L2_CID_PAN_RELATIVE:
diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c
index 0056b115b42e..997975d5e024 100644
--- a/drivers/media/video/v4l2-compat-ioctl32.c
+++ b/drivers/media/video/v4l2-compat-ioctl32.c
@@ -600,9 +600,37 @@ struct v4l2_ext_controls32 {
        compat_caddr_t controls; /* actually struct v4l2_ext_control32 * */
 };
 
+struct v4l2_ext_control32 {
+        __u32 id;
+        __u32 size;
+        __u32 reserved2[1];
+        union {
+                __s32 value;
+                __s64 value64;
+                compat_caddr_t string; /* actually char * */
+        };
+} __attribute__ ((packed));
+
+/* The following function really belong in v4l2-common, but that causes
+   a circular dependency between modules. We need to think about this, but
+   for now this will do. */
+
+/* Return non-zero if this control is a pointer type. Currently only
+   type STRING is a pointer type. */
+static inline int ctrl_is_pointer(u32 id)
+{
+        switch (id) {
+        case V4L2_CID_RDS_TX_PS_NAME:
+        case V4L2_CID_RDS_TX_RADIO_TEXT:
+                return 1;
+        default:
+                return 0;
+        }
+}
+
 static int get_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext_controls32 __user *up)
 {
-        struct v4l2_ext_control __user *ucontrols;
+        struct v4l2_ext_control32 __user *ucontrols;
         struct v4l2_ext_control __user *kcontrols;
         int n;
         compat_caddr_t p;
@@ -626,15 +654,17 @@ static int get_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext
         kcontrols = compat_alloc_user_space(n * sizeof(struct v4l2_ext_control));
         kp->controls = kcontrols;
         while (--n >= 0) {
-                if (copy_in_user(&kcontrols->id, &ucontrols->id, sizeof(__u32)))
-                        return -EFAULT;
-                if (copy_in_user(&kcontrols->reserved2, &ucontrols->reserved2, sizeof(ucontrols->reserved2)))
-                        return -EFAULT;
-                /* Note: if the void * part of the union ever becomes relevant
-                   then we need to know the type of the control in order to do
-                   the right thing here. Luckily, that is not yet an issue. */
-                if (copy_in_user(&kcontrols->value, &ucontrols->value, sizeof(ucontrols->value)))
+                if (copy_in_user(kcontrols, ucontrols, sizeof(*kcontrols)))
                         return -EFAULT;
+                if (ctrl_is_pointer(kcontrols->id)) {
+                        void __user *s;
+
+                        if (get_user(p, &ucontrols->string))
+                                return -EFAULT;
+                        s = compat_ptr(p);
+                        if (put_user(s, &kcontrols->string))
+                                return -EFAULT;
+                }
                 ucontrols++;
                 kcontrols++;
         }
@@ -643,7 +673,7 @@ static int get_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext
 
 static int put_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext_controls32 __user *up)
 {
-        struct v4l2_ext_control __user *ucontrols;
+        struct v4l2_ext_control32 __user *ucontrols;
         struct v4l2_ext_control __user *kcontrols = kp->controls;
         int n = kp->count;
         compat_caddr_t p;
@@ -664,15 +694,14 @@ static int put_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext
                 return -EFAULT;
 
         while (--n >= 0) {
-                if (copy_in_user(&ucontrols->id, &kcontrols->id, sizeof(__u32)))
-                        return -EFAULT;
-                if (copy_in_user(&ucontrols->reserved2, &kcontrols->reserved2,
-                                        sizeof(ucontrols->reserved2)))
-                        return -EFAULT;
-                /* Note: if the void * part of the union ever becomes relevant
-                   then we need to know the type of the control in order to do
-                   the right thing here. Luckily, that is not yet an issue. */
-                if (copy_in_user(&ucontrols->value, &kcontrols->value, sizeof(ucontrols->value)))
+                unsigned size = sizeof(*ucontrols);
+
+                /* Do not modify the pointer when copying a pointer control.
+                   The contents of the pointer was changed, not the pointer
+                   itself. */
+                if (ctrl_is_pointer(kcontrols->id))
+                        size -= sizeof(ucontrols->value64);
+                if (copy_in_user(ucontrols, kcontrols, size))
                         return -EFAULT;
                 ucontrols++;
                 kcontrols++;
diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
index f2afc4e08379..30cc3347ae52 100644
--- a/drivers/media/video/v4l2-ioctl.c
+++ b/drivers/media/video/v4l2-ioctl.c
@@ -42,6 +42,12 @@
                         printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);\
                 } while (0)
 
+#define dbgarg3(fmt, arg...) \
+                do {                                                    \
+                    if (vfd->debug & V4L2_DEBUG_IOCTL_ARG)              \
+                        printk(KERN_CONT "%s: " fmt, vfd->name, ## arg);\
+                } while (0)
+
 /* Zero out the end of the struct pointed to by p.  Everthing after, but
  * not including, the specified field is cleared. */
 #define CLEAR_AFTER_FIELD(p, field) \
@@ -507,11 +513,12 @@ static inline void v4l_print_ext_ctrls(unsigned int cmd,
         dbgarg(cmd, "");
         printk(KERN_CONT "class=0x%x", c->ctrl_class);
         for (i = 0; i < c->count; i++) {
-                if (show_vals)
+                if (show_vals && !c->controls[i].size)
                         printk(KERN_CONT " id/val=0x%x/0x%x",
                                 c->controls[i].id, c->controls[i].value);
                 else
-                        printk(KERN_CONT " id=0x%x", c->controls[i].id);
+                        printk(KERN_CONT " id=0x%x,size=%u",
+                                c->controls[i].id, c->controls[i].size);
         }
         printk(KERN_CONT "\n");
 };
@@ -522,10 +529,9 @@ static inline int check_ext_ctrls(struct v4l2_ext_controls *c, int allow_priv)
 
         /* zero the reserved fields */
         c->reserved[0] = c->reserved[1] = 0;
-        for (i = 0; i < c->count; i++) {
+        for (i = 0; i < c->count; i++)
                 c->controls[i].reserved2[0] = 0;
-                c->controls[i].reserved2[1] = 0;
-        }
+
         /* V4L2_CID_PRIVATE_BASE cannot be used as control class
            when using extended controls.
            Only when passed in through VIDIOC_G_CTRL and VIDIOC_S_CTRL
@@ -1726,24 +1732,29 @@ static long __video_do_ioctl(struct file *file,
 
                 ret = ops->vidioc_enum_framesizes(file, fh, p);
                 dbgarg(cmd,
-                        "index=%d, pixelformat=%d, type=%d ",
-                        p->index, p->pixel_format, p->type);
+                        "index=%d, pixelformat=%c%c%c%c, type=%d ",
+                        p->index,
+                        (p->pixel_format & 0xff),
+                        (p->pixel_format >>  8) & 0xff,
+                        (p->pixel_format >> 16) & 0xff,
+                        (p->pixel_format >> 24) & 0xff,
+                        p->type);
                 switch (p->type) {
                 case V4L2_FRMSIZE_TYPE_DISCRETE:
-                        dbgarg2("width = %d, height=%d\n",
+                        dbgarg3("width = %d, height=%d\n",
                                 p->discrete.width, p->discrete.height);
                         break;
                 case V4L2_FRMSIZE_TYPE_STEPWISE:
-                        dbgarg2("min %dx%d, max %dx%d, step %dx%d\n",
+                        dbgarg3("min %dx%d, max %dx%d, step %dx%d\n",
                                 p->stepwise.min_width,  p->stepwise.min_height,
                                 p->stepwise.step_width, p->stepwise.step_height,
                                 p->stepwise.max_width,  p->stepwise.max_height);
                         break;
                 case V4L2_FRMSIZE_TYPE_CONTINUOUS:
-                        dbgarg2("continuous\n");
+                        dbgarg3("continuous\n");
                         break;
                 default:
-                        dbgarg2("- Unknown type!\n");
+                        dbgarg3("- Unknown type!\n");
                 }
 
                 break;
diff --git a/drivers/media/video/vino.c b/drivers/media/video/vino.c
index 97b082fe4473..f3b6e15d91f2 100644
--- a/drivers/media/video/vino.c
+++ b/drivers/media/video/vino.c
@@ -1776,7 +1776,6 @@ static struct i2c_algo_sgi_data i2c_sgi_vino_data = {
 
 static struct i2c_adapter vino_i2c_adapter = {
         .name                   = "VINO I2C bus",
-        .id                     = I2C_HW_SGI_VINO,
         .algo                   = &sgi_algo,
         .algo_data              = &i2c_sgi_vino_data,
         .owner                  = THIS_MODULE,
diff --git a/drivers/media/video/w9968cf.c b/drivers/media/video/w9968cf.c
index 6c3f23e31b5c..602484dd3da9 100644
--- a/drivers/media/video/w9968cf.c
+++ b/drivers/media/video/w9968cf.c
@@ -1497,7 +1497,6 @@ static int w9968cf_i2c_init(struct w9968cf_device* cam)
         };
 
         static struct i2c_adapter adap = {
-                .id =                I2C_HW_SMBUS_W9968CF,
                 .owner =             THIS_MODULE,
                 .algo =              &algo,
         };
diff --git a/drivers/media/video/zoran/zoran_card.c b/drivers/media/video/zoran/zoran_card.c
index 03dc2f3cf84a..0c4d9b1f8e6f 100644
--- a/drivers/media/video/zoran/zoran_card.c
+++ b/drivers/media/video/zoran/zoran_card.c
@@ -732,7 +732,6 @@ zoran_register_i2c (struct zoran *zr)
         memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
                sizeof(struct i2c_algo_bit_data));
         zr->i2c_algo.data = zr;
-        zr->i2c_adapter.id = I2C_HW_B_ZR36067;
         strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
                 sizeof(zr->i2c_adapter.name));
         i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev);
@@ -1169,7 +1168,7 @@ zoran_setup_videocodec (struct zoran *zr,
         m->type = 0;
 
         m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
-        strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
+        strlcpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
         m->data = zr;
 
         switch (type)
diff --git a/drivers/media/video/zr364xx.c b/drivers/media/video/zr364xx.c
index 2622a6e63da1..9aae011d92ab 100644
--- a/drivers/media/video/zr364xx.c
+++ b/drivers/media/video/zr364xx.c
@@ -1,5 +1,5 @@
 /*
- * Zoran 364xx based USB webcam module version 0.72
+ * Zoran 364xx based USB webcam module version 0.73
  *
  * Allows you to use your USB webcam with V4L2 applications
  * This is still in heavy developpement !
@@ -10,6 +10,8 @@
  * Heavily inspired by usb-skeleton.c, vicam.c, cpia.c and spca50x.c drivers
  * V4L2 version inspired by meye.c driver
  *
+ * Some video buffer code by Lamarque based on s2255drv.c and vivi.c drivers.
+ *
  * 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
@@ -27,6 +29,7 @@
 
 
 #include <linux/module.h>
+#include <linux/version.h>
 #include <linux/init.h>
 #include <linux/usb.h>
 #include <linux/vmalloc.h>
@@ -35,24 +38,40 @@
 #include <linux/highmem.h>
 #include <media/v4l2-common.h>
 #include <media/v4l2-ioctl.h>
+#include <media/videobuf-vmalloc.h>
 
 
 /* Version Information */
-#define DRIVER_VERSION "v0.72"
+#define DRIVER_VERSION "v0.73"
+#define ZR364XX_VERSION_CODE KERNEL_VERSION(0, 7, 3)
 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
 #define DRIVER_DESC "Zoran 364xx"
 
 
 /* Camera */
-#define FRAMES 2
-#define MAX_FRAME_SIZE 100000
+#define FRAMES 1
+#define MAX_FRAME_SIZE 200000
 #define BUFFER_SIZE 0x1000
 #define CTRL_TIMEOUT 500
 
+#define ZR364XX_DEF_BUFS        4
+#define ZR364XX_READ_IDLE       0
+#define ZR364XX_READ_FRAME      1
 
 /* Debug macro */
-#define DBG(x...) if (debug) printk(KERN_INFO KBUILD_MODNAME x)
-
+#define DBG(fmt, args...) \
+        do { \
+                if (debug) { \
+                        printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
+                } \
+        } while (0)
+
+/*#define FULL_DEBUG 1*/
+#ifdef FULL_DEBUG
+#define _DBG DBG
+#else
+#define _DBG(fmt, args...)
+#endif
 
 /* Init methods, need to find nicer names for these
  * the exact names of the chipsets would be the best if someone finds it */
@@ -101,24 +120,93 @@ static struct usb_device_id device_table[] = {
 
 MODULE_DEVICE_TABLE(usb, device_table);
 
+struct zr364xx_mode {
+        u32 color;      /* output video color format */
+        u32 brightness; /* brightness */
+};
+
+/* frame structure */
+struct zr364xx_framei {
+        unsigned long ulState;  /* ulState:ZR364XX_READ_IDLE,
+                                           ZR364XX_READ_FRAME */
+        void *lpvbits;          /* image data */
+        unsigned long cur_size; /* current data copied to it */
+};
+
+/* image buffer structure */
+struct zr364xx_bufferi {
+        unsigned long dwFrames;                 /* number of frames in buffer */
+        struct zr364xx_framei frame[FRAMES];    /* array of FRAME structures */
+};
+
+struct zr364xx_dmaqueue {
+        struct list_head        active;
+        struct zr364xx_camera   *cam;
+};
+
+struct zr364xx_pipeinfo {
+        u32 transfer_size;
+        u8 *transfer_buffer;
+        u32 state;
+        void *stream_urb;
+        void *cam;      /* back pointer to zr364xx_camera struct */
+        u32 err_count;
+        u32 idx;
+};
+
+struct zr364xx_fmt {
+        char *name;
+        u32 fourcc;
+        int depth;
+};
+
+/* image formats.  */
+static const struct zr364xx_fmt formats[] = {
+        {
+                .name = "JPG",
+                .fourcc = V4L2_PIX_FMT_JPEG,
+                .depth = 24
+        }
+};
 
 /* Camera stuff */
 struct zr364xx_camera {
         struct usb_device *udev;        /* save off the usb device pointer */
         struct usb_interface *interface;/* the interface for this device */
         struct video_device *vdev;      /* v4l video device */
-        u8 *framebuf;
         int nb;
-        unsigned char *buffer;
+        struct zr364xx_bufferi          buffer;
         int skip;
-        int brightness;
         int width;
         int height;
         int method;
         struct mutex lock;
+        struct mutex open_lock;
         int users;
+
+        spinlock_t              slock;
+        struct zr364xx_dmaqueue vidq;
+        int                     resources;
+        int                     last_frame;
+        int                     cur_frame;
+        unsigned long           frame_count;
+        int                     b_acquire;
+        struct zr364xx_pipeinfo pipe[1];
+
+        u8                      read_endpoint;
+
+        const struct zr364xx_fmt *fmt;
+        struct videobuf_queue   vb_vidq;
+        enum v4l2_buf_type      type;
+        struct zr364xx_mode     mode;
 };
 
+/* buffer for one video frame */
+struct zr364xx_buffer {
+        /* common v4l buffer stuff -- must be first */
+        struct videobuf_buffer vb;
+        const struct zr364xx_fmt *fmt;
+};
 
 /* function used to send initialisation commands to the camera */
 static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
@@ -272,139 +360,116 @@ static unsigned char header2[] = {
 };
 static unsigned char header3;
 
+/* ------------------------------------------------------------------
+   Videobuf operations
+   ------------------------------------------------------------------*/
 
+static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
+                        unsigned int *size)
+{
+        struct zr364xx_camera *cam = vq->priv_data;
 
-/********************/
-/* V4L2 integration */
-/********************/
+        *size = cam->width * cam->height * (cam->fmt->depth >> 3);
 
-/* this function reads a full JPEG picture synchronously
- * TODO: do it asynchronously... */
-static int read_frame(struct zr364xx_camera *cam, int framenum)
-{
-        int i, n, temp, head, size, actual_length;
-        unsigned char *ptr = NULL, *jpeg;
-
-      redo:
-        /* hardware brightness */
-        n = send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
-        temp = (0x60 << 8) + 127 - cam->brightness;
-        n = send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
-
-        /* during the first loop we are going to insert JPEG header */
-        head = 0;
-        /* this is the place in memory where we are going to build
-         * the JPEG image */
-        jpeg = cam->framebuf + framenum * MAX_FRAME_SIZE;
-        /* read data... */
-        do {
-                n = usb_bulk_msg(cam->udev,
-                                 usb_rcvbulkpipe(cam->udev, 0x81),
-                                 cam->buffer, BUFFER_SIZE, &actual_length,
-                                 CTRL_TIMEOUT);
-                DBG("buffer : %d %d", cam->buffer[0], cam->buffer[1]);
-                DBG("bulk : n=%d size=%d", n, actual_length);
-                if (n < 0) {
-                        dev_err(&cam->udev->dev, "error reading bulk msg\n");
-                        return 0;
-                }
-                if (actual_length < 0 || actual_length > BUFFER_SIZE) {
-                        dev_err(&cam->udev->dev, "wrong number of bytes\n");
-                        return 0;
-                }
+        if (*count == 0)
+                *count = ZR364XX_DEF_BUFS;
 
-                /* swap bytes if camera needs it */
-                if (cam->method == METHOD0) {
-                        u16 *buf = (u16*)cam->buffer;
-                        for (i = 0; i < BUFFER_SIZE/2; i++)
-                                swab16s(buf + i);
-                }
+        while (*size * (*count) > ZR364XX_DEF_BUFS * 1024 * 1024)
+                (*count)--;
 
-                /* write the JPEG header */
-                if (!head) {
-                        DBG("jpeg header");
-                        ptr = jpeg;
-                        memcpy(ptr, header1, sizeof(header1));
-                        ptr += sizeof(header1);
-                        header3 = 0;
-                        memcpy(ptr, &header3, 1);
-                        ptr++;
-                        memcpy(ptr, cam->buffer, 64);
-                        ptr += 64;
-                        header3 = 1;
-                        memcpy(ptr, &header3, 1);
-                        ptr++;
-                        memcpy(ptr, cam->buffer + 64, 64);
-                        ptr += 64;
-                        memcpy(ptr, header2, sizeof(header2));
-                        ptr += sizeof(header2);
-                        memcpy(ptr, cam->buffer + 128,
-                               actual_length - 128);
-                        ptr += actual_length - 128;
-                        head = 1;
-                        DBG("header : %d %d %d %d %d %d %d %d %d",
-                            cam->buffer[0], cam->buffer[1], cam->buffer[2],
-                            cam->buffer[3], cam->buffer[4], cam->buffer[5],
-                            cam->buffer[6], cam->buffer[7], cam->buffer[8]);
-                } else {
-                        memcpy(ptr, cam->buffer, actual_length);
-                        ptr += actual_length;
-                }
-        }
-        /* ... until there is no more */
-        while (actual_length == BUFFER_SIZE);
+        return 0;
+}
 
-        /* we skip the 2 first frames which are usually buggy */
-        if (cam->skip) {
-                cam->skip--;
-                goto redo;
-        }
+static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf)
+{
+        _DBG("%s\n", __func__);
 
-        /* go back to find the JPEG EOI marker */
-        size = ptr - jpeg;
-        ptr -= 2;
-        while (ptr > jpeg) {
-                if (*ptr == 0xFF && *(ptr + 1) == 0xD9
-                    && *(ptr + 2) == 0xFF)
-                        break;
-                ptr--;
-        }
-        if (ptr == jpeg)
-                DBG("No EOI marker");
+        if (in_interrupt())
+                BUG();
 
-        /* Sometimes there is junk data in the middle of the picture,
-         * we want to skip this bogus frames */
-        while (ptr > jpeg) {
-                if (*ptr == 0xFF && *(ptr + 1) == 0xFF
-                    && *(ptr + 2) == 0xFF)
-                        break;
-                ptr--;
+        videobuf_vmalloc_free(&buf->vb);
+        buf->vb.state = VIDEOBUF_NEEDS_INIT;
+}
+
+static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
+                          enum v4l2_field field)
+{
+        struct zr364xx_camera *cam = vq->priv_data;
+        struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
+                                                  vb);
+        int rc;
+
+        DBG("%s, field=%d, fmt name = %s\n", __func__, field, cam->fmt != NULL ?
+            cam->fmt->name : "");
+        if (cam->fmt == NULL)
+                return -EINVAL;
+
+        buf->vb.size = cam->width * cam->height * (cam->fmt->depth >> 3);
+
+        if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size) {
+                DBG("invalid buffer prepare\n");
+                return -EINVAL;
         }
-        if (ptr != jpeg) {
-                DBG("Bogus frame ? %d", cam->nb);
-                goto redo;
+
+        buf->fmt = cam->fmt;
+        buf->vb.width = cam->width;
+        buf->vb.height = cam->height;
+        buf->vb.field = field;
+
+        if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
+                rc = videobuf_iolock(vq, &buf->vb, NULL);
+                if (rc < 0)
+                        goto fail;
         }
 
-        DBG("jpeg : %d %d %d %d %d %d %d %d",
-            jpeg[0], jpeg[1], jpeg[2], jpeg[3],
-            jpeg[4], jpeg[5], jpeg[6], jpeg[7]);
+        buf->vb.state = VIDEOBUF_PREPARED;
+        return 0;
+fail:
+        free_buffer(vq, buf);
+        return rc;
+}
+
+static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
+{
+        struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
+                                                  vb);
+        struct zr364xx_camera *cam = vq->priv_data;
+
+        _DBG("%s\n", __func__);
+
+        buf->vb.state = VIDEOBUF_QUEUED;
+        list_add_tail(&buf->vb.queue, &cam->vidq.active);
+}
+
+static void buffer_release(struct videobuf_queue *vq,
+                           struct videobuf_buffer *vb)
+{
+        struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
+                                                  vb);
 
-        return size;
+        _DBG("%s\n", __func__);
+        free_buffer(vq, buf);
 }
 
+static struct videobuf_queue_ops zr364xx_video_qops = {
+        .buf_setup = buffer_setup,
+        .buf_prepare = buffer_prepare,
+        .buf_queue = buffer_queue,
+        .buf_release = buffer_release,
+};
+
+/********************/
+/* V4L2 integration */
+/********************/
+static int zr364xx_vidioc_streamon(struct file *file, void *priv,
+                                   enum v4l2_buf_type type);
 
-static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t cnt,
+static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
                             loff_t * ppos)
 {
-        unsigned long count = cnt;
-        struct video_device *vdev = video_devdata(file);
-        struct zr364xx_camera *cam;
+        struct zr364xx_camera *cam = video_drvdata(file);
 
-        DBG("zr364xx_read: read %d bytes.", (int) count);
-
-        if (vdev == NULL)
-                return -ENODEV;
-        cam = video_get_drvdata(vdev);
+        _DBG("%s\n", __func__);
 
         if (!buf)
                 return -EINVAL;
@@ -412,21 +477,276 @@ static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t cnt,
         if (!count)
                 return -EINVAL;
 
-        /* NoMan Sux ! */
-        count = read_frame(cam, 0);
+        if (cam->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
+            zr364xx_vidioc_streamon(file, cam, cam->type) == 0) {
+                DBG("%s: reading %d bytes at pos %d.\n", __func__, (int) count,
+                    (int) *ppos);
+
+                /* NoMan Sux ! */
+                return videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
+                                        file->f_flags & O_NONBLOCK);
+        }
+
+        return 0;
+}
+
+/* video buffer vmalloc implementation based partly on VIVI driver which is
+ *          Copyright (c) 2006 by
+ *                  Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
+ *                  Ted Walther <ted--a.t--enumera.com>
+ *                  John Sokol <sokol--a.t--videotechnology.com>
+ *                  http://v4l.videotechnology.com/
+ *
+ */
+static void zr364xx_fillbuff(struct zr364xx_camera *cam,
+                             struct zr364xx_buffer *buf,
+                             int jpgsize)
+{
+        int pos = 0;
+        struct timeval ts;
+        const char *tmpbuf;
+        char *vbuf = videobuf_to_vmalloc(&buf->vb);
+        unsigned long last_frame;
+        struct zr364xx_framei *frm;
+
+        if (!vbuf)
+                return;
+
+        last_frame = cam->last_frame;
+        if (last_frame != -1) {
+                frm = &cam->buffer.frame[last_frame];
+                tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
+                switch (buf->fmt->fourcc) {
+                case V4L2_PIX_FMT_JPEG:
+                        buf->vb.size = jpgsize;
+                        memcpy(vbuf, tmpbuf, buf->vb.size);
+                        break;
+                default:
+                        printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
+                }
+                cam->last_frame = -1;
+        } else {
+                printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
+                return;
+        }
+        DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
+                (unsigned long)vbuf, pos);
+        /* tell v4l buffer was filled */
+
+        buf->vb.field_count = cam->frame_count * 2;
+        do_gettimeofday(&ts);
+        buf->vb.ts = ts;
+        buf->vb.state = VIDEOBUF_DONE;
+}
+
+static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
+{
+        struct zr364xx_dmaqueue *dma_q = &cam->vidq;
+        struct zr364xx_buffer *buf;
+        unsigned long flags = 0;
+        int rc = 0;
+
+        DBG("wakeup: %p\n", &dma_q);
+        spin_lock_irqsave(&cam->slock, flags);
+
+        if (list_empty(&dma_q->active)) {
+                DBG("No active queue to serve\n");
+                rc = -1;
+                goto unlock;
+        }
+        buf = list_entry(dma_q->active.next,
+                         struct zr364xx_buffer, vb.queue);
+
+        if (!waitqueue_active(&buf->vb.done)) {
+                /* no one active */
+                rc = -1;
+                goto unlock;
+        }
+        list_del(&buf->vb.queue);
+        do_gettimeofday(&buf->vb.ts);
+        DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
+        zr364xx_fillbuff(cam, buf, jpgsize);
+        wake_up(&buf->vb.done);
+        DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
+unlock:
+        spin_unlock_irqrestore(&cam->slock, flags);
+        return 0;
+}
+
+/* this function moves the usb stream read pipe data
+ * into the system buffers.
+ * returns 0 on success, EAGAIN if more data to process (call this
+ * function again).
+ */
+static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
+                                        struct zr364xx_pipeinfo *pipe_info,
+                                        struct urb *purb)
+{
+        unsigned char *pdest;
+        unsigned char *psrc;
+        s32 idx = -1;
+        struct zr364xx_framei *frm;
+        int i = 0;
+        unsigned char *ptr = NULL;
+
+        _DBG("buffer to user\n");
+        idx = cam->cur_frame;
+        frm = &cam->buffer.frame[idx];
+
+        /* swap bytes if camera needs it */
+        if (cam->method == METHOD0) {
+                u16 *buf = (u16 *)pipe_info->transfer_buffer;
+                for (i = 0; i < purb->actual_length/2; i++)
+                        swab16s(buf + i);
+        }
+
+        /* search done.  now find out if should be acquiring */
+        if (!cam->b_acquire) {
+                /* we found a frame, but this channel is turned off */
+                frm->ulState = ZR364XX_READ_IDLE;
+                return -EINVAL;
+        }
+
+        psrc = (u8 *)pipe_info->transfer_buffer;
+        ptr = pdest = frm->lpvbits;
+
+        if (frm->ulState == ZR364XX_READ_IDLE) {
+                frm->ulState = ZR364XX_READ_FRAME;
+                frm->cur_size = 0;
+
+                _DBG("jpeg header, ");
+                memcpy(ptr, header1, sizeof(header1));
+                ptr += sizeof(header1);
+                header3 = 0;
+                memcpy(ptr, &header3, 1);
+                ptr++;
+                memcpy(ptr, psrc, 64);
+                ptr += 64;
+                header3 = 1;
+                memcpy(ptr, &header3, 1);
+                ptr++;
+                memcpy(ptr, psrc + 64, 64);
+                ptr += 64;
+                memcpy(ptr, header2, sizeof(header2));
+                ptr += sizeof(header2);
+                memcpy(ptr, psrc + 128,
+                       purb->actual_length - 128);
+                ptr += purb->actual_length - 128;
+                _DBG("header : %d %d %d %d %d %d %d %d %d\n",
+                    psrc[0], psrc[1], psrc[2],
+                    psrc[3], psrc[4], psrc[5],
+                    psrc[6], psrc[7], psrc[8]);
+                frm->cur_size = ptr - pdest;
+        } else {
+                if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
+                        dev_info(&cam->udev->dev,
+                                 "%s: buffer (%d bytes) too small to hold "
+                                 "frame data. Discarding frame data.\n",
+                                 __func__, MAX_FRAME_SIZE);
+                } else {
+                        pdest += frm->cur_size;
+                        memcpy(pdest, psrc, purb->actual_length);
+                        frm->cur_size += purb->actual_length;
+                }
+        }
+        /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
+                purb->actual_length);*/
+
+        if (purb->actual_length < pipe_info->transfer_size) {
+                _DBG("****************Buffer[%d]full*************\n", idx);
+                cam->last_frame = cam->cur_frame;
+                cam->cur_frame++;
+                /* end of system frame ring buffer, start at zero */
+                if (cam->cur_frame == cam->buffer.dwFrames)
+                        cam->cur_frame = 0;
+
+                /* frame ready */
+                /* go back to find the JPEG EOI marker */
+                ptr = pdest = frm->lpvbits;
+                ptr += frm->cur_size - 2;
+                while (ptr > pdest) {
+                        if (*ptr == 0xFF && *(ptr + 1) == 0xD9
+                            && *(ptr + 2) == 0xFF)
+                                break;
+                        ptr--;
+                }
+                if (ptr == pdest)
+                        DBG("No EOI marker\n");
+
+                /* Sometimes there is junk data in the middle of the picture,
+                 * we want to skip this bogus frames */
+                while (ptr > pdest) {
+                        if (*ptr == 0xFF && *(ptr + 1) == 0xFF
+                            && *(ptr + 2) == 0xFF)
+                                break;
+                        ptr--;
+                }
+                if (ptr != pdest) {
+                        DBG("Bogus frame ? %d\n", ++(cam->nb));
+                } else if (cam->b_acquire) {
+                        /* we skip the 2 first frames which are usually buggy */
+                        if (cam->skip)
+                                cam->skip--;
+                        else {
+                                _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
+                                    frm->cur_size,
+                                    pdest[0], pdest[1], pdest[2], pdest[3],
+                                    pdest[4], pdest[5], pdest[6], pdest[7]);
+
+                                zr364xx_got_frame(cam, frm->cur_size);
+                        }
+                }
+                cam->frame_count++;
+                frm->ulState = ZR364XX_READ_IDLE;
+                frm->cur_size = 0;
+        }
+        /* done successfully */
+        return 0;
+}
 
-        if (copy_to_user(buf, cam->framebuf, count))
-                return -EFAULT;
+static int res_get(struct zr364xx_camera *cam)
+{
+        /* is it free? */
+        mutex_lock(&cam->lock);
+        if (cam->resources) {
+                /* no, someone else uses it */
+                mutex_unlock(&cam->lock);
+                return 0;
+        }
+        /* it's free, grab it */
+        cam->resources = 1;
+        _DBG("res: get\n");
+        mutex_unlock(&cam->lock);
+        return 1;
+}
 
-        return count;
+static inline int res_check(struct zr364xx_camera *cam)
+{
+        return cam->resources;
 }
 
+static void res_free(struct zr364xx_camera *cam)
+{
+        mutex_lock(&cam->lock);
+        cam->resources = 0;
+        mutex_unlock(&cam->lock);
+        _DBG("res: put\n");
+}
 
 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
                                    struct v4l2_capability *cap)
 {
-        strcpy(cap->driver, DRIVER_DESC);
-        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
+        struct zr364xx_camera *cam = video_drvdata(file);
+
+        strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
+        strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
+        strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
+                sizeof(cap->bus_info));
+        cap->version = ZR364XX_VERSION_CODE;
+        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
+                            V4L2_CAP_READWRITE |
+                            V4L2_CAP_STREAMING;
+
         return 0;
 }
 
@@ -458,12 +778,11 @@ static int zr364xx_vidioc_s_input(struct file *file, void *priv,
 static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
                                     struct v4l2_queryctrl *c)
 {
-        struct video_device *vdev = video_devdata(file);
         struct zr364xx_camera *cam;
 
-        if (vdev == NULL)
+        if (file == NULL)
                 return -ENODEV;
-        cam = video_get_drvdata(vdev);
+        cam = video_drvdata(file);
 
         switch (c->id) {
         case V4L2_CID_BRIGHTNESS:
@@ -472,7 +791,7 @@ static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
                 c->minimum = 0;
                 c->maximum = 127;
                 c->step = 1;
-                c->default_value = cam->brightness;
+                c->default_value = cam->mode.brightness;
                 c->flags = 0;
                 break;
         default:
@@ -484,36 +803,42 @@ static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
 static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
                                  struct v4l2_control *c)
 {
-        struct video_device *vdev = video_devdata(file);
         struct zr364xx_camera *cam;
+        int temp;
 
-        if (vdev == NULL)
+        if (file == NULL)
                 return -ENODEV;
-        cam = video_get_drvdata(vdev);
+        cam = video_drvdata(file);
 
         switch (c->id) {
         case V4L2_CID_BRIGHTNESS:
-                cam->brightness = c->value;
+                cam->mode.brightness = c->value;
+                /* hardware brightness */
+                mutex_lock(&cam->lock);
+                send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
+                temp = (0x60 << 8) + 127 - cam->mode.brightness;
+                send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
+                mutex_unlock(&cam->lock);
                 break;
         default:
                 return -EINVAL;
         }
+
         return 0;
 }
 
 static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
                                  struct v4l2_control *c)
 {
-        struct video_device *vdev = video_devdata(file);
         struct zr364xx_camera *cam;
 
-        if (vdev == NULL)
+        if (file == NULL)
                 return -ENODEV;
-        cam = video_get_drvdata(vdev);
+        cam = video_drvdata(file);
 
         switch (c->id) {
         case V4L2_CID_BRIGHTNESS:
-                c->value = cam->brightness;
+                c->value = cam->mode.brightness;
                 break;
         default:
                 return -EINVAL;
@@ -527,47 +852,63 @@ static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
         if (f->index > 0)
                 return -EINVAL;
         f->flags = V4L2_FMT_FLAG_COMPRESSED;
-        strcpy(f->description, "JPEG");
-        f->pixelformat = V4L2_PIX_FMT_JPEG;
+        strcpy(f->description, formats[0].name);
+        f->pixelformat = formats[0].fourcc;
         return 0;
 }
 
+static char *decode_fourcc(__u32 pixelformat, char *buf)
+{
+        buf[0] = pixelformat & 0xff;
+        buf[1] = (pixelformat >> 8) & 0xff;
+        buf[2] = (pixelformat >> 16) & 0xff;
+        buf[3] = (pixelformat >> 24) & 0xff;
+        buf[4] = '\0';
+        return buf;
+}
+
 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                                       struct v4l2_format *f)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct zr364xx_camera *cam;
+        struct zr364xx_camera *cam = video_drvdata(file);
+        char pixelformat_name[5];
 
-        if (vdev == NULL)
+        if (cam == NULL)
                 return -ENODEV;
-        cam = video_get_drvdata(vdev);
 
-        if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
-                return -EINVAL;
-        if (f->fmt.pix.field != V4L2_FIELD_ANY &&
-            f->fmt.pix.field != V4L2_FIELD_NONE)
+        if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
+                DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
+                    decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
                 return -EINVAL;
+        }
+
+        if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
+            !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
+                f->fmt.pix.width = 320;
+                f->fmt.pix.height = 240;
+        }
+
         f->fmt.pix.field = V4L2_FIELD_NONE;
-        f->fmt.pix.width = cam->width;
-        f->fmt.pix.height = cam->height;
         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
         f->fmt.pix.colorspace = 0;
         f->fmt.pix.priv = 0;
+        DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
+            decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
+            f->fmt.pix.field);
         return 0;
 }
 
 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
                                     struct v4l2_format *f)
 {
-        struct video_device *vdev = video_devdata(file);
         struct zr364xx_camera *cam;
 
-        if (vdev == NULL)
+        if (file == NULL)
                 return -ENODEV;
-        cam = video_get_drvdata(vdev);
+        cam = video_drvdata(file);
 
-        f->fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
+        f->fmt.pix.pixelformat = formats[0].fourcc;
         f->fmt.pix.field = V4L2_FIELD_NONE;
         f->fmt.pix.width = cam->width;
         f->fmt.pix.height = cam->height;
@@ -581,38 +922,327 @@ static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                                     struct v4l2_format *f)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct zr364xx_camera *cam;
+        struct zr364xx_camera *cam = video_drvdata(file);
+        struct videobuf_queue *q = &cam->vb_vidq;
+        char pixelformat_name[5];
+        int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
+        int i;
 
-        if (vdev == NULL)
-                return -ENODEV;
-        cam = video_get_drvdata(vdev);
+        if (ret < 0)
+                return ret;
 
-        if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
-                return -EINVAL;
-        if (f->fmt.pix.field != V4L2_FIELD_ANY &&
-            f->fmt.pix.field != V4L2_FIELD_NONE)
-                return -EINVAL;
-        f->fmt.pix.field = V4L2_FIELD_NONE;
-        f->fmt.pix.width = cam->width;
-        f->fmt.pix.height = cam->height;
+        mutex_lock(&q->vb_lock);
+
+        if (videobuf_queue_is_busy(&cam->vb_vidq)) {
+                DBG("%s queue busy\n", __func__);
+                ret = -EBUSY;
+                goto out;
+        }
+
+        if (res_check(cam)) {
+                DBG("%s can't change format after started\n", __func__);
+                ret = -EBUSY;
+                goto out;
+        }
+
+        cam->width = f->fmt.pix.width;
+        cam->height = f->fmt.pix.height;
+        dev_info(&cam->udev->dev, "%s: %dx%d mode selected\n", __func__,
+                 cam->width, cam->height);
         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
         f->fmt.pix.colorspace = 0;
         f->fmt.pix.priv = 0;
-        DBG("ok!");
+        cam->vb_vidq.field = f->fmt.pix.field;
+        cam->mode.color = V4L2_PIX_FMT_JPEG;
+
+        if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
+                mode = 1;
+        else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
+                mode = 2;
+        else
+                mode = 0;
+
+        m0d1[0] = mode;
+        m1[2].value = 0xf000 + mode;
+        m2[1].value = 0xf000 + mode;
+        header2[437] = cam->height / 256;
+        header2[438] = cam->height % 256;
+        header2[439] = cam->width / 256;
+        header2[440] = cam->width % 256;
+
+        for (i = 0; init[cam->method][i].size != -1; i++) {
+                ret =
+                    send_control_msg(cam->udev, 1, init[cam->method][i].value,
+                                     0, init[cam->method][i].bytes,
+                                     init[cam->method][i].size);
+                if (ret < 0) {
+                        dev_err(&cam->udev->dev,
+                           "error during resolution change sequence: %d\n", i);
+                        goto out;
+                }
+        }
+
+        /* Added some delay here, since opening/closing the camera quickly,
+         * like Ekiga does during its startup, can crash the webcam
+         */
+        mdelay(100);
+        cam->skip = 2;
+        ret = 0;
+
+out:
+        mutex_unlock(&q->vb_lock);
+
+        DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
+            decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
+            f->fmt.pix.field);
+        return ret;
+}
+
+static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
+                          struct v4l2_requestbuffers *p)
+{
+        int rc;
+        struct zr364xx_camera *cam = video_drvdata(file);
+        rc = videobuf_reqbufs(&cam->vb_vidq, p);
+        return rc;
+}
+
+static int zr364xx_vidioc_querybuf(struct file *file,
+                                void *priv,
+                                struct v4l2_buffer *p)
+{
+        int rc;
+        struct zr364xx_camera *cam = video_drvdata(file);
+        rc = videobuf_querybuf(&cam->vb_vidq, p);
+        return rc;
+}
+
+static int zr364xx_vidioc_qbuf(struct file *file,
+                                void *priv,
+                                struct v4l2_buffer *p)
+{
+        int rc;
+        struct zr364xx_camera *cam = video_drvdata(file);
+        _DBG("%s\n", __func__);
+        rc = videobuf_qbuf(&cam->vb_vidq, p);
+        return rc;
+}
+
+static int zr364xx_vidioc_dqbuf(struct file *file,
+                                void *priv,
+                                struct v4l2_buffer *p)
+{
+        int rc;
+        struct zr364xx_camera *cam = video_drvdata(file);
+        _DBG("%s\n", __func__);
+        rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
+        return rc;
+}
+
+static void read_pipe_completion(struct urb *purb)
+{
+        struct zr364xx_pipeinfo *pipe_info;
+        struct zr364xx_camera *cam;
+        int pipe;
+
+        pipe_info = purb->context;
+        _DBG("%s %p, status %d\n", __func__, purb, purb->status);
+        if (pipe_info == NULL) {
+                printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
+                return;
+        }
+
+        cam = pipe_info->cam;
+        if (cam == NULL) {
+                printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
+                return;
+        }
+
+        /* if shutting down, do not resubmit, exit immediately */
+        if (purb->status == -ESHUTDOWN) {
+                DBG("%s, err shutdown\n", __func__);
+                pipe_info->err_count++;
+                return;
+        }
+
+        if (pipe_info->state == 0) {
+                DBG("exiting USB pipe\n");
+                return;
+        }
+
+        if (purb->actual_length < 0 ||
+            purb->actual_length > pipe_info->transfer_size) {
+                dev_err(&cam->udev->dev, "wrong number of bytes\n");
+                return;
+        }
+
+        if (purb->status == 0)
+                zr364xx_read_video_callback(cam, pipe_info, purb);
+        else {
+                pipe_info->err_count++;
+                DBG("%s: failed URB %d\n", __func__, purb->status);
+        }
+
+        pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
+
+        /* reuse urb */
+        usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
+                          pipe,
+                          pipe_info->transfer_buffer,
+                          pipe_info->transfer_size,
+                          read_pipe_completion, pipe_info);
+
+        if (pipe_info->state != 0) {
+                purb->status = usb_submit_urb(pipe_info->stream_urb,
+                                              GFP_ATOMIC);
+
+                if (purb->status)
+                        dev_err(&cam->udev->dev,
+                                "error submitting urb (error=%i)\n",
+                                purb->status);
+        } else
+                DBG("read pipe complete state 0\n");
+}
+
+static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
+{
+        int pipe;
+        int retval;
+        struct zr364xx_pipeinfo *pipe_info = cam->pipe;
+        pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
+        DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
+
+        pipe_info->state = 1;
+        pipe_info->err_count = 0;
+        pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!pipe_info->stream_urb) {
+                dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
+                return -ENOMEM;
+        }
+        /* transfer buffer allocated in board_init */
+        usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
+                          pipe,
+                          pipe_info->transfer_buffer,
+                          pipe_info->transfer_size,
+                          read_pipe_completion, pipe_info);
+
+        DBG("submitting URB %p\n", pipe_info->stream_urb);
+        retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
+        if (retval) {
+                printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
+                return retval;
+        }
+
+        return 0;
+}
+
+static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
+{
+        struct zr364xx_pipeinfo *pipe_info;
+
+        if (cam == NULL) {
+                printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
+                return;
+        }
+        DBG("stop read pipe\n");
+        pipe_info = cam->pipe;
+        if (pipe_info) {
+                if (pipe_info->state != 0)
+                        pipe_info->state = 0;
+
+                if (pipe_info->stream_urb) {
+                        /* cancel urb */
+                        usb_kill_urb(pipe_info->stream_urb);
+                        usb_free_urb(pipe_info->stream_urb);
+                        pipe_info->stream_urb = NULL;
+                }
+        }
+        return;
+}
+
+/* starts acquisition process */
+static int zr364xx_start_acquire(struct zr364xx_camera *cam)
+{
+        int j;
+
+        DBG("start acquire\n");
+
+        cam->last_frame = -1;
+        cam->cur_frame = 0;
+        for (j = 0; j < FRAMES; j++) {
+                cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
+                cam->buffer.frame[j].cur_size = 0;
+        }
+        cam->b_acquire = 1;
+        return 0;
+}
+
+static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
+{
+        cam->b_acquire = 0;
         return 0;
 }
 
 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
                                    enum v4l2_buf_type type)
 {
-        return 0;
+        struct zr364xx_camera *cam = video_drvdata(file);
+        int j;
+        int res;
+
+        DBG("%s\n", __func__);
+
+        if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                dev_err(&cam->udev->dev, "invalid fh type0\n");
+                return -EINVAL;
+        }
+        if (cam->type != type) {
+                dev_err(&cam->udev->dev, "invalid fh type1\n");
+                return -EINVAL;
+        }
+
+        if (!res_get(cam)) {
+                dev_err(&cam->udev->dev, "stream busy\n");
+                return -EBUSY;
+        }
+
+        cam->last_frame = -1;
+        cam->cur_frame = 0;
+        cam->frame_count = 0;
+        for (j = 0; j < FRAMES; j++) {
+                cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
+                cam->buffer.frame[j].cur_size = 0;
+        }
+        res = videobuf_streamon(&cam->vb_vidq);
+        if (res == 0) {
+                zr364xx_start_acquire(cam);
+        } else {
+                res_free(cam);
+        }
+        return res;
 }
 
 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
                                     enum v4l2_buf_type type)
 {
+        int res;
+        struct zr364xx_camera *cam = video_drvdata(file);
+
+        DBG("%s\n", __func__);
+        if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                dev_err(&cam->udev->dev, "invalid fh type0\n");
+                return -EINVAL;
+        }
+        if (cam->type != type) {
+                dev_err(&cam->udev->dev, "invalid fh type1\n");
+                return -EINVAL;
+        }
+        zr364xx_stop_acquire(cam);
+        res = videobuf_streamoff(&cam->vb_vidq);
+        if (res < 0)
+                return res;
+        res_free(cam);
         return 0;
 }
 
@@ -621,28 +1251,19 @@ static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
 static int zr364xx_open(struct file *file)
 {
         struct video_device *vdev = video_devdata(file);
-        struct zr364xx_camera *cam = video_get_drvdata(vdev);
+        struct zr364xx_camera *cam = video_drvdata(file);
         struct usb_device *udev = cam->udev;
         int i, err;
 
-        DBG("zr364xx_open");
+        DBG("%s\n", __func__);
 
-        mutex_lock(&cam->lock);
+        mutex_lock(&cam->open_lock);
 
         if (cam->users) {
                 err = -EBUSY;
                 goto out;
         }
 
-        if (!cam->framebuf) {
-                cam->framebuf = vmalloc_32(MAX_FRAME_SIZE * FRAMES);
-                if (!cam->framebuf) {
-                        dev_err(&cam->udev->dev, "vmalloc_32 failed!\n");
-                        err = -ENOMEM;
-                        goto out;
-                }
-        }
-
         for (i = 0; init[cam->method][i].size != -1; i++) {
                 err =
                     send_control_msg(udev, 1, init[cam->method][i].value,
@@ -658,6 +1279,14 @@ static int zr364xx_open(struct file *file)
         cam->skip = 2;
         cam->users++;
         file->private_data = vdev;
+        cam->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        cam->fmt = formats;
+
+        videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
+                                    NULL, &cam->slock,
+                                    cam->type,
+                                    V4L2_FIELD_NONE,
+                                    sizeof(struct zr364xx_buffer), cam);
 
         /* Added some delay here, since opening/closing the camera quickly,
          * like Ekiga does during its startup, can crash the webcam
@@ -666,28 +1295,70 @@ static int zr364xx_open(struct file *file)
         err = 0;
 
 out:
-        mutex_unlock(&cam->lock);
+        mutex_unlock(&cam->open_lock);
+        DBG("%s: %d\n", __func__, err);
         return err;
 }
 
+static void zr364xx_destroy(struct zr364xx_camera *cam)
+{
+        unsigned long i;
+
+        if (!cam) {
+                printk(KERN_ERR KBUILD_MODNAME ", %s: no device\n", __func__);
+                return;
+        }
+        mutex_lock(&cam->open_lock);
+        if (cam->vdev)
+                video_unregister_device(cam->vdev);
+        cam->vdev = NULL;
+
+        /* stops the read pipe if it is running */
+        if (cam->b_acquire)
+                zr364xx_stop_acquire(cam);
+
+        zr364xx_stop_readpipe(cam);
+
+        /* release sys buffers */
+        for (i = 0; i < FRAMES; i++) {
+                if (cam->buffer.frame[i].lpvbits) {
+                        DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
+                        vfree(cam->buffer.frame[i].lpvbits);
+                }
+                cam->buffer.frame[i].lpvbits = NULL;
+        }
+
+        /* release transfer buffer */
+        kfree(cam->pipe->transfer_buffer);
+        cam->pipe->transfer_buffer = NULL;
+        mutex_unlock(&cam->open_lock);
+        kfree(cam);
+        cam = NULL;
+}
 
 /* release the camera */
 static int zr364xx_release(struct file *file)
 {
-        struct video_device *vdev = video_devdata(file);
         struct zr364xx_camera *cam;
         struct usb_device *udev;
         int i, err;
 
-        DBG("zr364xx_release");
+        DBG("%s\n", __func__);
+        cam = video_drvdata(file);
 
-        if (vdev == NULL)
+        if (!cam)
                 return -ENODEV;
-        cam = video_get_drvdata(vdev);
 
+        mutex_lock(&cam->open_lock);
         udev = cam->udev;
 
-        mutex_lock(&cam->lock);
+        /* turn off stream */
+        if (res_check(cam)) {
+                if (cam->b_acquire)
+                        zr364xx_stop_acquire(cam);
+                videobuf_streamoff(&cam->vb_vidq);
+                res_free(cam);
+        }
 
         cam->users--;
         file->private_data = NULL;
@@ -710,40 +1381,43 @@ static int zr364xx_release(struct file *file)
         err = 0;
 
 out:
-        mutex_unlock(&cam->lock);
+        mutex_unlock(&cam->open_lock);
+
         return err;
 }
 
 
 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        void *pos;
-        unsigned long start = vma->vm_start;
-        unsigned long size = vma->vm_end - vma->vm_start;
-        struct video_device *vdev = video_devdata(file);
-        struct zr364xx_camera *cam;
-
-        DBG("zr364xx_mmap: %ld\n", size);
+        struct zr364xx_camera *cam = video_drvdata(file);
+        int ret;
 
-        if (vdev == NULL)
+        if (cam == NULL) {
+                DBG("%s: cam == NULL\n", __func__);
                 return -ENODEV;
-        cam = video_get_drvdata(vdev);
-
-        pos = cam->framebuf;
-        while (size > 0) {
-                if (vm_insert_page(vma, start, vmalloc_to_page(pos)))
-                        return -EAGAIN;
-                start += PAGE_SIZE;
-                pos += PAGE_SIZE;
-                if (size > PAGE_SIZE)
-                        size -= PAGE_SIZE;
-                else
-                        size = 0;
         }
+        DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
 
-        return 0;
+        ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
+
+        DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
+                (unsigned long)vma->vm_start,
+                (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
+        return ret;
 }
 
+static unsigned int zr364xx_poll(struct file *file,
+                               struct poll_table_struct *wait)
+{
+        struct zr364xx_camera *cam = video_drvdata(file);
+        struct videobuf_queue *q = &cam->vb_vidq;
+        _DBG("%s\n", __func__);
+
+        if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return POLLERR;
+
+        return videobuf_poll_stream(file, q, wait);
+}
 
 static const struct v4l2_file_operations zr364xx_fops = {
         .owner = THIS_MODULE,
@@ -752,6 +1426,7 @@ static const struct v4l2_file_operations zr364xx_fops = {
         .read = zr364xx_read,
         .mmap = zr364xx_mmap,
         .ioctl = video_ioctl2,
+        .poll = zr364xx_poll,
 };
 
 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
@@ -768,6 +1443,10 @@ static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
         .vidioc_queryctrl       = zr364xx_vidioc_queryctrl,
         .vidioc_g_ctrl          = zr364xx_vidioc_g_ctrl,
         .vidioc_s_ctrl          = zr364xx_vidioc_s_ctrl,
+        .vidioc_reqbufs         = zr364xx_vidioc_reqbufs,
+        .vidioc_querybuf        = zr364xx_vidioc_querybuf,
+        .vidioc_qbuf            = zr364xx_vidioc_qbuf,
+        .vidioc_dqbuf           = zr364xx_vidioc_dqbuf,
 };
 
 static struct video_device zr364xx_template = {
@@ -783,15 +1462,76 @@ static struct video_device zr364xx_template = {
 /*******************/
 /* USB integration */
 /*******************/
+static int zr364xx_board_init(struct zr364xx_camera *cam)
+{
+        struct zr364xx_pipeinfo *pipe = cam->pipe;
+        unsigned long i;
+
+        DBG("board init: %p\n", cam);
+        memset(pipe, 0, sizeof(*pipe));
+        pipe->cam = cam;
+        pipe->transfer_size = BUFFER_SIZE;
+
+        pipe->transfer_buffer = kzalloc(pipe->transfer_size,
+                                        GFP_KERNEL);
+        if (pipe->transfer_buffer == NULL) {
+                DBG("out of memory!\n");
+                return -ENOMEM;
+        }
+
+        cam->b_acquire = 0;
+        cam->frame_count = 0;
+
+        /*** start create system buffers ***/
+        for (i = 0; i < FRAMES; i++) {
+                /* always allocate maximum size for system buffers */
+                cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
+
+                DBG("valloc %p, idx %lu, pdata %p\n",
+                        &cam->buffer.frame[i], i,
+                        cam->buffer.frame[i].lpvbits);
+                if (cam->buffer.frame[i].lpvbits == NULL) {
+                        printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
+                               "Using less frames\n");
+                        break;
+                }
+        }
+
+        if (i == 0) {
+                printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
+                kfree(cam->pipe->transfer_buffer);
+                cam->pipe->transfer_buffer = NULL;
+                return -ENOMEM;
+        } else
+                cam->buffer.dwFrames = i;
+
+        /* make sure internal states are set */
+        for (i = 0; i < FRAMES; i++) {
+                cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
+                cam->buffer.frame[i].cur_size = 0;
+        }
+
+        cam->cur_frame = 0;
+        cam->last_frame = -1;
+        /*** end create system buffers ***/
+
+        /* start read pipe */
+        zr364xx_start_readpipe(cam);
+        DBG(": board initialized\n");
+        return 0;
+}
 
 static int zr364xx_probe(struct usb_interface *intf,
                          const struct usb_device_id *id)
 {
         struct usb_device *udev = interface_to_usbdev(intf);
         struct zr364xx_camera *cam = NULL;
+        struct usb_host_interface *iface_desc;
+        struct usb_endpoint_descriptor *endpoint;
         int err;
+        int i;
 
-        DBG("probing...");
+        DBG("probing...\n");
 
         dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
         dev_info(&intf->dev, "model %04x:%04x detected\n",
@@ -810,22 +1550,17 @@ static int zr364xx_probe(struct usb_interface *intf,
         if (cam->vdev == NULL) {
                 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
                 kfree(cam);
+                cam = NULL;
                 return -ENOMEM;
         }
         memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
+        cam->vdev->parent = &intf->dev;
         video_set_drvdata(cam->vdev, cam);
         if (debug)
                 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
 
         cam->udev = udev;
 
-        if ((cam->buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL)) == NULL) {
-                dev_info(&udev->dev, "cam->buffer: out of memory !\n");
-                video_device_release(cam->vdev);
-                kfree(cam);
-                return -ENODEV;
-        }
-
         switch (mode) {
         case 1:
                 dev_info(&udev->dev, "160x120 mode selected\n");
@@ -852,21 +1587,53 @@ static int zr364xx_probe(struct usb_interface *intf,
         header2[439] = cam->width / 256;
         header2[440] = cam->width % 256;
 
+        cam->users = 0;
         cam->nb = 0;
-        cam->brightness = 64;
+        cam->mode.brightness = 64;
         mutex_init(&cam->lock);
+        mutex_init(&cam->open_lock);
+
+        DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
+
+        /* set up the endpoint information  */
+        iface_desc = intf->cur_altsetting;
+        DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
+        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
+                endpoint = &iface_desc->endpoint[i].desc;
+                if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
+                        /* we found the bulk in endpoint */
+                        cam->read_endpoint = endpoint->bEndpointAddress;
+                }
+        }
+
+        if (!cam->read_endpoint) {
+                dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
+                return -ENOMEM;
+        }
 
+        /* v4l */
+        INIT_LIST_HEAD(&cam->vidq.active);
+        cam->vidq.cam = cam;
         err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
         if (err) {
                 dev_err(&udev->dev, "video_register_device failed\n");
                 video_device_release(cam->vdev);
-                kfree(cam->buffer);
                 kfree(cam);
+                cam = NULL;
                 return err;
         }
 
         usb_set_intfdata(intf, cam);
 
+        /* load zr364xx board specific */
+        err = zr364xx_board_init(cam);
+        if (err) {
+                spin_lock_init(&cam->slock);
+                return err;
+        }
+
+        spin_lock_init(&cam->slock);
+
         dev_info(&udev->dev, DRIVER_DESC " controlling video device %d\n",
                  cam->vdev->num);
         return 0;
@@ -876,17 +1643,10 @@ static int zr364xx_probe(struct usb_interface *intf,
 static void zr364xx_disconnect(struct usb_interface *intf)
 {
         struct zr364xx_camera *cam = usb_get_intfdata(intf);
+        videobuf_mmap_free(&cam->vb_vidq);
         usb_set_intfdata(intf, NULL);
         dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
-        if (cam->vdev)
-                video_unregister_device(cam->vdev);
-        cam->vdev = NULL;
-        kfree(cam->buffer);
-        cam->buffer = NULL;
-        vfree(cam->framebuf);
-        cam->framebuf = NULL;
-        kfree(cam);
-        cam = NULL;
+        zr364xx_destroy(cam);
 }