drivers/media/video/gspca/sonixj.c

   1 /*
   2  *              Sonix sn9c102p sn9c105 sn9c120 (jpeg) library
   3  *              Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr
   4  *
   5  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21
  22 #define MODULE_NAME "sonixj"
  23
  24 #include "gspca.h"
  25 #include "jpeg.h"
  26
  27 #define V4L2_CID_INFRARED (V4L2_CID_PRIVATE_BASE + 0)
  28
  29 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
  30 MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver");
  31 MODULE_LICENSE("GPL");
  32
  33 /* specific webcam descriptor */
  34 struct sd {
  35         struct gspca_dev gspca_dev;     /* !! must be the first item */
  36
  37         atomic_t avg_lum;
  38         u32 exposure;
  39
  40         u16 brightness;
  41         u8 contrast;
  42         u8 colors;
  43         u8 autogain;
  44         u8 blue;
  45         u8 red;
  46         u8 gamma;
  47         u8 vflip;                       /* ov7630/ov7648 only */
  48         u8 infrared;                    /* mt9v111 only */
  49         u8 quality;                     /* image quality */
  50         u8 jpegqual;                    /* webcam quality */
  51
  52         u8 reg18;
  53
  54         s8 ag_cnt;
  55 #define AG_CNT_START 13
  56
  57         u8 bridge;
  58 #define BRIDGE_SN9C102P 0
  59 #define BRIDGE_SN9C105 1
  60 #define BRIDGE_SN9C110 2
  61 #define BRIDGE_SN9C120 3
  62 #define BRIDGE_SN9C325 4
  63         u8 sensor;                      /* Type of image sensor chip */
  64 #define SENSOR_HV7131R 0
  65 #define SENSOR_MI0360 1
  66 #define SENSOR_MO4000 2
  67 #define SENSOR_MT9V111 3
  68 #define SENSOR_OM6802 4
  69 #define SENSOR_OV7630 5
  70 #define SENSOR_OV7648 6
  71 #define SENSOR_OV7660 7
  72 #define SENSOR_SP80708 8
  73         u8 i2c_base;
  74
  75         u8 *jpeg_hdr;
  76 };
  77
  78 /* V4L2 controls supported by the driver */
  79 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
  80 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
  81 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
  82 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
  83 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
  84 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
  85 static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val);
  86 static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val);
  87 static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val);
  88 static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val);
  89 static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
  90 static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val);
  91 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
  92 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
  93 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
  94 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
  95 static int sd_setinfrared(struct gspca_dev *gspca_dev, __s32 val);
  96 static int sd_getinfrared(struct gspca_dev *gspca_dev, __s32 *val);
  97
  98 static struct ctrl sd_ctrls[] = {
  99         {
 100             {
 101                 .id      = V4L2_CID_BRIGHTNESS,
 102                 .type    = V4L2_CTRL_TYPE_INTEGER,
 103                 .name    = "Brightness",
 104                 .minimum = 0,
 105 #define BRIGHTNESS_MAX 0xffff
 106                 .maximum = BRIGHTNESS_MAX,
 107                 .step    = 1,
 108 #define BRIGHTNESS_DEF 0x8000
 109                 .default_value = BRIGHTNESS_DEF,
 110             },
 111             .set = sd_setbrightness,
 112             .get = sd_getbrightness,
 113         },
 114         {
 115             {
 116                 .id      = V4L2_CID_CONTRAST,
 117                 .type    = V4L2_CTRL_TYPE_INTEGER,
 118                 .name    = "Contrast",
 119                 .minimum = 0,
 120 #define CONTRAST_MAX 127
 121                 .maximum = CONTRAST_MAX,
 122                 .step    = 1,
 123 #define CONTRAST_DEF 63
 124                 .default_value = CONTRAST_DEF,
 125             },
 126             .set = sd_setcontrast,
 127             .get = sd_getcontrast,
 128         },
 129         {
 130             {
 131                 .id      = V4L2_CID_SATURATION,
 132                 .type    = V4L2_CTRL_TYPE_INTEGER,
 133                 .name    = "Color",
 134                 .minimum = 0,
 135                 .maximum = 40,
 136                 .step    = 1,
 137 #define COLOR_DEF 32
 138                 .default_value = COLOR_DEF,
 139             },
 140             .set = sd_setcolors,
 141             .get = sd_getcolors,
 142         },
 143         {
 144             {
 145                 .id      = V4L2_CID_BLUE_BALANCE,
 146                 .type    = V4L2_CTRL_TYPE_INTEGER,
 147                 .name    = "Blue Balance",
 148                 .minimum = 24,
 149                 .maximum = 40,
 150                 .step    = 1,
 151 #define BLUE_BALANCE_DEF 32
 152                 .default_value = BLUE_BALANCE_DEF,
 153             },
 154             .set = sd_setblue_balance,
 155             .get = sd_getblue_balance,
 156         },
 157         {
 158             {
 159                 .id      = V4L2_CID_RED_BALANCE,
 160                 .type    = V4L2_CTRL_TYPE_INTEGER,
 161                 .name    = "Red Balance",
 162                 .minimum = 24,
 163                 .maximum = 40,
 164                 .step    = 1,
 165 #define RED_BALANCE_DEF 32
 166                 .default_value = RED_BALANCE_DEF,
 167             },
 168             .set = sd_setred_balance,
 169             .get = sd_getred_balance,
 170         },
 171         {
 172             {
 173                 .id      = V4L2_CID_GAMMA,
 174                 .type    = V4L2_CTRL_TYPE_INTEGER,
 175                 .name    = "Gamma",
 176                 .minimum = 0,
 177                 .maximum = 40,
 178                 .step    = 1,
 179 #define GAMMA_DEF 20
 180                 .default_value = GAMMA_DEF,
 181             },
 182             .set = sd_setgamma,
 183             .get = sd_getgamma,
 184         },
 185 #define AUTOGAIN_IDX 5
 186         {
 187             {
 188                 .id      = V4L2_CID_AUTOGAIN,
 189                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 190                 .name    = "Auto Gain",
 191                 .minimum = 0,
 192                 .maximum = 1,
 193                 .step    = 1,
 194 #define AUTOGAIN_DEF 1
 195                 .default_value = AUTOGAIN_DEF,
 196             },
 197             .set = sd_setautogain,
 198             .get = sd_getautogain,
 199         },
 200 /* ov7630/ov7648 only */
 201 #define VFLIP_IDX 6
 202         {
 203             {
 204                 .id      = V4L2_CID_VFLIP,
 205                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 206                 .name    = "Vflip",
 207                 .minimum = 0,
 208                 .maximum = 1,
 209                 .step    = 1,
 210 #define VFLIP_DEF 0                     /* vflip def = 1 for ov7630 */
 211                 .default_value = VFLIP_DEF,
 212             },
 213             .set = sd_setvflip,
 214             .get = sd_getvflip,
 215         },
 216 /* mt9v111 only */
 217 #define INFRARED_IDX 7
 218         {
 219             {
 220                 .id      = V4L2_CID_INFRARED,
 221                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 222                 .name    = "Infrared",
 223                 .minimum = 0,
 224                 .maximum = 1,
 225                 .step    = 1,
 226 #define INFRARED_DEF 0
 227                 .default_value = INFRARED_DEF,
 228             },
 229             .set = sd_setinfrared,
 230             .get = sd_getinfrared,
 231         },
 232 };
 233
 234 /* table of the disabled controls */
 235 static __u32 ctrl_dis[] = {
 236         (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
 237                                                 /* SENSOR_HV7131R 0 */
 238         (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
 239                                                 /* SENSOR_MI0360 1 */
 240         (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
 241                                                 /* SENSOR_MO4000 2 */
 242         (1 << VFLIP_IDX),
 243                                                 /* SENSOR_MT9V111 3 */
 244         (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
 245                                                 /* SENSOR_OM6802 4 */
 246         (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX),
 247                                                 /* SENSOR_OV7630 5 */
 248         (1 << INFRARED_IDX),
 249                                                 /* SENSOR_OV7648 6 */
 250         (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
 251                                                 /* SENSOR_OV7660 7 */
 252         (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
 253                                                 /* SENSOR_SP80708 8 */
 254 };
 255
 256 static const struct v4l2_pix_format vga_mode[] = {
 257         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 258                 .bytesperline = 160,
 259                 .sizeimage = 160 * 120 * 4 / 8 + 590,
 260                 .colorspace = V4L2_COLORSPACE_JPEG,
 261                 .priv = 2},
 262         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 263                 .bytesperline = 320,
 264                 .sizeimage = 320 * 240 * 3 / 8 + 590,
 265                 .colorspace = V4L2_COLORSPACE_JPEG,
 266                 .priv = 1},
 267         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 268                 .bytesperline = 640,
 269                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 270                 .colorspace = V4L2_COLORSPACE_JPEG,
 271                 .priv = 0},
 272 };
 273
 274 /*Data from sn9c102p+hv7131r */
 275 static const u8 sn_hv7131[0x1c] = {
 276 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 277         0x00,   0x03,   0x64,   0x00,   0x1a,   0x20,   0x20,   0x20,
 278 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 279         0xa1,   0x11,   0x02,   0x09,   0x00,   0x00,   0x00,   0x10,
 280 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 281         0x03,   0x00,   0x00,   0x01,   0x03,   0x28,   0x1e,   0x41,
 282 /*      reg18   reg19   reg1a   reg1b */
 283         0x0a,   0x00,   0x00,   0x00
 284 };
 285
 286 static const u8 sn_mi0360[0x1c] = {
 287 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 288         0x00,   0x61,   0x44,   0x00,   0x1a,   0x20,   0x20,   0x20,
 289 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 290         0xb1,   0x5d,   0x07,   0x00,   0x00,   0x00,   0x00,   0x10,
 291 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 292         0x03,   0x00,   0x00,   0x02,   0x0a,   0x28,   0x1e,   0x61,
 293 /*      reg18   reg19   reg1a   reg1b */
 294         0x06,   0x00,   0x00,   0x00
 295 };
 296
 297 static const u8 sn_mo4000[0x1c] = {
 298 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 299         0x00,   0x23,   0x60,   0x00,   0x1a,   0x00,   0x20,   0x18,
 300 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 301         0x81,   0x21,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
 302 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 303         0x03,    0x00,  0x0b,   0x0f,   0x14,   0x28,   0x1e,   0x40,
 304 /*      reg18   reg19   reg1a   reg1b */
 305         0x08,   0x00,   0x00,   0x00
 306 };
 307
 308 static const u8 sn_mt9v111[0x1c] = {
 309 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 310         0x00,   0x61,   0x40,   0x00,   0x1a,   0x20,   0x20,   0x20,
 311 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 312         0x81,   0x5c,   0x07,   0x00,   0x00,   0x00,   0x00,   0x00,
 313 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 314         0x03,   0x00,   0x00,   0x02,   0x1c,   0x28,   0x1e,   0x40,
 315 /*      reg18   reg19   reg1a   reg1b */
 316         0x06,   0x00,   0x00,   0x00
 317 };
 318
 319 static const u8 sn_om6802[0x1c] = {
 320 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 321         0x00,   0x23,   0x72,   0x00,   0x1a,   0x34,   0x27,   0x20,
 322 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 323         0x80,   0x34,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
 324 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 325         0x03,   0x00,   0x51,   0x01,   0x00,   0x28,   0x1e,   0x40,
 326 /*      reg18   reg19   reg1a   reg1b */
 327         0x05,   0x00,   0x00,   0x00
 328 };
 329
 330 static const u8 sn_ov7630[0x1c] = {
 331 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 332         0x00,   0x21,   0x40,   0x00,   0x1a,   0x20,   0x1f,   0x20,
 333 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 334         0xa1,   0x21,   0x76,   0x21,   0x00,   0x00,   0x00,   0x10,
 335 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 336         0x03,   0x00,   0x04,   0x01,   0x0a,   0x28,   0x1e,   0xc2,
 337 /*      reg18   reg19   reg1a   reg1b */
 338         0x0b,   0x00,   0x00,   0x00
 339 };
 340
 341 static const u8 sn_ov7648[0x1c] = {
 342 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 343         0x00,   0x63,   0x40,   0x00,   0x1a,   0x20,   0x20,   0x20,
 344 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 345         0x81,   0x21,   0x00,   0x00,   0x00,   0x00,   0x00,   0x10,
 346 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 347         0x03,   0x00,   0x00,   0x01,   0x00,   0x28,   0x1e,   0x00,
 348 /*      reg18   reg19   reg1a   reg1b */
 349         0x0b,   0x00,   0x00,   0x00
 350 };
 351
 352 static const u8 sn_ov7660[0x1c] = {
 353 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 354         0x00,   0x61,   0x40,   0x00,   0x1a,   0x20,   0x20,   0x20,
 355 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 356         0x81,   0x21,   0x07,   0x00,   0x00,   0x00,   0x00,   0x10,
 357 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 358         0x03,   0x00,   0x01,   0x01,   0x08,   0x28,   0x1e,   0x20,
 359 /*      reg18   reg19   reg1a   reg1b */
 360         0x07,   0x00,   0x00,   0x00
 361 };
 362
 363 static const u8 sn_sp80708[0x1c] = {
 364 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 365         0x00,   0x63,   0x60,   0x00,   0x1a,   0x20,   0x20,   0x20,
 366 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 367         0x81,   0x18,   0x07,   0x00,   0x00,   0x00,   0x00,   0x00,
 368 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 369         0x03,   0x00,   0x00,   0x03,   0x04,   0x28,   0x1e,   0x00,
 370 /*      reg18   reg19   reg1a   reg1b */
 371         0x07,   0x00,   0x00,   0x00
 372 };
 373
 374 /* sequence specific to the sensors - !! index = SENSOR_xxx */
 375 static const u8 *sn_tb[] = {
 376         sn_hv7131,
 377         sn_mi0360,
 378         sn_mo4000,
 379         sn_mt9v111,
 380         sn_om6802,
 381         sn_ov7630,
 382         sn_ov7648,
 383         sn_ov7660,
 384         sn_sp80708
 385 };
 386
 387 /* default gamma table */
 388 static const u8 gamma_def[17] = {
 389         0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
 390         0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
 391 };
 392 /* gamma for sensors HV7131R and MT9V111 */
 393 static const u8 gamma_spec_1[17] = {
 394         0x08, 0x3a, 0x52, 0x65, 0x75, 0x83, 0x91, 0x9d,
 395         0xa9, 0xb4, 0xbe, 0xc8, 0xd2, 0xdb, 0xe4, 0xed, 0xf5
 396 };
 397 /* gamma for sensor SP80708 */
 398 static const u8 gamma_spec_2[17] = {
 399         0x0a, 0x2d, 0x4e, 0x68, 0x7d, 0x8f, 0x9f, 0xab,
 400         0xb7, 0xc2, 0xcc, 0xd3, 0xd8, 0xde, 0xe2, 0xe5, 0xe6
 401 };
 402
 403 /* color matrix and offsets */
 404 static const u8 reg84[] = {
 405         0x14, 0x00, 0x27, 0x00, 0x07, 0x00,     /* YR YG YB gains */
 406         0xe8, 0x0f, 0xda, 0x0f, 0x40, 0x00,     /* UR UG UB */
 407         0x3e, 0x00, 0xcd, 0x0f, 0xf7, 0x0f,     /* VR VG VB */
 408         0x00, 0x00, 0x00                        /* YUV offsets */
 409 };
 410 static const u8 hv7131r_sensor_init[][8] = {
 411         {0xc1, 0x11, 0x01, 0x08, 0x01, 0x00, 0x00, 0x10},
 412         {0xb1, 0x11, 0x34, 0x17, 0x7f, 0x00, 0x00, 0x10},
 413         {0xd1, 0x11, 0x40, 0xff, 0x7f, 0x7f, 0x7f, 0x10},
 414 /*      {0x91, 0x11, 0x44, 0x00, 0x00, 0x00, 0x00, 0x10}, */
 415         {0xd1, 0x11, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 416         {0xd1, 0x11, 0x14, 0x01, 0xe2, 0x02, 0x82, 0x10},
 417 /*      {0x91, 0x11, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10}, */
 418
 419         {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 420         {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 421         {0xc1, 0x11, 0x25, 0x00, 0x61, 0xa8, 0x00, 0x10},
 422         {0xa1, 0x11, 0x30, 0x22, 0x00, 0x00, 0x00, 0x10},
 423         {0xc1, 0x11, 0x31, 0x20, 0x2e, 0x20, 0x00, 0x10},
 424         {0xc1, 0x11, 0x25, 0x00, 0xc3, 0x50, 0x00, 0x10},
 425         {0xa1, 0x11, 0x30, 0x07, 0x00, 0x00, 0x00, 0x10}, /* gain14 */
 426         {0xc1, 0x11, 0x31, 0x10, 0x10, 0x10, 0x00, 0x10}, /* r g b 101a10 */
 427
 428         {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 429         {0xa1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
 430         {0xa1, 0x11, 0x21, 0xD0, 0x00, 0x00, 0x00, 0x10},
 431         {0xa1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 432         {0xa1, 0x11, 0x23, 0x09, 0x00, 0x00, 0x00, 0x10},
 433
 434         {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 435         {0xa1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
 436         {0xa1, 0x11, 0x21, 0xd0, 0x00, 0x00, 0x00, 0x10},
 437         {0xa1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 438         {0xa1, 0x11, 0x23, 0x10, 0x00, 0x00, 0x00, 0x10},
 439         {}
 440 };
 441 static const u8 mi0360_sensor_init[][8] = {
 442         {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
 443         {0xb1, 0x5d, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
 444         {0xb1, 0x5d, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
 445         {0xd1, 0x5d, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
 446         {0xd1, 0x5d, 0x03, 0x01, 0xe2, 0x02, 0x82, 0x10},
 447         {0xd1, 0x5d, 0x05, 0x00, 0x09, 0x00, 0x53, 0x10},
 448         {0xb1, 0x5d, 0x0d, 0x00, 0x02, 0x00, 0x00, 0x10},
 449         {0xd1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
 450         {0xd1, 0x5d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10},
 451         {0xd1, 0x5d, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
 452         {0xd1, 0x5d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 453         {0xd1, 0x5d, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
 454         {0xd1, 0x5d, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
 455         {0xd1, 0x5d, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
 456         {0xd1, 0x5d, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
 457         {0xd1, 0x5d, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x10},
 458         {0xd1, 0x5d, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
 459         {0xb1, 0x5d, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
 460         {0xd1, 0x5d, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
 461         {0xd1, 0x5d, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 462         {0xd1, 0x5d, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
 463         {0xd1, 0x5d, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
 464         {0xd1, 0x5d, 0x2f, 0xf7, 0xB0, 0x00, 0x04, 0x10},
 465         {0xd1, 0x5d, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
 466         {0xd1, 0x5d, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
 467         {0xb1, 0x5d, 0x3d, 0x06, 0x8f, 0x00, 0x00, 0x10},
 468         {0xd1, 0x5d, 0x40, 0x01, 0xe0, 0x00, 0xd1, 0x10},
 469         {0xb1, 0x5d, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
 470         {0xd1, 0x5d, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
 471         {0xd1, 0x5d, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x10},
 472         {0xd1, 0x5d, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x10},
 473         {0xd1, 0x5d, 0x5e, 0x00, 0x00, 0xa3, 0x1d, 0x10},
 474         {0xb1, 0x5d, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},
 475
 476         {0xb1, 0x5d, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
 477         {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
 478         {0xb1, 0x5d, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
 479         {0xd1, 0x5d, 0x2b, 0x00, 0xa0, 0x00, 0xb0, 0x10},
 480         {0xd1, 0x5d, 0x2d, 0x00, 0xa0, 0x00, 0xa0, 0x10},
 481
 482         {0xb1, 0x5d, 0x0a, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor clck ?2 */
 483         {0xb1, 0x5d, 0x06, 0x00, 0x30, 0x00, 0x00, 0x10},
 484         {0xb1, 0x5d, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x10},
 485         {0xb1, 0x5d, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10}, /* exposure 2 */
 486
 487         {0xd1, 0x5d, 0x2b, 0x00, 0xb9, 0x00, 0xe3, 0x10},
 488         {0xd1, 0x5d, 0x2d, 0x00, 0x5f, 0x00, 0xb9, 0x10}, /* 42 */
 489 /*      {0xb1, 0x5d, 0x35, 0x00, 0x67, 0x00, 0x00, 0x10}, * gain orig */
 490 /*      {0xb1, 0x5d, 0x35, 0x00, 0x20, 0x00, 0x00, 0x10}, * gain */
 491         {0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10}, /* update */
 492         {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
 493         {}
 494 };
 495 static const u8 mo4000_sensor_init[][8] = {
 496         {0xa1, 0x21, 0x01, 0x02, 0x00, 0x00, 0x00, 0x10},
 497         {0xa1, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10},
 498         {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
 499         {0xa1, 0x21, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
 500         {0xa1, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
 501         {0xa1, 0x21, 0x05, 0x04, 0x00, 0x00, 0x00, 0x10},
 502         {0xa1, 0x21, 0x06, 0x80, 0x00, 0x00, 0x00, 0x10},
 503         {0xa1, 0x21, 0x06, 0x81, 0x00, 0x00, 0x00, 0x10},
 504         {0xa1, 0x21, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
 505         {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
 506         {0xa1, 0x21, 0x11, 0x20, 0x00, 0x00, 0x00, 0x10},
 507         {0xa1, 0x21, 0x11, 0x30, 0x00, 0x00, 0x00, 0x10},
 508         {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
 509         {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
 510         {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
 511         {0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 512         {0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10},
 513         {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10},
 514         {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
 515         {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
 516         {}
 517 };
 518 static const u8 mt9v111_sensor_init[][8] = {
 519         {0xb1, 0x5c, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10}, /* reset? */
 520         /* delay 20 ms */
 521         {0xb1, 0x5c, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
 522         {0xb1, 0x5c, 0x01, 0x00, 0x01, 0x00, 0x00, 0x10}, /* IFP select */
 523         {0xb1, 0x5c, 0x08, 0x04, 0x80, 0x00, 0x00, 0x10}, /* output fmt ctrl */
 524         {0xb1, 0x5c, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10}, /* op mode ctrl */
 525         {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10},
 526         {0xb1, 0x5c, 0x03, 0x01, 0xe1, 0x00, 0x00, 0x10},
 527         {0xb1, 0x5c, 0x04, 0x02, 0x81, 0x00, 0x00, 0x10},
 528         {0xb1, 0x5c, 0x05, 0x00, 0x04, 0x00, 0x00, 0x10},
 529         {0xb1, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10}, /* sensor select */
 530         {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10},
 531         {0xb1, 0x5c, 0x03, 0x01, 0xe6, 0x00, 0x00, 0x10},
 532         {0xb1, 0x5c, 0x04, 0x02, 0x86, 0x00, 0x00, 0x10},
 533         {0xb1, 0x5c, 0x05, 0x00, 0x04, 0x00, 0x00, 0x10},
 534         {0xb1, 0x5c, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10},
 535         {0xb1, 0x5c, 0x08, 0x00, 0x08, 0x00, 0x00, 0x10}, /* row start */
 536         {0xb1, 0x5c, 0x0e, 0x00, 0x08, 0x00, 0x00, 0x10},
 537         {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10}, /* col start */
 538         {0xb1, 0x5c, 0x03, 0x01, 0xe7, 0x00, 0x00, 0x10}, /* window height */
 539         {0xb1, 0x5c, 0x04, 0x02, 0x87, 0x00, 0x00, 0x10}, /* window width */
 540         {0xb1, 0x5c, 0x07, 0x30, 0x02, 0x00, 0x00, 0x10}, /* output ctrl */
 541         {0xb1, 0x5c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10}, /* shutter delay */
 542         {0xb1, 0x5c, 0x12, 0x00, 0xb0, 0x00, 0x00, 0x10}, /* zoom col start */
 543         {0xb1, 0x5c, 0x13, 0x00, 0x7c, 0x00, 0x00, 0x10}, /* zoom row start */
 544         {0xb1, 0x5c, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* digital zoom */
 545         {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10}, /* read mode */
 546         {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
 547         /*******/
 548         {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
 549         {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
 550         {0xb1, 0x5c, 0x09, 0x01, 0x2c, 0x00, 0x00, 0x10},
 551         {0xd1, 0x5c, 0x2b, 0x00, 0x33, 0x00, 0xa0, 0x10}, /* green1 gain */
 552         {0xd1, 0x5c, 0x2d, 0x00, 0xa0, 0x00, 0x33, 0x10}, /* red gain */
 553         /*******/
 554         {0xb1, 0x5c, 0x06, 0x00, 0x1e, 0x00, 0x00, 0x10}, /* vert blanking */
 555         {0xb1, 0x5c, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x10}, /* horiz blanking */
 556         {0xd1, 0x5c, 0x2c, 0x00, 0xad, 0x00, 0xad, 0x10}, /* blue gain */
 557         {0xb1, 0x5c, 0x35, 0x01, 0xc0, 0x00, 0x00, 0x10}, /* global gain */
 558         {}
 559 };
 560 static const u8 om6802_sensor_init[][8] = {
 561         {0xa0, 0x34, 0x90, 0x05, 0x00, 0x00, 0x00, 0x10},
 562         {0xa0, 0x34, 0x49, 0x85, 0x00, 0x00, 0x00, 0x10},
 563         {0xa0, 0x34, 0x5a, 0xc0, 0x00, 0x00, 0x00, 0x10},
 564         {0xa0, 0x34, 0xdd, 0x18, 0x00, 0x00, 0x00, 0x10},
 565 /*      {0xa0, 0x34, 0xfb, 0x11, 0x00, 0x00, 0x00, 0x10}, */
 566         {0xa0, 0x34, 0xf0, 0x04, 0x00, 0x00, 0x00, 0x10},
 567                                         /* white balance & auto-exposure */
 568 /*      {0xa0, 0x34, 0xf1, 0x02, 0x00, 0x00, 0x00, 0x10},
 569                                                          * set color mode */
 570 /*      {0xa0, 0x34, 0xfe, 0x5b, 0x00, 0x00, 0x00, 0x10},
 571                                                  * max AGC value in AE */
 572 /*      {0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10},
 573                                                          * preset AGC */
 574 /*      {0xa0, 0x34, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x10},
 575                                                  * preset brightness */
 576 /*      {0xa0, 0x34, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x10},
 577                                                          * preset contrast */
 578 /*      {0xa0, 0x34, 0xe8, 0x31, 0x00, 0x00, 0x00, 0x10},
 579                                                          * preset gamma */
 580         {0xa0, 0x34, 0xe9, 0x0f, 0x00, 0x00, 0x00, 0x10},
 581                                         /* luminance mode (0x4f = AE) */
 582         {0xa0, 0x34, 0xe4, 0xff, 0x00, 0x00, 0x00, 0x10},
 583                                                         /* preset shutter */
 584 /*      {0xa0, 0x34, 0xef, 0x00, 0x00, 0x00, 0x00, 0x10},
 585                                                          * auto frame rate */
 586 /*      {0xa0, 0x34, 0xfb, 0xee, 0x00, 0x00, 0x00, 0x10}, */
 587
 588 /*      {0xa0, 0x34, 0x71, 0x84, 0x00, 0x00, 0x00, 0x10}, */
 589 /*      {0xa0, 0x34, 0x72, 0x05, 0x00, 0x00, 0x00, 0x10}, */
 590 /*      {0xa0, 0x34, 0x68, 0x80, 0x00, 0x00, 0x00, 0x10}, */
 591 /*      {0xa0, 0x34, 0x69, 0x01, 0x00, 0x00, 0x00, 0x10}, */
 592         {}
 593 };
 594 static const u8 ov7630_sensor_init[][8] = {
 595         {0xa1, 0x21, 0x76, 0x01, 0x00, 0x00, 0x00, 0x10},
 596         {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
 597 /* win: delay 20ms */
 598         {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 599         {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
 600 /* win: delay 20ms */
 601         {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 602 /* win: i2c_r from 00 to 80 */
 603         {0xd1, 0x21, 0x03, 0x80, 0x10, 0x20, 0x80, 0x10},
 604         {0xb1, 0x21, 0x0c, 0x20, 0x20, 0x00, 0x00, 0x10},
 605         {0xd1, 0x21, 0x11, 0x00, 0x48, 0xc0, 0x00, 0x10},
 606         {0xb1, 0x21, 0x15, 0x80, 0x03, 0x00, 0x00, 0x10},
 607         {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
 608         {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
 609         {0xd1, 0x21, 0x1f, 0x00, 0x80, 0x80, 0x80, 0x10},
 610         {0xd1, 0x21, 0x23, 0xde, 0x10, 0x8a, 0xa0, 0x10},
 611         {0xc1, 0x21, 0x27, 0xca, 0xa2, 0x74, 0x00, 0x10},
 612         {0xd1, 0x21, 0x2a, 0x88, 0x00, 0x88, 0x01, 0x10},
 613         {0xc1, 0x21, 0x2e, 0x80, 0x00, 0x18, 0x00, 0x10},
 614         {0xa1, 0x21, 0x21, 0x08, 0x00, 0x00, 0x00, 0x10},
 615         {0xa1, 0x21, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 616         {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
 617         {0xb1, 0x21, 0x32, 0xc2, 0x08, 0x00, 0x00, 0x10},
 618         {0xb1, 0x21, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x10},
 619         {0xd1, 0x21, 0x60, 0x05, 0x40, 0x12, 0x57, 0x10},
 620         {0xa1, 0x21, 0x64, 0x73, 0x00, 0x00, 0x00, 0x10},
 621         {0xd1, 0x21, 0x65, 0x00, 0x55, 0x01, 0xac, 0x10},
 622         {0xa1, 0x21, 0x69, 0x38, 0x00, 0x00, 0x00, 0x10},
 623         {0xd1, 0x21, 0x6f, 0x1f, 0x01, 0x00, 0x10, 0x10},
 624         {0xd1, 0x21, 0x73, 0x50, 0x20, 0x02, 0x01, 0x10},
 625         {0xd1, 0x21, 0x77, 0xf3, 0x90, 0x98, 0x98, 0x10},
 626         {0xc1, 0x21, 0x7b, 0x00, 0x4c, 0xf7, 0x00, 0x10},
 627         {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
 628         {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
 629 /* */
 630         {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 631         {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 632 /*fixme: + 0x12, 0x04*/
 633 /*      {0xa1, 0x21, 0x75, 0x82, 0x00, 0x00, 0x00, 0x10},  * COMN
 634                                                          * set by setvflip */
 635         {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
 636         {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
 637         {0xb1, 0x21, 0x01, 0x80, 0x80, 0x00, 0x00, 0x10},
 638 /* */
 639         {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
 640         {0xa1, 0x21, 0x2a, 0x88, 0x00, 0x00, 0x00, 0x10},
 641         {0xa1, 0x21, 0x2b, 0x34, 0x00, 0x00, 0x00, 0x10},
 642 /* */
 643         {0xa1, 0x21, 0x10, 0x83, 0x00, 0x00, 0x00, 0x10},
 644 /*      {0xb1, 0x21, 0x01, 0x88, 0x70, 0x00, 0x00, 0x10}, */
 645         {}
 646 };
 647
 648 static const u8 ov7648_sensor_init[][8] = {
 649         {0xa1, 0x21, 0x76, 0x00, 0x00, 0x00, 0x00, 0x10},
 650         {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},       /* reset */
 651         {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
 652         {0xd1, 0x21, 0x03, 0xa4, 0x30, 0x88, 0x00, 0x10},
 653         {0xb1, 0x21, 0x11, 0x80, 0x08, 0x00, 0x00, 0x10},
 654         {0xc1, 0x21, 0x13, 0xa0, 0x04, 0x84, 0x00, 0x10},
 655         {0xd1, 0x21, 0x17, 0x1a, 0x02, 0xba, 0xf4, 0x10},
 656         {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
 657         {0xd1, 0x21, 0x1f, 0x41, 0xc0, 0x80, 0x80, 0x10},
 658         {0xd1, 0x21, 0x23, 0xde, 0xa0, 0x80, 0x32, 0x10},
 659         {0xd1, 0x21, 0x27, 0xfe, 0xa0, 0x00, 0x91, 0x10},
 660         {0xd1, 0x21, 0x2b, 0x00, 0x88, 0x85, 0x80, 0x10},
 661         {0xc1, 0x21, 0x2f, 0x9c, 0x00, 0xc4, 0x00, 0x10},
 662         {0xd1, 0x21, 0x60, 0xa6, 0x60, 0x88, 0x12, 0x10},
 663         {0xd1, 0x21, 0x64, 0x88, 0x00, 0x00, 0x94, 0x10},
 664         {0xd1, 0x21, 0x68, 0x7a, 0x0c, 0x00, 0x00, 0x10},
 665         {0xd1, 0x21, 0x6c, 0x11, 0x33, 0x22, 0x00, 0x10},
 666         {0xd1, 0x21, 0x70, 0x11, 0x00, 0x10, 0x50, 0x10},
 667         {0xd1, 0x21, 0x74, 0x20, 0x06, 0x00, 0xb5, 0x10},
 668         {0xd1, 0x21, 0x78, 0x8a, 0x00, 0x00, 0x00, 0x10},
 669         {0xb1, 0x21, 0x7c, 0x00, 0x43, 0x00, 0x00, 0x10},
 670
 671         {0xd1, 0x21, 0x21, 0x86, 0x00, 0xde, 0xa0, 0x10},
 672 /*      {0xd1, 0x21, 0x25, 0x80, 0x32, 0xfe, 0xa0, 0x10}, jfm done */
 673 /*      {0xd1, 0x21, 0x29, 0x00, 0x91, 0x00, 0x88, 0x10}, jfm done */
 674         {0xb1, 0x21, 0x2d, 0x85, 0x00, 0x00, 0x00, 0x10},
 675 /*...*/
 676 /*      {0xa1, 0x21, 0x12, 0x08, 0x00, 0x00, 0x00, 0x10}, jfm done */
 677 /*      {0xa1, 0x21, 0x75, 0x06, 0x00, 0x00, 0x00, 0x10},   * COMN
 678                                                          * set by setvflip */
 679         {0xa1, 0x21, 0x19, 0x02, 0x00, 0x00, 0x00, 0x10},
 680         {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
 681 /*      {0xa1, 0x21, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
 682 /*      {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},  * GAIN - def */
 683 /*      {0xb1, 0x21, 0x01, 0x6c, 0x6c, 0x00, 0x00, 0x10},  * B R - def: 80 */
 684 /*...*/
 685         {0xa1, 0x21, 0x11, 0x81, 0x00, 0x00, 0x00, 0x10}, /* CLKRC */
 686 /*      {0xa1, 0x21, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
 687 /*      {0xa1, 0x21, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
 688 /*      {0xa1, 0x21, 0x2a, 0x91, 0x00, 0x00, 0x00, 0x10}, jfm done */
 689 /*      {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
 690 /*      {0xb1, 0x21, 0x01, 0x64, 0x84, 0x00, 0x00, 0x10},  * B R - def: 80 */
 691
 692         {}
 693 };
 694
 695 static const u8 ov7660_sensor_init[][8] = {
 696         {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset SCCB */
 697 /*              (delay 20ms) */
 698         {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
 699                                                 /* Outformat = rawRGB */
 700         {0xa1, 0x21, 0x13, 0xb8, 0x00, 0x00, 0x00, 0x10}, /* init COM8 */
 701         {0xd1, 0x21, 0x00, 0x01, 0x74, 0x74, 0x00, 0x10},
 702                                                 /* GAIN BLUE RED VREF */
 703         {0xd1, 0x21, 0x04, 0x00, 0x7d, 0x62, 0x00, 0x10},
 704                                                 /* COM 1 BAVE GEAVE AECHH */
 705         {0xb1, 0x21, 0x08, 0x83, 0x01, 0x00, 0x00, 0x10}, /* RAVE COM2 */
 706         {0xd1, 0x21, 0x0c, 0x00, 0x08, 0x04, 0x4f, 0x10}, /* COM 3 4 5 6 */
 707         {0xd1, 0x21, 0x10, 0x7f, 0x40, 0x05, 0xff, 0x10},
 708                                                 /* AECH CLKRC COM7 COM8 */
 709         {0xc1, 0x21, 0x14, 0x2c, 0x00, 0x02, 0x00, 0x10}, /* COM9 COM10 */
 710         {0xd1, 0x21, 0x17, 0x10, 0x60, 0x02, 0x7b, 0x10},
 711                                                 /* HSTART HSTOP VSTRT VSTOP */
 712         {0xa1, 0x21, 0x1b, 0x02, 0x00, 0x00, 0x00, 0x10}, /* PSHFT */
 713         {0xb1, 0x21, 0x1e, 0x01, 0x0e, 0x00, 0x00, 0x10}, /* MVFP LAEC */
 714         {0xd1, 0x21, 0x20, 0x07, 0x07, 0x07, 0x07, 0x10},
 715                                         /* BOS GBOS GROS ROS (BGGR offset) */
 716 /*      {0xd1, 0x21, 0x24, 0x68, 0x58, 0xd4, 0x80, 0x10}, */
 717         {0xd1, 0x21, 0x24, 0x78, 0x68, 0xd4, 0x80, 0x10},
 718                                                 /* AEW AEB VPT BBIAS */
 719         {0xd1, 0x21, 0x28, 0x80, 0x30, 0x00, 0x00, 0x10},
 720                                                 /* GbBIAS RSVD EXHCH EXHCL */
 721         {0xd1, 0x21, 0x2c, 0x80, 0x00, 0x00, 0x62, 0x10},
 722                                                 /* RBIAS ADVFL ASDVFH YAVE */
 723         {0xc1, 0x21, 0x30, 0x08, 0x30, 0xb4, 0x00, 0x10},
 724                                                 /* HSYST HSYEN HREF */
 725         {0xd1, 0x21, 0x33, 0x00, 0x07, 0x84, 0x00, 0x10}, /* reserved */
 726         {0xd1, 0x21, 0x37, 0x0c, 0x02, 0x43, 0x00, 0x10},
 727                                                 /* ADC ACOM OFON TSLB */
 728         {0xd1, 0x21, 0x3b, 0x02, 0x6c, 0x19, 0x0e, 0x10},
 729                                                 /* COM11 COM12 COM13 COM14 */
 730         {0xd1, 0x21, 0x3f, 0x41, 0xc1, 0x22, 0x08, 0x10},
 731                                                 /* EDGE COM15 COM16 COM17 */
 732         {0xd1, 0x21, 0x43, 0xf0, 0x10, 0x78, 0xa8, 0x10}, /* reserved */
 733         {0xd1, 0x21, 0x47, 0x60, 0x80, 0x00, 0x00, 0x10}, /* reserved */
 734         {0xd1, 0x21, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* reserved */
 735         {0xd1, 0x21, 0x4f, 0x46, 0x36, 0x0f, 0x17, 0x10}, /* MTX 1 2 3 4 */
 736         {0xd1, 0x21, 0x53, 0x7f, 0x96, 0x40, 0x40, 0x10}, /* MTX 5 6 7 8 */
 737         {0xb1, 0x21, 0x57, 0x40, 0x0f, 0x00, 0x00, 0x10}, /* MTX9 MTXS */
 738         {0xd1, 0x21, 0x59, 0xba, 0x9a, 0x22, 0xb9, 0x10}, /* reserved */
 739         {0xd1, 0x21, 0x5d, 0x9b, 0x10, 0xf0, 0x05, 0x10}, /* reserved */
 740         {0xa1, 0x21, 0x61, 0x60, 0x00, 0x00, 0x00, 0x10}, /* reserved */
 741         {0xd1, 0x21, 0x62, 0x00, 0x00, 0x50, 0x30, 0x10},
 742                                                 /* LCC1 LCC2 LCC3 LCC4 */
 743         {0xa1, 0x21, 0x66, 0x00, 0x00, 0x00, 0x00, 0x10}, /* LCC5 */
 744         {0xd1, 0x21, 0x67, 0x80, 0x7a, 0x90, 0x80, 0x10}, /* MANU */
 745         {0xa1, 0x21, 0x6b, 0x0a, 0x00, 0x00, 0x00, 0x10},
 746                                         /* band gap reference [0:3] DBLV */
 747         {0xd1, 0x21, 0x6c, 0x30, 0x48, 0x80, 0x74, 0x10}, /* gamma curve */
 748         {0xd1, 0x21, 0x70, 0x64, 0x60, 0x5c, 0x58, 0x10}, /* gamma curve */
 749         {0xd1, 0x21, 0x74, 0x54, 0x4c, 0x40, 0x38, 0x10}, /* gamma curve */
 750         {0xd1, 0x21, 0x78, 0x34, 0x30, 0x2f, 0x2b, 0x10}, /* gamma curve */
 751         {0xd1, 0x21, 0x7c, 0x03, 0x07, 0x17, 0x34, 0x10}, /* gamma curve */
 752         {0xd1, 0x21, 0x80, 0x41, 0x4d, 0x58, 0x63, 0x10}, /* gamma curve */
 753         {0xd1, 0x21, 0x84, 0x6e, 0x77, 0x87, 0x95, 0x10}, /* gamma curve */
 754         {0xc1, 0x21, 0x88, 0xaf, 0xc7, 0xdf, 0x00, 0x10}, /* gamma curve */
 755         {0xc1, 0x21, 0x8b, 0x99, 0x99, 0xcf, 0x00, 0x10}, /* reserved */
 756         {0xb1, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x10}, /* DM_LNL/H */
 757 /****** (some exchanges in the win trace) ******/
 758         {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10}, /* MVFP */
 759                                                 /* bits[3..0]reserved */
 760         {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10},
 761         {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
 762                                                 /* VREF vertical frame ctrl */
 763         {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
 764         {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10}, /* AECH 0x20 */
 765         {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFL */
 766         {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFH */
 767         {0xa1, 0x21, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x10}, /* GAIN */
 768 /*      {0xb1, 0x21, 0x01, 0x78, 0x78, 0x00, 0x00, 0x10}, * BLUE */
 769 /****** (some exchanges in the win trace) ******/
 770         {0xa1, 0x21, 0x93, 0x00, 0x00, 0x00, 0x00, 0x10},/* dummy line hight */
 771         {0xa1, 0x21, 0x92, 0x25, 0x00, 0x00, 0x00, 0x10}, /* dummy line low */
 772         {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCH */
 773         {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCL */
 774 /*      {0xa1, 0x21, 0x02, 0x90, 0x00, 0x00, 0x00, 0x10},  * RED */
 775 /****** (some exchanges in the win trace) ******/
 776 /******!! startsensor KO if changed !!****/
 777         {0xa1, 0x21, 0x93, 0x01, 0x00, 0x00, 0x00, 0x10},
 778         {0xa1, 0x21, 0x92, 0xff, 0x00, 0x00, 0x00, 0x10},
 779         {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
 780         {0xa1, 0x21, 0x2b, 0xc3, 0x00, 0x00, 0x00, 0x10},
 781         {}
 782 };
 783
 784 static const u8 sp80708_sensor_init[][8] = {
 785         {0xa1, 0x18, 0x06, 0xf9, 0x00, 0x00, 0x00, 0x10},
 786         {0xa1, 0x18, 0x09, 0x1f, 0x00, 0x00, 0x00, 0x10},
 787         {0xa1, 0x18, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
 788         {0xa1, 0x18, 0x0d, 0xc0, 0x00, 0x00, 0x00, 0x10},
 789         {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
 790         {0xa1, 0x18, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x10},
 791         {0xa1, 0x18, 0x10, 0x40, 0x00, 0x00, 0x00, 0x10},
 792         {0xa1, 0x18, 0x11, 0x4e, 0x00, 0x00, 0x00, 0x10},
 793         {0xa1, 0x18, 0x12, 0x53, 0x00, 0x00, 0x00, 0x10},
 794         {0xa1, 0x18, 0x15, 0x80, 0x00, 0x00, 0x00, 0x10},
 795         {0xa1, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x10},
 796         {0xa1, 0x18, 0x19, 0x18, 0x00, 0x00, 0x00, 0x10},
 797         {0xa1, 0x18, 0x1a, 0x10, 0x00, 0x00, 0x00, 0x10},
 798         {0xa1, 0x18, 0x1b, 0x10, 0x00, 0x00, 0x00, 0x10},
 799         {0xa1, 0x18, 0x1c, 0x28, 0x00, 0x00, 0x00, 0x10},
 800         {0xa1, 0x18, 0x1d, 0x02, 0x00, 0x00, 0x00, 0x10},
 801         {0xa1, 0x18, 0x1e, 0x10, 0x00, 0x00, 0x00, 0x10},
 802         {0xa1, 0x18, 0x26, 0x04, 0x00, 0x00, 0x00, 0x10},
 803         {0xa1, 0x18, 0x27, 0x1e, 0x00, 0x00, 0x00, 0x10},
 804         {0xa1, 0x18, 0x28, 0x5a, 0x00, 0x00, 0x00, 0x10},
 805         {0xa1, 0x18, 0x29, 0x28, 0x00, 0x00, 0x00, 0x10},
 806         {0xa1, 0x18, 0x2a, 0x78, 0x00, 0x00, 0x00, 0x10},
 807         {0xa1, 0x18, 0x2b, 0x01, 0x00, 0x00, 0x00, 0x10},
 808         {0xa1, 0x18, 0x2c, 0xf7, 0x00, 0x00, 0x00, 0x10},
 809         {0xa1, 0x18, 0x2d, 0x2d, 0x00, 0x00, 0x00, 0x10},
 810         {0xa1, 0x18, 0x2e, 0xd5, 0x00, 0x00, 0x00, 0x10},
 811         {0xa1, 0x18, 0x39, 0x42, 0x00, 0x00, 0x00, 0x10},
 812         {0xa1, 0x18, 0x3a, 0x67, 0x00, 0x00, 0x00, 0x10},
 813         {0xa1, 0x18, 0x3b, 0x87, 0x00, 0x00, 0x00, 0x10},
 814         {0xa1, 0x18, 0x3c, 0xa3, 0x00, 0x00, 0x00, 0x10},
 815         {0xa1, 0x18, 0x3d, 0xb0, 0x00, 0x00, 0x00, 0x10},
 816         {0xa1, 0x18, 0x3e, 0xbc, 0x00, 0x00, 0x00, 0x10},
 817         {0xa1, 0x18, 0x3f, 0xc8, 0x00, 0x00, 0x00, 0x10},
 818         {0xa1, 0x18, 0x40, 0xd4, 0x00, 0x00, 0x00, 0x10},
 819         {0xa1, 0x18, 0x41, 0xdf, 0x00, 0x00, 0x00, 0x10},
 820         {0xa1, 0x18, 0x42, 0xea, 0x00, 0x00, 0x00, 0x10},
 821         {0xa1, 0x18, 0x43, 0xf5, 0x00, 0x00, 0x00, 0x10},
 822         {0xa1, 0x18, 0x45, 0x80, 0x00, 0x00, 0x00, 0x10},
 823         {0xa1, 0x18, 0x46, 0x60, 0x00, 0x00, 0x00, 0x10},
 824         {0xa1, 0x18, 0x47, 0x50, 0x00, 0x00, 0x00, 0x10},
 825         {0xa1, 0x18, 0x48, 0x30, 0x00, 0x00, 0x00, 0x10},
 826         {0xa1, 0x18, 0x49, 0x01, 0x00, 0x00, 0x00, 0x10},
 827         {0xa1, 0x18, 0x4d, 0xae, 0x00, 0x00, 0x00, 0x10},
 828         {0xa1, 0x18, 0x4e, 0x03, 0x00, 0x00, 0x00, 0x10},
 829         {0xa1, 0x18, 0x4f, 0x66, 0x00, 0x00, 0x00, 0x10},
 830         {0xa1, 0x18, 0x50, 0x1c, 0x00, 0x00, 0x00, 0x10},
 831         {0xa1, 0x18, 0x44, 0x10, 0x00, 0x00, 0x00, 0x10},
 832         {0xa1, 0x18, 0x4a, 0x30, 0x00, 0x00, 0x00, 0x10},
 833         {0xa1, 0x18, 0x51, 0x80, 0x00, 0x00, 0x00, 0x10},
 834         {0xa1, 0x18, 0x52, 0x80, 0x00, 0x00, 0x00, 0x10},
 835         {0xa1, 0x18, 0x53, 0x80, 0x00, 0x00, 0x00, 0x10},
 836         {0xa1, 0x18, 0x54, 0x80, 0x00, 0x00, 0x00, 0x10},
 837         {0xa1, 0x18, 0x55, 0x80, 0x00, 0x00, 0x00, 0x10},
 838         {0xa1, 0x18, 0x56, 0x80, 0x00, 0x00, 0x00, 0x10},
 839         {0xa1, 0x18, 0x57, 0xe0, 0x00, 0x00, 0x00, 0x10},
 840         {0xa1, 0x18, 0x58, 0xc0, 0x00, 0x00, 0x00, 0x10},
 841         {0xa1, 0x18, 0x59, 0xab, 0x00, 0x00, 0x00, 0x10},
 842         {0xa1, 0x18, 0x5a, 0xa0, 0x00, 0x00, 0x00, 0x10},
 843         {0xa1, 0x18, 0x5b, 0x99, 0x00, 0x00, 0x00, 0x10},
 844         {0xa1, 0x18, 0x5c, 0x90, 0x00, 0x00, 0x00, 0x10},
 845         {0xa1, 0x18, 0x5e, 0x24, 0x00, 0x00, 0x00, 0x10},
 846         {0xa1, 0x18, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x10},
 847         {0xa1, 0x18, 0x60, 0x00, 0x00, 0x00, 0x00, 0x10},
 848         {0xa1, 0x18, 0x61, 0x73, 0x00, 0x00, 0x00, 0x10},
 849         {0xa1, 0x18, 0x63, 0x42, 0x00, 0x00, 0x00, 0x10},
 850         {0xa1, 0x18, 0x64, 0x42, 0x00, 0x00, 0x00, 0x10},
 851         {0xa1, 0x18, 0x65, 0x42, 0x00, 0x00, 0x00, 0x10},
 852         {0xa1, 0x18, 0x66, 0x24, 0x00, 0x00, 0x00, 0x10},
 853         {0xa1, 0x18, 0x67, 0x24, 0x00, 0x00, 0x00, 0x10},
 854         {0xa1, 0x18, 0x68, 0x08, 0x00, 0x00, 0x00, 0x10},
 855         {0xa1, 0x18, 0x2f, 0xc9, 0x00, 0x00, 0x00, 0x10},
 856         /********/
 857         {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
 858         {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
 859         {0xa1, 0x18, 0x03, 0x01, 0x00, 0x00, 0x00, 0x10},
 860         {0xa1, 0x18, 0x04, 0xa4, 0x00, 0x00, 0x00, 0x10},
 861         {0xa1, 0x18, 0x14, 0x3f, 0x00, 0x00, 0x00, 0x10},
 862         {0xa1, 0x18, 0x5d, 0x80, 0x00, 0x00, 0x00, 0x10},
 863         {0xb1, 0x18, 0x11, 0x40, 0x40, 0x00, 0x00, 0x10},
 864         {}
 865 };
 866
 867 /* read <len> bytes to gspca_dev->usb_buf */
 868 static void reg_r(struct gspca_dev *gspca_dev,
 869                   u16 value, int len)
 870 {
 871 #ifdef GSPCA_DEBUG
 872         if (len > USB_BUF_SZ) {
 873                 err("reg_r: buffer overflow");
 874                 return;
 875         }
 876 #endif
 877         usb_control_msg(gspca_dev->dev,
 878                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 879                         0,
 880                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 881                         value, 0,
 882                         gspca_dev->usb_buf, len,
 883                         500);
 884         PDEBUG(D_USBI, "reg_r [%02x] -> %02x", value, gspca_dev->usb_buf[0]);
 885 }
 886
 887 static void reg_w1(struct gspca_dev *gspca_dev,
 888                    u16 value,
 889                    u8 data)
 890 {
 891         PDEBUG(D_USBO, "reg_w1 [%04x] = %02x", value, data);
 892         gspca_dev->usb_buf[0] = data;
 893         usb_control_msg(gspca_dev->dev,
 894                         usb_sndctrlpipe(gspca_dev->dev, 0),
 895                         0x08,
 896                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 897                         value,
 898                         0,
 899                         gspca_dev->usb_buf, 1,
 900                         500);
 901 }
 902 static void reg_w(struct gspca_dev *gspca_dev,
 903                           u16 value,
 904                           const u8 *buffer,
 905                           int len)
 906 {
 907         PDEBUG(D_USBO, "reg_w [%04x] = %02x %02x ..",
 908                 value, buffer[0], buffer[1]);
 909 #ifdef GSPCA_DEBUG
 910         if (len > USB_BUF_SZ) {
 911                 err("reg_w: buffer overflow");
 912                 return;
 913         }
 914 #endif
 915         memcpy(gspca_dev->usb_buf, buffer, len);
 916         usb_control_msg(gspca_dev->dev,
 917                         usb_sndctrlpipe(gspca_dev->dev, 0),
 918                         0x08,
 919                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 920                         value, 0,
 921                         gspca_dev->usb_buf, len,
 922                         500);
 923 }
 924
 925 /* I2C write 1 byte */
 926 static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
 927 {
 928         struct sd *sd = (struct sd *) gspca_dev;
 929
 930         PDEBUG(D_USBO, "i2c_w2 [%02x] = %02x", reg, val);
 931         gspca_dev->usb_buf[0] = 0x81 | (2 << 4);        /* = a1 */
 932         gspca_dev->usb_buf[1] = sd->i2c_base;
 933         gspca_dev->usb_buf[2] = reg;
 934         gspca_dev->usb_buf[3] = val;
 935         gspca_dev->usb_buf[4] = 0;
 936         gspca_dev->usb_buf[5] = 0;
 937         gspca_dev->usb_buf[6] = 0;
 938         gspca_dev->usb_buf[7] = 0x10;
 939         usb_control_msg(gspca_dev->dev,
 940                         usb_sndctrlpipe(gspca_dev->dev, 0),
 941                         0x08,
 942                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 943                         0x08,                   /* value = i2c */
 944                         0,
 945                         gspca_dev->usb_buf, 8,
 946                         500);
 947 }
 948
 949 /* I2C write 8 bytes */
 950 static void i2c_w8(struct gspca_dev *gspca_dev,
 951                    const u8 *buffer)
 952 {
 953         memcpy(gspca_dev->usb_buf, buffer, 8);
 954         usb_control_msg(gspca_dev->dev,
 955                         usb_sndctrlpipe(gspca_dev->dev, 0),
 956                         0x08,
 957                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 958                         0x08, 0,                /* value, index */
 959                         gspca_dev->usb_buf, 8,
 960                         500);
 961         msleep(2);
 962 }
 963
 964 /* read 5 bytes in gspca_dev->usb_buf */
 965 static void i2c_r5(struct gspca_dev *gspca_dev, u8 reg)
 966 {
 967         struct sd *sd = (struct sd *) gspca_dev;
 968         u8 mode[8];
 969
 970         mode[0] = 0x81 | 0x10;
 971         mode[1] = sd->i2c_base;
 972         mode[2] = reg;
 973         mode[3] = 0;
 974         mode[4] = 0;
 975         mode[5] = 0;
 976         mode[6] = 0;
 977         mode[7] = 0x10;
 978         i2c_w8(gspca_dev, mode);
 979         msleep(2);
 980         mode[0] = 0x81 | (5 << 4) | 0x02;
 981         mode[2] = 0;
 982         i2c_w8(gspca_dev, mode);
 983         msleep(2);
 984         reg_r(gspca_dev, 0x0a, 5);
 985 }
 986
 987 static int hv7131r_probe(struct gspca_dev *gspca_dev)
 988 {
 989         i2c_w1(gspca_dev, 0x02, 0);                     /* sensor wakeup */
 990         msleep(10);
 991         reg_w1(gspca_dev, 0x02, 0x66);                  /* Gpio on */
 992         msleep(10);
 993         i2c_r5(gspca_dev, 0);                           /* read sensor id */
 994         if (gspca_dev->usb_buf[0] == 0x02
 995             && gspca_dev->usb_buf[1] == 0x09
 996             && gspca_dev->usb_buf[2] == 0x01
 997             && gspca_dev->usb_buf[3] == 0x00
 998             && gspca_dev->usb_buf[4] == 0x00) {
 999                 PDEBUG(D_PROBE, "Find Sensor sn9c102P HV7131R");
1000                 return 0;
1001         }
1002         PDEBUG(D_PROBE, "Find Sensor 0x%02x 0x%02x 0x%02x",
1003                 gspca_dev->usb_buf[0], gspca_dev->usb_buf[1],
1004                 gspca_dev->usb_buf[2]);
1005         PDEBUG(D_PROBE, "Sensor sn9c102P Not found");
1006         return -ENODEV;
1007 }
1008
1009 static void mi0360_probe(struct gspca_dev *gspca_dev)
1010 {
1011         struct sd *sd = (struct sd *) gspca_dev;
1012         int i, j;
1013         u16 val = 0;
1014         static const u8 probe_tb[][4][8] = {
1015             {                                   /* mi0360 */
1016                 {0xb0, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
1017                 {0x90, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1018                 {0xa2, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1019                 {0xb0, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10}
1020             },
1021             {                                   /* mt9v111 */
1022                 {0xb0, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10},
1023                 {0x90, 0x5c, 0x36, 0x00, 0x00, 0x00, 0x00, 0x10},
1024                 {0xa2, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1025                 {}
1026             },
1027         };
1028
1029         for (i = 0; i < ARRAY_SIZE(probe_tb); i++) {
1030                 reg_w1(gspca_dev, 0x17, 0x62);
1031                 reg_w1(gspca_dev, 0x01, 0x08);
1032                 for (j = 0; j < 3; j++)
1033                         i2c_w8(gspca_dev, probe_tb[i][j]);
1034                 msleep(2);
1035                 reg_r(gspca_dev, 0x0a, 5);
1036                 val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
1037                 if (probe_tb[i][3][0] != 0)
1038                         i2c_w8(gspca_dev, probe_tb[i][3]);
1039                 reg_w1(gspca_dev, 0x01, 0x29);
1040                 reg_w1(gspca_dev, 0x17, 0x42);
1041                 if (val != 0xffff)
1042                         break;
1043         }
1044         switch (val) {
1045         case 0x823a:
1046                 PDEBUG(D_PROBE, "Sensor mt9v111");
1047                 sd->sensor = SENSOR_MT9V111;
1048                 sd->i2c_base = 0x5c;
1049                 break;
1050         case 0x8243:
1051                 PDEBUG(D_PROBE, "Sensor mi0360");
1052                 break;
1053         default:
1054                 PDEBUG(D_PROBE, "Unknown sensor %04x - forced to mi0360", val);
1055                 break;
1056         }
1057 }
1058
1059 static int configure_gpio(struct gspca_dev *gspca_dev,
1060                           const u8 *sn9c1xx)
1061 {
1062         struct sd *sd = (struct sd *) gspca_dev;
1063         const u8 *reg9a;
1064         static const u8 reg9a_def[] =
1065                 {0x08, 0x40, 0x20, 0x10, 0x00, 0x04};
1066         static const u8 reg9a_sn9c325[] =
1067                 {0x0a, 0x40, 0x38, 0x30, 0x00, 0x20};
1068         static const u8 regd4[] = {0x60, 0x00, 0x00};
1069
1070         reg_w1(gspca_dev, 0xf1, 0x00);
1071         reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
1072
1073         /* configure gpio */
1074         reg_w(gspca_dev, 0x01, &sn9c1xx[1], 2);
1075         reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2);
1076         reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 5);      /* jfm len was 3 */
1077         switch (sd->bridge) {
1078         case BRIDGE_SN9C325:
1079                 reg9a = reg9a_sn9c325;
1080                 break;
1081         default:
1082                 reg9a = reg9a_def;
1083                 break;
1084         }
1085         reg_w(gspca_dev, 0x9a, reg9a, 6);
1086
1087         reg_w(gspca_dev, 0xd4, regd4, sizeof regd4); /*fixme:jfm was 60 only*/
1088
1089         reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
1090
1091         switch (sd->sensor) {
1092         case SENSOR_MT9V111:
1093                 reg_w1(gspca_dev, 0x01, 0x61);
1094                 reg_w1(gspca_dev, 0x17, 0x61);
1095                 reg_w1(gspca_dev, 0x01, 0x60);
1096                 reg_w1(gspca_dev, 0x01, 0x40);
1097                 break;
1098         case SENSOR_OM6802:
1099                 reg_w1(gspca_dev, 0x02, 0x71);
1100                 reg_w1(gspca_dev, 0x01, 0x42);
1101                 reg_w1(gspca_dev, 0x17, 0x64);
1102                 reg_w1(gspca_dev, 0x01, 0x42);
1103                 break;
1104 /*jfm: from win trace */
1105         case SENSOR_OV7630:
1106                 reg_w1(gspca_dev, 0x01, 0x61);
1107                 reg_w1(gspca_dev, 0x17, 0xe2);
1108                 reg_w1(gspca_dev, 0x01, 0x60);
1109                 reg_w1(gspca_dev, 0x01, 0x40);
1110                 break;
1111         case SENSOR_OV7648:
1112                 reg_w1(gspca_dev, 0x01, 0x63);
1113                 reg_w1(gspca_dev, 0x17, 0x20);
1114                 reg_w1(gspca_dev, 0x01, 0x42);
1115                 break;
1116 /*jfm: from win trace */
1117         case SENSOR_OV7660:
1118                 if (sd->bridge == BRIDGE_SN9C120) {
1119                         reg_w1(gspca_dev, 0x01, 0x61);
1120                         reg_w1(gspca_dev, 0x17, 0x20);
1121                         reg_w1(gspca_dev, 0x01, 0x60);
1122                         reg_w1(gspca_dev, 0x01, 0x40);
1123                         break;
1124                 }
1125                 /* fall thru */
1126         case SENSOR_SP80708:
1127                 reg_w1(gspca_dev, 0x01, 0x63);
1128                 reg_w1(gspca_dev, 0x17, 0x20);
1129                 reg_w1(gspca_dev, 0x01, 0x62);
1130                 reg_w1(gspca_dev, 0x01, 0x42);
1131                 mdelay(100);
1132                 reg_w1(gspca_dev, 0x02, 0x62);
1133                 break;
1134         default:
1135                 reg_w1(gspca_dev, 0x01, 0x43);
1136                 reg_w1(gspca_dev, 0x17, 0x61);
1137                 reg_w1(gspca_dev, 0x01, 0x42);
1138                 if (sd->sensor == SENSOR_HV7131R) {
1139                         if (hv7131r_probe(gspca_dev) < 0)
1140                                 return -ENODEV;
1141                 }
1142                 break;
1143         }
1144         return 0;
1145 }
1146
1147 static void hv7131R_InitSensor(struct gspca_dev *gspca_dev)
1148 {
1149         int i = 0;
1150         static const u8 SetSensorClk[] =        /* 0x08 Mclk */
1151                 { 0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10 };
1152
1153         while (hv7131r_sensor_init[i][0]) {
1154                 i2c_w8(gspca_dev, hv7131r_sensor_init[i]);
1155                 i++;
1156         }
1157         i2c_w8(gspca_dev, SetSensorClk);
1158 }
1159
1160 static void mi0360_InitSensor(struct gspca_dev *gspca_dev)
1161 {
1162         int i = 0;
1163
1164         while (mi0360_sensor_init[i][0]) {
1165                 i2c_w8(gspca_dev, mi0360_sensor_init[i]);
1166                 i++;
1167         }
1168 }
1169
1170 static void mo4000_InitSensor(struct gspca_dev *gspca_dev)
1171 {
1172         int i = 0;
1173
1174         while (mo4000_sensor_init[i][0]) {
1175                 i2c_w8(gspca_dev, mo4000_sensor_init[i]);
1176                 i++;
1177         }
1178 }
1179
1180 static void mt9v111_InitSensor(struct gspca_dev *gspca_dev)
1181 {
1182         int i = 0;
1183
1184         i2c_w8(gspca_dev, mt9v111_sensor_init[i]);
1185         i++;
1186         msleep(20);
1187         while (mt9v111_sensor_init[i][0]) {
1188                 i2c_w8(gspca_dev, mt9v111_sensor_init[i]);
1189                 i++;
1190         }
1191 }
1192
1193 static void om6802_InitSensor(struct gspca_dev *gspca_dev)
1194 {
1195         int i = 0;
1196
1197         while (om6802_sensor_init[i][0]) {
1198                 i2c_w8(gspca_dev, om6802_sensor_init[i]);
1199                 i++;
1200         }
1201 }
1202
1203 static void ov7630_InitSensor(struct gspca_dev *gspca_dev)
1204 {
1205         int i = 0;
1206
1207         i2c_w8(gspca_dev, ov7630_sensor_init[i]);       /* 76 01 */
1208         i++;
1209         i2c_w8(gspca_dev, ov7630_sensor_init[i]);       /* 12 c8 (RGB+SRST) */
1210         i++;
1211         msleep(20);
1212         i2c_w8(gspca_dev, ov7630_sensor_init[i]);       /* 12 48 */
1213         i++;
1214         i2c_w8(gspca_dev, ov7630_sensor_init[i]);       /* 12 c8 */
1215         i++;
1216         msleep(20);
1217         i2c_w8(gspca_dev, ov7630_sensor_init[i]);       /* 12 48 */
1218         i++;
1219 /*jfm:win i2c_r from 00 to 80*/
1220
1221         while (ov7630_sensor_init[i][0]) {
1222                 i2c_w8(gspca_dev, ov7630_sensor_init[i]);
1223                 i++;
1224         }
1225 }
1226
1227 static void ov7648_InitSensor(struct gspca_dev *gspca_dev)
1228 {
1229         int i = 0;
1230
1231         i2c_w8(gspca_dev, ov7648_sensor_init[i]);
1232         i++;
1233 /* win: dble reset */
1234         i2c_w8(gspca_dev, ov7648_sensor_init[i]);       /* reset */
1235         i++;
1236         msleep(20);
1237 /* win: i2c reg read 00..7f */
1238         while (ov7648_sensor_init[i][0]) {
1239                 i2c_w8(gspca_dev, ov7648_sensor_init[i]);
1240                 i++;
1241         }
1242 }
1243
1244 static void ov7660_InitSensor(struct gspca_dev *gspca_dev)
1245 {
1246         int i = 0;
1247
1248         i2c_w8(gspca_dev, ov7660_sensor_init[i]);       /* reset SCCB */
1249         i++;
1250         msleep(20);
1251         while (ov7660_sensor_init[i][0]) {
1252                 i2c_w8(gspca_dev, ov7660_sensor_init[i]);
1253                 i++;
1254         }
1255 }
1256
1257 static void sp80708_InitSensor(struct gspca_dev *gspca_dev)
1258 {
1259         int i = 0;
1260
1261         i2c_w8(gspca_dev, sp80708_sensor_init[i]);      /* reset SCCB */
1262         i++;
1263         msleep(20);
1264         while (sp80708_sensor_init[i][0]) {
1265                 i2c_w8(gspca_dev, sp80708_sensor_init[i]);
1266                 i++;
1267         }
1268 }
1269
1270 /* this function is called at probe time */
1271 static int sd_config(struct gspca_dev *gspca_dev,
1272                         const struct usb_device_id *id)
1273 {
1274         struct sd *sd = (struct sd *) gspca_dev;
1275         struct cam *cam;
1276
1277         cam = &gspca_dev->cam;
1278         cam->cam_mode = vga_mode;
1279         cam->nmodes = ARRAY_SIZE(vga_mode);
1280
1281         sd->bridge = id->driver_info >> 16;
1282         sd->sensor = id->driver_info >> 8;
1283         sd->i2c_base = id->driver_info;
1284
1285         sd->brightness = BRIGHTNESS_DEF;
1286         sd->contrast = CONTRAST_DEF;
1287         sd->colors = COLOR_DEF;
1288         sd->blue = BLUE_BALANCE_DEF;
1289         sd->red = RED_BALANCE_DEF;
1290         sd->gamma = GAMMA_DEF;
1291         sd->autogain = AUTOGAIN_DEF;
1292         sd->ag_cnt = -1;
1293         if (sd->sensor != SENSOR_OV7630)
1294                 sd->vflip = 0;
1295         else
1296                 sd->vflip = 1;
1297         sd->infrared = INFRARED_DEF;
1298         sd->quality = 80;
1299         sd->jpegqual = 80;
1300
1301         gspca_dev->ctrl_dis = ctrl_dis[sd->sensor];
1302         return 0;
1303 }
1304
1305 /* this function is called at probe and resume time */
1306 static int sd_init(struct gspca_dev *gspca_dev)
1307 {
1308         struct sd *sd = (struct sd *) gspca_dev;
1309         u8 regGpio[] = { 0x29, 0x74 };
1310         u8 regF1;
1311
1312         /* setup a selector by bridge */
1313         reg_w1(gspca_dev, 0xf1, 0x01);
1314         reg_r(gspca_dev, 0x00, 1);
1315         reg_w1(gspca_dev, 0xf1, gspca_dev->usb_buf[0]);
1316         reg_r(gspca_dev, 0x00, 1);              /* get sonix chip id */
1317         regF1 = gspca_dev->usb_buf[0];
1318         PDEBUG(D_PROBE, "Sonix chip id: %02x", regF1);
1319         switch (sd->bridge) {
1320         case BRIDGE_SN9C102P:
1321                 if (regF1 != 0x11)
1322                         return -ENODEV;
1323                 reg_w1(gspca_dev, 0x02, regGpio[1]);
1324                 break;
1325         case BRIDGE_SN9C105:
1326                 if (regF1 != 0x11)
1327                         return -ENODEV;
1328                 if (sd->sensor == SENSOR_MI0360)
1329                         mi0360_probe(gspca_dev);
1330                 reg_w(gspca_dev, 0x01, regGpio, 2);
1331                 break;
1332         case BRIDGE_SN9C120:
1333                 if (regF1 != 0x12)
1334                         return -ENODEV;
1335                 if (sd->sensor == SENSOR_MI0360)
1336                         mi0360_probe(gspca_dev);
1337                 regGpio[1] = 0x70;
1338                 reg_w(gspca_dev, 0x01, regGpio, 2);
1339                 break;
1340         default:
1341 /*      case BRIDGE_SN9C110: */
1342 /*      case BRIDGE_SN9C325: */
1343                 if (regF1 != 0x12)
1344                         return -ENODEV;
1345                 reg_w1(gspca_dev, 0x02, 0x62);
1346                 break;
1347         }
1348
1349         reg_w1(gspca_dev, 0xf1, 0x01);
1350
1351         return 0;
1352 }
1353
1354 static u32 setexposure(struct gspca_dev *gspca_dev,
1355                         u32 expo)
1356 {
1357         struct sd *sd = (struct sd *) gspca_dev;
1358
1359         switch (sd->sensor) {
1360         case SENSOR_HV7131R: {
1361                 u8 Expodoit[] =
1362                         { 0xc1, 0x11, 0x25, 0x07, 0x27, 0xc0, 0x00, 0x16 };
1363
1364                 Expodoit[3] = expo >> 16;
1365                 Expodoit[4] = expo >> 8;
1366                 Expodoit[5] = expo;
1367                 i2c_w8(gspca_dev, Expodoit);
1368                 break;
1369             }
1370         case SENSOR_MI0360: {
1371                 u8 expoMi[] =           /* exposure 0x0635 -> 4 fp/s 0x10 */
1372                         { 0xb1, 0x5d, 0x09, 0x06, 0x35, 0x00, 0x00, 0x16 };
1373                 static const u8 doit[] =                /* update sensor */
1374                         { 0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };
1375                 static const u8 sensorgo[] =            /* sensor on */
1376                         { 0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };
1377
1378                 if (expo > 0x0635)
1379                         expo = 0x0635;
1380                 else if (expo < 0x0001)
1381                         expo = 0x0001;
1382                 expoMi[3] = expo >> 8;
1383                 expoMi[4] = expo;
1384                 i2c_w8(gspca_dev, expoMi);
1385                 i2c_w8(gspca_dev, doit);
1386                 i2c_w8(gspca_dev, sensorgo);
1387                 break;
1388             }
1389         case SENSOR_MO4000: {
1390                 u8 expoMof[] =
1391                         { 0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10 };
1392                 u8 expoMo10[] =
1393                         { 0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10 };
1394                 static const u8 gainMo[] =
1395                         { 0xa1, 0x21, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1d };
1396
1397                 if (expo > 0x1fff)
1398                         expo = 0x1fff;
1399                 else if (expo < 0x0001)
1400                         expo = 0x0001;
1401                 expoMof[3] = (expo & 0x03fc) >> 2;
1402                 i2c_w8(gspca_dev, expoMof);
1403                 expoMo10[3] = ((expo & 0x1c00) >> 10)
1404                                 | ((expo & 0x0003) << 4);
1405                 i2c_w8(gspca_dev, expoMo10);
1406                 i2c_w8(gspca_dev, gainMo);
1407                 PDEBUG(D_FRAM, "set exposure %d",
1408                         ((expoMo10[3] & 0x07) << 10)
1409                         | (expoMof[3] << 2)
1410                         | ((expoMo10[3] & 0x30) >> 4));
1411                 break;
1412             }
1413         case SENSOR_MT9V111: {
1414                 u8 expo_c1[] =
1415                         { 0xb1, 0x5c, 0x09, 0x00, 0x00, 0x00, 0x00, 0x10 };
1416
1417                 if (expo > 0x0280)
1418                         expo = 0x0280;
1419                 else if (expo < 0x0040)
1420                         expo = 0x0040;
1421                 expo_c1[3] = expo >> 8;
1422                 expo_c1[4] = expo;
1423                 i2c_w8(gspca_dev, expo_c1);
1424                 break;
1425             }
1426         case SENSOR_OM6802: {
1427                 u8 gainOm[] =
1428                         { 0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10 };
1429
1430                 if (expo > 0x03ff)
1431                         expo = 0x03ff;
1432                  if (expo < 0x0001)
1433                         expo = 0x0001;
1434                 gainOm[3] = expo >> 2;
1435                 i2c_w8(gspca_dev, gainOm);
1436                 reg_w1(gspca_dev, 0x96, (expo >> 5) & 0x1f);
1437                 PDEBUG(D_FRAM, "set exposure %d", gainOm[3]);
1438                 break;
1439             }
1440         }
1441         return expo;
1442 }
1443
1444 static void setbrightness(struct gspca_dev *gspca_dev)
1445 {
1446         struct sd *sd = (struct sd *) gspca_dev;
1447         unsigned int expo;
1448         u8 k2;
1449
1450         k2 = ((int) sd->brightness - 0x8000) >> 10;
1451         switch (sd->sensor) {
1452         case SENSOR_HV7131R:
1453                 expo = sd->brightness << 4;
1454                 if (expo > 0x002dc6c0)
1455                         expo = 0x002dc6c0;
1456                 else if (expo < 0x02a0)
1457                         expo = 0x02a0;
1458                 sd->exposure = setexposure(gspca_dev, expo);
1459                 break;
1460         case SENSOR_MI0360:
1461         case SENSOR_MO4000:
1462                 expo = sd->brightness >> 4;
1463                 sd->exposure = setexposure(gspca_dev, expo);
1464                 break;
1465         case SENSOR_MT9V111:
1466                 expo = sd->brightness >> 8;
1467                 sd->exposure = setexposure(gspca_dev, expo);
1468                 break;
1469         case SENSOR_OM6802:
1470                 expo = sd->brightness >> 6;
1471                 sd->exposure = setexposure(gspca_dev, expo);
1472                 k2 = sd->brightness >> 11;
1473                 break;
1474         }
1475
1476         if (sd->sensor != SENSOR_MT9V111)
1477                 reg_w1(gspca_dev, 0x96, k2);    /* color matrix Y offset */
1478 }
1479
1480 static void setcontrast(struct gspca_dev *gspca_dev)
1481 {
1482         struct sd *sd = (struct sd *) gspca_dev;
1483         u8 k2;
1484         u8 contrast[6];
1485
1486         k2 = sd->contrast * 0x30 / (CONTRAST_MAX + 1) + 0x10;   /* 10..40 */
1487         contrast[0] = (k2 + 1) / 2;             /* red */
1488         contrast[1] = 0;
1489         contrast[2] = k2;                       /* green */
1490         contrast[3] = 0;
1491         contrast[4] = (k2 + 1) / 5;             /* blue */
1492         contrast[5] = 0;
1493         reg_w(gspca_dev, 0x84, contrast, sizeof contrast);
1494 }
1495
1496 static void setcolors(struct gspca_dev *gspca_dev)
1497 {
1498         struct sd *sd = (struct sd *) gspca_dev;
1499         int i, v;
1500         u8 reg8a[12];                   /* U & V gains */
1501         static s16 uv[6] = {            /* same as reg84 in signed decimal */
1502                 -24, -38, 64,           /* UR UG UB */
1503                  62, -51, -9            /* VR VG VB */
1504         };
1505         for (i = 0; i < 6; i++) {
1506                 v = uv[i] * sd->colors / COLOR_DEF;
1507                 reg8a[i * 2] = v;
1508                 reg8a[i * 2 + 1] = (v >> 8) & 0x0f;
1509         }
1510         reg_w(gspca_dev, 0x8a, reg8a, sizeof reg8a);
1511 }
1512
1513 static void setredblue(struct gspca_dev *gspca_dev)
1514 {
1515         struct sd *sd = (struct sd *) gspca_dev;
1516
1517         reg_w1(gspca_dev, 0x05, sd->red);
1518 /*      reg_w1(gspca_dev, 0x07, 32); */
1519         reg_w1(gspca_dev, 0x06, sd->blue);
1520 }
1521
1522 static void setgamma(struct gspca_dev *gspca_dev)
1523 {
1524         struct sd *sd = (struct sd *) gspca_dev;
1525         int i;
1526         u8 gamma[17];
1527         const u8 *gamma_base;
1528         static const u8 delta[17] = {
1529                 0x00, 0x14, 0x1c, 0x1c, 0x1c, 0x1c, 0x1b, 0x1a,
1530                 0x18, 0x13, 0x10, 0x0e, 0x08, 0x07, 0x04, 0x02, 0x00
1531         };
1532
1533         switch (sd->sensor) {
1534         case SENSOR_HV7131R:
1535         case SENSOR_MT9V111:
1536                 gamma_base = gamma_spec_1;
1537                 break;
1538         case SENSOR_SP80708:
1539                 gamma_base = gamma_spec_2;
1540                 break;
1541         default:
1542                 gamma_base = gamma_def;
1543                 break;
1544         }
1545
1546         for (i = 0; i < sizeof gamma; i++)
1547                 gamma[i] = gamma_base[i]
1548                         + delta[i] * (sd->gamma - GAMMA_DEF) / 32;
1549         reg_w(gspca_dev, 0x20, gamma, sizeof gamma);
1550 }
1551
1552 static void setautogain(struct gspca_dev *gspca_dev)
1553 {
1554         struct sd *sd = (struct sd *) gspca_dev;
1555
1556         if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
1557                 return;
1558         switch (sd->sensor) {
1559         case SENSOR_OV7630:
1560         case SENSOR_OV7648: {
1561                 u8 comb;
1562
1563                 if (sd->sensor == SENSOR_OV7630)
1564                         comb = 0xc0;
1565                 else
1566                         comb = 0xa0;
1567                 if (sd->autogain)
1568                         comb |= 0x02;
1569                 i2c_w1(&sd->gspca_dev, 0x13, comb);
1570                 return;
1571             }
1572         }
1573         if (sd->autogain)
1574                 sd->ag_cnt = AG_CNT_START;
1575         else
1576                 sd->ag_cnt = -1;
1577 }
1578
1579 /* ov7630/ov7648 only */
1580 static void setvflip(struct sd *sd)
1581 {
1582         u8 comn;
1583
1584         if (sd->sensor == SENSOR_OV7630)
1585                 comn = 0x02;
1586         else
1587                 comn = 0x06;
1588         if (sd->vflip)
1589                 comn |= 0x80;
1590         i2c_w1(&sd->gspca_dev, 0x75, comn);
1591 }
1592
1593 static void setinfrared(struct sd *sd)
1594 {
1595 /*fixme: different sequence for StarCam Clip and StarCam 370i */
1596 /* Clip */
1597         i2c_w1(&sd->gspca_dev, 0x02,                    /* gpio */
1598                 sd->infrared ? 0x66 : 0x64);
1599 }
1600
1601 static void setjpegqual(struct gspca_dev *gspca_dev)
1602 {
1603         struct sd *sd = (struct sd *) gspca_dev;
1604         int i, sc;
1605
1606         if (sd->jpegqual < 50)
1607                 sc = 5000 / sd->jpegqual;
1608         else
1609                 sc = 200 - sd->jpegqual * 2;
1610 #if USB_BUF_SZ < 64
1611 #error "No room enough in usb_buf for quantization table"
1612 #endif
1613         for (i = 0; i < 64; i++)
1614                 gspca_dev->usb_buf[i] =
1615                         (jpeg_head[JPEG_QT0_OFFSET + i] * sc + 50) / 100;
1616         usb_control_msg(gspca_dev->dev,
1617                         usb_sndctrlpipe(gspca_dev->dev, 0),
1618                         0x08,
1619                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1620                         0x0100, 0,
1621                         gspca_dev->usb_buf, 64,
1622                         500);
1623         for (i = 0; i < 64; i++)
1624                 gspca_dev->usb_buf[i] =
1625                         (jpeg_head[JPEG_QT1_OFFSET + i] * sc + 50) / 100;
1626         usb_control_msg(gspca_dev->dev,
1627                         usb_sndctrlpipe(gspca_dev->dev, 0),
1628                         0x08,
1629                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1630                         0x0140, 0,
1631                         gspca_dev->usb_buf, 64,
1632                         500);
1633
1634         sd->reg18 ^= 0x40;
1635         reg_w1(gspca_dev, 0x18, sd->reg18);
1636 }
1637
1638 /* -- start the camera -- */
1639 static int sd_start(struct gspca_dev *gspca_dev)
1640 {
1641         struct sd *sd = (struct sd *) gspca_dev;
1642         int i;
1643         u8 reg1, reg17;
1644         const u8 *sn9c1xx;
1645         int mode;
1646         static const u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
1647         static const u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
1648         static const u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd };      /* MI0360 */
1649         static const u8 CE_ov76xx[] =
1650                                 { 0x32, 0xdd, 0x32, 0xdd };
1651
1652         /* create the JPEG header */
1653         sd->jpeg_hdr = kmalloc(JPEG_HDR_SZ, GFP_KERNEL);
1654         jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
1655                         0x21);          /* JPEG 422 */
1656         jpeg_set_qual(sd->jpeg_hdr, sd->quality);
1657
1658         sn9c1xx = sn_tb[(int) sd->sensor];
1659         configure_gpio(gspca_dev, sn9c1xx);
1660
1661         reg_w1(gspca_dev, 0x15, sn9c1xx[0x15]);
1662         reg_w1(gspca_dev, 0x16, sn9c1xx[0x16]);
1663         reg_w1(gspca_dev, 0x12, sn9c1xx[0x12]);
1664         reg_w1(gspca_dev, 0x13, sn9c1xx[0x13]);
1665         reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
1666         reg_w1(gspca_dev, 0xd2, 0x6a);          /* DC29 */
1667         reg_w1(gspca_dev, 0xd3, 0x50);
1668         reg_w1(gspca_dev, 0xc6, 0x00);
1669         reg_w1(gspca_dev, 0xc7, 0x00);
1670         reg_w1(gspca_dev, 0xc8, 0x50);
1671         reg_w1(gspca_dev, 0xc9, 0x3c);
1672         reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
1673         switch (sd->sensor) {
1674         case SENSOR_MT9V111:
1675                 reg17 = 0xe0;
1676                 break;
1677         case SENSOR_OV7630:
1678                 reg17 = 0xe2;
1679                 break;
1680         case SENSOR_OV7648:
1681                 reg17 = 0x20;
1682                 break;
1683 /*jfm: from win trace */
1684         case SENSOR_OV7660:
1685                 if (sd->bridge == BRIDGE_SN9C120) {
1686                         reg17 = 0xa0;
1687                         break;
1688                 }
1689                 /* fall thru */
1690         default:
1691                 reg17 = 0x60;
1692                 break;
1693         }
1694         reg_w1(gspca_dev, 0x17, reg17);
1695 /* set reg1 was here */
1696         reg_w1(gspca_dev, 0x05, sn9c1xx[5]);    /* red */
1697         reg_w1(gspca_dev, 0x07, sn9c1xx[7]);    /* green */
1698         reg_w1(gspca_dev, 0x06, sn9c1xx[6]);    /* blue */
1699         reg_w1(gspca_dev, 0x14, sn9c1xx[0x14]);
1700
1701         setgamma(gspca_dev);
1702
1703         for (i = 0; i < 8; i++)
1704                 reg_w(gspca_dev, 0x84, reg84, sizeof reg84);
1705         switch (sd->sensor) {
1706         case SENSOR_MT9V111:
1707                 reg_w1(gspca_dev, 0x9a, 0x07);
1708                 reg_w1(gspca_dev, 0x99, 0x59);
1709                 break;
1710         case SENSOR_OV7648:
1711                 reg_w1(gspca_dev, 0x9a, 0x0a);
1712                 reg_w1(gspca_dev, 0x99, 0x60);
1713                 break;
1714         case SENSOR_SP80708:
1715                 reg_w1(gspca_dev, 0x9a, 0x05);
1716                 reg_w1(gspca_dev, 0x99, 0x59);
1717                 break;
1718         case SENSOR_OV7660:
1719                 if (sd->bridge == BRIDGE_SN9C120) {
1720                         reg_w1(gspca_dev, 0x9a, 0x05);
1721                         break;
1722                 }
1723                 /* fall thru */
1724         default:
1725                 reg_w1(gspca_dev, 0x9a, 0x08);
1726                 reg_w1(gspca_dev, 0x99, 0x59);
1727                 break;
1728         }
1729
1730         mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
1731         if (mode)
1732                 reg1 = 0x46;    /* 320x240: clk 48Mhz, video trf enable */
1733         else
1734                 reg1 = 0x06;    /* 640x480: clk 24Mhz, video trf enable */
1735         reg17 = 0x61;           /* 0x:20: enable sensor clock */
1736         switch (sd->sensor) {
1737         case SENSOR_HV7131R:
1738                 hv7131R_InitSensor(gspca_dev);
1739                 break;
1740         case SENSOR_MI0360:
1741                 mi0360_InitSensor(gspca_dev);
1742                 break;
1743         case SENSOR_MO4000:
1744                 mo4000_InitSensor(gspca_dev);
1745                 if (mode) {
1746 /*                      reg1 = 0x46;     * 320 clk 48Mhz 60fp/s */
1747                         reg1 = 0x06;    /* clk 24Mz */
1748                 } else {
1749                         reg17 = 0x22;   /* 640 MCKSIZE */
1750 /*                      reg1 = 0x06;     * 640 clk 24Mz (done) */
1751                 }
1752                 break;
1753         case SENSOR_MT9V111:
1754                 mt9v111_InitSensor(gspca_dev);
1755                 if (mode) {
1756                         reg1 = 0x04;    /* 320 clk 48Mhz */
1757                 } else {
1758 /*                      reg1 = 0x06;     * 640 clk 24Mz (done) */
1759                         reg17 = 0xc2;
1760                 }
1761                 break;
1762         case SENSOR_OM6802:
1763                 om6802_InitSensor(gspca_dev);
1764                 reg17 = 0x64;           /* 640 MCKSIZE */
1765                 break;
1766         case SENSOR_OV7630:
1767                 ov7630_InitSensor(gspca_dev);
1768                 setvflip(sd);
1769                 reg17 = 0xe2;
1770                 reg1 = 0x44;
1771                 break;
1772         case SENSOR_OV7648:
1773                 ov7648_InitSensor(gspca_dev);
1774                 reg17 = 0x21;
1775 /*              reg1 = 0x42;             * 42 - 46? */
1776                 break;
1777         case SENSOR_OV7660:
1778                 ov7660_InitSensor(gspca_dev);
1779                 if (sd->bridge == BRIDGE_SN9C120) {
1780                         if (mode) {             /* 320x240 - 160x120 */
1781                                 reg17 = 0xa2;
1782                                 reg1 = 0x44;    /* 48 Mhz, video trf eneble */
1783                         }
1784                 } else {
1785                         reg17 = 0x22;
1786                         reg1 = 0x06;    /* 24 Mhz, video trf eneble
1787                                          * inverse power down */
1788                 }
1789                 break;
1790         default:
1791 /*      case SENSOR_SP80708: */
1792                 sp80708_InitSensor(gspca_dev);
1793                 if (mode) {
1794 /*??                    reg1 = 0x04;     * 320 clk 48Mhz */
1795                 } else {
1796                         reg1 = 0x46;     /* 640 clk 48Mz */
1797                         reg17 = 0xa2;
1798                 }
1799                 break;
1800         }
1801         reg_w(gspca_dev, 0xc0, C0, 6);
1802         reg_w(gspca_dev, 0xca, CA, 4);
1803         switch (sd->sensor) {
1804         case SENSOR_OV7630:
1805         case SENSOR_OV7648:
1806         case SENSOR_OV7660:
1807                 reg_w(gspca_dev, 0xce, CE_ov76xx, 4);
1808                 break;
1809         default:
1810                 reg_w(gspca_dev, 0xce, CE, 4);
1811                                         /* ?? {0x1e, 0xdd, 0x2d, 0xe7} */
1812                 break;
1813         }
1814
1815         /* here change size mode 0 -> VGA; 1 -> CIF */
1816         sd->reg18 = sn9c1xx[0x18] | (mode << 4) | 0x40;
1817         reg_w1(gspca_dev, 0x18, sd->reg18);
1818         setjpegqual(gspca_dev);
1819
1820         reg_w1(gspca_dev, 0x17, reg17);
1821         reg_w1(gspca_dev, 0x01, reg1);
1822         switch (sd->sensor) {
1823         case SENSOR_OV7630:
1824                 setvflip(sd);
1825                 break;
1826         }
1827         setbrightness(gspca_dev);
1828         setcontrast(gspca_dev);
1829         setautogain(gspca_dev);
1830         return 0;
1831 }
1832
1833 static void sd_stopN(struct gspca_dev *gspca_dev)
1834 {
1835         struct sd *sd = (struct sd *) gspca_dev;
1836         static const u8 stophv7131[] =
1837                 { 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 };
1838         static const u8 stopmi0360[] =
1839                 { 0xb1, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10 };
1840         static const u8 stopov7648[] =
1841                 { 0xa1, 0x21, 0x76, 0x20, 0x00, 0x00, 0x00, 0x10 };
1842         u8 data;
1843         const u8 *sn9c1xx;
1844
1845         data = 0x0b;
1846         switch (sd->sensor) {
1847         case SENSOR_HV7131R:
1848                 i2c_w8(gspca_dev, stophv7131);
1849                 data = 0x2b;
1850                 break;
1851         case SENSOR_MI0360:
1852                 i2c_w8(gspca_dev, stopmi0360);
1853                 data = 0x29;
1854                 break;
1855         case SENSOR_OV7648:
1856                 i2c_w8(gspca_dev, stopov7648);
1857                 /* fall thru */
1858         case SENSOR_MT9V111:
1859         case SENSOR_OV7630:
1860                 data = 0x29;
1861                 break;
1862         default:
1863 /*      case SENSOR_MO4000: */
1864 /*      case SENSOR_OV7660: */
1865                 break;
1866         }
1867         sn9c1xx = sn_tb[(int) sd->sensor];
1868         reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
1869         reg_w1(gspca_dev, 0x17, sn9c1xx[0x17]);
1870         reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
1871         reg_w1(gspca_dev, 0x01, data);
1872         reg_w1(gspca_dev, 0xf1, 0x00);
1873 }
1874
1875 static void sd_stop0(struct gspca_dev *gspca_dev)
1876 {
1877         struct sd *sd = (struct sd *) gspca_dev;
1878
1879         kfree(sd->jpeg_hdr);
1880 }
1881
1882 static void do_autogain(struct gspca_dev *gspca_dev)
1883 {
1884         struct sd *sd = (struct sd *) gspca_dev;
1885         int delta;
1886         int expotimes;
1887         u8 luma_mean = 130;
1888         u8 luma_delta = 20;
1889
1890         /* Thanks S., without your advice, autobright should not work :) */
1891         if (sd->ag_cnt < 0)
1892                 return;
1893         if (--sd->ag_cnt >= 0)
1894                 return;
1895         sd->ag_cnt = AG_CNT_START;
1896
1897         delta = atomic_read(&sd->avg_lum);
1898         PDEBUG(D_FRAM, "mean lum %d", delta);
1899         if (delta < luma_mean - luma_delta ||
1900             delta > luma_mean + luma_delta) {
1901                 switch (sd->sensor) {
1902                 case SENSOR_HV7131R:
1903                         expotimes = sd->exposure >> 8;
1904                         expotimes += (luma_mean - delta) >> 4;
1905                         if (expotimes < 0)
1906                                 expotimes = 0;
1907                         sd->exposure = setexposure(gspca_dev,
1908                                         (unsigned int) (expotimes << 8));
1909                         break;
1910                 default:
1911 /*              case SENSOR_MO4000: */
1912 /*              case SENSOR_MI0360: */
1913 /*              case SENSOR_MT9V111: */
1914 /*              case SENSOR_OM6802: */
1915                         expotimes = sd->exposure;
1916                         expotimes += (luma_mean - delta) >> 6;
1917                         if (expotimes < 0)
1918                                 expotimes = 0;
1919                         sd->exposure = setexposure(gspca_dev,
1920                                                    (unsigned int) expotimes);
1921                         setredblue(gspca_dev);
1922                         break;
1923                 }
1924         }
1925 }
1926
1927 /* scan the URB packets */
1928 /* This function is run at interrupt level. */
1929 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1930                         struct gspca_frame *frame,      /* target */
1931                         u8 *data,                       /* isoc packet */
1932                         int len)                        /* iso packet length */
1933 {
1934         struct sd *sd = (struct sd *) gspca_dev;
1935         int sof, avg_lum;
1936
1937         sof = len - 64;
1938         if (sof >= 0 && data[sof] == 0xff && data[sof + 1] == 0xd9) {
1939
1940                 /* end of frame */
1941                 gspca_frame_add(gspca_dev, LAST_PACKET,
1942                                 frame, data, sof + 2);
1943                 if (sd->ag_cnt < 0)
1944                         return;
1945 /* w1 w2 w3 */
1946 /* w4 w5 w6 */
1947 /* w7 w8 */
1948 /* w4 */
1949                 avg_lum = ((data[sof + 29] << 8) | data[sof + 30]) >> 6;
1950 /* w6 */
1951                 avg_lum += ((data[sof + 33] << 8) | data[sof + 34]) >> 6;
1952 /* w2 */
1953                 avg_lum += ((data[sof + 25] << 8) | data[sof + 26]) >> 6;
1954 /* w8 */
1955                 avg_lum += ((data[sof + 37] << 8) | data[sof + 38]) >> 6;
1956 /* w5 */
1957                 avg_lum += ((data[sof + 31] << 8) | data[sof + 32]) >> 4;
1958                 avg_lum >>= 4;
1959                 atomic_set(&sd->avg_lum, avg_lum);
1960                 return;
1961         }
1962         if (gspca_dev->last_packet_type == LAST_PACKET) {
1963
1964                 /* put the JPEG 422 header */
1965                 gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
1966                         sd->jpeg_hdr, JPEG_HDR_SZ);
1967         }
1968         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
1969 }
1970
1971 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1972 {
1973         struct sd *sd = (struct sd *) gspca_dev;
1974
1975         sd->brightness = val;
1976         if (gspca_dev->streaming)
1977                 setbrightness(gspca_dev);
1978         return 0;
1979 }
1980
1981 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1982 {
1983         struct sd *sd = (struct sd *) gspca_dev;
1984
1985         *val = sd->brightness;
1986         return 0;
1987 }
1988
1989 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1990 {
1991         struct sd *sd = (struct sd *) gspca_dev;
1992
1993         sd->contrast = val;
1994         if (gspca_dev->streaming)
1995                 setcontrast(gspca_dev);
1996         return 0;
1997 }
1998
1999 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
2000 {
2001         struct sd *sd = (struct sd *) gspca_dev;
2002
2003         *val = sd->contrast;
2004         return 0;
2005 }
2006
2007 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
2008 {
2009         struct sd *sd = (struct sd *) gspca_dev;
2010
2011         sd->colors = val;
2012         if (gspca_dev->streaming)
2013                 setcolors(gspca_dev);
2014         return 0;
2015 }
2016
2017 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
2018 {
2019         struct sd *sd = (struct sd *) gspca_dev;
2020
2021         *val = sd->colors;
2022         return 0;
2023 }
2024
2025 static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val)
2026 {
2027         struct sd *sd = (struct sd *) gspca_dev;
2028
2029         sd->blue = val;
2030         if (gspca_dev->streaming)
2031                 setredblue(gspca_dev);
2032         return 0;
2033 }
2034
2035 static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val)
2036 {
2037         struct sd *sd = (struct sd *) gspca_dev;
2038
2039         *val = sd->blue;
2040         return 0;
2041 }
2042
2043 static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val)
2044 {
2045         struct sd *sd = (struct sd *) gspca_dev;
2046
2047         sd->red = val;
2048         if (gspca_dev->streaming)
2049                 setredblue(gspca_dev);
2050         return 0;
2051 }
2052
2053 static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val)
2054 {
2055         struct sd *sd = (struct sd *) gspca_dev;
2056
2057         *val = sd->red;
2058         return 0;
2059 }
2060
2061 static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
2062 {
2063         struct sd *sd = (struct sd *) gspca_dev;
2064
2065         sd->gamma = val;
2066         if (gspca_dev->streaming)
2067                 setgamma(gspca_dev);
2068         return 0;
2069 }
2070
2071 static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
2072 {
2073         struct sd *sd = (struct sd *) gspca_dev;
2074
2075         *val = sd->gamma;
2076         return 0;
2077 }
2078
2079 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
2080 {
2081         struct sd *sd = (struct sd *) gspca_dev;
2082
2083         sd->autogain = val;
2084         if (gspca_dev->streaming)
2085                 setautogain(gspca_dev);
2086         return 0;
2087 }
2088
2089 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
2090 {
2091         struct sd *sd = (struct sd *) gspca_dev;
2092
2093         *val = sd->autogain;
2094         return 0;
2095 }
2096
2097 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
2098 {
2099         struct sd *sd = (struct sd *) gspca_dev;
2100
2101         sd->vflip = val;
2102         if (gspca_dev->streaming)
2103                 setvflip(sd);
2104         return 0;
2105 }
2106
2107 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
2108 {
2109         struct sd *sd = (struct sd *) gspca_dev;
2110
2111         *val = sd->vflip;
2112         return 0;
2113 }
2114
2115 static int sd_setinfrared(struct gspca_dev *gspca_dev, __s32 val)
2116 {
2117         struct sd *sd = (struct sd *) gspca_dev;
2118
2119         sd->infrared = val;
2120         if (gspca_dev->streaming)
2121                 setinfrared(sd);
2122         return 0;
2123 }
2124
2125 static int sd_getinfrared(struct gspca_dev *gspca_dev, __s32 *val)
2126 {
2127         struct sd *sd = (struct sd *) gspca_dev;
2128
2129         *val = sd->infrared;
2130         return 0;
2131 }
2132
2133 /* sub-driver description */
2134 static const struct sd_desc sd_desc = {
2135         .name = MODULE_NAME,
2136         .ctrls = sd_ctrls,
2137         .nctrls = ARRAY_SIZE(sd_ctrls),
2138         .config = sd_config,
2139         .init = sd_init,
2140         .start = sd_start,
2141         .stopN = sd_stopN,
2142         .stop0 = sd_stop0,
2143         .pkt_scan = sd_pkt_scan,
2144         .dq_callback = do_autogain,
2145 };
2146
2147 /* -- module initialisation -- */
2148 #define BSI(bridge, sensor, i2c_addr) \
2149         .driver_info = (BRIDGE_ ## bridge << 16) \
2150                         | (SENSOR_ ## sensor << 8) \
2151                         | (i2c_addr)
2152 static const __devinitdata struct usb_device_id device_table[] = {
2153 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
2154         {USB_DEVICE(0x0458, 0x7025), BSI(SN9C120, MI0360, 0x5d)},
2155         {USB_DEVICE(0x0458, 0x702e), BSI(SN9C120, OV7660, 0x21)},
2156 #endif
2157         {USB_DEVICE(0x045e, 0x00f5), BSI(SN9C105, OV7660, 0x21)},
2158         {USB_DEVICE(0x045e, 0x00f7), BSI(SN9C105, OV7660, 0x21)},
2159 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
2160         {USB_DEVICE(0x0471, 0x0327), BSI(SN9C105, MI0360, 0x5d)},
2161 #endif
2162         {USB_DEVICE(0x0471, 0x0328), BSI(SN9C105, MI0360, 0x5d)},
2163         {USB_DEVICE(0x0471, 0x0330), BSI(SN9C105, MI0360, 0x5d)},
2164         {USB_DEVICE(0x06f8, 0x3004), BSI(SN9C105, OV7660, 0x21)},
2165         {USB_DEVICE(0x0c45, 0x6040), BSI(SN9C102P, HV7131R, 0x11)},
2166 /* bw600.inf:
2167         {USB_DEVICE(0x0c45, 0x6040), BSI(SN9C102P, MI0360, 0x5d)}, */
2168 /*      {USB_DEVICE(0x0c45, 0x603a), BSI(SN9C102P, OV7648, 0x??)}, */
2169 /*      {USB_DEVICE(0x0c45, 0x607a), BSI(SN9C102P, OV7648, 0x??)}, */
2170         {USB_DEVICE(0x0c45, 0x607c), BSI(SN9C102P, HV7131R, 0x11)},
2171 /*      {USB_DEVICE(0x0c45, 0x607e), BSI(SN9C102P, OV7630, 0x??)}, */
2172         {USB_DEVICE(0x0c45, 0x60c0), BSI(SN9C105, MI0360, 0x5d)},
2173 /*      {USB_DEVICE(0x0c45, 0x60c8), BSI(SN9C105, OM6801, 0x??)}, */
2174 /*      {USB_DEVICE(0x0c45, 0x60cc), BSI(SN9C105, HV7131GP, 0x??)}, */
2175         {USB_DEVICE(0x0c45, 0x60ec), BSI(SN9C105, MO4000, 0x21)},
2176 /*      {USB_DEVICE(0x0c45, 0x60ef), BSI(SN9C105, ICM105C, 0x??)}, */
2177 /*      {USB_DEVICE(0x0c45, 0x60fa), BSI(SN9C105, OV7648, 0x??)}, */
2178         {USB_DEVICE(0x0c45, 0x60fb), BSI(SN9C105, OV7660, 0x21)},
2179         {USB_DEVICE(0x0c45, 0x60fc), BSI(SN9C105, HV7131R, 0x11)},
2180 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
2181         {USB_DEVICE(0x0c45, 0x60fe), BSI(SN9C105, OV7630, 0x21)},
2182 #endif
2183 /*      {USB_DEVICE(0x0c45, 0x6108), BSI(SN9C120, OM6801, 0x??)}, */
2184 /*      {USB_DEVICE(0x0c45, 0x6122), BSI(SN9C110, ICM105C, 0x??)}, */
2185 /*      {USB_DEVICE(0x0c45, 0x6123), BSI(SN9C110, SanyoCCD, 0x??)}, */
2186         {USB_DEVICE(0x0c45, 0x6128), BSI(SN9C110, OM6802, 0x21)}, /*sn9c325?*/
2187 /*bw600.inf:*/
2188         {USB_DEVICE(0x0c45, 0x612a), BSI(SN9C120, OV7648, 0x21)}, /*sn9c110?*/
2189         {USB_DEVICE(0x0c45, 0x612c), BSI(SN9C110, MO4000, 0x21)},
2190         {USB_DEVICE(0x0c45, 0x612e), BSI(SN9C110, OV7630, 0x21)},
2191 /*      {USB_DEVICE(0x0c45, 0x612f), BSI(SN9C110, ICM105C, 0x??)}, */
2192 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
2193         {USB_DEVICE(0x0c45, 0x6130), BSI(SN9C120, MI0360, 0x5d)},
2194 #endif
2195         {USB_DEVICE(0x0c45, 0x6138), BSI(SN9C120, MO4000, 0x21)},
2196         {USB_DEVICE(0x0c45, 0x613a), BSI(SN9C120, OV7648, 0x21)},
2197 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
2198         {USB_DEVICE(0x0c45, 0x613b), BSI(SN9C120, OV7660, 0x21)},
2199 #endif
2200         {USB_DEVICE(0x0c45, 0x613c), BSI(SN9C120, HV7131R, 0x11)},
2201 /*      {USB_DEVICE(0x0c45, 0x613e), BSI(SN9C120, OV7630, 0x??)}, */
2202         {USB_DEVICE(0x0c45, 0x6143), BSI(SN9C120, SP80708, 0x18)},
2203         {}
2204 };
2205 MODULE_DEVICE_TABLE(usb, device_table);
2206
2207 /* -- device connect -- */
2208 static int sd_probe(struct usb_interface *intf,
2209                     const struct usb_device_id *id)
2210 {
2211         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
2212                                 THIS_MODULE);
2213 }
2214
2215 static struct usb_driver sd_driver = {
2216         .name = MODULE_NAME,
2217         .id_table = device_table,
2218         .probe = sd_probe,
2219         .disconnect = gspca_disconnect,
2220 #ifdef CONFIG_PM
2221         .suspend = gspca_suspend,
2222         .resume = gspca_resume,
2223 #endif
2224 };
2225
2226 /* -- module insert / remove -- */
2227 static int __init sd_mod_init(void)
2228 {
2229         int ret;
2230         ret = usb_register(&sd_driver);
2231         if (ret < 0)
2232                 return ret;
2233         info("registered");
2234         return 0;
2235 }
2236 static void __exit sd_mod_exit(void)
2237 {
2238         usb_deregister(&sd_driver);
2239         info("deregistered");
2240 }
2241
2242 module_init(sd_mod_init);
2243 module_exit(sd_mod_exit);