git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/gspca/ov519.c

   1 /**
   2  * OV519 driver
   3  *
   4  * Copyright (C) 2008 Jean-Francois Moine (http://moinejf.free.fr)
   5  *
   6  * (This module is adapted from the ov51x-jpeg package)
   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 MODULE_NAME "ov519"
  24
  25 #include "gspca.h"
  26
  27 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
  28 MODULE_DESCRIPTION("OV519 USB Camera Driver");
  29 MODULE_LICENSE("GPL");
  30
  31 /* global parameters */
  32 static int frame_rate;
  33
  34 /* Number of times to retry a failed I2C transaction. Increase this if you
  35  * are getting "Failed to read sensor ID..." */
  36 static int i2c_detect_tries = 10;
  37
  38 /* ov519 device descriptor */
  39 struct sd {
  40         struct gspca_dev gspca_dev;             /* !! must be the first item */
  41
  42         /* Determined by sensor type */
  43         char sif;
  44
  45         unsigned char primary_i2c_slave;        /* I2C write id of sensor */
  46
  47         unsigned char brightness;
  48         unsigned char contrast;
  49         unsigned char colors;
  50         __u8 hflip;
  51         __u8 vflip;
  52
  53         char compress;          /* Should the next frame be compressed? */
  54         char compress_inited;   /* Are compression params uploaded? */
  55         char stopped;           /* Streaming is temporarily paused */
  56
  57         char frame_rate;        /* current Framerate (OV519 only) */
  58         char clockdiv;          /* clockdiv override for OV519 only */
  59
  60         char sensor;            /* Type of image sensor chip (SEN_*) */
  61 #define SEN_UNKNOWN 0
  62 #define SEN_OV6620 1
  63 #define SEN_OV6630 2
  64 #define SEN_OV7610 3
  65 #define SEN_OV7620 4
  66 #define SEN_OV7630 5
  67 #define SEN_OV7640 6
  68 #define SEN_OV7670 7
  69 #define SEN_OV76BE 8
  70 #define SEN_OV8610 9
  71
  72 };
  73
  74 /* V4L2 controls supported by the driver */
  75 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
  76 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
  77 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
  78 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
  79 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
  80 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
  81 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val);
  82 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val);
  83 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
  84 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
  85
  86 static struct ctrl sd_ctrls[] = {
  87         {
  88             {
  89                 .id      = V4L2_CID_BRIGHTNESS,
  90                 .type    = V4L2_CTRL_TYPE_INTEGER,
  91                 .name    = "Brightness",
  92                 .minimum = 0,
  93                 .maximum = 255,
  94                 .step    = 1,
  95 #define BRIGHTNESS_DEF 127
  96                 .default_value = BRIGHTNESS_DEF,
  97             },
  98             .set = sd_setbrightness,
  99             .get = sd_getbrightness,
 100         },
 101         {
 102             {
 103                 .id      = V4L2_CID_CONTRAST,
 104                 .type    = V4L2_CTRL_TYPE_INTEGER,
 105                 .name    = "Contrast",
 106                 .minimum = 0,
 107                 .maximum = 255,
 108                 .step    = 1,
 109 #define CONTRAST_DEF 127
 110                 .default_value = CONTRAST_DEF,
 111             },
 112             .set = sd_setcontrast,
 113             .get = sd_getcontrast,
 114         },
 115         {
 116             {
 117                 .id      = V4L2_CID_SATURATION,
 118                 .type    = V4L2_CTRL_TYPE_INTEGER,
 119                 .name    = "Color",
 120                 .minimum = 0,
 121                 .maximum = 255,
 122                 .step    = 1,
 123 #define COLOR_DEF 127
 124                 .default_value = COLOR_DEF,
 125             },
 126             .set = sd_setcolors,
 127             .get = sd_getcolors,
 128         },
 129 /* next controls work with ov7670 only */
 130         {
 131             {
 132                 .id      = V4L2_CID_HFLIP,
 133                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 134                 .name    = "Mirror",
 135                 .minimum = 0,
 136                 .maximum = 1,
 137                 .step    = 1,
 138 #define HFLIP_DEF 0
 139                 .default_value = HFLIP_DEF,
 140             },
 141             .set = sd_sethflip,
 142             .get = sd_gethflip,
 143         },
 144         {
 145             {
 146                 .id      = V4L2_CID_VFLIP,
 147                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 148                 .name    = "Vflip",
 149                 .minimum = 0,
 150                 .maximum = 1,
 151                 .step    = 1,
 152 #define VFLIP_DEF 0
 153                 .default_value = VFLIP_DEF,
 154             },
 155             .set = sd_setvflip,
 156             .get = sd_getvflip,
 157         },
 158 };
 159
 160 static struct v4l2_pix_format vga_mode[] = {
 161         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 162                 .bytesperline = 320,
 163                 .sizeimage = 320 * 240 * 3 / 8 + 590,
 164                 .colorspace = V4L2_COLORSPACE_JPEG,
 165                 .priv = 1},
 166         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 167                 .bytesperline = 640,
 168                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 169                 .colorspace = V4L2_COLORSPACE_JPEG,
 170                 .priv = 0},
 171 };
 172 static struct v4l2_pix_format sif_mode[] = {
 173         {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 174                 .bytesperline = 176,
 175                 .sizeimage = 176 * 144 * 3 / 8 + 590,
 176                 .colorspace = V4L2_COLORSPACE_JPEG,
 177                 .priv = 1},
 178         {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 179                 .bytesperline = 352,
 180                 .sizeimage = 352 * 288 * 3 / 8 + 590,
 181                 .colorspace = V4L2_COLORSPACE_JPEG,
 182                 .priv = 0},
 183 };
 184
 185 /* OV519 Camera interface register numbers */
 186 #define OV519_CAM_H_SIZE                0x10
 187 #define OV519_CAM_V_SIZE                0x11
 188 #define OV519_CAM_X_OFFSETL             0x12
 189 #define OV519_CAM_X_OFFSETH             0x13
 190 #define OV519_CAM_Y_OFFSETL             0x14
 191 #define OV519_CAM_Y_OFFSETH             0x15
 192 #define OV519_CAM_DIVIDER               0x16
 193 #define OV519_CAM_DFR                   0x20
 194 #define OV519_CAM_FORMAT                0x25
 195
 196 /* OV519 System Controller register numbers */
 197 #define OV519_SYS_RESET1 0x51
 198 #define OV519_SYS_EN_CLK1 0x54
 199
 200 #define OV519_GPIO_DATA_OUT0            0x71
 201 #define OV519_GPIO_IO_CTRL0             0x72
 202
 203 #define OV511_ENDPOINT_ADDRESS  1       /* Isoc endpoint number */
 204
 205 /* I2C registers */
 206 #define R51x_I2C_W_SID          0x41
 207 #define R51x_I2C_SADDR_3        0x42
 208 #define R51x_I2C_SADDR_2        0x43
 209 #define R51x_I2C_R_SID          0x44
 210 #define R51x_I2C_DATA           0x45
 211 #define R518_I2C_CTL            0x47    /* OV518(+) only */
 212
 213 /* I2C ADDRESSES */
 214 #define OV7xx0_SID   0x42
 215 #define OV8xx0_SID   0xa0
 216 #define OV6xx0_SID   0xc0
 217
 218 /* OV7610 registers */
 219 #define OV7610_REG_GAIN         0x00    /* gain setting (5:0) */
 220 #define OV7610_REG_SAT          0x03    /* saturation */
 221 #define OV8610_REG_HUE          0x04    /* 04 reserved */
 222 #define OV7610_REG_CNT          0x05    /* Y contrast */
 223 #define OV7610_REG_BRT          0x06    /* Y brightness */
 224 #define OV7610_REG_COM_C        0x14    /* misc common regs */
 225 #define OV7610_REG_ID_HIGH      0x1c    /* manufacturer ID MSB */
 226 #define OV7610_REG_ID_LOW       0x1d    /* manufacturer ID LSB */
 227 #define OV7610_REG_COM_I        0x29    /* misc settings */
 228
 229 /* OV7670 registers */
 230 #define OV7670_REG_GAIN        0x00    /* Gain lower 8 bits (rest in vref) */
 231 #define OV7670_REG_BLUE        0x01    /* blue gain */
 232 #define OV7670_REG_RED         0x02    /* red gain */
 233 #define OV7670_REG_VREF        0x03    /* Pieces of GAIN, VSTART, VSTOP */
 234 #define OV7670_REG_COM1        0x04    /* Control 1 */
 235 #define OV7670_REG_AECHH       0x07    /* AEC MS 5 bits */
 236 #define OV7670_REG_COM3        0x0c    /* Control 3 */
 237 #define OV7670_REG_COM4        0x0d    /* Control 4 */
 238 #define OV7670_REG_COM5        0x0e    /* All "reserved" */
 239 #define OV7670_REG_COM6        0x0f    /* Control 6 */
 240 #define OV7670_REG_AECH        0x10    /* More bits of AEC value */
 241 #define OV7670_REG_CLKRC       0x11    /* Clock control */
 242 #define OV7670_REG_COM7        0x12    /* Control 7 */
 243 #define   OV7670_COM7_FMT_VGA    0x00
 244 #define   OV7670_COM7_YUV        0x00    /* YUV */
 245 #define   OV7670_COM7_FMT_QVGA   0x10    /* QVGA format */
 246 #define   OV7670_COM7_FMT_MASK   0x38
 247 #define   OV7670_COM7_RESET      0x80    /* Register reset */
 248 #define OV7670_REG_COM8        0x13    /* Control 8 */
 249 #define   OV7670_COM8_AEC        0x01    /* Auto exposure enable */
 250 #define   OV7670_COM8_AWB        0x02    /* White balance enable */
 251 #define   OV7670_COM8_AGC        0x04    /* Auto gain enable */
 252 #define   OV7670_COM8_BFILT      0x20    /* Band filter enable */
 253 #define   OV7670_COM8_AECSTEP    0x40    /* Unlimited AEC step size */
 254 #define   OV7670_COM8_FASTAEC    0x80    /* Enable fast AGC/AEC */
 255 #define OV7670_REG_COM9        0x14    /* Control 9  - gain ceiling */
 256 #define OV7670_REG_COM10       0x15    /* Control 10 */
 257 #define OV7670_REG_HSTART      0x17    /* Horiz start high bits */
 258 #define OV7670_REG_HSTOP       0x18    /* Horiz stop high bits */
 259 #define OV7670_REG_VSTART      0x19    /* Vert start high bits */
 260 #define OV7670_REG_VSTOP       0x1a    /* Vert stop high bits */
 261 #define OV7670_REG_MVFP        0x1e    /* Mirror / vflip */
 262 #define   OV7670_MVFP_VFLIP      0x10    /* vertical flip */
 263 #define   OV7670_MVFP_MIRROR     0x20    /* Mirror image */
 264 #define OV7670_REG_AEW         0x24    /* AGC upper limit */
 265 #define OV7670_REG_AEB         0x25    /* AGC lower limit */
 266 #define OV7670_REG_VPT         0x26    /* AGC/AEC fast mode op region */
 267 #define OV7670_REG_HREF        0x32    /* HREF pieces */
 268 #define OV7670_REG_TSLB        0x3a    /* lots of stuff */
 269 #define OV7670_REG_COM11       0x3b    /* Control 11 */
 270 #define   OV7670_COM11_EXP       0x02
 271 #define   OV7670_COM11_HZAUTO    0x10    /* Auto detect 50/60 Hz */
 272 #define OV7670_REG_COM12       0x3c    /* Control 12 */
 273 #define OV7670_REG_COM13       0x3d    /* Control 13 */
 274 #define   OV7670_COM13_GAMMA     0x80    /* Gamma enable */
 275 #define   OV7670_COM13_UVSAT     0x40    /* UV saturation auto adjustment */
 276 #define OV7670_REG_COM14       0x3e    /* Control 14 */
 277 #define OV7670_REG_EDGE        0x3f    /* Edge enhancement factor */
 278 #define OV7670_REG_COM15       0x40    /* Control 15 */
 279 #define   OV7670_COM15_R00FF     0xc0    /*            00 to FF */
 280 #define OV7670_REG_COM16       0x41    /* Control 16 */
 281 #define   OV7670_COM16_AWBGAIN   0x08    /* AWB gain enable */
 282 #define OV7670_REG_BRIGHT      0x55    /* Brightness */
 283 #define OV7670_REG_CONTRAS     0x56    /* Contrast control */
 284 #define OV7670_REG_GFIX        0x69    /* Fix gain control */
 285 #define OV7670_REG_RGB444      0x8c    /* RGB 444 control */
 286 #define OV7670_REG_HAECC1      0x9f    /* Hist AEC/AGC control 1 */
 287 #define OV7670_REG_HAECC2      0xa0    /* Hist AEC/AGC control 2 */
 288 #define OV7670_REG_BD50MAX     0xa5    /* 50hz banding step limit */
 289 #define OV7670_REG_HAECC3      0xa6    /* Hist AEC/AGC control 3 */
 290 #define OV7670_REG_HAECC4      0xa7    /* Hist AEC/AGC control 4 */
 291 #define OV7670_REG_HAECC5      0xa8    /* Hist AEC/AGC control 5 */
 292 #define OV7670_REG_HAECC6      0xa9    /* Hist AEC/AGC control 6 */
 293 #define OV7670_REG_HAECC7      0xaa    /* Hist AEC/AGC control 7 */
 294 #define OV7670_REG_BD60MAX     0xab    /* 60hz banding step limit */
 295
 296 static unsigned char ov7670_abs_to_sm(unsigned char v)
 297 {
 298         if (v > 127)
 299                 return v & 0x7f;
 300         return (128 - v) | 0x80;
 301 }
 302
 303 /* Write a OV519 register */
 304 static int reg_w(struct sd *sd, __u16 index, __u8 value)
 305 {
 306         int ret;
 307
 308         sd->gspca_dev.usb_buf[0] = value;
 309         ret = usb_control_msg(sd->gspca_dev.dev,
 310                         usb_sndctrlpipe(sd->gspca_dev.dev, 0),
 311                         1,                      /* REQ_IO (ov518/519) */
 312                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 313                         0, index,
 314                         sd->gspca_dev.usb_buf, 1, 500);
 315         if (ret < 0)
 316                 PDEBUG(D_ERR, "Write reg [%02x] %02x failed", index, value);
 317         return ret;
 318 }
 319
 320 /* Read from a OV519 register */
 321 /* returns: negative is error, pos or zero is data */
 322 static int reg_r(struct sd *sd, __u16 index)
 323 {
 324         int ret;
 325
 326         ret = usb_control_msg(sd->gspca_dev.dev,
 327                         usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
 328                         1,                      /* REQ_IO */
 329                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 330                         0, index, sd->gspca_dev.usb_buf, 1, 500);
 331
 332         if (ret >= 0)
 333                 ret = sd->gspca_dev.usb_buf[0];
 334         else
 335                 PDEBUG(D_ERR, "Read reg [0x%02x] failed", index);
 336         return ret;
 337 }
 338
 339 /* Read 8 values from a OV519 register */
 340 static int reg_r8(struct sd *sd,
 341                   __u16 index)
 342 {
 343         int ret;
 344
 345         ret = usb_control_msg(sd->gspca_dev.dev,
 346                         usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
 347                         1,                      /* REQ_IO */
 348                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 349                         0, index, sd->gspca_dev.usb_buf, 8, 500);
 350
 351         if (ret >= 0)
 352                 ret = sd->gspca_dev.usb_buf[0];
 353         else
 354                 PDEBUG(D_ERR, "Read reg 8 [0x%02x] failed", index);
 355         return ret;
 356 }
 357
 358 /*
 359  * Writes bits at positions specified by mask to an OV51x reg. Bits that are in
 360  * the same position as 1's in "mask" are cleared and set to "value". Bits
 361  * that are in the same position as 0's in "mask" are preserved, regardless
 362  * of their respective state in "value".
 363  */
 364 static int reg_w_mask(struct sd *sd,
 365                         __u16 index,
 366                         __u8 value,
 367                         __u8 mask)
 368 {
 369         int ret;
 370         __u8 oldval;
 371
 372         if (mask != 0xff) {
 373                 value &= mask;                  /* Enforce mask on value */
 374                 ret = reg_r(sd, index);
 375                 if (ret < 0)
 376                         return ret;
 377
 378                 oldval = ret & ~mask;           /* Clear the masked bits */
 379                 value |= oldval;                /* Set the desired bits */
 380         }
 381         return reg_w(sd, index, value);
 382 }
 383
 384 /*
 385  * The OV518 I2C I/O procedure is different, hence, this function.
 386  * This is normally only called from i2c_w(). Note that this function
 387  * always succeeds regardless of whether the sensor is present and working.
 388  */
 389 static int i2c_w(struct sd *sd,
 390                 __u8 reg,
 391                 __u8 value)
 392 {
 393         int rc;
 394
 395         PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
 396
 397         /* Select camera register */
 398         rc = reg_w(sd, R51x_I2C_SADDR_3, reg);
 399         if (rc < 0)
 400                 return rc;
 401
 402         /* Write "value" to I2C data port of OV511 */
 403         rc = reg_w(sd, R51x_I2C_DATA, value);
 404         if (rc < 0)
 405                 return rc;
 406
 407         /* Initiate 3-byte write cycle */
 408         rc = reg_w(sd, R518_I2C_CTL, 0x01);
 409
 410         /* wait for write complete */
 411         msleep(4);
 412         if (rc < 0)
 413                 return rc;
 414         return reg_r8(sd, R518_I2C_CTL);
 415 }
 416
 417 /*
 418  * returns: negative is error, pos or zero is data
 419  *
 420  * The OV518 I2C I/O procedure is different, hence, this function.
 421  * This is normally only called from i2c_r(). Note that this function
 422  * always succeeds regardless of whether the sensor is present and working.
 423  */
 424 static int i2c_r(struct sd *sd, __u8 reg)
 425 {
 426         int rc, value;
 427
 428         /* Select camera register */
 429         rc = reg_w(sd, R51x_I2C_SADDR_2, reg);
 430         if (rc < 0)
 431                 return rc;
 432
 433         /* Initiate 2-byte write cycle */
 434         rc = reg_w(sd, R518_I2C_CTL, 0x03);
 435         if (rc < 0)
 436                 return rc;
 437
 438         /* Initiate 2-byte read cycle */
 439         rc = reg_w(sd, R518_I2C_CTL, 0x05);
 440         if (rc < 0)
 441                 return rc;
 442         value = reg_r(sd, R51x_I2C_DATA);
 443         PDEBUG(D_USBI, "i2c [0x%02X] -> 0x%02X", reg, value);
 444         return value;
 445 }
 446
 447 /* Writes bits at positions specified by mask to an I2C reg. Bits that are in
 448  * the same position as 1's in "mask" are cleared and set to "value". Bits
 449  * that are in the same position as 0's in "mask" are preserved, regardless
 450  * of their respective state in "value".
 451  */
 452 static int i2c_w_mask(struct sd *sd,
 453                    __u8 reg,
 454                    __u8 value,
 455                    __u8 mask)
 456 {
 457         int rc;
 458         __u8 oldval;
 459
 460         value &= mask;                  /* Enforce mask on value */
 461         rc = i2c_r(sd, reg);
 462         if (rc < 0)
 463                 return rc;
 464         oldval = rc & ~mask;            /* Clear the masked bits */
 465         value |= oldval;                /* Set the desired bits */
 466         return i2c_w(sd, reg, value);
 467 }
 468
 469 /* Temporarily stops OV511 from functioning. Must do this before changing
 470  * registers while the camera is streaming */
 471 static inline int ov51x_stop(struct sd *sd)
 472 {
 473         PDEBUG(D_STREAM, "stopping");
 474         sd->stopped = 1;
 475         return reg_w(sd, OV519_SYS_RESET1, 0x0f);
 476 }
 477
 478 /* Restarts OV511 after ov511_stop() is called. Has no effect if it is not
 479  * actually stopped (for performance). */
 480 static inline int ov51x_restart(struct sd *sd)
 481 {
 482         PDEBUG(D_STREAM, "restarting");
 483         if (!sd->stopped)
 484                 return 0;
 485         sd->stopped = 0;
 486
 487         /* Reinitialize the stream */
 488         return reg_w(sd, OV519_SYS_RESET1, 0x00);
 489 }
 490
 491 /* This does an initial reset of an OmniVision sensor and ensures that I2C
 492  * is synchronized. Returns <0 on failure.
 493  */
 494 static int init_ov_sensor(struct sd *sd)
 495 {
 496         int i, success;
 497
 498         /* Reset the sensor */
 499         if (i2c_w(sd, 0x12, 0x80) < 0)
 500                 return -EIO;
 501
 502         /* Wait for it to initialize */
 503         msleep(150);
 504
 505         for (i = 0, success = 0; i < i2c_detect_tries && !success; i++) {
 506                 if (i2c_r(sd, OV7610_REG_ID_HIGH) == 0x7f &&
 507                     i2c_r(sd, OV7610_REG_ID_LOW) == 0xa2) {
 508                         success = 1;
 509                         continue;
 510                 }
 511
 512                 /* Reset the sensor */
 513                 if (i2c_w(sd, 0x12, 0x80) < 0)
 514                         return -EIO;
 515                 /* Wait for it to initialize */
 516                 msleep(150);
 517                 /* Dummy read to sync I2C */
 518                 if (i2c_r(sd, 0x00) < 0)
 519                         return -EIO;
 520         }
 521         if (!success)
 522                 return -EIO;
 523         PDEBUG(D_PROBE, "I2C synced in %d attempt(s)", i);
 524         return 0;
 525 }
 526
 527 /* Set the read and write slave IDs. The "slave" argument is the write slave,
 528  * and the read slave will be set to (slave + 1).
 529  * This should not be called from outside the i2c I/O functions.
 530  * Sets I2C read and write slave IDs. Returns <0 for error
 531  */
 532 static int ov51x_set_slave_ids(struct sd *sd,
 533                                 __u8 slave)
 534 {
 535         int rc;
 536
 537         rc = reg_w(sd, R51x_I2C_W_SID, slave);
 538         if (rc < 0)
 539                 return rc;
 540         return reg_w(sd, R51x_I2C_R_SID, slave + 1);
 541 }
 542
 543 struct ov_regvals {
 544         __u8 reg;
 545         __u8 val;
 546 };
 547 struct ov_i2c_regvals {
 548         __u8 reg;
 549         __u8 val;
 550 };
 551
 552 static int write_regvals(struct sd *sd,
 553                          const struct ov_regvals *regvals,
 554                          int n)
 555 {
 556         int rc;
 557
 558         while (--n >= 0) {
 559                 rc = reg_w(sd, regvals->reg, regvals->val);
 560                 if (rc < 0)
 561                         return rc;
 562                 regvals++;
 563         }
 564         return 0;
 565 }
 566
 567 static int write_i2c_regvals(struct sd *sd,
 568                              const struct ov_i2c_regvals *regvals,
 569                              int n)
 570 {
 571         int rc;
 572
 573         while (--n >= 0) {
 574                 rc = i2c_w(sd, regvals->reg, regvals->val);
 575                 if (rc < 0)
 576                         return rc;
 577                 regvals++;
 578         }
 579         return 0;
 580 }
 581
 582 /****************************************************************************
 583  *
 584  * OV511 and sensor configuration
 585  *
 586  ***************************************************************************/
 587
 588 /* This initializes the OV8110, OV8610 sensor. The OV8110 uses
 589  * the same register settings as the OV8610, since they are very similar.
 590  */
 591 static int ov8xx0_configure(struct sd *sd)
 592 {
 593         int rc;
 594         static const struct ov_i2c_regvals norm_8610[] = {
 595                 { 0x12, 0x80 },
 596                 { 0x00, 0x00 },
 597                 { 0x01, 0x80 },
 598                 { 0x02, 0x80 },
 599                 { 0x03, 0xc0 },
 600                 { 0x04, 0x30 },
 601                 { 0x05, 0x30 }, /* was 0x10, new from windrv 090403 */
 602                 { 0x06, 0x70 }, /* was 0x80, new from windrv 090403 */
 603                 { 0x0a, 0x86 },
 604                 { 0x0b, 0xb0 },
 605                 { 0x0c, 0x20 },
 606                 { 0x0d, 0x20 },
 607                 { 0x11, 0x01 },
 608                 { 0x12, 0x25 },
 609                 { 0x13, 0x01 },
 610                 { 0x14, 0x04 },
 611                 { 0x15, 0x01 }, /* Lin and Win think different about UV order */
 612                 { 0x16, 0x03 },
 613                 { 0x17, 0x38 }, /* was 0x2f, new from windrv 090403 */
 614                 { 0x18, 0xea }, /* was 0xcf, new from windrv 090403 */
 615                 { 0x19, 0x02 }, /* was 0x06, new from windrv 090403 */
 616                 { 0x1a, 0xf5 },
 617                 { 0x1b, 0x00 },
 618                 { 0x20, 0xd0 }, /* was 0x90, new from windrv 090403 */
 619                 { 0x23, 0xc0 }, /* was 0x00, new from windrv 090403 */
 620                 { 0x24, 0x30 }, /* was 0x1d, new from windrv 090403 */
 621                 { 0x25, 0x50 }, /* was 0x57, new from windrv 090403 */
 622                 { 0x26, 0xa2 },
 623                 { 0x27, 0xea },
 624                 { 0x28, 0x00 },
 625                 { 0x29, 0x00 },
 626                 { 0x2a, 0x80 },
 627                 { 0x2b, 0xc8 }, /* was 0xcc, new from windrv 090403 */
 628                 { 0x2c, 0xac },
 629                 { 0x2d, 0x45 }, /* was 0xd5, new from windrv 090403 */
 630                 { 0x2e, 0x80 },
 631                 { 0x2f, 0x14 }, /* was 0x01, new from windrv 090403 */
 632                 { 0x4c, 0x00 },
 633                 { 0x4d, 0x30 }, /* was 0x10, new from windrv 090403 */
 634                 { 0x60, 0x02 }, /* was 0x01, new from windrv 090403 */
 635                 { 0x61, 0x00 }, /* was 0x09, new from windrv 090403 */
 636                 { 0x62, 0x5f }, /* was 0xd7, new from windrv 090403 */
 637                 { 0x63, 0xff },
 638                 { 0x64, 0x53 }, /* new windrv 090403 says 0x57,
 639                                  * maybe thats wrong */
 640                 { 0x65, 0x00 },
 641                 { 0x66, 0x55 },
 642                 { 0x67, 0xb0 },
 643                 { 0x68, 0xc0 }, /* was 0xaf, new from windrv 090403 */
 644                 { 0x69, 0x02 },
 645                 { 0x6a, 0x22 },
 646                 { 0x6b, 0x00 },
 647                 { 0x6c, 0x99 }, /* was 0x80, old windrv says 0x00, but
 648                                    deleting bit7 colors the first images red */
 649                 { 0x6d, 0x11 }, /* was 0x00, new from windrv 090403 */
 650                 { 0x6e, 0x11 }, /* was 0x00, new from windrv 090403 */
 651                 { 0x6f, 0x01 },
 652                 { 0x70, 0x8b },
 653                 { 0x71, 0x00 },
 654                 { 0x72, 0x14 },
 655                 { 0x73, 0x54 },
 656                 { 0x74, 0x00 },/* 0x60? - was 0x00, new from windrv 090403 */
 657                 { 0x75, 0x0e },
 658                 { 0x76, 0x02 }, /* was 0x02, new from windrv 090403 */
 659                 { 0x77, 0xff },
 660                 { 0x78, 0x80 },
 661                 { 0x79, 0x80 },
 662                 { 0x7a, 0x80 },
 663                 { 0x7b, 0x10 }, /* was 0x13, new from windrv 090403 */
 664                 { 0x7c, 0x00 },
 665                 { 0x7d, 0x08 }, /* was 0x09, new from windrv 090403 */
 666                 { 0x7e, 0x08 }, /* was 0xc0, new from windrv 090403 */
 667                 { 0x7f, 0xfb },
 668                 { 0x80, 0x28 },
 669                 { 0x81, 0x00 },
 670                 { 0x82, 0x23 },
 671                 { 0x83, 0x0b },
 672                 { 0x84, 0x00 },
 673                 { 0x85, 0x62 }, /* was 0x61, new from windrv 090403 */
 674                 { 0x86, 0xc9 },
 675                 { 0x87, 0x00 },
 676                 { 0x88, 0x00 },
 677                 { 0x89, 0x01 },
 678                 { 0x12, 0x20 },
 679                 { 0x12, 0x25 }, /* was 0x24, new from windrv 090403 */
 680         };
 681
 682         PDEBUG(D_PROBE, "starting ov8xx0 configuration");
 683
 684         if (init_ov_sensor(sd) < 0)
 685                 PDEBUG(D_ERR|D_PROBE, "Failed to read sensor ID");
 686         else
 687                 PDEBUG(D_PROBE, "OV86x0 initialized");
 688
 689         /* Detect sensor (sub)type */
 690         rc = i2c_r(sd, OV7610_REG_COM_I);
 691         if (rc < 0) {
 692                 PDEBUG(D_ERR, "Error detecting sensor type");
 693                 return -1;
 694         }
 695         if ((rc & 3) == 1) {
 696                 sd->sensor = SEN_OV8610;
 697         } else {
 698                 PDEBUG(D_ERR, "Unknown image sensor version: %d", rc & 3);
 699                 return -1;
 700         }
 701         PDEBUG(D_PROBE, "Writing 8610 registers");
 702         if (write_i2c_regvals(sd, norm_8610, ARRAY_SIZE(norm_8610)))
 703                 return -1;
 704
 705         /* Set sensor-specific vars */
 706 /*      sd->sif = 0;            already done */
 707         return 0;
 708 }
 709
 710 /* This initializes the OV7610, OV7620, or OV76BE sensor. The OV76BE uses
 711  * the same register settings as the OV7610, since they are very similar.
 712  */
 713 static int ov7xx0_configure(struct sd *sd)
 714 {
 715         int rc, high, low;
 716
 717         /* Lawrence Glaister <lg@jfm.bc.ca> reports:
 718          *
 719          * Register 0x0f in the 7610 has the following effects:
 720          *
 721          * 0x85 (AEC method 1): Best overall, good contrast range
 722          * 0x45 (AEC method 2): Very overexposed
 723          * 0xa5 (spec sheet default): Ok, but the black level is
 724          *      shifted resulting in loss of contrast
 725          * 0x05 (old driver setting): very overexposed, too much
 726          *      contrast
 727          */
 728         static const struct ov_i2c_regvals norm_7610[] = {
 729                 { 0x10, 0xff },
 730                 { 0x16, 0x06 },
 731                 { 0x28, 0x24 },
 732                 { 0x2b, 0xac },
 733                 { 0x12, 0x00 },
 734                 { 0x38, 0x81 },
 735                 { 0x28, 0x24 }, /* 0c */
 736                 { 0x0f, 0x85 }, /* lg's setting */
 737                 { 0x15, 0x01 },
 738                 { 0x20, 0x1c },
 739                 { 0x23, 0x2a },
 740                 { 0x24, 0x10 },
 741                 { 0x25, 0x8a },
 742                 { 0x26, 0xa2 },
 743                 { 0x27, 0xc2 },
 744                 { 0x2a, 0x04 },
 745                 { 0x2c, 0xfe },
 746                 { 0x2d, 0x93 },
 747                 { 0x30, 0x71 },
 748                 { 0x31, 0x60 },
 749                 { 0x32, 0x26 },
 750                 { 0x33, 0x20 },
 751                 { 0x34, 0x48 },
 752                 { 0x12, 0x24 },
 753                 { 0x11, 0x01 },
 754                 { 0x0c, 0x24 },
 755                 { 0x0d, 0x24 },
 756         };
 757
 758         static const struct ov_i2c_regvals norm_7620[] = {
 759                 { 0x00, 0x00 },         /* gain */
 760                 { 0x01, 0x80 },         /* blue gain */
 761                 { 0x02, 0x80 },         /* red gain */
 762                 { 0x03, 0xc0 },         /* OV7670_REG_VREF */
 763                 { 0x06, 0x60 },
 764                 { 0x07, 0x00 },
 765                 { 0x0c, 0x24 },
 766                 { 0x0c, 0x24 },
 767                 { 0x0d, 0x24 },
 768                 { 0x11, 0x01 },
 769                 { 0x12, 0x24 },
 770                 { 0x13, 0x01 },
 771                 { 0x14, 0x84 },
 772                 { 0x15, 0x01 },
 773                 { 0x16, 0x03 },
 774                 { 0x17, 0x2f },
 775                 { 0x18, 0xcf },
 776                 { 0x19, 0x06 },
 777                 { 0x1a, 0xf5 },
 778                 { 0x1b, 0x00 },
 779                 { 0x20, 0x18 },
 780                 { 0x21, 0x80 },
 781                 { 0x22, 0x80 },
 782                 { 0x23, 0x00 },
 783                 { 0x26, 0xa2 },
 784                 { 0x27, 0xea },
 785                 { 0x28, 0x20 },
 786                 { 0x29, 0x00 },
 787                 { 0x2a, 0x10 },
 788                 { 0x2b, 0x00 },
 789                 { 0x2c, 0x88 },
 790                 { 0x2d, 0x91 },
 791                 { 0x2e, 0x80 },
 792                 { 0x2f, 0x44 },
 793                 { 0x60, 0x27 },
 794                 { 0x61, 0x02 },
 795                 { 0x62, 0x5f },
 796                 { 0x63, 0xd5 },
 797                 { 0x64, 0x57 },
 798                 { 0x65, 0x83 },
 799                 { 0x66, 0x55 },
 800                 { 0x67, 0x92 },
 801                 { 0x68, 0xcf },
 802                 { 0x69, 0x76 },
 803                 { 0x6a, 0x22 },
 804                 { 0x6b, 0x00 },
 805                 { 0x6c, 0x02 },
 806                 { 0x6d, 0x44 },
 807                 { 0x6e, 0x80 },
 808                 { 0x6f, 0x1d },
 809                 { 0x70, 0x8b },
 810                 { 0x71, 0x00 },
 811                 { 0x72, 0x14 },
 812                 { 0x73, 0x54 },
 813                 { 0x74, 0x00 },
 814                 { 0x75, 0x8e },
 815                 { 0x76, 0x00 },
 816                 { 0x77, 0xff },
 817                 { 0x78, 0x80 },
 818                 { 0x79, 0x80 },
 819                 { 0x7a, 0x80 },
 820                 { 0x7b, 0xe2 },
 821                 { 0x7c, 0x00 },
 822         };
 823
 824         /* 7640 and 7648. The defaults should be OK for most registers. */
 825         static const struct ov_i2c_regvals norm_7640[] = {
 826                 { 0x12, 0x80 },
 827                 { 0x12, 0x14 },
 828         };
 829
 830         /* 7670. Defaults taken from OmniVision provided data,
 831         *  as provided by Jonathan Corbet of OLPC               */
 832         static const struct ov_i2c_regvals norm_7670[] = {
 833                 { OV7670_REG_COM7, OV7670_COM7_RESET },
 834                 { OV7670_REG_TSLB, 0x04 },              /* OV */
 835                 { OV7670_REG_COM7, OV7670_COM7_FMT_VGA }, /* VGA */
 836                 { OV7670_REG_CLKRC, 0x01 },
 837         /*
 838          * Set the hardware window.  These values from OV don't entirely
 839          * make sense - hstop is less than hstart.  But they work...
 840          */
 841                 { OV7670_REG_HSTART, 0x13 },    { OV7670_REG_HSTOP, 0x01 },
 842                 { OV7670_REG_HREF, 0xb6 },      { OV7670_REG_VSTART, 0x02 },
 843                 { OV7670_REG_VSTOP, 0x7a },     { OV7670_REG_VREF, 0x0a },
 844
 845                 { OV7670_REG_COM3, 0 }, { OV7670_REG_COM14, 0 },
 846         /* Mystery scaling numbers */
 847                 { 0x70, 0x3a },         { 0x71, 0x35 },
 848                 { 0x72, 0x11 },         { 0x73, 0xf0 },
 849                 { 0xa2, 0x02 },
 850 /*              { OV7670_REG_COM10, 0x0 }, */
 851
 852         /* Gamma curve values */
 853                 { 0x7a, 0x20 },
 854                 { 0x7b, 0x10 },
 855                 { 0x7c, 0x1e },
 856                 { 0x7d, 0x35 },
 857                 { 0x7e, 0x5a },         { 0x7f, 0x69 },
 858                 { 0x80, 0x76 },         { 0x81, 0x80 },
 859                 { 0x82, 0x88 },         { 0x83, 0x8f },
 860                 { 0x84, 0x96 },         { 0x85, 0xa3 },
 861                 { 0x86, 0xaf },         { 0x87, 0xc4 },
 862                 { 0x88, 0xd7 },         { 0x89, 0xe8 },
 863
 864         /* AGC and AEC parameters.  Note we start by disabling those features,
 865            then turn them only after tweaking the values. */
 866                 { OV7670_REG_COM8, OV7670_COM8_FASTAEC
 867                                  | OV7670_COM8_AECSTEP
 868                                  | OV7670_COM8_BFILT },
 869                 { OV7670_REG_GAIN, 0 }, { OV7670_REG_AECH, 0 },
 870                 { OV7670_REG_COM4, 0x40 }, /* magic reserved bit */
 871                 { OV7670_REG_COM9, 0x18 }, /* 4x gain + magic rsvd bit */
 872                 { OV7670_REG_BD50MAX, 0x05 },   { OV7670_REG_BD60MAX, 0x07 },
 873                 { OV7670_REG_AEW, 0x95 },       { OV7670_REG_AEB, 0x33 },
 874                 { OV7670_REG_VPT, 0xe3 },       { OV7670_REG_HAECC1, 0x78 },
 875                 { OV7670_REG_HAECC2, 0x68 },
 876                 { 0xa1, 0x03 }, /* magic */
 877                 { OV7670_REG_HAECC3, 0xd8 },    { OV7670_REG_HAECC4, 0xd8 },
 878                 { OV7670_REG_HAECC5, 0xf0 },    { OV7670_REG_HAECC6, 0x90 },
 879                 { OV7670_REG_HAECC7, 0x94 },
 880                 { OV7670_REG_COM8, OV7670_COM8_FASTAEC
 881                                 | OV7670_COM8_AECSTEP
 882                                 | OV7670_COM8_BFILT
 883                                 | OV7670_COM8_AGC
 884                                 | OV7670_COM8_AEC },
 885
 886         /* Almost all of these are magic "reserved" values.  */
 887                 { OV7670_REG_COM5, 0x61 },      { OV7670_REG_COM6, 0x4b },
 888                 { 0x16, 0x02 },
 889                 { OV7670_REG_MVFP, 0x07 },
 890                 { 0x21, 0x02 },         { 0x22, 0x91 },
 891                 { 0x29, 0x07 },         { 0x33, 0x0b },
 892                 { 0x35, 0x0b },         { 0x37, 0x1d },
 893                 { 0x38, 0x71 },         { 0x39, 0x2a },
 894                 { OV7670_REG_COM12, 0x78 },     { 0x4d, 0x40 },
 895                 { 0x4e, 0x20 },         { OV7670_REG_GFIX, 0 },
 896                 { 0x6b, 0x4a },         { 0x74, 0x10 },
 897                 { 0x8d, 0x4f },         { 0x8e, 0 },
 898                 { 0x8f, 0 },            { 0x90, 0 },
 899                 { 0x91, 0 },            { 0x96, 0 },
 900                 { 0x9a, 0 },            { 0xb0, 0x84 },
 901                 { 0xb1, 0x0c },         { 0xb2, 0x0e },
 902                 { 0xb3, 0x82 },         { 0xb8, 0x0a },
 903
 904         /* More reserved magic, some of which tweaks white balance */
 905                 { 0x43, 0x0a },         { 0x44, 0xf0 },
 906                 { 0x45, 0x34 },         { 0x46, 0x58 },
 907                 { 0x47, 0x28 },         { 0x48, 0x3a },
 908                 { 0x59, 0x88 },         { 0x5a, 0x88 },
 909                 { 0x5b, 0x44 },         { 0x5c, 0x67 },
 910                 { 0x5d, 0x49 },         { 0x5e, 0x0e },
 911                 { 0x6c, 0x0a },         { 0x6d, 0x55 },
 912                 { 0x6e, 0x11 },         { 0x6f, 0x9f },
 913                                                 /* "9e for advance AWB" */
 914                 { 0x6a, 0x40 },         { OV7670_REG_BLUE, 0x40 },
 915                 { OV7670_REG_RED, 0x60 },
 916                 { OV7670_REG_COM8, OV7670_COM8_FASTAEC
 917                                 | OV7670_COM8_AECSTEP
 918                                 | OV7670_COM8_BFILT
 919                                 | OV7670_COM8_AGC
 920                                 | OV7670_COM8_AEC
 921                                 | OV7670_COM8_AWB },
 922
 923         /* Matrix coefficients */
 924                 { 0x4f, 0x80 },         { 0x50, 0x80 },
 925                 { 0x51, 0 },            { 0x52, 0x22 },
 926                 { 0x53, 0x5e },         { 0x54, 0x80 },
 927                 { 0x58, 0x9e },
 928
 929                 { OV7670_REG_COM16, OV7670_COM16_AWBGAIN },
 930                 { OV7670_REG_EDGE, 0 },
 931                 { 0x75, 0x05 },         { 0x76, 0xe1 },
 932                 { 0x4c, 0 },            { 0x77, 0x01 },
 933                 { OV7670_REG_COM13, OV7670_COM13_GAMMA
 934                                   | OV7670_COM13_UVSAT
 935                                   | 2},         /* was 3 */
 936                 { 0x4b, 0x09 },
 937                 { 0xc9, 0x60 },         { OV7670_REG_COM16, 0x38 },
 938                 { 0x56, 0x40 },
 939
 940                 { 0x34, 0x11 },
 941                 { OV7670_REG_COM11, OV7670_COM11_EXP|OV7670_COM11_HZAUTO },
 942                 { 0xa4, 0x88 },         { 0x96, 0 },
 943                 { 0x97, 0x30 },         { 0x98, 0x20 },
 944                 { 0x99, 0x30 },         { 0x9a, 0x84 },
 945                 { 0x9b, 0x29 },         { 0x9c, 0x03 },
 946                 { 0x9d, 0x4c },         { 0x9e, 0x3f },
 947                 { 0x78, 0x04 },
 948
 949         /* Extra-weird stuff.  Some sort of multiplexor register */
 950                 { 0x79, 0x01 },         { 0xc8, 0xf0 },
 951                 { 0x79, 0x0f },         { 0xc8, 0x00 },
 952                 { 0x79, 0x10 },         { 0xc8, 0x7e },
 953                 { 0x79, 0x0a },         { 0xc8, 0x80 },
 954                 { 0x79, 0x0b },         { 0xc8, 0x01 },
 955                 { 0x79, 0x0c },         { 0xc8, 0x0f },
 956                 { 0x79, 0x0d },         { 0xc8, 0x20 },
 957                 { 0x79, 0x09 },         { 0xc8, 0x80 },
 958                 { 0x79, 0x02 },         { 0xc8, 0xc0 },
 959                 { 0x79, 0x03 },         { 0xc8, 0x40 },
 960                 { 0x79, 0x05 },         { 0xc8, 0x30 },
 961                 { 0x79, 0x26 },
 962         };
 963
 964         PDEBUG(D_PROBE, "starting OV7xx0 configuration");
 965
 966         /* Detect sensor (sub)type */
 967         rc = i2c_r(sd, OV7610_REG_COM_I);
 968
 969         /* add OV7670 here
 970          * it appears to be wrongly detected as a 7610 by default */
 971         if (rc < 0) {
 972                 PDEBUG(D_ERR, "Error detecting sensor type");
 973                 return -1;
 974         }
 975         if ((rc & 3) == 3) {
 976                 /* quick hack to make OV7670s work */
 977                 high = i2c_r(sd, 0x0a);
 978                 low = i2c_r(sd, 0x0b);
 979                 /* info("%x, %x", high, low); */
 980                 if (high == 0x76 && low == 0x73) {
 981                         PDEBUG(D_PROBE, "Sensor is an OV7670");
 982                         sd->sensor = SEN_OV7670;
 983                 } else {
 984                         PDEBUG(D_PROBE, "Sensor is an OV7610");
 985                         sd->sensor = SEN_OV7610;
 986                 }
 987         } else if ((rc & 3) == 1) {
 988                 /* I don't know what's different about the 76BE yet. */
 989                 if (i2c_r(sd, 0x15) & 1)
 990                         PDEBUG(D_PROBE, "Sensor is an OV7620AE");
 991                 else
 992                         PDEBUG(D_PROBE, "Sensor is an OV76BE");
 993
 994                 /* OV511+ will return all zero isoc data unless we
 995                  * configure the sensor as a 7620. Someone needs to
 996                  * find the exact reg. setting that causes this. */
 997                 sd->sensor = SEN_OV76BE;
 998         } else if ((rc & 3) == 0) {
 999                 /* try to read product id registers */
1000                 high = i2c_r(sd, 0x0a);
1001                 if (high < 0) {
1002                         PDEBUG(D_ERR, "Error detecting camera chip PID");
1003                         return high;
1004                 }
1005                 low = i2c_r(sd, 0x0b);
1006                 if (low < 0) {
1007                         PDEBUG(D_ERR, "Error detecting camera chip VER");
1008                         return low;
1009                 }
1010                 if (high == 0x76) {
1011                         switch (low) {
1012                         case 0x30:
1013                                 PDEBUG(D_PROBE, "Sensor is an OV7630/OV7635");
1014                                 sd->sensor = SEN_OV7630;
1015                                 break;
1016                         case 0x40:
1017                                 PDEBUG(D_PROBE, "Sensor is an OV7645");
1018                                 sd->sensor = SEN_OV7640; /* FIXME */
1019                                 break;
1020                         case 0x45:
1021                                 PDEBUG(D_PROBE, "Sensor is an OV7645B");
1022                                 sd->sensor = SEN_OV7640; /* FIXME */
1023                                 break;
1024                         case 0x48:
1025                                 PDEBUG(D_PROBE, "Sensor is an OV7648");
1026                                 sd->sensor = SEN_OV7640; /* FIXME */
1027                                 break;
1028                         default:
1029                                 PDEBUG(D_PROBE, "Unknown sensor: 0x76%x", low);
1030                                 return -1;
1031                         }
1032                 } else {
1033                         PDEBUG(D_PROBE, "Sensor is an OV7620");
1034                         sd->sensor = SEN_OV7620;
1035                 }
1036         } else {
1037                 PDEBUG(D_ERR, "Unknown image sensor version: %d", rc & 3);
1038                 return -1;
1039         }
1040
1041         switch (sd->sensor) {
1042         case SEN_OV7620:
1043                 PDEBUG(D_PROBE, "Writing 7620 registers");
1044                 if (write_i2c_regvals(sd, norm_7620, ARRAY_SIZE(norm_7620)))
1045                         return -1;
1046                 break;
1047         case SEN_OV7630:
1048                 PDEBUG(D_ERR, "7630 is not supported by this driver version");
1049                 return -1;
1050         case SEN_OV7640:
1051                 PDEBUG(D_PROBE, "Writing 7640 registers");
1052                 if (write_i2c_regvals(sd, norm_7640, ARRAY_SIZE(norm_7640)))
1053                         return -1;
1054                 break;
1055         case SEN_OV7670:
1056                 PDEBUG(D_PROBE, "Writing 7670 registers");
1057                 if (write_i2c_regvals(sd, norm_7670, ARRAY_SIZE(norm_7670)))
1058                         return -1;
1059                 break;
1060         default:
1061                 PDEBUG(D_PROBE, "Writing 7610 registers");
1062                 if (write_i2c_regvals(sd, norm_7610, ARRAY_SIZE(norm_7610)))
1063                         return -1;
1064                 break;
1065         }
1066
1067         /* Set sensor-specific vars */
1068 /*      sd->sif = 0;            already done */
1069         return 0;
1070 }
1071
1072 /* This initializes the OV6620, OV6630, OV6630AE, or OV6630AF sensor. */
1073 static int ov6xx0_configure(struct sd *sd)
1074 {
1075         int rc;
1076         static const struct ov_i2c_regvals norm_6x20[] = {
1077                 { 0x12, 0x80 }, /* reset */
1078                 { 0x11, 0x01 },
1079                 { 0x03, 0x60 },
1080                 { 0x05, 0x7f }, /* For when autoadjust is off */
1081                 { 0x07, 0xa8 },
1082                 /* The ratio of 0x0c and 0x0d  controls the white point */
1083                 { 0x0c, 0x24 },
1084                 { 0x0d, 0x24 },
1085                 { 0x0f, 0x15 }, /* COMS */
1086                 { 0x10, 0x75 }, /* AEC Exposure time */
1087                 { 0x12, 0x24 }, /* Enable AGC */
1088                 { 0x14, 0x04 },
1089                 /* 0x16: 0x06 helps frame stability with moving objects */
1090                 { 0x16, 0x06 },
1091 /*              { 0x20, 0x30 },  * Aperture correction enable */
1092                 { 0x26, 0xb2 }, /* BLC enable */
1093                 /* 0x28: 0x05 Selects RGB format if RGB on */
1094                 { 0x28, 0x05 },
1095                 { 0x2a, 0x04 }, /* Disable framerate adjust */
1096 /*              { 0x2b, 0xac },  * Framerate; Set 2a[7] first */
1097                 { 0x2d, 0x99 },
1098                 { 0x33, 0xa0 }, /* Color Processing Parameter */
1099                 { 0x34, 0xd2 }, /* Max A/D range */
1100                 { 0x38, 0x8b },
1101                 { 0x39, 0x40 },
1102
1103                 { 0x3c, 0x39 }, /* Enable AEC mode changing */
1104                 { 0x3c, 0x3c }, /* Change AEC mode */
1105                 { 0x3c, 0x24 }, /* Disable AEC mode changing */
1106
1107                 { 0x3d, 0x80 },
1108                 /* These next two registers (0x4a, 0x4b) are undocumented.
1109                  * They control the color balance */
1110                 { 0x4a, 0x80 },
1111                 { 0x4b, 0x80 },
1112                 { 0x4d, 0xd2 }, /* This reduces noise a bit */
1113                 { 0x4e, 0xc1 },
1114                 { 0x4f, 0x04 },
1115 /* Do 50-53 have any effect? */
1116 /* Toggle 0x12[2] off and on here? */
1117         };
1118
1119         static const struct ov_i2c_regvals norm_6x30[] = {
1120                 { 0x12, 0x80 }, /* Reset */
1121                 { 0x00, 0x1f }, /* Gain */
1122                 { 0x01, 0x99 }, /* Blue gain */
1123                 { 0x02, 0x7c }, /* Red gain */
1124                 { 0x03, 0xc0 }, /* Saturation */
1125                 { 0x05, 0x0a }, /* Contrast */
1126                 { 0x06, 0x95 }, /* Brightness */
1127                 { 0x07, 0x2d }, /* Sharpness */
1128                 { 0x0c, 0x20 },
1129                 { 0x0d, 0x20 },
1130                 { 0x0e, 0x20 },
1131                 { 0x0f, 0x05 },
1132                 { 0x10, 0x9a },
1133                 { 0x11, 0x00 }, /* Pixel clock = fastest */
1134                 { 0x12, 0x24 }, /* Enable AGC and AWB */
1135                 { 0x13, 0x21 },
1136                 { 0x14, 0x80 },
1137                 { 0x15, 0x01 },
1138                 { 0x16, 0x03 },
1139                 { 0x17, 0x38 },
1140                 { 0x18, 0xea },
1141                 { 0x19, 0x04 },
1142                 { 0x1a, 0x93 },
1143                 { 0x1b, 0x00 },
1144                 { 0x1e, 0xc4 },
1145                 { 0x1f, 0x04 },
1146                 { 0x20, 0x20 },
1147                 { 0x21, 0x10 },
1148                 { 0x22, 0x88 },
1149                 { 0x23, 0xc0 }, /* Crystal circuit power level */
1150                 { 0x25, 0x9a }, /* Increase AEC black ratio */
1151                 { 0x26, 0xb2 }, /* BLC enable */
1152                 { 0x27, 0xa2 },
1153                 { 0x28, 0x00 },
1154                 { 0x29, 0x00 },
1155                 { 0x2a, 0x84 }, /* 60 Hz power */
1156                 { 0x2b, 0xa8 }, /* 60 Hz power */
1157                 { 0x2c, 0xa0 },
1158                 { 0x2d, 0x95 }, /* Enable auto-brightness */
1159                 { 0x2e, 0x88 },
1160                 { 0x33, 0x26 },
1161                 { 0x34, 0x03 },
1162                 { 0x36, 0x8f },
1163                 { 0x37, 0x80 },
1164                 { 0x38, 0x83 },
1165                 { 0x39, 0x80 },
1166                 { 0x3a, 0x0f },
1167                 { 0x3b, 0x3c },
1168                 { 0x3c, 0x1a },
1169                 { 0x3d, 0x80 },
1170                 { 0x3e, 0x80 },
1171                 { 0x3f, 0x0e },
1172                 { 0x40, 0x00 }, /* White bal */
1173                 { 0x41, 0x00 }, /* White bal */
1174                 { 0x42, 0x80 },
1175                 { 0x43, 0x3f }, /* White bal */
1176                 { 0x44, 0x80 },
1177                 { 0x45, 0x20 },
1178                 { 0x46, 0x20 },
1179                 { 0x47, 0x80 },
1180                 { 0x48, 0x7f },
1181                 { 0x49, 0x00 },
1182                 { 0x4a, 0x00 },
1183                 { 0x4b, 0x80 },
1184                 { 0x4c, 0xd0 },
1185                 { 0x4d, 0x10 }, /* U = 0.563u, V = 0.714v */
1186                 { 0x4e, 0x40 },
1187                 { 0x4f, 0x07 }, /* UV avg., col. killer: max */
1188                 { 0x50, 0xff },
1189                 { 0x54, 0x23 }, /* Max AGC gain: 18dB */
1190                 { 0x55, 0xff },
1191                 { 0x56, 0x12 },
1192                 { 0x57, 0x81 },
1193                 { 0x58, 0x75 },
1194                 { 0x59, 0x01 }, /* AGC dark current comp.: +1 */
1195                 { 0x5a, 0x2c },
1196                 { 0x5b, 0x0f }, /* AWB chrominance levels */
1197                 { 0x5c, 0x10 },
1198                 { 0x3d, 0x80 },
1199                 { 0x27, 0xa6 },
1200                 { 0x12, 0x20 }, /* Toggle AWB */
1201                 { 0x12, 0x24 },
1202         };
1203
1204         PDEBUG(D_PROBE, "starting sensor configuration");
1205
1206         if (init_ov_sensor(sd) < 0) {
1207                 PDEBUG(D_ERR, "Failed to read sensor ID.");
1208                 return -1;
1209         }
1210         PDEBUG(D_PROBE, "OV6xx0 sensor detected");
1211
1212         /* Detect sensor (sub)type */
1213         rc = i2c_r(sd, OV7610_REG_COM_I);
1214         if (rc < 0) {
1215                 PDEBUG(D_ERR, "Error detecting sensor type");
1216                 return -1;
1217         }
1218
1219         /* Ugh. The first two bits are the version bits, but
1220          * the entire register value must be used. I guess OVT
1221          * underestimated how many variants they would make. */
1222         switch (rc) {
1223         case 0x00:
1224                 sd->sensor = SEN_OV6630;
1225                 PDEBUG(D_ERR,
1226                         "WARNING: Sensor is an OV66308. Your camera may have");
1227                 PDEBUG(D_ERR, "been misdetected in previous driver versions.");
1228                 break;
1229         case 0x01:
1230                 sd->sensor = SEN_OV6620;
1231                 break;
1232         case 0x02:
1233                 sd->sensor = SEN_OV6630;
1234                 PDEBUG(D_PROBE, "Sensor is an OV66308AE");
1235                 break;
1236         case 0x03:
1237                 sd->sensor = SEN_OV6630;
1238                 PDEBUG(D_PROBE, "Sensor is an OV66308AF");
1239                 break;
1240         case 0x90:
1241                 sd->sensor = SEN_OV6630;
1242                 PDEBUG(D_ERR,
1243                         "WARNING: Sensor is an OV66307. Your camera may have");
1244                 PDEBUG(D_ERR, "been misdetected in previous driver versions.");
1245                 break;
1246         default:
1247                 PDEBUG(D_ERR, "FATAL: Unknown sensor version: 0x%02x", rc);
1248                 return -1;
1249         }
1250
1251         /* Set sensor-specific vars */
1252         sd->sif = 1;
1253
1254         if (sd->sensor == SEN_OV6620) {
1255                 PDEBUG(D_PROBE, "Writing 6x20 registers");
1256                 if (write_i2c_regvals(sd, norm_6x20, ARRAY_SIZE(norm_6x20)))
1257                         return -1;
1258         } else {
1259                 PDEBUG(D_PROBE, "Writing 6x30 registers");
1260                 if (write_i2c_regvals(sd, norm_6x30, ARRAY_SIZE(norm_6x30)))
1261                         return -1;
1262         }
1263         return 0;
1264 }
1265
1266 /* Turns on or off the LED. Only has an effect with OV511+/OV518(+)/OV519 */
1267 static void ov51x_led_control(struct sd *sd, int on)
1268 {
1269 /*      PDEBUG(D_STREAM, "LED (%s)", on ? "on" : "off"); */
1270         reg_w_mask(sd, OV519_GPIO_DATA_OUT0, !on, 1);   /* 0 / 1 */
1271 }
1272
1273 /* this function is called at probe time */
1274 static int sd_config(struct gspca_dev *gspca_dev,
1275                         const struct usb_device_id *id)
1276 {
1277         struct sd *sd = (struct sd *) gspca_dev;
1278         struct cam *cam;
1279
1280         static const struct ov_regvals init_519[] = {
1281                 { 0x5a,  0x6d }, /* EnableSystem */
1282                 { 0x53,  0x9b },
1283                 { 0x54,  0xff }, /* set bit2 to enable jpeg */
1284                 { 0x5d,  0x03 },
1285                 { 0x49,  0x01 },
1286                 { 0x48,  0x00 },
1287                 /* Set LED pin to output mode. Bit 4 must be cleared or sensor
1288                  * detection will fail. This deserves further investigation. */
1289                 { OV519_GPIO_IO_CTRL0,   0xee },
1290                 { 0x51,  0x0f }, /* SetUsbInit */
1291                 { 0x51,  0x00 },
1292                 { 0x22,  0x00 },
1293                 /* windows reads 0x55 at this point*/
1294         };
1295
1296         if (write_regvals(sd, init_519, ARRAY_SIZE(init_519)))
1297                 goto error;
1298         ov51x_led_control(sd, 0);       /* turn LED off */
1299
1300         /* Test for 76xx */
1301         sd->primary_i2c_slave = OV7xx0_SID;
1302         if (ov51x_set_slave_ids(sd, OV7xx0_SID) < 0)
1303                 goto error;
1304
1305         /* The OV519 must be more aggressive about sensor detection since
1306          * I2C write will never fail if the sensor is not present. We have
1307          * to try to initialize the sensor to detect its presence */
1308         if (init_ov_sensor(sd) < 0) {
1309                 /* Test for 6xx0 */
1310                 sd->primary_i2c_slave = OV6xx0_SID;
1311                 if (ov51x_set_slave_ids(sd, OV6xx0_SID) < 0)
1312                         goto error;
1313
1314                 if (init_ov_sensor(sd) < 0) {
1315                         /* Test for 8xx0 */
1316                         sd->primary_i2c_slave = OV8xx0_SID;
1317                         if (ov51x_set_slave_ids(sd, OV8xx0_SID) < 0)
1318                                 goto error;
1319
1320                         if (init_ov_sensor(sd) < 0) {
1321                                 PDEBUG(D_ERR,
1322                                         "Can't determine sensor slave IDs");
1323                                 goto error;
1324                         } else {
1325                                 if (ov8xx0_configure(sd) < 0) {
1326                                         PDEBUG(D_ERR,
1327                                            "Failed to configure OV8xx0 sensor");
1328                                         goto error;
1329                                 }
1330                         }
1331                 } else {
1332                         if (ov6xx0_configure(sd) < 0) {
1333                                 PDEBUG(D_ERR, "Failed to configure OV6xx0");
1334                                 goto error;
1335                         }
1336                 }
1337         } else {
1338                 if (ov7xx0_configure(sd) < 0) {
1339                         PDEBUG(D_ERR, "Failed to configure OV7xx0");
1340                         goto error;
1341                 }
1342         }
1343
1344         cam = &gspca_dev->cam;
1345         cam->epaddr = OV511_ENDPOINT_ADDRESS;
1346         if (!sd->sif) {
1347                 cam->cam_mode = vga_mode;
1348                 cam->nmodes = ARRAY_SIZE(vga_mode);
1349         } else {
1350                 cam->cam_mode = sif_mode;
1351                 cam->nmodes = ARRAY_SIZE(sif_mode);
1352         }
1353         sd->brightness = BRIGHTNESS_DEF;
1354         sd->contrast = CONTRAST_DEF;
1355         sd->colors = COLOR_DEF;
1356         sd->hflip = HFLIP_DEF;
1357         sd->vflip = VFLIP_DEF;
1358         return 0;
1359 error:
1360         PDEBUG(D_ERR, "OV519 Config failed");
1361         return -EBUSY;
1362 }
1363
1364 /* this function is called at open time */
1365 static int sd_open(struct gspca_dev *gspca_dev)
1366 {
1367         return 0;
1368 }
1369
1370 /* Sets up the OV519 with the given image parameters
1371  *
1372  * OV519 needs a completely different approach, until we can figure out what
1373  * the individual registers do.
1374  *
1375  * Do not put any sensor-specific code in here (including I2C I/O functions)
1376  */
1377 static int ov519_mode_init_regs(struct sd *sd)
1378 {
1379         static const struct ov_regvals mode_init_519_ov7670[] = {
1380                 { 0x5d, 0x03 }, /* Turn off suspend mode */
1381                 { 0x53, 0x9f }, /* was 9b in 1.65-1.08 */
1382                 { 0x54, 0x0f }, /* bit2 (jpeg enable) */
1383                 { 0xa2, 0x20 }, /* a2-a5 are undocumented */
1384                 { 0xa3, 0x18 },
1385                 { 0xa4, 0x04 },
1386                 { 0xa5, 0x28 },
1387                 { 0x37, 0x00 }, /* SetUsbInit */
1388                 { 0x55, 0x02 }, /* 4.096 Mhz audio clock */
1389                 /* Enable both fields, YUV Input, disable defect comp (why?) */
1390                 { 0x20, 0x0c },
1391                 { 0x21, 0x38 },
1392                 { 0x22, 0x1d },
1393                 { 0x17, 0x50 }, /* undocumented */
1394                 { 0x37, 0x00 }, /* undocumented */
1395                 { 0x40, 0xff }, /* I2C timeout counter */
1396                 { 0x46, 0x00 }, /* I2C clock prescaler */
1397                 { 0x59, 0x04 }, /* new from windrv 090403 */
1398                 { 0xff, 0x00 }, /* undocumented */
1399                 /* windows reads 0x55 at this point, why? */
1400         };
1401
1402         static const struct ov_regvals mode_init_519[] = {
1403                 { 0x5d, 0x03 }, /* Turn off suspend mode */
1404                 { 0x53, 0x9f }, /* was 9b in 1.65-1.08 */
1405                 { 0x54, 0x0f }, /* bit2 (jpeg enable) */
1406                 { 0xa2, 0x20 }, /* a2-a5 are undocumented */
1407                 { 0xa3, 0x18 },
1408                 { 0xa4, 0x04 },
1409                 { 0xa5, 0x28 },
1410                 { 0x37, 0x00 }, /* SetUsbInit */
1411                 { 0x55, 0x02 }, /* 4.096 Mhz audio clock */
1412                 /* Enable both fields, YUV Input, disable defect comp (why?) */
1413                 { 0x22, 0x1d },
1414                 { 0x17, 0x50 }, /* undocumented */
1415                 { 0x37, 0x00 }, /* undocumented */
1416                 { 0x40, 0xff }, /* I2C timeout counter */
1417                 { 0x46, 0x00 }, /* I2C clock prescaler */
1418                 { 0x59, 0x04 }, /* new from windrv 090403 */
1419                 { 0xff, 0x00 }, /* undocumented */
1420                 /* windows reads 0x55 at this point, why? */
1421         };
1422
1423         /******** Set the mode ********/
1424         if (sd->sensor != SEN_OV7670) {
1425                 if (write_regvals(sd, mode_init_519,
1426                                   ARRAY_SIZE(mode_init_519)))
1427                         return -EIO;
1428                 if (sd->sensor == SEN_OV7640) {
1429                         /* Select 8-bit input mode */
1430                         reg_w_mask(sd, OV519_CAM_DFR, 0x10, 0x10);
1431                 }
1432         } else {
1433                 if (write_regvals(sd, mode_init_519_ov7670,
1434                                   ARRAY_SIZE(mode_init_519_ov7670)))
1435                         return -EIO;
1436         }
1437
1438         reg_w(sd, OV519_CAM_H_SIZE,     sd->gspca_dev.width >> 4);
1439         reg_w(sd, OV519_CAM_V_SIZE,     sd->gspca_dev.height >> 3);
1440         reg_w(sd, OV519_CAM_X_OFFSETL,  0x00);
1441         reg_w(sd, OV519_CAM_X_OFFSETH,  0x00);
1442         reg_w(sd, OV519_CAM_Y_OFFSETL,  0x00);
1443         reg_w(sd, OV519_CAM_Y_OFFSETH,  0x00);
1444         reg_w(sd, OV519_CAM_DIVIDER,    0x00);
1445         reg_w(sd, OV519_CAM_FORMAT,     0x03); /* YUV422 */
1446         reg_w(sd, 0x26,                 0x00); /* Undocumented */
1447
1448         /******** Set the framerate ********/
1449         if (frame_rate > 0)
1450                 sd->frame_rate = frame_rate;
1451
1452 /* FIXME: These are only valid at the max resolution. */
1453         sd->clockdiv = 0;
1454         switch (sd->sensor) {
1455         case SEN_OV7640:
1456                 switch (sd->frame_rate) {
1457 /*fixme: default was 30 fps */
1458                 case 30:
1459                         reg_w(sd, 0xa4, 0x0c);
1460                         reg_w(sd, 0x23, 0xff);
1461                         break;
1462                 case 25:
1463                         reg_w(sd, 0xa4, 0x0c);
1464                         reg_w(sd, 0x23, 0x1f);
1465                         break;
1466                 case 20:
1467                         reg_w(sd, 0xa4, 0x0c);
1468                         reg_w(sd, 0x23, 0x1b);
1469                         break;
1470                 default:
1471 /*              case 15: */
1472                         reg_w(sd, 0xa4, 0x04);
1473                         reg_w(sd, 0x23, 0xff);
1474                         sd->clockdiv = 1;
1475                         break;
1476                 case 10:
1477                         reg_w(sd, 0xa4, 0x04);
1478                         reg_w(sd, 0x23, 0x1f);
1479                         sd->clockdiv = 1;
1480                         break;
1481                 case 5:
1482                         reg_w(sd, 0xa4, 0x04);
1483                         reg_w(sd, 0x23, 0x1b);
1484                         sd->clockdiv = 1;
1485                         break;
1486                 }
1487                 break;
1488         case SEN_OV8610:
1489                 switch (sd->frame_rate) {
1490                 default:        /* 15 fps */
1491 /*              case 15: */
1492                         reg_w(sd, 0xa4, 0x06);
1493                         reg_w(sd, 0x23, 0xff);
1494                         break;
1495                 case 10:
1496                         reg_w(sd, 0xa4, 0x06);
1497                         reg_w(sd, 0x23, 0x1f);
1498                         break;
1499                 case 5:
1500                         reg_w(sd, 0xa4, 0x06);
1501                         reg_w(sd, 0x23, 0x1b);
1502                         break;
1503                 }
1504                 break;
1505         case SEN_OV7670:                /* guesses, based on 7640 */
1506                 PDEBUG(D_STREAM, "Setting framerate to %d fps",
1507                                  (sd->frame_rate == 0) ? 15 : sd->frame_rate);
1508                 reg_w(sd, 0xa4, 0x10);
1509                 switch (sd->frame_rate) {
1510                 case 30:
1511                         reg_w(sd, 0x23, 0xff);
1512                         break;
1513                 case 20:
1514                         reg_w(sd, 0x23, 0x1b);
1515                         break;
1516                 default:
1517 /*              case 15: */
1518                         reg_w(sd, 0x23, 0xff);
1519                         sd->clockdiv = 1;
1520                         break;
1521                 }
1522                 break;
1523         }
1524
1525         return 0;
1526 }
1527
1528 static int mode_init_ov_sensor_regs(struct sd *sd)
1529 {
1530         struct gspca_dev *gspca_dev;
1531         int qvga;
1532
1533         gspca_dev = &sd->gspca_dev;
1534         qvga = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
1535
1536         /******** Mode (VGA/QVGA) and sensor specific regs ********/
1537         switch (sd->sensor) {
1538         case SEN_OV8610:
1539                 /* For OV8610 qvga means qsvga */
1540                 i2c_w_mask(sd, OV7610_REG_COM_C, qvga ? (1 << 5) : 0, 1 << 5);
1541                 break;
1542         case SEN_OV7610:
1543                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1544                 break;
1545         case SEN_OV7620:
1546 /*              i2c_w(sd, 0x2b, 0x00); */
1547                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1548                 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
1549                 i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a);
1550                 i2c_w(sd, 0x25, qvga ? 0x30 : 0x60);
1551                 i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40);
1552                 i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0);
1553                 i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20);
1554                 break;
1555         case SEN_OV76BE:
1556 /*              i2c_w(sd, 0x2b, 0x00); */
1557                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1558                 break;
1559         case SEN_OV7640:
1560 /*              i2c_w(sd, 0x2b, 0x00); */
1561                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1562                 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
1563 /*              i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a); */
1564 /*              i2c_w(sd, 0x25, qvga ? 0x30 : 0x60); */
1565 /*              i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40); */
1566 /*              i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0); */
1567 /*              i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20); */
1568                 break;
1569         case SEN_OV7670:
1570                 /* set COM7_FMT_VGA or COM7_FMT_QVGA
1571                  * do we need to set anything else?
1572                  *      HSTART etc are set in set_ov_sensor_window itself */
1573                 i2c_w_mask(sd, OV7670_REG_COM7,
1574                          qvga ? OV7670_COM7_FMT_QVGA : OV7670_COM7_FMT_VGA,
1575                          OV7670_COM7_FMT_MASK);
1576                 break;
1577         case SEN_OV6620:
1578         case SEN_OV6630:
1579                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1580                 break;
1581         default:
1582                 return -EINVAL;
1583         }
1584
1585         /******** Palette-specific regs ********/
1586         if (sd->sensor == SEN_OV7610 || sd->sensor == SEN_OV76BE) {
1587                 /* not valid on the OV6620/OV7620/6630? */
1588                 i2c_w_mask(sd, 0x0e, 0x00, 0x40);
1589         }
1590
1591         /* The OV518 needs special treatment. Although both the OV518
1592          * and the OV6630 support a 16-bit video bus, only the 8 bit Y
1593          * bus is actually used. The UV bus is tied to ground.
1594          * Therefore, the OV6630 needs to be in 8-bit multiplexed
1595          * output mode */
1596
1597         /* OV7640 is 8-bit only */
1598
1599         if (sd->sensor != SEN_OV6630 && sd->sensor != SEN_OV7640)
1600                 i2c_w_mask(sd, 0x13, 0x00, 0x20);
1601
1602         /******** Clock programming ********/
1603         /* The OV6620 needs special handling. This prevents the
1604          * severe banding that normally occurs */
1605         if (sd->sensor == SEN_OV6620) {
1606
1607                 /* Clock down */
1608                 i2c_w(sd, 0x2a, 0x04);
1609                 i2c_w(sd, 0x11, sd->clockdiv);
1610                 i2c_w(sd, 0x2a, 0x84);
1611                 /* This next setting is critical. It seems to improve
1612                  * the gain or the contrast. The "reserved" bits seem
1613                  * to have some effect in this case. */
1614                 i2c_w(sd, 0x2d, 0x85);
1615         } else if (sd->clockdiv >= 0) {
1616                 i2c_w(sd, 0x11, sd->clockdiv);
1617         }
1618
1619         /******** Special Features ********/
1620 /* no evidence this is possible with OV7670, either */
1621         /* Test Pattern */
1622         if (sd->sensor != SEN_OV7640 && sd->sensor != SEN_OV7670)
1623                 i2c_w_mask(sd, 0x12, 0x00, 0x02);
1624
1625         /* Enable auto white balance */
1626         if (sd->sensor == SEN_OV7670)
1627                 i2c_w_mask(sd, OV7670_REG_COM8, OV7670_COM8_AWB,
1628                                 OV7670_COM8_AWB);
1629         else
1630                 i2c_w_mask(sd, 0x12, 0x04, 0x04);
1631
1632         /* This will go away as soon as ov51x_mode_init_sensor_regs() */
1633         /* is fully tested. */
1634         /* 7620/6620/6630? don't have register 0x35, so play it safe */
1635         if (sd->sensor == SEN_OV7610 || sd->sensor == SEN_OV76BE) {
1636                 if (!qvga)
1637                         i2c_w(sd, 0x35, 0x9e);
1638                 else
1639                         i2c_w(sd, 0x35, 0x1e);
1640         }
1641         return 0;
1642 }
1643
1644 static void sethvflip(struct sd *sd)
1645 {
1646         if (sd->sensor != SEN_OV7670)
1647                 return;
1648         if (sd->gspca_dev.streaming)
1649                 ov51x_stop(sd);
1650         i2c_w_mask(sd, OV7670_REG_MVFP,
1651                 OV7670_MVFP_MIRROR * sd->hflip
1652                         | OV7670_MVFP_VFLIP * sd->vflip,
1653                 OV7670_MVFP_MIRROR | OV7670_MVFP_VFLIP);
1654         if (sd->gspca_dev.streaming)
1655                 ov51x_restart(sd);
1656 }
1657
1658 static int set_ov_sensor_window(struct sd *sd)
1659 {
1660         struct gspca_dev *gspca_dev;
1661         int qvga;
1662         int hwsbase, hwebase, vwsbase, vwebase, hwscale, vwscale;
1663         int ret, hstart, hstop, vstop, vstart;
1664         __u8 v;
1665
1666         gspca_dev = &sd->gspca_dev;
1667         qvga = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
1668
1669         /* The different sensor ICs handle setting up of window differently.
1670          * IF YOU SET IT WRONG, YOU WILL GET ALL ZERO ISOC DATA FROM OV51x!! */
1671         switch (sd->sensor) {
1672         case SEN_OV8610:
1673                 hwsbase = 0x1e;
1674                 hwebase = 0x1e;
1675                 vwsbase = 0x02;
1676                 vwebase = 0x02;
1677                 break;
1678         case SEN_OV7610:
1679         case SEN_OV76BE:
1680                 hwsbase = 0x38;
1681                 hwebase = 0x3a;
1682                 vwsbase = vwebase = 0x05;
1683                 break;
1684         case SEN_OV6620:
1685         case SEN_OV6630:
1686                 hwsbase = 0x38;
1687                 hwebase = 0x3a;
1688                 vwsbase = 0x05;
1689                 vwebase = 0x06;
1690                 break;
1691         case SEN_OV7620:
1692                 hwsbase = 0x2f;         /* From 7620.SET (spec is wrong) */
1693                 hwebase = 0x2f;
1694                 vwsbase = vwebase = 0x05;
1695                 break;
1696         case SEN_OV7640:
1697                 hwsbase = 0x1a;
1698                 hwebase = 0x1a;
1699                 vwsbase = vwebase = 0x03;
1700                 break;
1701         case SEN_OV7670:
1702                 /*handling of OV7670 hardware sensor start and stop values
1703                  * is very odd, compared to the other OV sensors */
1704                 vwsbase = vwebase = hwebase = hwsbase = 0x00;
1705                 break;
1706         default:
1707                 return -EINVAL;
1708         }
1709
1710         switch (sd->sensor) {
1711         case SEN_OV6620:
1712         case SEN_OV6630:
1713                 if (qvga) {             /* QCIF */
1714                         hwscale = 0;
1715                         vwscale = 0;
1716                 } else {                /* CIF */
1717                         hwscale = 1;
1718                         vwscale = 1;    /* The datasheet says 0;
1719                                          * it's wrong */
1720                 }
1721                 break;
1722         case SEN_OV8610:
1723                 if (qvga) {             /* QSVGA */
1724                         hwscale = 1;
1725                         vwscale = 1;
1726                 } else {                /* SVGA */
1727                         hwscale = 2;
1728                         vwscale = 2;
1729                 }
1730                 break;
1731         default:                        /* SEN_OV7xx0 */
1732                 if (qvga) {             /* QVGA */
1733                         hwscale = 1;
1734                         vwscale = 0;
1735                 } else {                /* VGA */
1736                         hwscale = 2;
1737                         vwscale = 1;
1738                 }
1739         }
1740
1741         ret = mode_init_ov_sensor_regs(sd);
1742         if (ret < 0)
1743                 return ret;
1744
1745         if (sd->sensor == SEN_OV8610) {
1746                 i2c_w_mask(sd, 0x2d, 0x05, 0x40);
1747                                 /* old 0x95, new 0x05 from windrv 090403 */
1748                                                 /* bits 5-7: reserved */
1749                 i2c_w_mask(sd, 0x28, 0x20, 0x20);
1750                                         /* bit 5: progressive mode on */
1751         }
1752
1753         /* The below is wrong for OV7670s because their window registers
1754          * only store the high bits in 0x17 to 0x1a */
1755
1756         /* SRH Use sd->max values instead of requested win values */
1757         /* SCS Since we're sticking with only the max hardware widths
1758          * for a given mode */
1759         /* I can hard code this for OV7670s */
1760         /* Yes, these numbers do look odd, but they're tested and work! */
1761         if (sd->sensor == SEN_OV7670) {
1762                 if (qvga) {             /* QVGA from ov7670.c by
1763                                          * Jonathan Corbet */
1764                         hstart = 164;
1765                         hstop = 20;
1766                         vstart = 14;
1767                         vstop = 494;
1768                 } else {                /* VGA */
1769                         hstart = 158;
1770                         hstop = 14;
1771                         vstart = 10;
1772                         vstop = 490;
1773                 }
1774                 /* OV7670 hardware window registers are split across
1775                  * multiple locations */
1776                 i2c_w(sd, OV7670_REG_HSTART, hstart >> 3);
1777                 i2c_w(sd, OV7670_REG_HSTOP, hstop >> 3);
1778                 v = i2c_r(sd, OV7670_REG_HREF);
1779                 v = (v & 0xc0) | ((hstop & 0x7) << 3) | (hstart & 0x07);
1780                 msleep(10);     /* need to sleep between read and write to
1781                                  * same reg! */
1782                 i2c_w(sd, OV7670_REG_HREF, v);
1783
1784                 i2c_w(sd, OV7670_REG_VSTART, vstart >> 2);
1785                 i2c_w(sd, OV7670_REG_VSTOP, vstop >> 2);
1786                 v = i2c_r(sd, OV7670_REG_VREF);
1787                 v = (v & 0xc0) | ((vstop & 0x3) << 2) | (vstart & 0x03);
1788                 msleep(10);     /* need to sleep between read and write to
1789                                  * same reg! */
1790                 i2c_w(sd, OV7670_REG_VREF, v);
1791                 sethvflip(sd);
1792         } else {
1793                 i2c_w(sd, 0x17, hwsbase);
1794                 i2c_w(sd, 0x18, hwebase + (sd->gspca_dev.width >> hwscale));
1795                 i2c_w(sd, 0x19, vwsbase);
1796                 i2c_w(sd, 0x1a, vwebase + (sd->gspca_dev.height >> vwscale));
1797         }
1798         return 0;
1799 }
1800
1801 /* -- start the camera -- */
1802 static void sd_start(struct gspca_dev *gspca_dev)
1803 {
1804         struct sd *sd = (struct sd *) gspca_dev;
1805         int ret;
1806
1807         ret = ov519_mode_init_regs(sd);
1808         if (ret < 0)
1809                 goto out;
1810         ret = set_ov_sensor_window(sd);
1811         if (ret < 0)
1812                 goto out;
1813
1814         ret = ov51x_restart(sd);
1815         if (ret < 0)
1816                 goto out;
1817         PDEBUG(D_STREAM, "camera started alt: 0x%02x", gspca_dev->alt);
1818         ov51x_led_control(sd, 1);
1819         return;
1820 out:
1821         PDEBUG(D_ERR, "camera start error:%d", ret);
1822 }
1823
1824 static void sd_stopN(struct gspca_dev *gspca_dev)
1825 {
1826         ov51x_stop((struct sd *) gspca_dev);
1827         ov51x_led_control((struct sd *) gspca_dev, 0);
1828 }
1829
1830 static void sd_stop0(struct gspca_dev *gspca_dev)
1831 {
1832 }
1833
1834 static void sd_close(struct gspca_dev *gspca_dev)
1835 {
1836 }
1837
1838 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1839                         struct gspca_frame *frame,      /* target */
1840                         __u8 *data,                     /* isoc packet */
1841                         int len)                        /* iso packet length */
1842 {
1843         /* Header of ov519 is 16 bytes:
1844          *     Byte     Value      Description
1845          *      0       0xff    magic
1846          *      1       0xff    magic
1847          *      2       0xff    magic
1848          *      3       0xXX    0x50 = SOF, 0x51 = EOF
1849          *      9       0xXX    0x01 initial frame without data,
1850          *                      0x00 standard frame with image
1851          *      14      Lo      in EOF: length of image data / 8
1852          *      15      Hi
1853          */
1854
1855         if (data[0] == 0xff && data[1] == 0xff && data[2] == 0xff) {
1856                 switch (data[3]) {
1857                 case 0x50:              /* start of frame */
1858 #define HDRSZ 16
1859                         data += HDRSZ;
1860                         len -= HDRSZ;
1861 #undef HDRSZ
1862                         if (data[0] == 0xff || data[1] == 0xd8)
1863                                 gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
1864                                                 data, len);
1865                         else
1866                                 gspca_dev->last_packet_type = DISCARD_PACKET;
1867                         return;
1868                 case 0x51:              /* end of frame */
1869                         if (data[9] != 0)
1870                                 gspca_dev->last_packet_type = DISCARD_PACKET;
1871                         gspca_frame_add(gspca_dev, LAST_PACKET, frame,
1872                                         data, 0);
1873                         return;
1874                 }
1875         }
1876
1877         /* intermediate packet */
1878         gspca_frame_add(gspca_dev, INTER_PACKET, frame,
1879                         data, len);
1880 }
1881
1882 /* -- management routines -- */
1883
1884 static void setbrightness(struct gspca_dev *gspca_dev)
1885 {
1886         struct sd *sd = (struct sd *) gspca_dev;
1887         int val;
1888
1889         val = sd->brightness;
1890         PDEBUG(D_CONF, "brightness:%d", val);
1891 /*      if (gspca_dev->streaming)
1892  *              ov51x_stop(sd); */
1893         switch (sd->sensor) {
1894         case SEN_OV8610:
1895         case SEN_OV7610:
1896         case SEN_OV76BE:
1897         case SEN_OV6620:
1898         case SEN_OV6630:
1899         case SEN_OV7640:
1900                 i2c_w(sd, OV7610_REG_BRT, val);
1901                 break;
1902         case SEN_OV7620:
1903                 /* 7620 doesn't like manual changes when in auto mode */
1904 /*fixme
1905  *              if (!sd->auto_brt) */
1906                         i2c_w(sd, OV7610_REG_BRT, val);
1907                 break;
1908         case SEN_OV7670:
1909 /*win trace
1910  *              i2c_w_mask(sd, OV7670_REG_COM8, 0, OV7670_COM8_AEC); */
1911                 i2c_w(sd, OV7670_REG_BRIGHT, ov7670_abs_to_sm(val));
1912                 break;
1913         }
1914 /*      if (gspca_dev->streaming)
1915  *              ov51x_restart(sd); */
1916 }
1917
1918 static void setcontrast(struct gspca_dev *gspca_dev)
1919 {
1920         struct sd *sd = (struct sd *) gspca_dev;
1921         int val;
1922
1923         val = sd->contrast;
1924         PDEBUG(D_CONF, "contrast:%d", val);
1925 /*      if (gspca_dev->streaming)
1926                 ov51x_stop(sd); */
1927         switch (sd->sensor) {
1928         case SEN_OV7610:
1929         case SEN_OV6620:
1930                 i2c_w(sd, OV7610_REG_CNT, val);
1931                 break;
1932         case SEN_OV6630:
1933                 i2c_w_mask(sd, OV7610_REG_CNT, val >> 4, 0x0f);
1934         case SEN_OV8610: {
1935                 static const __u8 ctab[] = {
1936                         0x03, 0x09, 0x0b, 0x0f, 0x53, 0x6f, 0x35, 0x7f
1937                 };
1938
1939                 /* Use Y gamma control instead. Bit 0 enables it. */
1940                 i2c_w(sd, 0x64, ctab[val >> 5]);
1941                 break;
1942             }
1943         case SEN_OV7620: {
1944                 static const __u8 ctab[] = {
1945                         0x01, 0x05, 0x09, 0x11, 0x15, 0x35, 0x37, 0x57,
1946                         0x5b, 0xa5, 0xa7, 0xc7, 0xc9, 0xcf, 0xef, 0xff
1947                 };
1948
1949                 /* Use Y gamma control instead. Bit 0 enables it. */
1950                 i2c_w(sd, 0x64, ctab[val >> 4]);
1951                 break;
1952             }
1953         case SEN_OV7640:
1954                 /* Use gain control instead. */
1955                 i2c_w(sd, OV7610_REG_GAIN, val >> 2);
1956                 break;
1957         case SEN_OV7670:
1958                 /* check that this isn't just the same as ov7610 */
1959                 i2c_w(sd, OV7670_REG_CONTRAS, val >> 1);
1960                 break;
1961         }
1962 /*      if (gspca_dev->streaming)
1963                 ov51x_restart(sd); */
1964 }
1965
1966 static void setcolors(struct gspca_dev *gspca_dev)
1967 {
1968         struct sd *sd = (struct sd *) gspca_dev;
1969         int val;
1970
1971         val = sd->colors;
1972         PDEBUG(D_CONF, "saturation:%d", val);
1973 /*      if (gspca_dev->streaming)
1974                 ov51x_stop(sd); */
1975         switch (sd->sensor) {
1976         case SEN_OV8610:
1977         case SEN_OV7610:
1978         case SEN_OV76BE:
1979         case SEN_OV6620:
1980         case SEN_OV6630:
1981                 i2c_w(sd, OV7610_REG_SAT, val);
1982                 break;
1983         case SEN_OV7620:
1984                 /* Use UV gamma control instead. Bits 0 & 7 are reserved. */
1985 /*              rc = ov_i2c_write(sd->dev, 0x62, (val >> 9) & 0x7e);
1986                 if (rc < 0)
1987                         goto out; */
1988                 i2c_w(sd, OV7610_REG_SAT, val);
1989                 break;
1990         case SEN_OV7640:
1991                 i2c_w(sd, OV7610_REG_SAT, val & 0xf0);
1992                 break;
1993         case SEN_OV7670:
1994                 /* supported later once I work out how to do it
1995                  * transparently fail now! */
1996                 /* set REG_COM13 values for UV sat auto mode */
1997                 break;
1998         }
1999 /*      if (gspca_dev->streaming)
2000                 ov51x_restart(sd); */
2001 }
2002
2003 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
2004 {
2005         struct sd *sd = (struct sd *) gspca_dev;
2006
2007         sd->brightness = val;
2008         setbrightness(gspca_dev);
2009         return 0;
2010 }
2011
2012 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
2013 {
2014         struct sd *sd = (struct sd *) gspca_dev;
2015
2016         *val = sd->brightness;
2017         return 0;
2018 }
2019
2020 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
2021 {
2022         struct sd *sd = (struct sd *) gspca_dev;
2023
2024         sd->contrast = val;
2025         setcontrast(gspca_dev);
2026         return 0;
2027 }
2028
2029 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
2030 {
2031         struct sd *sd = (struct sd *) gspca_dev;
2032
2033         *val = sd->contrast;
2034         return 0;
2035 }
2036
2037 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
2038 {
2039         struct sd *sd = (struct sd *) gspca_dev;
2040
2041         sd->colors = val;
2042         setcolors(gspca_dev);
2043         return 0;
2044 }
2045
2046 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
2047 {
2048         struct sd *sd = (struct sd *) gspca_dev;
2049
2050         *val = sd->colors;
2051         return 0;
2052 }
2053
2054 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
2055 {
2056         struct sd *sd = (struct sd *) gspca_dev;
2057
2058         sd->hflip = val;
2059         sethvflip(sd);
2060         return 0;
2061 }
2062
2063 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
2064 {
2065         struct sd *sd = (struct sd *) gspca_dev;
2066
2067         *val = sd->hflip;
2068         return 0;
2069 }
2070
2071 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
2072 {
2073         struct sd *sd = (struct sd *) gspca_dev;
2074
2075         sd->vflip = val;
2076         sethvflip(sd);
2077         return 0;
2078 }
2079
2080 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
2081 {
2082         struct sd *sd = (struct sd *) gspca_dev;
2083
2084         *val = sd->vflip;
2085         return 0;
2086 }
2087
2088 /* sub-driver description */
2089 static const struct sd_desc sd_desc = {
2090         .name = MODULE_NAME,
2091         .ctrls = sd_ctrls,
2092         .nctrls = ARRAY_SIZE(sd_ctrls),
2093         .config = sd_config,
2094         .open = sd_open,
2095         .start = sd_start,
2096         .stopN = sd_stopN,
2097         .stop0 = sd_stop0,
2098         .close = sd_close,
2099         .pkt_scan = sd_pkt_scan,
2100 };
2101
2102 /* -- module initialisation -- */
2103 static const __devinitdata struct usb_device_id device_table[] = {
2104         {USB_DEVICE(0x041e, 0x4052)},
2105         {USB_DEVICE(0x041e, 0x405f)},
2106         {USB_DEVICE(0x041e, 0x4060)},
2107         {USB_DEVICE(0x041e, 0x4061)},
2108         {USB_DEVICE(0x041e, 0x4064)},
2109         {USB_DEVICE(0x041e, 0x4068)},
2110         {USB_DEVICE(0x045e, 0x028c)},
2111         {USB_DEVICE(0x054c, 0x0154)},
2112         {USB_DEVICE(0x054c, 0x0155)},
2113         {USB_DEVICE(0x05a9, 0x0519)},
2114         {USB_DEVICE(0x05a9, 0x0530)},
2115         {USB_DEVICE(0x05a9, 0x4519)},
2116         {USB_DEVICE(0x05a9, 0x8519)},
2117         {}
2118 };
2119 #undef DVNAME
2120 MODULE_DEVICE_TABLE(usb, device_table);
2121
2122 /* -- device connect -- */
2123 static int sd_probe(struct usb_interface *intf,
2124                         const struct usb_device_id *id)
2125 {
2126         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
2127                                 THIS_MODULE);
2128 }
2129
2130 static struct usb_driver sd_driver = {
2131         .name = MODULE_NAME,
2132         .id_table = device_table,
2133         .probe = sd_probe,
2134         .disconnect = gspca_disconnect,
2135 };
2136
2137 /* -- module insert / remove -- */
2138 static int __init sd_mod_init(void)
2139 {
2140         if (usb_register(&sd_driver) < 0)
2141                 return -1;
2142         PDEBUG(D_PROBE, "registered");
2143         return 0;
2144 }
2145 static void __exit sd_mod_exit(void)
2146 {
2147         usb_deregister(&sd_driver);
2148         PDEBUG(D_PROBE, "deregistered");
2149 }
2150
2151 module_init(sd_mod_init);
2152 module_exit(sd_mod_exit);
2153
2154 module_param(frame_rate, int, 0644);
2155 MODULE_PARM_DESC(frame_rate, "Frame rate (5, 10, 15, 20 or 30 fps)");