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