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 sn9c101 / sn9c102:
  27 0x10    high nibble red gain low nibble blue gain
  28 0x11    low nibble green gain
  29 sn9c103:
  30 0x05    red gain 0-127
  31 0x06    blue gain 0-127
  32 0x07    green gain 0-127
  33 all:
  34 0x08-0x0f i2c / 3wire registers
  35 0x12    hstart
  36 0x13    vstart
  37 0x15    hsize (hsize = register-value * 16)
  38 0x16    vsize (vsize = register-value * 16)
  39 0x17    bit 0 toggle compression quality (according to sn9c102 driver)
  40 0x18    bit 7 enables compression, bit 4-5 set image down scaling:
  41         00 scale 1, 01 scale 1/2, 10, scale 1/4
  42 0x19    high-nibble is sensor clock divider, changes exposure on sensors which
  43         use a clock generated by the bridge. Some sensors have their own clock.
  44 0x1c    auto_exposure area (for avg_lum) startx (startx = register-value * 32)
  45 0x1d    auto_exposure area (for avg_lum) starty (starty = register-value * 32)
  46 0x1e    auto_exposure area (for avg_lum) stopx (hsize = (0x1e - 0x1c) * 32)
  47 0x1f    auto_exposure area (for avg_lum) stopy (vsize = (0x1f - 0x1d) * 32)
  48 */
  49
  50 #define MODULE_NAME "sonixb"
  51
  52 #include <linux/input.h>
  53 #include "gspca.h"
  54
  55 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
  56 MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver");
  57 MODULE_LICENSE("GPL");
  58
  59 /* specific webcam descriptor */
  60 struct sd {
  61         struct gspca_dev gspca_dev;     /* !! must be the first item */
  62         atomic_t avg_lum;
  63         int prev_avg_lum;
  64         int exp_too_low_cnt;
  65         int exp_too_high_cnt;
  66         int header_read;
  67         u8 header[12]; /* Header without sof marker */
  68
  69         unsigned short exposure;
  70         unsigned char gain;
  71         unsigned char brightness;
  72         unsigned char autogain;
  73         unsigned char autogain_ignore_frames;
  74         unsigned char frames_to_drop;
  75         unsigned char freq;             /* light freq filter setting */
  76
  77         __u8 bridge;                    /* Type of bridge */
  78 #define BRIDGE_101 0
  79 #define BRIDGE_102 0 /* We make no difference between 101 and 102 */
  80 #define BRIDGE_103 1
  81
  82         __u8 sensor;                    /* Type of image sensor chip */
  83 #define SENSOR_HV7131D 0
  84 #define SENSOR_HV7131R 1
  85 #define SENSOR_OV6650 2
  86 #define SENSOR_OV7630 3
  87 #define SENSOR_PAS106 4
  88 #define SENSOR_PAS202 5
  89 #define SENSOR_TAS5110C 6
  90 #define SENSOR_TAS5110D 7
  91 #define SENSOR_TAS5130CXX 8
  92         __u8 reg11;
  93 };
  94
  95 typedef const __u8 sensor_init_t[8];
  96
  97 struct sensor_data {
  98         const __u8 *bridge_init;
  99         sensor_init_t *sensor_init;
 100         int sensor_init_size;
 101         int flags;
 102         unsigned ctrl_dis;
 103         __u8 sensor_addr;
 104 };
 105
 106 /* sensor_data flags */
 107 #define F_GAIN 0x01             /* has gain */
 108 #define F_SIF  0x02             /* sif or vga */
 109 #define F_COARSE_EXPO 0x04      /* exposure control is coarse */
 110
 111 /* priv field of struct v4l2_pix_format flags (do not use low nibble!) */
 112 #define MODE_RAW 0x10           /* raw bayer mode */
 113 #define MODE_REDUCED_SIF 0x20   /* vga mode (320x240 / 160x120) on sif cam */
 114
 115 /* ctrl_dis helper macros */
 116 #define NO_EXPO ((1 << EXPOSURE_IDX) | (1 << COARSE_EXPOSURE_IDX) | \
 117                  (1 << AUTOGAIN_IDX))
 118 #define NO_FREQ (1 << FREQ_IDX)
 119 #define NO_BRIGHTNESS (1 << BRIGHTNESS_IDX)
 120
 121 #define COMP 0xc7               /* 0x87 //0x07 */
 122 #define COMP1 0xc9              /* 0x89 //0x09 */
 123
 124 #define MCK_INIT 0x63
 125 #define MCK_INIT1 0x20          /*fixme: Bayer - 0x50 for JPEG ??*/
 126
 127 #define SYS_CLK 0x04
 128
 129 #define SENS(bridge, sensor, _flags, _ctrl_dis, _sensor_addr) \
 130 { \
 131         .bridge_init = bridge, \
 132         .sensor_init = sensor, \
 133         .sensor_init_size = sizeof(sensor), \
 134         .flags = _flags, .ctrl_dis = _ctrl_dis, .sensor_addr = _sensor_addr \
 135 }
 136
 137 /* We calculate the autogain at the end of the transfer of a frame, at this
 138    moment a frame with the old settings is being captured and transmitted. So
 139    if we adjust the gain or exposure we must ignore atleast the next frame for
 140    the new settings to come into effect before doing any other adjustments. */
 141 #define AUTOGAIN_IGNORE_FRAMES 1
 142
 143 /* V4L2 controls supported by the driver */
 144 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
 145 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
 146 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
 147 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
 148 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
 149 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
 150 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
 151 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
 152 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
 153 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 154
 155 static const struct ctrl sd_ctrls[] = {
 156 #define BRIGHTNESS_IDX 0
 157         {
 158             {
 159                 .id      = V4L2_CID_BRIGHTNESS,
 160                 .type    = V4L2_CTRL_TYPE_INTEGER,
 161                 .name    = "Brightness",
 162                 .minimum = 0,
 163                 .maximum = 255,
 164                 .step    = 1,
 165 #define BRIGHTNESS_DEF 127
 166                 .default_value = BRIGHTNESS_DEF,
 167             },
 168             .set = sd_setbrightness,
 169             .get = sd_getbrightness,
 170         },
 171 #define GAIN_IDX 1
 172         {
 173             {
 174                 .id      = V4L2_CID_GAIN,
 175                 .type    = V4L2_CTRL_TYPE_INTEGER,
 176                 .name    = "Gain",
 177                 .minimum = 0,
 178                 .maximum = 255,
 179                 .step    = 1,
 180 #define GAIN_DEF 127
 181 #define GAIN_KNEE 230
 182                 .default_value = GAIN_DEF,
 183             },
 184             .set = sd_setgain,
 185             .get = sd_getgain,
 186         },
 187 #define EXPOSURE_IDX 2
 188         {
 189                 {
 190                         .id = V4L2_CID_EXPOSURE,
 191                         .type = V4L2_CTRL_TYPE_INTEGER,
 192                         .name = "Exposure",
 193 #define EXPOSURE_DEF  66 /*  33 ms / 30 fps (except on PASXXX) */
 194 #define EXPOSURE_KNEE 200 /* 100 ms / 10 fps (except on PASXXX) */
 195                         .minimum = 0,
 196                         .maximum = 1023,
 197                         .step = 1,
 198                         .default_value = EXPOSURE_DEF,
 199                         .flags = 0,
 200                 },
 201                 .set = sd_setexposure,
 202                 .get = sd_getexposure,
 203         },
 204 #define COARSE_EXPOSURE_IDX 3
 205         {
 206                 {
 207                         .id = V4L2_CID_EXPOSURE,
 208                         .type = V4L2_CTRL_TYPE_INTEGER,
 209                         .name = "Exposure",
 210 #define COARSE_EXPOSURE_DEF  2 /* 30 fps */
 211                         .minimum = 2,
 212                         .maximum = 15,
 213                         .step = 1,
 214                         .default_value = COARSE_EXPOSURE_DEF,
 215                         .flags = 0,
 216                 },
 217                 .set = sd_setexposure,
 218                 .get = sd_getexposure,
 219         },
 220 #define AUTOGAIN_IDX 4
 221         {
 222                 {
 223                         .id = V4L2_CID_AUTOGAIN,
 224                         .type = V4L2_CTRL_TYPE_BOOLEAN,
 225                         .name = "Automatic Gain (and Exposure)",
 226                         .minimum = 0,
 227                         .maximum = 1,
 228                         .step = 1,
 229 #define AUTOGAIN_DEF 1
 230                         .default_value = AUTOGAIN_DEF,
 231                         .flags = 0,
 232                 },
 233                 .set = sd_setautogain,
 234                 .get = sd_getautogain,
 235         },
 236 #define FREQ_IDX 5
 237         {
 238                 {
 239                         .id      = V4L2_CID_POWER_LINE_FREQUENCY,
 240                         .type    = V4L2_CTRL_TYPE_MENU,
 241                         .name    = "Light frequency filter",
 242                         .minimum = 0,
 243                         .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
 244                         .step    = 1,
 245 #define FREQ_DEF 0
 246                         .default_value = FREQ_DEF,
 247                 },
 248                 .set = sd_setfreq,
 249                 .get = sd_getfreq,
 250         },
 251 };
 252
 253 static const struct v4l2_pix_format vga_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 = 2 | MODE_RAW},
 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 = 2},
 264         {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 265                 .bytesperline = 320,
 266                 .sizeimage = 320 * 240 * 5 / 4,
 267                 .colorspace = V4L2_COLORSPACE_SRGB,
 268                 .priv = 1},
 269         {640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 270                 .bytesperline = 640,
 271                 .sizeimage = 640 * 480 * 5 / 4,
 272                 .colorspace = V4L2_COLORSPACE_SRGB,
 273                 .priv = 0},
 274 };
 275 static const struct v4l2_pix_format sif_mode[] = {
 276         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 277                 .bytesperline = 160,
 278                 .sizeimage = 160 * 120,
 279                 .colorspace = V4L2_COLORSPACE_SRGB,
 280                 .priv = 1 | MODE_RAW | MODE_REDUCED_SIF},
 281         {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 282                 .bytesperline = 160,
 283                 .sizeimage = 160 * 120 * 5 / 4,
 284                 .colorspace = V4L2_COLORSPACE_SRGB,
 285                 .priv = 1 | MODE_REDUCED_SIF},
 286         {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 287                 .bytesperline = 176,
 288                 .sizeimage = 176 * 144,
 289                 .colorspace = V4L2_COLORSPACE_SRGB,
 290                 .priv = 1 | MODE_RAW},
 291         {176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 292                 .bytesperline = 176,
 293                 .sizeimage = 176 * 144 * 5 / 4,
 294                 .colorspace = V4L2_COLORSPACE_SRGB,
 295                 .priv = 1},
 296         {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 297                 .bytesperline = 320,
 298                 .sizeimage = 320 * 240 * 5 / 4,
 299                 .colorspace = V4L2_COLORSPACE_SRGB,
 300                 .priv = 0 | MODE_REDUCED_SIF},
 301         {352, 288, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 302                 .bytesperline = 352,
 303                 .sizeimage = 352 * 288 * 5 / 4,
 304                 .colorspace = V4L2_COLORSPACE_SRGB,
 305                 .priv = 0},
 306 };
 307
 308 static const __u8 initHv7131d[] = {
 309         0x04, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
 310         0x00, 0x00,
 311         0x00, 0x00, 0x00, 0x02, 0x02, 0x00,
 312         0x28, 0x1e, 0x60, 0x8e, 0x42,
 313 };
 314 static const __u8 hv7131d_sensor_init[][8] = {
 315         {0xa0, 0x11, 0x01, 0x04, 0x00, 0x00, 0x00, 0x17},
 316         {0xa0, 0x11, 0x02, 0x00, 0x00, 0x00, 0x00, 0x17},
 317         {0xa0, 0x11, 0x28, 0x00, 0x00, 0x00, 0x00, 0x17},
 318         {0xa0, 0x11, 0x30, 0x30, 0x00, 0x00, 0x00, 0x17}, /* reset level */
 319         {0xa0, 0x11, 0x34, 0x02, 0x00, 0x00, 0x00, 0x17}, /* pixel bias volt */
 320 };
 321
 322 static const __u8 initHv7131r[] = {
 323         0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
 324         0x00, 0x00,
 325         0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
 326         0x28, 0x1e, 0x60, 0x8a, 0x20,
 327 };
 328 static const __u8 hv7131r_sensor_init[][8] = {
 329         {0xc0, 0x11, 0x31, 0x38, 0x2a, 0x2e, 0x00, 0x10},
 330         {0xa0, 0x11, 0x01, 0x08, 0x2a, 0x2e, 0x00, 0x10},
 331         {0xb0, 0x11, 0x20, 0x00, 0xd0, 0x2e, 0x00, 0x10},
 332         {0xc0, 0x11, 0x25, 0x03, 0x0e, 0x28, 0x00, 0x16},
 333         {0xa0, 0x11, 0x30, 0x10, 0x0e, 0x28, 0x00, 0x15},
 334 };
 335 static const __u8 initOv6650[] = {
 336         0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
 337         0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 338         0x00, 0x01, 0x01, 0x0a, 0x16, 0x12, 0x68, 0x8b,
 339         0x10,
 340 };
 341 static const __u8 ov6650_sensor_init[][8] = {
 342         /* Bright, contrast, etc are set through SCBB interface.
 343          * AVCAP on win2 do not send any data on this controls. */
 344         /* Anyway, some registers appears to alter bright and constrat */
 345
 346         /* Reset sensor */
 347         {0xa0, 0x60, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
 348         /* Set clock register 0x11 low nibble is clock divider */
 349         {0xd0, 0x60, 0x11, 0xc0, 0x1b, 0x18, 0xc1, 0x10},
 350         /* Next some unknown stuff */
 351         {0xb0, 0x60, 0x15, 0x00, 0x02, 0x18, 0xc1, 0x10},
 352 /*      {0xa0, 0x60, 0x1b, 0x01, 0x02, 0x18, 0xc1, 0x10},
 353                  * THIS SET GREEN SCREEN
 354                  * (pixels could be innverted in decode kind of "brg",
 355                  * but blue wont be there. Avoid this data ... */
 356         {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10}, /* format out? */
 357         {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10},
 358         {0xa0, 0x60, 0x30, 0x3d, 0x0a, 0xd8, 0xa4, 0x10},
 359         /* Enable rgb brightness control */
 360         {0xa0, 0x60, 0x61, 0x08, 0x00, 0x00, 0x00, 0x10},
 361         /* HDG: Note windows uses the line below, which sets both register 0x60
 362            and 0x61 I believe these registers of the ov6650 are identical as
 363            those of the ov7630, because if this is true the windows settings
 364            add a bit additional red gain and a lot additional blue gain, which
 365            matches my findings that the windows settings make blue much too
 366            blue and red a little too red.
 367         {0xb0, 0x60, 0x60, 0x66, 0x68, 0xd8, 0xa4, 0x10}, */
 368         /* Some more unknown stuff */
 369         {0xa0, 0x60, 0x68, 0x04, 0x68, 0xd8, 0xa4, 0x10},
 370         {0xd0, 0x60, 0x17, 0x24, 0xd6, 0x04, 0x94, 0x10}, /* Clipreg */
 371 };
 372
 373 static const __u8 initOv7630[] = {
 374         0x04, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, /* r01 .. r08 */
 375         0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* r09 .. r10 */
 376         0x00, 0x01, 0x01, 0x0a,                         /* r11 .. r14 */
 377         0x28, 0x1e,                     /* H & V sizes     r15 .. r16 */
 378         0x68, 0x8f, MCK_INIT1,                          /* r17 .. r19 */
 379 };
 380 static const __u8 ov7630_sensor_init[][8] = {
 381         {0xa0, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
 382         {0xb0, 0x21, 0x01, 0x77, 0x3a, 0x00, 0x00, 0x10},
 383 /*      {0xd0, 0x21, 0x12, 0x7c, 0x01, 0x80, 0x34, 0x10},          jfm */
 384         {0xd0, 0x21, 0x12, 0x5c, 0x00, 0x80, 0x34, 0x10},       /* jfm */
 385         {0xa0, 0x21, 0x1b, 0x04, 0x00, 0x80, 0x34, 0x10},
 386         {0xa0, 0x21, 0x20, 0x44, 0x00, 0x80, 0x34, 0x10},
 387         {0xa0, 0x21, 0x23, 0xee, 0x00, 0x80, 0x34, 0x10},
 388         {0xd0, 0x21, 0x26, 0xa0, 0x9a, 0xa0, 0x30, 0x10},
 389         {0xb0, 0x21, 0x2a, 0x80, 0x00, 0xa0, 0x30, 0x10},
 390         {0xb0, 0x21, 0x2f, 0x3d, 0x24, 0xa0, 0x30, 0x10},
 391         {0xa0, 0x21, 0x32, 0x86, 0x24, 0xa0, 0x30, 0x10},
 392         {0xb0, 0x21, 0x60, 0xa9, 0x4a, 0xa0, 0x30, 0x10},
 393 /*      {0xb0, 0x21, 0x60, 0xa9, 0x42, 0xa0, 0x30, 0x10},        * jfm */
 394         {0xa0, 0x21, 0x65, 0x00, 0x42, 0xa0, 0x30, 0x10},
 395         {0xa0, 0x21, 0x69, 0x38, 0x42, 0xa0, 0x30, 0x10},
 396         {0xc0, 0x21, 0x6f, 0x88, 0x0b, 0x00, 0x30, 0x10},
 397         {0xc0, 0x21, 0x74, 0x21, 0x8e, 0x00, 0x30, 0x10},
 398         {0xa0, 0x21, 0x7d, 0xf7, 0x8e, 0x00, 0x30, 0x10},
 399         {0xd0, 0x21, 0x17, 0x1c, 0xbd, 0x06, 0xf6, 0x10},
 400 };
 401
 402 static const __u8 initPas106[] = {
 403         0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00,
 404         0x00, 0x00,
 405         0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
 406         0x16, 0x12, 0x24, COMP1, MCK_INIT1,
 407 };
 408 /* compression 0x86 mckinit1 0x2b */
 409
 410 /* "Known" PAS106B registers:
 411   0x02 clock divider
 412   0x03 Variable framerate bits 4-11
 413   0x04 Var framerate bits 0-3, one must leave the 4 msb's at 0 !!
 414        The variable framerate control must never be set lower then 300,
 415        which sets the framerate at 90 / reg02, otherwise vsync is lost.
 416   0x05 Shutter Time Line Offset, this can be used as an exposure control:
 417        0 = use full frame time, 255 = no exposure at all
 418        Note this may never be larger then "var-framerate control" / 2 - 2.
 419        When var-framerate control is < 514, no exposure is reached at the max
 420        allowed value for the framerate control value, rather then at 255.
 421   0x06 Shutter Time Pixel Offset, like reg05 this influences exposure, but
 422        only a very little bit, leave at 0xcd
 423   0x07 offset sign bit (bit0 1 > negative offset)
 424   0x08 offset
 425   0x09 Blue Gain
 426   0x0a Green1 Gain
 427   0x0b Green2 Gain
 428   0x0c Red Gain
 429   0x0e Global gain
 430   0x13 Write 1 to commit settings to sensor
 431 */
 432
 433 static const __u8 pas106_sensor_init[][8] = {
 434         /* Pixel Clock Divider 6 */
 435         { 0xa1, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14 },
 436         /* Frame Time MSB (also seen as 0x12) */
 437         { 0xa1, 0x40, 0x03, 0x13, 0x00, 0x00, 0x00, 0x14 },
 438         /* Frame Time LSB (also seen as 0x05) */
 439         { 0xa1, 0x40, 0x04, 0x06, 0x00, 0x00, 0x00, 0x14 },
 440         /* Shutter Time Line Offset (also seen as 0x6d) */
 441         { 0xa1, 0x40, 0x05, 0x65, 0x00, 0x00, 0x00, 0x14 },
 442         /* Shutter Time Pixel Offset (also seen as 0xb1) */
 443         { 0xa1, 0x40, 0x06, 0xcd, 0x00, 0x00, 0x00, 0x14 },
 444         /* Black Level Subtract Sign (also seen 0x00) */
 445         { 0xa1, 0x40, 0x07, 0xc1, 0x00, 0x00, 0x00, 0x14 },
 446         /* Black Level Subtract Level (also seen 0x01) */
 447         { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
 448         { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
 449         /* Color Gain B Pixel 5 a */
 450         { 0xa1, 0x40, 0x09, 0x05, 0x00, 0x00, 0x00, 0x14 },
 451         /* Color Gain G1 Pixel 1 5 */
 452         { 0xa1, 0x40, 0x0a, 0x04, 0x00, 0x00, 0x00, 0x14 },
 453         /* Color Gain G2 Pixel 1 0 5 */
 454         { 0xa1, 0x40, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x14 },
 455         /* Color Gain R Pixel 3 1 */
 456         { 0xa1, 0x40, 0x0c, 0x05, 0x00, 0x00, 0x00, 0x14 },
 457         /* Color GainH  Pixel */
 458         { 0xa1, 0x40, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x14 },
 459         /* Global Gain */
 460         { 0xa1, 0x40, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x14 },
 461         /* Contrast */
 462         { 0xa1, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x14 },
 463         /* H&V synchro polarity */
 464         { 0xa1, 0x40, 0x10, 0x06, 0x00, 0x00, 0x00, 0x14 },
 465         /* ?default */
 466         { 0xa1, 0x40, 0x11, 0x06, 0x00, 0x00, 0x00, 0x14 },
 467         /* DAC scale */
 468         { 0xa1, 0x40, 0x12, 0x06, 0x00, 0x00, 0x00, 0x14 },
 469         /* ?default */
 470         { 0xa1, 0x40, 0x14, 0x02, 0x00, 0x00, 0x00, 0x14 },
 471         /* Validate Settings */
 472         { 0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14 },
 473 };
 474
 475 static const __u8 initPas202[] = {
 476         0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00,
 477         0x00, 0x00,
 478         0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
 479         0x28, 0x1e, 0x20, 0x89, 0x20,
 480 };
 481
 482 /* "Known" PAS202BCB registers:
 483   0x02 clock divider
 484   0x04 Variable framerate bits 6-11 (*)
 485   0x05 Var framerate  bits 0-5, one must leave the 2 msb's at 0 !!
 486   0x07 Blue Gain
 487   0x08 Green Gain
 488   0x09 Red Gain
 489   0x0b offset sign bit (bit0 1 > negative offset)
 490   0x0c offset
 491   0x0e Unknown image is slightly brighter when bit 0 is 0, if reg0f is 0 too,
 492        leave at 1 otherwise we get a jump in our exposure control
 493   0x0f Exposure 0-255, 0 = use full frame time, 255 = no exposure at all
 494   0x10 Master gain 0 - 31
 495   0x11 write 1 to apply changes
 496   (*) The variable framerate control must never be set lower then 500
 497       which sets the framerate at 30 / reg02, otherwise vsync is lost.
 498 */
 499 static const __u8 pas202_sensor_init[][8] = {
 500         /* Set the clock divider to 4 -> 30 / 4 = 7.5 fps, we would like
 501            to set it lower, but for some reason the bridge starts missing
 502            vsync's then */
 503         {0xa0, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x10},
 504         {0xd0, 0x40, 0x04, 0x07, 0x34, 0x00, 0x09, 0x10},
 505         {0xd0, 0x40, 0x08, 0x01, 0x00, 0x00, 0x01, 0x10},
 506         {0xd0, 0x40, 0x0c, 0x00, 0x0c, 0x01, 0x32, 0x10},
 507         {0xd0, 0x40, 0x10, 0x00, 0x01, 0x00, 0x63, 0x10},
 508         {0xa0, 0x40, 0x15, 0x70, 0x01, 0x00, 0x63, 0x10},
 509         {0xa0, 0x40, 0x18, 0x00, 0x01, 0x00, 0x63, 0x10},
 510         {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
 511         {0xa0, 0x40, 0x03, 0x56, 0x01, 0x00, 0x63, 0x10},
 512         {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
 513 };
 514
 515 static const __u8 initTas5110c[] = {
 516         0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
 517         0x00, 0x00,
 518         0x00, 0x00, 0x00, 0x45, 0x09, 0x0a,
 519         0x16, 0x12, 0x60, 0x86, 0x2b,
 520 };
 521 /* Same as above, except a different hstart */
 522 static const __u8 initTas5110d[] = {
 523         0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
 524         0x00, 0x00,
 525         0x00, 0x00, 0x00, 0x41, 0x09, 0x0a,
 526         0x16, 0x12, 0x60, 0x86, 0x2b,
 527 };
 528 /* tas5110c is 3 wire, tas5110d is 2 wire (regular i2c) */
 529 static const __u8 tas5110c_sensor_init[][8] = {
 530         {0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10},
 531         {0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10},
 532 };
 533 /* Known TAS5110D registers
 534  * reg02: gain, bit order reversed!! 0 == max gain, 255 == min gain
 535  * reg03: bit3: vflip, bit4: ~hflip, bit7: ~gainboost (~ == inverted)
 536  *        Note: writing reg03 seems to only work when written together with 02
 537  */
 538 static const __u8 tas5110d_sensor_init[][8] = {
 539         {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17}, /* reset */
 540 };
 541
 542 static const __u8 initTas5130[] = {
 543         0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
 544         0x00, 0x00,
 545         0x00, 0x00, 0x00, 0x68, 0x0c, 0x0a,
 546         0x28, 0x1e, 0x60, COMP, MCK_INIT,
 547 };
 548 static const __u8 tas5130_sensor_init[][8] = {
 549 /*      {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
 550                                         * shutter 0x47 short exposure? */
 551         {0x30, 0x11, 0x00, 0x40, 0x01, 0x00, 0x00, 0x10},
 552                                         /* shutter 0x01 long exposure */
 553         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10},
 554 };
 555
 556 static struct sensor_data sensor_data[] = {
 557 SENS(initHv7131d, hv7131d_sensor_init, F_GAIN, NO_BRIGHTNESS|NO_FREQ, 0),
 558 SENS(initHv7131r, hv7131r_sensor_init, 0, NO_BRIGHTNESS|NO_EXPO|NO_FREQ, 0),
 559 SENS(initOv6650, ov6650_sensor_init, F_GAIN|F_SIF, 0, 0x60),
 560 SENS(initOv7630, ov7630_sensor_init, F_GAIN, 0, 0x21),
 561 SENS(initPas106, pas106_sensor_init, F_GAIN|F_SIF, NO_FREQ, 0),
 562 SENS(initPas202, pas202_sensor_init, F_GAIN, NO_FREQ, 0),
 563 SENS(initTas5110c, tas5110c_sensor_init, F_GAIN|F_SIF|F_COARSE_EXPO,
 564         NO_BRIGHTNESS|NO_FREQ, 0),
 565 SENS(initTas5110d, tas5110d_sensor_init, F_GAIN|F_SIF|F_COARSE_EXPO,
 566         NO_BRIGHTNESS|NO_FREQ, 0),
 567 SENS(initTas5130, tas5130_sensor_init, F_GAIN,
 568         NO_BRIGHTNESS|NO_EXPO|NO_FREQ, 0),
 569 };
 570
 571 /* get one byte in gspca_dev->usb_buf */
 572 static void reg_r(struct gspca_dev *gspca_dev,
 573                   __u16 value)
 574 {
 575         usb_control_msg(gspca_dev->dev,
 576                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 577                         0,                      /* request */
 578                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 579                         value,
 580                         0,                      /* index */
 581                         gspca_dev->usb_buf, 1,
 582                         500);
 583 }
 584
 585 static void reg_w(struct gspca_dev *gspca_dev,
 586                   __u16 value,
 587                   const __u8 *buffer,
 588                   int len)
 589 {
 590 #ifdef GSPCA_DEBUG
 591         if (len > USB_BUF_SZ) {
 592                 PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
 593                 return;
 594         }
 595 #endif
 596         memcpy(gspca_dev->usb_buf, buffer, len);
 597         usb_control_msg(gspca_dev->dev,
 598                         usb_sndctrlpipe(gspca_dev->dev, 0),
 599                         0x08,                   /* request */
 600                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 601                         value,
 602                         0,                      /* index */
 603                         gspca_dev->usb_buf, len,
 604                         500);
 605 }
 606
 607 static int i2c_w(struct gspca_dev *gspca_dev, const __u8 *buffer)
 608 {
 609         int retry = 60;
 610
 611         /* is i2c ready */
 612         reg_w(gspca_dev, 0x08, buffer, 8);
 613         while (retry--) {
 614                 msleep(10);
 615                 reg_r(gspca_dev, 0x08);
 616                 if (gspca_dev->usb_buf[0] & 0x04) {
 617                         if (gspca_dev->usb_buf[0] & 0x08)
 618                                 return -1;
 619                         return 0;
 620                 }
 621         }
 622         return -1;
 623 }
 624
 625 static void i2c_w_vector(struct gspca_dev *gspca_dev,
 626                         const __u8 buffer[][8], int len)
 627 {
 628         for (;;) {
 629                 reg_w(gspca_dev, 0x08, *buffer, 8);
 630                 len -= 8;
 631                 if (len <= 0)
 632                         break;
 633                 buffer++;
 634         }
 635 }
 636
 637 static void setbrightness(struct gspca_dev *gspca_dev)
 638 {
 639         struct sd *sd = (struct sd *) gspca_dev;
 640
 641         switch (sd->sensor) {
 642         case  SENSOR_OV6650:
 643         case  SENSOR_OV7630: {
 644                 __u8 i2cOV[] =
 645                         {0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10};
 646
 647                 /* change reg 0x06 */
 648                 i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
 649                 i2cOV[3] = sd->brightness;
 650                 if (i2c_w(gspca_dev, i2cOV) < 0)
 651                         goto err;
 652                 break;
 653             }
 654         case SENSOR_PAS106:
 655         case SENSOR_PAS202: {
 656                 __u8 i2cpbright[] =
 657                         {0xb0, 0x40, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x16};
 658                 __u8 i2cpdoit[] =
 659                         {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
 660
 661                 /* PAS106 uses reg 7 and 8 instead of b and c */
 662                 if (sd->sensor == SENSOR_PAS106) {
 663                         i2cpbright[2] = 7;
 664                         i2cpdoit[2] = 0x13;
 665                 }
 666
 667                 if (sd->brightness < 127) {
 668                         /* change reg 0x0b, signreg */
 669                         i2cpbright[3] = 0x01;
 670                         /* set reg 0x0c, offset */
 671                         i2cpbright[4] = 127 - sd->brightness;
 672                 } else
 673                         i2cpbright[4] = sd->brightness - 127;
 674
 675                 if (i2c_w(gspca_dev, i2cpbright) < 0)
 676                         goto err;
 677                 if (i2c_w(gspca_dev, i2cpdoit) < 0)
 678                         goto err;
 679                 break;
 680             }
 681         }
 682         return;
 683 err:
 684         PDEBUG(D_ERR, "i2c error brightness");
 685 }
 686
 687 static void setsensorgain(struct gspca_dev *gspca_dev)
 688 {
 689         struct sd *sd = (struct sd *) gspca_dev;
 690         unsigned char gain = sd->gain;
 691
 692         switch (sd->sensor) {
 693         case SENSOR_HV7131D: {
 694                 __u8 i2c[] =
 695                         {0xc0, 0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x17};
 696
 697                 i2c[3] = 0x3f - (sd->gain / 4);
 698                 i2c[4] = 0x3f - (sd->gain / 4);
 699                 i2c[5] = 0x3f - (sd->gain / 4);
 700
 701                 if (i2c_w(gspca_dev, i2c) < 0)
 702                         goto err;
 703                 break;
 704             }
 705         case SENSOR_TAS5110C:
 706         case SENSOR_TAS5130CXX: {
 707                 __u8 i2c[] =
 708                         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
 709
 710                 i2c[4] = 255 - gain;
 711                 if (i2c_w(gspca_dev, i2c) < 0)
 712                         goto err;
 713                 break;
 714             }
 715         case SENSOR_TAS5110D: {
 716                 __u8 i2c[] = {
 717                         0xb0, 0x61, 0x02, 0x00, 0x10, 0x00, 0x00, 0x17 };
 718                 gain = 255 - gain;
 719                 /* The bits in the register are the wrong way around!! */
 720                 i2c[3] |= (gain & 0x80) >> 7;
 721                 i2c[3] |= (gain & 0x40) >> 5;
 722                 i2c[3] |= (gain & 0x20) >> 3;
 723                 i2c[3] |= (gain & 0x10) >> 1;
 724                 i2c[3] |= (gain & 0x08) << 1;
 725                 i2c[3] |= (gain & 0x04) << 3;
 726                 i2c[3] |= (gain & 0x02) << 5;
 727                 i2c[3] |= (gain & 0x01) << 7;
 728                 if (i2c_w(gspca_dev, i2c) < 0)
 729                         goto err;
 730                 break;
 731             }
 732
 733         case SENSOR_OV6650:
 734                 gain >>= 1;
 735                 /* fall thru */
 736         case SENSOR_OV7630: {
 737                 __u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
 738
 739                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
 740                 i2c[3] = gain >> 2;
 741                 if (i2c_w(gspca_dev, i2c) < 0)
 742                         goto err;
 743                 break;
 744             }
 745         case SENSOR_PAS106:
 746         case SENSOR_PAS202: {
 747                 __u8 i2cpgain[] =
 748                         {0xa0, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x15};
 749                 __u8 i2cpcolorgain[] =
 750                         {0xc0, 0x40, 0x07, 0x00, 0x00, 0x00, 0x00, 0x15};
 751                 __u8 i2cpdoit[] =
 752                         {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
 753
 754                 /* PAS106 uses different regs (and has split green gains) */
 755                 if (sd->sensor == SENSOR_PAS106) {
 756                         i2cpgain[2] = 0x0e;
 757                         i2cpcolorgain[0] = 0xd0;
 758                         i2cpcolorgain[2] = 0x09;
 759                         i2cpdoit[2] = 0x13;
 760                 }
 761
 762                 i2cpgain[3] = sd->gain >> 3;
 763                 i2cpcolorgain[3] = sd->gain >> 4;
 764                 i2cpcolorgain[4] = sd->gain >> 4;
 765                 i2cpcolorgain[5] = sd->gain >> 4;
 766                 i2cpcolorgain[6] = sd->gain >> 4;
 767
 768                 if (i2c_w(gspca_dev, i2cpgain) < 0)
 769                         goto err;
 770                 if (i2c_w(gspca_dev, i2cpcolorgain) < 0)
 771                         goto err;
 772                 if (i2c_w(gspca_dev, i2cpdoit) < 0)
 773                         goto err;
 774                 break;
 775             }
 776         }
 777         return;
 778 err:
 779         PDEBUG(D_ERR, "i2c error gain");
 780 }
 781
 782 static void setgain(struct gspca_dev *gspca_dev)
 783 {
 784         struct sd *sd = (struct sd *) gspca_dev;
 785         __u8 gain;
 786         __u8 buf[3] = { 0, 0, 0 };
 787
 788         if (sensor_data[sd->sensor].flags & F_GAIN) {
 789                 /* Use the sensor gain to do the actual gain */
 790                 setsensorgain(gspca_dev);
 791                 return;
 792         }
 793
 794         if (sd->bridge == BRIDGE_103) {
 795                 gain = sd->gain >> 1;
 796                 buf[0] = gain; /* Red */
 797                 buf[1] = gain; /* Green */
 798                 buf[2] = gain; /* Blue */
 799                 reg_w(gspca_dev, 0x05, buf, 3);
 800         } else {
 801                 gain = sd->gain >> 4;
 802                 buf[0] = gain << 4 | gain; /* Red and blue */
 803                 buf[1] = gain; /* Green */
 804                 reg_w(gspca_dev, 0x10, buf, 2);
 805         }
 806 }
 807
 808 static void setexposure(struct gspca_dev *gspca_dev)
 809 {
 810         struct sd *sd = (struct sd *) gspca_dev;
 811
 812         switch (sd->sensor) {
 813         case SENSOR_HV7131D: {
 814                 /* Note the datasheet wrongly says line mode exposure uses reg
 815                    0x26 and 0x27, testing has shown 0x25 + 0x26 */
 816                 __u8 i2c[] = {0xc0, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x17};
 817                 /* The HV7131D's exposure goes from 0 - 65535, we scale our
 818                    exposure of 0-1023 to 0-6138. There are 2 reasons for this:
 819                    1) This puts our exposure knee of 200 at approx the point
 820                       where the framerate starts dropping
 821                    2) At 6138 the framerate has already dropped to 2 fps,
 822                       going any lower makes little sense */
 823                 __u16 reg = sd->exposure * 6;
 824                 i2c[3] = reg >> 8;
 825                 i2c[4] = reg & 0xff;
 826                 if (i2c_w(gspca_dev, i2c) != 0)
 827                         goto err;
 828                 break;
 829             }
 830         case SENSOR_TAS5110C:
 831         case SENSOR_TAS5110D: {
 832                 /* register 19's high nibble contains the sn9c10x clock divider
 833                    The high nibble configures the no fps according to the
 834                    formula: 60 / high_nibble. With a maximum of 30 fps */
 835                 __u8 reg = sd->exposure;
 836                 reg = (reg << 4) | 0x0b;
 837                 reg_w(gspca_dev, 0x19, &reg, 1);
 838                 break;
 839             }
 840         case SENSOR_OV6650:
 841         case SENSOR_OV7630: {
 842                 /* The ov6650 / ov7630 have 2 registers which both influence
 843                    exposure, register 11, whose low nibble sets the nr off fps
 844                    according to: fps = 30 / (low_nibble + 1)
 845
 846                    The fps configures the maximum exposure setting, but it is
 847                    possible to use less exposure then what the fps maximum
 848                    allows by setting register 10. register 10 configures the
 849                    actual exposure as quotient of the full exposure, with 0
 850                    being no exposure at all (not very usefull) and reg10_max
 851                    being max exposure possible at that framerate.
 852
 853                    The code maps our 0 - 510 ms exposure ctrl to these 2
 854                    registers, trying to keep fps as high as possible.
 855                 */
 856                 __u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10};
 857                 int reg10, reg11, reg10_max;
 858
 859                 /* ov6645 datasheet says reg10_max is 9a, but that uses
 860                    tline * 2 * reg10 as formula for calculating texpo, the
 861                    ov6650 probably uses the same formula as the 7730 which uses
 862                    tline * 4 * reg10, which explains why the reg10max we've
 863                    found experimentally for the ov6650 is exactly half that of
 864                    the ov6645. The ov7630 datasheet says the max is 0x41. */
 865                 if (sd->sensor == SENSOR_OV6650) {
 866                         reg10_max = 0x4d;
 867                         i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */
 868                 } else
 869                         reg10_max = 0x41;
 870
 871                 reg11 = (15 * sd->exposure + 999) / 1000;
 872                 if (reg11 < 1)
 873                         reg11 = 1;
 874                 else if (reg11 > 16)
 875                         reg11 = 16;
 876
 877                 /* In 640x480, if the reg11 has less than 4, the image is
 878                    unstable (the bridge goes into a higher compression mode
 879                    which we have not reverse engineered yet). */
 880                 if (gspca_dev->width == 640 && reg11 < 4)
 881                         reg11 = 4;
 882
 883                 /* frame exposure time in ms = 1000 * reg11 / 30    ->
 884                 reg10 = (sd->exposure / 2) * reg10_max / (1000 * reg11 / 30) */
 885                 reg10 = (sd->exposure * 15 * reg10_max) / (1000 * reg11);
 886
 887                 /* Don't allow this to get below 10 when using autogain, the
 888                    steps become very large (relatively) when below 10 causing
 889                    the image to oscilate from much too dark, to much too bright
 890                    and back again. */
 891                 if (sd->autogain && reg10 < 10)
 892                         reg10 = 10;
 893                 else if (reg10 > reg10_max)
 894                         reg10 = reg10_max;
 895
 896                 /* Write reg 10 and reg11 low nibble */
 897                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
 898                 i2c[3] = reg10;
 899                 i2c[4] |= reg11 - 1;
 900
 901                 /* If register 11 didn't change, don't change it */
 902                 if (sd->reg11 == reg11)
 903                         i2c[0] = 0xa0;
 904
 905                 if (i2c_w(gspca_dev, i2c) == 0)
 906                         sd->reg11 = reg11;
 907                 else
 908                         goto err;
 909                 break;
 910             }
 911         case SENSOR_PAS202: {
 912                 __u8 i2cpframerate[] =
 913                         {0xb0, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x16};
 914                 __u8 i2cpexpo[] =
 915                         {0xa0, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x16};
 916                 const __u8 i2cpdoit[] =
 917                         {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
 918                 int framerate_ctrl;
 919
 920                 /* The exposure knee for the autogain algorithm is 200
 921                    (100 ms / 10 fps on other sensors), for values below this
 922                    use the control for setting the partial frame expose time,
 923                    above that use variable framerate. This way we run at max
 924                    framerate (640x480@7.5 fps, 320x240@10fps) until the knee
 925                    is reached. Using the variable framerate control above 200
 926                    is better then playing around with both clockdiv + partial
 927                    frame exposure times (like we are doing with the ov chips),
 928                    as that sometimes leads to jumps in the exposure control,
 929                    which are bad for auto exposure. */
 930                 if (sd->exposure < 200) {
 931                         i2cpexpo[3] = 255 - (sd->exposure * 255) / 200;
 932                         framerate_ctrl = 500;
 933                 } else {
 934                         /* The PAS202's exposure control goes from 0 - 4095,
 935                            but anything below 500 causes vsync issues, so scale
 936                            our 200-1023 to 500-4095 */
 937                         framerate_ctrl = (sd->exposure - 200) * 1000 / 229 +
 938                                          500;
 939                 }
 940
 941                 i2cpframerate[3] = framerate_ctrl >> 6;
 942                 i2cpframerate[4] = framerate_ctrl & 0x3f;
 943                 if (i2c_w(gspca_dev, i2cpframerate) < 0)
 944                         goto err;
 945                 if (i2c_w(gspca_dev, i2cpexpo) < 0)
 946                         goto err;
 947                 if (i2c_w(gspca_dev, i2cpdoit) < 0)
 948                         goto err;
 949                 break;
 950             }
 951         case SENSOR_PAS106: {
 952                 __u8 i2cpframerate[] =
 953                         {0xb1, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x14};
 954                 __u8 i2cpexpo[] =
 955                         {0xa1, 0x40, 0x05, 0x00, 0x00, 0x00, 0x00, 0x14};
 956                 const __u8 i2cpdoit[] =
 957                         {0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14};
 958                 int framerate_ctrl;
 959
 960                 /* For values below 150 use partial frame exposure, above
 961                    that use framerate ctrl */
 962                 if (sd->exposure < 150) {
 963                         i2cpexpo[3] = 150 - sd->exposure;
 964                         framerate_ctrl = 300;
 965                 } else {
 966                         /* The PAS106's exposure control goes from 0 - 4095,
 967                            but anything below 300 causes vsync issues, so scale
 968                            our 150-1023 to 300-4095 */
 969                         framerate_ctrl = (sd->exposure - 150) * 1000 / 230 +
 970                                          300;
 971                 }
 972
 973                 i2cpframerate[3] = framerate_ctrl >> 4;
 974                 i2cpframerate[4] = framerate_ctrl & 0x0f;
 975                 if (i2c_w(gspca_dev, i2cpframerate) < 0)
 976                         goto err;
 977                 if (i2c_w(gspca_dev, i2cpexpo) < 0)
 978                         goto err;
 979                 if (i2c_w(gspca_dev, i2cpdoit) < 0)
 980                         goto err;
 981                 break;
 982             }
 983         }
 984         return;
 985 err:
 986         PDEBUG(D_ERR, "i2c error exposure");
 987 }
 988
 989 static void setfreq(struct gspca_dev *gspca_dev)
 990 {
 991         struct sd *sd = (struct sd *) gspca_dev;
 992
 993         switch (sd->sensor) {
 994         case SENSOR_OV6650:
 995         case SENSOR_OV7630: {
 996                 /* Framerate adjust register for artificial light 50 hz flicker
 997                    compensation, for the ov6650 this is identical to ov6630
 998                    0x2b register, see ov6630 datasheet.
 999                    0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
1000                 __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
1001                 switch (sd->freq) {
1002                 default:
1003 /*              case 0:                  * no filter*/
1004 /*              case 2:                  * 60 hz */
1005                         i2c[3] = 0;
1006                         break;
1007                 case 1:                 /* 50 hz */
1008                         i2c[3] = (sd->sensor == SENSOR_OV6650)
1009                                         ? 0x4f : 0x8a;
1010                         break;
1011                 }
1012                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
1013                 if (i2c_w(gspca_dev, i2c) < 0)
1014                         PDEBUG(D_ERR, "i2c error setfreq");
1015                 break;
1016             }
1017         }
1018 }
1019
1020 #include "coarse_expo_autogain.h"
1021
1022 static void do_autogain(struct gspca_dev *gspca_dev)
1023 {
1024         int deadzone, desired_avg_lum, result;
1025         struct sd *sd = (struct sd *) gspca_dev;
1026         int avg_lum = atomic_read(&sd->avg_lum);
1027
1028         if (avg_lum == -1 || !sd->autogain)
1029                 return;
1030
1031         if (sd->autogain_ignore_frames > 0) {
1032                 sd->autogain_ignore_frames--;
1033                 return;
1034         }
1035
1036         /* SIF / VGA sensors have a different autoexposure area and thus
1037            different avg_lum values for the same picture brightness */
1038         if (sensor_data[sd->sensor].flags & F_SIF) {
1039                 deadzone = 500;
1040                 /* SIF sensors tend to overexpose, so keep this small */
1041                 desired_avg_lum = 5000;
1042         } else {
1043                 deadzone = 1500;
1044                 desired_avg_lum = 13000;
1045         }
1046
1047         if (sensor_data[sd->sensor].flags & F_COARSE_EXPO)
1048                 result = gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
1049                                 sd->brightness * desired_avg_lum / 127,
1050                                 deadzone);
1051         else
1052                 result = gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
1053                                 sd->brightness * desired_avg_lum / 127,
1054                                 deadzone, GAIN_KNEE, EXPOSURE_KNEE);
1055
1056         if (result) {
1057                 PDEBUG(D_FRAM, "autogain: gain changed: gain: %d expo: %d",
1058                         (int)sd->gain, (int)sd->exposure);
1059                 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
1060         }
1061 }
1062
1063 /* this function is called at probe time */
1064 static int sd_config(struct gspca_dev *gspca_dev,
1065                         const struct usb_device_id *id)
1066 {
1067         struct sd *sd = (struct sd *) gspca_dev;
1068         struct cam *cam;
1069
1070         reg_r(gspca_dev, 0x00);
1071         if (gspca_dev->usb_buf[0] != 0x10)
1072                 return -ENODEV;
1073
1074         /* copy the webcam info from the device id */
1075         sd->sensor = id->driver_info >> 8;
1076         sd->bridge = id->driver_info & 0xff;
1077         gspca_dev->ctrl_dis = sensor_data[sd->sensor].ctrl_dis;
1078
1079         cam = &gspca_dev->cam;
1080         if (!(sensor_data[sd->sensor].flags & F_SIF)) {
1081                 cam->cam_mode = vga_mode;
1082                 cam->nmodes = ARRAY_SIZE(vga_mode);
1083         } else {
1084                 cam->cam_mode = sif_mode;
1085                 cam->nmodes = ARRAY_SIZE(sif_mode);
1086         }
1087         cam->npkt = 36;                 /* 36 packets per ISOC message */
1088
1089         sd->brightness = BRIGHTNESS_DEF;
1090         sd->gain = GAIN_DEF;
1091         if (sensor_data[sd->sensor].flags & F_COARSE_EXPO) {
1092                 sd->exposure = COARSE_EXPOSURE_DEF;
1093                 gspca_dev->ctrl_dis |= (1 << EXPOSURE_IDX);
1094         } else {
1095                 sd->exposure = EXPOSURE_DEF;
1096                 gspca_dev->ctrl_dis |= (1 << COARSE_EXPOSURE_IDX);
1097         }
1098         if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
1099                 sd->autogain = 0; /* Disable do_autogain callback */
1100         else
1101                 sd->autogain = AUTOGAIN_DEF;
1102         sd->freq = FREQ_DEF;
1103
1104         return 0;
1105 }
1106
1107 /* this function is called at probe and resume time */
1108 static int sd_init(struct gspca_dev *gspca_dev)
1109 {
1110         const __u8 stop = 0x09; /* Disable stream turn of LED */
1111
1112         reg_w(gspca_dev, 0x01, &stop, 1);
1113
1114         return 0;
1115 }
1116
1117 /* -- start the camera -- */
1118 static int sd_start(struct gspca_dev *gspca_dev)
1119 {
1120         struct sd *sd = (struct sd *) gspca_dev;
1121         struct cam *cam = &gspca_dev->cam;
1122         int i, mode;
1123         __u8 regs[0x31];
1124
1125         mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
1126         /* Copy registers 0x01 - 0x19 from the template */
1127         memcpy(&regs[0x01], sensor_data[sd->sensor].bridge_init, 0x19);
1128         /* Set the mode */
1129         regs[0x18] |= mode << 4;
1130
1131         /* Set bridge gain to 1.0 */
1132         if (sd->bridge == BRIDGE_103) {
1133                 regs[0x05] = 0x20; /* Red */
1134                 regs[0x06] = 0x20; /* Green */
1135                 regs[0x07] = 0x20; /* Blue */
1136         } else {
1137                 regs[0x10] = 0x00; /* Red and blue */
1138                 regs[0x11] = 0x00; /* Green */
1139         }
1140
1141         /* Setup pixel numbers and auto exposure window */
1142         if (sensor_data[sd->sensor].flags & F_SIF) {
1143                 regs[0x1a] = 0x14; /* HO_SIZE 640, makes no sense */
1144                 regs[0x1b] = 0x0a; /* VO_SIZE 320, makes no sense */
1145                 regs[0x1c] = 0x02; /* AE H-start 64 */
1146                 regs[0x1d] = 0x02; /* AE V-start 64 */
1147                 regs[0x1e] = 0x09; /* AE H-end 288 */
1148                 regs[0x1f] = 0x07; /* AE V-end 224 */
1149         } else {
1150                 regs[0x1a] = 0x1d; /* HO_SIZE 960, makes no sense */
1151                 regs[0x1b] = 0x10; /* VO_SIZE 512, makes no sense */
1152                 regs[0x1c] = 0x05; /* AE H-start 160 */
1153                 regs[0x1d] = 0x03; /* AE V-start 96 */
1154                 regs[0x1e] = 0x0f; /* AE H-end 480 */
1155                 regs[0x1f] = 0x0c; /* AE V-end 384 */
1156         }
1157
1158         /* Setup the gamma table (only used with the sn9c103 bridge) */
1159         for (i = 0; i < 16; i++)
1160                 regs[0x20 + i] = i * 16;
1161         regs[0x20 + i] = 255;
1162
1163         /* Special cases where some regs depend on mode or bridge */
1164         switch (sd->sensor) {
1165         case SENSOR_TAS5130CXX:
1166                 /* FIXME / TESTME
1167                    probably not mode specific at all most likely the upper
1168                    nibble of 0x19 is exposure (clock divider) just as with
1169                    the tas5110, we need someone to test this. */
1170                 regs[0x19] = mode ? 0x23 : 0x43;
1171                 break;
1172         case SENSOR_OV7630:
1173                 /* FIXME / TESTME for some reason with the 101/102 bridge the
1174                    clock is set to 12 Mhz (reg1 == 0x04), rather then 24.
1175                    Also the hstart needs to go from 1 to 2 when using a 103,
1176                    which is likely related. This does not seem right. */
1177                 if (sd->bridge == BRIDGE_103) {
1178                         regs[0x01] = 0x44; /* Select 24 Mhz clock */
1179                         regs[0x12] = 0x02; /* Set hstart to 2 */
1180                 }
1181         }
1182         /* Disable compression when the raw bayer format has been selected */
1183         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
1184                 regs[0x18] &= ~0x80;
1185
1186         /* Vga mode emulation on SIF sensor? */
1187         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
1188                 regs[0x12] += 16;       /* hstart adjust */
1189                 regs[0x13] += 24;       /* vstart adjust */
1190                 regs[0x15]  = 320 / 16; /* hsize */
1191                 regs[0x16]  = 240 / 16; /* vsize */
1192         }
1193
1194         /* reg 0x01 bit 2 video transfert on */
1195         reg_w(gspca_dev, 0x01, &regs[0x01], 1);
1196         /* reg 0x17 SensorClk enable inv Clk 0x60 */
1197         reg_w(gspca_dev, 0x17, &regs[0x17], 1);
1198         /* Set the registers from the template */
1199         reg_w(gspca_dev, 0x01, &regs[0x01],
1200               (sd->bridge == BRIDGE_103) ? 0x30 : 0x1f);
1201
1202         /* Init the sensor */
1203         i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
1204                         sensor_data[sd->sensor].sensor_init_size);
1205
1206         /* Mode / bridge specific sensor setup */
1207         switch (sd->sensor) {
1208         case SENSOR_PAS202: {
1209                 const __u8 i2cpclockdiv[] =
1210                         {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10};
1211                 /* clockdiv from 4 to 3 (7.5 -> 10 fps) when in low res mode */
1212                 if (mode)
1213                         i2c_w(gspca_dev, i2cpclockdiv);
1214                 break;
1215             }
1216         case SENSOR_OV7630:
1217                 /* FIXME / TESTME We should be able to handle this identical
1218                    for the 101/102 and the 103 case */
1219                 if (sd->bridge == BRIDGE_103) {
1220                         const __u8 i2c[] = { 0xa0, 0x21, 0x13,
1221                                              0x80, 0x00, 0x00, 0x00, 0x10 };
1222                         i2c_w(gspca_dev, i2c);
1223                 }
1224                 break;
1225         }
1226         /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
1227         reg_w(gspca_dev, 0x15, &regs[0x15], 2);
1228         /* compression register */
1229         reg_w(gspca_dev, 0x18, &regs[0x18], 1);
1230         /* H_start */
1231         reg_w(gspca_dev, 0x12, &regs[0x12], 1);
1232         /* V_START */
1233         reg_w(gspca_dev, 0x13, &regs[0x13], 1);
1234         /* reset 0x17 SensorClk enable inv Clk 0x60 */
1235                                 /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
1236         reg_w(gspca_dev, 0x17, &regs[0x17], 1);
1237         /*MCKSIZE ->3 */        /*fixme: not ov7630*/
1238         reg_w(gspca_dev, 0x19, &regs[0x19], 1);
1239         /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
1240         reg_w(gspca_dev, 0x1c, &regs[0x1c], 4);
1241         /* Enable video transfert */
1242         reg_w(gspca_dev, 0x01, &regs[0x01], 1);
1243         /* Compression */
1244         reg_w(gspca_dev, 0x18, &regs[0x18], 2);
1245         msleep(20);
1246
1247         sd->reg11 = -1;
1248
1249         setgain(gspca_dev);
1250         setbrightness(gspca_dev);
1251         setexposure(gspca_dev);
1252         setfreq(gspca_dev);
1253
1254         sd->frames_to_drop = 0;
1255         sd->autogain_ignore_frames = 0;
1256         sd->exp_too_high_cnt = 0;
1257         sd->exp_too_low_cnt = 0;
1258         atomic_set(&sd->avg_lum, -1);
1259         return 0;
1260 }
1261
1262 static void sd_stopN(struct gspca_dev *gspca_dev)
1263 {
1264         sd_init(gspca_dev);
1265 }
1266
1267 static u8* find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
1268 {
1269         struct sd *sd = (struct sd *) gspca_dev;
1270         int i, header_size = (sd->bridge == BRIDGE_103) ? 18 : 12;
1271
1272         /* frames start with:
1273          *      ff ff 00 c4 c4 96       synchro
1274          *      00              (unknown)
1275          *      xx              (frame sequence / size / compression)
1276          *      (xx)            (idem - extra byte for sn9c103)
1277          *      ll mm           brightness sum inside auto exposure
1278          *      ll mm           brightness sum outside auto exposure
1279          *      (xx xx xx xx xx)        audio values for snc103
1280          */
1281         for (i = 0; i < len; i++) {
1282                 switch (sd->header_read) {
1283                 case 0:
1284                         if (data[i] == 0xff)
1285                                 sd->header_read++;
1286                         break;
1287                 case 1:
1288                         if (data[i] == 0xff)
1289                                 sd->header_read++;
1290                         else
1291                                 sd->header_read = 0;
1292                         break;
1293                 case 2:
1294                         if (data[i] == 0x00)
1295                                 sd->header_read++;
1296                         else if (data[i] != 0xff)
1297                                 sd->header_read = 0;
1298                         break;
1299                 case 3:
1300                         if (data[i] == 0xc4)
1301                                 sd->header_read++;
1302                         else if (data[i] == 0xff)
1303                                 sd->header_read = 1;
1304                         else
1305                                 sd->header_read = 0;
1306                         break;
1307                 case 4:
1308                         if (data[i] == 0xc4)
1309                                 sd->header_read++;
1310                         else if (data[i] == 0xff)
1311                                 sd->header_read = 1;
1312                         else
1313                                 sd->header_read = 0;
1314                         break;
1315                 case 5:
1316                         if (data[i] == 0x96)
1317                                 sd->header_read++;
1318                         else if (data[i] == 0xff)
1319                                 sd->header_read = 1;
1320                         else
1321                                 sd->header_read = 0;
1322                         break;
1323                 default:
1324                         sd->header[sd->header_read - 6] = data[i];
1325                         sd->header_read++;
1326                         if (sd->header_read == header_size) {
1327                                 sd->header_read = 0;
1328                                 return data + i + 1;
1329                         }
1330                 }
1331         }
1332         return NULL;
1333 }
1334
1335 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1336                         u8 *data,                       /* isoc packet */
1337                         int len)                        /* iso packet length */
1338 {
1339         int fr_h_sz = 0, lum_offset = 0, len_after_sof = 0;
1340         struct sd *sd = (struct sd *) gspca_dev;
1341         struct cam *cam = &gspca_dev->cam;
1342         u8 *sof;
1343
1344         sof = find_sof(gspca_dev, data, len);
1345         if (sof) {
1346                 if (sd->bridge == BRIDGE_103) {
1347                         fr_h_sz = 18;
1348                         lum_offset = 3;
1349                 } else {
1350                         fr_h_sz = 12;
1351                         lum_offset = 2;
1352                 }
1353
1354                 len_after_sof = len - (sof - data);
1355                 len = (sof - data) - fr_h_sz;
1356                 if (len < 0)
1357                         len = 0;
1358         }
1359
1360         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
1361                 /* In raw mode we sometimes get some garbage after the frame
1362                    ignore this */
1363                 int used;
1364                 int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
1365
1366                 used = gspca_dev->image_len;
1367                 if (used + len > size)
1368                         len = size - used;
1369         }
1370
1371         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1372
1373         if (sof) {
1374                 int  lum = sd->header[lum_offset] +
1375                           (sd->header[lum_offset + 1] << 8);
1376
1377                 /* When exposure changes midway a frame we
1378                    get a lum of 0 in this case drop 2 frames
1379                    as the frames directly after an exposure
1380                    change have an unstable image. Sometimes lum
1381                    *really* is 0 (cam used in low light with
1382                    low exposure setting), so do not drop frames
1383                    if the previous lum was 0 too. */
1384                 if (lum == 0 && sd->prev_avg_lum != 0) {
1385                         lum = -1;
1386                         sd->frames_to_drop = 2;
1387                         sd->prev_avg_lum = 0;
1388                 } else
1389                         sd->prev_avg_lum = lum;
1390                 atomic_set(&sd->avg_lum, lum);
1391
1392                 if (sd->frames_to_drop)
1393                         sd->frames_to_drop--;
1394                 else
1395                         gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
1396
1397                 gspca_frame_add(gspca_dev, FIRST_PACKET, sof, len_after_sof);
1398         }
1399 }
1400
1401 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1402 {
1403         struct sd *sd = (struct sd *) gspca_dev;
1404
1405         sd->brightness = val;
1406         if (gspca_dev->streaming)
1407                 setbrightness(gspca_dev);
1408         return 0;
1409 }
1410
1411 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1412 {
1413         struct sd *sd = (struct sd *) gspca_dev;
1414
1415         *val = sd->brightness;
1416         return 0;
1417 }
1418
1419 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
1420 {
1421         struct sd *sd = (struct sd *) gspca_dev;
1422
1423         sd->gain = val;
1424         if (gspca_dev->streaming)
1425                 setgain(gspca_dev);
1426         return 0;
1427 }
1428
1429 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1430 {
1431         struct sd *sd = (struct sd *) gspca_dev;
1432
1433         *val = sd->gain;
1434         return 0;
1435 }
1436
1437 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
1438 {
1439         struct sd *sd = (struct sd *) gspca_dev;
1440
1441         sd->exposure = val;
1442         if (gspca_dev->streaming)
1443                 setexposure(gspca_dev);
1444         return 0;
1445 }
1446
1447 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
1448 {
1449         struct sd *sd = (struct sd *) gspca_dev;
1450
1451         *val = sd->exposure;
1452         return 0;
1453 }
1454
1455 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1456 {
1457         struct sd *sd = (struct sd *) gspca_dev;
1458
1459         sd->autogain = val;
1460         sd->exp_too_high_cnt = 0;
1461         sd->exp_too_low_cnt = 0;
1462
1463         /* when switching to autogain set defaults to make sure
1464            we are on a valid point of the autogain gain /
1465            exposure knee graph, and give this change time to
1466            take effect before doing autogain. */
1467         if (sd->autogain && !(sensor_data[sd->sensor].flags & F_COARSE_EXPO)) {
1468                 sd->exposure = EXPOSURE_DEF;
1469                 sd->gain = GAIN_DEF;
1470                 if (gspca_dev->streaming) {
1471                         sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
1472                         setexposure(gspca_dev);
1473                         setgain(gspca_dev);
1474                 }
1475         }
1476
1477         return 0;
1478 }
1479
1480 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1481 {
1482         struct sd *sd = (struct sd *) gspca_dev;
1483
1484         *val = sd->autogain;
1485         return 0;
1486 }
1487
1488 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
1489 {
1490         struct sd *sd = (struct sd *) gspca_dev;
1491
1492         sd->freq = val;
1493         if (gspca_dev->streaming)
1494                 setfreq(gspca_dev);
1495         return 0;
1496 }
1497
1498 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
1499 {
1500         struct sd *sd = (struct sd *) gspca_dev;
1501
1502         *val = sd->freq;
1503         return 0;
1504 }
1505
1506 static int sd_querymenu(struct gspca_dev *gspca_dev,
1507                         struct v4l2_querymenu *menu)
1508 {
1509         switch (menu->id) {
1510         case V4L2_CID_POWER_LINE_FREQUENCY:
1511                 switch (menu->index) {
1512                 case 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
1513                         strcpy((char *) menu->name, "NoFliker");
1514                         return 0;
1515                 case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1516                         strcpy((char *) menu->name, "50 Hz");
1517                         return 0;
1518                 case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
1519                         strcpy((char *) menu->name, "60 Hz");
1520                         return 0;
1521                 }
1522                 break;
1523         }
1524         return -EINVAL;
1525 }
1526
1527 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1528 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
1529                         u8 *data,               /* interrupt packet data */
1530                         int len)                /* interrupt packet length */
1531 {
1532         int ret = -EINVAL;
1533
1534         if (len == 1 && data[0] == 1) {
1535                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
1536                 input_sync(gspca_dev->input_dev);
1537                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1538                 input_sync(gspca_dev->input_dev);
1539                 ret = 0;
1540         }
1541
1542         return ret;
1543 }
1544 #endif
1545
1546 /* sub-driver description */
1547 static const struct sd_desc sd_desc = {
1548         .name = MODULE_NAME,
1549         .ctrls = sd_ctrls,
1550         .nctrls = ARRAY_SIZE(sd_ctrls),
1551         .config = sd_config,
1552         .init = sd_init,
1553         .start = sd_start,
1554         .stopN = sd_stopN,
1555         .pkt_scan = sd_pkt_scan,
1556         .querymenu = sd_querymenu,
1557         .dq_callback = do_autogain,
1558 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1559         .int_pkt_scan = sd_int_pkt_scan,
1560 #endif
1561 };
1562
1563 /* -- module initialisation -- */
1564 #define SB(sensor, bridge) \
1565         .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
1566
1567
1568 static const struct usb_device_id device_table[] = {
1569         {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110C, 102)}, /* TAS5110C1B */
1570         {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110C, 101)}, /* TAS5110C1B */
1571         {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110D, 101)}, /* TAS5110D */
1572         {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
1573         {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
1574         {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
1575         {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
1576 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1577         {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
1578         {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
1579 #endif
1580         {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
1581         {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
1582         {USB_DEVICE(0x0c45, 0x602a), SB(HV7131D, 102)},
1583         /* {USB_DEVICE(0x0c45, 0x602b), SB(MI0343, 102)}, */
1584         {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
1585         {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
1586         {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
1587         /* {USB_DEVICE(0x0c45, 0x6030), SB(MI03XX, 102)}, */ /* MI0343 MI0360 MI0330 */
1588         /* {USB_DEVICE(0x0c45, 0x6082), SB(MI03XX, 103)}, */ /* MI0343 MI0360 */
1589         {USB_DEVICE(0x0c45, 0x6083), SB(HV7131D, 103)},
1590         {USB_DEVICE(0x0c45, 0x608c), SB(HV7131R, 103)},
1591         /* {USB_DEVICE(0x0c45, 0x608e), SB(CISVF10, 103)}, */
1592         {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
1593         {USB_DEVICE(0x0c45, 0x60a8), SB(PAS106, 103)},
1594         {USB_DEVICE(0x0c45, 0x60aa), SB(TAS5130CXX, 103)},
1595         {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
1596         {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
1597         {}
1598 };
1599 MODULE_DEVICE_TABLE(usb, device_table);
1600
1601 /* -- device connect -- */
1602 static int sd_probe(struct usb_interface *intf,
1603                         const struct usb_device_id *id)
1604 {
1605         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1606                                 THIS_MODULE);
1607 }
1608
1609 static struct usb_driver sd_driver = {
1610         .name = MODULE_NAME,
1611         .id_table = device_table,
1612         .probe = sd_probe,
1613         .disconnect = gspca_disconnect,
1614 #ifdef CONFIG_PM
1615         .suspend = gspca_suspend,
1616         .resume = gspca_resume,
1617 #endif
1618 };
1619
1620 /* -- module insert / remove -- */
1621 static int __init sd_mod_init(void)
1622 {
1623         return usb_register(&sd_driver);
1624 }
1625 static void __exit sd_mod_exit(void)
1626 {
1627         usb_deregister(&sd_driver);
1628 }
1629
1630 module_init(sd_mod_init);
1631 module_exit(sd_mod_exit);