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