drivers/media/usb/gspca/sonixb.c

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