drivers/media/video/gspca/sonixb.c

   1 /*
   2  *              sonix sn9c102 (bayer) library
   3  *              Copyright (C) 2003 2004 Michel Xhaard mxhaard@magic.fr
   4  * Add Pas106 Stefano Mozzi (C) 2004
   5  *
   6  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21  */
  22
  23 /* Some documentation on known sonixb registers:
  24
  25 Reg     Use
  26 0x10    high nibble red gain low nibble blue gain
  27 0x11    low nibble green gain
  28 0x12    hstart
  29 0x13    vstart
  30 0x15    hsize (hsize = register-value * 16)
  31 0x16    vsize (vsize = register-value * 16)
  32 0x17    bit 0 toggle compression quality (according to sn9c102 driver)
  33 0x18    bit 7 enables compression, bit 4-5 set image down scaling:
  34         00 scale 1, 01 scale 1/2, 10, scale 1/4
  35 0x19    high-nibble is sensor clock divider, changes exposure on sensors which
  36         use a clock generated by the bridge. Some sensors have their own clock.
  37 0x1c    auto_exposure area (for avg_lum) startx (startx = register-value * 32)
  38 0x1d    auto_exposure area (for avg_lum) starty (starty = register-value * 32)
  39 0x1e    auto_exposure area (for avg_lum) stopx (hsize = (0x1e - 0x1c) * 32)
  40 0x1f    auto_exposure area (for avg_lum) stopy (vsize = (0x1f - 0x1d) * 32)
  41 */
  42
  43 #define MODULE_NAME "sonixb"
  44
  45 #include "gspca.h"
  46
  47 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
  48 MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver");
  49 MODULE_LICENSE("GPL");
  50
  51 /* specific webcam descriptor */
  52 struct sd {
  53         struct gspca_dev gspca_dev;     /* !! must be the first item */
  54         atomic_t avg_lum;
  55         int prev_avg_lum;
  56
  57         unsigned char gain;
  58         unsigned char exposure;
  59         unsigned char brightness;
  60         unsigned char autogain;
  61         unsigned char autogain_ignore_frames;
  62         unsigned char frames_to_drop;
  63         unsigned char freq;             /* light freq filter setting */
  64
  65         __u8 bridge;                    /* Type of bridge */
  66 #define BRIDGE_101 0
  67 #define BRIDGE_102 0 /* We make no difference between 101 and 102 */
  68 #define BRIDGE_103 1
  69
  70         __u8 sensor;                    /* Type of image sensor chip */
  71 #define SENSOR_HV7131R 0
  72 #define SENSOR_OV6650 1
  73 #define SENSOR_OV7630 2
  74 #define SENSOR_PAS106 3
  75 #define SENSOR_PAS202 4
  76 #define SENSOR_TAS5110 5
  77 #define SENSOR_TAS5130CXX 6
  78         __u8 reg11;
  79 };
  80
  81 typedef const __u8 sensor_init_t[8];
  82
  83 struct sensor_data {
  84         const __u8 *bridge_init[2];
  85         int bridge_init_size[2];
  86         sensor_init_t *sensor_init;
  87         int sensor_init_size;
  88         sensor_init_t *sensor_bridge_init[2];
  89         int sensor_bridge_init_size[2];
  90         int flags;
  91         unsigned ctrl_dis;
  92         __u8 sensor_addr;
  93 };
  94
  95 /* sensor_data flags */
  96 #define F_GAIN 0x01             /* has gain */
  97 #define F_SIF  0x02             /* sif or vga */
  98
  99 /* priv field of struct v4l2_pix_format flags (do not use low nibble!) */
 100 #define MODE_RAW 0x10           /* raw bayer mode */
 101 #define MODE_REDUCED_SIF 0x20   /* vga mode (320x240 / 160x120) on sif cam */
 102
 103 /* ctrl_dis helper macros */
 104 #define NO_EXPO ((1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX))
 105 #define NO_FREQ (1 << FREQ_IDX)
 106 #define NO_BRIGHTNESS (1 << BRIGHTNESS_IDX)
 107
 108 #define COMP2 0x8f
 109 #define COMP 0xc7               /* 0x87 //0x07 */
 110 #define COMP1 0xc9              /* 0x89 //0x09 */
 111
 112 #define MCK_INIT 0x63
 113 #define MCK_INIT1 0x20          /*fixme: Bayer - 0x50 for JPEG ??*/
 114
 115 #define SYS_CLK 0x04
 116
 117 #define SENS(bridge_1, bridge_3, sensor, sensor_1, \
 118         sensor_3, _flags, _ctrl_dis, _sensor_addr) \
 119 { \
 120         .bridge_init = { bridge_1, bridge_3 }, \
 121         .bridge_init_size = { sizeof(bridge_1), sizeof(bridge_3) }, \
 122         .sensor_init = sensor, \
 123         .sensor_init_size = sizeof(sensor), \
 124         .sensor_bridge_init = { sensor_1, sensor_3,}, \
 125         .sensor_bridge_init_size = { sizeof(sensor_1), sizeof(sensor_3)}, \
 126         .flags = _flags, .ctrl_dis = _ctrl_dis, .sensor_addr = _sensor_addr \
 127 }
 128
 129 /* We calculate the autogain at the end of the transfer of a frame, at this
 130    moment a frame with the old settings is being transmitted, and a frame is
 131    being captured with the old settings. So if we adjust the autogain we must
 132    ignore atleast the 2 next frames for the new settings to come into effect
 133    before doing any other adjustments */
 134 #define AUTOGAIN_IGNORE_FRAMES 3
 135
 136 /* V4L2 controls supported by the driver */
 137 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
 138 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
 139 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
 140 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
 141 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
 142 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
 143 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
 144 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
 145 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
 146 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 147
 148 static struct ctrl sd_ctrls[] = {
 149 #define BRIGHTNESS_IDX 0
 150         {
 151             {
 152                 .id      = V4L2_CID_BRIGHTNESS,
 153                 .type    = V4L2_CTRL_TYPE_INTEGER,
 154                 .name    = "Brightness",
 155                 .minimum = 0,
 156                 .maximum = 255,
 157                 .step    = 1,
 158 #define BRIGHTNESS_DEF 127
 159                 .default_value = BRIGHTNESS_DEF,
 160             },
 161             .set = sd_setbrightness,
 162             .get = sd_getbrightness,
 163         },
 164 #define GAIN_IDX 1
 165         {
 166             {
 167                 .id      = V4L2_CID_GAIN,
 168                 .type    = V4L2_CTRL_TYPE_INTEGER,
 169                 .name    = "Gain",
 170                 .minimum = 0,
 171                 .maximum = 255,
 172                 .step    = 1,
 173 #define GAIN_DEF 127
 174 #define GAIN_KNEE 200
 175                 .default_value = GAIN_DEF,
 176             },
 177             .set = sd_setgain,
 178             .get = sd_getgain,
 179         },
 180 #define EXPOSURE_IDX 2
 181         {
 182                 {
 183                         .id = V4L2_CID_EXPOSURE,
 184                         .type = V4L2_CTRL_TYPE_INTEGER,
 185                         .name = "Exposure",
 186 #define EXPOSURE_DEF  16 /*  32 ms / 30 fps */
 187 #define EXPOSURE_KNEE 50 /* 100 ms / 10 fps */
 188                         .minimum = 0,
 189                         .maximum = 255,
 190                         .step = 1,
 191                         .default_value = EXPOSURE_DEF,
 192                         .flags = 0,
 193                 },
 194                 .set = sd_setexposure,
 195                 .get = sd_getexposure,
 196         },
 197 #define AUTOGAIN_IDX 3
 198         {
 199                 {
 200                         .id = V4L2_CID_AUTOGAIN,
 201                         .type = V4L2_CTRL_TYPE_BOOLEAN,
 202                         .name = "Automatic Gain (and Exposure)",
 203                         .minimum = 0,
 204                         .maximum = 1,
 205                         .step = 1,
 206 #define AUTOGAIN_DEF 1
 207                         .default_value = AUTOGAIN_DEF,
 208                         .flags = 0,
 209                 },
 210                 .set = sd_setautogain,
 211                 .get = sd_getautogain,
 212         },
 213 #define FREQ_IDX 4
 214         {
 215                 {
 216                         .id      = V4L2_CID_POWER_LINE_FREQUENCY,
 217                         .type    = V4L2_CTRL_TYPE_MENU,
 218                         .name    = "Light frequency filter",
 219                         .minimum = 0,
 220                         .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
 221                         .step    = 1,
 222 #define FREQ_DEF 1
 223                         .default_value = FREQ_DEF,
 224                 },
 225                 .set = sd_setfreq,
 226                 .get = sd_getfreq,
 227         },
 228 };
 229
 230 static const struct v4l2_pix_format vga_mode[] = {
 231         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 232                 .bytesperline = 160,
 233                 .sizeimage = 160 * 120,
 234                 .colorspace = V4L2_COLORSPACE_SRGB,
 235                 .priv = 2 | MODE_RAW},
 236         {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 237                 .bytesperline = 160,
 238                 .sizeimage = 160 * 120 * 5 / 4,
 239                 .colorspace = V4L2_COLORSPACE_SRGB,
 240                 .priv = 2},
 241         {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 242                 .bytesperline = 320,
 243                 .sizeimage = 320 * 240 * 5 / 4,
 244                 .colorspace = V4L2_COLORSPACE_SRGB,
 245                 .priv = 1},
 246         {640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 247                 .bytesperline = 640,
 248                 .sizeimage = 640 * 480 * 5 / 4,
 249                 .colorspace = V4L2_COLORSPACE_SRGB,
 250                 .priv = 0},
 251 };
 252 static const struct v4l2_pix_format sif_mode[] = {
 253         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 254                 .bytesperline = 160,
 255                 .sizeimage = 160 * 120,
 256                 .colorspace = V4L2_COLORSPACE_SRGB,
 257                 .priv = 1 | MODE_RAW | MODE_REDUCED_SIF},
 258         {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 259                 .bytesperline = 160,
 260                 .sizeimage = 160 * 120 * 5 / 4,
 261                 .colorspace = V4L2_COLORSPACE_SRGB,
 262                 .priv = 1 | MODE_REDUCED_SIF},
 263         {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 264                 .bytesperline = 176,
 265                 .sizeimage = 176 * 144,
 266                 .colorspace = V4L2_COLORSPACE_SRGB,
 267                 .priv = 1 | MODE_RAW},
 268         {176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 269                 .bytesperline = 176,
 270                 .sizeimage = 176 * 144 * 5 / 4,
 271                 .colorspace = V4L2_COLORSPACE_SRGB,
 272                 .priv = 1},
 273         {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 274                 .bytesperline = 320,
 275                 .sizeimage = 320 * 240 * 5 / 4,
 276                 .colorspace = V4L2_COLORSPACE_SRGB,
 277                 .priv = 0 | MODE_REDUCED_SIF},
 278         {352, 288, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 279                 .bytesperline = 352,
 280                 .sizeimage = 352 * 288 * 5 / 4,
 281                 .colorspace = V4L2_COLORSPACE_SRGB,
 282                 .priv = 0},
 283 };
 284
 285 static const __u8 initHv7131[] = {
 286         0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
 287         0x00, 0x00,
 288         0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
 289         0x28, 0x1e, 0x60, 0x8a, 0x20,
 290         0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c
 291 };
 292 static const __u8 hv7131_sensor_init[][8] = {
 293         {0xc0, 0x11, 0x31, 0x38, 0x2a, 0x2e, 0x00, 0x10},
 294         {0xa0, 0x11, 0x01, 0x08, 0x2a, 0x2e, 0x00, 0x10},
 295         {0xb0, 0x11, 0x20, 0x00, 0xd0, 0x2e, 0x00, 0x10},
 296         {0xc0, 0x11, 0x25, 0x03, 0x0e, 0x28, 0x00, 0x16},
 297         {0xa0, 0x11, 0x30, 0x10, 0x0e, 0x28, 0x00, 0x15},
 298 };
 299 static const __u8 initOv6650[] = {
 300         0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
 301         0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 302         0x00, 0x01, 0x01, 0x0a, 0x16, 0x12, 0x68, 0x8b,
 303         0x10, 0x1d, 0x10, 0x02, 0x02, 0x09, 0x07
 304 };
 305 static const __u8 ov6650_sensor_init[][8] =
 306 {
 307         /* Bright, contrast, etc are set througth SCBB interface.
 308          * AVCAP on win2 do not send any data on this   controls. */
 309         /* Anyway, some registers appears to alter bright and constrat */
 310
 311         /* Reset sensor */
 312         {0xa0, 0x60, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
 313         /* Set clock register 0x11 low nibble is clock divider */
 314         {0xd0, 0x60, 0x11, 0xc0, 0x1b, 0x18, 0xc1, 0x10},
 315         /* Next some unknown stuff */
 316         {0xb0, 0x60, 0x15, 0x00, 0x02, 0x18, 0xc1, 0x10},
 317 /*      {0xa0, 0x60, 0x1b, 0x01, 0x02, 0x18, 0xc1, 0x10},
 318                  * THIS SET GREEN SCREEN
 319                  * (pixels could be innverted in decode kind of "brg",
 320                  * but blue wont be there. Avoid this data ... */
 321         {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10}, /* format out? */
 322         {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10},
 323         {0xa0, 0x60, 0x30, 0x3d, 0x0A, 0xd8, 0xa4, 0x10},
 324         /* Enable rgb brightness control */
 325         {0xa0, 0x60, 0x61, 0x08, 0x00, 0x00, 0x00, 0x10},
 326         /* HDG: Note windows uses the line below, which sets both register 0x60
 327            and 0x61 I believe these registers of the ov6650 are identical as
 328            those of the ov7630, because if this is true the windows settings
 329            add a bit additional red gain and a lot additional blue gain, which
 330            matches my findings that the windows settings make blue much too
 331            blue and red a little too red.
 332         {0xb0, 0x60, 0x60, 0x66, 0x68, 0xd8, 0xa4, 0x10}, */
 333         /* Some more unknown stuff */
 334         {0xa0, 0x60, 0x68, 0x04, 0x68, 0xd8, 0xa4, 0x10},
 335         {0xd0, 0x60, 0x17, 0x24, 0xd6, 0x04, 0x94, 0x10}, /* Clipreg */
 336 };
 337
 338 static const __u8 initOv7630[] = {
 339         0x04, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, /* r01 .. r08 */
 340         0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* r09 .. r10 */
 341         0x00, 0x01, 0x01, 0x0a,                         /* r11 .. r14 */
 342         0x28, 0x1e,                     /* H & V sizes     r15 .. r16 */
 343         0x68, COMP2, MCK_INIT1,                         /* r17 .. r19 */
 344         0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c              /* r1a .. r1f */
 345 };
 346 static const __u8 initOv7630_3[] = {
 347         0x44, 0x44, 0x00, 0x1a, 0x20, 0x20, 0x20, 0x80, /* r01 .. r08 */
 348         0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, /* r09 .. r10 */
 349         0x00, 0x02, 0x01, 0x0a,                         /* r11 .. r14 */
 350         0x28, 0x1e,                     /* H & V sizes     r15 .. r16 */
 351         0x68, 0x8f, MCK_INIT1,                          /* r17 .. r19 */
 352         0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c, 0x00,       /* r1a .. r20 */
 353         0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, /* r21 .. r28 */
 354         0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0xff  /* r29 .. r30 */
 355 };
 356 static const __u8 ov7630_sensor_init[][8] = {
 357         {0xa0, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
 358         {0xb0, 0x21, 0x01, 0x77, 0x3a, 0x00, 0x00, 0x10},
 359 /*      {0xd0, 0x21, 0x12, 0x7c, 0x01, 0x80, 0x34, 0x10},          jfm */
 360         {0xd0, 0x21, 0x12, 0x1c, 0x00, 0x80, 0x34, 0x10},       /* jfm */
 361         {0xa0, 0x21, 0x1b, 0x04, 0x00, 0x80, 0x34, 0x10},
 362         {0xa0, 0x21, 0x20, 0x44, 0x00, 0x80, 0x34, 0x10},
 363         {0xa0, 0x21, 0x23, 0xee, 0x00, 0x80, 0x34, 0x10},
 364         {0xd0, 0x21, 0x26, 0xa0, 0x9a, 0xa0, 0x30, 0x10},
 365         {0xb0, 0x21, 0x2a, 0x80, 0x00, 0xa0, 0x30, 0x10},
 366         {0xb0, 0x21, 0x2f, 0x3d, 0x24, 0xa0, 0x30, 0x10},
 367         {0xa0, 0x21, 0x32, 0x86, 0x24, 0xa0, 0x30, 0x10},
 368         {0xb0, 0x21, 0x60, 0xa9, 0x4a, 0xa0, 0x30, 0x10},
 369 /*      {0xb0, 0x21, 0x60, 0xa9, 0x42, 0xa0, 0x30, 0x10},        * jfm */
 370         {0xa0, 0x21, 0x65, 0x00, 0x42, 0xa0, 0x30, 0x10},
 371         {0xa0, 0x21, 0x69, 0x38, 0x42, 0xa0, 0x30, 0x10},
 372         {0xc0, 0x21, 0x6f, 0x88, 0x0b, 0x00, 0x30, 0x10},
 373         {0xc0, 0x21, 0x74, 0x21, 0x8e, 0x00, 0x30, 0x10},
 374         {0xa0, 0x21, 0x7d, 0xf7, 0x8e, 0x00, 0x30, 0x10},
 375         {0xd0, 0x21, 0x17, 0x1c, 0xbd, 0x06, 0xf6, 0x10},
 376 };
 377
 378 static const __u8 ov7630_sensor_init_3[][8] = {
 379         {0xa0, 0x21, 0x13, 0x80, 0x00,  0x00, 0x00, 0x10},
 380 };
 381
 382 static const __u8 initPas106[] = {
 383         0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00,
 384         0x00, 0x00,
 385         0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
 386         0x16, 0x12, 0x24, COMP1, MCK_INIT1,
 387         0x18, 0x10, 0x02, 0x02, 0x09, 0x07
 388 };
 389 /* compression 0x86 mckinit1 0x2b */
 390 static const __u8 pas106_sensor_init[][8] = {
 391         /* Pixel Clock Divider 6 */
 392         { 0xa1, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14 },
 393         /* Frame Time MSB (also seen as 0x12) */
 394         { 0xa1, 0x40, 0x03, 0x13, 0x00, 0x00, 0x00, 0x14 },
 395         /* Frame Time LSB (also seen as 0x05) */
 396         { 0xa1, 0x40, 0x04, 0x06, 0x00, 0x00, 0x00, 0x14 },
 397         /* Shutter Time Line Offset (also seen as 0x6d) */
 398         { 0xa1, 0x40, 0x05, 0x65, 0x00, 0x00, 0x00, 0x14 },
 399         /* Shutter Time Pixel Offset (also seen as 0xb1) */
 400         { 0xa1, 0x40, 0x06, 0xcd, 0x00, 0x00, 0x00, 0x14 },
 401         /* Black Level Subtract Sign (also seen 0x00) */
 402         { 0xa1, 0x40, 0x07, 0xc1, 0x00, 0x00, 0x00, 0x14 },
 403         /* Black Level Subtract Level (also seen 0x01) */
 404         { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
 405         { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
 406         /* Color Gain B Pixel 5 a */
 407         { 0xa1, 0x40, 0x09, 0x05, 0x00, 0x00, 0x00, 0x14 },
 408         /* Color Gain G1 Pixel 1 5 */
 409         { 0xa1, 0x40, 0x0a, 0x04, 0x00, 0x00, 0x00, 0x14 },
 410         /* Color Gain G2 Pixel 1 0 5 */
 411         { 0xa1, 0x40, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x14 },
 412         /* Color Gain R Pixel 3 1 */
 413         { 0xa1, 0x40, 0x0c, 0x05, 0x00, 0x00, 0x00, 0x14 },
 414         /* Color GainH  Pixel */
 415         { 0xa1, 0x40, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x14 },
 416         /* Global Gain */
 417         { 0xa1, 0x40, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x14 },
 418         /* Contrast */
 419         { 0xa1, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x14 },
 420         /* H&V synchro polarity */
 421         { 0xa1, 0x40, 0x10, 0x06, 0x00, 0x00, 0x00, 0x14 },
 422         /* ?default */
 423         { 0xa1, 0x40, 0x11, 0x06, 0x00, 0x00, 0x00, 0x14 },
 424         /* DAC scale */
 425         { 0xa1, 0x40, 0x12, 0x06, 0x00, 0x00, 0x00, 0x14 },
 426         /* ?default */
 427         { 0xa1, 0x40, 0x14, 0x02, 0x00, 0x00, 0x00, 0x14 },
 428         /* Validate Settings */
 429         { 0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14 },
 430 };
 431
 432 static const __u8 initPas202[] = {
 433         0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00,
 434         0x00, 0x00,
 435         0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
 436         0x28, 0x1e, 0x28, 0x89, 0x20,
 437         0x00, 0x00, 0x02, 0x03, 0x0f, 0x0c
 438 };
 439 static const __u8 pas202_sensor_init[][8] = {
 440         {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10},
 441         {0xd0, 0x40, 0x04, 0x07, 0x34, 0x00, 0x09, 0x10},
 442         {0xd0, 0x40, 0x08, 0x01, 0x00, 0x00, 0x01, 0x10},
 443         {0xd0, 0x40, 0x0C, 0x00, 0x0C, 0x00, 0x32, 0x10},
 444         {0xd0, 0x40, 0x10, 0x00, 0x01, 0x00, 0x63, 0x10},
 445         {0xa0, 0x40, 0x15, 0x70, 0x01, 0x00, 0x63, 0x10},
 446         {0xa0, 0x40, 0x18, 0x00, 0x01, 0x00, 0x63, 0x10},
 447         {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
 448         {0xa0, 0x40, 0x03, 0x56, 0x01, 0x00, 0x63, 0x10},
 449         {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
 450         {0xb0, 0x40, 0x04, 0x07, 0x2a, 0x00, 0x63, 0x10},
 451         {0xb0, 0x40, 0x0e, 0x00, 0x3d, 0x00, 0x63, 0x10},
 452
 453         {0xa0, 0x40, 0x11, 0x01, 0x3d, 0x00, 0x63, 0x16},
 454         {0xa0, 0x40, 0x10, 0x08, 0x3d, 0x00, 0x63, 0x15},
 455         {0xa0, 0x40, 0x02, 0x04, 0x3d, 0x00, 0x63, 0x16},
 456         {0xa0, 0x40, 0x11, 0x01, 0x3d, 0x00, 0x63, 0x16},
 457         {0xb0, 0x40, 0x0e, 0x00, 0x31, 0x00, 0x63, 0x16},
 458         {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16},
 459         {0xa0, 0x40, 0x10, 0x0e, 0x31, 0x00, 0x63, 0x15},
 460         {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16},
 461 };
 462
 463 static const __u8 initTas5110[] = {
 464         0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
 465         0x00, 0x00,
 466         0x00, 0x01, 0x00, 0x45, 0x09, 0x0a,
 467         0x16, 0x12, 0x60, 0x86, 0x2b,
 468         0x14, 0x0a, 0x02, 0x02, 0x09, 0x07
 469 };
 470 static const __u8 tas5110_sensor_init[][8] = {
 471         {0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10},
 472         {0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10},
 473         {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17},
 474 };
 475
 476 static const __u8 initTas5130[] = {
 477         0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
 478         0x00, 0x00,
 479         0x00, 0x01, 0x00, 0x68, 0x0c, 0x0a,
 480         0x28, 0x1e, 0x60, COMP, MCK_INIT,
 481         0x18, 0x10, 0x04, 0x03, 0x11, 0x0c
 482 };
 483 static const __u8 tas5130_sensor_init[][8] = {
 484 /*      {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
 485                                         * shutter 0x47 short exposure? */
 486         {0x30, 0x11, 0x00, 0x40, 0x01, 0x00, 0x00, 0x10},
 487                                         /* shutter 0x01 long exposure */
 488         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10},
 489 };
 490
 491 static struct sensor_data sensor_data[] = {
 492 SENS(initHv7131, NULL, hv7131_sensor_init, NULL, NULL, 0, NO_EXPO|NO_FREQ, 0),
 493 SENS(initOv6650, NULL, ov6650_sensor_init, NULL, NULL, F_GAIN|F_SIF, 0, 0x60),
 494 SENS(initOv7630, initOv7630_3, ov7630_sensor_init, NULL, ov7630_sensor_init_3,
 495         F_GAIN, 0, 0x21),
 496 SENS(initPas106, NULL, pas106_sensor_init, NULL, NULL, F_SIF, NO_EXPO|NO_FREQ,
 497         0),
 498 SENS(initPas202, initPas202, pas202_sensor_init, NULL, NULL, 0,
 499         NO_EXPO|NO_FREQ, 0),
 500 SENS(initTas5110, NULL, tas5110_sensor_init, NULL, NULL, F_GAIN|F_SIF,
 501         NO_BRIGHTNESS|NO_FREQ, 0),
 502 SENS(initTas5130, NULL, tas5130_sensor_init, NULL, NULL, 0, NO_EXPO|NO_FREQ,
 503         0),
 504 };
 505
 506 /* get one byte in gspca_dev->usb_buf */
 507 static void reg_r(struct gspca_dev *gspca_dev,
 508                   __u16 value)
 509 {
 510         usb_control_msg(gspca_dev->dev,
 511                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 512                         0,                      /* request */
 513                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 514                         value,
 515                         0,                      /* index */
 516                         gspca_dev->usb_buf, 1,
 517                         500);
 518 }
 519
 520 static void reg_w(struct gspca_dev *gspca_dev,
 521                   __u16 value,
 522                   const __u8 *buffer,
 523                   int len)
 524 {
 525 #ifdef GSPCA_DEBUG
 526         if (len > USB_BUF_SZ) {
 527                 PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
 528                 return;
 529         }
 530 #endif
 531         memcpy(gspca_dev->usb_buf, buffer, len);
 532         usb_control_msg(gspca_dev->dev,
 533                         usb_sndctrlpipe(gspca_dev->dev, 0),
 534                         0x08,                   /* request */
 535                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 536                         value,
 537                         0,                      /* index */
 538                         gspca_dev->usb_buf, len,
 539                         500);
 540 }
 541
 542 static int i2c_w(struct gspca_dev *gspca_dev, const __u8 *buffer)
 543 {
 544         int retry = 60;
 545
 546         /* is i2c ready */
 547         reg_w(gspca_dev, 0x08, buffer, 8);
 548         while (retry--) {
 549                 msleep(10);
 550                 reg_r(gspca_dev, 0x08);
 551                 if (gspca_dev->usb_buf[0] & 0x04) {
 552                         if (gspca_dev->usb_buf[0] & 0x08)
 553                                 return -1;
 554                         return 0;
 555                 }
 556         }
 557         return -1;
 558 }
 559
 560 static void i2c_w_vector(struct gspca_dev *gspca_dev,
 561                         const __u8 buffer[][8], int len)
 562 {
 563         for (;;) {
 564                 reg_w(gspca_dev, 0x08, *buffer, 8);
 565                 len -= 8;
 566                 if (len <= 0)
 567                         break;
 568                 buffer++;
 569         }
 570 }
 571
 572 static void setbrightness(struct gspca_dev *gspca_dev)
 573 {
 574         struct sd *sd = (struct sd *) gspca_dev;
 575         __u8 value;
 576
 577         switch (sd->sensor) {
 578         case  SENSOR_OV6650:
 579         case  SENSOR_OV7630: {
 580                 __u8 i2cOV[] =
 581                         {0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10};
 582
 583                 /* change reg 0x06 */
 584                 i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
 585                 i2cOV[3] = sd->brightness;
 586                 if (i2c_w(gspca_dev, i2cOV) < 0)
 587                         goto err;
 588                 break;
 589             }
 590         case SENSOR_PAS106: {
 591                 __u8 i2c1[] =
 592                         {0xa1, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14};
 593
 594                 i2c1[3] = sd->brightness >> 3;
 595                 i2c1[2] = 0x0e;
 596                 if (i2c_w(gspca_dev, i2c1) < 0)
 597                         goto err;
 598                 i2c1[3] = 0x01;
 599                 i2c1[2] = 0x13;
 600                 if (i2c_w(gspca_dev, i2c1) < 0)
 601                         goto err;
 602                 break;
 603             }
 604         case SENSOR_PAS202: {
 605                 /* __u8 i2cpexpo1[] =
 606                         {0xb0, 0x40, 0x04, 0x07, 0x2a, 0x00, 0x63, 0x16}; */
 607                 __u8 i2cpexpo[] =
 608                         {0xb0, 0x40, 0x0e, 0x01, 0xab, 0x00, 0x63, 0x16};
 609                 __u8 i2cp202[] =
 610                         {0xa0, 0x40, 0x10, 0x0e, 0x31, 0x00, 0x63, 0x15};
 611                 static __u8 i2cpdoit[] =
 612                         {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16};
 613
 614                 /* change reg 0x10 */
 615                 i2cpexpo[4] = 0xff - sd->brightness;
 616 /*              if(i2c_w(gspca_dev,i2cpexpo1) < 0)
 617                         goto err; */
 618 /*              if(i2c_w(gspca_dev,i2cpdoit) < 0)
 619                         goto err; */
 620                 if (i2c_w(gspca_dev, i2cpexpo) < 0)
 621                         goto err;
 622                 if (i2c_w(gspca_dev, i2cpdoit) < 0)
 623                         goto err;
 624                 i2cp202[3] = sd->brightness >> 3;
 625                 if (i2c_w(gspca_dev, i2cp202) < 0)
 626                         goto err;
 627                 if (i2c_w(gspca_dev, i2cpdoit) < 0)
 628                         goto err;
 629                 break;
 630             }
 631         case SENSOR_TAS5130CXX: {
 632                 __u8 i2c[] =
 633                         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
 634
 635                 value = 0xff - sd->brightness;
 636                 i2c[4] = value;
 637                 PDEBUG(D_CONF, "brightness %d : %d", value, i2c[4]);
 638                 if (i2c_w(gspca_dev, i2c) < 0)
 639                         goto err;
 640                 break;
 641             }
 642         }
 643         return;
 644 err:
 645         PDEBUG(D_ERR, "i2c error brightness");
 646 }
 647
 648 static void setsensorgain(struct gspca_dev *gspca_dev)
 649 {
 650         struct sd *sd = (struct sd *) gspca_dev;
 651         unsigned char gain = sd->gain;
 652
 653         switch (sd->sensor) {
 654
 655         case SENSOR_TAS5110: {
 656                 __u8 i2c[] =
 657                         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
 658
 659                 i2c[4] = 255 - gain;
 660                 if (i2c_w(gspca_dev, i2c) < 0)
 661                         goto err;
 662                 break;
 663             }
 664
 665         case SENSOR_OV6650:
 666                 gain >>= 1;
 667                 /* fall thru */
 668         case SENSOR_OV7630: {
 669                 __u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
 670
 671                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
 672                 i2c[3] = gain >> 2;
 673                 if (i2c_w(gspca_dev, i2c) < 0)
 674                         goto err;
 675                 break;
 676             }
 677         }
 678         return;
 679 err:
 680         PDEBUG(D_ERR, "i2c error gain");
 681 }
 682
 683 static void setgain(struct gspca_dev *gspca_dev)
 684 {
 685         struct sd *sd = (struct sd *) gspca_dev;
 686         __u8 gain;
 687         __u8 rgb_value;
 688
 689         gain = sd->gain >> 4;
 690
 691         /* red and blue gain */
 692         rgb_value = gain << 4 | gain;
 693         reg_w(gspca_dev, 0x10, &rgb_value, 1);
 694         /* green gain */
 695         rgb_value = gain;
 696         reg_w(gspca_dev, 0x11, &rgb_value, 1);
 697
 698         if (sensor_data[sd->sensor].flags & F_GAIN)
 699                 setsensorgain(gspca_dev);
 700 }
 701
 702 static void setexposure(struct gspca_dev *gspca_dev)
 703 {
 704         struct sd *sd = (struct sd *) gspca_dev;
 705
 706         switch (sd->sensor) {
 707         case SENSOR_TAS5110: {
 708                 __u8 reg;
 709
 710                 /* register 19's high nibble contains the sn9c10x clock divider
 711                    The high nibble configures the no fps according to the
 712                    formula: 60 / high_nibble. With a maximum of 30 fps */
 713                 reg = 120 * sd->exposure / 1000;
 714                 if (reg < 2)
 715                         reg = 2;
 716                 else if (reg > 15)
 717                         reg = 15;
 718                 reg = (reg << 4) | 0x0b;
 719                 reg_w(gspca_dev, 0x19, &reg, 1);
 720                 break;
 721             }
 722         case SENSOR_OV6650:
 723         case SENSOR_OV7630: {
 724                 /* The ov6650 / ov7630 have 2 registers which both influence
 725                    exposure, register 11, whose low nibble sets the nr off fps
 726                    according to: fps = 30 / (low_nibble + 1)
 727
 728                    The fps configures the maximum exposure setting, but it is
 729                    possible to use less exposure then what the fps maximum
 730                    allows by setting register 10. register 10 configures the
 731                    actual exposure as quotient of the full exposure, with 0
 732                    being no exposure at all (not very usefull) and reg10_max
 733                    being max exposure possible at that framerate.
 734
 735                    The code maps our 0 - 510 ms exposure ctrl to these 2
 736                    registers, trying to keep fps as high as possible.
 737                 */
 738                 __u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10};
 739                 int reg10, reg11, reg10_max;
 740
 741                 /* ov6645 datasheet says reg10_max is 9a, but that uses
 742                    tline * 2 * reg10 as formula for calculating texpo, the
 743                    ov6650 probably uses the same formula as the 7730 which uses
 744                    tline * 4 * reg10, which explains why the reg10max we've
 745                    found experimentally for the ov6650 is exactly half that of
 746                    the ov6645. The ov7630 datasheet says the max is 0x41. */
 747                 if (sd->sensor == SENSOR_OV6650) {
 748                         reg10_max = 0x4d;
 749                         i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */
 750                 } else
 751                         reg10_max = 0x41;
 752
 753                 reg11 = (60 * sd->exposure + 999) / 1000;
 754                 if (reg11 < 1)
 755                         reg11 = 1;
 756                 else if (reg11 > 16)
 757                         reg11 = 16;
 758
 759                 /* In 640x480, if the reg11 has less than 3, the image is
 760                    unstable (not enough bandwidth). */
 761                 if (gspca_dev->width == 640 && reg11 < 3)
 762                         reg11 = 3;
 763
 764                 /* frame exposure time in ms = 1000 * reg11 / 30    ->
 765                 reg10 = sd->exposure * 2 * reg10_max / (1000 * reg11 / 30) */
 766                 reg10 = (sd->exposure * 60 * reg10_max) / (1000 * reg11);
 767
 768                 /* Don't allow this to get below 10 when using autogain, the
 769                    steps become very large (relatively) when below 10 causing
 770                    the image to oscilate from much too dark, to much too bright
 771                    and back again. */
 772                 if (sd->autogain && reg10 < 10)
 773                         reg10 = 10;
 774                 else if (reg10 > reg10_max)
 775                         reg10 = reg10_max;
 776
 777                 /* Write reg 10 and reg11 low nibble */
 778                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
 779                 i2c[3] = reg10;
 780                 i2c[4] |= reg11 - 1;
 781
 782                 /* If register 11 didn't change, don't change it */
 783                 if (sd->reg11 == reg11 )
 784                         i2c[0] = 0xa0;
 785
 786                 if (i2c_w(gspca_dev, i2c) == 0)
 787                         sd->reg11 = reg11;
 788                 else
 789                         PDEBUG(D_ERR, "i2c error exposure");
 790                 break;
 791             }
 792         }
 793 }
 794
 795 static void setfreq(struct gspca_dev *gspca_dev)
 796 {
 797         struct sd *sd = (struct sd *) gspca_dev;
 798
 799         switch (sd->sensor) {
 800         case SENSOR_OV6650:
 801         case SENSOR_OV7630: {
 802                 /* Framerate adjust register for artificial light 50 hz flicker
 803                    compensation, for the ov6650 this is identical to ov6630
 804                    0x2b register, see ov6630 datasheet.
 805                    0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
 806                 __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
 807                 switch (sd->freq) {
 808                 default:
 809 /*              case 0:                  * no filter*/
 810 /*              case 2:                  * 60 hz */
 811                         i2c[3] = 0;
 812                         break;
 813                 case 1:                 /* 50 hz */
 814                         i2c[3] = (sd->sensor == SENSOR_OV6650)
 815                                         ? 0x4f : 0x8a;
 816                         break;
 817                 }
 818                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
 819                 if (i2c_w(gspca_dev, i2c) < 0)
 820                         PDEBUG(D_ERR, "i2c error setfreq");
 821                 break;
 822             }
 823         }
 824 }
 825
 826 static void do_autogain(struct gspca_dev *gspca_dev)
 827 {
 828         int deadzone, desired_avg_lum;
 829         struct sd *sd = (struct sd *) gspca_dev;
 830         int avg_lum = atomic_read(&sd->avg_lum);
 831
 832         if (avg_lum == -1)
 833                 return;
 834
 835         /* SIF / VGA sensors have a different autoexposure area and thus
 836            different avg_lum values for the same picture brightness */
 837         if (sensor_data[sd->sensor].flags & F_SIF) {
 838                 deadzone = 1000;
 839                 desired_avg_lum = 7000;
 840         } else {
 841                 deadzone = 3000;
 842                 desired_avg_lum = 23000;
 843         }
 844
 845         if (sd->autogain_ignore_frames > 0)
 846                 sd->autogain_ignore_frames--;
 847         else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
 848                         sd->brightness * desired_avg_lum / 127,
 849                         deadzone, GAIN_KNEE, EXPOSURE_KNEE)) {
 850                 PDEBUG(D_FRAM, "autogain: gain changed: gain: %d expo: %d",
 851                         (int)sd->gain, (int)sd->exposure);
 852                 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
 853         }
 854 }
 855
 856 /* this function is called at probe time */
 857 static int sd_config(struct gspca_dev *gspca_dev,
 858                         const struct usb_device_id *id)
 859 {
 860         struct sd *sd = (struct sd *) gspca_dev;
 861         struct cam *cam;
 862
 863         reg_r(gspca_dev, 0x00);
 864         if (gspca_dev->usb_buf[0] != 0x10)
 865                 return -ENODEV;
 866
 867         /* copy the webcam info from the device id */
 868         sd->sensor = id->driver_info >> 8;
 869         sd->bridge = id->driver_info & 0xff;
 870         gspca_dev->ctrl_dis = sensor_data[sd->sensor].ctrl_dis;
 871
 872         cam = &gspca_dev->cam;
 873         cam->epaddr = 0x01;
 874         if (!(sensor_data[sd->sensor].flags & F_SIF)) {
 875                 cam->cam_mode = vga_mode;
 876                 cam->nmodes = ARRAY_SIZE(vga_mode);
 877         } else {
 878                 cam->cam_mode = sif_mode;
 879                 cam->nmodes = ARRAY_SIZE(sif_mode);
 880         }
 881         sd->brightness = BRIGHTNESS_DEF;
 882         sd->gain = GAIN_DEF;
 883         sd->exposure = EXPOSURE_DEF;
 884         if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
 885                 sd->autogain = 0; /* Disable do_autogain callback */
 886         else
 887                 sd->autogain = AUTOGAIN_DEF;
 888         sd->freq = FREQ_DEF;
 889
 890         return 0;
 891 }
 892
 893 /* this function is called at probe and resume time */
 894 static int sd_init(struct gspca_dev *gspca_dev)
 895 {
 896         const __u8 stop = 0x09; /* Disable stream turn of LED */
 897
 898         reg_w(gspca_dev, 0x01, &stop, 1);
 899
 900         return 0;
 901 }
 902
 903 /* -- start the camera -- */
 904 static int sd_start(struct gspca_dev *gspca_dev)
 905 {
 906         struct sd *sd = (struct sd *) gspca_dev;
 907         struct cam *cam = &gspca_dev->cam;
 908         int mode, l;
 909         const __u8 *sn9c10x;
 910         __u8 reg12_19[8];
 911
 912         mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
 913         sn9c10x = sensor_data[sd->sensor].bridge_init[sd->bridge];
 914         l = sensor_data[sd->sensor].bridge_init_size[sd->bridge];
 915         memcpy(reg12_19, &sn9c10x[0x12 - 1], 8);
 916         reg12_19[6] = sn9c10x[0x18 - 1] | (mode << 4);
 917         /* Special cases where reg 17 and or 19 value depends on mode */
 918         switch (sd->sensor) {
 919         case SENSOR_PAS202:
 920                 reg12_19[5] = mode ? 0x24 : 0x20;
 921                 break;
 922         case SENSOR_TAS5130CXX:
 923                 /* probably not mode specific at all most likely the upper
 924                    nibble of 0x19 is exposure (clock divider) just as with
 925                    the tas5110, we need someone to test this. */
 926                 reg12_19[7] = mode ? 0x23 : 0x43;
 927                 break;
 928         }
 929         /* Disable compression when the raw bayer format has been selected */
 930         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
 931                 reg12_19[6] &= ~0x80;
 932
 933         /* Vga mode emulation on SIF sensor? */
 934         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
 935                 reg12_19[0] += 16; /* 0x12: hstart adjust */
 936                 reg12_19[1] += 24; /* 0x13: vstart adjust */
 937                 reg12_19[3] = 320 / 16; /* 0x15: hsize */
 938                 reg12_19[4] = 240 / 16; /* 0x16: vsize */
 939         }
 940
 941         /* reg 0x01 bit 2 video transfert on */
 942         reg_w(gspca_dev, 0x01, &sn9c10x[0x01 - 1], 1);
 943         /* reg 0x17 SensorClk enable inv Clk 0x60 */
 944         reg_w(gspca_dev, 0x17, &sn9c10x[0x17 - 1], 1);
 945         /* Set the registers from the template */
 946         reg_w(gspca_dev, 0x01, sn9c10x, l);
 947
 948         /* Init the sensor */
 949         i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
 950                         sensor_data[sd->sensor].sensor_init_size);
 951         if (sensor_data[sd->sensor].sensor_bridge_init[sd->bridge])
 952                 i2c_w_vector(gspca_dev,
 953                         sensor_data[sd->sensor].sensor_bridge_init[sd->bridge],
 954                         sensor_data[sd->sensor].sensor_bridge_init_size[
 955                                 sd->bridge]);
 956
 957         /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
 958         reg_w(gspca_dev, 0x15, &reg12_19[3], 2);
 959         /* compression register */
 960         reg_w(gspca_dev, 0x18, &reg12_19[6], 1);
 961         /* H_start */
 962         reg_w(gspca_dev, 0x12, &reg12_19[0], 1);
 963         /* V_START */
 964         reg_w(gspca_dev, 0x13, &reg12_19[1], 1);
 965         /* reset 0x17 SensorClk enable inv Clk 0x60 */
 966                                 /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
 967         reg_w(gspca_dev, 0x17, &reg12_19[5], 1);
 968         /*MCKSIZE ->3 */        /*fixme: not ov7630*/
 969         reg_w(gspca_dev, 0x19, &reg12_19[7], 1);
 970         /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
 971         reg_w(gspca_dev, 0x1c, &sn9c10x[0x1c - 1], 4);
 972         /* Enable video transfert */
 973         reg_w(gspca_dev, 0x01, &sn9c10x[0], 1);
 974         /* Compression */
 975         reg_w(gspca_dev, 0x18, &reg12_19[6], 2);
 976         msleep(20);
 977
 978         sd->reg11 = -1;
 979
 980         setgain(gspca_dev);
 981         setbrightness(gspca_dev);
 982         setexposure(gspca_dev);
 983         setfreq(gspca_dev);
 984
 985         sd->frames_to_drop = 0;
 986         sd->autogain_ignore_frames = 0;
 987         atomic_set(&sd->avg_lum, -1);
 988         return 0;
 989 }
 990
 991 static void sd_stopN(struct gspca_dev *gspca_dev)
 992 {
 993         sd_init(gspca_dev);
 994 }
 995
 996 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 997                         struct gspca_frame *frame,      /* target */
 998                         unsigned char *data,            /* isoc packet */
 999                         int len)                        /* iso packet length */
