kernel/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 %8ph\n", buf);
 517                                 gspca_dev->usb_err = -EIO;
 518                         }
 519                         return;
 520                 }
 521         }
 522
 523         dev_err(gspca_dev->v4l2_dev.dev, "i2c write timeout\n");
 524         gspca_dev->usb_err = -EIO;
 525 }
 526
 527 static void i2c_w_vector(struct gspca_dev *gspca_dev,
 528                         const __u8 buffer[][8], int len)
 529 {
 530         for (;;) {
 531                 if (gspca_dev->usb_err < 0)
 532                         return;
 533                 i2c_w(gspca_dev, *buffer);
 534                 len -= 8;
 535                 if (len <= 0)
 536                         break;
 537                 buffer++;
 538         }
 539 }
 540
 541 static void setbrightness(struct gspca_dev *gspca_dev)
 542 {
 543         struct sd *sd = (struct sd *) gspca_dev;
 544
 545         switch (sd->sensor) {
 546         case  SENSOR_OV6650:
 547         case  SENSOR_OV7630: {
 548                 __u8 i2cOV[] =
 549                         {0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10};
 550
 551                 /* change reg 0x06 */
 552                 i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
 553                 i2cOV[3] = sd->brightness->val;
 554                 i2c_w(gspca_dev, i2cOV);
 555                 break;
 556         }
 557         case SENSOR_PAS106:
 558         case SENSOR_PAS202: {
 559                 __u8 i2cpbright[] =
 560                         {0xb0, 0x40, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x16};
 561                 __u8 i2cpdoit[] =
 562                         {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
 563
 564                 /* PAS106 uses reg 7 and 8 instead of b and c */
 565                 if (sd->sensor == SENSOR_PAS106) {
 566                         i2cpbright[2] = 7;
 567                         i2cpdoit[2] = 0x13;
 568                 }
 569
 570                 if (sd->brightness->val < 127) {
 571                         /* change reg 0x0b, signreg */
 572                         i2cpbright[3] = 0x01;
 573                         /* set reg 0x0c, offset */
 574                         i2cpbright[4] = 127 - sd->brightness->val;
 575                 } else
 576                         i2cpbright[4] = sd->brightness->val - 127;
 577
 578                 i2c_w(gspca_dev, i2cpbright);
 579                 i2c_w(gspca_dev, i2cpdoit);
 580                 break;
 581         }
 582         default:
 583                 break;
 584         }
 585 }
 586
 587 static void setgain(struct gspca_dev *gspca_dev)
 588 {
 589         struct sd *sd = (struct sd *) gspca_dev;
 590         u8 gain = gspca_dev->gain->val;
 591
 592         switch (sd->sensor) {
 593         case SENSOR_HV7131D: {
 594                 __u8 i2c[] =
 595                         {0xc0, 0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x17};
 596
 597                 i2c[3] = 0x3f - gain;
 598                 i2c[4] = 0x3f - gain;
 599                 i2c[5] = 0x3f - gain;
 600
 601                 i2c_w(gspca_dev, i2c);
 602                 break;
 603         }
 604         case SENSOR_TAS5110C:
 605         case SENSOR_TAS5130CXX: {
 606                 __u8 i2c[] =
 607                         {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
 608
 609                 i2c[4] = 255 - gain;
 610                 i2c_w(gspca_dev, i2c);
 611                 break;
 612         }
 613         case SENSOR_TAS5110D: {
 614                 __u8 i2c[] = {
 615                         0xb0, 0x61, 0x02, 0x00, 0x10, 0x00, 0x00, 0x17 };
 616                 gain = 255 - gain;
 617                 /* The bits in the register are the wrong way around!! */
 618                 i2c[3] |= (gain & 0x80) >> 7;
 619                 i2c[3] |= (gain & 0x40) >> 5;
 620                 i2c[3] |= (gain & 0x20) >> 3;
 621                 i2c[3] |= (gain & 0x10) >> 1;
 622                 i2c[3] |= (gain & 0x08) << 1;
 623                 i2c[3] |= (gain & 0x04) << 3;
 624                 i2c[3] |= (gain & 0x02) << 5;
 625                 i2c[3] |= (gain & 0x01) << 7;
 626                 i2c_w(gspca_dev, i2c);
 627                 break;
 628         }
 629         case SENSOR_OV6650:
 630         case SENSOR_OV7630: {
 631                 __u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
 632
 633                 /*
 634                  * The ov7630's gain is weird, at 32 the gain drops to the
 635                  * same level as at 16, so skip 32-47 (of the 0-63 scale).
 636                  */
 637                 if (sd->sensor == SENSOR_OV7630 && gain >= 32)
 638                         gain += 16;
 639
 640                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
 641                 i2c[3] = gain;
 642                 i2c_w(gspca_dev, i2c);
 643                 break;
 644         }
 645         case SENSOR_PAS106:
 646         case SENSOR_PAS202: {
 647                 __u8 i2cpgain[] =
 648                         {0xa0, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x15};
 649                 __u8 i2cpcolorgain[] =
 650                         {0xc0, 0x40, 0x07, 0x00, 0x00, 0x00, 0x00, 0x15};
 651                 __u8 i2cpdoit[] =
 652                         {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
 653
 654                 /* PAS106 uses different regs (and has split green gains) */
 655                 if (sd->sensor == SENSOR_PAS106) {
 656                         i2cpgain[2] = 0x0e;
 657                         i2cpcolorgain[0] = 0xd0;
 658                         i2cpcolorgain[2] = 0x09;
 659                         i2cpdoit[2] = 0x13;
 660                 }
 661
 662                 i2cpgain[3] = gain;
 663                 i2cpcolorgain[3] = gain >> 1;
 664                 i2cpcolorgain[4] = gain >> 1;
 665                 i2cpcolorgain[5] = gain >> 1;
 666                 i2cpcolorgain[6] = gain >> 1;
 667
 668                 i2c_w(gspca_dev, i2cpgain);
 669                 i2c_w(gspca_dev, i2cpcolorgain);
 670                 i2c_w(gspca_dev, i2cpdoit);
 671                 break;
 672         }
 673         default:
 674                 if (sd->bridge == BRIDGE_103) {
 675                         u8 buf[3] = { gain, gain, gain }; /* R, G, B */
 676                         reg_w(gspca_dev, 0x05, buf, 3);
 677                 } else {
 678                         u8 buf[2];
 679                         buf[0] = gain << 4 | gain; /* Red and blue */
 680                         buf[1] = gain; /* Green */
 681                         reg_w(gspca_dev, 0x10, buf, 2);
 682                 }
 683         }
 684 }
 685
 686 static void setexposure(struct gspca_dev *gspca_dev)
 687 {
 688         struct sd *sd = (struct sd *) gspca_dev;
 689
 690         switch (sd->sensor) {
 691         case SENSOR_HV7131D: {
 692                 /* Note the datasheet wrongly says line mode exposure uses reg
 693                    0x26 and 0x27, testing has shown 0x25 + 0x26 */
 694                 __u8 i2c[] = {0xc0, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x17};
 695                 u16 reg = gspca_dev->exposure->val;
 696
 697                 i2c[3] = reg >> 8;
 698                 i2c[4] = reg & 0xff;
 699                 i2c_w(gspca_dev, i2c);
 700                 break;
 701         }
 702         case SENSOR_TAS5110C:
 703         case SENSOR_TAS5110D: {
 704                 /* register 19's high nibble contains the sn9c10x clock divider
 705                    The high nibble configures the no fps according to the
 706                    formula: 60 / high_nibble. With a maximum of 30 fps */
 707                 u8 reg = gspca_dev->exposure->val;
 708
 709                 reg = (reg << 4) | 0x0b;
 710                 reg_w(gspca_dev, 0x19, &reg, 1);
 711                 break;
 712         }
 713         case SENSOR_OV6650:
 714         case SENSOR_OV7630: {
 715                 /* The ov6650 / ov7630 have 2 registers which both influence
 716                    exposure, register 11, whose low nibble sets the nr off fps
 717                    according to: fps = 30 / (low_nibble + 1)
 718
 719                    The fps configures the maximum exposure setting, but it is
 720                    possible to use less exposure then what the fps maximum
 721                    allows by setting register 10. register 10 configures the
 722                    actual exposure as quotient of the full exposure, with 0
 723                    being no exposure at all (not very useful) and reg10_max
 724                    being max exposure possible at that framerate.
 725
 726                    The code maps our 0 - 510 ms exposure ctrl to these 2
 727                    registers, trying to keep fps as high as possible.
 728                 */
 729                 __u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10};
 730                 int reg10, reg11, reg10_max;
 731
 732                 /* ov6645 datasheet says reg10_max is 9a, but that uses
 733                    tline * 2 * reg10 as formula for calculating texpo, the
 734                    ov6650 probably uses the same formula as the 7730 which uses
 735                    tline * 4 * reg10, which explains why the reg10max we've
 736                    found experimentally for the ov6650 is exactly half that of
 737                    the ov6645. The ov7630 datasheet says the max is 0x41. */
 738                 if (sd->sensor == SENSOR_OV6650) {
 739                         reg10_max = 0x4d;
 740                         i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */
 741                 } else
 742                         reg10_max = 0x41;
 743
 744                 reg11 = (15 * gspca_dev->exposure->val + 999) / 1000;
 745                 if (reg11 < 1)
 746                         reg11 = 1;
 747                 else if (reg11 > 16)
 748                         reg11 = 16;
 749
 750                 /* In 640x480, if the reg11 has less than 4, the image is
 751                    unstable (the bridge goes into a higher compression mode
 752                    which we have not reverse engineered yet). */
 753                 if (gspca_dev->pixfmt.width == 640 && reg11 < 4)
 754                         reg11 = 4;
 755
 756                 /* frame exposure time in ms = 1000 * reg11 / 30    ->
 757                 reg10 = (gspca_dev->exposure->val / 2) * reg10_max
 758                                 / (1000 * reg11 / 30) */
 759                 reg10 = (gspca_dev->exposure->val * 15 * reg10_max)
 760                                 / (1000 * reg11);
 761
 762                 /* Don't allow this to get below 10 when using autogain, the
 763                    steps become very large (relatively) when below 10 causing
 764                    the image to oscilate from much too dark, to much too bright
 765                    and back again. */
 766                 if (gspca_dev->autogain->val && reg10 < 10)
 767                         reg10 = 10;
 768                 else if (reg10 > reg10_max)
 769                         reg10 = reg10_max;
 770
 771                 /* Write reg 10 and reg11 low nibble */
 772                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
 773                 i2c[3] = reg10;
 774                 i2c[4] |= reg11 - 1;
 775
 776                 /* If register 11 didn't change, don't change it */
 777                 if (sd->reg11 == reg11)
 778                         i2c[0] = 0xa0;
 779
 780                 i2c_w(gspca_dev, i2c);
 781                 if (gspca_dev->usb_err == 0)
 782                         sd->reg11 = reg11;
 783                 break;
 784         }
 785         case SENSOR_PAS202: {
 786                 __u8 i2cpframerate[] =
 787                         {0xb0, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x16};
 788                 __u8 i2cpexpo[] =
 789                         {0xa0, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x16};
 790                 const __u8 i2cpdoit[] =
 791                         {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
 792                 int framerate_ctrl;
 793
 794                 /* The exposure knee for the autogain algorithm is 200
 795                    (100 ms / 10 fps on other sensors), for values below this
 796                    use the control for setting the partial frame expose time,
 797                    above that use variable framerate. This way we run at max
 798                    framerate (640x480@7.5 fps, 320x240@10fps) until the knee
 799                    is reached. Using the variable framerate control above 200
 800                    is better then playing around with both clockdiv + partial
 801                    frame exposure times (like we are doing with the ov chips),
 802                    as that sometimes leads to jumps in the exposure control,
 803                    which are bad for auto exposure. */
 804                 if (gspca_dev->exposure->val < 200) {
 805                         i2cpexpo[3] = 255 - (gspca_dev->exposure->val * 255)
 806                                                 / 200;
 807                         framerate_ctrl = 500;
 808                 } else {
 809                         /* The PAS202's exposure control goes from 0 - 4095,
 810                            but anything below 500 causes vsync issues, so scale
 811                            our 200-1023 to 500-4095 */
 812                         framerate_ctrl = (gspca_dev->exposure->val - 200)
 813                                                         * 1000 / 229 +  500;
 814                 }
 815
 816                 i2cpframerate[3] = framerate_ctrl >> 6;
 817                 i2cpframerate[4] = framerate_ctrl & 0x3f;
 818                 i2c_w(gspca_dev, i2cpframerate);
 819                 i2c_w(gspca_dev, i2cpexpo);
 820                 i2c_w(gspca_dev, i2cpdoit);
 821                 break;
 822         }
 823         case SENSOR_PAS106: {
 824                 __u8 i2cpframerate[] =
 825                         {0xb1, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x14};
 826                 __u8 i2cpexpo[] =
 827                         {0xa1, 0x40, 0x05, 0x00, 0x00, 0x00, 0x00, 0x14};
 828                 const __u8 i2cpdoit[] =
 829                         {0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14};
 830                 int framerate_ctrl;
 831
 832                 /* For values below 150 use partial frame exposure, above
 833                    that use framerate ctrl */
 834                 if (gspca_dev->exposure->val < 150) {
 835                         i2cpexpo[3] = 150 - gspca_dev->exposure->val;
 836                         framerate_ctrl = 300;
 837                 } else {
 838                         /* The PAS106's exposure control goes from 0 - 4095,
 839                            but anything below 300 causes vsync issues, so scale
 840                            our 150-1023 to 300-4095 */
 841                         framerate_ctrl = (gspca_dev->exposure->val - 150)
 842                                                 * 1000 / 230 + 300;
 843                 }
 844
 845                 i2cpframerate[3] = framerate_ctrl >> 4;
 846                 i2cpframerate[4] = framerate_ctrl & 0x0f;
 847                 i2c_w(gspca_dev, i2cpframerate);
 848                 i2c_w(gspca_dev, i2cpexpo);
 849                 i2c_w(gspca_dev, i2cpdoit);
 850                 break;
 851         }
 852         default:
 853                 break;
 854         }
 855 }
 856
 857 static void setfreq(struct gspca_dev *gspca_dev)
 858 {
 859         struct sd *sd = (struct sd *) gspca_dev;
 860
 861         if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630) {
 862                 /* Framerate adjust register for artificial light 50 hz flicker
 863                    compensation, for the ov6650 this is identical to ov6630
 864                    0x2b register, see ov6630 datasheet.
 865                    0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
 866                 __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
 867                 switch (sd->plfreq->val) {
 868                 default:
 869 /*              case 0:                  * no filter*/
 870 /*              case 2:                  * 60 hz */
 871                         i2c[3] = 0;
 872                         break;
 873                 case 1:                 /* 50 hz */
 874                         i2c[3] = (sd->sensor == SENSOR_OV6650)
 875                                         ? 0x4f : 0x8a;
 876                         break;
 877                 }
 878                 i2c[1] = sensor_data[sd->sensor].sensor_addr;
 879                 i2c_w(gspca_dev, i2c);
 880         }
 881 }
 882
 883 static void do_autogain(struct gspca_dev *gspca_dev)
 884 {
 885         struct sd *sd = (struct sd *) gspca_dev;
 886         int deadzone, desired_avg_lum, avg_lum;
 887
 888         avg_lum = atomic_read(&sd->avg_lum);
 889         if (avg_lum == -1)
 890                 return;
 891
 892         if (sd->autogain_ignore_frames > 0) {
 893                 sd->autogain_ignore_frames--;
 894                 return;
 895         }
 896
 897         /* SIF / VGA sensors have a different autoexposure area and thus
 898            different avg_lum values for the same picture brightness */
 899         if (sensor_data[sd->sensor].flags & F_SIF) {
 900                 deadzone = 500;
 901                 /* SIF sensors tend to overexpose, so keep this small */
 902                 desired_avg_lum = 5000;
 903         } else {
 904                 deadzone = 1500;
 905                 desired_avg_lum = 13000;
 906         }
 907
 908         if (sd->brightness)
 909                 desired_avg_lum = sd->brightness->val * desired_avg_lum / 127;
 910
 911         if (gspca_dev->exposure->maximum < 500) {
 912                 if (gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
 913                                 desired_avg_lum, deadzone))
 914                         sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
 915         } else {
 916                 int gain_knee = (s32)gspca_dev->gain->maximum * 9 / 10;
 917                 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_avg_lum,
 918                                 deadzone, gain_knee, sd->exposure_knee))
 919                         sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
 920         }
 921 }
 922
 923 /* this function is called at probe time */
 924 static int sd_config(struct gspca_dev *gspca_dev,
 925                         const struct usb_device_id *id)
 926 {
 927         struct sd *sd = (struct sd *) gspca_dev;
 928         struct cam *cam;
 929
 930         reg_r(gspca_dev, 0x00);
 931         if (gspca_dev->usb_buf[0] != 0x10)
 932                 return -ENODEV;
 933
 934         /* copy the webcam info from the device id */
 935         sd->sensor = id->driver_info >> 8;
 936         sd->bridge = id->driver_info & 0xff;
 937
 938         cam = &gspca_dev->cam;
 939         if (!(sensor_data[sd->sensor].flags & F_SIF)) {
 940                 cam->cam_mode = vga_mode;
 941                 cam->nmodes = ARRAY_SIZE(vga_mode);
 942         } else {
 943                 cam->cam_mode = sif_mode;
 944                 cam->nmodes = ARRAY_SIZE(sif_mode);
 945         }
 946         cam->npkt = 36;                 /* 36 packets per ISOC message */
 947
 948         return 0;
 949 }
 950
 951 /* this function is called at probe and resume time */
 952 static int sd_init(struct gspca_dev *gspca_dev)
 953 {
 954         const __u8 stop = 0x09; /* Disable stream turn of LED */
 955
 956         reg_w(gspca_dev, 0x01, &stop, 1);
 957
 958         return gspca_dev->usb_err;
 959 }
 960
 961 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 962 {
 963         struct gspca_dev *gspca_dev =
 964                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 965         struct sd *sd = (struct sd *)gspca_dev;
 966
 967         gspca_dev->usb_err = 0;
 968
 969         if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
 970                 /* when switching to autogain set defaults to make sure
 971                    we are on a valid point of the autogain gain /
 972                    exposure knee graph, and give this change time to
 973                    take effect before doing autogain. */
 974                 gspca_dev->gain->val = gspca_dev->gain->default_value;
 975                 gspca_dev->exposure->val = gspca_dev->exposure->default_value;
 976                 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
 977         }
 978
 979         if (!gspca_dev->streaming)
 980                 return 0;
 981
 982         switch (ctrl->id) {
 983         case V4L2_CID_BRIGHTNESS:
 984                 setbrightness(gspca_dev);
 985                 break;
 986         case V4L2_CID_AUTOGAIN:
 987                 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
 988                         setexposure(gspca_dev);
 989                 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
 990                         setgain(gspca_dev);
 991                 break;
 992         case V4L2_CID_POWER_LINE_FREQUENCY:
 993                 setfreq(gspca_dev);
 994                 break;
 995         default:
 996                 return -EINVAL;
 997         }
 998         return gspca_dev->usb_err;
 999 }
