drivers/media/video/gspca/sn9c20x.c

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