1000 {
1001         int i;
1002         struct sd *sd = (struct sd *) gspca_dev;
1003         struct cam *cam = &gspca_dev->cam;
1004
1005         /* frames start with:
1006          *      ff ff 00 c4 c4 96       synchro
1007          *      00              (unknown)
1008          *      xx              (frame sequence / size / compression)
1009          *      (xx)            (idem - extra byte for sn9c103)
1010          *      ll mm           brightness sum inside auto exposure
1011          *      ll mm           brightness sum outside auto exposure
1012          *      (xx xx xx xx xx)        audio values for snc103
1013          */
1014         if (len > 6 && len < 24) {
1015                 for (i = 0; i < len - 6; i++) {
1016                         if (data[0 + i] == 0xff
1017                             && data[1 + i] == 0xff
1018                             && data[2 + i] == 0x00
1019                             && data[3 + i] == 0xc4
1020                             && data[4 + i] == 0xc4
1021                             && data[5 + i] == 0x96) {   /* start of frame */
1022                                 int lum = -1;
1023                                 int pkt_type = LAST_PACKET;
1024                                 int fr_h_sz = (sd->bridge == BRIDGE_103) ?
1025                                         18 : 12;
1026
1027                                 if (len - i < fr_h_sz) {
1028                                         PDEBUG(D_STREAM, "packet too short to"
1029                                                 " get avg brightness");
1030                                 } else if (sd->bridge == BRIDGE_103) {
1031                                         lum = data[i + 9] +
1032                                                 (data[i + 10] << 8);
1033                                 } else {
1034                                         lum = data[i + 8] + (data[i + 9] << 8);
1035                                 }
1036                                 /* When exposure changes midway a frame we
1037                                    get a lum of 0 in this case drop 2 frames
1038                                    as the frames directly after an exposure
1039                                    change have an unstable image. Sometimes lum
1040                                    *really* is 0 (cam used in low light with
1041                                    low exposure setting), so do not drop frames
1042                                    if the previous lum was 0 too. */
1043                                 if (lum == 0 && sd->prev_avg_lum != 0) {
1044                                         lum = -1;
1045                                         sd->frames_to_drop = 2;
1046                                         sd->prev_avg_lum = 0;
1047                                 } else
1048                                         sd->prev_avg_lum = lum;
1049                                 atomic_set(&sd->avg_lum, lum);
1050
1051                                 if (sd->frames_to_drop) {
1052                                         sd->frames_to_drop--;
1053                                         pkt_type = DISCARD_PACKET;
1054                                 }
1055
1056                                 frame = gspca_frame_add(gspca_dev, pkt_type,
1057                                                         frame, data, 0);
1058                                 data += i + fr_h_sz;
1059                                 len -= i + fr_h_sz;
1060                                 gspca_frame_add(gspca_dev, FIRST_PACKET,
1061                                                 frame, data, len);
1062                                 return;
1063                         }
1064                 }
1065         }
1066
1067         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
1068                 /* In raw mode we sometimes get some garbage after the frame
1069                    ignore this */
1070                 int used = frame->data_end - frame->data;
1071                 int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
1072
1073                 if (used + len > size)
1074                         len = size - used;
1075         }
1076
1077         gspca_frame_add(gspca_dev, INTER_PACKET,
1078                         frame, data, len);
1079 }
1080
1081 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1082 {
1083         struct sd *sd = (struct sd *) gspca_dev;
1084
1085         sd->brightness = val;
1086         if (gspca_dev->streaming)
1087                 setbrightness(gspca_dev);
1088         return 0;
1089 }
1090
1091 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1092 {
1093         struct sd *sd = (struct sd *) gspca_dev;
1094
1095         *val = sd->brightness;
1096         return 0;
1097 }
1098
1099 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
1100 {
1101         struct sd *sd = (struct sd *) gspca_dev;
1102
1103         sd->gain = val;
1104         if (gspca_dev->streaming)
1105                 setgain(gspca_dev);
1106         return 0;
1107 }
1108
1109 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1110 {
1111         struct sd *sd = (struct sd *) gspca_dev;
1112
1113         *val = sd->gain;
1114         return 0;
1115 }
1116
1117 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
1118 {
1119         struct sd *sd = (struct sd *) gspca_dev;
1120
1121         sd->exposure = val;
1122         if (gspca_dev->streaming)
1123                 setexposure(gspca_dev);
1124         return 0;
1125 }
1126
1127 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
1128 {
1129         struct sd *sd = (struct sd *) gspca_dev;
1130
1131         *val = sd->exposure;
1132         return 0;
1133 }
1134
1135 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1136 {
1137         struct sd *sd = (struct sd *) gspca_dev;
1138
1139         sd->autogain = val;
1140         /* when switching to autogain set defaults to make sure
1141            we are on a valid point of the autogain gain /
1142            exposure knee graph, and give this change time to
1143            take effect before doing autogain. */
1144         if (sd->autogain) {
1145                 sd->exposure = EXPOSURE_DEF;
1146                 sd->gain = GAIN_DEF;
1147                 if (gspca_dev->streaming) {
1148                         sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
1149                         setexposure(gspca_dev);
1150                         setgain(gspca_dev);
1151                 }
1152         }
1153
1154         return 0;
1155 }
1156
1157 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1158 {
1159         struct sd *sd = (struct sd *) gspca_dev;
1160
1161         *val = sd->autogain;
1162         return 0;
1163 }
1164
1165 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
1166 {
1167         struct sd *sd = (struct sd *) gspca_dev;
1168
1169         sd->freq = val;
1170         if (gspca_dev->streaming)
1171                 setfreq(gspca_dev);
1172         return 0;
1173 }
1174
1175 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
1176 {
1177         struct sd *sd = (struct sd *) gspca_dev;
1178
1179         *val = sd->freq;
1180         return 0;
1181 }
1182
1183 static int sd_querymenu(struct gspca_dev *gspca_dev,
1184                         struct v4l2_querymenu *menu)
1185 {
1186         switch (menu->id) {
1187         case V4L2_CID_POWER_LINE_FREQUENCY:
1188                 switch (menu->index) {
1189                 case 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
1190                         strcpy((char *) menu->name, "NoFliker");
1191                         return 0;
1192                 case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1193                         strcpy((char *) menu->name, "50 Hz");
1194                         return 0;
1195                 case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
1196                         strcpy((char *) menu->name, "60 Hz");
1197                         return 0;
1198                 }
1199                 break;
1200         }
1201         return -EINVAL;
1202 }
1203
1204 /* sub-driver description */
1205 static const struct sd_desc sd_desc = {
1206         .name = MODULE_NAME,
1207         .ctrls = sd_ctrls,
1208         .nctrls = ARRAY_SIZE(sd_ctrls),
1209         .config = sd_config,
1210         .init = sd_init,
1211         .start = sd_start,
1212         .stopN = sd_stopN,
1213         .pkt_scan = sd_pkt_scan,
1214         .querymenu = sd_querymenu,
1215         .dq_callback = do_autogain,
1216 };
1217
1218 /* -- module initialisation -- */
1219 #define SB(sensor, bridge) \
1220         .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
1221
1222
1223 static __devinitdata struct usb_device_id device_table[] = {
1224         {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110, 102)}, /* TAS5110C1B */
1225         {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110, 101)}, /* TAS5110C1B */
1226 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1227         {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110, 101)}, /* TAS5110D */
1228         {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
1229         {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
1230 #endif
1231         {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
1232 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1233         {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
1234         {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
1235         {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
1236         {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
1237         {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
1238 #endif
1239         {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
1240         {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
1241 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1242         {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
1243 #endif
1244         {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
1245 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1246         {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
1247 #endif
1248         {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
1249         {}
1250 };
1251 MODULE_DEVICE_TABLE(usb, device_table);
1252
1253 /* -- device connect -- */
1254 static int sd_probe(struct usb_interface *intf,
1255                         const struct usb_device_id *id)
1256 {
1257         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1258                                 THIS_MODULE);
1259 }
1260
1261 static struct usb_driver sd_driver = {
1262         .name = MODULE_NAME,
1263         .id_table = device_table,
1264         .probe = sd_probe,
1265         .disconnect = gspca_disconnect,
1266 #ifdef CONFIG_PM
1267         .suspend = gspca_suspend,
1268         .resume = gspca_resume,
1269 #endif
1270 };
1271
1272 /* -- module insert / remove -- */
1273 static int __init sd_mod_init(void)
1274 {
1275         if (usb_register(&sd_driver) < 0)
1276                 return -1;
1277         PDEBUG(D_PROBE, "registered");
1278         return 0;
1279 }
1280 static void __exit sd_mod_exit(void)
1281 {
1282         usb_deregister(&sd_driver);
1283         PDEBUG(D_PROBE, "deregistered");
1284 }
1285
1286 module_init(sd_mod_init);
1287 module_exit(sd_mod_exit);