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