Merge branch 'v4l_for_2.6.35' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6

* 'v4l_for_2.6.35' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6: (243 commits)
  V4L/DVB: sms: Convert IR support to use the Remote Controller core
  V4L/DVB: sms: properly initialize IR phys and IR name
  V4L/DVB: standardize names at rc-dib0700 tables
  V4L/DVB: smsusb: enable IR port for Hauppauge WinTV MiniStick
  V4L/DVB: dib0700: Fix RC protocol logic to properly handle NEC/NECx and RC-5
  V4L/DVB: dib0700: properly implement IR change_protocol
  V4L/DVB: dib0700: break keytable into NEC and RC-5 variants
  V4L/DVB: dib0700: avoid bad repeat
  V4L/DVB: Port dib0700 to rc-core
  V4L/DVB: Add a keymap file with dib0700 table
  V4L/DVB: dvb-usb: add support for rc-core mode
  V4L/DVB: dvb-usb: prepare drivers for using rc-core
  V4L/DVB: dvb-usb: get rid of struct dvb_usb_rc_key
  V4L/DVB: rj54n1cb0c: fix a comment in the driver
  V4L/DVB: V4L2: sh_vou: VOU does support the full PAL resolution too
  V4L/DVB: V4L2: sh_mobile_camera_ceu: add support for CSI2
  V4L/DVB: V4L2: soc-camera: add a MIPI CSI-2 driver for SH-Mobile platforms
  V4L/DVB: V4L2: soc-camera: export soc-camera bus type for notifications
  V4L/DVB: V4L2: mediabus: add 12-bit Bayer and YUV420 pixel formats
  V4L/DVB: mediabus: fix ambiguous pixel code names
  ...

1 files changed, 217 insertions, 191 deletions

diff --git a/drivers/media/video/gspca/t613.c b/drivers/media/video/gspca/t613.c
index 63014372adbc..2a0f12d55e48 100644
--- a/drivers/media/video/gspca/t613.c
+++ b/drivers/media/video/gspca/t613.c
@@ -1,5 +1,7 @@
 /*
- * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
+ * T613 subdriver
+ *
+ * Copyright (C) 2010 Jean-Francois Moine (http://moinejf.free.fr)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -26,6 +28,7 @@
 
 #define MODULE_NAME "t613"
 
+#include <linux/slab.h>
 #include "gspca.h"
 
 #define V4L2_CID_EFFECTS (V4L2_CID_PRIVATE_BASE + 0)
@@ -44,18 +47,20 @@ struct sd {
         u8 gamma;
         u8 sharpness;
         u8 freq;
-        u8 red_balance; /* split balance */
-        u8 blue_balance;
-        u8 global_gain; /* aka gain */
-        u8 whitebalance; /* set default r/g/b and activate */
+        u8 red_gain;
+        u8 blue_gain;
+        u8 green_gain;
+        u8 awb; /* set default r/g/b and activate */
         u8 mirror;
         u8 effect;
 
         u8 sensor;
-#define SENSOR_OM6802 0
-#define SENSOR_OTHER 1
-#define SENSOR_TAS5130A 2
-#define SENSOR_LT168G 3     /* must verify if this is the actual model */
+enum {
+        SENSOR_OM6802,
+        SENSOR_OTHER,
+        SENSOR_TAS5130A,
+        SENSOR_LT168G,          /* must verify if this is the actual model */
+} sensors;
 };
 
 /* V4L2 controls supported by the driver */
