drivers/media/usb/gspca/sn9c20x.c

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