drivers/media/video/gspca/sn9c20x.c

   1 /*
   2  *      Sonix sn9c201 sn9c202 library
   3  *      Copyright (C) 2008-2009 microdia project <microdia@googlegroups.com>
   4  *      Copyright (C) 2009 Brian Johnson <brijohn@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19  */
  20
  21 #include <linux/input.h>
  22
  23 #include "gspca.h"
  24 #include "jpeg.h"
  25
  26 #include <media/v4l2-chip-ident.h>
  27 #include <linux/dmi.h>
  28
  29 MODULE_AUTHOR("Brian Johnson <brijohn@gmail.com>, "
  30                 "microdia project <microdia@googlegroups.com>");
  31 MODULE_DESCRIPTION("GSPCA/SN9C20X USB Camera Driver");
  32 MODULE_LICENSE("GPL");
  33
  34 #define MODULE_NAME "sn9c20x"
  35
  36 /*
  37  * Pixel format private data
  38  */
  39 #define SCALE_MASK      0x0f
  40 #define SCALE_160x120   0
  41 #define SCALE_320x240   1
  42 #define SCALE_640x480   2
  43 #define SCALE_1280x1024 3
  44 #define MODE_RAW        0x10
  45 #define MODE_JPEG       0x20
  46 #define MODE_SXGA       0x80
  47
  48 #define SENSOR_OV9650   0
  49 #define SENSOR_OV9655   1
  50 #define SENSOR_SOI968   2
  51 #define SENSOR_OV7660   3
  52 #define SENSOR_OV7670   4
  53 #define SENSOR_MT9V011  5
  54 #define SENSOR_MT9V111  6
  55 #define SENSOR_MT9V112  7
  56 #define SENSOR_MT9M001  8
  57 #define SENSOR_MT9M111  9
  58 #define SENSOR_MT9M112  10
  59 #define SENSOR_HV7131R  11
  60 #define SENSOR_MT9VPRB  20
  61
  62 /* camera flags */
  63 #define HAS_NO_BUTTON   0x1
  64 #define LED_REVERSE     0x2 /* some cameras unset gpio to turn on leds */
  65 #define FLIP_DETECT     0x4
  66
  67 /* specific webcam descriptor */
  68 struct sd {
  69         struct gspca_dev gspca_dev;
  70
  71 #define MIN_AVG_LUM 80
  72 #define MAX_AVG_LUM 130
  73         atomic_t avg_lum;
  74         u8 old_step;
  75         u8 older_step;
  76         u8 exposure_step;
  77
  78         u8 brightness;
  79         u8 contrast;
  80         u8 saturation;
  81         s16 hue;
  82         u8 gamma;
  83         u8 red;
  84         u8 blue;
  85
  86         u8 hflip;
  87         u8 vflip;
  88         u8 gain;
  89         u16 exposure;
  90         u8 auto_exposure;
  91
  92         u8 i2c_addr;
  93         u8 sensor;
  94         u8 hstart;
  95         u8 vstart;
  96
  97         u8 jpeg_hdr[JPEG_HDR_SZ];
  98         u8 quality;
  99
 100         u8 flags;
 101 };
 102
 103 struct i2c_reg_u8 {
 104         u8 reg;
 105         u8 val;
 106 };
 107
 108 struct i2c_reg_u16 {
 109         u8 reg;
 110         u16 val;
 111 };
 112
 113 static int sd_setbrightness(struct gspca_dev *gspca_dev, s32 val);
 114 static int sd_getbrightness(struct gspca_dev *gspca_dev, s32 *val);
 115 static int sd_setcontrast(struct gspca_dev *gspca_dev, s32 val);
 116 static int sd_getcontrast(struct gspca_dev *gspca_dev, s32 *val);
 117 static int sd_setsaturation(struct gspca_dev *gspca_dev, s32 val);
 118 static int sd_getsaturation(struct gspca_dev *gspca_dev, s32 *val);
 119 static int sd_sethue(struct gspca_dev *gspca_dev, s32 val);
 120 static int sd_gethue(struct gspca_dev *gspca_dev, s32 *val);
 121 static int sd_setgamma(struct gspca_dev *gspca_dev, s32 val);
 122 static int sd_getgamma(struct gspca_dev *gspca_dev, s32 *val);
 123 static int sd_setredbalance(struct gspca_dev *gspca_dev, s32 val);
 124 static int sd_getredbalance(struct gspca_dev *gspca_dev, s32 *val);
 125 static int sd_setbluebalance(struct gspca_dev *gspca_dev, s32 val);
 126 static int sd_getbluebalance(struct gspca_dev *gspca_dev, s32 *val);
 127 static int sd_setvflip(struct gspca_dev *gspca_dev, s32 val);
 128 static int sd_getvflip(struct gspca_dev *gspca_dev, s32 *val);
 129 static int sd_sethflip(struct gspca_dev *gspca_dev, s32 val);
 130 static int sd_gethflip(struct gspca_dev *gspca_dev, s32 *val);
 131 static int sd_setgain(struct gspca_dev *gspca_dev, s32 val);
 132 static int sd_getgain(struct gspca_dev *gspca_dev, s32 *val);
 133 static int sd_setexposure(struct gspca_dev *gspca_dev, s32 val);
 134 static int sd_getexposure(struct gspca_dev *gspca_dev, s32 *val);
 135 static int sd_setautoexposure(struct gspca_dev *gspca_dev, s32 val);
 136 static int sd_getautoexposure(struct gspca_dev *gspca_dev, s32 *val);
 137
 138 static const struct dmi_system_id flip_dmi_table[] = {
 139         {
 140                 .ident = "MSI MS-1034",
 141                 .matches = {
 142                         DMI_MATCH(DMI_SYS_VENDOR, "MICRO-STAR INT'L CO.,LTD."),
 143                         DMI_MATCH(DMI_PRODUCT_NAME, "MS-1034"),
 144                         DMI_MATCH(DMI_PRODUCT_VERSION, "0341")
 145                 }
 146         },
 147         {
 148                 .ident = "MSI MS-1632",
 149                 .matches = {
 150                         DMI_MATCH(DMI_BOARD_VENDOR, "MSI"),
 151                         DMI_MATCH(DMI_BOARD_NAME, "MS-1632")
 152                 }
 153         },
 154         {
 155                 .ident = "MSI MS-1633X",
 156                 .matches = {
 157                         DMI_MATCH(DMI_BOARD_VENDOR, "MSI"),
 158                         DMI_MATCH(DMI_BOARD_NAME, "MS-1633X")
 159                 }
 160         },
 161         {
 162                 .ident = "MSI MS-1635X",
 163                 .matches = {
 164                         DMI_MATCH(DMI_BOARD_VENDOR, "MSI"),
 165                         DMI_MATCH(DMI_BOARD_NAME, "MS-1635X")
 166                 }
 167         },
 168         {
 169                 .ident = "ASUSTeK W7J",
 170                 .matches = {
 171                         DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."),
 172                         DMI_MATCH(DMI_BOARD_NAME, "W7J       ")
 173                 }
 174         },
 175         {}
 176 };
 177
 178 static const struct ctrl sd_ctrls[] = {
 179         {
 180 #define BRIGHTNESS_IDX 0
 181             {
 182                 .id      = V4L2_CID_BRIGHTNESS,
 183                 .type    = V4L2_CTRL_TYPE_INTEGER,
 184                 .name    = "Brightness",
 185                 .minimum = 0,
 186                 .maximum = 0xff,
 187                 .step    = 1,
 188 #define BRIGHTNESS_DEFAULT 0x7f
 189                 .default_value = BRIGHTNESS_DEFAULT,
 190             },
 191             .set = sd_setbrightness,
 192             .get = sd_getbrightness,
 193         },
 194         {
 195 #define CONTRAST_IDX 1
 196             {
 197                 .id      = V4L2_CID_CONTRAST,
 198                 .type    = V4L2_CTRL_TYPE_INTEGER,
 199                 .name    = "Contrast",
 200                 .minimum = 0,
 201                 .maximum = 0xff,
 202                 .step    = 1,
 203 #define CONTRAST_DEFAULT 0x7f
 204                 .default_value = CONTRAST_DEFAULT,
 205             },
 206             .set = sd_setcontrast,
 207             .get = sd_getcontrast,
 208         },
 209         {
 210 #define SATURATION_IDX 2
 211             {
 212                 .id      = V4L2_CID_SATURATION,
 213                 .type    = V4L2_CTRL_TYPE_INTEGER,
 214                 .name    = "Saturation",
 215                 .minimum = 0,
 216                 .maximum = 0xff,
 217                 .step    = 1,
 218 #define SATURATION_DEFAULT 0x7f
 219                 .default_value = SATURATION_DEFAULT,
 220             },
 221             .set = sd_setsaturation,
 222             .get = sd_getsaturation,
 223         },
 224         {
 225 #define HUE_IDX 3
 226             {
 227                 .id      = V4L2_CID_HUE,
 228                 .type    = V4L2_CTRL_TYPE_INTEGER,
 229                 .name    = "Hue",
 230                 .minimum = -180,
 231                 .maximum = 180,
 232                 .step    = 1,
 233 #define HUE_DEFAULT 0
 234                 .default_value = HUE_DEFAULT,
 235             },
 236             .set = sd_sethue,
 237             .get = sd_gethue,
 238         },
 239         {
 240 #define GAMMA_IDX 4
 241             {
 242                 .id      = V4L2_CID_GAMMA,
 243                 .type    = V4L2_CTRL_TYPE_INTEGER,
 244                 .name    = "Gamma",
 245                 .minimum = 0,
 246                 .maximum = 0xff,
 247                 .step    = 1,
 248 #define GAMMA_DEFAULT 0x10
 249                 .default_value = GAMMA_DEFAULT,
 250             },
 251             .set = sd_setgamma,
 252             .get = sd_getgamma,
 253         },
 254         {
 255 #define BLUE_IDX 5
 256             {
 257                 .id      = V4L2_CID_BLUE_BALANCE,
 258                 .type    = V4L2_CTRL_TYPE_INTEGER,
 259                 .name    = "Blue Balance",
 260                 .minimum = 0,
 261                 .maximum = 0x7f,
 262                 .step    = 1,
 263 #define BLUE_DEFAULT 0x28
 264                 .default_value = BLUE_DEFAULT,
 265             },
 266             .set = sd_setbluebalance,
 267             .get = sd_getbluebalance,
 268         },
 269         {
 270 #define RED_IDX 6
 271             {
 272                 .id      = V4L2_CID_RED_BALANCE,
 273                 .type    = V4L2_CTRL_TYPE_INTEGER,
 274                 .name    = "Red Balance",
 275                 .minimum = 0,
 276                 .maximum = 0x7f,
 277                 .step    = 1,
 278 #define RED_DEFAULT 0x28
 279                 .default_value = RED_DEFAULT,
 280             },
 281             .set = sd_setredbalance,
 282             .get = sd_getredbalance,
 283         },
 284         {
 285 #define HFLIP_IDX 7
 286             {
 287                 .id      = V4L2_CID_HFLIP,
 288                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 289                 .name    = "Horizontal Flip",
 290                 .minimum = 0,
 291                 .maximum = 1,
 292                 .step    = 1,
 293 #define HFLIP_DEFAULT 0
 294                 .default_value = HFLIP_DEFAULT,
 295             },
 296             .set = sd_sethflip,
 297             .get = sd_gethflip,
 298         },
 299         {
 300 #define VFLIP_IDX 8
 301             {
 302                 .id      = V4L2_CID_VFLIP,
 303                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 304                 .name    = "Vertical Flip",
 305                 .minimum = 0,
 306                 .maximum = 1,
 307                 .step    = 1,
 308 #define VFLIP_DEFAULT 0
 309                 .default_value = VFLIP_DEFAULT,
 310             },
 311             .set = sd_setvflip,
 312             .get = sd_getvflip,
 313         },
 314         {
 315 #define EXPOSURE_IDX 9
 316             {
 317                 .id      = V4L2_CID_EXPOSURE,
 318                 .type    = V4L2_CTRL_TYPE_INTEGER,
 319                 .name    = "Exposure",
 320                 .minimum = 0,
 321                 .maximum = 0x1780,
 322                 .step    = 1,
 323 #define EXPOSURE_DEFAULT 0x33
 324                 .default_value = EXPOSURE_DEFAULT,
 325             },
 326             .set = sd_setexposure,
 327             .get = sd_getexposure,
 328         },
 329         {
 330 #define GAIN_IDX 10
 331             {
 332                 .id      = V4L2_CID_GAIN,
 333                 .type    = V4L2_CTRL_TYPE_INTEGER,
 334                 .name    = "Gain",
 335                 .minimum = 0,
 336                 .maximum = 28,
 337                 .step    = 1,
 338 #define GAIN_DEFAULT 0x00
 339                 .default_value = GAIN_DEFAULT,
 340             },
 341             .set = sd_setgain,
 342             .get = sd_getgain,
 343         },
 344         {
 345 #define AUTOGAIN_IDX 11
 346             {
 347                 .id      = V4L2_CID_AUTOGAIN,
 348                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 349                 .name    = "Auto Exposure",
 350                 .minimum = 0,
 351                 .maximum = 1,
 352                 .step    = 1,
 353 #define AUTO_EXPOSURE_DEFAULT 1
 354                 .default_value = AUTO_EXPOSURE_DEFAULT,
 355             },
 356             .set = sd_setautoexposure,
 357             .get = sd_getautoexposure,
 358         },
 359 };
 360
 361 static const struct v4l2_pix_format vga_mode[] = {
 362         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 363                 .bytesperline = 160,
 364                 .sizeimage = 160 * 120 * 4 / 8 + 590,
 365                 .colorspace = V4L2_COLORSPACE_JPEG,
 366                 .priv = SCALE_160x120 | MODE_JPEG},
 367         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 368                 .bytesperline = 160,
 369                 .sizeimage = 160 * 120,
 370                 .colorspace = V4L2_COLORSPACE_SRGB,
 371                 .priv = SCALE_160x120 | MODE_RAW},
 372         {160, 120, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
 373                 .bytesperline = 160,
 374                 .sizeimage = 240 * 120,
 375                 .colorspace = V4L2_COLORSPACE_SRGB,
 376                 .priv = SCALE_160x120},
 377         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 378                 .bytesperline = 320,
 379                 .sizeimage = 320 * 240 * 4 / 8 + 590,
 380                 .colorspace = V4L2_COLORSPACE_JPEG,
 381                 .priv = SCALE_320x240 | MODE_JPEG},
 382         {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 383                 .bytesperline = 320,
 384                 .sizeimage = 320 * 240 ,
 385                 .colorspace = V4L2_COLORSPACE_SRGB,
 386                 .priv = SCALE_320x240 | MODE_RAW},
 387         {320, 240, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
 388                 .bytesperline = 320,
 389                 .sizeimage = 480 * 240 ,
 390                 .colorspace = V4L2_COLORSPACE_SRGB,
 391                 .priv = SCALE_320x240},
 392         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 393                 .bytesperline = 640,
 394                 .sizeimage = 640 * 480 * 4 / 8 + 590,
 395                 .colorspace = V4L2_COLORSPACE_JPEG,
 396                 .priv = SCALE_640x480 | MODE_JPEG},
 397         {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 398                 .bytesperline = 640,
 399                 .sizeimage = 640 * 480,
 400                 .colorspace = V4L2_COLORSPACE_SRGB,
 401                 .priv = SCALE_640x480 | MODE_RAW},
 402         {640, 480, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
 403                 .bytesperline = 640,
 404                 .sizeimage = 960 * 480,
 405                 .colorspace = V4L2_COLORSPACE_SRGB,
 406                 .priv = SCALE_640x480},
 407 };
 408
 409 static const struct v4l2_pix_format sxga_mode[] = {
 410         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 411                 .bytesperline = 160,
 412                 .sizeimage = 160 * 120 * 4 / 8 + 590,
 413                 .colorspace = V4L2_COLORSPACE_JPEG,
 414                 .priv = SCALE_160x120 | MODE_JPEG},
 415         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 416                 .bytesperline = 160,
 417                 .sizeimage = 160 * 120,
 418                 .colorspace = V4L2_COLORSPACE_SRGB,
 419                 .priv = SCALE_160x120 | MODE_RAW},
 420         {160, 120, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
 421                 .bytesperline = 160,
 422                 .sizeimage = 240 * 120,
 423                 .colorspace = V4L2_COLORSPACE_SRGB,
 424                 .priv = SCALE_160x120},
 425         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 426                 .bytesperline = 320,
 427                 .sizeimage = 320 * 240 * 4 / 8 + 590,
 428                 .colorspace = V4L2_COLORSPACE_JPEG,
 429                 .priv = SCALE_320x240 | MODE_JPEG},
 430         {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 431                 .bytesperline = 320,
 432                 .sizeimage = 320 * 240 ,
 433                 .colorspace = V4L2_COLORSPACE_SRGB,
 434                 .priv = SCALE_320x240 | MODE_RAW},
 435         {320, 240, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
 436                 .bytesperline = 320,
 437                 .sizeimage = 480 * 240 ,
 438                 .colorspace = V4L2_COLORSPACE_SRGB,
 439                 .priv = SCALE_320x240},
 440         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 441                 .bytesperline = 640,
 442                 .sizeimage = 640 * 480 * 4 / 8 + 590,
 443                 .colorspace = V4L2_COLORSPACE_JPEG,
 444                 .priv = SCALE_640x480 | MODE_JPEG},
 445         {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 446                 .bytesperline = 640,
 447                 .sizeimage = 640 * 480,
 448                 .colorspace = V4L2_COLORSPACE_SRGB,
 449                 .priv = SCALE_640x480 | MODE_RAW},
 450         {640, 480, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE,
 451                 .bytesperline = 640,
 452                 .sizeimage = 960 * 480,
 453                 .colorspace = V4L2_COLORSPACE_SRGB,
 454                 .priv = SCALE_640x480},
 455         {1280, 1024, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 456                 .bytesperline = 1280,
 457                 .sizeimage = 1280 * 1024,
 458                 .colorspace = V4L2_COLORSPACE_SRGB,
 459                 .priv = SCALE_1280x1024 | MODE_RAW | MODE_SXGA},
 460 };
 461
 462 static const struct v4l2_pix_format mono_mode[] = {
 463         {160, 120, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
 464                 .bytesperline = 160,
 465                 .sizeimage = 160 * 120,
 466                 .colorspace = V4L2_COLORSPACE_SRGB,
 467                 .priv = SCALE_160x120 | MODE_RAW},
 468         {320, 240, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
 469                 .bytesperline = 320,
 470                 .sizeimage = 320 * 240 ,
 471                 .colorspace = V4L2_COLORSPACE_SRGB,
 472                 .priv = SCALE_320x240 | MODE_RAW},
 473         {640, 480, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
 474                 .bytesperline = 640,
 475                 .sizeimage = 640 * 480,
 476                 .colorspace = V4L2_COLORSPACE_SRGB,
 477                 .priv = SCALE_640x480 | MODE_RAW},
 478         {1280, 1024, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
 479                 .bytesperline = 1280,
 480                 .sizeimage = 1280 * 1024,
 481                 .colorspace = V4L2_COLORSPACE_SRGB,
 482                 .priv = SCALE_1280x1024 | MODE_RAW | MODE_SXGA},
 483 };
 484
 485 static const s16 hsv_red_x[] = {
 486         41,  44,  46,  48,  50,  52,  54,  56,
 487         58,  60,  62,  64,  66,  68,  70,  72,
 488         74,  76,  78,  80,  81,  83,  85,  87,
 489         88,  90,  92,  93,  95,  97,  98, 100,
 490         101, 102, 104, 105, 107, 108, 109, 110,
 491         112, 113, 114, 115, 116, 117, 118, 119,
 492         120, 121, 122, 123, 123, 124, 125, 125,
 493         126, 127, 127, 128, 128, 129, 129, 129,
 494         130, 130, 130, 130, 131, 131, 131, 131,
 495         131, 131, 131, 131, 130, 130, 130, 130,
 496         129, 129, 129, 128, 128, 127, 127, 126,
 497         125, 125, 124, 123, 122, 122, 121, 120,
 498         119, 118, 117, 116, 115, 114, 112, 111,
 499         110, 109, 107, 106, 105, 103, 102, 101,
 500         99,  98,  96,  94,  93,  91,  90,  88,
 501         86,  84,  83,  81,  79,  77,  75,  74,
 502         72,  70,  68,  66,  64,  62,  60,  58,
 503         56,  54,  52,  49,  47,  45,  43,  41,
 504         39,  36,  34,  32,  30,  28,  25,  23,
 505         21,  19,  16,  14,  12,   9,   7,   5,
 506         3,   0,  -1,  -3,  -6,  -8, -10, -12,
 507         -15, -17, -19, -22, -24, -26, -28, -30,
 508         -33, -35, -37, -39, -41, -44, -46, -48,
 509         -50, -52, -54, -56, -58, -60, -62, -64,
 510         -66, -68, -70, -72, -74, -76, -78, -80,
 511         -81, -83, -85, -87, -88, -90, -92, -93,
 512         -95, -97, -98, -100, -101, -102, -104, -105,
 513         -107, -108, -109, -110, -112, -113, -114, -115,
 514         -116, -117, -118, -119, -120, -121, -122, -123,
 515         -123, -124, -125, -125, -126, -127, -127, -128,
 516         -128, -128, -128, -128, -128, -128, -128, -128,
 517         -128, -128, -128, -128, -128, -128, -128, -128,
 518         -128, -128, -128, -128, -128, -128, -128, -128,
 519         -128, -127, -127, -126, -125, -125, -124, -123,
 520         -122, -122, -121, -120, -119, -118, -117, -116,
 521         -115, -114, -112, -111, -110, -109, -107, -106,
 522         -105, -103, -102, -101, -99, -98, -96, -94,
 523         -93, -91, -90, -88, -86, -84, -83, -81,
 524         -79, -77, -75, -74, -72, -70, -68, -66,
 525         -64, -62, -60, -58, -56, -54, -52, -49,
 526         -47, -45, -43, -41, -39, -36, -34, -32,
 527         -30, -28, -25, -23, -21, -19, -16, -14,
 528         -12,  -9,  -7,  -5,  -3,   0,   1,   3,
 529         6,   8,  10,  12,  15,  17,  19,  22,
 530         24,  26,  28,  30,  33,  35,  37,  39, 41
 531 };
 532
 533 static const s16 hsv_red_y[] = {
 534         82,  80,  78,  76,  74,  73,  71,  69,
 535         67,  65,  63,  61,  58,  56,  54,  52,
 536         50,  48,  46,  44,  41,  39,  37,  35,
 537         32,  30,  28,  26,  23,  21,  19,  16,
 538         14,  12,  10,   7,   5,   3,   0,  -1,
 539         -3,  -6,  -8, -10, -13, -15, -17, -19,
 540         -22, -24, -26, -29, -31, -33, -35, -38,
 541         -40, -42, -44, -46, -48, -51, -53, -55,
 542         -57, -59, -61, -63, -65, -67, -69, -71,
 543         -73, -75, -77, -79, -81, -82, -84, -86,
 544         -88, -89, -91, -93, -94, -96, -98, -99,
 545         -101, -102, -104, -105, -106, -108, -109, -110,
 546         -112, -113, -114, -115, -116, -117, -119, -120,
 547         -120, -121, -122, -123, -124, -125, -126, -126,
 548         -127, -128, -128, -128, -128, -128, -128, -128,
 549         -128, -128, -128, -128, -128, -128, -128, -128,
 550         -128, -128, -128, -128, -128, -128, -128, -128,
 551         -128, -128, -128, -128, -128, -128, -128, -128,
 552         -127, -127, -126, -125, -125, -124, -123, -122,
 553         -121, -120, -119, -118, -117, -116, -115, -114,
 554         -113, -111, -110, -109, -107, -106, -105, -103,
 555         -102, -100, -99, -97, -96, -94, -92, -91,
 556         -89, -87, -85, -84, -82, -80, -78, -76,
 557         -74, -73, -71, -69, -67, -65, -63, -61,
 558         -58, -56, -54, -52, -50, -48, -46, -44,
 559         -41, -39, -37, -35, -32, -30, -28, -26,
 560         -23, -21, -19, -16, -14, -12, -10,  -7,
 561         -5,  -3,   0,   1,   3,   6,   8,  10,
 562         13,  15,  17,  19,  22,  24,  26,  29,
 563         31,  33,  35,  38,  40,  42,  44,  46,
 564         48,  51,  53,  55,  57,  59,  61,  63,
 565         65,  67,  69,  71,  73,  75,  77,  79,
 566         81,  82,  84,  86,  88,  89,  91,  93,
 567         94,  96,  98,  99, 101, 102, 104, 105,
 568         106, 108, 109, 110, 112, 113, 114, 115,
 569         116, 117, 119, 120, 120, 121, 122, 123,
 570         124, 125, 126, 126, 127, 128, 128, 129,
 571         129, 130, 130, 131, 131, 131, 131, 132,
 572         132, 132, 132, 132, 132, 132, 132, 132,
 573         132, 132, 132, 131, 131, 131, 130, 130,
 574         130, 129, 129, 128, 127, 127, 126, 125,
 575         125, 124, 123, 122, 121, 120, 119, 118,
 576         117, 116, 115, 114, 113, 111, 110, 109,
 577         107, 106, 105, 103, 102, 100,  99,  97,
 578         96, 94, 92, 91, 89, 87, 85, 84, 82
 579 };
 580
 581 static const s16 hsv_green_x[] = {
 582         -124, -124, -125, -125, -125, -125, -125, -125,
 583         -125, -126, -126, -125, -125, -125, -125, -125,
 584         -125, -124, -124, -124, -123, -123, -122, -122,
 585         -121, -121, -120, -120, -119, -118, -117, -117,
 586         -116, -115, -114, -113, -112, -111, -110, -109,
 587         -108, -107, -105, -104, -103, -102, -100, -99,
 588         -98, -96, -95, -93, -92, -91, -89, -87,
 589         -86, -84, -83, -81, -79, -77, -76, -74,
 590         -72, -70, -69, -67, -65, -63, -61, -59,
 591         -57, -55, -53, -51, -49, -47, -45, -43,
 592         -41, -39, -37, -35, -33, -30, -28, -26,
 593         -24, -22, -20, -18, -15, -13, -11,  -9,
 594         -7,  -4,  -2,   0,   1,   3,   6,   8,
 595         10,  12,  14,  17,  19,  21,  23,  25,
 596         27,  29,  32,  34,  36,  38,  40,  42,
 597         44,  46,  48,  50,  52,  54,  56,  58,
 598         60,  62,  64,  66,  68,  70,  71,  73,
 599         75,  77,  78,  80,  82,  83,  85,  87,
 600         88,  90,  91,  93,  94,  96,  97,  98,
 601         100, 101, 102, 104, 105, 106, 107, 108,
 602         109, 111, 112, 113, 113, 114, 115, 116,
 603         117, 118, 118, 119, 120, 120, 121, 122,
 604         122, 123, 123, 124, 124, 124, 125, 125,
 605         125, 125, 125, 125, 125, 126, 126, 125,
 606         125, 125, 125, 125, 125, 124, 124, 124,
 607         123, 123, 122, 122, 121, 121, 120, 120,
 608         119, 118, 117, 117, 116, 115, 114, 113,
 609         112, 111, 110, 109, 108, 107, 105, 104,
 610         103, 102, 100,  99,  98,  96,  95,  93,
 611         92,  91,  89,  87,  86,  84,  83,  81,
 612         79,  77,  76,  74,  72,  70,  69,  67,
 613         65,  63,  61,  59,  57,  55,  53,  51,
 614         49,  47,  45,  43,  41,  39,  37,  35,
 615         33,  30,  28,  26,  24,  22,  20,  18,
 616         15,  13,  11,   9,   7,   4,   2,   0,
 617         -1,  -3,  -6,  -8, -10, -12, -14, -17,
 618         -19, -21, -23, -25, -27, -29, -32, -34,
 619         -36, -38, -40, -42, -44, -46, -48, -50,
 620         -52, -54, -56, -58, -60, -62, -64, -66,
 621         -68, -70, -71, -73, -75, -77, -78, -80,
 622         -82, -83, -85, -87, -88, -90, -91, -93,
 623         -94, -96, -97, -98, -100, -101, -102, -104,
 624         -105, -106, -107, -108, -109, -111, -112, -113,
 625         -113, -114, -115, -116, -117, -118, -118, -119,
 626         -120, -120, -121, -122, -122, -123, -123, -124, -124
 627 };
 628
 629 static const s16 hsv_green_y[] = {
 630         -100, -99, -98, -97, -95, -94, -93, -91,
 631         -90, -89, -87, -86, -84, -83, -81, -80,
 632         -78, -76, -75, -73, -71, -70, -68, -66,
 633         -64, -63, -61, -59, -57, -55, -53, -51,
 634         -49, -48, -46, -44, -42, -40, -38, -36,
 635         -34, -32, -30, -27, -25, -23, -21, -19,
 636         -17, -15, -13, -11,  -9,  -7,  -4,  -2,
 637         0,   1,   3,   5,   7,   9,  11,  14,
 638         16,  18,  20,  22,  24,  26,  28,  30,
 639         32,  34,  36,  38,  40,  42,  44,  46,
 640         48,  50,  52,  54,  56,  58,  59,  61,
 641         63,  65,  67,  68,  70,  72,  74,  75,
 642         77,  78,  80,  82,  83,  85,  86,  88,
 643         89,  90,  92,  93,  95,  96,  97,  98,
 644         100, 101, 102, 103, 104, 105, 106, 107,
 645         108, 109, 110, 111, 112, 112, 113, 114,
 646         115, 115, 116, 116, 117, 117, 118, 118,
 647         119, 119, 119, 120, 120, 120, 120, 120,
 648         121, 121, 121, 121, 121, 121, 120, 120,
 649         120, 120, 120, 119, 119, 119, 118, 118,
 650         117, 117, 116, 116, 115, 114, 114, 113,
 651         112, 111, 111, 110, 109, 108, 107, 106,
 652         105, 104, 103, 102, 100,  99,  98,  97,
 653         95,  94,  93,  91,  90,  89,  87,  86,
 654         84,  83,  81,  80,  78,  76,  75,  73,
 655         71,  70,  68,  66,  64,  63,  61,  59,
 656         57,  55,  53,  51,  49,  48,  46,  44,
 657         42,  40,  38,  36,  34,  32,  30,  27,
 658         25,  23,  21,  19,  17,  15,  13,  11,
 659         9,   7,   4,   2,   0,  -1,  -3,  -5,
 660         -7,  -9, -11, -14, -16, -18, -20, -22,
 661         -24, -26, -28, -30, -32, -34, -36, -38,
 662         -40, -42, -44, -46, -48, -50, -52, -54,
 663         -56, -58, -59, -61, -63, -65, -67, -68,
 664         -70, -72, -74, -75, -77, -78, -80, -82,
 665         -83, -85, -86, -88, -89, -90, -92, -93,
 666         -95, -96, -97, -98, -100, -101, -102, -103,
 667         -104, -105, -106, -107, -108, -109, -110, -111,
 668         -112, -112, -113, -114, -115, -115, -116, -116,
 669         -117, -117, -118, -118, -119, -119, -119, -120,
 670         -120, -120, -120, -120, -121, -121, -121, -121,
 671         -121, -121, -120, -120, -120, -120, -120, -119,
 672         -119, -119, -118, -118, -117, -117, -116, -116,
 673         -115, -114, -114, -113, -112, -111, -111, -110,
 674         -109, -108, -107, -106, -105, -104, -103, -102, -100
 675 };
 676
 677 static const s16 hsv_blue_x[] = {
 678         112, 113, 114, 114, 115, 116, 117, 117,
 679         118, 118, 119, 119, 120, 120, 120, 121,
 680         121, 121, 122, 122, 122, 122, 122, 122,
 681         122, 122, 122, 122, 122, 122, 121, 121,
 682         121, 120, 120, 120, 119, 119, 118, 118,
 683         117, 116, 116, 115, 114, 113, 113, 112,
 684         111, 110, 109, 108, 107, 106, 105, 104,
 685         103, 102, 100,  99,  98,  97,  95,  94,
 686         93,  91,  90,  88,  87,  85,  84,  82,
 687         80,  79,  77,  76,  74,  72,  70,  69,
 688         67,  65,  63,  61,  60,  58,  56,  54,
 689         52,  50,  48,  46,  44,  42,  40,  38,
 690         36,  34,  32,  30,  28,  26,  24,  22,
 691         19,  17,  15,  13,  11,   9,   7,   5,
 692         2,   0,  -1,  -3,  -5,  -7,  -9, -12,
 693         -14, -16, -18, -20, -22, -24, -26, -28,
 694         -31, -33, -35, -37, -39, -41, -43, -45,
 695         -47, -49, -51, -53, -54, -56, -58, -60,
 696         -62, -64, -66, -67, -69, -71, -73, -74,
 697         -76, -78, -79, -81, -83, -84, -86, -87,
 698         -89, -90, -92, -93, -94, -96, -97, -98,
 699         -99, -101, -102, -103, -104, -105, -106, -107,
 700         -108, -109, -110, -111, -112, -113, -114, -114,
 701         -115, -116, -117, -117, -118, -118, -119, -119,
 702         -120, -120, -120, -121, -121, -121, -122, -122,
 703         -122, -122, -122, -122, -122, -122, -122, -122,
 704         -122, -122, -121, -121, -121, -120, -120, -120,
 705         -119, -119, -118, -118, -117, -116, -116, -115,
 706         -114, -113, -113, -112, -111, -110, -109, -108,
 707         -107, -106, -105, -104, -103, -102, -100, -99,
 708         -98, -97, -95, -94, -93, -91, -90, -88,
 709         -87, -85, -84, -82, -80, -79, -77, -76,
 710         -74, -72, -70, -69, -67, -65, -63, -61,
 711         -60, -58, -56, -54, -52, -50, -48, -46,
 712         -44, -42, -40, -38, -36, -34, -32, -30,
 713         -28, -26, -24, -22, -19, -17, -15, -13,
 714         -11,  -9,  -7,  -5,  -2,   0,   1,   3,
 715         5,   7,   9,  12,  14,  16,  18,  20,
 716         22,  24,  26,  28,  31,  33,  35,  37,
 717         39,  41,  43,  45,  47,  49,  51,  53,
 718         54,  56,  58,  60,  62,  64,  66,  67,
 719         69,  71,  73,  74,  76,  78,  79,  81,
 720         83,  84,  86,  87,  89,  90,  92,  93,
 721         94,  96,  97,  98,  99, 101, 102, 103,
 722         104, 105, 106, 107, 108, 109, 110, 111, 112
 723 };
 724
 725 static const s16 hsv_blue_y[] = {
 726         -11, -13, -15, -17, -19, -21, -23, -25,
 727         -27, -29, -31, -33, -35, -37, -39, -41,
 728         -43, -45, -46, -48, -50, -52, -54, -55,
 729         -57, -59, -61, -62, -64, -66, -67, -69,
 730         -71, -72, -74, -75, -77, -78, -80, -81,
 731         -83, -84, -86, -87, -88, -90, -91, -92,
 732         -93, -95, -96, -97, -98, -99, -100, -101,
 733         -102, -103, -104, -105, -106, -106, -107, -108,
 734         -109, -109, -110, -111, -111, -112, -112, -113,
 735         -113, -114, -114, -114, -115, -115, -115, -115,
 736         -116, -116, -116, -116, -116, -116, -116, -116,
 737         -116, -115, -115, -115, -115, -114, -114, -114,
 738         -113, -113, -112, -112, -111, -111, -110, -110,
 739         -109, -108, -108, -107, -106, -105, -104, -103,
 740         -102, -101, -100, -99, -98, -97, -96, -95,
 741         -94, -93, -91, -90, -89, -88, -86, -85,
 742         -84, -82, -81, -79, -78, -76, -75, -73,
 743         -71, -70, -68, -67, -65, -63, -62, -60,
 744         -58, -56, -55, -53, -51, -49, -47, -45,
 745         -44, -42, -40, -38, -36, -34, -32, -30,
 746         -28, -26, -24, -22, -20, -18, -16, -14,
 747         -12, -10,  -8,  -6,  -4,  -2,   0,   1,
 748         3,   5,   7,   9,  11,  13,  15,  17,
 749         19,  21,  23,  25,  27,  29,  31,  33,
 750         35,  37,  39,  41,  43,  45,  46,  48,
 751         50,  52,  54,  55,  57,  59,  61,  62,
 752         64,  66,  67,  69,  71,  72,  74,  75,
 753         77,  78,  80,  81,  83,  84,  86,  87,
 754         88,  90,  91,  92,  93,  95,  96,  97,
 755         98,  99, 100, 101, 102, 103, 104, 105,
 756         106, 106, 107, 108, 109, 109, 110, 111,
 757         111, 112, 112, 113, 113, 114, 114, 114,
 758         115, 115, 115, 115, 116, 116, 116, 116,
 759         116, 116, 116, 116, 116, 115, 115, 115,
 760         115, 114, 114, 114, 113, 113, 112, 112,
 761         111, 111, 110, 110, 109, 108, 108, 107,
 762         106, 105, 104, 103, 102, 101, 100,  99,
 763         98,  97,  96,  95,  94,  93,  91,  90,
 764         89,  88,  86,  85,  84,  82,  81,  79,
 765         78,  76,  75,  73,  71,  70,  68,  67,
 766         65,  63,  62,  60,  58,  56,  55,  53,
 767         51,  49,  47,  45,  44,  42,  40,  38,
 768         36,  34,  32,  30,  28,  26,  24,  22,
 769         20,  18,  16,  14,  12,  10,   8,   6,
 770         4,   2,   0,  -1,  -3,  -5,  -7,  -9, -11
 771 };
 772
 773 static u16 i2c_ident[] = {
 774         V4L2_IDENT_OV9650,
 775         V4L2_IDENT_OV9655,
 776         V4L2_IDENT_SOI968,
 777         V4L2_IDENT_OV7660,
 778         V4L2_IDENT_OV7670,
 779         V4L2_IDENT_MT9V011,
 780         V4L2_IDENT_MT9V111,
 781         V4L2_IDENT_MT9V112,
 782         V4L2_IDENT_MT9M001C12ST,
 783         V4L2_IDENT_MT9M111,
 784         V4L2_IDENT_MT9M112,
 785         V4L2_IDENT_HV7131R,
 786 };
 787
 788 static u16 bridge_init[][2] = {
 789         {0x1000, 0x78}, {0x1001, 0x40}, {0x1002, 0x1c},
 790         {0x1020, 0x80}, {0x1061, 0x01}, {0x1067, 0x40},
 791         {0x1068, 0x30}, {0x1069, 0x20}, {0x106a, 0x10},
 792         {0x106b, 0x08}, {0x1188, 0x87}, {0x11a1, 0x00},
 793         {0x11a2, 0x00}, {0x11a3, 0x6a}, {0x11a4, 0x50},
 794         {0x11ab, 0x00}, {0x11ac, 0x00}, {0x11ad, 0x50},
 795         {0x11ae, 0x3c}, {0x118a, 0x04}, {0x0395, 0x04},
 796         {0x11b8, 0x3a}, {0x118b, 0x0e}, {0x10f7, 0x05},
 797         {0x10f8, 0x14}, {0x10fa, 0xff}, {0x10f9, 0x00},
 798         {0x11ba, 0x0a}, {0x11a5, 0x2d}, {0x11a6, 0x2d},
 799         {0x11a7, 0x3a}, {0x11a8, 0x05}, {0x11a9, 0x04},
 800         {0x11aa, 0x3f}, {0x11af, 0x28}, {0x11b0, 0xd8},
 801         {0x11b1, 0x14}, {0x11b2, 0xec}, {0x11b3, 0x32},
 802         {0x11b4, 0xdd}, {0x11b5, 0x32}, {0x11b6, 0xdd},
 803         {0x10e0, 0x2c}, {0x11bc, 0x40}, {0x11bd, 0x01},
 804         {0x11be, 0xf0}, {0x11bf, 0x00}, {0x118c, 0x1f},
 805         {0x118d, 0x1f}, {0x118e, 0x1f}, {0x118f, 0x1f},
 806         {0x1180, 0x01}, {0x1181, 0x00}, {0x1182, 0x01},
 807         {0x1183, 0x00}, {0x1184, 0x50}, {0x1185, 0x80},
 808         {0x1007, 0x00}
 809 };
 810
 811 /* Gain = (bit[3:0] / 16 + 1) * (bit[4] + 1) * (bit[5] + 1) * (bit[6] + 1) */
 812 static u8 ov_gain[] = {
 813         0x00 /* 1x */, 0x04 /* 1.25x */, 0x08 /* 1.5x */, 0x0c /* 1.75x */,
 814         0x10 /* 2x */, 0x12 /* 2.25x */, 0x14 /* 2.5x */, 0x16 /* 2.75x */,
 815         0x18 /* 3x */, 0x1a /* 3.25x */, 0x1c /* 3.5x */, 0x1e /* 3.75x */,
 816         0x30 /* 4x */, 0x31 /* 4.25x */, 0x32 /* 4.5x */, 0x33 /* 4.75x */,
 817         0x34 /* 5x */, 0x35 /* 5.25x */, 0x36 /* 5.5x */, 0x37 /* 5.75x */,
 818         0x38 /* 6x */, 0x39 /* 6.25x */, 0x3a /* 6.5x */, 0x3b /* 6.75x */,
 819         0x3c /* 7x */, 0x3d /* 7.25x */, 0x3e /* 7.5x */, 0x3f /* 7.75x */,
 820         0x70 /* 8x */
 821 };
 822
 823 /* Gain = (bit[8] + 1) * (bit[7] + 1) * (bit[6:0] * 0.03125) */
 824 static u16 micron1_gain[] = {
 825         /* 1x   1.25x   1.5x    1.75x */
 826         0x0020, 0x0028, 0x0030, 0x0038,
 827         /* 2x   2.25x   2.5x    2.75x */
 828         0x00a0, 0x00a4, 0x00a8, 0x00ac,
 829         /* 3x   3.25x   3.5x    3.75x */
 830         0x00b0, 0x00b4, 0x00b8, 0x00bc,
 831         /* 4x   4.25x   4.5x    4.75x */
 832         0x00c0, 0x00c4, 0x00c8, 0x00cc,
 833         /* 5x   5.25x   5.5x    5.75x */
 834         0x00d0, 0x00d4, 0x00d8, 0x00dc,
 835         /* 6x   6.25x   6.5x    6.75x */
 836         0x00e0, 0x00e4, 0x00e8, 0x00ec,
 837         /* 7x   7.25x   7.5x    7.75x */
 838         0x00f0, 0x00f4, 0x00f8, 0x00fc,
 839         /* 8x */
 840         0x01c0
 841 };
 842
 843 /* mt9m001 sensor uses a different gain formula then other micron sensors */
 844 /* Gain = (bit[6] + 1) * (bit[5-0] * 0.125) */
 845 static u16 micron2_gain[] = {
 846         /* 1x   1.25x   1.5x    1.75x */
 847         0x0008, 0x000a, 0x000c, 0x000e,
 848         /* 2x   2.25x   2.5x    2.75x */
 849         0x0010, 0x0012, 0x0014, 0x0016,
 850         /* 3x   3.25x   3.5x    3.75x */
 851         0x0018, 0x001a, 0x001c, 0x001e,
 852         /* 4x   4.25x   4.5x    4.75x */
 853         0x0020, 0x0051, 0x0052, 0x0053,
 854         /* 5x   5.25x   5.5x    5.75x */
 855         0x0054, 0x0055, 0x0056, 0x0057,
 856         /* 6x   6.25x   6.5x    6.75x */
 857         0x0058, 0x0059, 0x005a, 0x005b,
 858         /* 7x   7.25x   7.5x    7.75x */
 859         0x005c, 0x005d, 0x005e, 0x005f,
 860         /* 8x */
 861         0x0060
 862 };
 863
 864 /* Gain = .5 + bit[7:0] / 16 */
 865 static u8 hv7131r_gain[] = {
 866         0x08 /* 1x */, 0x0c /* 1.25x */, 0x10 /* 1.5x */, 0x14 /* 1.75x */,
 867         0x18 /* 2x */, 0x1c /* 2.25x */, 0x20 /* 2.5x */, 0x24 /* 2.75x */,
 868         0x28 /* 3x */, 0x2c /* 3.25x */, 0x30 /* 3.5x */, 0x34 /* 3.75x */,
 869         0x38 /* 4x */, 0x3c /* 4.25x */, 0x40 /* 4.5x */, 0x44 /* 4.75x */,
 870         0x48 /* 5x */, 0x4c /* 5.25x */, 0x50 /* 5.5x */, 0x54 /* 5.75x */,
 871         0x58 /* 6x */, 0x5c /* 6.25x */, 0x60 /* 6.5x */, 0x64 /* 6.75x */,
 872         0x68 /* 7x */, 0x6c /* 7.25x */, 0x70 /* 7.5x */, 0x74 /* 7.75x */,
 873         0x78 /* 8x */
 874 };
 875
 876 static struct i2c_reg_u8 soi968_init[] = {
 877         {0x12, 0x80}, {0x0c, 0x00}, {0x0f, 0x1f},
 878         {0x11, 0x80}, {0x38, 0x52}, {0x1e, 0x00},
 879         {0x33, 0x08}, {0x35, 0x8c}, {0x36, 0x0c},
 880         {0x37, 0x04}, {0x45, 0x04}, {0x47, 0xff},
 881         {0x3e, 0x00}, {0x3f, 0x00}, {0x3b, 0x20},
 882         {0x3a, 0x96}, {0x3d, 0x0a}, {0x14, 0x8e},
 883         {0x13, 0x8b}, {0x12, 0x40}, {0x17, 0x13},
 884         {0x18, 0x63}, {0x19, 0x01}, {0x1a, 0x79},
 885         {0x32, 0x24}, {0x03, 0x00}, {0x11, 0x40},
 886         {0x2a, 0x10}, {0x2b, 0xe0}, {0x10, 0x32},
 887         {0x00, 0x00}, {0x01, 0x80}, {0x02, 0x80},
 888 };
 889
 890 static struct i2c_reg_u8 ov7660_init[] = {
 891         {0x0e, 0x80}, {0x0d, 0x08}, {0x0f, 0xc3},
 892         {0x04, 0xc3}, {0x10, 0x40}, {0x11, 0x40},
 893         {0x12, 0x05}, {0x13, 0xba}, {0x14, 0x2a},
 894         /* HDG Set hstart and hstop, datasheet default 0x11, 0x61, using
 895            0x10, 0x61 and sd->hstart, vstart = 3, fixes ugly colored borders */
 896         {0x17, 0x10}, {0x18, 0x61},
 897         {0x37, 0x0f}, {0x38, 0x02}, {0x39, 0x43},
 898         {0x3a, 0x00}, {0x69, 0x90}, {0x2d, 0xf6},
 899         {0x2e, 0x0b}, {0x01, 0x78}, {0x02, 0x50},
 900 };
 901
 902 static struct i2c_reg_u8 ov7670_init[] = {
 903         {0x12, 0x80}, {0x11, 0x80}, {0x3a, 0x04}, {0x12, 0x01},
 904         {0x32, 0xb6}, {0x03, 0x0a}, {0x0c, 0x00}, {0x3e, 0x00},
 905         {0x70, 0x3a}, {0x71, 0x35}, {0x72, 0x11}, {0x73, 0xf0},
 906         {0xa2, 0x02}, {0x13, 0xe0}, {0x00, 0x00}, {0x10, 0x00},
 907         {0x0d, 0x40}, {0x14, 0x28}, {0xa5, 0x05}, {0xab, 0x07},
 908         {0x24, 0x95}, {0x25, 0x33}, {0x26, 0xe3}, {0x9f, 0x75},
 909         {0xa0, 0x65}, {0xa1, 0x0b}, {0xa6, 0xd8}, {0xa7, 0xd8},
 910         {0xa8, 0xf0}, {0xa9, 0x90}, {0xaa, 0x94}, {0x13, 0xe5},
 911         {0x0e, 0x61}, {0x0f, 0x4b}, {0x16, 0x02}, {0x1e, 0x27},
 912         {0x21, 0x02}, {0x22, 0x91}, {0x29, 0x07}, {0x33, 0x0b},
 913         {0x35, 0x0b}, {0x37, 0x1d}, {0x38, 0x71}, {0x39, 0x2a},
 914         {0x3c, 0x78}, {0x4d, 0x40}, {0x4e, 0x20}, {0x69, 0x00},
 915         {0x74, 0x19}, {0x8d, 0x4f}, {0x8e, 0x00}, {0x8f, 0x00},
 916         {0x90, 0x00}, {0x91, 0x00}, {0x96, 0x00}, {0x9a, 0x80},
 917         {0xb0, 0x84}, {0xb1, 0x0c}, {0xb2, 0x0e}, {0xb3, 0x82},
 918         {0xb8, 0x0a}, {0x43, 0x0a}, {0x44, 0xf0}, {0x45, 0x20},
 919         {0x46, 0x7d}, {0x47, 0x29}, {0x48, 0x4a}, {0x59, 0x8c},
 920         {0x5a, 0xa5}, {0x5b, 0xde}, {0x5c, 0x96}, {0x5d, 0x66},
 921         {0x5e, 0x10}, {0x6c, 0x0a}, {0x6d, 0x55}, {0x6e, 0x11},
 922         {0x6f, 0x9e}, {0x6a, 0x40}, {0x01, 0x40}, {0x02, 0x40},
 923         {0x13, 0xe7}, {0x4f, 0x6e}, {0x50, 0x70}, {0x51, 0x02},
 924         {0x52, 0x1d}, {0x53, 0x56}, {0x54, 0x73}, {0x55, 0x0a},
 925         {0x56, 0x55}, {0x57, 0x80}, {0x58, 0x9e}, {0x41, 0x08},
 926         {0x3f, 0x02}, {0x75, 0x03}, {0x76, 0x63}, {0x4c, 0x04},
 927         {0x77, 0x06}, {0x3d, 0x02}, {0x4b, 0x09}, {0xc9, 0x30},
 928         {0x41, 0x08}, {0x56, 0x48}, {0x34, 0x11}, {0xa4, 0x88},
 929         {0x96, 0x00}, {0x97, 0x30}, {0x98, 0x20}, {0x99, 0x30},
 930         {0x9a, 0x84}, {0x9b, 0x29}, {0x9c, 0x03}, {0x9d, 0x99},
 931         {0x9e, 0x7f}, {0x78, 0x04}, {0x79, 0x01}, {0xc8, 0xf0},
 932         {0x79, 0x0f}, {0xc8, 0x00}, {0x79, 0x10}, {0xc8, 0x7e},
 933         {0x79, 0x0a}, {0xc8, 0x80}, {0x79, 0x0b}, {0xc8, 0x01},
 934         {0x79, 0x0c}, {0xc8, 0x0f}, {0x79, 0x0d}, {0xc8, 0x20},
 935         {0x79, 0x09}, {0xc8, 0x80}, {0x79, 0x02}, {0xc8, 0xc0},
 936         {0x79, 0x03}, {0xc8, 0x40}, {0x79, 0x05}, {0xc8, 0x30},
 937         {0x79, 0x26}, {0x62, 0x20}, {0x63, 0x00}, {0x64, 0x06},
 938         {0x65, 0x00}, {0x66, 0x05}, {0x94, 0x05}, {0x95, 0x0a},
 939         {0x17, 0x13}, {0x18, 0x01}, {0x19, 0x02}, {0x1a, 0x7a},
 940         {0x46, 0x59}, {0x47, 0x30}, {0x58, 0x9a}, {0x59, 0x84},
 941         {0x5a, 0x91}, {0x5b, 0x57}, {0x5c, 0x75}, {0x5d, 0x6d},
 942         {0x5e, 0x13}, {0x64, 0x07}, {0x94, 0x07}, {0x95, 0x0d},
 943         {0xa6, 0xdf}, {0xa7, 0xdf}, {0x48, 0x4d}, {0x51, 0x00},
 944         {0x6b, 0x0a}, {0x11, 0x80}, {0x2a, 0x00}, {0x2b, 0x00},
 945         {0x92, 0x00}, {0x93, 0x00}, {0x55, 0x0a}, {0x56, 0x60},
 946         {0x4f, 0x6e}, {0x50, 0x70}, {0x51, 0x00}, {0x52, 0x1d},
 947         {0x53, 0x56}, {0x54, 0x73}, {0x58, 0x9a}, {0x4f, 0x6e},
 948         {0x50, 0x70}, {0x51, 0x00}, {0x52, 0x1d}, {0x53, 0x56},
 949         {0x54, 0x73}, {0x58, 0x9a}, {0x3f, 0x01}, {0x7b, 0x03},
 950         {0x7c, 0x09}, {0x7d, 0x16}, {0x7e, 0x38}, {0x7f, 0x47},
 951         {0x80, 0x53}, {0x81, 0x5e}, {0x82, 0x6a}, {0x83, 0x74},
 952         {0x84, 0x80}, {0x85, 0x8c}, {0x86, 0x9b}, {0x87, 0xb2},
 953         {0x88, 0xcc}, {0x89, 0xe5}, {0x7a, 0x24}, {0x3b, 0x00},
 954         {0x9f, 0x76}, {0xa0, 0x65}, {0x13, 0xe2}, {0x6b, 0x0a},
 955         {0x11, 0x80}, {0x2a, 0x00}, {0x2b, 0x00}, {0x92, 0x00},
 956         {0x93, 0x00},
 957 };
 958
 959 static struct i2c_reg_u8 ov9650_init[] = {
 960         {0x12, 0x80}, {0x00, 0x00}, {0x01, 0x78},
 961         {0x02, 0x78}, {0x03, 0x36}, {0x04, 0x03},
 962         {0x05, 0x00}, {0x06, 0x00}, {0x08, 0x00},
 963         {0x09, 0x01}, {0x0c, 0x00}, {0x0d, 0x00},
 964         {0x0e, 0xa0}, {0x0f, 0x52}, {0x10, 0x7c},
 965         {0x11, 0x80}, {0x12, 0x45}, {0x13, 0xc2},
 966         {0x14, 0x2e}, {0x15, 0x00}, {0x16, 0x07},
 967         {0x17, 0x24}, {0x18, 0xc5}, {0x19, 0x00},
 968         {0x1a, 0x3c}, {0x1b, 0x00}, {0x1e, 0x04},
 969         {0x1f, 0x00}, {0x24, 0x78}, {0x25, 0x68},
 970         {0x26, 0xd4}, {0x27, 0x80}, {0x28, 0x80},
 971         {0x29, 0x30}, {0x2a, 0x00}, {0x2b, 0x00},
 972         {0x2c, 0x80}, {0x2d, 0x00}, {0x2e, 0x00},
 973         {0x2f, 0x00}, {0x30, 0x08}, {0x31, 0x30},
 974         {0x32, 0x84}, {0x33, 0xe2}, {0x34, 0xbf},
 975         {0x35, 0x81}, {0x36, 0xf9}, {0x37, 0x00},
 976         {0x38, 0x93}, {0x39, 0x50}, {0x3a, 0x01},
 977         {0x3b, 0x01}, {0x3c, 0x73}, {0x3d, 0x19},
 978         {0x3e, 0x0b}, {0x3f, 0x80}, {0x40, 0xc1},
 979         {0x41, 0x00}, {0x42, 0x08}, {0x67, 0x80},
 980         {0x68, 0x80}, {0x69, 0x40}, {0x6a, 0x00},
 981         {0x6b, 0x0a}, {0x8b, 0x06}, {0x8c, 0x20},
 982         {0x8d, 0x00}, {0x8e, 0x00}, {0x8f, 0xdf},
 983         {0x92, 0x00}, {0x93, 0x00}, {0x94, 0x88},
 984         {0x95, 0x88}, {0x96, 0x04}, {0xa1, 0x00},
 985         {0xa5, 0x80}, {0xa8, 0x80}, {0xa9, 0xb8},
 986         {0xaa, 0x92}, {0xab, 0x0a},
 987 };
 988
 989 static struct i2c_reg_u8 ov9655_init[] = {
 990         {0x12, 0x80}, {0x0e, 0x61}, {0x11, 0x80}, {0x13, 0xba},
 991         {0x14, 0x2e}, {0x16, 0x24}, {0x1e, 0x04}, {0x27, 0x08},
 992         {0x28, 0x08}, {0x29, 0x15}, {0x2c, 0x08}, {0x34, 0x3d},
 993         {0x35, 0x00}, {0x38, 0x12}, {0x0f, 0x42}, {0x39, 0x57},
 994         {0x3a, 0x00}, {0x3b, 0xcc}, {0x3c, 0x0c}, {0x3d, 0x19},
 995         {0x3e, 0x0c}, {0x3f, 0x01}, {0x41, 0x40}, {0x42, 0x80},
 996         {0x45, 0x46}, {0x46, 0x62}, {0x47, 0x2a}, {0x48, 0x3c},
 997         {0x4a, 0xf0}, {0x4b, 0xdc}, {0x4c, 0xdc}, {0x4d, 0xdc},
 998         {0x4e, 0xdc}, {0x6c, 0x04}, {0x6f, 0x9e}, {0x70, 0x05},
 999         {0x71, 0x78}, {0x77, 0x02}, {0x8a, 0x23}, {0x90, 0x7e},
1000         {0x91, 0x7c}, {0x9f, 0x6e}, {0xa0, 0x6e}, {0xa5, 0x68},
1001         {0xa6, 0x60}, {0xa8, 0xc1}, {0xa9, 0xfa}, {0xaa, 0x92},
1002         {0xab, 0x04}, {0xac, 0x80}, {0xad, 0x80}, {0xae, 0x80},
1003         {0xaf, 0x80}, {0xb2, 0xf2}, {0xb3, 0x20}, {0xb5, 0x00},
1004         {0xb6, 0xaf}, {0xbb, 0xae}, {0xbc, 0x44}, {0xbd, 0x44},
1005         {0xbe, 0x3b}, {0xbf, 0x3a}, {0xc1, 0xc8}, {0xc2, 0x01},
1006         {0xc4, 0x00}, {0xc6, 0x85}, {0xc7, 0x81}, {0xc9, 0xe0},
1007         {0xca, 0xe8}, {0xcc, 0xd8}, {0xcd, 0x93}, {0x2d, 0x00},
1008         {0x2e, 0x00}, {0x01, 0x80}, {0x02, 0x80}, {0x12, 0x61},
1009         {0x36, 0xfa}, {0x8c, 0x8d}, {0xc0, 0xaa}, {0x69, 0x0a},
1010         {0x03, 0x09}, {0x17, 0x16}, {0x18, 0x6e}, {0x19, 0x01},
1011         {0x1a, 0x3e}, {0x32, 0x09}, {0x2a, 0x10}, {0x2b, 0x0a},
1012         {0x92, 0x00}, {0x93, 0x00}, {0xa1, 0x00}, {0x10, 0x7c},
1013         {0x04, 0x03}, {0x00, 0x13},
1014 };
1015
1016 static struct i2c_reg_u16 mt9v112_init[] = {
1017         {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0020},
1018         {0x34, 0xc019}, {0x0a, 0x0011}, {0x0b, 0x000b},
1019         {0x20, 0x0703}, {0x35, 0x2022}, {0xf0, 0x0001},
1020         {0x05, 0x0000}, {0x06, 0x340c}, {0x3b, 0x042a},
1021         {0x3c, 0x0400}, {0xf0, 0x0002}, {0x2e, 0x0c58},
1022         {0x5b, 0x0001}, {0xc8, 0x9f0b}, {0xf0, 0x0001},
1023         {0x9b, 0x5300}, {0xf0, 0x0000}, {0x2b, 0x0020},
1024         {0x2c, 0x002a}, {0x2d, 0x0032}, {0x2e, 0x0020},
1025         {0x09, 0x01dc}, {0x01, 0x000c}, {0x02, 0x0020},
1026         {0x03, 0x01e0}, {0x04, 0x0280}, {0x06, 0x000c},
1027         {0x05, 0x0098}, {0x20, 0x0703}, {0x09, 0x01f2},
1028         {0x2b, 0x00a0}, {0x2c, 0x00a0}, {0x2d, 0x00a0},
1029         {0x2e, 0x00a0}, {0x01, 0x000c}, {0x02, 0x0020},
1030         {0x03, 0x01e0}, {0x04, 0x0280}, {0x06, 0x000c},
1031         {0x05, 0x0098}, {0x09, 0x01c1}, {0x2b, 0x00ae},
1032         {0x2c, 0x00ae}, {0x2d, 0x00ae}, {0x2e, 0x00ae},
1033 };
1034
1035 static struct i2c_reg_u16 mt9v111_init[] = {
1036         {0x01, 0x0004}, {0x0d, 0x0001}, {0x0d, 0x0000},
1037         {0x01, 0x0001}, {0x05, 0x0004}, {0x2d, 0xe0a0},
1038         {0x2e, 0x0c64}, {0x2f, 0x0064}, {0x06, 0x600e},
1039         {0x08, 0x0480}, {0x01, 0x0004}, {0x02, 0x0016},
1040         {0x03, 0x01e7}, {0x04, 0x0287}, {0x05, 0x0004},
1041         {0x06, 0x002d}, {0x07, 0x3002}, {0x08, 0x0008},
1042         {0x0e, 0x0008}, {0x20, 0x0000}
1043 };
1044
1045 static struct i2c_reg_u16 mt9v011_init[] = {
1046         {0x07, 0x0002}, {0x0d, 0x0001}, {0x0d, 0x0000},
1047         {0x01, 0x0008}, {0x02, 0x0016}, {0x03, 0x01e1},
1048         {0x04, 0x0281}, {0x05, 0x0083}, {0x06, 0x0006},
1049         {0x0d, 0x0002}, {0x0a, 0x0000}, {0x0b, 0x0000},
1050         {0x0c, 0x0000}, {0x0d, 0x0000}, {0x0e, 0x0000},
1051         {0x0f, 0x0000}, {0x10, 0x0000}, {0x11, 0x0000},
1052         {0x12, 0x0000}, {0x13, 0x0000}, {0x14, 0x0000},
1053         {0x15, 0x0000}, {0x16, 0x0000}, {0x17, 0x0000},
1054         {0x18, 0x0000}, {0x19, 0x0000}, {0x1a, 0x0000},
1055         {0x1b, 0x0000}, {0x1c, 0x0000}, {0x1d, 0x0000},
1056         {0x32, 0x0000}, {0x20, 0x1101}, {0x21, 0x0000},
1057         {0x22, 0x0000}, {0x23, 0x0000}, {0x24, 0x0000},
1058         {0x25, 0x0000}, {0x26, 0x0000}, {0x27, 0x0024},
1059         {0x2f, 0xf7b0}, {0x30, 0x0005}, {0x31, 0x0000},
1060         {0x32, 0x0000}, {0x33, 0x0000}, {0x34, 0x0100},
1061         {0x3d, 0x068f}, {0x40, 0x01e0}, {0x41, 0x00d1},
1062         {0x44, 0x0082}, {0x5a, 0x0000}, {0x5b, 0x0000},
1063         {0x5c, 0x0000}, {0x5d, 0x0000}, {0x5e, 0x0000},
1064         {0x5f, 0xa31d}, {0x62, 0x0611}, {0x0a, 0x0000},
1065         {0x06, 0x0029}, {0x05, 0x0009}, {0x20, 0x1101},
1066         {0x20, 0x1101}, {0x09, 0x0064}, {0x07, 0x0003},
1067         {0x2b, 0x0033}, {0x2c, 0x00a0}, {0x2d, 0x00a0},
1068         {0x2e, 0x0033}, {0x07, 0x0002}, {0x06, 0x0000},
1069         {0x06, 0x0029}, {0x05, 0x0009},
1070 };
1071
1072 static struct i2c_reg_u16 mt9m001_init[] = {
1073         {0x0d, 0x0001},
1074         {0x0d, 0x0000},
1075         {0x04, 0x0500},         /* hres = 1280 */
1076         {0x03, 0x0400},         /* vres = 1024 */
1077         {0x20, 0x1100},
1078         {0x06, 0x0010},
1079         {0x2b, 0x0024},
1080         {0x2e, 0x0024},
1081         {0x35, 0x0024},
1082         {0x2d, 0x0020},
1083         {0x2c, 0x0020},
1084         {0x09, 0x0ad4},
1085         {0x35, 0x0057},
1086 };
1087
1088 static struct i2c_reg_u16 mt9m111_init[] = {
1089         {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0008},
1090         {0xf0, 0x0001}, {0x3a, 0x4300}, {0x9b, 0x4300},
1091         {0x06, 0x708e}, {0xf0, 0x0002}, {0x2e, 0x0a1e},
1092         {0xf0, 0x0000},
1093 };
1094
1095 static struct i2c_reg_u16 mt9m112_init[] = {
1096         {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0008},
1097         {0xf0, 0x0001}, {0x3a, 0x4300}, {0x9b, 0x4300},
1098         {0x06, 0x708e}, {0xf0, 0x0002}, {0x2e, 0x0a1e},
1099         {0xf0, 0x0000},
1100 };
1101
1102 static struct i2c_reg_u8 hv7131r_init[] = {
1103         {0x02, 0x08}, {0x02, 0x00}, {0x01, 0x08},
1104         {0x02, 0x00}, {0x20, 0x00}, {0x21, 0xd0},
1105         {0x22, 0x00}, {0x23, 0x09}, {0x01, 0x08},
1106         {0x01, 0x08}, {0x01, 0x08}, {0x25, 0x07},
1107         {0x26, 0xc3}, {0x27, 0x50}, {0x30, 0x62},
1108         {0x31, 0x10}, {0x32, 0x06}, {0x33, 0x10},
1109         {0x20, 0x00}, {0x21, 0xd0}, {0x22, 0x00},
1110         {0x23, 0x09}, {0x01, 0x08},
1111 };
1112
1113 static int reg_r(struct gspca_dev *gspca_dev, u16 reg, u16 length)
1114 {
1115         struct usb_device *dev = gspca_dev->dev;
1116         int result;
1117         result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1118                         0x00,
1119                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1120                         reg,
1121                         0x00,
1122                         gspca_dev->usb_buf,
1123                         length,
1124                         500);
1125         if (unlikely(result < 0 || result != length)) {
1126                 err("Read register failed 0x%02X", reg);
1127                 return -EIO;
1128         }
1129         return 0;
1130 }
1131
1132 static int reg_w(struct gspca_dev *gspca_dev, u16 reg,
1133                  const u8 *buffer, int length)
1134 {
1135         struct usb_device *dev = gspca_dev->dev;
1136         int result;
1137         memcpy(gspca_dev->usb_buf, buffer, length);
1138         result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1139                         0x08,
1140                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1141                         reg,
1142                         0x00,
1143                         gspca_dev->usb_buf,
1144                         length,
1145                         500);
1146         if (unlikely(result < 0 || result != length)) {
1147                 err("Write register failed index 0x%02X", reg);
1148                 return -EIO;
1149         }
1150         return 0;
1151 }
1152
1153 static int reg_w1(struct gspca_dev *gspca_dev, u16 reg, const u8 value)
1154 {
1155         u8 data[1] = {value};
1156         return reg_w(gspca_dev, reg, data, 1);
1157 }
1158
1159 static int i2c_w(struct gspca_dev *gspca_dev, const u8 *buffer)
1160 {
1161         int i;
1162         reg_w(gspca_dev, 0x10c0, buffer, 8);
1163         for (i = 0; i < 5; i++) {
1164                 reg_r(gspca_dev, 0x10c0, 1);
1165                 if (gspca_dev->usb_buf[0] & 0x04) {
1166                         if (gspca_dev->usb_buf[0] & 0x08)
1167                                 return -EIO;
1168                         return 0;
1169                 }
1170                 msleep(1);
1171         }
1172         return -EIO;
1173 }
1174
1175 static int i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
1176 {
1177         struct sd *sd = (struct sd *) gspca_dev;
1178
1179         u8 row[8];
1180
1181         /*
1182          * from the point of view of the bridge, the length
1183          * includes the address
1184          */
1185         row[0] = 0x81 | (2 << 4);
1186         row[1] = sd->i2c_addr;
1187         row[2] = reg;
1188         row[3] = val;
1189         row[4] = 0x00;
1190         row[5] = 0x00;
1191         row[6] = 0x00;
1192         row[7] = 0x10;
1193
1194         return i2c_w(gspca_dev, row);
1195 }
1196
1197 static int i2c_w2(struct gspca_dev *gspca_dev, u8 reg, u16 val)
1198 {
1199         struct sd *sd = (struct sd *) gspca_dev;
1200         u8 row[8];
1201
1202         /*
1203          * from the point of view of the bridge, the length
1204          * includes the address
1205          */
1206         row[0] = 0x81 | (3 << 4);
1207         row[1] = sd->i2c_addr;
1208         row[2] = reg;
1209         row[3] = (val >> 8) & 0xff;
1210         row[4] = val & 0xff;
1211         row[5] = 0x00;
1212         row[6] = 0x00;
1213         row[7] = 0x10;
1214
1215         return i2c_w(gspca_dev, row);
1216 }
1217
1218 static int i2c_r1(struct gspca_dev *gspca_dev, u8 reg, u8 *val)
1219 {
1220         struct sd *sd = (struct sd *) gspca_dev;
1221         u8 row[8];
1222
1223         row[0] = 0x81 | (1 << 4);
1224         row[1] = sd->i2c_addr;
1225         row[2] = reg;
1226         row[3] = 0;
1227         row[4] = 0;
1228         row[5] = 0;
1229         row[6] = 0;
1230         row[7] = 0x10;
1231         if (i2c_w(gspca_dev, row) < 0)
1232                 return -EIO;
1233         row[0] = 0x81 | (1 << 4) | 0x02;
1234         row[2] = 0;
1235         if (i2c_w(gspca_dev, row) < 0)
1236                 return -EIO;
1237         if (reg_r(gspca_dev, 0x10c2, 5) < 0)
1238                 return -EIO;
1239         *val = gspca_dev->usb_buf[4];
1240         return 0;
1241 }
1242
1243 static int i2c_r2(struct gspca_dev *gspca_dev, u8 reg, u16 *val)
1244 {
1245         struct sd *sd = (struct sd *) gspca_dev;
1246         u8 row[8];
1247
1248         row[0] = 0x81 | (1 << 4);
1249         row[1] = sd->i2c_addr;
1250         row[2] = reg;
1251         row[3] = 0;
1252         row[4] = 0;
1253         row[5] = 0;
1254         row[6] = 0;
1255         row[7] = 0x10;
1256         if (i2c_w(gspca_dev, row) < 0)
1257                 return -EIO;
1258         row[0] = 0x81 | (2 << 4) | 0x02;
1259         row[2] = 0;
1260         if (i2c_w(gspca_dev, row) < 0)
1261                 return -EIO;
1262         if (reg_r(gspca_dev, 0x10c2, 5) < 0)
1263                 return -EIO;
1264         *val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
1265         return 0;
1266 }
1267
1268 static int ov9650_init_sensor(struct gspca_dev *gspca_dev)
1269 {
1270         int i;
1271         u16 id;
1272         struct sd *sd = (struct sd *) gspca_dev;
1273
1274         if (i2c_r2(gspca_dev, 0x1c, &id) < 0)
1275                 return -EINVAL;
1276
1277         if (id != 0x7fa2) {
1278                 err("sensor id for ov9650 doesn't match (0x%04x)", id);
1279                 return -ENODEV;
1280         }
1281
1282         for (i = 0; i < ARRAY_SIZE(ov9650_init); i++) {
1283                 if (i2c_w1(gspca_dev, ov9650_init[i].reg,
1284                                 ov9650_init[i].val) < 0) {
1285                         err("OV9650 sensor initialization failed");
1286                         return -ENODEV;
1287                 }
1288         }
1289         sd->hstart = 1;
1290         sd->vstart = 7;
1291         return 0;
1292 }
1293
1294 static int ov9655_init_sensor(struct gspca_dev *gspca_dev)
1295 {
1296         int i;
1297         struct sd *sd = (struct sd *) gspca_dev;
1298
1299         for (i = 0; i < ARRAY_SIZE(ov9655_init); i++) {
1300                 if (i2c_w1(gspca_dev, ov9655_init[i].reg,
1301                                 ov9655_init[i].val) < 0) {
1302                         err("OV9655 sensor initialization failed");
1303                         return -ENODEV;
1304                 }
1305         }
1306         /* disable hflip and vflip */
1307         gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX);
1308         sd->hstart = 1;
1309         sd->vstart = 2;
1310         return 0;
1311 }
1312
1313 static int soi968_init_sensor(struct gspca_dev *gspca_dev)
1314 {
1315         int i;
1316         struct sd *sd = (struct sd *) gspca_dev;
1317
1318         for (i = 0; i < ARRAY_SIZE(soi968_init); i++) {
1319                 if (i2c_w1(gspca_dev, soi968_init[i].reg,
1320                                 soi968_init[i].val) < 0) {
1321                         err("SOI968 sensor initialization failed");
1322                         return -ENODEV;
1323                 }
1324         }
1325         /* disable hflip and vflip */
1326         gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX)
1327                                 | (1 << EXPOSURE_IDX);
1328         sd->hstart = 60;
1329         sd->vstart = 11;
1330         return 0;
1331 }
1332
1333 static int ov7660_init_sensor(struct gspca_dev *gspca_dev)
1334 {
1335         int i;
1336         struct sd *sd = (struct sd *) gspca_dev;
1337
1338         for (i = 0; i < ARRAY_SIZE(ov7660_init); i++) {
1339                 if (i2c_w1(gspca_dev, ov7660_init[i].reg,
1340                                 ov7660_init[i].val) < 0) {
1341                         err("OV7660 sensor initialization failed");
1342                         return -ENODEV;
1343                 }
1344         }
1345         sd->hstart = 3;
1346         sd->vstart = 3;
1347         return 0;
1348 }
1349
1350 static int ov7670_init_sensor(struct gspca_dev *gspca_dev)
1351 {
1352         int i;
1353         struct sd *sd = (struct sd *) gspca_dev;
1354
1355         for (i = 0; i < ARRAY_SIZE(ov7670_init); i++) {
1356                 if (i2c_w1(gspca_dev, ov7670_init[i].reg,
1357                                 ov7670_init[i].val) < 0) {
1358                         err("OV7670 sensor initialization failed");
1359                         return -ENODEV;
1360                 }
1361         }
1362         /* disable hflip and vflip */
1363         gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX);
1364         sd->hstart = 0;
1365         sd->vstart = 1;
1366         return 0;
1367 }
1368
1369 static int mt9v_init_sensor(struct gspca_dev *gspca_dev)
1370 {
1371         struct sd *sd = (struct sd *) gspca_dev;
1372         int i;
1373         u16 value;
1374         int ret;
1375
1376         sd->i2c_addr = 0x5d;
1377         ret = i2c_r2(gspca_dev, 0xff, &value);
1378         if ((ret == 0) && (value == 0x8243)) {
1379                 for (i = 0; i < ARRAY_SIZE(mt9v011_init); i++) {
1380                         if (i2c_w2(gspca_dev, mt9v011_init[i].reg,
1381                                         mt9v011_init[i].val) < 0) {
1382                                 err("MT9V011 sensor initialization failed");
1383                                 return -ENODEV;
1384                         }
1385                 }
1386                 sd->hstart = 2;
1387                 sd->vstart = 2;
1388                 sd->sensor = SENSOR_MT9V011;
1389                 info("MT9V011 sensor detected");
1390                 return 0;
1391         }
1392
1393         sd->i2c_addr = 0x5c;
1394         i2c_w2(gspca_dev, 0x01, 0x0004);
1395         ret = i2c_r2(gspca_dev, 0xff, &value);
1396         if ((ret == 0) && (value == 0x823a)) {
1397                 for (i = 0; i < ARRAY_SIZE(mt9v111_init); i++) {
1398                         if (i2c_w2(gspca_dev, mt9v111_init[i].reg,
1399                                         mt9v111_init[i].val) < 0) {
1400                                 err("MT9V111 sensor initialization failed");
1401                                 return -ENODEV;
1402                         }
1403                 }
1404                 gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX)
1405                                         | (1 << AUTOGAIN_IDX)
1406                                         | (1 << GAIN_IDX);
1407                 sd->hstart = 2;
1408                 sd->vstart = 2;
1409                 sd->sensor = SENSOR_MT9V111;
1410                 info("MT9V111 sensor detected");
1411                 return 0;
1412         }
1413
1414         sd->i2c_addr = 0x5d;
1415         ret = i2c_w2(gspca_dev, 0xf0, 0x0000);
1416         if (ret < 0) {
1417                 sd->i2c_addr = 0x48;
1418                 i2c_w2(gspca_dev, 0xf0, 0x0000);
1419         }
1420         ret = i2c_r2(gspca_dev, 0x00, &value);
1421         if ((ret == 0) && (value == 0x1229)) {
1422                 for (i = 0; i < ARRAY_SIZE(mt9v112_init); i++) {
1423                         if (i2c_w2(gspca_dev, mt9v112_init[i].reg,
1424                                         mt9v112_init[i].val) < 0) {
1425                                 err("MT9V112 sensor initialization failed");
1426                                 return -ENODEV;
1427                         }
1428                 }
1429                 sd->hstart = 6;
1430                 sd->vstart = 2;
1431                 sd->sensor = SENSOR_MT9V112;
1432                 info("MT9V112 sensor detected");
1433                 return 0;
1434         }
1435
1436         return -ENODEV;
1437 }
1438
1439 static int mt9m112_init_sensor(struct gspca_dev *gspca_dev)
1440 {
1441         struct sd *sd = (struct sd *) gspca_dev;
1442         int i;
1443         for (i = 0; i < ARRAY_SIZE(mt9m112_init); i++) {
1444                 if (i2c_w2(gspca_dev, mt9m112_init[i].reg,
1445                                 mt9m112_init[i].val) < 0) {
1446                         err("MT9M112 sensor initialization failed");
1447                         return -ENODEV;
1448                 }
1449         }
1450         gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX)
1451                                 | (1 << GAIN_IDX);
1452         sd->hstart = 0;
1453         sd->vstart = 2;
1454         return 0;
1455 }
1456
1457 static int mt9m111_init_sensor(struct gspca_dev *gspca_dev)
1458 {
1459         struct sd *sd = (struct sd *) gspca_dev;
1460         int i;
1461         for (i = 0; i < ARRAY_SIZE(mt9m111_init); i++) {
1462                 if (i2c_w2(gspca_dev, mt9m111_init[i].reg,
1463                                 mt9m111_init[i].val) < 0) {
1464                         err("MT9M111 sensor initialization failed");
1465                         return -ENODEV;
1466                 }
1467         }
1468         gspca_dev->ctrl_dis = (1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX)
1469                                 | (1 << GAIN_IDX);
1470         sd->hstart = 0;
1471         sd->vstart = 2;
1472         return 0;
1473 }
1474
1475 static int mt9m001_init_sensor(struct gspca_dev *gspca_dev)
1476 {
1477         struct sd *sd = (struct sd *) gspca_dev;
1478         int i;
1479         u16 id;
1480
1481         if (i2c_r2(gspca_dev, 0x00, &id) < 0)
1482                 return -EINVAL;
1483
1484         /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */
1485         switch (id) {
1486         case 0x8411:
1487         case 0x8421:
1488                 info("MT9M001 color sensor detected");
1489                 break;
1490         case 0x8431:
1491                 info("MT9M001 mono sensor detected");
1492                 break;
1493         default:
1494                 err("No MT9M001 chip detected, ID = %x\n", id);
1495                 return -ENODEV;
1496         }
1497
1498         for (i = 0; i < ARRAY_SIZE(mt9m001_init); i++) {
1499                 if (i2c_w2(gspca_dev, mt9m001_init[i].reg,
1500                                 mt9m001_init[i].val) < 0) {
1501                         err("MT9M001 sensor initialization failed");
1502                         return -ENODEV;
1503                 }
1504         }
1505         /* disable hflip and vflip */
1506         gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX);
1507         sd->hstart = 1;
1508         sd->vstart = 1;
1509         return 0;
1510 }
1511
1512 static int hv7131r_init_sensor(struct gspca_dev *gspca_dev)
1513 {
1514         int i;
1515         struct sd *sd = (struct sd *) gspca_dev;
1516
1517         for (i = 0; i < ARRAY_SIZE(hv7131r_init); i++) {
1518                 if (i2c_w1(gspca_dev, hv7131r_init[i].reg,
1519                                 hv7131r_init[i].val) < 0) {
1520                         err("HV7131R Sensor initialization failed");
1521                         return -ENODEV;
1522                 }
1523         }
1524         sd->hstart = 0;
1525         sd->vstart = 1;
1526         return 0;
1527 }
1528
1529 static int set_cmatrix(struct gspca_dev *gspca_dev)
1530 {
1531         struct sd *sd = (struct sd *) gspca_dev;
1532         s32 hue_coord, hue_index = 180 + sd->hue;
1533         u8 cmatrix[21];
1534
1535         memset(cmatrix, 0, sizeof cmatrix);
1536         cmatrix[2] = (sd->contrast * 0x25 / 0x100) + 0x26;
1537         cmatrix[0] = 0x13 + (cmatrix[2] - 0x26) * 0x13 / 0x25;
1538         cmatrix[4] = 0x07 + (cmatrix[2] - 0x26) * 0x07 / 0x25;
1539         cmatrix[18] = sd->brightness - 0x80;
1540
1541         hue_coord = (hsv_red_x[hue_index] * sd->saturation) >> 8;
1542         cmatrix[6] = hue_coord;
1543         cmatrix[7] = (hue_coord >> 8) & 0x0f;
1544
1545         hue_coord = (hsv_red_y[hue_index] * sd->saturation) >> 8;
1546         cmatrix[8] = hue_coord;
1547         cmatrix[9] = (hue_coord >> 8) & 0x0f;
1548
1549         hue_coord = (hsv_green_x[hue_index] * sd->saturation) >> 8;
1550         cmatrix[10] = hue_coord;
1551         cmatrix[11] = (hue_coord >> 8) & 0x0f;
1552
1553         hue_coord = (hsv_green_y[hue_index] * sd->saturation) >> 8;
1554         cmatrix[12] = hue_coord;
1555         cmatrix[13] = (hue_coord >> 8) & 0x0f;
1556
1557         hue_coord = (hsv_blue_x[hue_index] * sd->saturation) >> 8;
1558         cmatrix[14] = hue_coord;
1559         cmatrix[15] = (hue_coord >> 8) & 0x0f;
1560
1561         hue_coord = (hsv_blue_y[hue_index] * sd->saturation) >> 8;
1562         cmatrix[16] = hue_coord;
1563         cmatrix[17] = (hue_coord >> 8) & 0x0f;
1564
1565         return reg_w(gspca_dev, 0x10e1, cmatrix, 21);
1566 }
1567
1568 static int set_gamma(struct gspca_dev *gspca_dev)
1569 {
1570         struct sd *sd = (struct sd *) gspca_dev;
1571         u8 gamma[17];
1572         u8 gval = sd->gamma * 0xb8 / 0x100;
1573
1574
1575         gamma[0] = 0x0a;
1576         gamma[1] = 0x13 + (gval * (0xcb - 0x13) / 0xb8);
1577         gamma[2] = 0x25 + (gval * (0xee - 0x25) / 0xb8);
1578         gamma[3] = 0x37 + (gval * (0xfa - 0x37) / 0xb8);
1579         gamma[4] = 0x45 + (gval * (0xfc - 0x45) / 0xb8);
1580         gamma[5] = 0x55 + (gval * (0xfb - 0x55) / 0xb8);
1581         gamma[6] = 0x65 + (gval * (0xfc - 0x65) / 0xb8);
1582         gamma[7] = 0x74 + (gval * (0xfd - 0x74) / 0xb8);
1583         gamma[8] = 0x83 + (gval * (0xfe - 0x83) / 0xb8);
1584         gamma[9] = 0x92 + (gval * (0xfc - 0x92) / 0xb8);
1585         gamma[10] = 0xa1 + (gval * (0xfc - 0xa1) / 0xb8);
1586         gamma[11] = 0xb0 + (gval * (0xfc - 0xb0) / 0xb8);
1587         gamma[12] = 0xbf + (gval * (0xfb - 0xbf) / 0xb8);
1588         gamma[13] = 0xce + (gval * (0xfb - 0xce) / 0xb8);
1589         gamma[14] = 0xdf + (gval * (0xfd - 0xdf) / 0xb8);
1590         gamma[15] = 0xea + (gval * (0xf9 - 0xea) / 0xb8);
1591         gamma[16] = 0xf5;
1592
1593         return reg_w(gspca_dev, 0x1190, gamma, 17);
1594 }
1595
1596 static int set_redblue(struct gspca_dev *gspca_dev)
1597 {
1598         struct sd *sd = (struct sd *) gspca_dev;
1599         reg_w1(gspca_dev, 0x118c, sd->red);
1600         reg_w1(gspca_dev, 0x118f, sd->blue);
1601         return 0;
1602 }
1603
1604 static int set_hvflip(struct gspca_dev *gspca_dev)
1605 {
1606         u8 value, tslb, hflip, vflip;
1607         u16 value2;
1608         struct sd *sd = (struct sd *) gspca_dev;
1609
1610         if ((sd->flags & FLIP_DETECT) && dmi_check_system(flip_dmi_table)) {
1611                 hflip = !sd->hflip;
1612                 vflip = !sd->vflip;
1613         } else {
1614                 hflip = sd->hflip;
1615                 vflip = sd->vflip;
1616         }
1617
1618         switch (sd->sensor) {
1619         case SENSOR_OV7660:
1620                 value = 0x01;
1621                 if (hflip)
1622                         value |= 0x20;
1623                 if (vflip) {
1624                         value |= 0x10;
1625                         sd->vstart = 2;
1626                 } else
1627                         sd->vstart = 3;
1628                 reg_w1(gspca_dev, 0x1182, sd->vstart);
1629                 i2c_w1(gspca_dev, 0x1e, value);
1630                 break;
1631         case SENSOR_OV9650:
1632                 i2c_r1(gspca_dev, 0x1e, &value);
1633                 value &= ~0x30;
1634                 tslb = 0x01;
1635                 if (hflip)
1636                         value |= 0x20;
1637                 if (vflip) {
1638                         value |= 0x10;
1639                         tslb = 0x49;
1640                 }
1641                 i2c_w1(gspca_dev, 0x1e, value);
1642                 i2c_w1(gspca_dev, 0x3a, tslb);
1643                 break;
1644         case SENSOR_MT9V111:
1645         case SENSOR_MT9V011:
1646                 i2c_r2(gspca_dev, 0x20, &value2);
1647                 value2 &= ~0xc0a0;
1648                 if (hflip)
1649                         value2 |= 0x8080;
1650                 if (vflip)
1651                         value2 |= 0x4020;
1652                 i2c_w2(gspca_dev, 0x20, value2);
1653                 break;
1654         case SENSOR_MT9M112:
1655         case SENSOR_MT9M111:
1656         case SENSOR_MT9V112:
1657                 i2c_r2(gspca_dev, 0x20, &value2);
1658                 value2 &= ~0x0003;
1659                 if (hflip)
1660                         value2 |= 0x0002;
1661                 if (vflip)
1662                         value2 |= 0x0001;
1663                 i2c_w2(gspca_dev, 0x20, value2);
1664                 break;
1665         case SENSOR_HV7131R:
1666                 i2c_r1(gspca_dev, 0x01, &value);
1667                 value &= ~0x03;
1668                 if (vflip)
1669                         value |= 0x01;
1670                 if (hflip)
1671                         value |= 0x02;
1672                 i2c_w1(gspca_dev, 0x01, value);
1673                 break;
1674         }
1675         return 0;
1676 }
1677
1678 static int set_exposure(struct gspca_dev *gspca_dev)
1679 {
1680         struct sd *sd = (struct sd *) gspca_dev;
1681         u8 exp[8] = {0x81, sd->i2c_addr, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e};
1682         switch (sd->sensor) {
1683         case SENSOR_OV7660:
1684         case SENSOR_OV7670:
1685         case SENSOR_OV9655:
1686         case SENSOR_OV9650:
1687                 exp[0] |= (3 << 4);
1688                 exp[2] = 0x2d;
1689                 exp[3] = sd->exposure & 0xff;
1690                 exp[4] = sd->exposure >> 8;
1691                 break;
1692         case SENSOR_MT9M001:
1693         case SENSOR_MT9V112:
1694         case SENSOR_MT9V011:
1695                 exp[0] |= (3 << 4);
1696                 exp[2] = 0x09;
1697                 exp[3] = sd->exposure >> 8;
1698                 exp[4] = sd->exposure & 0xff;
1699                 break;
1700         case SENSOR_HV7131R:
1701                 exp[0] |= (4 << 4);
1702                 exp[2] = 0x25;
1703                 exp[3] = (sd->exposure >> 5) & 0xff;
1704                 exp[4] = (sd->exposure << 3) & 0xff;
1705                 exp[5] = 0;
1706                 break;
1707         default:
1708                 return 0;
1709         }
1710         i2c_w(gspca_dev, exp);
1711         return 0;
1712 }
1713
1714 static int set_gain(struct gspca_dev *gspca_dev)
1715 {
1716         struct sd *sd = (struct sd *) gspca_dev;
1717         u8 gain[8] = {0x81, sd->i2c_addr, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d};
1718         switch (sd->sensor) {
1719         case SENSOR_OV7660:
1720         case SENSOR_OV7670:
1721         case SENSOR_SOI968:
1722         case SENSOR_OV9655:
1723         case SENSOR_OV9650:
1724                 gain[0] |= (2 << 4);
1725                 gain[3] = ov_gain[sd->gain];
1726                 break;
1727         case SENSOR_MT9V011:
1728                 gain[0] |= (3 << 4);
1729                 gain[2] = 0x35;
1730                 gain[3] = micron1_gain[sd->gain] >> 8;
1731                 gain[4] = micron1_gain[sd->gain] & 0xff;
1732                 break;
1733         case SENSOR_MT9V112:
1734                 gain[0] |= (3 << 4);
1735                 gain[2] = 0x2f;
1736                 gain[3] = micron1_gain[sd->gain] >> 8;
1737                 gain[4] = micron1_gain[sd->gain] & 0xff;
1738                 break;
1739         case SENSOR_MT9M001:
1740                 gain[0] |= (3 << 4);
1741                 gain[2] = 0x2f;
1742                 gain[3] = micron2_gain[sd->gain] >> 8;
1743                 gain[4] = micron2_gain[sd->gain] & 0xff;
1744                 break;
1745         case SENSOR_HV7131R:
1746                 gain[0] |= (2 << 4);
1747                 gain[2] = 0x30;
1748                 gain[3] = hv7131r_gain[sd->gain];
1749                 break;
1750         default:
1751                 return 0;
1752         }
1753         i2c_w(gspca_dev, gain);
1754         return 0;
1755 }
1756
1757 static int sd_setbrightness(struct gspca_dev *gspca_dev, s32 val)
1758 {
1759         struct sd *sd = (struct sd *) gspca_dev;
1760
1761         sd->brightness = val;
1762         if (gspca_dev->streaming)
1763                 return set_cmatrix(gspca_dev);
1764         return 0;
1765 }
1766
1767 static int sd_getbrightness(struct gspca_dev *gspca_dev, s32 *val)
1768 {
1769         struct sd *sd = (struct sd *) gspca_dev;
1770         *val = sd->brightness;
1771         return 0;
1772 }
1773
1774
1775 static int sd_setcontrast(struct gspca_dev *gspca_dev, s32 val)
1776 {
1777         struct sd *sd = (struct sd *) gspca_dev;
1778
1779         sd->contrast = val;
1780         if (gspca_dev->streaming)
1781                 return set_cmatrix(gspca_dev);
1782         return 0;
1783 }
1784
1785 static int sd_getcontrast(struct gspca_dev *gspca_dev, s32 *val)
1786 {
1787         struct sd *sd = (struct sd *) gspca_dev;
1788         *val = sd->contrast;
1789         return 0;
1790 }
1791
1792 static int sd_setsaturation(struct gspca_dev *gspca_dev, s32 val)
1793 {
1794         struct sd *sd = (struct sd *) gspca_dev;
1795
1796         sd->saturation = val;
1797         if (gspca_dev->streaming)
1798                 return set_cmatrix(gspca_dev);
1799         return 0;
1800 }
1801
1802 static int sd_getsaturation(struct gspca_dev *gspca_dev, s32 *val)
1803 {
1804         struct sd *sd = (struct sd *) gspca_dev;
1805         *val = sd->saturation;
1806         return 0;
1807 }
1808
1809 static int sd_sethue(struct gspca_dev *gspca_dev, s32 val)
1810 {
1811         struct sd *sd = (struct sd *) gspca_dev;
1812
1813         sd->hue = val;
1814         if (gspca_dev->streaming)
1815                 return set_cmatrix(gspca_dev);
1816         return 0;
1817 }
1818
1819 static int sd_gethue(struct gspca_dev *gspca_dev, s32 *val)
1820 {
1821         struct sd *sd = (struct sd *) gspca_dev;
1822         *val = sd->hue;
1823         return 0;
1824 }
1825
1826 static int sd_setgamma(struct gspca_dev *gspca_dev, s32 val)
1827 {
1828         struct sd *sd = (struct sd *) gspca_dev;
1829
1830         sd->gamma = val;
1831         if (gspca_dev->streaming)
1832                 return set_gamma(gspca_dev);
1833         return 0;
1834 }
1835
1836 static int sd_getgamma(struct gspca_dev *gspca_dev, s32 *val)
1837 {
1838         struct sd *sd = (struct sd *) gspca_dev;
1839         *val = sd->gamma;
1840         return 0;
1841 }
1842
1843 static int sd_setredbalance(struct gspca_dev *gspca_dev, s32 val)
1844 {
1845         struct sd *sd = (struct sd *) gspca_dev;
1846
1847         sd->red = val;
1848         if (gspca_dev->streaming)
1849                 return set_redblue(gspca_dev);
1850         return 0;
1851 }
1852
1853 static int sd_getredbalance(struct gspca_dev *gspca_dev, s32 *val)
1854 {
1855         struct sd *sd = (struct sd *) gspca_dev;
1856         *val = sd->red;
1857         return 0;
1858 }
1859
1860 static int sd_setbluebalance(struct gspca_dev *gspca_dev, s32 val)
1861 {
1862         struct sd *sd = (struct sd *) gspca_dev;
1863
1864         sd->blue = val;
1865         if (gspca_dev->streaming)
1866                 return set_redblue(gspca_dev);
1867         return 0;
1868 }
1869
1870 static int sd_getbluebalance(struct gspca_dev *gspca_dev, s32 *val)
1871 {
1872         struct sd *sd = (struct sd *) gspca_dev;
1873         *val = sd->blue;
1874         return 0;
1875 }
1876
1877 static int sd_sethflip(struct gspca_dev *gspca_dev, s32 val)
1878 {
1879         struct sd *sd = (struct sd *) gspca_dev;
1880
1881         sd->hflip = val;
1882         if (gspca_dev->streaming)
1883                 return set_hvflip(gspca_dev);
1884         return 0;
1885 }
1886
1887 static int sd_gethflip(struct gspca_dev *gspca_dev, s32 *val)
1888 {
1889         struct sd *sd = (struct sd *) gspca_dev;
1890         *val = sd->hflip;
1891         return 0;
1892 }
1893
1894 static int sd_setvflip(struct gspca_dev *gspca_dev, s32 val)
1895 {
1896         struct sd *sd = (struct sd *) gspca_dev;
1897
1898         sd->vflip = val;
1899         if (gspca_dev->streaming)
1900                 return set_hvflip(gspca_dev);
1901         return 0;
1902 }
1903
1904 static int sd_getvflip(struct gspca_dev *gspca_dev, s32 *val)
1905 {
1906         struct sd *sd = (struct sd *) gspca_dev;
1907         *val = sd->vflip;
1908         return 0;
1909 }
1910
1911 static int sd_setexposure(struct gspca_dev *gspca_dev, s32 val)
1912 {
1913         struct sd *sd = (struct sd *) gspca_dev;
1914
1915         sd->exposure = val;
1916         if (gspca_dev->streaming)
1917                 return set_exposure(gspca_dev);
1918         return 0;
1919 }
1920
1921 static int sd_getexposure(struct gspca_dev *gspca_dev, s32 *val)
1922 {
1923         struct sd *sd = (struct sd *) gspca_dev;
1924         *val = sd->exposure;
1925         return 0;
1926 }
1927
1928 static int sd_setgain(struct gspca_dev *gspca_dev, s32 val)
1929 {
1930         struct sd *sd = (struct sd *) gspca_dev;
1931
1932         sd->gain = val;
1933         if (gspca_dev->streaming)
1934                 return set_gain(gspca_dev);
1935         return 0;
1936 }
1937
1938 static int sd_getgain(struct gspca_dev *gspca_dev, s32 *val)
1939 {
1940         struct sd *sd = (struct sd *) gspca_dev;
1941         *val = sd->gain;
1942         return 0;
1943 }
1944
1945 static int sd_setautoexposure(struct gspca_dev *gspca_dev, s32 val)
1946 {
1947         struct sd *sd = (struct sd *) gspca_dev;
1948         sd->auto_exposure = val;
1949         return 0;
1950 }
1951
1952 static int sd_getautoexposure(struct gspca_dev *gspca_dev, s32 *val)
1953 {
1954         struct sd *sd = (struct sd *) gspca_dev;
1955         *val = sd->auto_exposure;
1956         return 0;
1957 }
1958
1959 #ifdef CONFIG_VIDEO_ADV_DEBUG
1960 static int sd_dbg_g_register(struct gspca_dev *gspca_dev,
1961                         struct v4l2_dbg_register *reg)
1962 {
1963         struct sd *sd = (struct sd *) gspca_dev;
1964         switch (reg->match.type) {
1965         case V4L2_CHIP_MATCH_HOST:
1966                 if (reg->match.addr != 0)
1967                         return -EINVAL;
1968                 if (reg->reg < 0x1000 || reg->reg > 0x11ff)
1969                         return -EINVAL;
1970                 if (reg_r(gspca_dev, reg->reg, 1) < 0)
1971                         return -EINVAL;
1972                 reg->val = gspca_dev->usb_buf[0];
1973                 return 0;
1974         case V4L2_CHIP_MATCH_I2C_ADDR:
1975                 if (reg->match.addr != sd->i2c_addr)
1976                         return -EINVAL;
1977                 if (sd->sensor >= SENSOR_MT9V011 &&
1978                     sd->sensor <= SENSOR_MT9M112) {
1979                         if (i2c_r2(gspca_dev, reg->reg, (u16 *)&reg->val) < 0)
1980                                 return -EINVAL;
1981                 } else {
1982                         if (i2c_r1(gspca_dev, reg->reg, (u8 *)&reg->val) < 0)
1983                                 return -EINVAL;
1984                 }
1985                 return 0;
1986         }
1987         return -EINVAL;
1988 }
1989
1990 static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
1991                         struct v4l2_dbg_register *reg)
1992 {
1993         struct sd *sd = (struct sd *) gspca_dev;
1994         switch (reg->match.type) {
1995         case V4L2_CHIP_MATCH_HOST:
1996                 if (reg->match.addr != 0)
1997                         return -EINVAL;
1998                 if (reg->reg < 0x1000 || reg->reg > 0x11ff)
1999                         return -EINVAL;
2000                 if (reg_w1(gspca_dev, reg->reg, reg->val) < 0)
2001                         return -EINVAL;
2002                 return 0;
2003         case V4L2_CHIP_MATCH_I2C_ADDR:
2004                 if (reg->match.addr != sd->i2c_addr)
2005                         return -EINVAL;
2006                 if (sd->sensor >= SENSOR_MT9V011 &&
2007                     sd->sensor <= SENSOR_MT9M112) {
2008                         if (i2c_w2(gspca_dev, reg->reg, reg->val) < 0)
2009                                 return -EINVAL;
2010                 } else {
2011                         if (i2c_w1(gspca_dev, reg->reg, reg->val) < 0)
2012                                 return -EINVAL;
2013                 }
2014                 return 0;
2015         }
2016         return -EINVAL;
2017 }
2018 #endif
2019
2020 static int sd_chip_ident(struct gspca_dev *gspca_dev,
2021                         struct v4l2_dbg_chip_ident *chip)
2022 {
2023         struct sd *sd = (struct sd *) gspca_dev;
2024
2025         switch (chip->match.type) {
2026         case V4L2_CHIP_MATCH_HOST:
2027                 if (chip->match.addr != 0)
2028                         return -EINVAL;
2029                 chip->revision = 0;
2030                 chip->ident = V4L2_IDENT_SN9C20X;
2031                 return 0;
2032         case V4L2_CHIP_MATCH_I2C_ADDR:
2033                 if (chip->match.addr != sd->i2c_addr)
2034                         return -EINVAL;
2035                 chip->revision = 0;
2036                 chip->ident = i2c_ident[sd->sensor];
2037                 return 0;
2038         }
2039         return -EINVAL;
2040 }
2041
2042 static int sd_config(struct gspca_dev *gspca_dev,
2043                         const struct usb_device_id *id)
2044 {
2045         struct sd *sd = (struct sd *) gspca_dev;
2046         struct cam *cam;
2047
2048         cam = &gspca_dev->cam;
2049
2050         sd->sensor = (id->driver_info >> 8) & 0xff;
2051         sd->i2c_addr = id->driver_info & 0xff;
2052         sd->flags = (id->driver_info >> 16) & 0xff;
2053
2054         switch (sd->sensor) {
2055         case SENSOR_MT9M112:
2056         case SENSOR_MT9M111:
2057         case SENSOR_OV9650:
2058         case SENSOR_SOI968:
2059                 cam->cam_mode = sxga_mode;
2060                 cam->nmodes = ARRAY_SIZE(sxga_mode);
2061                 break;
2062         case SENSOR_MT9M001:
2063                 cam->cam_mode = mono_mode;
2064                 cam->nmodes = ARRAY_SIZE(mono_mode);
2065                 break;
2066         default:
2067                 cam->cam_mode = vga_mode;
2068                 cam->nmodes = ARRAY_SIZE(vga_mode);
2069                 break;
2070         }
2071
2072         sd->old_step = 0;
2073         sd->older_step = 0;
2074         sd->exposure_step = 16;
2075
2076         sd->brightness = BRIGHTNESS_DEFAULT;
2077         sd->contrast = CONTRAST_DEFAULT;
2078         sd->saturation = SATURATION_DEFAULT;
2079         sd->hue = HUE_DEFAULT;
2080         sd->gamma = GAMMA_DEFAULT;
2081         sd->red = RED_DEFAULT;
2082         sd->blue = BLUE_DEFAULT;
2083
2084         sd->hflip = HFLIP_DEFAULT;
2085         sd->vflip = VFLIP_DEFAULT;
2086         sd->exposure = EXPOSURE_DEFAULT;
2087         sd->gain = GAIN_DEFAULT;
2088         sd->auto_exposure = AUTO_EXPOSURE_DEFAULT;
2089
2090         sd->quality = 95;
2091
2092         return 0;
2093 }
2094
2095 static int sd_init(struct gspca_dev *gspca_dev)
2096 {
2097         struct sd *sd = (struct sd *) gspca_dev;
2098         int i;
2099         u8 value;
2100         u8 i2c_init[9] =
2101                 {0x80, sd->i2c_addr, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03};
2102
2103         for (i = 0; i < ARRAY_SIZE(bridge_init); i++) {
2104                 value = bridge_init[i][1];
2105                 if (reg_w(gspca_dev, bridge_init[i][0], &value, 1) < 0) {
2106                         err("Device initialization failed");
2107                         return -ENODEV;
2108                 }
2109         }
2110
2111         if (sd->flags & LED_REVERSE)
2112                 reg_w1(gspca_dev, 0x1006, 0x00);
2113         else
2114                 reg_w1(gspca_dev, 0x1006, 0x20);
2115
2116         if (reg_w(gspca_dev, 0x10c0, i2c_init, 9) < 0) {
2117                 err("Device initialization failed");
2118                 return -ENODEV;
2119         }
2120
2121         switch (sd->sensor) {
2122         case SENSOR_OV9650:
2123                 if (ov9650_init_sensor(gspca_dev) < 0)
2124                         return -ENODEV;
2125                 info("OV9650 sensor detected");
2126                 break;
2127         case SENSOR_OV9655:
2128                 if (ov9655_init_sensor(gspca_dev) < 0)
2129                         return -ENODEV;
2130                 info("OV9655 sensor detected");
2131                 break;
2132         case SENSOR_SOI968:
2133                 if (soi968_init_sensor(gspca_dev) < 0)
2134                         return -ENODEV;
2135                 info("SOI968 sensor detected");
2136                 break;
2137         case SENSOR_OV7660:
2138                 if (ov7660_init_sensor(gspca_dev) < 0)
2139                         return -ENODEV;
2140                 info("OV7660 sensor detected");
2141                 break;
2142         case SENSOR_OV7670:
2143                 if (ov7670_init_sensor(gspca_dev) < 0)
2144                         return -ENODEV;
2145                 info("OV7670 sensor detected");
2146                 break;
2147         case SENSOR_MT9VPRB:
2148                 if (mt9v_init_sensor(gspca_dev) < 0)
2149                         return -ENODEV;
2150                 break;
2151         case SENSOR_MT9M111:
2152                 if (mt9m111_init_sensor(gspca_dev) < 0)
2153                         return -ENODEV;
2154                 info("MT9M111 sensor detected");
2155                 break;
2156         case SENSOR_MT9M112:
2157                 if (mt9m112_init_sensor(gspca_dev) < 0)
2158                         return -ENODEV;
2159                 info("MT9M112 sensor detected");
2160                 break;
2161         case SENSOR_MT9M001:
2162                 if (mt9m001_init_sensor(gspca_dev) < 0)
2163                         return -ENODEV;
2164                 break;
2165         case SENSOR_HV7131R:
2166                 if (hv7131r_init_sensor(gspca_dev) < 0)
2167                         return -ENODEV;
2168                 info("HV7131R sensor detected");
2169                 break;
2170         default:
2171                 info("Unsupported Sensor");
2172                 return -ENODEV;
2173         }
2174
2175         return 0;
2176 }
2177
2178 static void configure_sensor_output(struct gspca_dev *gspca_dev, int mode)
2179 {
2180         struct sd *sd = (struct sd *) gspca_dev;
2181         u8 value;
2182         switch (sd->sensor) {
2183         case SENSOR_SOI968:
2184                 if (mode & MODE_SXGA) {
2185                         i2c_w1(gspca_dev, 0x17, 0x1d);
2186                         i2c_w1(gspca_dev, 0x18, 0xbd);
2187                         i2c_w1(gspca_dev, 0x19, 0x01);
2188                         i2c_w1(gspca_dev, 0x1a, 0x81);
2189                         i2c_w1(gspca_dev, 0x12, 0x00);
2190                         sd->hstart = 140;
2191                         sd->vstart = 19;
2192                 } else {
2193                         i2c_w1(gspca_dev, 0x17, 0x13);
2194                         i2c_w1(gspca_dev, 0x18, 0x63);
2195                         i2c_w1(gspca_dev, 0x19, 0x01);
2196                         i2c_w1(gspca_dev, 0x1a, 0x79);
2197                         i2c_w1(gspca_dev, 0x12, 0x40);
2198                         sd->hstart = 60;
2199                         sd->vstart = 11;
2200                 }
2201                 break;
2202         case SENSOR_OV9650:
2203                 if (mode & MODE_SXGA) {
2204                         i2c_w1(gspca_dev, 0x17, 0x1b);
2205                         i2c_w1(gspca_dev, 0x18, 0xbc);
2206                         i2c_w1(gspca_dev, 0x19, 0x01);
2207                         i2c_w1(gspca_dev, 0x1a, 0x82);
2208                         i2c_r1(gspca_dev, 0x12, &value);
2209                         i2c_w1(gspca_dev, 0x12, value & 0x07);
2210                 } else {
2211                         i2c_w1(gspca_dev, 0x17, 0x24);
2212                         i2c_w1(gspca_dev, 0x18, 0xc5);
2213                         i2c_w1(gspca_dev, 0x19, 0x00);
2214                         i2c_w1(gspca_dev, 0x1a, 0x3c);
2215                         i2c_r1(gspca_dev, 0x12, &value);
2216                         i2c_w1(gspca_dev, 0x12, (value & 0x7) | 0x40);
2217                 }
2218                 break;
2219         case SENSOR_MT9M112:
2220         case SENSOR_MT9M111:
2221                 if (mode & MODE_SXGA) {
2222                         i2c_w2(gspca_dev, 0xf0, 0x0002);
2223                         i2c_w2(gspca_dev, 0xc8, 0x970b);
2224                         i2c_w2(gspca_dev, 0xf0, 0x0000);
2225                 } else {
2226                         i2c_w2(gspca_dev, 0xf0, 0x0002);
2227                         i2c_w2(gspca_dev, 0xc8, 0x8000);
2228                         i2c_w2(gspca_dev, 0xf0, 0x0000);
2229                 }
2230                 break;
2231         }
2232 }
2233
2234 #define HW_WIN(mode, hstart, vstart) \
2235 ((const u8 []){hstart, 0, vstart, 0, \
2236 (mode & MODE_SXGA ? 1280 >> 4 : 640 >> 4), \
2237 (mode & MODE_SXGA ? 1024 >> 3 : 480 >> 3)})
2238
2239 #define CLR_WIN(width, height) \
2240 ((const u8 [])\
2241 {0, width >> 2, 0, height >> 1,\
2242 ((width >> 10) & 0x01) | ((height >> 8) & 0x6)})
2243
2244 static int sd_start(struct gspca_dev *gspca_dev)
2245 {
2246         struct sd *sd = (struct sd *) gspca_dev;
2247         int mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
2248         int width = gspca_dev->width;
2249         int height = gspca_dev->height;
2250         u8 fmt, scale = 0;
2251
2252         jpeg_define(sd->jpeg_hdr, height, width,
2253                         0x21);
2254         jpeg_set_qual(sd->jpeg_hdr, sd->quality);
2255
2256         if (mode & MODE_RAW)
2257                 fmt = 0x2d;
2258         else if (mode & MODE_JPEG)
2259                 fmt = 0x2c;
2260         else
2261                 fmt = 0x2f;     /* YUV 420 */
2262
2263         switch (mode & SCALE_MASK) {
2264         case SCALE_1280x1024:
2265                 scale = 0xc0;
2266                 info("Set 1280x1024");
2267                 break;
2268         case SCALE_640x480:
2269                 scale = 0x80;
2270                 info("Set 640x480");
2271                 break;
2272         case SCALE_320x240:
2273                 scale = 0x90;
2274                 info("Set 320x240");
2275                 break;
2276         case SCALE_160x120:
2277                 scale = 0xa0;
2278                 info("Set 160x120");
2279                 break;
2280         }
2281
2282         configure_sensor_output(gspca_dev, mode);
2283         reg_w(gspca_dev, 0x1100, &sd->jpeg_hdr[JPEG_QT0_OFFSET], 64);
2284         reg_w(gspca_dev, 0x1140, &sd->jpeg_hdr[JPEG_QT1_OFFSET], 64);
2285         reg_w(gspca_dev, 0x10fb, CLR_WIN(width, height), 5);
2286         reg_w(gspca_dev, 0x1180, HW_WIN(mode, sd->hstart, sd->vstart), 6);
2287         reg_w1(gspca_dev, 0x1189, scale);
2288         reg_w1(gspca_dev, 0x10e0, fmt);
2289
2290         set_cmatrix(gspca_dev);
2291         set_gamma(gspca_dev);
2292         set_redblue(gspca_dev);
2293         set_gain(gspca_dev);
2294         set_exposure(gspca_dev);
2295         set_hvflip(gspca_dev);
2296
2297         reg_w1(gspca_dev, 0x1007, 0x20);
2298
2299         reg_r(gspca_dev, 0x1061, 1);
2300         reg_w1(gspca_dev, 0x1061, gspca_dev->usb_buf[0] | 0x02);
2301         return 0;
2302 }
2303
2304 static void sd_stopN(struct gspca_dev *gspca_dev)
2305 {
2306         reg_w1(gspca_dev, 0x1007, 0x00);
2307
2308         reg_r(gspca_dev, 0x1061, 1);
2309         reg_w1(gspca_dev, 0x1061, gspca_dev->usb_buf[0] & ~0x02);
2310 }
2311
2312 static void do_autoexposure(struct gspca_dev *gspca_dev, u16 avg_lum)
2313 {
2314         struct sd *sd = (struct sd *) gspca_dev;
2315         s16 new_exp;
2316
2317         /*
2318          * some hardcoded values are present
2319          * like those for maximal/minimal exposure
2320          * and exposure steps
2321          */
2322         if (avg_lum < MIN_AVG_LUM) {
2323                 if (sd->exposure > 0x1770)
2324                         return;
2325
2326                 new_exp = sd->exposure + sd->exposure_step;
2327                 if (new_exp > 0x1770)
2328                         new_exp = 0x1770;
2329                 if (new_exp < 0x10)
2330                         new_exp = 0x10;
2331                 sd->exposure = new_exp;
2332                 set_exposure(gspca_dev);
2333
2334                 sd->older_step = sd->old_step;
2335                 sd->old_step = 1;
2336
2337                 if (sd->old_step ^ sd->older_step)
2338                         sd->exposure_step /= 2;
2339                 else
2340                         sd->exposure_step += 2;
2341         }
2342         if (avg_lum > MAX_AVG_LUM) {
2343                 if (sd->exposure < 0x10)
2344                         return;
2345                 new_exp = sd->exposure - sd->exposure_step;
2346                 if (new_exp > 0x1700)
2347                         new_exp = 0x1770;
2348                 if (new_exp < 0x10)
2349                         new_exp = 0x10;
2350                 sd->exposure = new_exp;
2351                 set_exposure(gspca_dev);
2352                 sd->older_step = sd->old_step;
2353                 sd->old_step = 0;
2354
2355                 if (sd->old_step ^ sd->older_step)
2356                         sd->exposure_step /= 2;
2357                 else
2358                         sd->exposure_step += 2;
2359         }
2360 }
2361
2362 static void do_autogain(struct gspca_dev *gspca_dev, u16 avg_lum)
2363 {
2364         struct sd *sd = (struct sd *) gspca_dev;
2365
2366         if (avg_lum < MIN_AVG_LUM) {
2367                 if (sd->gain + 1 <= 28) {
2368                         sd->gain++;
2369                         set_gain(gspca_dev);
2370                 }
2371         }
2372         if (avg_lum > MAX_AVG_LUM) {
2373                 if (sd->gain > 0) {
2374                         sd->gain--;
2375                         set_gain(gspca_dev);
2376                 }
2377         }
2378 }
2379
2380 static void sd_dqcallback(struct gspca_dev *gspca_dev)
2381 {
2382         struct sd *sd = (struct sd *) gspca_dev;
2383         int avg_lum;
2384
2385         if (!sd->auto_exposure)
2386                 return;
2387
2388         avg_lum = atomic_read(&sd->avg_lum);
2389         if (sd->sensor == SENSOR_SOI968)
2390                 do_autogain(gspca_dev, avg_lum);
2391         else
2392                 do_autoexposure(gspca_dev, avg_lum);
2393 }
2394
2395 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2396 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
2397                         u8 *data,               /* interrupt packet */
2398                         int len)                /* interrupt packet length */
2399 {
2400         struct sd *sd = (struct sd *) gspca_dev;
2401         int ret = -EINVAL;
2402         if (!(sd->flags & HAS_NO_BUTTON) && len == 1) {
2403                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
2404                         input_sync(gspca_dev->input_dev);
2405                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
2406                         input_sync(gspca_dev->input_dev);
2407                         ret = 0;
2408         }
2409         return ret;
2410 }
2411 #endif
2412
2413 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
2414                         u8 *data,                       /* isoc packet */
2415                         int len)                        /* iso packet length */
2416 {
2417         struct sd *sd = (struct sd *) gspca_dev;
2418         int avg_lum;
2419         static u8 frame_header[] =
2420                 {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96};
2421         if (len == 64 && memcmp(data, frame_header, 6) == 0) {
2422                 avg_lum = ((data[35] >> 2) & 3) |
2423                            (data[20] << 2) |
2424                            (data[19] << 10);
2425                 avg_lum += ((data[35] >> 4) & 3) |
2426                             (data[22] << 2) |
2427                             (data[21] << 10);
2428                 avg_lum += ((data[35] >> 6) & 3) |
2429                             (data[24] << 2) |
2430                             (data[23] << 10);
2431                 avg_lum += (data[36] & 3) |
2432                            (data[26] << 2) |
2433                            (data[25] << 10);
2434                 avg_lum += ((data[36] >> 2) & 3) |
2435                             (data[28] << 2) |
2436                             (data[27] << 10);
2437                 avg_lum += ((data[36] >> 4) & 3) |
2438                             (data[30] << 2) |
2439                             (data[29] << 10);
2440                 avg_lum += ((data[36] >> 6) & 3) |
2441                             (data[32] << 2) |
2442                             (data[31] << 10);
2443                 avg_lum += ((data[44] >> 4) & 3) |
2444                             (data[34] << 2) |
2445                             (data[33] << 10);
2446                 avg_lum >>= 9;
2447                 atomic_set(&sd->avg_lum, avg_lum);
2448                 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
2449                 return;
2450         }
2451         if (gspca_dev->last_packet_type == LAST_PACKET) {
2452                 if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv
2453                                 & MODE_JPEG) {
2454                         gspca_frame_add(gspca_dev, FIRST_PACKET,
2455                                 sd->jpeg_hdr, JPEG_HDR_SZ);
2456                         gspca_frame_add(gspca_dev, INTER_PACKET,
2457                                 data, len);
2458                 } else {
2459                         gspca_frame_add(gspca_dev, FIRST_PACKET,
2460                                 data, len);
2461                 }
2462         } else {
2463                 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
2464         }
2465 }
2466
2467 /* sub-driver description */
2468 static const struct sd_desc sd_desc = {
2469         .name = MODULE_NAME,
2470         .ctrls = sd_ctrls,
2471         .nctrls = ARRAY_SIZE(sd_ctrls),
2472         .config = sd_config,
2473         .init = sd_init,
2474         .start = sd_start,
2475         .stopN = sd_stopN,
2476         .pkt_scan = sd_pkt_scan,
2477 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2478         .int_pkt_scan = sd_int_pkt_scan,
2479 #endif
2480         .dq_callback = sd_dqcallback,
2481 #ifdef CONFIG_VIDEO_ADV_DEBUG
2482         .set_register = sd_dbg_s_register,
2483         .get_register = sd_dbg_g_register,
2484 #endif
2485         .get_chip_ident = sd_chip_ident,
2486 };
2487
2488 #define SN9C20X(sensor, i2c_addr, flags) \
2489         .driver_info =  ((flags & 0xff) << 16) \
2490                         | (SENSOR_ ## sensor << 8) \
2491                         | (i2c_addr)
2492
2493 static const struct usb_device_id device_table[] = {
2494         {USB_DEVICE(0x0c45, 0x6240), SN9C20X(MT9M001, 0x5d, 0)},
2495         {USB_DEVICE(0x0c45, 0x6242), SN9C20X(MT9M111, 0x5d, 0)},
2496         {USB_DEVICE(0x0c45, 0x6248), SN9C20X(OV9655, 0x30, 0)},
2497         {USB_DEVICE(0x0c45, 0x624c), SN9C20X(MT9M112, 0x5d, 0)},
2498         {USB_DEVICE(0x0c45, 0x624e), SN9C20X(SOI968, 0x30, LED_REVERSE)},
2499         {USB_DEVICE(0x0c45, 0x624f), SN9C20X(OV9650, 0x30,
2500                                              (FLIP_DETECT | HAS_NO_BUTTON))},
2501         {USB_DEVICE(0x0c45, 0x6251), SN9C20X(OV9650, 0x30, 0)},
2502         {USB_DEVICE(0x0c45, 0x6253), SN9C20X(OV9650, 0x30, 0)},
2503         {USB_DEVICE(0x0c45, 0x6260), SN9C20X(OV7670, 0x21, 0)},
2504         {USB_DEVICE(0x0c45, 0x6270), SN9C20X(MT9VPRB, 0x00, 0)},
2505         {USB_DEVICE(0x0c45, 0x627b), SN9C20X(OV7660, 0x21, FLIP_DETECT)},
2506         {USB_DEVICE(0x0c45, 0x627c), SN9C20X(HV7131R, 0x11, 0)},
2507         {USB_DEVICE(0x0c45, 0x627f), SN9C20X(OV9650, 0x30, 0)},
2508         {USB_DEVICE(0x0c45, 0x6280), SN9C20X(MT9M001, 0x5d, 0)},
2509         {USB_DEVICE(0x0c45, 0x6282), SN9C20X(MT9M111, 0x5d, 0)},
2510         {USB_DEVICE(0x0c45, 0x6288), SN9C20X(OV9655, 0x30, 0)},
2511         {USB_DEVICE(0x0c45, 0x628c), SN9C20X(MT9M112, 0x5d, 0)},
2512         {USB_DEVICE(0x0c45, 0x628e), SN9C20X(SOI968, 0x30, 0)},
2513         {USB_DEVICE(0x0c45, 0x628f), SN9C20X(OV9650, 0x30, 0)},
2514         {USB_DEVICE(0x0c45, 0x62a0), SN9C20X(OV7670, 0x21, 0)},
2515         {USB_DEVICE(0x0c45, 0x62b0), SN9C20X(MT9VPRB, 0x00, 0)},
2516         {USB_DEVICE(0x0c45, 0x62b3), SN9C20X(OV9655, 0x30, 0)},
2517         {USB_DEVICE(0x0c45, 0x62bb), SN9C20X(OV7660, 0x21, LED_REVERSE)},
2518         {USB_DEVICE(0x0c45, 0x62bc), SN9C20X(HV7131R, 0x11, 0)},
2519         {USB_DEVICE(0x045e, 0x00f4), SN9C20X(OV9650, 0x30, 0)},
2520         {USB_DEVICE(0x145f, 0x013d), SN9C20X(OV7660, 0x21, 0)},
2521         {USB_DEVICE(0x0458, 0x7029), SN9C20X(HV7131R, 0x11, 0)},
2522         {USB_DEVICE(0x0458, 0x704a), SN9C20X(MT9M112, 0x5d, 0)},
2523         {USB_DEVICE(0x0458, 0x704c), SN9C20X(MT9M112, 0x5d, 0)},
2524         {USB_DEVICE(0xa168, 0x0610), SN9C20X(HV7131R, 0x11, 0)},
2525         {USB_DEVICE(0xa168, 0x0611), SN9C20X(HV7131R, 0x11, 0)},
2526         {USB_DEVICE(0xa168, 0x0613), SN9C20X(HV7131R, 0x11, 0)},
2527         {USB_DEVICE(0xa168, 0x0618), SN9C20X(HV7131R, 0x11, 0)},
2528         {USB_DEVICE(0xa168, 0x0614), SN9C20X(MT9M111, 0x5d, 0)},
2529         {USB_DEVICE(0xa168, 0x0615), SN9C20X(MT9M111, 0x5d, 0)},
2530         {USB_DEVICE(0xa168, 0x0617), SN9C20X(MT9M111, 0x5d, 0)},
2531         {}
2532 };
2533 MODULE_DEVICE_TABLE(usb, device_table);
2534
2535 /* -- device connect -- */
2536 static int sd_probe(struct usb_interface *intf,
2537                     const struct usb_device_id *id)
2538 {
2539         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
2540                                 THIS_MODULE);
2541 }
2542
2543 static struct usb_driver sd_driver = {
2544         .name = MODULE_NAME,
2545         .id_table = device_table,
2546         .probe = sd_probe,
2547         .disconnect = gspca_disconnect,
2548 #ifdef CONFIG_PM
2549         .suspend = gspca_suspend,
2550         .resume = gspca_resume,
2551         .reset_resume = gspca_resume,
2552 #endif
2553 };
2554
2555 /* -- module insert / remove -- */
2556 static int __init sd_mod_init(void)
2557 {
2558         return usb_register(&sd_driver);
2559 }
2560 static void __exit sd_mod_exit(void)
2561 {
2562         usb_deregister(&sd_driver);
2563 }
2564
2565 module_init(sd_mod_init);
2566 module_exit(sd_mod_exit);