@@ -74,24 +79,22 @@ static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 
-
-static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val);
-static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val);
-static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val);
-static int sd_setglobal_gain(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getglobal_gain(struct gspca_dev *gspca_dev, __s32 *val);
-
-static int sd_setflip(struct gspca_dev *gspca_dev, __s32 val);
-static int sd_getflip(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setawb(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getawb(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setblue_gain(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getblue_gain(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setred_gain(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getred_gain(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
+
+static int sd_setmirror(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getmirror(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_querymenu(struct gspca_dev *gspca_dev,
                         struct v4l2_querymenu *menu);
 
-
 static const struct ctrl sd_ctrls[] = {
         {
          {
@@ -177,8 +180,8 @@ static const struct ctrl sd_ctrls[] = {
 #define MIRROR_DEF 0
           .default_value = MIRROR_DEF,
           },
-         .set = sd_setflip,
-         .get = sd_getflip
+         .set = sd_setmirror,
+         .get = sd_getmirror
         },
         {
          {
@@ -198,15 +201,15 @@ static const struct ctrl sd_ctrls[] = {
          {
           .id =  V4L2_CID_AUTO_WHITE_BALANCE,
           .type = V4L2_CTRL_TYPE_INTEGER,
-          .name = "White Balance",
+          .name = "Auto White Balance",
           .minimum = 0,
           .maximum = 1,
           .step = 1,
-#define WHITE_BALANCE_DEF 0
-          .default_value = WHITE_BALANCE_DEF,
+#define AWB_DEF 0
+          .default_value = AWB_DEF,
           },
-         .set = sd_setwhitebalance,
-         .get = sd_getwhitebalance
+         .set = sd_setawb,
+         .get = sd_getawb
         },
         {
          {
@@ -244,11 +247,11 @@ static const struct ctrl sd_ctrls[] = {
             .minimum = 0x10,
             .maximum = 0x40,
             .step    = 1,
-#define BLUE_BALANCE_DEF 0x20
-            .default_value = BLUE_BALANCE_DEF,
+#define BLUE_GAIN_DEF 0x20
+            .default_value = BLUE_GAIN_DEF,
          },
-        .set = sd_setblue_balance,
-        .get = sd_getblue_balance,
+        .set = sd_setblue_gain,
+        .get = sd_getblue_gain,
         },
         {
          {
@@ -258,11 +261,11 @@ static const struct ctrl sd_ctrls[] = {
             .minimum = 0x10,
             .maximum = 0x40,
             .step    = 1,
-#define RED_BALANCE_DEF 0x20
-            .default_value = RED_BALANCE_DEF,
+#define RED_GAIN_DEF 0x20
+            .default_value = RED_GAIN_DEF,
          },
-        .set = sd_setred_balance,
-        .get = sd_getred_balance,
+        .set = sd_setred_gain,
+        .get = sd_getred_gain,
         },
         {
          {
@@ -272,24 +275,14 @@ static const struct ctrl sd_ctrls[] = {
             .minimum = 0x10,
             .maximum = 0x40,
             .step    = 1,
-#define global_gain_DEF  0x20
-            .default_value = global_gain_DEF,
+#define GAIN_DEF  0x20
+            .default_value = GAIN_DEF,
          },
-        .set = sd_setglobal_gain,
-        .get = sd_getglobal_gain,
+        .set = sd_setgain,
+        .get = sd_getgain,
         },
 };
 
-static char *effects_control[] = {
-        "Normal",
-        "Emboss",               /* disabled */
-        "Monochrome",
-        "Sepia",
-        "Sketch",
-        "Sun Effect",           /* disabled */
-        "Negative",
-};
-
 static const struct v4l2_pix_format vga_mode_t16[] = {
         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
                 .bytesperline = 160,
@@ -327,7 +320,6 @@ struct additional_sensor_data {
         const u8 data1[10];
         const u8 data2[9];
         const u8 data3[9];
-        const u8 data4[4];
         const u8 data5[6];
         const u8 stream[4];
 };
@@ -375,7 +367,7 @@ static const u8 n4_lt168g[] = {
 };
 
 static const struct additional_sensor_data sensor_data[] = {
-    {                           /* 0: OM6802 */
+[SENSOR_OM6802] = {
         .n3 =
                 {0x61, 0x68, 0x65, 0x0a, 0x60, 0x04},
         .n4 = n4_om6802,
@@ -392,14 +384,12 @@ static const struct additional_sensor_data sensor_data[] = {
         .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 */
                 {0x0c, 0x03, 0xab, 0x13, 0x81, 0x23},
         .stream =
                 {0x0b, 0x04, 0x0a, 0x78},
     },
-    {                           /* 1: OTHER */
+[SENSOR_OTHER] = {
         .n3 =
                 {0x61, 0xc2, 0x65, 0x88, 0x60, 0x00},
         .n4 = n4_other,
@@ -416,14 +406,12 @@ static const struct additional_sensor_data sensor_data[] = {
         .data3 =
                 {0x4e, 0x9c, 0xec, 0x40, 0x80, 0xc0, 0x48, 0x96,
                  0xd9},
-        .data4 =
-                {0x66, 0x00, 0xa8, 0xa8},
         .data5 =
                 {0x0c, 0x03, 0xab, 0x29, 0x81, 0x69},
         .stream =
                 {0x0b, 0x04, 0x0a, 0x00},
     },
-    {                           /* 2: TAS5130A */
+[SENSOR_TAS5130A] = {
         .n3 =
                 {0x61, 0xc2, 0x65, 0x0d, 0x60, 0x08},
         .n4 = n4_tas5130a,
@@ -440,14 +428,12 @@ static const struct additional_sensor_data sensor_data[] = {
         .data3 =
                 {0x60, 0xa8, 0xe0, 0x60, 0xa8, 0xe0, 0x60, 0xa8,
                  0xe0},
-        .data4 =        /* Freq (50/60Hz). Splitted for test purpose */
-                {0x66, 0x00, 0xa8, 0xe8},
         .data5 =
                 {0x0c, 0x03, 0xab, 0x10, 0x81, 0x20},
         .stream =
                 {0x0b, 0x04, 0x0a, 0x40},
     },
-    {                           /* 3: LT168G */
+[SENSOR_LT168G] = {
         .n3 = {0x61, 0xc2, 0x65, 0x68, 0x60, 0x00},
         .n4 = n4_lt168g,
         .n4sz = sizeof n4_lt168g,
@@ -460,7 +446,6 @@ static const struct additional_sensor_data sensor_data[] = {
                  0xff},
         .data3 = {0x40, 0x80, 0xc0, 0x50, 0xa0, 0xf0, 0x53, 0xa6,
                  0xff},
-        .data4 = {0x66, 0x41, 0xa8, 0xf0},
         .data5 = {0x0c, 0x03, 0xab, 0x4b, 0x81, 0x2b},
         .stream = {0x0b, 0x04, 0x0a, 0x28},
     },
@@ -469,6 +454,15 @@ static const struct additional_sensor_data sensor_data[] = {
 #define MAX_EFFECTS 7
 /* easily done by soft, this table could be removed,
  * i keep it here just in case */
+static char *effects_control[MAX_EFFECTS] = {
+        "Normal",
+        "Emboss",               /* disabled */
+        "Monochrome",
+        "Sepia",
+        "Sketch",
+        "Sun Effect",           /* disabled */
+        "Negative",
+};
 static const u8 effects_table[MAX_EFFECTS][6] = {
         {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x00},   /* Normal */
         {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x04},   /* Repujar */
@@ -480,40 +474,41 @@ static const u8 effects_table[MAX_EFFECTS][6] = {
 };
 
 static const u8 gamma_table[GAMMA_MAX][17] = {
-        {0x00, 0x3e, 0x69, 0x85, 0x95, 0xa1, 0xae, 0xb9,        /* 0 */
-         0xc2, 0xcb, 0xd4, 0xdb, 0xe3, 0xea, 0xf1, 0xf8,
+/* gamma table from cam1690.ini */
+        {0x00, 0x00, 0x01, 0x04, 0x08, 0x0e, 0x16, 0x21,        /* 0 */
+         0x2e, 0x3d, 0x50, 0x65, 0x7d, 0x99, 0xb8, 0xdb,
          0xff},
-        {0x00, 0x33, 0x5a, 0x75, 0x85, 0x93, 0xa1, 0xad,        /* 1 */
-         0xb7, 0xc2, 0xcb, 0xd4, 0xde, 0xe7, 0xf0, 0xf7,
+        {0x00, 0x01, 0x03, 0x08, 0x0e, 0x16, 0x21, 0x2d,        /* 1 */
+         0x3c, 0x4d, 0x60, 0x75, 0x8d, 0xa6, 0xc2, 0xe1,
          0xff},
-        {0x00, 0x2f, 0x51, 0x6b, 0x7c, 0x8a, 0x99, 0xa6,        /* 2 */
-         0xb1, 0xbc, 0xc6, 0xd0, 0xdb, 0xe4, 0xed, 0xf6,
+        {0x00, 0x01, 0x05, 0x0b, 0x12, 0x1c, 0x28, 0x35,        /* 2 */
+         0x45, 0x56, 0x69, 0x7e, 0x95, 0xad, 0xc7, 0xe3,
          0xff},
-        {0x00, 0x29, 0x48, 0x60, 0x72, 0x81, 0x90, 0x9e,        /* 3 */
-         0xaa, 0xb5, 0xbf, 0xcb, 0xd6, 0xe1, 0xeb, 0xf5,
+        {0x00, 0x02, 0x07, 0x0f, 0x18, 0x24, 0x30, 0x3f,        /* 3 */
+         0x4f, 0x61, 0x73, 0x88, 0x9d, 0xb4, 0xcd, 0xe6,
          0xff},
-        {0x00, 0x23, 0x3f, 0x55, 0x68, 0x77, 0x86, 0x95,        /* 4 */
-         0xa2, 0xad, 0xb9, 0xc6, 0xd2, 0xde, 0xe9, 0xf4,
+        {0x00, 0x04, 0x0B, 0x15, 0x20, 0x2d, 0x3b, 0x4a,        /* 4 */
+         0x5b, 0x6c, 0x7f, 0x92, 0xa7, 0xbc, 0xd2, 0xe9,
          0xff},
-        {0x00, 0x1b, 0x33, 0x48, 0x59, 0x69, 0x79, 0x87,        /* 5 */
-         0x96, 0xa3, 0xb1, 0xbe, 0xcc, 0xda, 0xe7, 0xf3,
+        {0x00, 0x07, 0x11, 0x15, 0x20, 0x2d, 0x48, 0x58,        /* 5 */
+         0x68, 0x79, 0x8b, 0x9d, 0xb0, 0xc4, 0xd7, 0xec,
          0xff},
-        {0x00, 0x02, 0x10, 0x20, 0x32, 0x40, 0x57, 0x67,        /* 6 */
+        {0x00, 0x0c, 0x1a, 0x29, 0x38, 0x47, 0x57, 0x67,        /* 6 */
          0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee,
          0xff},
-        {0x00, 0x02, 0x14, 0x26, 0x38, 0x4a, 0x60, 0x70,        /* 7 */
+        {0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,        /* 7 */
          0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
          0xff},
-        {0x00, 0x10, 0x22, 0x35, 0x47, 0x5a, 0x69, 0x79,        /* 8 */
-         0x88, 0x97, 0xa7, 0xb6, 0xc4, 0xd3, 0xe0, 0xf0,
+        {0x00, 0x15, 0x27, 0x38, 0x49, 0x59, 0x69, 0x79,        /* 8 */
+         0x88, 0x97, 0xa7, 0xb6, 0xc4, 0xd3, 0xe2, 0xf0,
          0xff},
-        {0x00, 0x10, 0x26, 0x40, 0x54, 0x65, 0x75, 0x84,        /* 9 */
-         0x93, 0xa1, 0xb0, 0xbd, 0xca, 0xd6, 0xe0, 0xf0,
+        {0x00, 0x1c, 0x30, 0x43, 0x54, 0x65, 0x75, 0x84,        /* 9 */
+         0x93, 0xa1, 0xb0, 0xbd, 0xca, 0xd8, 0xe5, 0xf2,
          0xff},
-        {0x00, 0x18, 0x2b, 0x44, 0x60, 0x70, 0x80, 0x8e,        /* 10 */
-         0x9c, 0xaa, 0xb7, 0xc4, 0xd0, 0xd8, 0xe2, 0xf0,
+        {0x00, 0x24, 0x3b, 0x4f, 0x60, 0x70, 0x80, 0x8e,        /* 10 */
+         0x9c, 0xaa, 0xb7, 0xc4, 0xd0, 0xdc, 0xe8, 0xf3,
          0xff},
-        {0x00, 0x1a, 0x34, 0x52, 0x66, 0x7e, 0x8d, 0x9b,        /* 11 */
+        {0x00, 0x2a, 0x3c, 0x5d, 0x6e, 0x7e, 0x8d, 0x9b,        /* 11 */
          0xa8, 0xb4, 0xc0, 0xcb, 0xd6, 0xe1, 0xeb, 0xf5,
          0xff},
         {0x00, 0x3f, 0x5a, 0x6e, 0x7f, 0x8e, 0x9c, 0xa8,        /* 12 */
@@ -577,12 +572,11 @@ static void reg_w_buf(struct gspca_dev *gspca_dev,
         } else {
                 u8 *tmpbuf;
 
-                tmpbuf = kmalloc(len, GFP_KERNEL);
+                tmpbuf = kmemdup(buffer, len, GFP_KERNEL);
                 if (!tmpbuf) {
                         err("Out of memory");
                         return;
                 }
-                memcpy(tmpbuf, buffer, len);
                 usb_control_msg(gspca_dev->dev,
                                 usb_sndctrlpipe(gspca_dev->dev, 0),
                                 0,
@@ -625,7 +619,6 @@ static void reg_w_ixbuf(struct gspca_dev *gspca_dev,
                 kfree(tmpbuf);
 }
 
-/* Reported as OM6802*/
 static void om6802_sensor_init(struct gspca_dev *gspca_dev)
 {
         int i;
@@ -703,12 +696,12 @@ static int sd_config(struct gspca_dev *gspca_dev,
         sd->autogain = AUTOGAIN_DEF;
         sd->mirror = MIRROR_DEF;
         sd->freq = FREQ_DEF;
-        sd->whitebalance = WHITE_BALANCE_DEF;
+        sd->awb = AWB_DEF;
         sd->sharpness = SHARPNESS_DEF;
         sd->effect = EFFECTS_DEF;
-        sd->red_balance = RED_BALANCE_DEF;
-        sd->blue_balance = BLUE_BALANCE_DEF;
-        sd->global_gain = global_gain_DEF;
+        sd->red_gain = RED_GAIN_DEF;
+        sd->blue_gain = BLUE_GAIN_DEF;
+        sd->green_gain = GAIN_DEF * 3 - RED_GAIN_DEF - BLUE_GAIN_DEF;
 
         return 0;
 }
@@ -761,40 +754,59 @@ static void setgamma(struct gspca_dev *gspca_dev)
         reg_w_ixbuf(gspca_dev, 0x90,
                 gamma_table[sd->gamma], sizeof gamma_table[0]);
 }
-static void setglobalgain(struct gspca_dev *gspca_dev)
-{
 
+static void setRGB(struct gspca_dev *gspca_dev)
+{
         struct sd *sd = (struct sd *) gspca_dev;
-        reg_w(gspca_dev, (sd->red_balance  << 8) + 0x87);
-        reg_w(gspca_dev, (sd->blue_balance << 8) + 0x88);
-        reg_w(gspca_dev, (sd->global_gain  << 8) + 0x89);
+        u8 all_gain_reg[6] =
+                {0x87, 0x00, 0x88, 0x00, 0x89, 0x00};
+
+        all_gain_reg[1] = sd->red_gain;
+        all_gain_reg[3] = sd->blue_gain;
+        all_gain_reg[5] = sd->green_gain;
+        reg_w_buf(gspca_dev, all_gain_reg, sizeof all_gain_reg);
 }
 
-/* Generic fnc for r/b balance, exposure and whitebalance */
-static void setbalance(struct gspca_dev *gspca_dev)
+/* Generic fnc for r/b balance, exposure and awb */
+static void setawb(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        u16 reg80;
 
-        /* on whitebalance leave defaults values */
-        if (sd->whitebalance) {
-                reg_w(gspca_dev, 0x3c80);
-        } else {
-                reg_w(gspca_dev, 0x3880);
+        reg80 = (sensor_data[sd->sensor].reg80 << 8) | 0x80;
+
+        /* on awb leave defaults values */
+        if (!sd->awb) {
                 /* shoud we wait here.. */
-                /* update and reset 'global gain' with webcam parameters */
-                sd->red_balance = reg_r(gspca_dev, 0x0087);
-                sd->blue_balance = reg_r(gspca_dev, 0x0088);
-                sd->global_gain = reg_r(gspca_dev, 0x0089);
-                setglobalgain(gspca_dev);
+                /* update and reset RGB gains with webcam values */
+                sd->red_gain = reg_r(gspca_dev, 0x0087);
+                sd->blue_gain = reg_r(gspca_dev, 0x0088);
+                sd->green_gain = reg_r(gspca_dev, 0x0089);
+                reg80 &= ~0x0400;               /* AWB off */
         }
-
+        reg_w(gspca_dev, reg80);
+        reg_w(gspca_dev, reg80);
 }
 
-
-
-static void setwhitebalance(struct gspca_dev *gspca_dev)
+static void init_gains(struct gspca_dev *gspca_dev)
 {
-        setbalance(gspca_dev);
+        struct sd *sd = (struct sd *) gspca_dev;
+        u16 reg80;
+        u8 all_gain_reg[8] =
+                {0x87, 0x00, 0x88, 0x00, 0x89, 0x00, 0x80, 0x00};
+
+        all_gain_reg[1] = sd->red_gain;
+        all_gain_reg[3] = sd->blue_gain;
+        all_gain_reg[5] = sd->green_gain;
+        reg80 = sensor_data[sd->sensor].reg80;
+        if (!sd->awb)
+                reg80 &= ~0x04;
+        all_gain_reg[7] = reg80;
+        reg_w_buf(gspca_dev, all_gain_reg, sizeof all_gain_reg);
+
+        reg_w(gspca_dev, (sd->red_gain  << 8) + 0x87);
+        reg_w(gspca_dev, (sd->blue_gain << 8) + 0x88);
+        reg_w(gspca_dev, (sd->green_gain  << 8) + 0x89);
 }
 
 static void setsharpness(struct gspca_dev *gspca_dev)
@@ -807,6 +819,38 @@ static void setsharpness(struct gspca_dev *gspca_dev)
         reg_w(gspca_dev, reg_to_write);
 }
 
+static void setfreq(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 reg66;
+        u8 freq[4] = { 0x66, 0x00, 0xa8, 0xe8 };
+
+        switch (sd->sensor) {
+        case SENSOR_LT168G:
+                if (sd->freq != 0)
+                        freq[3] = 0xa8;
+                reg66 = 0x41;
+                break;
+        case SENSOR_OM6802:
+                reg66 = 0xca;
+                break;
+        default:
+                reg66 = 0x40;
+                break;
+        }
+        switch (sd->freq) {
+        case 0:                         /* no flicker */
+                freq[3] = 0xf0;
+                break;
+        case 2:                         /* 60Hz */
+                reg66 &= ~0x40;
+                break;
+        }
+        freq[1] = reg66;
+
+        reg_w_buf(gspca_dev, freq, sizeof freq);
+}
+
 /* this function is called at probe and resume time */
 static int sd_init(struct gspca_dev *gspca_dev)
 {
@@ -901,13 +945,9 @@ static int sd_init(struct gspca_dev *gspca_dev)
         setgamma(gspca_dev);
         setcolors(gspca_dev);
         setsharpness(gspca_dev);
-        setwhitebalance(gspca_dev);
-
-        reg_w(gspca_dev, 0x2087);       /* tied to white balance? */
-        reg_w(gspca_dev, 0x2088);
-        reg_w(gspca_dev, 0x2089);
+        init_gains(gspca_dev);
+        setfreq(gspca_dev);
 
-        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);
@@ -926,16 +966,16 @@ static int sd_init(struct gspca_dev *gspca_dev)
         return 0;
 }
 
-static void setflip(struct gspca_dev *gspca_dev)
+static void setmirror(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        u8 flipcmd[8] =
+        u8 hflipcmd[8] =
                 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09};
 
         if (sd->mirror)
-                flipcmd[3] = 0x01;
+                hflipcmd[3] = 0x01;
 
-        reg_w_buf(gspca_dev, flipcmd, sizeof flipcmd);
+        reg_w_buf(gspca_dev, hflipcmd, sizeof hflipcmd);
 }
 
 static void seteffect(struct gspca_dev *gspca_dev)
@@ -956,17 +996,6 @@ static void seteffect(struct gspca_dev *gspca_dev)
                 reg_w(gspca_dev, 0xfaa6);
 }
 
-static void setlightfreq(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        u8 freq[4] = { 0x66, 0x40, 0xa8, 0xe8 };
-
-        if (sd->freq == 2)      /* 60hz */
-                freq[1] = 0x00;
-
-        reg_w_buf(gspca_dev, freq, sizeof freq);
-}
-
 /* Is this really needed?
  * i added some module parameters for test with some users */
 static void poll_sensor(struct gspca_dev *gspca_dev)
@@ -979,9 +1008,7 @@ static void poll_sensor(struct gspca_dev *gspca_dev)
         static const u8 poll2[] =
                 {0x67, 0x02, 0x68, 0x71, 0x69, 0x72, 0x72, 0xa9,
                  0x73, 0x02, 0x73, 0x02, 0x60, 0x14};
-        static const u8 poll3[] =
-                {0x87, 0x3f, 0x88, 0x20, 0x89, 0x2d};
-        static const u8 poll4[] =
+        static const u8 noise03[] =     /* (some differences / ms-drv) */
                 {0xa6, 0x0a, 0xea, 0xcf, 0xbe, 0x26, 0xb1, 0x5f,
                  0xa1, 0xb1, 0xda, 0x6b, 0xdb, 0x98, 0xdf, 0x0c,
                  0xc2, 0x80, 0xc3, 0x10};
@@ -989,8 +1016,7 @@ static void poll_sensor(struct gspca_dev *gspca_dev)
         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);
+        reg_w_buf(gspca_dev, noise03, sizeof noise03);
 }
 
 static int sd_start(struct gspca_dev *gspca_dev)
@@ -1025,12 +1051,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
         case SENSOR_OM6802:
                 om6802_sensor_init(gspca_dev);
                 break;
-        case SENSOR_LT168G:
-                break;
-        case SENSOR_OTHER:
-                break;
-        default:
-/*      case SENSOR_TAS5130A: */
+        case SENSOR_TAS5130A:
                 i = 0;
                 for (;;) {
                         reg_w_buf(gspca_dev, tas5130a_sensor_init[i],
@@ -1047,7 +1068,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 break;
         }
         sensor = &sensor_data[sd->sensor];
-        reg_w_buf(gspca_dev, sensor->data4, sizeof sensor->data4);
+        setfreq(gspca_dev);
         reg_r(gspca_dev, 0x0012);
         reg_w_buf(gspca_dev, t2, sizeof t2);
         reg_w_ixbuf(gspca_dev, 0xb3, t3, sizeof t3);
@@ -1080,7 +1101,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,                       /* isoc packet */
                         int len)                        /* iso packet length */
 {
-        static u8 ffd9[] = { 0xff, 0xd9 };
+        int pkt_type;
 
         if (data[0] == 0x5a) {
                 /* Control Packet, after this came the header again,
@@ -1090,84 +1111,88 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         }
         data += 2;
         len -= 2;
-        if (data[0] == 0xff && data[1] == 0xd8) {
-                /* extra bytes....., could be processed too but would be
-                 * a waste of time, right now leave the application and
-                 * libjpeg do it for ourserlves.. */
-                gspca_frame_add(gspca_dev, LAST_PACKET,
-                                        ffd9, 2);
-                gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
-                return;
-        }
-
-        if (data[len - 2] == 0xff && data[len - 1] == 0xd9) {
-                /* Just in case, i have seen packets with the marker,
-                 * other's do not include it... */
-                len -= 2;
-        }
-        gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
+        if (data[0] == 0xff && data[1] == 0xd8)
+                pkt_type = FIRST_PACKET;
+        else if (data[len - 2] == 0xff && data[len - 1] == 0xd9)
+                pkt_type = LAST_PACKET;
+        else
+                pkt_type = INTER_PACKET;
+        gspca_frame_add(gspca_dev, pkt_type, data, len);
 }
 
-
-static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val)
+static int sd_setblue_gain(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        sd->blue_balance = val;
+        sd->blue_gain = val;
         if (gspca_dev->streaming)
                 reg_w(gspca_dev, (val << 8) + 0x88);
         return 0;
 }
 
-static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val)
+static int sd_getblue_gain(struct gspca_dev *gspca_dev, __s32 *val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        *val = sd->blue_balance;
+        *val = sd->blue_gain;
         return 0;
 }
 
-static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val)
+static int sd_setred_gain(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        sd->red_balance = val;
+        sd->red_gain = val;
         if (gspca_dev->streaming)
                 reg_w(gspca_dev, (val << 8) + 0x87);
 
         return 0;
 }
 
-static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val)
+static int sd_getred_gain(struct gspca_dev *gspca_dev, __s32 *val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        *val = sd->red_balance;
+        *val = sd->red_gain;
         return 0;
 }
 
-
-
-static int sd_setglobal_gain(struct gspca_dev *gspca_dev, __s32 val)
+static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        u16 psg, nsg;
+
+        psg = sd->red_gain + sd->blue_gain + sd->green_gain;
+        nsg = val * 3;
+        sd->red_gain = sd->red_gain * nsg / psg;
+        if (sd->red_gain > 0x40)
+                sd->red_gain = 0x40;
+        else if (sd->red_gain < 0x10)
+                sd->red_gain = 0x10;
+        sd->blue_gain = sd->blue_gain * nsg / psg;
+        if (sd->blue_gain > 0x40)
+                sd->blue_gain = 0x40;
+        else if (sd->blue_gain < 0x10)
+                sd->blue_gain = 0x10;
+        sd->green_gain = sd->green_gain * nsg / psg;
+        if (sd->green_gain > 0x40)
+                sd->green_gain = 0x40;
+        else if (sd->green_gain < 0x10)
+                sd->green_gain = 0x10;
 
-        sd->global_gain = val;
         if (gspca_dev->streaming)
-                setglobalgain(gspca_dev);
-
+                setRGB(gspca_dev);
         return 0;
 }
 
-static int sd_getglobal_gain(struct gspca_dev *gspca_dev, __s32 *val)
+static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        *val = sd->global_gain;
+        *val = (sd->red_gain + sd->blue_gain + sd->green_gain) / 3;
         return 0;
 }
 
-
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -1186,35 +1211,35 @@ static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
         return *val;
 }
 
-static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val)
+static int sd_setawb(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        sd->whitebalance = val;
+        sd->awb = val;
         if (gspca_dev->streaming)
-                setwhitebalance(gspca_dev);
+                setawb(gspca_dev);
         return 0;
 }
 
-static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val)
+static int sd_getawb(struct gspca_dev *gspca_dev, __s32 *val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        *val = sd->whitebalance;
+        *val = sd->awb;
         return *val;
 }
 
-static int sd_setflip(struct gspca_dev *gspca_dev, __s32 val)
+static int sd_setmirror(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
         sd->mirror = val;
         if (gspca_dev->streaming)
-                setflip(gspca_dev);
+                setmirror(gspca_dev);
         return 0;
 }
 
-static int sd_getflip(struct gspca_dev *gspca_dev, __s32 *val)
+static int sd_getmirror(struct gspca_dev *gspca_dev, __s32 *val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
@@ -1300,7 +1325,7 @@ static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
 
         sd->freq = val;
         if (gspca_dev->streaming)
-                setlightfreq(gspca_dev);
+                setfreq(gspca_dev);
         return 0;
 }
 
@@ -1368,7 +1393,8 @@ static int sd_querymenu(struct gspca_dev *gspca_dev,
         case V4L2_CID_EFFECTS:
                 if ((unsigned) menu->index < ARRAY_SIZE(effects_control)) {
                         strncpy((char *) menu->name,
-                                effects_control[menu->index], 32);
+                                effects_control[menu->index],
+                                sizeof menu->name);
                         return 0;
                 }
                 break;