1000
1001 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
1002         .s_ctrl = sd_s_ctrl,
1003 };
1004
1005 /* this function is called at probe time */
1006 static int sd_init_controls(struct gspca_dev *gspca_dev)
1007 {
1008         struct sd *sd = (struct sd *) gspca_dev;
1009         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
1010
1011         gspca_dev->vdev.ctrl_handler = hdl;
1012         v4l2_ctrl_handler_init(hdl, 5);
1013
1014         if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630 ||
1015             sd->sensor == SENSOR_PAS106 || sd->sensor == SENSOR_PAS202)
1016                 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1017                                         V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1018
1019         /* Gain range is sensor dependent */
1020         switch (sd->sensor) {
1021         case SENSOR_OV6650:
1022         case SENSOR_PAS106:
1023         case SENSOR_PAS202:
1024                 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1025                                         V4L2_CID_GAIN, 0, 31, 1, 15);
1026                 break;
1027         case SENSOR_OV7630:
1028                 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1029                                         V4L2_CID_GAIN, 0, 47, 1, 31);
1030                 break;
1031         case SENSOR_HV7131D:
1032                 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1033                                         V4L2_CID_GAIN, 0, 63, 1, 31);
1034                 break;
1035         case SENSOR_TAS5110C:
1036         case SENSOR_TAS5110D:
1037         case SENSOR_TAS5130CXX:
1038                 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1039                                         V4L2_CID_GAIN, 0, 255, 1, 127);
1040                 break;
1041         default:
1042                 if (sd->bridge == BRIDGE_103) {
1043                         gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1044                                                 V4L2_CID_GAIN, 0, 127, 1, 63);
1045                 } else {
1046                         gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1047                                                 V4L2_CID_GAIN, 0, 15, 1, 7);
1048                 }
1049         }
1050
1051         /* Exposure range is sensor dependent, and not all have exposure */
1052         switch (sd->sensor) {
1053         case SENSOR_HV7131D:
1054                 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1055                                         V4L2_CID_EXPOSURE, 0, 8191, 1, 482);
1056                 sd->exposure_knee = 964;
1057                 break;
1058         case SENSOR_OV6650:
1059         case SENSOR_OV7630:
1060         case SENSOR_PAS106:
1061         case SENSOR_PAS202:
1062                 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1063                                         V4L2_CID_EXPOSURE, 0, 1023, 1, 66);
1064                 sd->exposure_knee = 200;
1065                 break;
1066         case SENSOR_TAS5110C:
1067         case SENSOR_TAS5110D:
1068                 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1069                                         V4L2_CID_EXPOSURE, 2, 15, 1, 2);
1070                 break;
1071         }
1072
1073         if (gspca_dev->exposure) {
1074                 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1075                                                 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1076         }
1077
1078         if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630)
1079                 sd->plfreq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
1080                         V4L2_CID_POWER_LINE_FREQUENCY,
1081                         V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0,
1082                         V4L2_CID_POWER_LINE_FREQUENCY_DISABLED);
1083
1084         if (hdl->error) {
1085                 pr_err("Could not initialize controls\n");
1086                 return hdl->error;
1087         }
1088
1089         if (gspca_dev->autogain)
1090                 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
1091
1092         return 0;
1093 }
1094
1095 /* -- start the camera -- */
1096 static int sd_start(struct gspca_dev *gspca_dev)
1097 {
1098         struct sd *sd = (struct sd *) gspca_dev;
1099         struct cam *cam = &gspca_dev->cam;
1100         int i, mode;
1101         __u8 regs[0x31];
1102
1103         mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
1104         /* Copy registers 0x01 - 0x19 from the template */
1105         memcpy(&regs[0x01], sensor_data[sd->sensor].bridge_init, 0x19);
1106         /* Set the mode */
1107         regs[0x18] |= mode << 4;
1108
1109         /* Set bridge gain to 1.0 */
1110         if (sd->bridge == BRIDGE_103) {
1111                 regs[0x05] = 0x20; /* Red */
1112                 regs[0x06] = 0x20; /* Green */
1113                 regs[0x07] = 0x20; /* Blue */
1114         } else {
1115                 regs[0x10] = 0x00; /* Red and blue */
1116                 regs[0x11] = 0x00; /* Green */
1117         }
1118
1119         /* Setup pixel numbers and auto exposure window */
1120         if (sensor_data[sd->sensor].flags & F_SIF) {
1121                 regs[0x1a] = 0x14; /* HO_SIZE 640, makes no sense */
1122                 regs[0x1b] = 0x0a; /* VO_SIZE 320, makes no sense */
1123                 regs[0x1c] = 0x02; /* AE H-start 64 */
1124                 regs[0x1d] = 0x02; /* AE V-start 64 */
1125                 regs[0x1e] = 0x09; /* AE H-end 288 */
1126                 regs[0x1f] = 0x07; /* AE V-end 224 */
1127         } else {
1128                 regs[0x1a] = 0x1d; /* HO_SIZE 960, makes no sense */
1129                 regs[0x1b] = 0x10; /* VO_SIZE 512, makes no sense */
1130                 regs[0x1c] = 0x05; /* AE H-start 160 */
1131                 regs[0x1d] = 0x03; /* AE V-start 96 */
1132                 regs[0x1e] = 0x0f; /* AE H-end 480 */
1133                 regs[0x1f] = 0x0c; /* AE V-end 384 */
1134         }
1135
1136         /* Setup the gamma table (only used with the sn9c103 bridge) */
1137         for (i = 0; i < 16; i++)
1138                 regs[0x20 + i] = i * 16;
1139         regs[0x20 + i] = 255;
1140
1141         /* Special cases where some regs depend on mode or bridge */
1142         switch (sd->sensor) {
1143         case SENSOR_TAS5130CXX:
1144                 /* FIXME / TESTME
1145                    probably not mode specific at all most likely the upper
1146                    nibble of 0x19 is exposure (clock divider) just as with
1147                    the tas5110, we need someone to test this. */
1148                 regs[0x19] = mode ? 0x23 : 0x43;
1149                 break;
1150         case SENSOR_OV7630:
1151                 /* FIXME / TESTME for some reason with the 101/102 bridge the
1152                    clock is set to 12 Mhz (reg1 == 0x04), rather then 24.
1153                    Also the hstart needs to go from 1 to 2 when using a 103,
1154                    which is likely related. This does not seem right. */
1155                 if (sd->bridge == BRIDGE_103) {
1156                         regs[0x01] = 0x44; /* Select 24 Mhz clock */
1157                         regs[0x12] = 0x02; /* Set hstart to 2 */
1158                 }
1159                 break;
1160         case SENSOR_PAS202:
1161                 /* For some unknown reason we need to increase hstart by 1 on
1162                    the sn9c103, otherwise we get wrong colors (bayer shift). */
1163                 if (sd->bridge == BRIDGE_103)
1164                         regs[0x12] += 1;
1165                 break;
1166         }
1167         /* Disable compression when the raw bayer format has been selected */
1168         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
1169                 regs[0x18] &= ~0x80;
1170
1171         /* Vga mode emulation on SIF sensor? */
1172         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
1173                 regs[0x12] += 16;       /* hstart adjust */
1174                 regs[0x13] += 24;       /* vstart adjust */
1175                 regs[0x15]  = 320 / 16; /* hsize */
1176                 regs[0x16]  = 240 / 16; /* vsize */
1177         }
1178
1179         /* reg 0x01 bit 2 video transfert on */
1180         reg_w(gspca_dev, 0x01, &regs[0x01], 1);
1181         /* reg 0x17 SensorClk enable inv Clk 0x60 */
1182         reg_w(gspca_dev, 0x17, &regs[0x17], 1);
1183         /* Set the registers from the template */
1184         reg_w(gspca_dev, 0x01, &regs[0x01],
1185               (sd->bridge == BRIDGE_103) ? 0x30 : 0x1f);
1186
1187         /* Init the sensor */
1188         i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
1189                         sensor_data[sd->sensor].sensor_init_size);
1190
1191         /* Mode / bridge specific sensor setup */
1192         switch (sd->sensor) {
1193         case SENSOR_PAS202: {
1194                 const __u8 i2cpclockdiv[] =
1195                         {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10};
1196                 /* clockdiv from 4 to 3 (7.5 -> 10 fps) when in low res mode */
1197                 if (mode)
1198                         i2c_w(gspca_dev, i2cpclockdiv);
1199                 break;
1200             }
1201         case SENSOR_OV7630:
1202                 /* FIXME / TESTME We should be able to handle this identical
1203                    for the 101/102 and the 103 case */
1204                 if (sd->bridge == BRIDGE_103) {
1205                         const __u8 i2c[] = { 0xa0, 0x21, 0x13,
1206                                              0x80, 0x00, 0x00, 0x00, 0x10 };
1207                         i2c_w(gspca_dev, i2c);
1208                 }
1209                 break;
1210         }
1211         /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
1212         reg_w(gspca_dev, 0x15, &regs[0x15], 2);
1213         /* compression register */
1214         reg_w(gspca_dev, 0x18, &regs[0x18], 1);
1215         /* H_start */
1216         reg_w(gspca_dev, 0x12, &regs[0x12], 1);
1217         /* V_START */
1218         reg_w(gspca_dev, 0x13, &regs[0x13], 1);
1219         /* reset 0x17 SensorClk enable inv Clk 0x60 */
1220                                 /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
1221         reg_w(gspca_dev, 0x17, &regs[0x17], 1);
1222         /*MCKSIZE ->3 */        /*fixme: not ov7630*/
1223         reg_w(gspca_dev, 0x19, &regs[0x19], 1);
1224         /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
1225         reg_w(gspca_dev, 0x1c, &regs[0x1c], 4);
1226         /* Enable video transfert */
1227         reg_w(gspca_dev, 0x01, &regs[0x01], 1);
1228         /* Compression */
1229         reg_w(gspca_dev, 0x18, &regs[0x18], 2);
1230         msleep(20);
1231
1232         sd->reg11 = -1;
1233
1234         setgain(gspca_dev);
1235         setbrightness(gspca_dev);
1236         setexposure(gspca_dev);
1237         setfreq(gspca_dev);
1238
1239         sd->frames_to_drop = 0;
1240         sd->autogain_ignore_frames = 0;
1241         gspca_dev->exp_too_high_cnt = 0;
1242         gspca_dev->exp_too_low_cnt = 0;
1243         atomic_set(&sd->avg_lum, -1);
1244         return gspca_dev->usb_err;
1245 }
1246
1247 static void sd_stopN(struct gspca_dev *gspca_dev)
1248 {
1249         sd_init(gspca_dev);
1250 }
1251
1252 static u8* find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
1253 {
1254         struct sd *sd = (struct sd *) gspca_dev;
1255         int i, header_size = (sd->bridge == BRIDGE_103) ? 18 : 12;
1256
1257         /* frames start with:
1258          *      ff ff 00 c4 c4 96       synchro
1259          *      00              (unknown)
1260          *      xx              (frame sequence / size / compression)
1261          *      (xx)            (idem - extra byte for sn9c103)
1262          *      ll mm           brightness sum inside auto exposure
1263          *      ll mm           brightness sum outside auto exposure
1264          *      (xx xx xx xx xx)        audio values for snc103
1265          */
1266         for (i = 0; i < len; i++) {
1267                 switch (sd->header_read) {
1268                 case 0:
1269                         if (data[i] == 0xff)
1270                                 sd->header_read++;
1271                         break;
1272                 case 1:
1273                         if (data[i] == 0xff)
1274                                 sd->header_read++;
1275                         else
1276                                 sd->header_read = 0;
1277                         break;
1278                 case 2:
1279                         if (data[i] == 0x00)
1280                                 sd->header_read++;
1281                         else if (data[i] != 0xff)
1282                                 sd->header_read = 0;
1283                         break;
1284                 case 3:
1285                         if (data[i] == 0xc4)
1286                                 sd->header_read++;
1287                         else if (data[i] == 0xff)
1288                                 sd->header_read = 1;
1289                         else
1290                                 sd->header_read = 0;
1291                         break;
1292                 case 4:
1293                         if (data[i] == 0xc4)
1294                                 sd->header_read++;
1295                         else if (data[i] == 0xff)
1296                                 sd->header_read = 1;
1297                         else
1298                                 sd->header_read = 0;
1299                         break;
1300                 case 5:
1301                         if (data[i] == 0x96)
1302                                 sd->header_read++;
1303                         else if (data[i] == 0xff)
1304                                 sd->header_read = 1;
1305                         else
1306                                 sd->header_read = 0;
1307                         break;
1308                 default:
1309                         sd->header[sd->header_read - 6] = data[i];
1310                         sd->header_read++;
1311                         if (sd->header_read == header_size) {
1312                                 sd->header_read = 0;
1313                                 return data + i + 1;
1314                         }
1315                 }
1316         }
1317         return NULL;
1318 }
1319
1320 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1321                         u8 *data,                       /* isoc packet */
1322                         int len)                        /* iso packet length */
1323 {
1324         int fr_h_sz = 0, lum_offset = 0, len_after_sof = 0;
1325         struct sd *sd = (struct sd *) gspca_dev;
1326         struct cam *cam = &gspca_dev->cam;
1327         u8 *sof;
1328
1329         sof = find_sof(gspca_dev, data, len);
1330         if (sof) {
1331                 if (sd->bridge == BRIDGE_103) {
1332                         fr_h_sz = 18;
1333                         lum_offset = 3;
1334                 } else {
1335                         fr_h_sz = 12;
1336                         lum_offset = 2;
1337                 }
1338
1339                 len_after_sof = len - (sof - data);
1340                 len = (sof - data) - fr_h_sz;
1341                 if (len < 0)
1342                         len = 0;
1343         }
1344
1345         if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
1346                 /* In raw mode we sometimes get some garbage after the frame
1347                    ignore this */
1348                 int used;
1349                 int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
1350
1351                 used = gspca_dev->image_len;
1352                 if (used + len > size)
1353                         len = size - used;
1354         }
1355
1356         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1357
1358         if (sof) {
1359                 int  lum = sd->header[lum_offset] +
1360                           (sd->header[lum_offset + 1] << 8);
1361
1362                 /* When exposure changes midway a frame we
1363                    get a lum of 0 in this case drop 2 frames
1364                    as the frames directly after an exposure
1365                    change have an unstable image. Sometimes lum
1366                    *really* is 0 (cam used in low light with
1367                    low exposure setting), so do not drop frames
1368                    if the previous lum was 0 too. */
1369                 if (lum == 0 && sd->prev_avg_lum != 0) {
1370                         lum = -1;
1371                         sd->frames_to_drop = 2;
1372                         sd->prev_avg_lum = 0;
1373                 } else
1374                         sd->prev_avg_lum = lum;
1375                 atomic_set(&sd->avg_lum, lum);
1376
1377                 if (sd->frames_to_drop)
1378                         sd->frames_to_drop--;
1379                 else
1380                         gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
1381
1382                 gspca_frame_add(gspca_dev, FIRST_PACKET, sof, len_after_sof);
1383         }
1384 }
1385
1386 #if IS_ENABLED(CONFIG_INPUT)
1387 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
1388                         u8 *data,               /* interrupt packet data */
1389                         int len)                /* interrupt packet length */
1390 {
1391         int ret = -EINVAL;
1392
1393         if (len == 1 && data[0] == 1) {
1394                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
1395                 input_sync(gspca_dev->input_dev);
1396                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1397                 input_sync(gspca_dev->input_dev);
1398                 ret = 0;
1399         }
1400
1401         return ret;
1402 }
1403 #endif
1404
1405 /* sub-driver description */
1406 static const struct sd_desc sd_desc = {
1407         .name = MODULE_NAME,
1408         .config = sd_config,
1409         .init = sd_init,
1410         .init_controls = sd_init_controls,
1411         .start = sd_start,
1412         .stopN = sd_stopN,
1413         .pkt_scan = sd_pkt_scan,
1414         .dq_callback = do_autogain,
1415 #if IS_ENABLED(CONFIG_INPUT)
1416         .int_pkt_scan = sd_int_pkt_scan,
1417 #endif
1418 };
1419
1420 /* -- module initialisation -- */
1421 #define SB(sensor, bridge) \
1422         .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
1423
1424
1425 static const struct usb_device_id device_table[] = {
1426         {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110C, 102)}, /* TAS5110C1B */
1427         {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110C, 101)}, /* TAS5110C1B */
1428         {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110D, 101)}, /* TAS5110D */
1429         {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
1430         {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
1431         {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
1432         {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
1433         {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
1434         {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
1435         {USB_DEVICE(0x0c45, 0x6027), SB(OV7630, 101)}, /* Genius Eye 310 */
1436         {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
1437         {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
1438         {USB_DEVICE(0x0c45, 0x602a), SB(HV7131D, 102)},
1439         /* {USB_DEVICE(0x0c45, 0x602b), SB(MI0343, 102)}, */
1440         {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
1441         {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
1442         {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
1443         /* {USB_DEVICE(0x0c45, 0x6030), SB(MI03XX, 102)}, */ /* MI0343 MI0360 MI0330 */
1444         /* {USB_DEVICE(0x0c45, 0x6082), SB(MI03XX, 103)}, */ /* MI0343 MI0360 */
1445         {USB_DEVICE(0x0c45, 0x6083), SB(HV7131D, 103)},
1446         {USB_DEVICE(0x0c45, 0x608c), SB(HV7131R, 103)},
1447         /* {USB_DEVICE(0x0c45, 0x608e), SB(CISVF10, 103)}, */
1448         {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
1449         {USB_DEVICE(0x0c45, 0x60a8), SB(PAS106, 103)},
1450         {USB_DEVICE(0x0c45, 0x60aa), SB(TAS5130CXX, 103)},
1451         {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
1452         {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
1453         {}
1454 };
1455 MODULE_DEVICE_TABLE(usb, device_table);
1456
1457 /* -- device connect -- */
1458 static int sd_probe(struct usb_interface *intf,
1459                         const struct usb_device_id *id)
1460 {
1461         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1462                                 THIS_MODULE);
1463 }
1464
1465 static struct usb_driver sd_driver = {
1466         .name = MODULE_NAME,
1467         .id_table = device_table,
1468         .probe = sd_probe,
1469         .disconnect = gspca_disconnect,
1470 #ifdef CONFIG_PM
1471         .suspend = gspca_suspend,
1472         .resume = gspca_resume,
1473         .reset_resume = gspca_resume,
1474 #endif
1475 };
1476
1477 module_usb_driver(sd_driver);