4 * Copyright (C) 2008 Jean-Francois Moine (http://moinejf.free.fr)
6 * (This module is adapted from the ov51x-jpeg package)
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
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.
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
23 #define MODULE_NAME "ov519"
27 #define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5)
28 static const char version[] = "2.1.5";
30 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
31 MODULE_DESCRIPTION("OV519 USB Camera Driver");
32 MODULE_LICENSE("GPL");
34 /* global parameters */
35 static int frame_rate;
37 /* Number of times to retry a failed I2C transaction. Increase this if you
38 * are getting "Failed to read sensor ID..." */
39 static int i2c_detect_tries = 10;
41 /* ov519 device descriptor */
43 struct gspca_dev gspca_dev; /* !! must be the first item */
45 /* Determined by sensor type */
49 unsigned char primary_i2c_slave; /* I2C write id of sensor */
51 unsigned char brightness;
52 unsigned char contrast;
55 char compress; /* Should the next frame be compressed? */
56 char compress_inited; /* Are compression params uploaded? */
57 char stopped; /* Streaming is temporarily paused */
59 char frame_rate; /* current Framerate (OV519 only) */
60 char clockdiv; /* clockdiv override for OV519 only */
62 char sensor; /* Type of image sensor chip (SEN_*) */
76 /* V4L2 controls supported by the driver */
77 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
78 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
79 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
80 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
81 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
82 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
84 static struct ctrl sd_ctrls[] = {
85 #define SD_BRIGHTNESS 0
88 .id = V4L2_CID_BRIGHTNESS,
89 .type = V4L2_CTRL_TYPE_INTEGER,
96 .set = sd_setbrightness,
97 .get = sd_getbrightness,
102 .id = V4L2_CID_CONTRAST,
103 .type = V4L2_CTRL_TYPE_INTEGER,
108 .default_value = 127,
110 .set = sd_setcontrast,
111 .get = sd_getcontrast,
116 .id = V4L2_CID_SATURATION,
117 .type = V4L2_CTRL_TYPE_INTEGER,
118 .name = "Saturation",
122 .default_value = 127,
129 static struct v4l2_pix_format vga_mode[] = {
130 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
132 .sizeimage = 320 * 240 * 3 / 8 + 589,
133 .colorspace = V4L2_COLORSPACE_JPEG,
135 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
137 .sizeimage = 640 * 480 * 3 / 8 + 590,
138 .colorspace = V4L2_COLORSPACE_JPEG,
141 static struct v4l2_pix_format sif_mode[] = {
142 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
144 .sizeimage = 176 * 144 * 3 / 8 + 589,
145 .colorspace = V4L2_COLORSPACE_JPEG,
147 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
149 .sizeimage = 352 * 288 * 3 / 8 + 589,
150 .colorspace = V4L2_COLORSPACE_JPEG,
154 /* OV519 Camera interface register numbers */
155 #define OV519_CAM_H_SIZE 0x10
156 #define OV519_CAM_V_SIZE 0x11
157 #define OV519_CAM_X_OFFSETL 0x12
158 #define OV519_CAM_X_OFFSETH 0x13
159 #define OV519_CAM_Y_OFFSETL 0x14
160 #define OV519_CAM_Y_OFFSETH 0x15
161 #define OV519_CAM_DIVIDER 0x16
162 #define OV519_CAM_DFR 0x20
163 #define OV519_CAM_FORMAT 0x25
165 /* OV519 System Controller register numbers */
166 #define OV519_SYS_RESET1 0x51
167 #define OV519_SYS_EN_CLK1 0x54
169 #define OV519_GPIO_DATA_OUT0 0x71
170 #define OV519_GPIO_IO_CTRL0 0x72
172 #define OV511_ENDPOINT_ADDRESS 1 /* Isoc endpoint number */
175 #define R51x_I2C_W_SID 0x41
176 #define R51x_I2C_SADDR_3 0x42
177 #define R51x_I2C_SADDR_2 0x43
178 #define R51x_I2C_R_SID 0x44
179 #define R51x_I2C_DATA 0x45
180 #define R518_I2C_CTL 0x47 /* OV518(+) only */
183 #define OV7xx0_SID 0x42
184 #define OV8xx0_SID 0xa0
185 #define OV6xx0_SID 0xc0
187 /* OV7610 registers */
188 #define OV7610_REG_GAIN 0x00 /* gain setting (5:0) */
189 #define OV7610_REG_SAT 0x03 /* saturation */
190 #define OV8610_REG_HUE 0x04 /* 04 reserved */
191 #define OV7610_REG_CNT 0x05 /* Y contrast */
192 #define OV7610_REG_BRT 0x06 /* Y brightness */
193 #define OV7610_REG_COM_C 0x14 /* misc common regs */
194 #define OV7610_REG_ID_HIGH 0x1c /* manufacturer ID MSB */
195 #define OV7610_REG_ID_LOW 0x1d /* manufacturer ID LSB */
196 #define OV7610_REG_COM_I 0x29 /* misc settings */
198 /* OV7670 registers */
199 #define OV7670_REG_GAIN 0x00 /* Gain lower 8 bits (rest in vref) */
200 #define OV7670_REG_BLUE 0x01 /* blue gain */
201 #define OV7670_REG_RED 0x02 /* red gain */
202 #define OV7670_REG_VREF 0x03 /* Pieces of GAIN, VSTART, VSTOP */
203 #define OV7670_REG_COM1 0x04 /* Control 1 */
204 #define OV7670_REG_AECHH 0x07 /* AEC MS 5 bits */
205 #define OV7670_REG_COM3 0x0c /* Control 3 */
206 #define OV7670_REG_COM4 0x0d /* Control 4 */
207 #define OV7670_REG_COM5 0x0e /* All "reserved" */
208 #define OV7670_REG_COM6 0x0f /* Control 6 */
209 #define OV7670_REG_AECH 0x10 /* More bits of AEC value */
210 #define OV7670_REG_CLKRC 0x11 /* Clock control */
211 #define OV7670_REG_COM7 0x12 /* Control 7 */
212 #define OV7670_COM7_FMT_VGA 0x00
213 #define OV7670_COM7_YUV 0x00 /* YUV */
214 #define OV7670_COM7_FMT_QVGA 0x10 /* QVGA format */
215 #define OV7670_COM7_FMT_MASK 0x38
216 #define OV7670_COM7_RESET 0x80 /* Register reset */
217 #define OV7670_REG_COM8 0x13 /* Control 8 */
218 #define OV7670_COM8_AEC 0x01 /* Auto exposure enable */
219 #define OV7670_COM8_AWB 0x02 /* White balance enable */
220 #define OV7670_COM8_AGC 0x04 /* Auto gain enable */
221 #define OV7670_COM8_BFILT 0x20 /* Band filter enable */
222 #define OV7670_COM8_AECSTEP 0x40 /* Unlimited AEC step size */
223 #define OV7670_COM8_FASTAEC 0x80 /* Enable fast AGC/AEC */
224 #define OV7670_REG_COM9 0x14 /* Control 9 - gain ceiling */
225 #define OV7670_REG_COM10 0x15 /* Control 10 */
226 #define OV7670_REG_HSTART 0x17 /* Horiz start high bits */
227 #define OV7670_REG_HSTOP 0x18 /* Horiz stop high bits */
228 #define OV7670_REG_VSTART 0x19 /* Vert start high bits */
229 #define OV7670_REG_VSTOP 0x1a /* Vert stop high bits */
230 #define OV7670_REG_MVFP 0x1e /* Mirror / vflip */
231 #define OV7670_MVFP_MIRROR 0x20 /* Mirror image */
232 #define OV7670_REG_AEW 0x24 /* AGC upper limit */
233 #define OV7670_REG_AEB 0x25 /* AGC lower limit */
234 #define OV7670_REG_VPT 0x26 /* AGC/AEC fast mode op region */
235 #define OV7670_REG_HREF 0x32 /* HREF pieces */
236 #define OV7670_REG_TSLB 0x3a /* lots of stuff */
237 #define OV7670_REG_COM11 0x3b /* Control 11 */
238 #define OV7670_COM11_EXP 0x02
239 #define OV7670_COM11_HZAUTO 0x10 /* Auto detect 50/60 Hz */
240 #define OV7670_REG_COM12 0x3c /* Control 12 */
241 #define OV7670_REG_COM13 0x3d /* Control 13 */
242 #define OV7670_COM13_GAMMA 0x80 /* Gamma enable */
243 #define OV7670_COM13_UVSAT 0x40 /* UV saturation auto adjustment */
244 #define OV7670_REG_COM14 0x3e /* Control 14 */
245 #define OV7670_REG_EDGE 0x3f /* Edge enhancement factor */
246 #define OV7670_REG_COM15 0x40 /* Control 15 */
247 #define OV7670_COM15_R00FF 0xc0 /* 00 to FF */
248 #define OV7670_REG_COM16 0x41 /* Control 16 */
249 #define OV7670_COM16_AWBGAIN 0x08 /* AWB gain enable */
250 #define OV7670_REG_BRIGHT 0x55 /* Brightness */
251 #define OV7670_REG_CONTRAS 0x56 /* Contrast control */
252 #define OV7670_REG_GFIX 0x69 /* Fix gain control */
253 #define OV7670_REG_RGB444 0x8c /* RGB 444 control */
254 #define OV7670_REG_HAECC1 0x9f /* Hist AEC/AGC control 1 */
255 #define OV7670_REG_HAECC2 0xa0 /* Hist AEC/AGC control 2 */
256 #define OV7670_REG_BD50MAX 0xa5 /* 50hz banding step limit */
257 #define OV7670_REG_HAECC3 0xa6 /* Hist AEC/AGC control 3 */
258 #define OV7670_REG_HAECC4 0xa7 /* Hist AEC/AGC control 4 */
259 #define OV7670_REG_HAECC5 0xa8 /* Hist AEC/AGC control 5 */
260 #define OV7670_REG_HAECC6 0xa9 /* Hist AEC/AGC control 6 */
261 #define OV7670_REG_HAECC7 0xaa /* Hist AEC/AGC control 7 */
262 #define OV7670_REG_BD60MAX 0xab /* 60hz banding step limit */
264 struct ovsensor_window {
270 short quarter; /* Scale width and height down 2x */
271 short clockdiv; /* Clock divisor setting */
274 static unsigned char ov7670_abs_to_sm(unsigned char v)
278 return (128 - v) | 0x80;
281 /* Write a OV519 register */
282 static int reg_w(struct sd *sd, __u16 index, __u8 value)
288 ret = usb_control_msg(sd->gspca_dev.dev,
289 usb_sndctrlpipe(sd->gspca_dev.dev, 0),
290 1, /* REQ_IO (ov518/519) */
291 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
295 PDEBUG(D_ERR, "Write reg [%02x] %02x failed", index, value);
299 /* Read from a OV519 register */
300 /* returns: negative is error, pos or zero is data */
301 static int reg_r(struct sd *sd, __u16 index)
306 ret = usb_control_msg(sd->gspca_dev.dev,
307 usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
309 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
310 0, index, &data, 1, 500);
315 PDEBUG(D_ERR, "Read reg [0x%02x] failed", index);
319 /* Read 8 values from a OV519 register */
320 static int reg_r8(struct sd *sd,
326 ret = usb_control_msg(sd->gspca_dev.dev,
327 usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
329 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
330 0, index, &buf[0], 8, 500);
335 PDEBUG(D_ERR, "Read reg 8 [0x%02x] failed", index);
340 * Writes bits at positions specified by mask to an OV51x reg. Bits that are in
341 * the same position as 1's in "mask" are cleared and set to "value". Bits
342 * that are in the same position as 0's in "mask" are preserved, regardless
343 * of their respective state in "value".
345 static int reg_w_mask(struct sd *sd,
354 value &= mask; /* Enforce mask on value */
355 ret = reg_r(sd, index);
359 oldval = ret & ~mask; /* Clear the masked bits */
360 value |= oldval; /* Set the desired bits */
362 return reg_w(sd, index, value);
366 * The OV518 I2C I/O procedure is different, hence, this function.
367 * This is normally only called from i2c_w(). Note that this function
368 * always succeeds regardless of whether the sensor is present and working.
370 static int i2c_w(struct sd *sd,
376 PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
378 /* Select camera register */
379 rc = reg_w(sd, R51x_I2C_SADDR_3, reg);
383 /* Write "value" to I2C data port of OV511 */
384 rc = reg_w(sd, R51x_I2C_DATA, value);
388 /* Initiate 3-byte write cycle */
389 rc = reg_w(sd, R518_I2C_CTL, 0x01);
391 /* wait for write complete */
395 return reg_r8(sd, R518_I2C_CTL);
399 * returns: negative is error, pos or zero is data
401 * The OV518 I2C I/O procedure is different, hence, this function.
402 * This is normally only called from i2c_r(). Note that this function
403 * always succeeds regardless of whether the sensor is present and working.
405 static int i2c_r(struct sd *sd, __u8 reg)
409 /* Select camera register */
410 rc = reg_w(sd, R51x_I2C_SADDR_2, reg);
414 /* Initiate 2-byte write cycle */
415 rc = reg_w(sd, R518_I2C_CTL, 0x03);
419 /* Initiate 2-byte read cycle */
420 rc = reg_w(sd, R518_I2C_CTL, 0x05);
423 value = reg_r(sd, R51x_I2C_DATA);
424 PDEBUG(D_USBI, "i2c [0x%02X] -> 0x%02X", reg, value);
428 /* Writes bits at positions specified by mask to an I2C reg. Bits that are in
429 * the same position as 1's in "mask" are cleared and set to "value". Bits
430 * that are in the same position as 0's in "mask" are preserved, regardless
431 * of their respective state in "value".
433 static int i2c_w_mask(struct sd *sd,
441 value &= mask; /* Enforce mask on value */
445 oldval = rc & ~mask; /* Clear the masked bits */
446 value |= oldval; /* Set the desired bits */
447 return i2c_w(sd, reg, value);
450 /* Temporarily stops OV511 from functioning. Must do this before changing
451 * registers while the camera is streaming */
452 static inline int ov51x_stop(struct sd *sd)
454 PDEBUG(D_STREAM, "stopping");
456 return reg_w(sd, OV519_SYS_RESET1, 0x0f);
459 /* Restarts OV511 after ov511_stop() is called. Has no effect if it is not
460 * actually stopped (for performance). */
461 static inline int ov51x_restart(struct sd *sd)
463 PDEBUG(D_STREAM, "restarting");
468 /* Reinitialize the stream */
469 return reg_w(sd, OV519_SYS_RESET1, 0x00);
472 /* This does an initial reset of an OmniVision sensor and ensures that I2C
473 * is synchronized. Returns <0 on failure.
475 static int init_ov_sensor(struct sd *sd)
479 /* Reset the sensor */
480 if (i2c_w(sd, 0x12, 0x80) < 0)
483 /* Wait for it to initialize */
486 for (i = 0, success = 0; i < i2c_detect_tries && !success; i++) {
487 if (i2c_r(sd, OV7610_REG_ID_HIGH) == 0x7f &&
488 i2c_r(sd, OV7610_REG_ID_LOW) == 0xa2) {
493 /* Reset the sensor */
494 if (i2c_w(sd, 0x12, 0x80) < 0)
496 /* Wait for it to initialize */
498 /* Dummy read to sync I2C */
499 if (i2c_r(sd, 0x00) < 0)
504 PDEBUG(D_PROBE, "I2C synced in %d attempt(s)", i);
508 /* Switch on standard JPEG compression. Returns 0 for success. */
509 static int ov519_init_compression(struct sd *sd)
511 if (!sd->compress_inited) {
512 if (reg_w_mask(sd, OV519_SYS_EN_CLK1, 1 << 2, 1 << 2) < 0) {
513 PDEBUG(D_ERR, "Error switching to compressed mode");
516 sd->compress_inited = 1;
521 /* Set the read and write slave IDs. The "slave" argument is the write slave,
522 * and the read slave will be set to (slave + 1).
523 * This should not be called from outside the i2c I/O functions.
524 * Sets I2C read and write slave IDs. Returns <0 for error
526 static int ov51x_set_slave_ids(struct sd *sd,
531 rc = reg_w(sd, R51x_I2C_W_SID, slave);
534 return reg_w(sd, R51x_I2C_R_SID, slave + 1);
541 struct ov_i2c_regvals {
546 static int write_regvals(struct sd *sd,
547 const struct ov_regvals *regvals,
553 rc = reg_w(sd, regvals->reg, regvals->val);
561 static int write_i2c_regvals(struct sd *sd,
562 const struct ov_i2c_regvals *regvals,
568 rc = i2c_w(sd, regvals->reg, regvals->val);
576 /****************************************************************************
578 * OV511 and sensor configuration
580 ***************************************************************************/
582 /* This initializes the OV8110, OV8610 sensor. The OV8110 uses
583 * the same register settings as the OV8610, since they are very similar.
585 static int ov8xx0_configure(struct sd *sd)
588 static const struct ov_i2c_regvals norm_8610[] = {
595 { 0x05, 0x30 }, /* was 0x10, new from windrv 090403 */
596 { 0x06, 0x70 }, /* was 0x80, new from windrv 090403 */
605 { 0x15, 0x01 }, /* Lin and Win think different about UV order */
607 { 0x17, 0x38 }, /* was 0x2f, new from windrv 090403 */
608 { 0x18, 0xea }, /* was 0xcf, new from windrv 090403 */
609 { 0x19, 0x02 }, /* was 0x06, new from windrv 090403 */
612 { 0x20, 0xd0 }, /* was 0x90, new from windrv 090403 */
613 { 0x23, 0xc0 }, /* was 0x00, new from windrv 090403 */
614 { 0x24, 0x30 }, /* was 0x1d, new from windrv 090403 */
615 { 0x25, 0x50 }, /* was 0x57, new from windrv 090403 */
621 { 0x2b, 0xc8 }, /* was 0xcc, new from windrv 090403 */
623 { 0x2d, 0x45 }, /* was 0xd5, new from windrv 090403 */
625 { 0x2f, 0x14 }, /* was 0x01, new from windrv 090403 */
627 { 0x4d, 0x30 }, /* was 0x10, new from windrv 090403 */
628 { 0x60, 0x02 }, /* was 0x01, new from windrv 090403 */
629 { 0x61, 0x00 }, /* was 0x09, new from windrv 090403 */
630 { 0x62, 0x5f }, /* was 0xd7, new from windrv 090403 */
632 { 0x64, 0x53 }, /* new windrv 090403 says 0x57,
633 * maybe thats wrong */
637 { 0x68, 0xc0 }, /* was 0xaf, new from windrv 090403 */
641 { 0x6c, 0x99 }, /* was 0x80, old windrv says 0x00, but
642 deleting bit7 colors the first images red */
643 { 0x6d, 0x11 }, /* was 0x00, new from windrv 090403 */
644 { 0x6e, 0x11 }, /* was 0x00, new from windrv 090403 */
650 { 0x74, 0x00 },/* 0x60? - was 0x00, new from windrv 090403 */
652 { 0x76, 0x02 }, /* was 0x02, new from windrv 090403 */
657 { 0x7b, 0x10 }, /* was 0x13, new from windrv 090403 */
659 { 0x7d, 0x08 }, /* was 0x09, new from windrv 090403 */
660 { 0x7e, 0x08 }, /* was 0xc0, new from windrv 090403 */
667 { 0x85, 0x62 }, /* was 0x61, new from windrv 090403 */
673 { 0x12, 0x25 }, /* was 0x24, new from windrv 090403 */
676 PDEBUG(D_PROBE, "starting ov8xx0 configuration");
678 if (init_ov_sensor(sd) < 0)
679 PDEBUG(D_ERR|D_PROBE, "Failed to read sensor ID");
681 PDEBUG(D_PROBE, "OV86x0 initialized");
683 /* Detect sensor (sub)type */
684 rc = i2c_r(sd, OV7610_REG_COM_I);
686 PDEBUG(D_ERR, "Error detecting sensor type");
690 PDEBUG(D_PROBE, "Sensor is an OV8610");
691 sd->sensor = SEN_OV8610;
693 PDEBUG(D_ERR, "Unknown image sensor version: %d", rc & 3);
696 PDEBUG(D_PROBE, "Writing 8610 registers");
697 if (write_i2c_regvals(sd,
699 sizeof norm_8610 / sizeof norm_8610[0]))
702 /* Set sensor-specific vars */
708 /* This initializes the OV7610, OV7620, or OV76BE sensor. The OV76BE uses
709 * the same register settings as the OV7610, since they are very similar.
711 static int ov7xx0_configure(struct sd *sd)
715 /* Lawrence Glaister <lg@jfm.bc.ca> reports:
717 * Register 0x0f in the 7610 has the following effects:
719 * 0x85 (AEC method 1): Best overall, good contrast range
720 * 0x45 (AEC method 2): Very overexposed
721 * 0xa5 (spec sheet default): Ok, but the black level is
722 * shifted resulting in loss of contrast
723 * 0x05 (old driver setting): very overexposed, too much
726 static const struct ov_i2c_regvals norm_7610[] = {
733 { 0x28, 0x24 }, /* 0c */
734 { 0x0f, 0x85 }, /* lg's setting */
756 static const struct ov_i2c_regvals norm_7620[] = {
757 { 0x00, 0x00 }, /* gain */
758 { 0x01, 0x80 }, /* blue gain */
759 { 0x02, 0x80 }, /* red gain */
760 { 0x03, 0xc0 }, /* OV7670_REG_VREF */
822 /* 7640 and 7648. The defaults should be OK for most registers. */
823 static const struct ov_i2c_regvals norm_7640[] = {
828 /* 7670. Defaults taken from OmniVision provided data,
829 * as provided by Jonathan Corbet of OLPC */
830 static const struct ov_i2c_regvals norm_7670[] = {
831 { OV7670_REG_COM7, OV7670_COM7_RESET },
832 { OV7670_REG_TSLB, 0x04 }, /* OV */
833 { OV7670_REG_COM7, OV7670_COM7_FMT_VGA }, /* VGA */
834 { OV7670_REG_CLKRC, 0x1 },
836 * Set the hardware window. These values from OV don't entirely
837 * make sense - hstop is less than hstart. But they work...
839 { OV7670_REG_HSTART, 0x13 }, { OV7670_REG_HSTOP, 0x01 },
840 { OV7670_REG_HREF, 0xb6 }, { OV7670_REG_VSTART, 0x02 },
841 { OV7670_REG_VSTOP, 0x7a }, { OV7670_REG_VREF, 0x0a },
843 { OV7670_REG_COM3, 0 }, { OV7670_REG_COM14, 0 },
844 /* Mystery scaling numbers */
845 { 0x70, 0x3a }, { 0x71, 0x35 },
846 { 0x72, 0x11 }, { 0x73, 0xf0 },
849 /* { OV7670_REG_COM10, 0x0 }, */
851 /* Gamma curve values */
859 { 0x7e, 0x5a }, { 0x7f, 0x69 },
860 { 0x80, 0x76 }, { 0x81, 0x80 },
861 { 0x82, 0x88 }, { 0x83, 0x8f },
862 { 0x84, 0x96 }, { 0x85, 0xa3 },
863 { 0x86, 0xaf }, { 0x87, 0xc4 },
864 { 0x88, 0xd7 }, { 0x89, 0xe8 },
866 /* AGC and AEC parameters. Note we start by disabling those features,
867 then turn them only after tweaking the values. */
868 { OV7670_REG_COM8, OV7670_COM8_FASTAEC
869 | OV7670_COM8_AECSTEP
870 | OV7670_COM8_BFILT },
871 { OV7670_REG_GAIN, 0 }, { OV7670_REG_AECH, 0 },
872 { OV7670_REG_COM4, 0x40 }, /* magic reserved bit */
874 { OV7670_REG_COM9, 0x18 }, /* 4x gain + magic rsvd bit */
875 { OV7670_REG_BD50MAX, 0x05 }, { OV7670_REG_BD60MAX, 0x07 },
876 { OV7670_REG_AEW, 0x95 }, { OV7670_REG_AEB, 0x33 },
877 { OV7670_REG_VPT, 0xe3 }, { OV7670_REG_HAECC1, 0x78 },
878 { OV7670_REG_HAECC2, 0x68 },
880 { 0xa1, 0x03 }, /* magic */
881 { OV7670_REG_HAECC3, 0xd8 }, { OV7670_REG_HAECC4, 0xd8 },
882 { OV7670_REG_HAECC5, 0xf0 }, { OV7670_REG_HAECC6, 0x90 },
883 { OV7670_REG_HAECC7, 0x94 },
884 { OV7670_REG_COM8, OV7670_COM8_FASTAEC
885 | OV7670_COM8_AECSTEP
890 /* Almost all of these are magic "reserved" values. */
891 { OV7670_REG_COM5, 0x61 }, { OV7670_REG_COM6, 0x4b },
894 /* { OV7670_REG_MVFP, 0x07|OV7670_MVFP_MIRROR }, */
895 { OV7670_REG_MVFP, 0x07 },
896 { 0x21, 0x02 }, { 0x22, 0x91 },
897 { 0x29, 0x07 }, { 0x33, 0x0b },
898 { 0x35, 0x0b }, { 0x37, 0x1d },
899 { 0x38, 0x71 }, { 0x39, 0x2a },
900 { OV7670_REG_COM12, 0x78 }, { 0x4d, 0x40 },
901 { 0x4e, 0x20 }, { OV7670_REG_GFIX, 0 },
902 { 0x6b, 0x4a }, { 0x74, 0x10 },
903 { 0x8d, 0x4f }, { 0x8e, 0 },
904 { 0x8f, 0 }, { 0x90, 0 },
905 { 0x91, 0 }, { 0x96, 0 },
906 { 0x9a, 0 }, { 0xb0, 0x84 },
907 { 0xb1, 0x0c }, { 0xb2, 0x0e },
908 { 0xb3, 0x82 }, { 0xb8, 0x0a },
910 /* More reserved magic, some of which tweaks white balance */
911 { 0x43, 0x0a }, { 0x44, 0xf0 },
912 { 0x45, 0x34 }, { 0x46, 0x58 },
913 { 0x47, 0x28 }, { 0x48, 0x3a },
914 { 0x59, 0x88 }, { 0x5a, 0x88 },
915 { 0x5b, 0x44 }, { 0x5c, 0x67 },
916 { 0x5d, 0x49 }, { 0x5e, 0x0e },
917 { 0x6c, 0x0a }, { 0x6d, 0x55 },
918 { 0x6e, 0x11 }, { 0x6f, 0x9f },
919 /* "9e for advance AWB" */
920 { 0x6a, 0x40 }, { OV7670_REG_BLUE, 0x40 },
921 { OV7670_REG_RED, 0x60 },
922 { OV7670_REG_COM8, OV7670_COM8_FASTAEC
923 | OV7670_COM8_AECSTEP
929 /* Matrix coefficients */
930 { 0x4f, 0x80 }, { 0x50, 0x80 },
931 { 0x51, 0 }, { 0x52, 0x22 },
932 { 0x53, 0x5e }, { 0x54, 0x80 },
935 { OV7670_REG_COM16, OV7670_COM16_AWBGAIN },
936 { OV7670_REG_EDGE, 0 },
937 { 0x75, 0x05 }, { 0x76, 0xe1 },
938 { 0x4c, 0 }, { 0x77, 0x01 },
939 { OV7670_REG_COM13, 0xc3 }, { 0x4b, 0x09 },
940 { 0xc9, 0x60 }, { OV7670_REG_COM16, 0x38 },
944 { OV7670_REG_COM11, OV7670_COM11_EXP|OV7670_COM11_HZAUTO },
945 { 0xa4, 0x88 }, { 0x96, 0 },
946 { 0x97, 0x30 }, { 0x98, 0x20 },
947 { 0x99, 0x30 }, { 0x9a, 0x84 },
948 { 0x9b, 0x29 }, { 0x9c, 0x03 },
949 { 0x9d, 0x4c }, { 0x9e, 0x3f },
952 /* Extra-weird stuff. Some sort of multiplexor register */
953 { 0x79, 0x01 }, { 0xc8, 0xf0 },
954 { 0x79, 0x0f }, { 0xc8, 0x00 },
955 { 0x79, 0x10 }, { 0xc8, 0x7e },
956 { 0x79, 0x0a }, { 0xc8, 0x80 },
957 { 0x79, 0x0b }, { 0xc8, 0x01 },
958 { 0x79, 0x0c }, { 0xc8, 0x0f },
959 { 0x79, 0x0d }, { 0xc8, 0x20 },
960 { 0x79, 0x09 }, { 0xc8, 0x80 },
961 { 0x79, 0x02 }, { 0xc8, 0xc0 },
962 { 0x79, 0x03 }, { 0xc8, 0x40 },
963 { 0x79, 0x05 }, { 0xc8, 0x30 },
967 { OV7670_REG_COM7, OV7670_COM7_YUV }, /* Selects YUV mode */
968 { OV7670_REG_RGB444, 0 }, /* No RGB444 please */
969 { OV7670_REG_COM1, 0 },
970 { OV7670_REG_COM15, OV7670_COM15_R00FF },
971 { OV7670_REG_COM9, 0x18 },
972 /* 4x gain ceiling; 0x8 is reserved bit */
973 { 0x4f, 0x80 }, /* "matrix coefficient 1" */
974 { 0x50, 0x80 }, /* "matrix coefficient 2" */
975 { 0x52, 0x22 }, /* "matrix coefficient 4" */
976 { 0x53, 0x5e }, /* "matrix coefficient 5" */
977 { 0x54, 0x80 }, /* "matrix coefficient 6" */
978 { OV7670_REG_COM13, OV7670_COM13_GAMMA|OV7670_COM13_UVSAT },
981 PDEBUG(D_PROBE, "starting OV7xx0 configuration");
983 /* jfm:already done? */
984 if (init_ov_sensor(sd) < 0)
985 PDEBUG(D_ERR, "Failed to read sensor ID");
987 PDEBUG(D_PROBE, "OV7xx0 initialized");
989 /* Detect sensor (sub)type */
990 rc = i2c_r(sd, OV7610_REG_COM_I);
993 * it appears to be wrongly detected as a 7610 by default */
995 PDEBUG(D_ERR, "Error detecting sensor type");
999 /* quick hack to make OV7670s work */
1000 high = i2c_r(sd, 0x0a);
1001 low = i2c_r(sd, 0x0b);
1002 /* info("%x, %x", high, low); */
1003 if (high == 0x76 && low == 0x73) {
1004 PDEBUG(D_PROBE, "Sensor is an OV7670");
1005 sd->sensor = SEN_OV7670;
1007 PDEBUG(D_PROBE, "Sensor is an OV7610");
1008 sd->sensor = SEN_OV7610;
1010 } else if ((rc & 3) == 1) {
1011 /* I don't know what's different about the 76BE yet. */
1012 if (i2c_r(sd, 0x15) & 1)
1013 PDEBUG(D_PROBE, "Sensor is an OV7620AE");
1015 PDEBUG(D_PROBE, "Sensor is an OV76BE");
1017 /* OV511+ will return all zero isoc data unless we
1018 * configure the sensor as a 7620. Someone needs to
1019 * find the exact reg. setting that causes this. */
1020 sd->sensor = SEN_OV76BE;
1021 } else if ((rc & 3) == 0) {
1022 /* try to read product id registers */
1023 high = i2c_r(sd, 0x0a);
1025 PDEBUG(D_ERR, "Error detecting camera chip PID");
1028 low = i2c_r(sd, 0x0b);
1030 PDEBUG(D_ERR, "Error detecting camera chip VER");
1035 PDEBUG(D_PROBE, "Sensor is an OV7630/OV7635");
1036 sd->sensor = SEN_OV7630;
1037 } else if (low == 0x40) {
1038 PDEBUG(D_PROBE, "Sensor is an OV7645");
1039 sd->sensor = SEN_OV7640; /* FIXME */
1040 } else if (low == 0x45) {
1041 PDEBUG(D_PROBE, "Sensor is an OV7645B");
1042 sd->sensor = SEN_OV7640; /* FIXME */
1043 } else if (low == 0x48) {
1044 PDEBUG(D_PROBE, "Sensor is an OV7648");
1045 sd->sensor = SEN_OV7640; /* FIXME */
1047 PDEBUG(D_PROBE, "Unknown sensor: 0x76%X", low);
1051 PDEBUG(D_PROBE, "Sensor is an OV7620");
1052 sd->sensor = SEN_OV7620;
1055 PDEBUG(D_ERR, "Unknown image sensor version: %d", rc & 3);
1059 if (sd->sensor == SEN_OV7620) {
1060 PDEBUG(D_PROBE, "Writing 7620 registers");
1061 if (write_i2c_regvals(sd, norm_7620,
1062 sizeof norm_7620 / sizeof norm_7620[0]))
1064 } else if (sd->sensor == SEN_OV7630) {
1065 PDEBUG(D_ERR, "7630 is not supported by this driver version");
1067 } else if (sd->sensor == SEN_OV7640) {
1068 PDEBUG(D_PROBE, "Writing 7640 registers");
1069 if (write_i2c_regvals(sd, norm_7640,
1070 sizeof norm_7640 / sizeof norm_7640[0]))
1072 } else if (sd->sensor == SEN_OV7670) {
1073 PDEBUG(D_PROBE, "Writing 7670 registers");
1074 if (write_i2c_regvals(sd, norm_7670,
1075 sizeof norm_7670 / sizeof norm_7670[0]))
1078 PDEBUG(D_PROBE, "Writing 7610 registers");
1079 if (write_i2c_regvals(sd, norm_7610,
1080 sizeof norm_7610 / sizeof norm_7610[0]))
1084 /* Set sensor-specific vars */
1086 sd->maxheight = 480;
1090 /* This initializes the OV6620, OV6630, OV6630AE, or OV6630AF sensor. */
1091 static int ov6xx0_configure(struct sd *sd)
1094 static const struct ov_i2c_regvals norm_6x20[] = {
1095 { 0x12, 0x80 }, /* reset */
1098 { 0x05, 0x7f }, /* For when autoadjust is off */
1100 /* The ratio of 0x0c and 0x0d controls the white point */
1103 { 0x0f, 0x15 }, /* COMS */
1104 { 0x10, 0x75 }, /* AEC Exposure time */
1105 { 0x12, 0x24 }, /* Enable AGC */
1107 /* 0x16: 0x06 helps frame stability with moving objects */
1109 /* { 0x20, 0x30 }, * Aperture correction enable */
1110 { 0x26, 0xb2 }, /* BLC enable */
1111 /* 0x28: 0x05 Selects RGB format if RGB on */
1113 { 0x2a, 0x04 }, /* Disable framerate adjust */
1114 /* { 0x2b, 0xac }, * Framerate; Set 2a[7] first */
1116 { 0x33, 0xa0 }, /* Color Processing Parameter */
1117 { 0x34, 0xd2 }, /* Max A/D range */
1121 { 0x3c, 0x39 }, /* Enable AEC mode changing */
1122 { 0x3c, 0x3c }, /* Change AEC mode */
1123 { 0x3c, 0x24 }, /* Disable AEC mode changing */
1126 /* These next two registers (0x4a, 0x4b) are undocumented.
1127 * They control the color balance */
1130 { 0x4d, 0xd2 }, /* This reduces noise a bit */
1133 /* Do 50-53 have any effect? */
1134 /* Toggle 0x12[2] off and on here? */
1137 static const struct ov_i2c_regvals norm_6x30[] = {
1138 { 0x12, 0x80 }, /* Reset */
1139 { 0x00, 0x1f }, /* Gain */
1140 { 0x01, 0x99 }, /* Blue gain */
1141 { 0x02, 0x7c }, /* Red gain */
1142 { 0x03, 0xc0 }, /* Saturation */
1143 { 0x05, 0x0a }, /* Contrast */
1144 { 0x06, 0x95 }, /* Brightness */
1145 { 0x07, 0x2d }, /* Sharpness */
1151 { 0x11, 0x00 }, /* Pixel clock = fastest */
1152 { 0x12, 0x24 }, /* Enable AGC and AWB */
1167 { 0x23, 0xc0 }, /* Crystal circuit power level */
1168 { 0x25, 0x9a }, /* Increase AEC black ratio */
1169 { 0x26, 0xb2 }, /* BLC enable */
1173 { 0x2a, 0x84 }, /* 60 Hz power */
1174 { 0x2b, 0xa8 }, /* 60 Hz power */
1176 { 0x2d, 0x95 }, /* Enable auto-brightness */
1190 { 0x40, 0x00 }, /* White bal */
1191 { 0x41, 0x00 }, /* White bal */
1193 { 0x43, 0x3f }, /* White bal */
1203 { 0x4d, 0x10 }, /* U = 0.563u, V = 0.714v */
1205 { 0x4f, 0x07 }, /* UV avg., col. killer: max */
1207 { 0x54, 0x23 }, /* Max AGC gain: 18dB */
1212 { 0x59, 0x01 }, /* AGC dark current comp.: +1 */
1214 { 0x5b, 0x0f }, /* AWB chrominance levels */
1218 { 0x12, 0x20 }, /* Toggle AWB */
1222 PDEBUG(D_PROBE, "starting sensor configuration");
1224 if (init_ov_sensor(sd) < 0) {
1225 PDEBUG(D_ERR, "Failed to read sensor ID.");
1228 PDEBUG(D_PROBE, "OV6xx0 sensor detected");
1230 /* Detect sensor (sub)type */
1231 rc = i2c_r(sd, OV7610_REG_COM_I);
1233 PDEBUG(D_ERR, "Error detecting sensor type");
1237 /* Ugh. The first two bits are the version bits, but
1238 * the entire register value must be used. I guess OVT
1239 * underestimated how many variants they would make. */
1241 sd->sensor = SEN_OV6630;
1243 "WARNING: Sensor is an OV66308. Your camera may have");
1244 PDEBUG(D_ERR, "been misdetected in previous driver versions.");
1245 } else if (rc == 0x01) {
1246 sd->sensor = SEN_OV6620;
1247 PDEBUG(D_PROBE, "Sensor is an OV6620");
1248 } else if (rc == 0x02) {
1249 sd->sensor = SEN_OV6630;
1250 PDEBUG(D_PROBE, "Sensor is an OV66308AE");
1251 } else if (rc == 0x03) {
1252 sd->sensor = SEN_OV6630;
1253 PDEBUG(D_PROBE, "Sensor is an OV66308AF");
1254 } else if (rc == 0x90) {
1255 sd->sensor = SEN_OV6630;
1257 "WARNING: Sensor is an OV66307. Your camera may have");
1258 PDEBUG(D_ERR, "been misdetected in previous driver versions.");
1260 PDEBUG(D_ERR, "FATAL: Unknown sensor version: 0x%02x", rc);
1264 /* Set sensor-specific vars */
1266 sd->maxheight = 288;
1268 if (sd->sensor == SEN_OV6620) {
1269 PDEBUG(D_PROBE, "Writing 6x20 registers");
1270 if (write_i2c_regvals(sd, norm_6x20,
1271 sizeof norm_6x20 / sizeof norm_6x20[0]))
1274 PDEBUG(D_PROBE, "Writing 6x30 registers");
1275 if (write_i2c_regvals(sd, norm_6x30,
1276 sizeof norm_6x30 / sizeof norm_6x30[0]))
1282 /* Turns on or off the LED. Only has an effect with OV511+/OV518(+)/OV519 */
1283 static void ov51x_led_control(struct sd *sd, int on)
1285 PDEBUG(D_STREAM, "LED (%s)", on ? "on" : "off");
1287 /* if (sd->bridge == BRG_OV511PLUS) */
1288 /* reg_w(sd, R511_SYS_LED_CTL, on ? 1 : 0); */
1289 /* else if (sd->bridge == BRG_OV519) */
1290 reg_w_mask(sd, OV519_GPIO_DATA_OUT0, !on, 1); /* 0 / 1 */
1291 /* else if (sd->bclass == BCL_OV518) */
1292 /* reg_w_mask(sd, R518_GPIO_OUT, on ? 0x02 : 0x00, 0x02); */
1295 /* this function is called at probe time */
1296 static int sd_config(struct gspca_dev *gspca_dev,
1297 const struct usb_device_id *id)
1299 struct sd *sd = (struct sd *) gspca_dev;
1302 /* (from ov519_configure) */
1303 static const struct ov_regvals init_519[] = {
1304 { 0x5a, 0x6d }, /* EnableSystem */
1305 /* jfm trace usbsnoop3-1.txt */
1308 { 0x54, 0xff }, /* set bit2 to enable jpeg */
1312 /* Set LED pin to output mode. Bit 4 must be cleared or sensor
1313 * detection will fail. This deserves further investigation. */
1314 { OV519_GPIO_IO_CTRL0, 0xee },
1315 { 0x51, 0x0f }, /* SetUsbInit */
1318 /* windows reads 0x55 at this point*/
1321 if (write_regvals(sd, init_519, ARRAY_SIZE(init_519)))
1323 /* jfm: not seen in windows trace */
1324 if (ov519_init_compression(sd))
1326 ov51x_led_control(sd, 0); /* turn LED off */
1329 sd->primary_i2c_slave = OV7xx0_SID;
1330 if (ov51x_set_slave_ids(sd, OV7xx0_SID) < 0)
1333 /* The OV519 must be more aggressive about sensor detection since
1334 * I2C write will never fail if the sensor is not present. We have
1335 * to try to initialize the sensor to detect its presence */
1336 if (init_ov_sensor(sd) < 0) {
1338 sd->primary_i2c_slave = OV6xx0_SID;
1339 if (ov51x_set_slave_ids(sd, OV6xx0_SID) < 0)
1342 if (init_ov_sensor(sd) < 0) {
1344 sd->primary_i2c_slave = OV8xx0_SID;
1345 if (ov51x_set_slave_ids(sd, OV8xx0_SID) < 0)
1348 if (init_ov_sensor(sd) < 0) {
1350 "Can't determine sensor slave IDs");
1353 if (ov8xx0_configure(sd) < 0) {
1355 "Failed to configure OV8xx0 sensor");
1360 if (ov6xx0_configure(sd) < 0) {
1361 PDEBUG(D_ERR, "Failed to configure OV6xx0");
1366 if (ov7xx0_configure(sd) < 0) {
1367 PDEBUG(D_ERR, "Failed to configure OV7xx0");
1372 cam = &gspca_dev->cam;
1373 cam->epaddr = OV511_ENDPOINT_ADDRESS;
1374 if (sd->maxwidth == 640) {
1375 cam->cam_mode = vga_mode;
1376 cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
1378 cam->cam_mode = sif_mode;
1379 cam->nmodes = sizeof sif_mode / sizeof sif_mode[0];
1381 cam->dev_name = (char *) id->driver_info;
1382 sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
1383 sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
1384 sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
1387 PDEBUG(D_ERR, "OV519 Config failed");
1391 /* this function is called at open time */
1392 static int sd_open(struct gspca_dev *gspca_dev)
1397 /* Sets up the OV519 with the given image parameters
1399 * OV519 needs a completely different approach, until we can figure out what
1400 * the individual registers do.
1402 * Do not put any sensor-specific code in here (including I2C I/O functions)
1404 static int ov519_mode_init_regs(struct sd *sd,
1405 int width, int height)
1407 static const struct ov_regvals mode_init_519_ov7670[] = {
1408 { 0x5d, 0x03 }, /* Turn off suspend mode */
1409 { 0x53, 0x9f }, /* was 9b in 1.65-1.08 */
1410 { 0x54, 0x0f }, /* bit2 (jpeg enable) */
1411 { 0xa2, 0x20 }, /* a2-a5 are undocumented */
1415 { 0x37, 0x00 }, /* SetUsbInit */
1416 { 0x55, 0x02 }, /* 4.096 Mhz audio clock */
1417 /* Enable both fields, YUV Input, disable defect comp (why?) */
1421 { 0x17, 0x50 }, /* undocumented */
1422 { 0x37, 0x00 }, /* undocumented */
1423 { 0x40, 0xff }, /* I2C timeout counter */
1424 { 0x46, 0x00 }, /* I2C clock prescaler */
1425 { 0x59, 0x04 }, /* new from windrv 090403 */
1426 { 0xff, 0x00 }, /* undocumented */
1427 /* windows reads 0x55 at this point, why? */
1430 static const struct ov_regvals mode_init_519[] = {
1431 { 0x5d, 0x03 }, /* Turn off suspend mode */
1432 { 0x53, 0x9f }, /* was 9b in 1.65-1.08 */
1433 { 0x54, 0x0f }, /* bit2 (jpeg enable) */
1434 { 0xa2, 0x20 }, /* a2-a5 are undocumented */
1438 { 0x37, 0x00 }, /* SetUsbInit */
1439 { 0x55, 0x02 }, /* 4.096 Mhz audio clock */
1440 /* Enable both fields, YUV Input, disable defect comp (why?) */
1442 { 0x17, 0x50 }, /* undocumented */
1443 { 0x37, 0x00 }, /* undocumented */
1444 { 0x40, 0xff }, /* I2C timeout counter */
1445 { 0x46, 0x00 }, /* I2C clock prescaler */
1446 { 0x59, 0x04 }, /* new from windrv 090403 */
1447 { 0xff, 0x00 }, /* undocumented */
1448 /* windows reads 0x55 at this point, why? */
1453 PDEBUG(D_CONF, "mode init %dx%d", width, height);
1455 /* if (width >= 800 && height >= 600)
1460 /* if (ov51x_stop(sd) < 0)
1463 /******** Set the mode ********/
1464 if (sd->sensor != SEN_OV7670) {
1465 if (write_regvals(sd, mode_init_519,
1466 ARRAY_SIZE(mode_init_519)))
1469 if (write_regvals(sd, mode_init_519_ov7670,
1470 ARRAY_SIZE(mode_init_519_ov7670)))
1474 if (sd->sensor == SEN_OV7640) {
1475 /* Select 8-bit input mode */
1476 reg_w_mask(sd, OV519_CAM_DFR, 0x10, 0x10);
1479 reg_w(sd, OV519_CAM_H_SIZE, width >> 4);
1480 reg_w(sd, OV519_CAM_V_SIZE, height >> 3);
1481 reg_w(sd, OV519_CAM_X_OFFSETL, 0x00);
1482 reg_w(sd, OV519_CAM_X_OFFSETH, 0x00);
1483 reg_w(sd, OV519_CAM_Y_OFFSETL, 0x00);
1484 reg_w(sd, OV519_CAM_Y_OFFSETH, 0x00);
1485 reg_w(sd, OV519_CAM_DIVIDER, 0x00);
1486 reg_w(sd, OV519_CAM_FORMAT, 0x03); /* YUV422 */
1487 reg_w(sd, 0x26, 0x00); /* Undocumented */
1489 /******** Set the framerate ********/
1491 sd->frame_rate = frame_rate;
1493 /* FIXME: These are only valid at the max resolution. */
1495 if (sd->sensor == SEN_OV7640) {
1496 switch (sd->frame_rate) {
1497 /*jfm: default was 30 fps */
1499 reg_w(sd, 0xa4, 0x0c);
1500 reg_w(sd, 0x23, 0xff);
1503 reg_w(sd, 0xa4, 0x0c);
1504 reg_w(sd, 0x23, 0x1f);
1507 reg_w(sd, 0xa4, 0x0c);
1508 reg_w(sd, 0x23, 0x1b);
1512 reg_w(sd, 0xa4, 0x04);
1513 reg_w(sd, 0x23, 0xff);
1517 reg_w(sd, 0xa4, 0x04);
1518 reg_w(sd, 0x23, 0x1f);
1522 reg_w(sd, 0xa4, 0x04);
1523 reg_w(sd, 0x23, 0x1b);
1527 } else if (sd->sensor == SEN_OV8610) {
1528 switch (sd->frame_rate) {
1529 default: /* 15 fps */
1531 reg_w(sd, 0xa4, 0x06);
1532 reg_w(sd, 0x23, 0xff);
1535 reg_w(sd, 0xa4, 0x06);
1536 reg_w(sd, 0x23, 0x1f);
1539 reg_w(sd, 0xa4, 0x06);
1540 reg_w(sd, 0x23, 0x1b);
1544 } else if (sd->sensor == SEN_OV7670) { /* guesses, based on 7640 */
1545 PDEBUG(D_STREAM, "Setting framerate to %d fps",
1546 (sd->frame_rate == 0) ? 15 : sd->frame_rate);
1547 switch (sd->frame_rate) {
1549 reg_w(sd, 0xa4, 0x10);
1550 reg_w(sd, 0x23, 0xff);
1553 reg_w(sd, 0xa4, 0x10);
1554 reg_w(sd, 0x23, 0x1b);
1556 default: /* 15 fps */
1558 reg_w(sd, 0xa4, 0x10);
1559 reg_w(sd, 0x23, 0xff);
1565 /* if (ov51x_restart(sd) < 0)
1568 /* Reset it just for good measure */
1569 /* if (ov51x_reset(sd, OV511_RESET_NOREGS) < 0)
1574 static int mode_init_ov_sensor_regs(struct sd *sd,
1575 struct ovsensor_window *win)
1577 int qvga = win->quarter;
1579 /******** Mode (VGA/QVGA) and sensor specific regs ********/
1580 switch (sd->sensor) {
1582 /* For OV8610 qvga means qsvga */
1583 i2c_w_mask(sd, OV7610_REG_COM_C, qvga ? (1 << 5) : 0, 1 << 5);
1586 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1589 /* i2c_w(sd, 0x2b, 0x00); */
1590 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1591 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
1592 i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a);
1593 i2c_w(sd, 0x25, qvga ? 0x30 : 0x60);
1594 i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40);
1595 i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0);
1596 i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20);
1599 /* i2c_w(sd, 0x2b, 0x00); */
1600 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1603 /* i2c_w(sd, 0x2b, 0x00); */
1604 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1605 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
1606 /* i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a); */
1607 /* i2c_w(sd, 0x25, qvga ? 0x30 : 0x60); */
1608 /* i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40); */
1609 /* i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0); */
1610 /* i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20); */
1613 /* set COM7_FMT_VGA or COM7_FMT_QVGA
1614 * do we need to set anything else?
1615 * HSTART etc are set in set_ov_sensor_window itself */
1616 i2c_w_mask(sd, OV7670_REG_COM7,
1617 qvga ? OV7670_COM7_FMT_QVGA : OV7670_COM7_FMT_VGA,
1618 OV7670_COM7_FMT_MASK);
1621 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1624 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
1630 /******** Palette-specific regs ********/
1631 /* Need to do work here for the OV7670 */
1633 if (sd->sensor == SEN_OV7610 || sd->sensor == SEN_OV76BE) {
1634 /* not valid on the OV6620/OV7620/6630? */
1635 i2c_w_mask(sd, 0x0e, 0x00, 0x40);
1638 /* The OV518 needs special treatment. Although both the OV518
1639 * and the OV6630 support a 16-bit video bus, only the 8 bit Y
1640 * bus is actually used. The UV bus is tied to ground.
1641 * Therefore, the OV6630 needs to be in 8-bit multiplexed
1644 /* OV7640 is 8-bit only */
1646 if (sd->sensor != SEN_OV6630 && sd->sensor != SEN_OV7640)
1647 i2c_w_mask(sd, 0x13, 0x00, 0x20);
1650 /******** Clock programming ********/
1651 /* The OV6620 needs special handling. This prevents the
1652 * severe banding that normally occurs */
1653 if (sd->sensor == SEN_OV6620) {
1656 i2c_w(sd, 0x2a, 0x04);
1657 i2c_w(sd, 0x11, win->clockdiv);
1658 i2c_w(sd, 0x2a, 0x84);
1659 /* This next setting is critical. It seems to improve
1660 * the gain or the contrast. The "reserved" bits seem
1661 * to have some effect in this case. */
1662 i2c_w(sd, 0x2d, 0x85);
1663 } else if (win->clockdiv >= 0) {
1664 i2c_w(sd, 0x11, win->clockdiv);
1667 /******** Special Features ********/
1668 /* no evidence this is possible with OV7670, either */
1670 if (sd->sensor != SEN_OV7640 && sd->sensor != SEN_OV7670)
1671 i2c_w_mask(sd, 0x12, 0x00, 0x02);
1673 /* Enable auto white balance */
1674 if (sd->sensor == SEN_OV7670)
1675 i2c_w_mask(sd, OV7670_REG_COM8, OV7670_COM8_AWB,
1678 i2c_w_mask(sd, 0x12, 0x04, 0x04);
1680 /* This will go away as soon as ov51x_mode_init_sensor_regs() */
1681 /* is fully tested. */
1682 /* 7620/6620/6630? don't have register 0x35, so play it safe */
1683 if (sd->sensor == SEN_OV7610 || sd->sensor == SEN_OV76BE) {
1684 if (win->width == 640 /*&& win->height == 480*/)
1685 i2c_w(sd, 0x35, 0x9e);
1687 i2c_w(sd, 0x35, 0x1e);
1692 static int set_ov_sensor_window(struct sd *sd,
1693 struct ovsensor_window *win)
1695 int hwsbase, hwebase, vwsbase, vwebase, hwscale, vwscale;
1696 int ret, hstart, hstop, vstop, vstart;
1699 /* The different sensor ICs handle setting up of window differently.
1700 * IF YOU SET IT WRONG, YOU WILL GET ALL ZERO ISOC DATA FROM OV51x!! */
1701 switch (sd->sensor) {
1712 vwsbase = vwebase = 0x05;
1722 hwsbase = 0x2f; /* From 7620.SET (spec is wrong) */
1724 vwsbase = vwebase = 0x05;
1729 vwsbase = vwebase = 0x03;
1732 /*handling of OV7670 hardware sensor start and stop values
1733 * is very odd, compared to the other OV sensors */
1734 vwsbase = vwebase = hwebase = hwsbase = 0x00;
1740 switch (sd->sensor) {
1743 if (win->quarter) { /* QCIF */
1748 vwscale = 1; /* The datasheet says 0;
1753 if (win->quarter) { /* QSVGA */
1761 default: /* SEN_OV7xx0 */
1762 if (win->quarter) { /* QVGA */
1771 ret = mode_init_ov_sensor_regs(sd, win);
1775 if (sd->sensor == SEN_OV8610) {
1776 i2c_w_mask(sd, 0x2d, 0x05, 0x40);
1777 /* old 0x95, new 0x05 from windrv 090403 */
1778 /* bits 5-7: reserved */
1779 i2c_w_mask(sd, 0x28, 0x20, 0x20);
1780 /* bit 5: progressive mode on */
1783 /* The below is wrong for OV7670s because their window registers
1784 * only store the high bits in 0x17 to 0x1a */
1786 /* SRH Use sd->max values instead of requested win values */
1787 /* SCS Since we're sticking with only the max hardware widths
1788 * for a given mode */
1789 /* I can hard code this for OV7670s */
1790 /* Yes, these numbers do look odd, but they're tested and work! */
1791 if (sd->sensor == SEN_OV7670) {
1792 if (win->quarter) { /* QVGA from ov7670.c by
1793 * Jonathan Corbet */
1804 /* OV7670 hardware window registers are split across
1805 * multiple locations */
1806 i2c_w(sd, OV7670_REG_HSTART, (hstart >> 3) & 0xff);
1807 i2c_w(sd, OV7670_REG_HSTOP, (hstop >> 3) & 0xff);
1808 v = i2c_r(sd, OV7670_REG_HREF);
1809 v = (v & 0xc0) | ((hstop & 0x7) << 3) | (hstart & 0x07);
1810 msleep(10); /* need to sleep between read and write to
1812 i2c_w(sd, OV7670_REG_HREF, v);
1814 i2c_w(sd, OV7670_REG_VSTART, (vstart >> 2) & 0xff);
1815 i2c_w(sd, OV7670_REG_VSTOP, (vstop >> 2) & 0xff);
1816 v = i2c_r(sd, OV7670_REG_VREF);
1817 v = (v & 0xc0) | ((vstop & 0x3) << 2) | (vstart & 0x03);
1818 msleep(10); /* need to sleep between read and write to
1820 i2c_w(sd, OV7670_REG_VREF, v);
1823 i2c_w(sd, 0x17, hwsbase + (win->x >> hwscale));
1824 i2c_w(sd, 0x18, hwebase + ((win->x + win->width) >> hwscale));
1825 i2c_w(sd, 0x19, vwsbase + (win->y >> vwscale));
1826 i2c_w(sd, 0x1a, vwebase + ((win->y + win->height) >> vwscale));
1831 static int ov_sensor_mode_setup(struct sd *sd,
1832 int width, int height)
1834 struct ovsensor_window win;
1836 /* win.format = mode; */
1838 /* Unless subcapture is enabled,
1839 * center the image window and downsample
1840 * if possible to increase the field of view */
1841 /* NOTE: OV518(+) and OV519 does downsampling on its own */
1843 win.height = height;
1844 if (width == sd->maxwidth)
1850 win.x = (win.width - width) / 2;
1851 win.y = (win.height - height) / 2;
1853 /* Clock is determined by OV519 frame rate code */
1854 win.clockdiv = sd->clockdiv;
1856 PDEBUG(D_CONF, "Setting clock divider to %d", win.clockdiv);
1857 return set_ov_sensor_window(sd, &win);
1860 /* -- start the camera -- */
1861 static void sd_start(struct gspca_dev *gspca_dev)
1863 struct sd *sd = (struct sd *) gspca_dev;
1867 ret = ov519_mode_init_regs(sd, gspca_dev->width, gspca_dev->height);
1870 ret = ov_sensor_mode_setup(sd, gspca_dev->width, gspca_dev->height);
1874 ret = ov51x_restart((struct sd *) gspca_dev);
1877 PDEBUG(D_STREAM, "camera started alt: 0x%02x", gspca_dev->alt);
1878 ov51x_led_control(sd, 1);
1881 PDEBUG(D_ERR, "camera start error:%d", ret);
1884 static void sd_stopN(struct gspca_dev *gspca_dev)
1886 ov51x_stop((struct sd *) gspca_dev);
1887 ov51x_led_control((struct sd *) gspca_dev, 0);
1890 static void sd_stop0(struct gspca_dev *gspca_dev)
1894 static void sd_close(struct gspca_dev *gspca_dev)
1898 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1899 struct gspca_frame *frame, /* target */
1900 __u8 *data, /* isoc packet */
1901 int len) /* iso packet length */
1903 /* Header of ov519 is 16 bytes:
1904 * Byte Value Description
1908 * 3 0xXX 0x50 = SOF, 0x51 = EOF
1909 * 9 0xXX 0x01 initial frame without data,
1910 * 0x00 standard frame with image
1911 * 14 Lo in EOF: length of image data / 8
1915 if (data[0] == 0xff && data[1] == 0xff && data[2] == 0xff) {
1917 case 0x50: /* start of frame */
1922 if (data[0] == 0xff || data[1] == 0xd8)
1923 gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
1926 gspca_dev->last_packet_type = DISCARD_PACKET;
1928 case 0x51: /* end of frame */
1930 gspca_dev->last_packet_type = DISCARD_PACKET;
1931 gspca_frame_add(gspca_dev, LAST_PACKET, frame,
1937 /* intermediate packet */
1938 gspca_frame_add(gspca_dev, INTER_PACKET, frame,
1942 /* -- management routines -- */
1944 static void setbrightness(struct gspca_dev *gspca_dev)
1946 struct sd *sd = (struct sd *) gspca_dev;
1948 /* int was_streaming; */
1950 val = sd->brightness;
1951 PDEBUG(D_CONF, "brightness:%d", val);
1952 /* was_streaming = gspca_dev->streaming;
1953 * if (was_streaming)
1954 * ov51x_stop(sd); */
1955 switch (sd->sensor) {
1962 i2c_w(sd, OV7610_REG_BRT, val);
1965 /* 7620 doesn't like manual changes when in auto mode */
1967 * if (!sd->auto_brt) */
1968 i2c_w(sd, OV7610_REG_BRT, val);
1971 /*jfm - from windblows
1972 * i2c_w_mask(sd, OV7670_REG_COM8, 0, OV7670_COM8_AEC); */
1973 i2c_w(sd, OV7670_REG_BRIGHT, ov7670_abs_to_sm(val));
1976 /* if (was_streaming)
1977 * ov51x_restart(sd); */
1980 static void setcontrast(struct gspca_dev *gspca_dev)
1982 struct sd *sd = (struct sd *) gspca_dev;
1984 /* int was_streaming; */
1987 PDEBUG(D_CONF, "contrast:%d", val);
1988 /* was_streaming = gspca_dev->streaming;
1991 switch (sd->sensor) {
1994 i2c_w(sd, OV7610_REG_CNT, val);
1997 i2c_w_mask(sd, OV7610_REG_CNT, val >> 4, 0x0f);
1999 static const __u8 ctab[] = {
2000 0x03, 0x09, 0x0b, 0x0f, 0x53, 0x6f, 0x35, 0x7f
2003 /* Use Y gamma control instead. Bit 0 enables it. */
2004 i2c_w(sd, 0x64, ctab[val >> 5]);
2008 static const __u8 ctab[] = {
2009 0x01, 0x05, 0x09, 0x11, 0x15, 0x35, 0x37, 0x57,
2010 0x5b, 0xa5, 0xa7, 0xc7, 0xc9, 0xcf, 0xef, 0xff
2013 /* Use Y gamma control instead. Bit 0 enables it. */
2014 i2c_w(sd, 0x64, ctab[val >> 4]);
2018 /* Use gain control instead. */
2019 i2c_w(sd, OV7610_REG_GAIN, val >> 2);
2022 /* check that this isn't just the same as ov7610 */
2023 i2c_w(sd, OV7670_REG_CONTRAS, val >> 1);
2026 /* if (was_streaming)
2027 ov51x_restart(sd); */
2030 static void setcolors(struct gspca_dev *gspca_dev)
2032 struct sd *sd = (struct sd *) gspca_dev;
2034 /* int was_streaming; */
2037 PDEBUG(D_CONF, "saturation:%d", val);
2038 /* was_streaming = gspca_dev->streaming;
2041 switch (sd->sensor) {
2047 i2c_w(sd, OV7610_REG_SAT, val);
2050 /* Use UV gamma control instead. Bits 0 & 7 are reserved. */
2051 /* rc = ov_i2c_write(sd->dev, 0x62, (val >> 9) & 0x7e);
2054 i2c_w(sd, OV7610_REG_SAT, val);
2057 i2c_w(sd, OV7610_REG_SAT, val & 0xf0);
2060 /* supported later once I work out how to do it
2061 * transparently fail now! */
2062 /* set REG_COM13 values for UV sat auto mode */
2065 /* if (was_streaming)
2066 ov51x_restart(sd); */
2069 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
2071 struct sd *sd = (struct sd *) gspca_dev;
2073 sd->brightness = val;
2074 setbrightness(gspca_dev);
2078 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
2080 struct sd *sd = (struct sd *) gspca_dev;
2082 *val = sd->brightness;
2086 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
2088 struct sd *sd = (struct sd *) gspca_dev;
2091 setcontrast(gspca_dev);
2095 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
2097 struct sd *sd = (struct sd *) gspca_dev;
2099 *val = sd->contrast;
2103 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
2105 struct sd *sd = (struct sd *) gspca_dev;
2108 setcolors(gspca_dev);
2112 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
2114 struct sd *sd = (struct sd *) gspca_dev;
2120 /* sub-driver description */
2121 static const struct sd_desc sd_desc = {
2122 .name = MODULE_NAME,
2124 .nctrls = ARRAY_SIZE(sd_ctrls),
2125 .config = sd_config,
2131 .pkt_scan = sd_pkt_scan,
2134 /* -- module initialisation -- */
2135 #define DVNM(name) .driver_info = (kernel_ulong_t) name
2136 static const __devinitdata struct usb_device_id device_table[] = {
2137 {USB_DEVICE(0x041e, 0x4052), DVNM("Creative Live! VISTA IM")},
2138 {USB_DEVICE(0x041e, 0x405f), DVNM("Creative Live! VISTA VF0330")},
2139 {USB_DEVICE(0x041e, 0x4060), DVNM("Creative Live! VISTA VF0350")},
2140 {USB_DEVICE(0x041e, 0x4061), DVNM("Creative Live! VISTA VF0400")},
2141 {USB_DEVICE(0x041e, 0x4064), DVNM("Creative Live! VISTA VF0420")},
2142 {USB_DEVICE(0x041e, 0x4068), DVNM("Creative Live! VISTA VF0470")},
2143 {USB_DEVICE(0x045e, 0x028c), DVNM("Microsoft xbox cam")},
2144 {USB_DEVICE(0x054c, 0x0154), DVNM("Sonny toy4")},
2145 {USB_DEVICE(0x054c, 0x0155), DVNM("Sonny toy5")},
2146 {USB_DEVICE(0x05a9, 0x0519), DVNM("OmniVision")},
2147 {USB_DEVICE(0x05a9, 0x0530), DVNM("OmniVision")},
2148 {USB_DEVICE(0x05a9, 0x4519), DVNM("OmniVision")},
2149 {USB_DEVICE(0x05a9, 0x8519), DVNM("OmniVision")},
2153 MODULE_DEVICE_TABLE(usb, device_table);
2155 /* -- device connect -- */
2156 static int sd_probe(struct usb_interface *intf,
2157 const struct usb_device_id *id)
2159 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
2163 static struct usb_driver sd_driver = {
2164 .name = MODULE_NAME,
2165 .id_table = device_table,
2167 .disconnect = gspca_disconnect,
2170 /* -- module insert / remove -- */
2171 static int __init sd_mod_init(void)
2173 if (usb_register(&sd_driver) < 0)
2175 PDEBUG(D_PROBE, "v%s registered", version);
2178 static void __exit sd_mod_exit(void)
2180 usb_deregister(&sd_driver);
2181 PDEBUG(D_PROBE, "deregistered");
2184 module_init(sd_mod_init);
2185 module_exit(sd_mod_exit);
2187 module_param(frame_rate, int, 0644);
2188 MODULE_PARM_DESC(frame_rate, "Frame rate (5, 10, 15, 20 or 30 fps)");