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