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