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