SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/gspca/sn9c20x.c

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