4 * Copyright (C) 2008-2011 Jean-François Moine <moinejf@free.fr>
5 * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com>
7 * This module is adapted from the ov51x-jpeg package, which itself
8 * was adapted from the ov511 driver.
10 * Original copyright for the ov511 driver is:
12 * Copyright (c) 1999-2006 Mark W. McClelland
13 * Support for OV519, OV8610 Copyright (c) 2003 Joerg Heckenbach
14 * Many improvements by Bret Wallach <bwallac1@san.rr.com>
15 * Color fixes by by Orion Sky Lawlor <olawlor@acm.org> (2/26/2000)
16 * OV7620 fixes by Charl P. Botha <cpbotha@ieee.org>
17 * Changes by Claudio Matsuoka <claudio@conectiva.com>
19 * ov51x-jpeg original copyright is:
21 * Copyright (c) 2004-2007 Romain Beauxis <toots@rastageeks.org>
22 * Support for OV7670 sensors was contributed by Sam Skipsey <aoanla@yahoo.com>
24 * This program is free software; you can redistribute it and/or modify
25 * it under the terms of the GNU General Public License as published by
26 * the Free Software Foundation; either version 2 of the License, or
29 * This program is distributed in the hope that it will be useful,
30 * but WITHOUT ANY WARRANTY; without even the implied warranty of
31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32 * GNU General Public License for more details.
34 * You should have received a copy of the GNU General Public License
35 * along with this program; if not, write to the Free Software
36 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
39 #define MODULE_NAME "ov519"
41 #include <linux/input.h>
44 /* The jpeg_hdr is used by w996Xcf only */
45 /* The CONEX_CAM define for jpeg.h needs renaming, now its used here too */
49 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
50 MODULE_DESCRIPTION("OV519 USB Camera Driver");
51 MODULE_LICENSE("GPL");
53 /* global parameters */
54 static int frame_rate;
56 /* Number of times to retry a failed I2C transaction. Increase this if you
57 * are getting "Failed to read sensor ID..." */
58 static int i2c_detect_tries = 10;
71 NCTRL /* number of controls */
74 /* ov519 device descriptor */
76 struct gspca_dev gspca_dev; /* !! must be the first item */
78 struct gspca_ctrl ctrls[NCTRL];
83 #define BRIDGE_OV511 0
84 #define BRIDGE_OV511PLUS 1
85 #define BRIDGE_OV518 2
86 #define BRIDGE_OV518PLUS 3
87 #define BRIDGE_OV519 4 /* = ov530 */
88 #define BRIDGE_OVFX2 5
89 #define BRIDGE_W9968CF 6
93 #define BRIDGE_INVERT_LED 8
95 char snapshot_pressed;
96 char snapshot_needs_reset;
98 /* Determined by sensor type */
102 #define QUALITY_MIN 50
103 #define QUALITY_MAX 70
104 #define QUALITY_DEF 50
106 u8 stopped; /* Streaming is temporarily paused */
109 u8 frame_rate; /* current Framerate */
110 u8 clockdiv; /* clockdiv override */
112 s8 sensor; /* Type of image sensor chip (SEN_*) */
117 s16 sensor_reg_cache[256];
119 u8 jpeg_hdr[JPEG_HDR_SZ];
139 /* Note this is a bit of a hack, but the w9968cf driver needs the code for all
140 the ov sensors which is already present here. When we have the time we
141 really should move the sensor drivers to v4l2 sub drivers. */
144 /* V4L2 controls supported by the driver */
145 static void setbrightness(struct gspca_dev *gspca_dev);
146 static void setcontrast(struct gspca_dev *gspca_dev);
147 static void setexposure(struct gspca_dev *gspca_dev);
148 static void setcolors(struct gspca_dev *gspca_dev);
149 static void sethvflip(struct gspca_dev *gspca_dev);
150 static void setautobright(struct gspca_dev *gspca_dev);
151 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
152 static void setfreq(struct gspca_dev *gspca_dev);
153 static void setfreq_i(struct sd *sd);
155 static const struct ctrl sd_ctrls[] = {
158 .id = V4L2_CID_BRIGHTNESS,
159 .type = V4L2_CTRL_TYPE_INTEGER,
160 .name = "Brightness",
164 .default_value = 127,
166 .set_control = setbrightness,
170 .id = V4L2_CID_CONTRAST,
171 .type = V4L2_CTRL_TYPE_INTEGER,
176 .default_value = 127,
178 .set_control = setcontrast,
182 .id = V4L2_CID_EXPOSURE,
183 .type = V4L2_CTRL_TYPE_INTEGER,
188 .default_value = 127,
190 .set_control = setexposure,
194 .id = V4L2_CID_SATURATION,
195 .type = V4L2_CTRL_TYPE_INTEGER,
200 .default_value = 127,
202 .set_control = setcolors,
204 /* The flip controls work for sensors ov7660 and ov7670 only */
207 .id = V4L2_CID_HFLIP,
208 .type = V4L2_CTRL_TYPE_BOOLEAN,
215 .set_control = sethvflip,
219 .id = V4L2_CID_VFLIP,
220 .type = V4L2_CTRL_TYPE_BOOLEAN,
227 .set_control = sethvflip,
231 .id = V4L2_CID_AUTOBRIGHTNESS,
232 .type = V4L2_CTRL_TYPE_BOOLEAN,
233 .name = "Auto Brightness",
239 .set_control = setautobright,
243 .id = V4L2_CID_AUTOGAIN,
244 .type = V4L2_CTRL_TYPE_BOOLEAN,
250 .flags = V4L2_CTRL_FLAG_UPDATE
252 .set = sd_setautogain,
256 .id = V4L2_CID_POWER_LINE_FREQUENCY,
257 .type = V4L2_CTRL_TYPE_MENU,
258 .name = "Light frequency filter",
260 .maximum = 2, /* 0: no flicker, 1: 50Hz, 2:60Hz, 3: auto */
264 .set_control = setfreq,
268 /* table of the disabled controls */
269 static const unsigned ctrl_dis[] = {
270 [SEN_OV2610] = ((1 << NCTRL) - 1) /* no control */
271 ^ ((1 << EXPOSURE) /* but exposure */
272 | (1 << AUTOGAIN)), /* and autogain */
274 [SEN_OV2610AE] = ((1 << NCTRL) - 1) /* no control */
275 ^ ((1 << EXPOSURE) /* but exposure */
276 | (1 << AUTOGAIN)), /* and autogain */
278 [SEN_OV3610] = (1 << NCTRL) - 1, /* no control */
280 [SEN_OV6620] = (1 << HFLIP) |
285 [SEN_OV6630] = (1 << HFLIP) |
290 [SEN_OV66308AF] = (1 << HFLIP) |
295 [SEN_OV7610] = (1 << HFLIP) |
300 [SEN_OV7620] = (1 << HFLIP) |
305 [SEN_OV7620AE] = (1 << HFLIP) |
310 [SEN_OV7640] = (1 << HFLIP) |
317 [SEN_OV7648] = (1 << HFLIP) |
324 [SEN_OV7660] = (1 << AUTOBRIGHT) |
328 [SEN_OV7670] = (1 << COLORS) |
333 [SEN_OV76BE] = (1 << HFLIP) |
338 [SEN_OV8610] = (1 << HFLIP) |
345 static const struct v4l2_pix_format ov519_vga_mode[] = {
346 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
348 .sizeimage = 320 * 240 * 3 / 8 + 590,
349 .colorspace = V4L2_COLORSPACE_JPEG,
351 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
353 .sizeimage = 640 * 480 * 3 / 8 + 590,
354 .colorspace = V4L2_COLORSPACE_JPEG,
357 static const struct v4l2_pix_format ov519_sif_mode[] = {
358 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
360 .sizeimage = 160 * 120 * 3 / 8 + 590,
361 .colorspace = V4L2_COLORSPACE_JPEG,
363 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
365 .sizeimage = 176 * 144 * 3 / 8 + 590,
366 .colorspace = V4L2_COLORSPACE_JPEG,
368 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
370 .sizeimage = 320 * 240 * 3 / 8 + 590,
371 .colorspace = V4L2_COLORSPACE_JPEG,
373 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
375 .sizeimage = 352 * 288 * 3 / 8 + 590,
376 .colorspace = V4L2_COLORSPACE_JPEG,
380 /* Note some of the sizeimage values for the ov511 / ov518 may seem
381 larger then necessary, however they need to be this big as the ov511 /
382 ov518 always fills the entire isoc frame, using 0 padding bytes when
383 it doesn't have any data. So with low framerates the amount of data
384 transferred can become quite large (libv4l will remove all the 0 padding
386 static const struct v4l2_pix_format ov518_vga_mode[] = {
387 {320, 240, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
389 .sizeimage = 320 * 240 * 3,
390 .colorspace = V4L2_COLORSPACE_JPEG,
392 {640, 480, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
394 .sizeimage = 640 * 480 * 2,
395 .colorspace = V4L2_COLORSPACE_JPEG,
398 static const struct v4l2_pix_format ov518_sif_mode[] = {
399 {160, 120, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
402 .colorspace = V4L2_COLORSPACE_JPEG,
404 {176, 144, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
407 .colorspace = V4L2_COLORSPACE_JPEG,
409 {320, 240, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
411 .sizeimage = 320 * 240 * 3,
412 .colorspace = V4L2_COLORSPACE_JPEG,
414 {352, 288, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
416 .sizeimage = 352 * 288 * 3,
417 .colorspace = V4L2_COLORSPACE_JPEG,
421 static const struct v4l2_pix_format ov511_vga_mode[] = {
422 {320, 240, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
424 .sizeimage = 320 * 240 * 3,
425 .colorspace = V4L2_COLORSPACE_JPEG,
427 {640, 480, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
429 .sizeimage = 640 * 480 * 2,
430 .colorspace = V4L2_COLORSPACE_JPEG,
433 static const struct v4l2_pix_format ov511_sif_mode[] = {
434 {160, 120, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
437 .colorspace = V4L2_COLORSPACE_JPEG,
439 {176, 144, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
442 .colorspace = V4L2_COLORSPACE_JPEG,
444 {320, 240, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
446 .sizeimage = 320 * 240 * 3,
447 .colorspace = V4L2_COLORSPACE_JPEG,
449 {352, 288, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
451 .sizeimage = 352 * 288 * 3,
452 .colorspace = V4L2_COLORSPACE_JPEG,
456 static const struct v4l2_pix_format ovfx2_vga_mode[] = {
457 {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
459 .sizeimage = 320 * 240,
460 .colorspace = V4L2_COLORSPACE_SRGB,
462 {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
464 .sizeimage = 640 * 480,
465 .colorspace = V4L2_COLORSPACE_SRGB,
468 static const struct v4l2_pix_format ovfx2_cif_mode[] = {
469 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
471 .sizeimage = 160 * 120,
472 .colorspace = V4L2_COLORSPACE_SRGB,
474 {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
476 .sizeimage = 176 * 144,
477 .colorspace = V4L2_COLORSPACE_SRGB,
479 {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
481 .sizeimage = 320 * 240,
482 .colorspace = V4L2_COLORSPACE_SRGB,
484 {352, 288, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
486 .sizeimage = 352 * 288,
487 .colorspace = V4L2_COLORSPACE_SRGB,
490 static const struct v4l2_pix_format ovfx2_ov2610_mode[] = {
491 {800, 600, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
493 .sizeimage = 800 * 600,
494 .colorspace = V4L2_COLORSPACE_SRGB,
496 {1600, 1200, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
497 .bytesperline = 1600,
498 .sizeimage = 1600 * 1200,
499 .colorspace = V4L2_COLORSPACE_SRGB},
501 static const struct v4l2_pix_format ovfx2_ov3610_mode[] = {
502 {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
504 .sizeimage = 640 * 480,
505 .colorspace = V4L2_COLORSPACE_SRGB,
507 {800, 600, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
509 .sizeimage = 800 * 600,
510 .colorspace = V4L2_COLORSPACE_SRGB,
512 {1024, 768, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
513 .bytesperline = 1024,
514 .sizeimage = 1024 * 768,
515 .colorspace = V4L2_COLORSPACE_SRGB,
517 {1600, 1200, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
518 .bytesperline = 1600,
519 .sizeimage = 1600 * 1200,
520 .colorspace = V4L2_COLORSPACE_SRGB,
522 {2048, 1536, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
523 .bytesperline = 2048,
524 .sizeimage = 2048 * 1536,
525 .colorspace = V4L2_COLORSPACE_SRGB,
529 /* Registers common to OV511 / OV518 */
530 #define R51x_FIFO_PSIZE 0x30 /* 2 bytes wide w/ OV518(+) */
531 #define R51x_SYS_RESET 0x50
532 /* Reset type flags */
533 #define OV511_RESET_OMNICE 0x08
534 #define R51x_SYS_INIT 0x53
535 #define R51x_SYS_SNAP 0x52
536 #define R51x_SYS_CUST_ID 0x5f
537 #define R51x_COMP_LUT_BEGIN 0x80
539 /* OV511 Camera interface register numbers */
540 #define R511_CAM_DELAY 0x10
541 #define R511_CAM_EDGE 0x11
542 #define R511_CAM_PXCNT 0x12
543 #define R511_CAM_LNCNT 0x13
544 #define R511_CAM_PXDIV 0x14
545 #define R511_CAM_LNDIV 0x15
546 #define R511_CAM_UV_EN 0x16
547 #define R511_CAM_LINE_MODE 0x17
548 #define R511_CAM_OPTS 0x18
550 #define R511_SNAP_FRAME 0x19
551 #define R511_SNAP_PXCNT 0x1a
552 #define R511_SNAP_LNCNT 0x1b
553 #define R511_SNAP_PXDIV 0x1c
554 #define R511_SNAP_LNDIV 0x1d
555 #define R511_SNAP_UV_EN 0x1e
556 #define R511_SNAP_OPTS 0x1f
558 #define R511_DRAM_FLOW_CTL 0x20
559 #define R511_FIFO_OPTS 0x31
560 #define R511_I2C_CTL 0x40
561 #define R511_SYS_LED_CTL 0x55 /* OV511+ only */
562 #define R511_COMP_EN 0x78
563 #define R511_COMP_LUT_EN 0x79
565 /* OV518 Camera interface register numbers */
566 #define R518_GPIO_OUT 0x56 /* OV518(+) only */
567 #define R518_GPIO_CTL 0x57 /* OV518(+) only */
569 /* OV519 Camera interface register numbers */
570 #define OV519_R10_H_SIZE 0x10
571 #define OV519_R11_V_SIZE 0x11
572 #define OV519_R12_X_OFFSETL 0x12
573 #define OV519_R13_X_OFFSETH 0x13
574 #define OV519_R14_Y_OFFSETL 0x14
575 #define OV519_R15_Y_OFFSETH 0x15
576 #define OV519_R16_DIVIDER 0x16
577 #define OV519_R20_DFR 0x20
578 #define OV519_R25_FORMAT 0x25
580 /* OV519 System Controller register numbers */
581 #define OV519_R51_RESET1 0x51
582 #define OV519_R54_EN_CLK1 0x54
583 #define OV519_R57_SNAPSHOT 0x57
585 #define OV519_GPIO_DATA_OUT0 0x71
586 #define OV519_GPIO_IO_CTRL0 0x72
588 /*#define OV511_ENDPOINT_ADDRESS 1 * Isoc endpoint number */
591 * The FX2 chip does not give us a zero length read at end of frame.
592 * It does, however, give a short read at the end of a frame, if
593 * necessary, rather than run two frames together.
595 * By choosing the right bulk transfer size, we are guaranteed to always
596 * get a short read for the last read of each frame. Frame sizes are
597 * always a composite number (width * height, or a multiple) so if we
598 * choose a prime number, we are guaranteed that the last read of a
599 * frame will be short.
601 * But it isn't that easy: the 2.6 kernel requires a multiple of 4KB,
602 * otherwise EOVERFLOW "babbling" errors occur. I have not been able
603 * to figure out why. [PMiller]
605 * The constant (13 * 4096) is the largest "prime enough" number less than 64KB.
607 * It isn't enough to know the number of bytes per frame, in case we
608 * have data dropouts or buffer overruns (even though the FX2 double
609 * buffers, there are some pretty strict real time constraints for
610 * isochronous transfer for larger frame sizes).
612 /*jfm: this value works well for 1600x1200, but not 800x600 - see isoc_init */
613 #define OVFX2_BULK_SIZE (13 * 4096)
616 #define R51x_I2C_W_SID 0x41
617 #define R51x_I2C_SADDR_3 0x42
618 #define R51x_I2C_SADDR_2 0x43
619 #define R51x_I2C_R_SID 0x44
620 #define R51x_I2C_DATA 0x45
621 #define R518_I2C_CTL 0x47 /* OV518(+) only */
622 #define OVFX2_I2C_ADDR 0x00
625 #define OV7xx0_SID 0x42
626 #define OV_HIRES_SID 0x60 /* OV9xxx / OV2xxx / OV3xxx */
627 #define OV8xx0_SID 0xa0
628 #define OV6xx0_SID 0xc0
630 /* OV7610 registers */
631 #define OV7610_REG_GAIN 0x00 /* gain setting (5:0) */
632 #define OV7610_REG_BLUE 0x01 /* blue channel balance */
633 #define OV7610_REG_RED 0x02 /* red channel balance */
634 #define OV7610_REG_SAT 0x03 /* saturation */
635 #define OV8610_REG_HUE 0x04 /* 04 reserved */
636 #define OV7610_REG_CNT 0x05 /* Y contrast */
637 #define OV7610_REG_BRT 0x06 /* Y brightness */
638 #define OV7610_REG_COM_C 0x14 /* misc common regs */
639 #define OV7610_REG_ID_HIGH 0x1c /* manufacturer ID MSB */
640 #define OV7610_REG_ID_LOW 0x1d /* manufacturer ID LSB */
641 #define OV7610_REG_COM_I 0x29 /* misc settings */
643 /* OV7660 and OV7670 registers */
644 #define OV7670_R00_GAIN 0x00 /* Gain lower 8 bits (rest in vref) */
645 #define OV7670_R01_BLUE 0x01 /* blue gain */
646 #define OV7670_R02_RED 0x02 /* red gain */
647 #define OV7670_R03_VREF 0x03 /* Pieces of GAIN, VSTART, VSTOP */
648 #define OV7670_R04_COM1 0x04 /* Control 1 */
649 /*#define OV7670_R07_AECHH 0x07 * AEC MS 5 bits */
650 #define OV7670_R0C_COM3 0x0c /* Control 3 */
651 #define OV7670_R0D_COM4 0x0d /* Control 4 */
652 #define OV7670_R0E_COM5 0x0e /* All "reserved" */
653 #define OV7670_R0F_COM6 0x0f /* Control 6 */
654 #define OV7670_R10_AECH 0x10 /* More bits of AEC value */
655 #define OV7670_R11_CLKRC 0x11 /* Clock control */
656 #define OV7670_R12_COM7 0x12 /* Control 7 */
657 #define OV7670_COM7_FMT_VGA 0x00
658 /*#define OV7670_COM7_YUV 0x00 * YUV */
659 #define OV7670_COM7_FMT_QVGA 0x10 /* QVGA format */
660 #define OV7670_COM7_FMT_MASK 0x38
661 #define OV7670_COM7_RESET 0x80 /* Register reset */
662 #define OV7670_R13_COM8 0x13 /* Control 8 */
663 #define OV7670_COM8_AEC 0x01 /* Auto exposure enable */
664 #define OV7670_COM8_AWB 0x02 /* White balance enable */
665 #define OV7670_COM8_AGC 0x04 /* Auto gain enable */
666 #define OV7670_COM8_BFILT 0x20 /* Band filter enable */
667 #define OV7670_COM8_AECSTEP 0x40 /* Unlimited AEC step size */
668 #define OV7670_COM8_FASTAEC 0x80 /* Enable fast AGC/AEC */
669 #define OV7670_R14_COM9 0x14 /* Control 9 - gain ceiling */
670 #define OV7670_R15_COM10 0x15 /* Control 10 */
671 #define OV7670_R17_HSTART 0x17 /* Horiz start high bits */
672 #define OV7670_R18_HSTOP 0x18 /* Horiz stop high bits */
673 #define OV7670_R19_VSTART 0x19 /* Vert start high bits */
674 #define OV7670_R1A_VSTOP 0x1a /* Vert stop high bits */
675 #define OV7670_R1E_MVFP 0x1e /* Mirror / vflip */
676 #define OV7670_MVFP_VFLIP 0x10 /* vertical flip */
677 #define OV7670_MVFP_MIRROR 0x20 /* Mirror image */
678 #define OV7670_R24_AEW 0x24 /* AGC upper limit */
679 #define OV7670_R25_AEB 0x25 /* AGC lower limit */
680 #define OV7670_R26_VPT 0x26 /* AGC/AEC fast mode op region */
681 #define OV7670_R32_HREF 0x32 /* HREF pieces */
682 #define OV7670_R3A_TSLB 0x3a /* lots of stuff */
683 #define OV7670_R3B_COM11 0x3b /* Control 11 */
684 #define OV7670_COM11_EXP 0x02
685 #define OV7670_COM11_HZAUTO 0x10 /* Auto detect 50/60 Hz */
686 #define OV7670_R3C_COM12 0x3c /* Control 12 */
687 #define OV7670_R3D_COM13 0x3d /* Control 13 */
688 #define OV7670_COM13_GAMMA 0x80 /* Gamma enable */
689 #define OV7670_COM13_UVSAT 0x40 /* UV saturation auto adjustment */
690 #define OV7670_R3E_COM14 0x3e /* Control 14 */
691 #define OV7670_R3F_EDGE 0x3f /* Edge enhancement factor */
692 #define OV7670_R40_COM15 0x40 /* Control 15 */
693 /*#define OV7670_COM15_R00FF 0xc0 * 00 to FF */
694 #define OV7670_R41_COM16 0x41 /* Control 16 */
695 #define OV7670_COM16_AWBGAIN 0x08 /* AWB gain enable */
696 /* end of ov7660 common registers */
697 #define OV7670_R55_BRIGHT 0x55 /* Brightness */
698 #define OV7670_R56_CONTRAS 0x56 /* Contrast control */
699 #define OV7670_R69_GFIX 0x69 /* Fix gain control */
700 /*#define OV7670_R8C_RGB444 0x8c * RGB 444 control */
701 #define OV7670_R9F_HAECC1 0x9f /* Hist AEC/AGC control 1 */
702 #define OV7670_RA0_HAECC2 0xa0 /* Hist AEC/AGC control 2 */
703 #define OV7670_RA5_BD50MAX 0xa5 /* 50hz banding step limit */
704 #define OV7670_RA6_HAECC3 0xa6 /* Hist AEC/AGC control 3 */
705 #define OV7670_RA7_HAECC4 0xa7 /* Hist AEC/AGC control 4 */
706 #define OV7670_RA8_HAECC5 0xa8 /* Hist AEC/AGC control 5 */
707 #define OV7670_RA9_HAECC6 0xa9 /* Hist AEC/AGC control 6 */
708 #define OV7670_RAA_HAECC7 0xaa /* Hist AEC/AGC control 7 */
709 #define OV7670_RAB_BD60MAX 0xab /* 60hz banding step limit */
715 struct ov_i2c_regvals {
720 /* Settings for OV2610 camera chip */
721 static const struct ov_i2c_regvals norm_2610[] = {
722 { 0x12, 0x80 }, /* reset */
725 static const struct ov_i2c_regvals norm_2610ae[] = {
726 {0x12, 0x80}, /* reset */
731 {0x12, 0x20}, /* 1600x1200 */
736 {0x11, 0x83}, /* clock / 3 ? */
737 {0x2d, 0x00}, /* 60 Hz filter */
738 {0x24, 0xb0}, /* normal colors */
743 static const struct ov_i2c_regvals norm_3620b[] = {
745 * From the datasheet: "Note that after writing to register COMH
746 * (0x12) to change the sensor mode, registers related to the
747 * sensor’s cropping window will be reset back to their default
750 * "wait 4096 external clock ... to make sure the sensor is
751 * stable and ready to access registers" i.e. 160us at 24MHz
753 { 0x12, 0x80 }, /* COMH reset */
754 { 0x12, 0x00 }, /* QXGA, master */
757 * 11 CLKRC "Clock Rate Control"
758 * [7] internal frequency doublers: on
759 * [6] video port mode: master
760 * [5:0] clock divider: 1
765 * 13 COMI "Common Control I"
766 * = 192 (0xC0) 11000000
767 * COMI[7] "AEC speed selection"
768 * = 1 (0x01) 1....... "Faster AEC correction"
769 * COMI[6] "AEC speed step selection"
770 * = 1 (0x01) .1...... "Big steps, fast"
771 * COMI[5] "Banding filter on off"
772 * = 0 (0x00) ..0..... "Off"
773 * COMI[4] "Banding filter option"
774 * = 0 (0x00) ...0.... "Main clock is 48 MHz and
777 * = 0 (0x00) ....0...
778 * COMI[2] "AGC auto manual control selection"
779 * = 0 (0x00) .....0.. "Manual"
780 * COMI[1] "AWB auto manual control selection"
781 * = 0 (0x00) ......0. "Manual"
782 * COMI[0] "Exposure control"
783 * = 0 (0x00) .......0 "Manual"
788 * 09 COMC "Common Control C"
789 * = 8 (0x08) 00001000
790 * COMC[7:5] "Reserved"
791 * = 0 (0x00) 000.....
792 * COMC[4] "Sleep Mode Enable"
793 * = 0 (0x00) ...0.... "Normal mode"
794 * COMC[3:2] "Sensor sampling reset timing selection"
795 * = 2 (0x02) ....10.. "Longer reset time"
796 * COMC[1:0] "Output drive current select"
797 * = 0 (0x00) ......00 "Weakest"
802 * 0C COMD "Common Control D"
803 * = 8 (0x08) 00001000
805 * = 0 (0x00) 0.......
806 * COMD[6] "Swap MSB and LSB at the output port"
807 * = 0 (0x00) .0...... "False"
808 * COMD[5:3] "Reserved"
809 * = 1 (0x01) ..001...
810 * COMD[2] "Output Average On Off"
811 * = 0 (0x00) .....0.. "Output Normal"
812 * COMD[1] "Sensor precharge voltage selection"
813 * = 0 (0x00) ......0. "Selects internal
814 * reference precharge
816 * COMD[0] "Snapshot option"
817 * = 0 (0x00) .......0 "Enable live video output
818 * after snapshot sequence"
823 * 0D COME "Common Control E"
824 * = 161 (0xA1) 10100001
825 * COME[7] "Output average option"
826 * = 1 (0x01) 1....... "Output average of 4 pixels"
827 * COME[6] "Anti-blooming control"
828 * = 0 (0x00) .0...... "Off"
829 * COME[5:3] "Reserved"
830 * = 4 (0x04) ..100...
831 * COME[2] "Clock output power down pin status"
832 * = 0 (0x00) .....0.. "Tri-state data output pin
834 * COME[1] "Data output pin status selection at power down"
835 * = 0 (0x00) ......0. "Tri-state VSYNC, PCLK,
836 * HREF, and CHSYNC pins on
838 * COME[0] "Auto zero circuit select"
839 * = 1 (0x01) .......1 "On"
844 * 0E COMF "Common Control F"
845 * = 112 (0x70) 01110000
846 * COMF[7] "System clock selection"
847 * = 0 (0x00) 0....... "Use 24 MHz system clock"
848 * COMF[6:4] "Reserved"
849 * = 7 (0x07) .111....
850 * COMF[3] "Manual auto negative offset canceling selection"
851 * = 0 (0x00) ....0... "Auto detect negative
852 * offset and cancel it"
853 * COMF[2:0] "Reserved"
854 * = 0 (0x00) .....000
859 * 0F COMG "Common Control G"
860 * = 66 (0x42) 01000010
861 * COMG[7] "Optical black output selection"
862 * = 0 (0x00) 0....... "Disable"
863 * COMG[6] "Black level calibrate selection"
864 * = 1 (0x01) .1...... "Use optical black pixels
866 * COMG[5:4] "Reserved"
867 * = 0 (0x00) ..00....
868 * COMG[3] "Channel offset adjustment"
869 * = 0 (0x00) ....0... "Disable offset adjustment"
870 * COMG[2] "ADC black level calibration option"
871 * = 0 (0x00) .....0.. "Use B/G line and G/R
872 * line to calibrate each
873 * channel's black level"
875 * = 1 (0x01) ......1.
876 * COMG[0] "ADC black level calibration enable"
877 * = 0 (0x00) .......0 "Disable"
882 * 14 COMJ "Common Control J"
883 * = 198 (0xC6) 11000110
884 * COMJ[7:6] "AGC gain ceiling"
885 * = 3 (0x03) 11...... "8x"
886 * COMJ[5:4] "Reserved"
887 * = 0 (0x00) ..00....
888 * COMJ[3] "Auto banding filter"
889 * = 0 (0x00) ....0... "Banding filter is always
890 * on off depending on
892 * COMJ[2] "VSYNC drop option"
893 * = 1 (0x01) .....1.. "SYNC is dropped if frame
895 * COMJ[1] "Frame data drop"
896 * = 1 (0x01) ......1. "Drop frame data if
897 * exposure is not within
898 * tolerance. In AEC mode,
899 * data is normally dropped
900 * when data is out of
903 * = 0 (0x00) .......0
908 * 15 COMK "Common Control K"
909 * = 2 (0x02) 00000010
910 * COMK[7] "CHSYNC pin output swap"
911 * = 0 (0x00) 0....... "CHSYNC"
912 * COMK[6] "HREF pin output swap"
913 * = 0 (0x00) .0...... "HREF"
914 * COMK[5] "PCLK output selection"
915 * = 0 (0x00) ..0..... "PCLK always output"
916 * COMK[4] "PCLK edge selection"
917 * = 0 (0x00) ...0.... "Data valid on falling edge"
918 * COMK[3] "HREF output polarity"
919 * = 0 (0x00) ....0... "positive"
921 * = 0 (0x00) .....0..
922 * COMK[1] "VSYNC polarity"
923 * = 1 (0x01) ......1. "negative"
924 * COMK[0] "HSYNC polarity"
925 * = 0 (0x00) .......0 "positive"
930 * 33 CHLF "Current Control"
931 * = 9 (0x09) 00001001
932 * CHLF[7:6] "Sensor current control"
933 * = 0 (0x00) 00......
934 * CHLF[5] "Sensor current range control"
935 * = 0 (0x00) ..0..... "normal range"
936 * CHLF[4] "Sensor current"
937 * = 0 (0x00) ...0.... "normal current"
938 * CHLF[3] "Sensor buffer current control"
939 * = 1 (0x01) ....1... "half current"
940 * CHLF[2] "Column buffer current control"
941 * = 0 (0x00) .....0.. "normal current"
942 * CHLF[1] "Analog DSP current control"
943 * = 0 (0x00) ......0. "normal current"
944 * CHLF[1] "ADC current control"
945 * = 0 (0x00) ......0. "normal current"
950 * 34 VBLM "Blooming Control"
951 * = 80 (0x50) 01010000
952 * VBLM[7] "Hard soft reset switch"
953 * = 0 (0x00) 0....... "Hard reset"
954 * VBLM[6:4] "Blooming voltage selection"
955 * = 5 (0x05) .101....
956 * VBLM[3:0] "Sensor current control"
957 * = 0 (0x00) ....0000
962 * 36 VCHG "Sensor Precharge Voltage Control"
963 * = 0 (0x00) 00000000
965 * = 0 (0x00) 0.......
966 * VCHG[6:4] "Sensor precharge voltage control"
967 * = 0 (0x00) .000....
968 * VCHG[3:0] "Sensor array common reference"
969 * = 0 (0x00) ....0000
974 * 37 ADC "ADC Reference Control"
975 * = 4 (0x04) 00000100
976 * ADC[7:4] "Reserved"
977 * = 0 (0x00) 0000....
978 * ADC[3] "ADC input signal range"
979 * = 0 (0x00) ....0... "Input signal 1.0x"
980 * ADC[2:0] "ADC range control"
981 * = 4 (0x04) .....100
986 * 38 ACOM "Analog Common Ground"
987 * = 82 (0x52) 01010010
988 * ACOM[7] "Analog gain control"
989 * = 0 (0x00) 0....... "Gain 1x"
990 * ACOM[6] "Analog black level calibration"
991 * = 1 (0x01) .1...... "On"
992 * ACOM[5:0] "Reserved"
993 * = 18 (0x12) ..010010
998 * 3A FREFA "Internal Reference Adjustment"
999 * = 0 (0x00) 00000000
1000 * FREFA[7:0] "Range"
1001 * = 0 (0x00) 00000000
1006 * 3C FVOPT "Internal Reference Adjustment"
1007 * = 31 (0x1F) 00011111
1008 * FVOPT[7:0] "Range"
1009 * = 31 (0x1F) 00011111
1014 * 44 Undocumented = 0 (0x00) 00000000
1015 * 44[7:0] "It's a secret"
1016 * = 0 (0x00) 00000000
1021 * 40 Undocumented = 0 (0x00) 00000000
1022 * 40[7:0] "It's a secret"
1023 * = 0 (0x00) 00000000
1028 * 41 Undocumented = 0 (0x00) 00000000
1029 * 41[7:0] "It's a secret"
1030 * = 0 (0x00) 00000000
1035 * 42 Undocumented = 0 (0x00) 00000000
1036 * 42[7:0] "It's a secret"
1037 * = 0 (0x00) 00000000
1042 * 43 Undocumented = 0 (0x00) 00000000
1043 * 43[7:0] "It's a secret"
1044 * = 0 (0x00) 00000000
1049 * 45 Undocumented = 128 (0x80) 10000000
1050 * 45[7:0] "It's a secret"
1051 * = 128 (0x80) 10000000
1056 * 48 Undocumented = 192 (0xC0) 11000000
1057 * 48[7:0] "It's a secret"
1058 * = 192 (0xC0) 11000000
1063 * 49 Undocumented = 25 (0x19) 00011001
1064 * 49[7:0] "It's a secret"
1065 * = 25 (0x19) 00011001
1070 * 4B Undocumented = 128 (0x80) 10000000
1071 * 4B[7:0] "It's a secret"
1072 * = 128 (0x80) 10000000
1077 * 4D Undocumented = 196 (0xC4) 11000100
1078 * 4D[7:0] "It's a secret"
1079 * = 196 (0xC4) 11000100
1084 * 35 VREF "Reference Voltage Control"
1085 * = 76 (0x4c) 01001100
1086 * VREF[7:5] "Column high reference control"
1087 * = 2 (0x02) 010..... "higher voltage"
1088 * VREF[4:2] "Column low reference control"
1089 * = 3 (0x03) ...011.. "Highest voltage"
1090 * VREF[1:0] "Reserved"
1091 * = 0 (0x00) ......00
1096 * 3D Undocumented = 0 (0x00) 00000000
1097 * 3D[7:0] "It's a secret"
1098 * = 0 (0x00) 00000000
1103 * 3E Undocumented = 0 (0x00) 00000000
1104 * 3E[7:0] "It's a secret"
1105 * = 0 (0x00) 00000000
1110 * 3B FREFB "Internal Reference Adjustment"
1111 * = 24 (0x18) 00011000
1112 * FREFB[7:0] "Range"
1113 * = 24 (0x18) 00011000
1118 * 33 CHLF "Current Control"
1119 * = 25 (0x19) 00011001
1120 * CHLF[7:6] "Sensor current control"
1121 * = 0 (0x00) 00......
1122 * CHLF[5] "Sensor current range control"
1123 * = 0 (0x00) ..0..... "normal range"
1124 * CHLF[4] "Sensor current"
1125 * = 1 (0x01) ...1.... "double current"
1126 * CHLF[3] "Sensor buffer current control"
1127 * = 1 (0x01) ....1... "half current"
1128 * CHLF[2] "Column buffer current control"
1129 * = 0 (0x00) .....0.. "normal current"
1130 * CHLF[1] "Analog DSP current control"
1131 * = 0 (0x00) ......0. "normal current"
1132 * CHLF[1] "ADC current control"
1133 * = 0 (0x00) ......0. "normal current"
1138 * 34 VBLM "Blooming Control"
1139 * = 90 (0x5A) 01011010
1140 * VBLM[7] "Hard soft reset switch"
1141 * = 0 (0x00) 0....... "Hard reset"
1142 * VBLM[6:4] "Blooming voltage selection"
1143 * = 5 (0x05) .101....
1144 * VBLM[3:0] "Sensor current control"
1145 * = 10 (0x0A) ....1010
1150 * 3B FREFB "Internal Reference Adjustment"
1151 * = 0 (0x00) 00000000
1152 * FREFB[7:0] "Range"
1153 * = 0 (0x00) 00000000
1158 * 33 CHLF "Current Control"
1159 * = 9 (0x09) 00001001
1160 * CHLF[7:6] "Sensor current control"
1161 * = 0 (0x00) 00......
1162 * CHLF[5] "Sensor current range control"
1163 * = 0 (0x00) ..0..... "normal range"
1164 * CHLF[4] "Sensor current"
1165 * = 0 (0x00) ...0.... "normal current"
1166 * CHLF[3] "Sensor buffer current control"
1167 * = 1 (0x01) ....1... "half current"
1168 * CHLF[2] "Column buffer current control"
1169 * = 0 (0x00) .....0.. "normal current"
1170 * CHLF[1] "Analog DSP current control"
1171 * = 0 (0x00) ......0. "normal current"
1172 * CHLF[1] "ADC current control"
1173 * = 0 (0x00) ......0. "normal current"
1178 * 34 VBLM "Blooming Control"
1179 * = 80 (0x50) 01010000
1180 * VBLM[7] "Hard soft reset switch"
1181 * = 0 (0x00) 0....... "Hard reset"
1182 * VBLM[6:4] "Blooming voltage selection"
1183 * = 5 (0x05) .101....
1184 * VBLM[3:0] "Sensor current control"
1185 * = 0 (0x00) ....0000
1190 * 12 COMH "Common Control H"
1191 * = 64 (0x40) 01000000
1193 * = 0 (0x00) 0....... "No-op"
1194 * COMH[6:4] "Resolution selection"
1195 * = 4 (0x04) .100.... "XGA"
1196 * COMH[3] "Master slave selection"
1197 * = 0 (0x00) ....0... "Master mode"
1198 * COMH[2] "Internal B/R channel option"
1199 * = 0 (0x00) .....0.. "B/R use same channel"
1200 * COMH[1] "Color bar test pattern"
1201 * = 0 (0x00) ......0. "Off"
1202 * COMH[0] "Reserved"
1203 * = 0 (0x00) .......0
1208 * 17 HREFST "Horizontal window start"
1209 * = 31 (0x1F) 00011111
1210 * HREFST[7:0] "Horizontal window start, 8 MSBs"
1211 * = 31 (0x1F) 00011111
1216 * 18 HREFEND "Horizontal window end"
1217 * = 95 (0x5F) 01011111
1218 * HREFEND[7:0] "Horizontal Window End, 8 MSBs"
1219 * = 95 (0x5F) 01011111
1224 * 19 VSTRT "Vertical window start"
1225 * = 0 (0x00) 00000000
1226 * VSTRT[7:0] "Vertical Window Start, 8 MSBs"
1227 * = 0 (0x00) 00000000
1232 * 1A VEND "Vertical window end"
1233 * = 96 (0x60) 01100000
1234 * VEND[7:0] "Vertical Window End, 8 MSBs"
1235 * = 96 (0x60) 01100000
1240 * 32 COMM "Common Control M"
1241 * = 18 (0x12) 00010010
1242 * COMM[7:6] "Pixel clock divide option"
1243 * = 0 (0x00) 00...... "/1"
1244 * COMM[5:3] "Horizontal window end position, 3 LSBs"
1245 * = 2 (0x02) ..010...
1246 * COMM[2:0] "Horizontal window start position, 3 LSBs"
1247 * = 2 (0x02) .....010
1252 * 03 COMA "Common Control A"
1253 * = 74 (0x4A) 01001010
1254 * COMA[7:4] "AWB Update Threshold"
1255 * = 4 (0x04) 0100....
1256 * COMA[3:2] "Vertical window end line control 2 LSBs"
1257 * = 2 (0x02) ....10..
1258 * COMA[1:0] "Vertical window start line control 2 LSBs"
1259 * = 2 (0x02) ......10
1264 * 11 CLKRC "Clock Rate Control"
1265 * = 128 (0x80) 10000000
1266 * CLKRC[7] "Internal frequency doublers on off seclection"
1267 * = 1 (0x01) 1....... "On"
1268 * CLKRC[6] "Digital video master slave selection"
1269 * = 0 (0x00) .0...... "Master mode, sensor
1271 * CLKRC[5:0] "Clock divider { CLK = PCLK/(1+CLKRC[5:0]) }"
1272 * = 0 (0x00) ..000000
1277 * 12 COMH "Common Control H"
1278 * = 0 (0x00) 00000000
1280 * = 0 (0x00) 0....... "No-op"
1281 * COMH[6:4] "Resolution selection"
1282 * = 0 (0x00) .000.... "QXGA"
1283 * COMH[3] "Master slave selection"
1284 * = 0 (0x00) ....0... "Master mode"
1285 * COMH[2] "Internal B/R channel option"
1286 * = 0 (0x00) .....0.. "B/R use same channel"
1287 * COMH[1] "Color bar test pattern"
1288 * = 0 (0x00) ......0. "Off"
1289 * COMH[0] "Reserved"
1290 * = 0 (0x00) .......0
1295 * 12 COMH "Common Control H"
1296 * = 64 (0x40) 01000000
1298 * = 0 (0x00) 0....... "No-op"
1299 * COMH[6:4] "Resolution selection"
1300 * = 4 (0x04) .100.... "XGA"
1301 * COMH[3] "Master slave selection"
1302 * = 0 (0x00) ....0... "Master mode"
1303 * COMH[2] "Internal B/R channel option"
1304 * = 0 (0x00) .....0.. "B/R use same channel"
1305 * COMH[1] "Color bar test pattern"
1306 * = 0 (0x00) ......0. "Off"
1307 * COMH[0] "Reserved"
1308 * = 0 (0x00) .......0
1313 * 17 HREFST "Horizontal window start"
1314 * = 31 (0x1F) 00011111
1315 * HREFST[7:0] "Horizontal window start, 8 MSBs"
1316 * = 31 (0x1F) 00011111
1321 * 18 HREFEND "Horizontal window end"
1322 * = 95 (0x5F) 01011111
1323 * HREFEND[7:0] "Horizontal Window End, 8 MSBs"
1324 * = 95 (0x5F) 01011111
1329 * 19 VSTRT "Vertical window start"
1330 * = 0 (0x00) 00000000
1331 * VSTRT[7:0] "Vertical Window Start, 8 MSBs"
1332 * = 0 (0x00) 00000000
1337 * 1A VEND "Vertical window end"
1338 * = 96 (0x60) 01100000
1339 * VEND[7:0] "Vertical Window End, 8 MSBs"
1340 * = 96 (0x60) 01100000
1345 * 32 COMM "Common Control M"
1346 * = 18 (0x12) 00010010
1347 * COMM[7:6] "Pixel clock divide option"
1348 * = 0 (0x00) 00...... "/1"
1349 * COMM[5:3] "Horizontal window end position, 3 LSBs"
1350 * = 2 (0x02) ..010...
1351 * COMM[2:0] "Horizontal window start position, 3 LSBs"
1352 * = 2 (0x02) .....010
1357 * 03 COMA "Common Control A"
1358 * = 74 (0x4A) 01001010
1359 * COMA[7:4] "AWB Update Threshold"
1360 * = 4 (0x04) 0100....
1361 * COMA[3:2] "Vertical window end line control 2 LSBs"
1362 * = 2 (0x02) ....10..
1363 * COMA[1:0] "Vertical window start line control 2 LSBs"
1364 * = 2 (0x02) ......10
1369 * 02 RED "Red Gain Control"
1370 * = 175 (0xAF) 10101111
1372 * = 1 (0x01) 1....... "gain = 1/(1+bitrev([6:0]))"
1374 * = 47 (0x2F) .0101111
1379 * 2D ADDVSL "VSYNC Pulse Width"
1380 * = 210 (0xD2) 11010010
1381 * ADDVSL[7:0] "VSYNC pulse width, LSB"
1382 * = 210 (0xD2) 11010010
1387 * 00 GAIN = 24 (0x18) 00011000
1388 * GAIN[7:6] "Reserved"
1389 * = 0 (0x00) 00......
1391 * = 0 (0x00) ..0..... "False"
1393 * = 1 (0x01) ...1.... "True"
1395 * = 8 (0x08) ....1000
1400 * 01 BLUE "Blue Gain Control"
1401 * = 240 (0xF0) 11110000
1403 * = 1 (0x01) 1....... "gain = 1/(1+bitrev([6:0]))"
1405 * = 112 (0x70) .1110000
1410 * 10 AEC "Automatic Exposure Control"
1411 * = 10 (0x0A) 00001010
1412 * AEC[7:0] "Automatic Exposure Control, 8 MSBs"
1413 * = 10 (0x0A) 00001010
1425 static const struct ov_i2c_regvals norm_6x20[] = {
1426 { 0x12, 0x80 }, /* reset */
1429 { 0x05, 0x7f }, /* For when autoadjust is off */
1431 /* The ratio of 0x0c and 0x0d controls the white point */
1434 { 0x0f, 0x15 }, /* COMS */
1435 { 0x10, 0x75 }, /* AEC Exposure time */
1436 { 0x12, 0x24 }, /* Enable AGC */
1438 /* 0x16: 0x06 helps frame stability with moving objects */
1440 /* { 0x20, 0x30 }, * Aperture correction enable */
1441 { 0x26, 0xb2 }, /* BLC enable */
1442 /* 0x28: 0x05 Selects RGB format if RGB on */
1444 { 0x2a, 0x04 }, /* Disable framerate adjust */
1445 /* { 0x2b, 0xac }, * Framerate; Set 2a[7] first */
1447 { 0x33, 0xa0 }, /* Color Processing Parameter */
1448 { 0x34, 0xd2 }, /* Max A/D range */
1452 { 0x3c, 0x39 }, /* Enable AEC mode changing */
1453 { 0x3c, 0x3c }, /* Change AEC mode */
1454 { 0x3c, 0x24 }, /* Disable AEC mode changing */
1457 /* These next two registers (0x4a, 0x4b) are undocumented.
1458 * They control the color balance */
1461 { 0x4d, 0xd2 }, /* This reduces noise a bit */
1464 /* Do 50-53 have any effect? */
1465 /* Toggle 0x12[2] off and on here? */
1468 static const struct ov_i2c_regvals norm_6x30[] = {
1469 { 0x12, 0x80 }, /* Reset */
1470 { 0x00, 0x1f }, /* Gain */
1471 { 0x01, 0x99 }, /* Blue gain */
1472 { 0x02, 0x7c }, /* Red gain */
1473 { 0x03, 0xc0 }, /* Saturation */
1474 { 0x05, 0x0a }, /* Contrast */
1475 { 0x06, 0x95 }, /* Brightness */
1476 { 0x07, 0x2d }, /* Sharpness */
1479 { 0x0e, 0xa0 }, /* Was 0x20, bit7 enables a 2x gain which we need */
1482 { 0x11, 0x00 }, /* Pixel clock = fastest */
1483 { 0x12, 0x24 }, /* Enable AGC and AWB */
1498 { 0x23, 0xc0 }, /* Crystal circuit power level */
1499 { 0x25, 0x9a }, /* Increase AEC black ratio */
1500 { 0x26, 0xb2 }, /* BLC enable */
1504 { 0x2a, 0x84 }, /* 60 Hz power */
1505 { 0x2b, 0xa8 }, /* 60 Hz power */
1507 { 0x2d, 0x95 }, /* Enable auto-brightness */
1521 { 0x40, 0x00 }, /* White bal */
1522 { 0x41, 0x00 }, /* White bal */
1524 { 0x43, 0x3f }, /* White bal */
1534 { 0x4d, 0x10 }, /* U = 0.563u, V = 0.714v */
1536 { 0x4f, 0x07 }, /* UV avg., col. killer: max */
1538 { 0x54, 0x23 }, /* Max AGC gain: 18dB */
1543 { 0x59, 0x01 }, /* AGC dark current comp.: +1 */
1545 { 0x5b, 0x0f }, /* AWB chrominance levels */
1549 { 0x12, 0x20 }, /* Toggle AWB */
1553 /* Lawrence Glaister <lg@jfm.bc.ca> reports:
1555 * Register 0x0f in the 7610 has the following effects:
1557 * 0x85 (AEC method 1): Best overall, good contrast range
1558 * 0x45 (AEC method 2): Very overexposed
1559 * 0xa5 (spec sheet default): Ok, but the black level is
1560 * shifted resulting in loss of contrast
1561 * 0x05 (old driver setting): very overexposed, too much
1564 static const struct ov_i2c_regvals norm_7610[] = {
1571 { 0x28, 0x24 }, /* 0c */
1572 { 0x0f, 0x85 }, /* lg's setting */
1594 static const struct ov_i2c_regvals norm_7620[] = {
1595 { 0x12, 0x80 }, /* reset */
1596 { 0x00, 0x00 }, /* gain */
1597 { 0x01, 0x80 }, /* blue gain */
1598 { 0x02, 0x80 }, /* red gain */
1599 { 0x03, 0xc0 }, /* OV7670_R03_VREF */
1622 { 0x28, 0x22 }, /* Was 0x20, bit1 enables a 2x gain which we need */
1661 /* 7640 and 7648. The defaults should be OK for most registers. */
1662 static const struct ov_i2c_regvals norm_7640[] = {
1667 static const struct ov_regvals init_519_ov7660[] = {
1668 { 0x5d, 0x03 }, /* Turn off suspend mode */
1669 { 0x53, 0x9b }, /* 0x9f enables the (unused) microcontroller */
1670 { 0x54, 0x0f }, /* bit2 (jpeg enable) */
1671 { 0xa2, 0x20 }, /* a2-a5 are undocumented */
1675 { 0x37, 0x00 }, /* SetUsbInit */
1676 { 0x55, 0x02 }, /* 4.096 Mhz audio clock */
1677 /* Enable both fields, YUV Input, disable defect comp (why?) */
1678 { 0x20, 0x0c }, /* 0x0d does U <-> V swap */
1681 { 0x17, 0x50 }, /* undocumented */
1682 { 0x37, 0x00 }, /* undocumented */
1683 { 0x40, 0xff }, /* I2C timeout counter */
1684 { 0x46, 0x00 }, /* I2C clock prescaler */
1686 static const struct ov_i2c_regvals norm_7660[] = {
1687 {OV7670_R12_COM7, OV7670_COM7_RESET},
1688 {OV7670_R11_CLKRC, 0x81},
1689 {0x92, 0x00}, /* DM_LNL */
1690 {0x93, 0x00}, /* DM_LNH */
1691 {0x9d, 0x4c}, /* BD50ST */
1692 {0x9e, 0x3f}, /* BD60ST */
1693 {OV7670_R3B_COM11, 0x02},
1694 {OV7670_R13_COM8, 0xf5},
1695 {OV7670_R10_AECH, 0x00},
1696 {OV7670_R00_GAIN, 0x00},
1697 {OV7670_R01_BLUE, 0x7c},
1698 {OV7670_R02_RED, 0x9d},
1699 {OV7670_R12_COM7, 0x00},
1700 {OV7670_R04_COM1, 00},
1701 {OV7670_R18_HSTOP, 0x01},
1702 {OV7670_R17_HSTART, 0x13},
1703 {OV7670_R32_HREF, 0x92},
1704 {OV7670_R19_VSTART, 0x02},
1705 {OV7670_R1A_VSTOP, 0x7a},
1706 {OV7670_R03_VREF, 0x00},
1707 {OV7670_R0E_COM5, 0x04},
1708 {OV7670_R0F_COM6, 0x62},
1709 {OV7670_R15_COM10, 0x00},
1710 {0x16, 0x02}, /* RSVD */
1711 {0x1b, 0x00}, /* PSHFT */
1712 {OV7670_R1E_MVFP, 0x01},
1713 {0x29, 0x3c}, /* RSVD */
1714 {0x33, 0x00}, /* CHLF */
1715 {0x34, 0x07}, /* ARBLM */
1716 {0x35, 0x84}, /* RSVD */
1717 {0x36, 0x00}, /* RSVD */
1718 {0x37, 0x04}, /* ADC */
1719 {0x39, 0x43}, /* OFON */
1720 {OV7670_R3A_TSLB, 0x00},
1721 {OV7670_R3C_COM12, 0x6c},
1722 {OV7670_R3D_COM13, 0x98},
1723 {OV7670_R3F_EDGE, 0x23},
1724 {OV7670_R40_COM15, 0xc1},
1725 {OV7670_R41_COM16, 0x22},
1726 {0x6b, 0x0a}, /* DBLV */
1727 {0xa1, 0x08}, /* RSVD */
1728 {0x69, 0x80}, /* HV */
1729 {0x43, 0xf0}, /* RSVD.. */
1744 {0x9f, 0x9d}, /* RSVD */
1745 {0xa0, 0xa0}, /* DSPC2 */
1746 {0x4f, 0x60}, /* matrix */
1755 {0x58, 0x0d}, /* matrix sign */
1756 {0x8b, 0xcc}, /* RSVD */
1759 {0x6c, 0x40}, /* gamma curve */
1775 {0x7c, 0x04}, /* gamma curve */
1790 {OV7670_R14_COM9, 0x1e},
1791 {OV7670_R24_AEW, 0x80},
1792 {OV7670_R25_AEB, 0x72},
1793 {OV7670_R26_VPT, 0xb3},
1794 {0x62, 0x80}, /* LCC1 */
1795 {0x63, 0x80}, /* LCC2 */
1796 {0x64, 0x06}, /* LCC3 */
1797 {0x65, 0x00}, /* LCC4 */
1798 {0x66, 0x01}, /* LCC5 */
1799 {0x94, 0x0e}, /* RSVD.. */
1801 {OV7670_R13_COM8, OV7670_COM8_FASTAEC
1802 | OV7670_COM8_AECSTEP
1811 /* 7670. Defaults taken from OmniVision provided data,
1812 * as provided by Jonathan Corbet of OLPC */
1813 static const struct ov_i2c_regvals norm_7670[] = {
1814 { OV7670_R12_COM7, OV7670_COM7_RESET },
1815 { OV7670_R3A_TSLB, 0x04 }, /* OV */
1816 { OV7670_R12_COM7, OV7670_COM7_FMT_VGA }, /* VGA */
1817 { OV7670_R11_CLKRC, 0x01 },
1819 * Set the hardware window. These values from OV don't entirely
1820 * make sense - hstop is less than hstart. But they work...
1822 { OV7670_R17_HSTART, 0x13 },
1823 { OV7670_R18_HSTOP, 0x01 },
1824 { OV7670_R32_HREF, 0xb6 },
1825 { OV7670_R19_VSTART, 0x02 },
1826 { OV7670_R1A_VSTOP, 0x7a },
1827 { OV7670_R03_VREF, 0x0a },
1829 { OV7670_R0C_COM3, 0x00 },
1830 { OV7670_R3E_COM14, 0x00 },
1831 /* Mystery scaling numbers */
1837 /* { OV7670_R15_COM10, 0x0 }, */
1839 /* Gamma curve values */
1857 /* AGC and AEC parameters. Note we start by disabling those features,
1858 then turn them only after tweaking the values. */
1859 { OV7670_R13_COM8, OV7670_COM8_FASTAEC
1860 | OV7670_COM8_AECSTEP
1861 | OV7670_COM8_BFILT },
1862 { OV7670_R00_GAIN, 0x00 },
1863 { OV7670_R10_AECH, 0x00 },
1864 { OV7670_R0D_COM4, 0x40 }, /* magic reserved bit */
1865 { OV7670_R14_COM9, 0x18 }, /* 4x gain + magic rsvd bit */
1866 { OV7670_RA5_BD50MAX, 0x05 },
1867 { OV7670_RAB_BD60MAX, 0x07 },
1868 { OV7670_R24_AEW, 0x95 },
1869 { OV7670_R25_AEB, 0x33 },
1870 { OV7670_R26_VPT, 0xe3 },
1871 { OV7670_R9F_HAECC1, 0x78 },
1872 { OV7670_RA0_HAECC2, 0x68 },
1873 { 0xa1, 0x03 }, /* magic */
1874 { OV7670_RA6_HAECC3, 0xd8 },
1875 { OV7670_RA7_HAECC4, 0xd8 },
1876 { OV7670_RA8_HAECC5, 0xf0 },
1877 { OV7670_RA9_HAECC6, 0x90 },
1878 { OV7670_RAA_HAECC7, 0x94 },
1879 { OV7670_R13_COM8, OV7670_COM8_FASTAEC
1880 | OV7670_COM8_AECSTEP
1883 | OV7670_COM8_AEC },
1885 /* Almost all of these are magic "reserved" values. */
1886 { OV7670_R0E_COM5, 0x61 },
1887 { OV7670_R0F_COM6, 0x4b },
1889 { OV7670_R1E_MVFP, 0x07 },
1898 { OV7670_R3C_COM12, 0x78 },
1901 { OV7670_R69_GFIX, 0x00 },
1917 /* More reserved magic, some of which tweaks white balance */
1933 { 0x6f, 0x9f }, /* "9e for advance AWB" */
1935 { OV7670_R01_BLUE, 0x40 },
1936 { OV7670_R02_RED, 0x60 },
1937 { OV7670_R13_COM8, OV7670_COM8_FASTAEC
1938 | OV7670_COM8_AECSTEP
1942 | OV7670_COM8_AWB },
1944 /* Matrix coefficients */
1953 { OV7670_R41_COM16, OV7670_COM16_AWBGAIN },
1954 { OV7670_R3F_EDGE, 0x00 },
1959 { OV7670_R3D_COM13, OV7670_COM13_GAMMA
1960 | OV7670_COM13_UVSAT
1964 { OV7670_R41_COM16, 0x38 },
1968 { OV7670_R3B_COM11, OV7670_COM11_EXP|OV7670_COM11_HZAUTO },
1981 /* Extra-weird stuff. Some sort of multiplexor register */
2007 static const struct ov_i2c_regvals norm_8610[] = {
2014 { 0x05, 0x30 }, /* was 0x10, new from windrv 090403 */
2015 { 0x06, 0x70 }, /* was 0x80, new from windrv 090403 */
2024 { 0x15, 0x01 }, /* Lin and Win think different about UV order */
2026 { 0x17, 0x38 }, /* was 0x2f, new from windrv 090403 */
2027 { 0x18, 0xea }, /* was 0xcf, new from windrv 090403 */
2028 { 0x19, 0x02 }, /* was 0x06, new from windrv 090403 */
2031 { 0x20, 0xd0 }, /* was 0x90, new from windrv 090403 */
2032 { 0x23, 0xc0 }, /* was 0x00, new from windrv 090403 */
2033 { 0x24, 0x30 }, /* was 0x1d, new from windrv 090403 */
2034 { 0x25, 0x50 }, /* was 0x57, new from windrv 090403 */
2040 { 0x2b, 0xc8 }, /* was 0xcc, new from windrv 090403 */
2042 { 0x2d, 0x45 }, /* was 0xd5, new from windrv 090403 */
2044 { 0x2f, 0x14 }, /* was 0x01, new from windrv 090403 */
2046 { 0x4d, 0x30 }, /* was 0x10, new from windrv 090403 */
2047 { 0x60, 0x02 }, /* was 0x01, new from windrv 090403 */
2048 { 0x61, 0x00 }, /* was 0x09, new from windrv 090403 */
2049 { 0x62, 0x5f }, /* was 0xd7, new from windrv 090403 */
2051 { 0x64, 0x53 }, /* new windrv 090403 says 0x57,
2052 * maybe thats wrong */
2056 { 0x68, 0xc0 }, /* was 0xaf, new from windrv 090403 */
2060 { 0x6c, 0x99 }, /* was 0x80, old windrv says 0x00, but
2061 * deleting bit7 colors the first images red */
2062 { 0x6d, 0x11 }, /* was 0x00, new from windrv 090403 */
2063 { 0x6e, 0x11 }, /* was 0x00, new from windrv 090403 */
2069 { 0x74, 0x00 },/* 0x60? - was 0x00, new from windrv 090403 */
2071 { 0x76, 0x02 }, /* was 0x02, new from windrv 090403 */
2076 { 0x7b, 0x10 }, /* was 0x13, new from windrv 090403 */
2078 { 0x7d, 0x08 }, /* was 0x09, new from windrv 090403 */
2079 { 0x7e, 0x08 }, /* was 0xc0, new from windrv 090403 */
2086 { 0x85, 0x62 }, /* was 0x61, new from windrv 090403 */
2092 { 0x12, 0x25 }, /* was 0x24, new from windrv 090403 */
2095 static unsigned char ov7670_abs_to_sm(unsigned char v)
2099 return (128 - v) | 0x80;
2102 /* Write a OV519 register */
2103 static void reg_w(struct sd *sd, u16 index, u16 value)
2107 if (sd->gspca_dev.usb_err < 0)
2110 switch (sd->bridge) {
2112 case BRIDGE_OV511PLUS:
2118 case BRIDGE_W9968CF:
2119 PDEBUG(D_USBO, "SET %02x %04x %04x",
2121 ret = usb_control_msg(sd->gspca_dev.dev,
2122 usb_sndctrlpipe(sd->gspca_dev.dev, 0),
2124 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2125 value, index, NULL, 0, 500);
2131 PDEBUG(D_USBO, "SET %02x 0000 %04x %02x",
2133 sd->gspca_dev.usb_buf[0] = value;
2134 ret = usb_control_msg(sd->gspca_dev.dev,
2135 usb_sndctrlpipe(sd->gspca_dev.dev, 0),
2137 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2139 sd->gspca_dev.usb_buf, 1, 500);
2142 err("reg_w %02x failed %d", index, ret);
2143 sd->gspca_dev.usb_err = ret;
2148 /* Read from a OV519 register, note not valid for the w9968cf!! */
2149 /* returns: negative is error, pos or zero is data */
2150 static int reg_r(struct sd *sd, u16 index)
2155 if (sd->gspca_dev.usb_err < 0)
2158 switch (sd->bridge) {
2160 case BRIDGE_OV511PLUS:
2170 ret = usb_control_msg(sd->gspca_dev.dev,
2171 usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
2173 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2174 0, index, sd->gspca_dev.usb_buf, 1, 500);
2177 ret = sd->gspca_dev.usb_buf[0];
2178 PDEBUG(D_USBI, "GET %02x 0000 %04x %02x",
2181 err("reg_r %02x failed %d", index, ret);
2182 sd->gspca_dev.usb_err = ret;
2188 /* Read 8 values from a OV519 register */
2189 static int reg_r8(struct sd *sd,
2194 if (sd->gspca_dev.usb_err < 0)
2197 ret = usb_control_msg(sd->gspca_dev.dev,
2198 usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
2200 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2201 0, index, sd->gspca_dev.usb_buf, 8, 500);
2204 ret = sd->gspca_dev.usb_buf[0];
2206 err("reg_r8 %02x failed %d", index, ret);
2207 sd->gspca_dev.usb_err = ret;
2214 * Writes bits at positions specified by mask to an OV51x reg. Bits that are in
2215 * the same position as 1's in "mask" are cleared and set to "value". Bits
2216 * that are in the same position as 0's in "mask" are preserved, regardless
2217 * of their respective state in "value".
2219 static void reg_w_mask(struct sd *sd,
2228 value &= mask; /* Enforce mask on value */
2229 ret = reg_r(sd, index);
2233 oldval = ret & ~mask; /* Clear the masked bits */
2234 value |= oldval; /* Set the desired bits */
2236 reg_w(sd, index, value);
2240 * Writes multiple (n) byte value to a single register. Only valid with certain
2241 * registers (0x30 and 0xc4 - 0xce).
2243 static void ov518_reg_w32(struct sd *sd, u16 index, u32 value, int n)
2247 if (sd->gspca_dev.usb_err < 0)
2250 *((__le32 *) sd->gspca_dev.usb_buf) = __cpu_to_le32(value);
2252 ret = usb_control_msg(sd->gspca_dev.dev,
2253 usb_sndctrlpipe(sd->gspca_dev.dev, 0),
2255 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2257 sd->gspca_dev.usb_buf, n, 500);
2259 err("reg_w32 %02x failed %d", index, ret);
2260 sd->gspca_dev.usb_err = ret;
2264 static void ov511_i2c_w(struct sd *sd, u8 reg, u8 value)
2268 PDEBUG(D_USBO, "ov511_i2c_w %02x %02x", reg, value);
2270 /* Three byte write cycle */
2271 for (retries = 6; ; ) {
2272 /* Select camera register */
2273 reg_w(sd, R51x_I2C_SADDR_3, reg);
2275 /* Write "value" to I2C data port of OV511 */
2276 reg_w(sd, R51x_I2C_DATA, value);
2278 /* Initiate 3-byte write cycle */
2279 reg_w(sd, R511_I2C_CTL, 0x01);
2282 rc = reg_r(sd, R511_I2C_CTL);
2283 } while (rc > 0 && ((rc & 1) == 0)); /* Retry until idle */
2288 if ((rc & 2) == 0) /* Ack? */
2290 if (--retries < 0) {
2291 PDEBUG(D_USBO, "i2c write retries exhausted");
2297 static int ov511_i2c_r(struct sd *sd, u8 reg)
2299 int rc, value, retries;
2301 /* Two byte write cycle */
2302 for (retries = 6; ; ) {
2303 /* Select camera register */
2304 reg_w(sd, R51x_I2C_SADDR_2, reg);
2306 /* Initiate 2-byte write cycle */
2307 reg_w(sd, R511_I2C_CTL, 0x03);
2310 rc = reg_r(sd, R511_I2C_CTL);
2311 } while (rc > 0 && ((rc & 1) == 0)); /* Retry until idle */
2316 if ((rc & 2) == 0) /* Ack? */
2320 reg_w(sd, R511_I2C_CTL, 0x10);
2322 if (--retries < 0) {
2323 PDEBUG(D_USBI, "i2c write retries exhausted");
2328 /* Two byte read cycle */
2329 for (retries = 6; ; ) {
2330 /* Initiate 2-byte read cycle */
2331 reg_w(sd, R511_I2C_CTL, 0x05);
2334 rc = reg_r(sd, R511_I2C_CTL);
2335 } while (rc > 0 && ((rc & 1) == 0)); /* Retry until idle */
2340 if ((rc & 2) == 0) /* Ack? */
2344 reg_w(sd, R511_I2C_CTL, 0x10);
2346 if (--retries < 0) {
2347 PDEBUG(D_USBI, "i2c read retries exhausted");
2352 value = reg_r(sd, R51x_I2C_DATA);
2354 PDEBUG(D_USBI, "ov511_i2c_r %02x %02x", reg, value);
2356 /* This is needed to make i2c_w() work */
2357 reg_w(sd, R511_I2C_CTL, 0x05);
2363 * The OV518 I2C I/O procedure is different, hence, this function.
2364 * This is normally only called from i2c_w(). Note that this function
2365 * always succeeds regardless of whether the sensor is present and working.
2367 static void ov518_i2c_w(struct sd *sd,
2371 PDEBUG(D_USBO, "ov518_i2c_w %02x %02x", reg, value);
2373 /* Select camera register */
2374 reg_w(sd, R51x_I2C_SADDR_3, reg);
2376 /* Write "value" to I2C data port of OV511 */
2377 reg_w(sd, R51x_I2C_DATA, value);
2379 /* Initiate 3-byte write cycle */
2380 reg_w(sd, R518_I2C_CTL, 0x01);
2382 /* wait for write complete */
2384 reg_r8(sd, R518_I2C_CTL);
2388 * returns: negative is error, pos or zero is data
2390 * The OV518 I2C I/O procedure is different, hence, this function.
2391 * This is normally only called from i2c_r(). Note that this function
2392 * always succeeds regardless of whether the sensor is present and working.
2394 static int ov518_i2c_r(struct sd *sd, u8 reg)
2398 /* Select camera register */
2399 reg_w(sd, R51x_I2C_SADDR_2, reg);
2401 /* Initiate 2-byte write cycle */
2402 reg_w(sd, R518_I2C_CTL, 0x03);
2404 /* Initiate 2-byte read cycle */
2405 reg_w(sd, R518_I2C_CTL, 0x05);
2406 value = reg_r(sd, R51x_I2C_DATA);
2407 PDEBUG(D_USBI, "ov518_i2c_r %02x %02x", reg, value);
2411 static void ovfx2_i2c_w(struct sd *sd, u8 reg, u8 value)
2415 if (sd->gspca_dev.usb_err < 0)
2418 ret = usb_control_msg(sd->gspca_dev.dev,
2419 usb_sndctrlpipe(sd->gspca_dev.dev, 0),
2421 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2422 (u16) value, (u16) reg, NULL, 0, 500);
2425 err("ovfx2_i2c_w %02x failed %d", reg, ret);
2426 sd->gspca_dev.usb_err = ret;
2429 PDEBUG(D_USBO, "ovfx2_i2c_w %02x %02x", reg, value);
2432 static int ovfx2_i2c_r(struct sd *sd, u8 reg)
2436 if (sd->gspca_dev.usb_err < 0)
2439 ret = usb_control_msg(sd->gspca_dev.dev,
2440 usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
2442 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2443 0, (u16) reg, sd->gspca_dev.usb_buf, 1, 500);
2446 ret = sd->gspca_dev.usb_buf[0];
2447 PDEBUG(D_USBI, "ovfx2_i2c_r %02x %02x", reg, ret);
2449 err("ovfx2_i2c_r %02x failed %d", reg, ret);
2450 sd->gspca_dev.usb_err = ret;
2456 static void i2c_w(struct sd *sd, u8 reg, u8 value)
2458 if (sd->sensor_reg_cache[reg] == value)
2461 switch (sd->bridge) {
2463 case BRIDGE_OV511PLUS:
2464 ov511_i2c_w(sd, reg, value);
2467 case BRIDGE_OV518PLUS:
2469 ov518_i2c_w(sd, reg, value);
2472 ovfx2_i2c_w(sd, reg, value);
2474 case BRIDGE_W9968CF:
2475 w9968cf_i2c_w(sd, reg, value);
2479 if (sd->gspca_dev.usb_err >= 0) {
2480 /* Up on sensor reset empty the register cache */
2481 if (reg == 0x12 && (value & 0x80))
2482 memset(sd->sensor_reg_cache, -1,
2483 sizeof(sd->sensor_reg_cache));
2485 sd->sensor_reg_cache[reg] = value;
2489 static int i2c_r(struct sd *sd, u8 reg)
2493 if (sd->sensor_reg_cache[reg] != -1)
2494 return sd->sensor_reg_cache[reg];
2496 switch (sd->bridge) {
2498 case BRIDGE_OV511PLUS:
2499 ret = ov511_i2c_r(sd, reg);
2502 case BRIDGE_OV518PLUS:
2504 ret = ov518_i2c_r(sd, reg);
2507 ret = ovfx2_i2c_r(sd, reg);
2509 case BRIDGE_W9968CF:
2510 ret = w9968cf_i2c_r(sd, reg);
2515 sd->sensor_reg_cache[reg] = ret;
2520 /* Writes bits at positions specified by mask to an I2C reg. Bits that are in
2521 * the same position as 1's in "mask" are cleared and set to "value". Bits
2522 * that are in the same position as 0's in "mask" are preserved, regardless
2523 * of their respective state in "value".
2525 static void i2c_w_mask(struct sd *sd,
2533 value &= mask; /* Enforce mask on value */
2534 rc = i2c_r(sd, reg);
2537 oldval = rc & ~mask; /* Clear the masked bits */
2538 value |= oldval; /* Set the desired bits */
2539 i2c_w(sd, reg, value);
2542 /* Temporarily stops OV511 from functioning. Must do this before changing
2543 * registers while the camera is streaming */
2544 static inline void ov51x_stop(struct sd *sd)
2546 PDEBUG(D_STREAM, "stopping");
2548 switch (sd->bridge) {
2550 case BRIDGE_OV511PLUS:
2551 reg_w(sd, R51x_SYS_RESET, 0x3d);
2554 case BRIDGE_OV518PLUS:
2555 reg_w_mask(sd, R51x_SYS_RESET, 0x3a, 0x3a);
2558 reg_w(sd, OV519_R51_RESET1, 0x0f);
2559 reg_w(sd, OV519_R51_RESET1, 0x00);
2560 reg_w(sd, 0x22, 0x00); /* FRAR */
2563 reg_w_mask(sd, 0x0f, 0x00, 0x02);
2565 case BRIDGE_W9968CF:
2566 reg_w(sd, 0x3c, 0x0a05); /* stop USB transfer */
2571 /* Restarts OV511 after ov511_stop() is called. Has no effect if it is not
2572 * actually stopped (for performance). */
2573 static inline void ov51x_restart(struct sd *sd)
2575 PDEBUG(D_STREAM, "restarting");
2580 /* Reinitialize the stream */
2581 switch (sd->bridge) {
2583 case BRIDGE_OV511PLUS:
2584 reg_w(sd, R51x_SYS_RESET, 0x00);
2587 case BRIDGE_OV518PLUS:
2588 reg_w(sd, 0x2f, 0x80);
2589 reg_w(sd, R51x_SYS_RESET, 0x00);
2592 reg_w(sd, OV519_R51_RESET1, 0x0f);
2593 reg_w(sd, OV519_R51_RESET1, 0x00);
2594 reg_w(sd, 0x22, 0x1d); /* FRAR */
2597 reg_w_mask(sd, 0x0f, 0x02, 0x02);
2599 case BRIDGE_W9968CF:
2600 reg_w(sd, 0x3c, 0x8a05); /* USB FIFO enable */
2605 static void ov51x_set_slave_ids(struct sd *sd, u8 slave);
2607 /* This does an initial reset of an OmniVision sensor and ensures that I2C
2608 * is synchronized. Returns <0 on failure.
2610 static int init_ov_sensor(struct sd *sd, u8 slave)
2614 ov51x_set_slave_ids(sd, slave);
2616 /* Reset the sensor */
2617 i2c_w(sd, 0x12, 0x80);
2619 /* Wait for it to initialize */
2622 for (i = 0; i < i2c_detect_tries; i++) {
2623 if (i2c_r(sd, OV7610_REG_ID_HIGH) == 0x7f &&
2624 i2c_r(sd, OV7610_REG_ID_LOW) == 0xa2) {
2625 PDEBUG(D_PROBE, "I2C synced in %d attempt(s)", i);
2629 /* Reset the sensor */
2630 i2c_w(sd, 0x12, 0x80);
2632 /* Wait for it to initialize */
2635 /* Dummy read to sync I2C */
2636 if (i2c_r(sd, 0x00) < 0)
2642 /* Set the read and write slave IDs. The "slave" argument is the write slave,
2643 * and the read slave will be set to (slave + 1).
2644 * This should not be called from outside the i2c I/O functions.
2645 * Sets I2C read and write slave IDs. Returns <0 for error
2647 static void ov51x_set_slave_ids(struct sd *sd,
2650 switch (sd->bridge) {
2652 reg_w(sd, OVFX2_I2C_ADDR, slave);
2654 case BRIDGE_W9968CF:
2655 sd->sensor_addr = slave;
2659 reg_w(sd, R51x_I2C_W_SID, slave);
2660 reg_w(sd, R51x_I2C_R_SID, slave + 1);
2663 static void write_regvals(struct sd *sd,
2664 const struct ov_regvals *regvals,
2668 reg_w(sd, regvals->reg, regvals->val);
2673 static void write_i2c_regvals(struct sd *sd,
2674 const struct ov_i2c_regvals *regvals,
2678 i2c_w(sd, regvals->reg, regvals->val);
2683 /****************************************************************************
2685 * OV511 and sensor configuration
2687 ***************************************************************************/
2689 /* This initializes the OV2x10 / OV3610 / OV3620 */
2690 static void ov_hires_configure(struct sd *sd)
2694 if (sd->bridge != BRIDGE_OVFX2) {
2695 err("error hires sensors only supported with ovfx2");
2699 PDEBUG(D_PROBE, "starting ov hires configuration");
2701 /* Detect sensor (sub)type */
2702 high = i2c_r(sd, 0x0a);
2703 low = i2c_r(sd, 0x0b);
2704 /* info("%x, %x", high, low); */
2705 if (high == 0x96 && low == 0x40) {
2706 PDEBUG(D_PROBE, "Sensor is an OV2610");
2707 sd->sensor = SEN_OV2610;
2708 } else if (high == 0x96 && low == 0x41) {
2709 PDEBUG(D_PROBE, "Sensor is an OV2610AE");
2710 sd->sensor = SEN_OV2610AE;
2711 } else if (high == 0x36 && (low & 0x0f) == 0x00) {
2712 PDEBUG(D_PROBE, "Sensor is an OV3610");
2713 sd->sensor = SEN_OV3610;
2715 err("Error unknown sensor type: %02x%02x",
2720 /* This initializes the OV8110, OV8610 sensor. The OV8110 uses
2721 * the same register settings as the OV8610, since they are very similar.
2723 static void ov8xx0_configure(struct sd *sd)
2727 PDEBUG(D_PROBE, "starting ov8xx0 configuration");
2729 /* Detect sensor (sub)type */
2730 rc = i2c_r(sd, OV7610_REG_COM_I);
2732 PDEBUG(D_ERR, "Error detecting sensor type");
2736 sd->sensor = SEN_OV8610;
2738 err("Unknown image sensor version: %d", rc & 3);
2741 /* This initializes the OV7610, OV7620, or OV76BE sensor. The OV76BE uses
2742 * the same register settings as the OV7610, since they are very similar.
2744 static void ov7xx0_configure(struct sd *sd)
2748 PDEBUG(D_PROBE, "starting OV7xx0 configuration");
2750 /* Detect sensor (sub)type */
2751 rc = i2c_r(sd, OV7610_REG_COM_I);
2754 * it appears to be wrongly detected as a 7610 by default */
2756 PDEBUG(D_ERR, "Error detecting sensor type");
2759 if ((rc & 3) == 3) {
2760 /* quick hack to make OV7670s work */
2761 high = i2c_r(sd, 0x0a);
2762 low = i2c_r(sd, 0x0b);
2763 /* info("%x, %x", high, low); */
2764 if (high == 0x76 && (low & 0xf0) == 0x70) {
2765 PDEBUG(D_PROBE, "Sensor is an OV76%02x", low);
2766 sd->sensor = SEN_OV7670;
2768 PDEBUG(D_PROBE, "Sensor is an OV7610");
2769 sd->sensor = SEN_OV7610;
2771 } else if ((rc & 3) == 1) {
2772 /* I don't know what's different about the 76BE yet. */
2773 if (i2c_r(sd, 0x15) & 1) {
2774 PDEBUG(D_PROBE, "Sensor is an OV7620AE");
2775 sd->sensor = SEN_OV7620AE;
2777 PDEBUG(D_PROBE, "Sensor is an OV76BE");
2778 sd->sensor = SEN_OV76BE;
2780 } else if ((rc & 3) == 0) {
2781 /* try to read product id registers */
2782 high = i2c_r(sd, 0x0a);
2784 PDEBUG(D_ERR, "Error detecting camera chip PID");
2787 low = i2c_r(sd, 0x0b);
2789 PDEBUG(D_ERR, "Error detecting camera chip VER");
2795 err("Sensor is an OV7630/OV7635");
2796 err("7630 is not supported by this driver");
2799 PDEBUG(D_PROBE, "Sensor is an OV7645");
2800 sd->sensor = SEN_OV7640; /* FIXME */
2803 PDEBUG(D_PROBE, "Sensor is an OV7645B");
2804 sd->sensor = SEN_OV7640; /* FIXME */
2807 PDEBUG(D_PROBE, "Sensor is an OV7648");
2808 sd->sensor = SEN_OV7648;
2811 PDEBUG(D_PROBE, "Sensor is a OV7660");
2812 sd->sensor = SEN_OV7660;
2816 PDEBUG(D_PROBE, "Unknown sensor: 0x76%x", low);
2820 PDEBUG(D_PROBE, "Sensor is an OV7620");
2821 sd->sensor = SEN_OV7620;
2824 err("Unknown image sensor version: %d", rc & 3);
2828 /* This initializes the OV6620, OV6630, OV6630AE, or OV6630AF sensor. */
2829 static void ov6xx0_configure(struct sd *sd)
2832 PDEBUG(D_PROBE, "starting OV6xx0 configuration");
2834 /* Detect sensor (sub)type */
2835 rc = i2c_r(sd, OV7610_REG_COM_I);
2837 PDEBUG(D_ERR, "Error detecting sensor type");
2841 /* Ugh. The first two bits are the version bits, but
2842 * the entire register value must be used. I guess OVT
2843 * underestimated how many variants they would make. */
2846 sd->sensor = SEN_OV6630;
2847 warn("WARNING: Sensor is an OV66308. Your camera may have");
2848 warn("been misdetected in previous driver versions.");
2851 sd->sensor = SEN_OV6620;
2852 PDEBUG(D_PROBE, "Sensor is an OV6620");
2855 sd->sensor = SEN_OV6630;
2856 PDEBUG(D_PROBE, "Sensor is an OV66308AE");
2859 sd->sensor = SEN_OV66308AF;
2860 PDEBUG(D_PROBE, "Sensor is an OV66308AF");
2863 sd->sensor = SEN_OV6630;
2864 warn("WARNING: Sensor is an OV66307. Your camera may have");
2865 warn("been misdetected in previous driver versions.");
2868 err("FATAL: Unknown sensor version: 0x%02x", rc);
2872 /* Set sensor-specific vars */
2876 /* Turns on or off the LED. Only has an effect with OV511+/OV518(+)/OV519 */
2877 static void ov51x_led_control(struct sd *sd, int on)
2882 switch (sd->bridge) {
2883 /* OV511 has no LED control */
2884 case BRIDGE_OV511PLUS:
2885 reg_w(sd, R511_SYS_LED_CTL, on);
2888 case BRIDGE_OV518PLUS:
2889 reg_w_mask(sd, R518_GPIO_OUT, 0x02 * on, 0x02);
2892 reg_w_mask(sd, OV519_GPIO_DATA_OUT0, on, 1);
2897 static void sd_reset_snapshot(struct gspca_dev *gspca_dev)
2899 struct sd *sd = (struct sd *) gspca_dev;
2901 if (!sd->snapshot_needs_reset)
2904 /* Note it is important that we clear sd->snapshot_needs_reset,
2905 before actually clearing the snapshot state in the bridge
2906 otherwise we might race with the pkt_scan interrupt handler */
2907 sd->snapshot_needs_reset = 0;
2909 switch (sd->bridge) {
2911 case BRIDGE_OV511PLUS:
2912 reg_w(sd, R51x_SYS_SNAP, 0x02);
2913 reg_w(sd, R51x_SYS_SNAP, 0x00);
2916 case BRIDGE_OV518PLUS:
2917 reg_w(sd, R51x_SYS_SNAP, 0x02); /* Reset */
2918 reg_w(sd, R51x_SYS_SNAP, 0x01); /* Enable */
2921 reg_w(sd, R51x_SYS_RESET, 0x40);
2922 reg_w(sd, R51x_SYS_RESET, 0x00);
2927 static void ov51x_upload_quan_tables(struct sd *sd)
2929 const unsigned char yQuanTable511[] = {
2930 0, 1, 1, 2, 2, 3, 3, 4,
2931 1, 1, 1, 2, 2, 3, 4, 4,
2932 1, 1, 2, 2, 3, 4, 4, 4,
2933 2, 2, 2, 3, 4, 4, 4, 4,
2934 2, 2, 3, 4, 4, 5, 5, 5,
2935 3, 3, 4, 4, 5, 5, 5, 5,
2936 3, 4, 4, 4, 5, 5, 5, 5,
2937 4, 4, 4, 4, 5, 5, 5, 5
2940 const unsigned char uvQuanTable511[] = {
2941 0, 2, 2, 3, 4, 4, 4, 4,
2942 2, 2, 2, 4, 4, 4, 4, 4,
2943 2, 2, 3, 4, 4, 4, 4, 4,
2944 3, 4, 4, 4, 4, 4, 4, 4,
2945 4, 4, 4, 4, 4, 4, 4, 4,
2946 4, 4, 4, 4, 4, 4, 4, 4,
2947 4, 4, 4, 4, 4, 4, 4, 4,
2948 4, 4, 4, 4, 4, 4, 4, 4
2951 /* OV518 quantization tables are 8x4 (instead of 8x8) */
2952 const unsigned char yQuanTable518[] = {
2953 5, 4, 5, 6, 6, 7, 7, 7,
2954 5, 5, 5, 5, 6, 7, 7, 7,
2955 6, 6, 6, 6, 7, 7, 7, 8,
2956 7, 7, 6, 7, 7, 7, 8, 8
2958 const unsigned char uvQuanTable518[] = {
2959 6, 6, 6, 7, 7, 7, 7, 7,
2960 6, 6, 6, 7, 7, 7, 7, 7,
2961 6, 6, 6, 7, 7, 7, 7, 8,
2962 7, 7, 7, 7, 7, 7, 8, 8
2965 const unsigned char *pYTable, *pUVTable;
2966 unsigned char val0, val1;
2967 int i, size, reg = R51x_COMP_LUT_BEGIN;
2969 PDEBUG(D_PROBE, "Uploading quantization tables");
2971 if (sd->bridge == BRIDGE_OV511 || sd->bridge == BRIDGE_OV511PLUS) {
2972 pYTable = yQuanTable511;
2973 pUVTable = uvQuanTable511;
2976 pYTable = yQuanTable518;
2977 pUVTable = uvQuanTable518;
2981 for (i = 0; i < size; i++) {
2987 reg_w(sd, reg, val0);
2994 reg_w(sd, reg + size, val0);
3000 /* This initializes the OV511/OV511+ and the sensor */
3001 static void ov511_configure(struct gspca_dev *gspca_dev)
3003 struct sd *sd = (struct sd *) gspca_dev;
3005 /* For 511 and 511+ */
3006 const struct ov_regvals init_511[] = {
3007 { R51x_SYS_RESET, 0x7f },
3008 { R51x_SYS_INIT, 0x01 },
3009 { R51x_SYS_RESET, 0x7f },
3010 { R51x_SYS_INIT, 0x01 },
3011 { R51x_SYS_RESET, 0x3f },
3012 { R51x_SYS_INIT, 0x01 },
3013 { R51x_SYS_RESET, 0x3d },
3016 const struct ov_regvals norm_511[] = {
3017 { R511_DRAM_FLOW_CTL, 0x01 },
3018 { R51x_SYS_SNAP, 0x00 },
3019 { R51x_SYS_SNAP, 0x02 },
3020 { R51x_SYS_SNAP, 0x00 },
3021 { R511_FIFO_OPTS, 0x1f },
3022 { R511_COMP_EN, 0x00 },
3023 { R511_COMP_LUT_EN, 0x03 },
3026 const struct ov_regvals norm_511_p[] = {
3027 { R511_DRAM_FLOW_CTL, 0xff },
3028 { R51x_SYS_SNAP, 0x00 },
3029 { R51x_SYS_SNAP, 0x02 },
3030 { R51x_SYS_SNAP, 0x00 },
3031 { R511_FIFO_OPTS, 0xff },
3032 { R511_COMP_EN, 0x00 },
3033 { R511_COMP_LUT_EN, 0x03 },
3036 const struct ov_regvals compress_511[] = {
3047 PDEBUG(D_PROBE, "Device custom id %x", reg_r(sd, R51x_SYS_CUST_ID));
3049 write_regvals(sd, init_511, ARRAY_SIZE(init_511));
3051 switch (sd->bridge) {
3053 write_regvals(sd, norm_511, ARRAY_SIZE(norm_511));
3055 case BRIDGE_OV511PLUS:
3056 write_regvals(sd, norm_511_p, ARRAY_SIZE(norm_511_p));
3060 /* Init compression */
3061 write_regvals(sd, compress_511, ARRAY_SIZE(compress_511));
3063 ov51x_upload_quan_tables(sd);
3066 /* This initializes the OV518/OV518+ and the sensor */
3067 static void ov518_configure(struct gspca_dev *gspca_dev)
3069 struct sd *sd = (struct sd *) gspca_dev;
3071 /* For 518 and 518+ */
3072 const struct ov_regvals init_518[] = {
3073 { R51x_SYS_RESET, 0x40 },
3074 { R51x_SYS_INIT, 0xe1 },
3075 { R51x_SYS_RESET, 0x3e },
3076 { R51x_SYS_INIT, 0xe1 },
3077 { R51x_SYS_RESET, 0x00 },
3078 { R51x_SYS_INIT, 0xe1 },
3083 const struct ov_regvals norm_518[] = {
3084 { R51x_SYS_SNAP, 0x02 }, /* Reset */
3085 { R51x_SYS_SNAP, 0x01 }, /* Enable */
3096 const struct ov_regvals norm_518_p[] = {
3097 { R51x_SYS_SNAP, 0x02 }, /* Reset */
3098 { R51x_SYS_SNAP, 0x01 }, /* Enable */
3115 /* First 5 bits of custom ID reg are a revision ID on OV518 */
3116 PDEBUG(D_PROBE, "Device revision %d",
3117 0x1f & reg_r(sd, R51x_SYS_CUST_ID));
3119 write_regvals(sd, init_518, ARRAY_SIZE(init_518));
3121 /* Set LED GPIO pin to output mode */
3122 reg_w_mask(sd, R518_GPIO_CTL, 0x00, 0x02);
3124 switch (sd->bridge) {
3126 write_regvals(sd, norm_518, ARRAY_SIZE(norm_518));
3128 case BRIDGE_OV518PLUS:
3129 write_regvals(sd, norm_518_p, ARRAY_SIZE(norm_518_p));
3133 ov51x_upload_quan_tables(sd);
3135 reg_w(sd, 0x2f, 0x80);
3138 static void ov519_configure(struct sd *sd)
3140 static const struct ov_regvals init_519[] = {
3141 { 0x5a, 0x6d }, /* EnableSystem */
3142 { 0x53, 0x9b }, /* don't enable the microcontroller */
3143 { OV519_R54_EN_CLK1, 0xff }, /* set bit2 to enable jpeg */
3147 /* Set LED pin to output mode. Bit 4 must be cleared or sensor
3148 * detection will fail. This deserves further investigation. */
3149 { OV519_GPIO_IO_CTRL0, 0xee },
3150 { OV519_R51_RESET1, 0x0f },
3151 { OV519_R51_RESET1, 0x00 },
3153 /* windows reads 0x55 at this point*/
3156 write_regvals(sd, init_519, ARRAY_SIZE(init_519));
3159 static void ovfx2_configure(struct sd *sd)
3161 static const struct ov_regvals init_fx2[] = {
3173 write_regvals(sd, init_fx2, ARRAY_SIZE(init_fx2));
3177 /* This function works for ov7660 only */
3178 static void ov519_set_mode(struct sd *sd)
3180 static const struct ov_regvals bridge_ov7660[2][10] = {
3181 {{0x10, 0x14}, {0x11, 0x1e}, {0x12, 0x00}, {0x13, 0x00},
3182 {0x14, 0x00}, {0x15, 0x00}, {0x16, 0x00}, {0x20, 0x0c},
3183 {0x25, 0x01}, {0x26, 0x00}},
3184 {{0x10, 0x28}, {0x11, 0x3c}, {0x12, 0x00}, {0x13, 0x00},
3185 {0x14, 0x00}, {0x15, 0x00}, {0x16, 0x00}, {0x20, 0x0c},
3186 {0x25, 0x03}, {0x26, 0x00}}
3188 static const struct ov_i2c_regvals sensor_ov7660[2][3] = {
3189 {{0x12, 0x00}, {0x24, 0x00}, {0x0c, 0x0c}},
3190 {{0x12, 0x00}, {0x04, 0x00}, {0x0c, 0x00}}
3192 static const struct ov_i2c_regvals sensor_ov7660_2[] = {
3193 {OV7670_R17_HSTART, 0x13},
3194 {OV7670_R18_HSTOP, 0x01},
3195 {OV7670_R32_HREF, 0x92},
3196 {OV7670_R19_VSTART, 0x02},
3197 {OV7670_R1A_VSTOP, 0x7a},
3198 {OV7670_R03_VREF, 0x00},
3205 write_regvals(sd, bridge_ov7660[sd->gspca_dev.curr_mode],
3206 ARRAY_SIZE(bridge_ov7660[0]));
3207 write_i2c_regvals(sd, sensor_ov7660[sd->gspca_dev.curr_mode],
3208 ARRAY_SIZE(sensor_ov7660[0]));
3209 write_i2c_regvals(sd, sensor_ov7660_2,
3210 ARRAY_SIZE(sensor_ov7660_2));
3213 /* set the frame rate */
3214 /* This function works for sensors ov7640, ov7648 ov7660 and ov7670 only */
3215 static void ov519_set_fr(struct sd *sd)
3219 /* frame rate table with indices:
3220 * - mode = 0: 320x240, 1: 640x480
3221 * - fr rate = 0: 30, 1: 25, 2: 20, 3: 15, 4: 10, 5: 5
3222 * - reg = 0: bridge a4, 1: bridge 23, 2: sensor 11 (clock)
3224 static const u8 fr_tb[2][6][3] = {
3225 {{0x04, 0xff, 0x00},
3230 {0x04, 0x01, 0x00}},
3231 {{0x0c, 0xff, 0x00},
3236 {0x04, 0x1b, 0x01}},
3240 sd->frame_rate = frame_rate;
3241 if (sd->frame_rate >= 30)
3243 else if (sd->frame_rate >= 25)
3245 else if (sd->frame_rate >= 20)
3247 else if (sd->frame_rate >= 15)
3249 else if (sd->frame_rate >= 10)
3253 reg_w(sd, 0xa4, fr_tb[sd->gspca_dev.curr_mode][fr][0]);
3254 reg_w(sd, 0x23, fr_tb[sd->gspca_dev.curr_mode][fr][1]);
3255 clock = fr_tb[sd->gspca_dev.curr_mode][fr][2];
3256 if (sd->sensor == SEN_OV7660)
3257 clock |= 0x80; /* enable double clock */
3258 ov518_i2c_w(sd, OV7670_R11_CLKRC, clock);
3261 static void setautogain(struct gspca_dev *gspca_dev)
3263 struct sd *sd = (struct sd *) gspca_dev;
3265 i2c_w_mask(sd, 0x13, sd->ctrls[AUTOGAIN].val ? 0x05 : 0x00, 0x05);
3268 /* this function is called at probe time */
3269 static int sd_config(struct gspca_dev *gspca_dev,
3270 const struct usb_device_id *id)
3272 struct sd *sd = (struct sd *) gspca_dev;
3273 struct cam *cam = &gspca_dev->cam;
3275 sd->bridge = id->driver_info & BRIDGE_MASK;
3276 sd->invert_led = (id->driver_info & BRIDGE_INVERT_LED) != 0;
3278 switch (sd->bridge) {
3280 case BRIDGE_OV511PLUS:
3281 cam->cam_mode = ov511_vga_mode;
3282 cam->nmodes = ARRAY_SIZE(ov511_vga_mode);
3285 case BRIDGE_OV518PLUS:
3286 cam->cam_mode = ov518_vga_mode;
3287 cam->nmodes = ARRAY_SIZE(ov518_vga_mode);
3290 cam->cam_mode = ov519_vga_mode;
3291 cam->nmodes = ARRAY_SIZE(ov519_vga_mode);
3292 sd->invert_led = !sd->invert_led;
3295 cam->cam_mode = ov519_vga_mode;
3296 cam->nmodes = ARRAY_SIZE(ov519_vga_mode);
3297 cam->bulk_size = OVFX2_BULK_SIZE;
3298 cam->bulk_nurbs = MAX_NURBS;
3301 case BRIDGE_W9968CF:
3302 cam->cam_mode = w9968cf_vga_mode;
3303 cam->nmodes = ARRAY_SIZE(w9968cf_vga_mode);
3304 cam->reverse_alts = 1;
3308 gspca_dev->cam.ctrls = sd->ctrls;
3309 sd->quality = QUALITY_DEF;
3314 /* this function is called at probe and resume time */
3315 static int sd_init(struct gspca_dev *gspca_dev)
3317 struct sd *sd = (struct sd *) gspca_dev;
3318 struct cam *cam = &gspca_dev->cam;
3320 switch (sd->bridge) {
3322 case BRIDGE_OV511PLUS:
3323 ov511_configure(gspca_dev);
3326 case BRIDGE_OV518PLUS:
3327 ov518_configure(gspca_dev);
3330 ov519_configure(sd);
3333 ovfx2_configure(sd);
3335 case BRIDGE_W9968CF:
3336 w9968cf_configure(sd);
3340 /* The OV519 must be more aggressive about sensor detection since
3341 * I2C write will never fail if the sensor is not present. We have
3342 * to try to initialize the sensor to detect its presence */
3346 if (init_ov_sensor(sd, OV7xx0_SID) >= 0) {
3347 ov7xx0_configure(sd);
3350 } else if (init_ov_sensor(sd, OV6xx0_SID) >= 0) {
3351 ov6xx0_configure(sd);
3354 } else if (init_ov_sensor(sd, OV8xx0_SID) >= 0) {
3355 ov8xx0_configure(sd);
3357 /* Test for 3xxx / 2xxx */
3358 } else if (init_ov_sensor(sd, OV_HIRES_SID) >= 0) {
3359 ov_hires_configure(sd);
3361 err("Can't determine sensor slave IDs");
3368 ov51x_led_control(sd, 0); /* turn LED off */
3370 switch (sd->bridge) {
3372 case BRIDGE_OV511PLUS:
3374 cam->cam_mode = ov511_sif_mode;
3375 cam->nmodes = ARRAY_SIZE(ov511_sif_mode);
3379 case BRIDGE_OV518PLUS:
3381 cam->cam_mode = ov518_sif_mode;
3382 cam->nmodes = ARRAY_SIZE(ov518_sif_mode);
3387 cam->cam_mode = ov519_sif_mode;
3388 cam->nmodes = ARRAY_SIZE(ov519_sif_mode);
3392 switch (sd->sensor) {
3395 cam->cam_mode = ovfx2_ov2610_mode;
3396 cam->nmodes = ARRAY_SIZE(ovfx2_ov2610_mode);
3399 cam->cam_mode = ovfx2_ov3610_mode;
3400 cam->nmodes = ARRAY_SIZE(ovfx2_ov3610_mode);
3404 cam->cam_mode = ov519_sif_mode;
3405 cam->nmodes = ARRAY_SIZE(ov519_sif_mode);
3410 case BRIDGE_W9968CF:
3412 cam->nmodes = ARRAY_SIZE(w9968cf_vga_mode) - 1;
3414 /* w9968cf needs initialisation once the sensor is known */
3419 gspca_dev->ctrl_dis = ctrl_dis[sd->sensor];
3421 /* initialize the sensor */
3422 switch (sd->sensor) {
3424 write_i2c_regvals(sd, norm_2610, ARRAY_SIZE(norm_2610));
3426 /* Enable autogain, autoexpo, awb, bandfilter */
3427 i2c_w_mask(sd, 0x13, 0x27, 0x27);
3430 write_i2c_regvals(sd, norm_2610ae, ARRAY_SIZE(norm_2610ae));
3432 /* enable autoexpo */
3433 i2c_w_mask(sd, 0x13, 0x05, 0x05);
3436 write_i2c_regvals(sd, norm_3620b, ARRAY_SIZE(norm_3620b));
3438 /* Enable autogain, autoexpo, awb, bandfilter */
3439 i2c_w_mask(sd, 0x13, 0x27, 0x27);
3442 write_i2c_regvals(sd, norm_6x20, ARRAY_SIZE(norm_6x20));
3446 sd->ctrls[CONTRAST].def = 200;
3447 /* The default is too low for the ov6630 */
3448 write_i2c_regvals(sd, norm_6x30, ARRAY_SIZE(norm_6x30));
3451 /* case SEN_OV7610: */
3452 /* case SEN_OV76BE: */
3453 write_i2c_regvals(sd, norm_7610, ARRAY_SIZE(norm_7610));
3454 i2c_w_mask(sd, 0x0e, 0x00, 0x40);
3458 write_i2c_regvals(sd, norm_7620, ARRAY_SIZE(norm_7620));
3462 write_i2c_regvals(sd, norm_7640, ARRAY_SIZE(norm_7640));
3465 i2c_w(sd, OV7670_R12_COM7, OV7670_COM7_RESET);
3467 reg_w(sd, OV519_R57_SNAPSHOT, 0x23);
3468 write_regvals(sd, init_519_ov7660,
3469 ARRAY_SIZE(init_519_ov7660));
3470 write_i2c_regvals(sd, norm_7660, ARRAY_SIZE(norm_7660));
3471 sd->gspca_dev.curr_mode = 1; /* 640x480 */
3472 sd->frame_rate = 15;
3475 sd->ctrls[COLORS].max = 4; /* 0..4 */
3476 sd->ctrls[COLORS].val =
3477 sd->ctrls[COLORS].def = 2;
3478 setcolors(gspca_dev);
3479 sd->ctrls[CONTRAST].max = 6; /* 0..6 */
3480 sd->ctrls[CONTRAST].val =
3481 sd->ctrls[CONTRAST].def = 3;
3482 setcontrast(gspca_dev);
3483 sd->ctrls[BRIGHTNESS].max = 6; /* 0..6 */
3484 sd->ctrls[BRIGHTNESS].val =
3485 sd->ctrls[BRIGHTNESS].def = 3;
3486 setbrightness(gspca_dev);
3487 sd_reset_snapshot(gspca_dev);
3489 ov51x_stop(sd); /* not in win traces */
3490 ov51x_led_control(sd, 0);
3493 sd->ctrls[FREQ].max = 3; /* auto */
3494 sd->ctrls[FREQ].def = 3;
3495 write_i2c_regvals(sd, norm_7670, ARRAY_SIZE(norm_7670));
3498 write_i2c_regvals(sd, norm_8610, ARRAY_SIZE(norm_8610));
3501 return gspca_dev->usb_err;
3503 PDEBUG(D_ERR, "OV519 Config failed");
3507 /* function called at start time before URB creation */
3508 static int sd_isoc_init(struct gspca_dev *gspca_dev)
3510 struct sd *sd = (struct sd *) gspca_dev;
3512 switch (sd->bridge) {
3514 if (gspca_dev->width == 1600)
3515 gspca_dev->cam.bulk_size = OVFX2_BULK_SIZE;
3517 gspca_dev->cam.bulk_size = 7 * 4096;
3523 /* Set up the OV511/OV511+ with the given image parameters.
3525 * Do not put any sensor-specific code in here (including I2C I/O functions)
3527 static void ov511_mode_init_regs(struct sd *sd)
3529 int hsegs, vsegs, packet_size, fps, needed;
3531 struct usb_host_interface *alt;
3532 struct usb_interface *intf;
3534 intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
3535 alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
3537 err("Couldn't get altsetting");
3538 sd->gspca_dev.usb_err = -EIO;
3542 packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
3543 reg_w(sd, R51x_FIFO_PSIZE, packet_size >> 5);
3545 reg_w(sd, R511_CAM_UV_EN, 0x01);
3546 reg_w(sd, R511_SNAP_UV_EN, 0x01);
3547 reg_w(sd, R511_SNAP_OPTS, 0x03);
3549 /* Here I'm assuming that snapshot size == image size.
3550 * I hope that's always true. --claudio
3552 hsegs = (sd->gspca_dev.width >> 3) - 1;
3553 vsegs = (sd->gspca_dev.height >> 3) - 1;
3555 reg_w(sd, R511_CAM_PXCNT, hsegs);
3556 reg_w(sd, R511_CAM_LNCNT, vsegs);
3557 reg_w(sd, R511_CAM_PXDIV, 0x00);
3558 reg_w(sd, R511_CAM_LNDIV, 0x00);
3560 /* YUV420, low pass filter on */
3561 reg_w(sd, R511_CAM_OPTS, 0x03);
3563 /* Snapshot additions */
3564 reg_w(sd, R511_SNAP_PXCNT, hsegs);
3565 reg_w(sd, R511_SNAP_LNCNT, vsegs);
3566 reg_w(sd, R511_SNAP_PXDIV, 0x00);
3567 reg_w(sd, R511_SNAP_LNDIV, 0x00);
3569 /******** Set the framerate ********/
3571 sd->frame_rate = frame_rate;
3573 switch (sd->sensor) {
3575 /* No framerate control, doesn't like higher rates yet */
3579 /* Note once the FIXME's in mode_init_ov_sensor_regs() are fixed
3580 for more sensors we need to do this for them too */
3586 if (sd->gspca_dev.width == 320)
3592 switch (sd->frame_rate) {
3595 /* Not enough bandwidth to do 640x480 @ 30 fps */
3596 if (sd->gspca_dev.width != 640) {
3600 /* Fall through for 640x480 case */
3614 sd->clockdiv = (sd->clockdiv + 1) * 2 - 1;
3615 /* Higher then 10 does not work */
3616 if (sd->clockdiv > 10)
3622 /* No framerate control ?? */
3627 /* Check if we have enough bandwidth to disable compression */
3628 fps = (interlaced ? 60 : 30) / (sd->clockdiv + 1) + 1;
3629 needed = fps * sd->gspca_dev.width * sd->gspca_dev.height * 3 / 2;
3630 /* 1400 is a conservative estimate of the max nr of isoc packets/sec */
3631 if (needed > 1400 * packet_size) {
3632 /* Enable Y and UV quantization and compression */
3633 reg_w(sd, R511_COMP_EN, 0x07);
3634 reg_w(sd, R511_COMP_LUT_EN, 0x03);
3636 reg_w(sd, R511_COMP_EN, 0x06);
3637 reg_w(sd, R511_COMP_LUT_EN, 0x00);
3640 reg_w(sd, R51x_SYS_RESET, OV511_RESET_OMNICE);
3641 reg_w(sd, R51x_SYS_RESET, 0);
3644 /* Sets up the OV518/OV518+ with the given image parameters
3646 * OV518 needs a completely different approach, until we can figure out what
3647 * the individual registers do. Also, only 15 FPS is supported now.
3649 * Do not put any sensor-specific code in here (including I2C I/O functions)
3651 static void ov518_mode_init_regs(struct sd *sd)
3653 int hsegs, vsegs, packet_size;
3654 struct usb_host_interface *alt;
3655 struct usb_interface *intf;
3657 intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
3658 alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
3660 err("Couldn't get altsetting");
3661 sd->gspca_dev.usb_err = -EIO;
3665 packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
3666 ov518_reg_w32(sd, R51x_FIFO_PSIZE, packet_size & ~7, 2);
3668 /******** Set the mode ********/
3678 if (sd->bridge == BRIDGE_OV518) {
3679 /* Set 8-bit (YVYU) input format */
3680 reg_w_mask(sd, 0x20, 0x08, 0x08);
3682 /* Set 12-bit (4:2:0) output format */
3683 reg_w_mask(sd, 0x28, 0x80, 0xf0);
3684 reg_w_mask(sd, 0x38, 0x80, 0xf0);
3686 reg_w(sd, 0x28, 0x80);
3687 reg_w(sd, 0x38, 0x80);
3690 hsegs = sd->gspca_dev.width / 16;
3691 vsegs = sd->gspca_dev.height / 4;
3693 reg_w(sd, 0x29, hsegs);
3694 reg_w(sd, 0x2a, vsegs);
3696 reg_w(sd, 0x39, hsegs);
3697 reg_w(sd, 0x3a, vsegs);
3699 /* Windows driver does this here; who knows why */
3700 reg_w(sd, 0x2f, 0x80);
3702 /******** Set the framerate ********/
3705 /* Mode independent, but framerate dependent, regs */
3706 /* 0x51: Clock divider; Only works on some cams which use 2 crystals */
3707 reg_w(sd, 0x51, 0x04);
3708 reg_w(sd, 0x22, 0x18);
3709 reg_w(sd, 0x23, 0xff);
3711 if (sd->bridge == BRIDGE_OV518PLUS) {
3712 switch (sd->sensor) {
3714 if (sd->gspca_dev.width == 320) {
3715 reg_w(sd, 0x20, 0x00);
3716 reg_w(sd, 0x21, 0x19);
3718 reg_w(sd, 0x20, 0x60);
3719 reg_w(sd, 0x21, 0x1f);
3723 reg_w(sd, 0x20, 0x00);
3724 reg_w(sd, 0x21, 0x19);
3727 reg_w(sd, 0x21, 0x19);
3730 reg_w(sd, 0x71, 0x17); /* Compression-related? */
3732 /* FIXME: Sensor-specific */
3733 /* Bit 5 is what matters here. Of course, it is "reserved" */
3734 i2c_w(sd, 0x54, 0x23);
3736 reg_w(sd, 0x2f, 0x80);
3738 if (sd->bridge == BRIDGE_OV518PLUS) {
3739 reg_w(sd, 0x24, 0x94);
3740 reg_w(sd, 0x25, 0x90);
3741 ov518_reg_w32(sd, 0xc4, 400, 2); /* 190h */
3742 ov518_reg_w32(sd, 0xc6, 540, 2); /* 21ch */
3743 ov518_reg_w32(sd, 0xc7, 540, 2); /* 21ch */
3744 ov518_reg_w32(sd, 0xc8, 108, 2); /* 6ch */
3745 ov518_reg_w32(sd, 0xca, 131098, 3); /* 2001ah */
3746 ov518_reg_w32(sd, 0xcb, 532, 2); /* 214h */
3747 ov518_reg_w32(sd, 0xcc, 2400, 2); /* 960h */
3748 ov518_reg_w32(sd, 0xcd, 32, 2); /* 20h */
3749 ov518_reg_w32(sd, 0xce, 608, 2); /* 260h */
3751 reg_w(sd, 0x24, 0x9f);
3752 reg_w(sd, 0x25, 0x90);
3753 ov518_reg_w32(sd, 0xc4, 400, 2); /* 190h */
3754 ov518_reg_w32(sd, 0xc6, 381, 2); /* 17dh */
3755 ov518_reg_w32(sd, 0xc7, 381, 2); /* 17dh */
3756 ov518_reg_w32(sd, 0xc8, 128, 2); /* 80h */
3757 ov518_reg_w32(sd, 0xca, 183331, 3); /* 2cc23h */
3758 ov518_reg_w32(sd, 0xcb, 746, 2); /* 2eah */
3759 ov518_reg_w32(sd, 0xcc, 1750, 2); /* 6d6h */
3760 ov518_reg_w32(sd, 0xcd, 45, 2); /* 2dh */
3761 ov518_reg_w32(sd, 0xce, 851, 2); /* 353h */
3764 reg_w(sd, 0x2f, 0x80);
3767 /* Sets up the OV519 with the given image parameters
3769 * OV519 needs a completely different approach, until we can figure out what
3770 * the individual registers do.
3772 * Do not put any sensor-specific code in here (including I2C I/O functions)
3774 static void ov519_mode_init_regs(struct sd *sd)
3776 static const struct ov_regvals mode_init_519_ov7670[] = {
3777 { 0x5d, 0x03 }, /* Turn off suspend mode */
3778 { 0x53, 0x9f }, /* was 9b in 1.65-1.08 */
3779 { OV519_R54_EN_CLK1, 0x0f }, /* bit2 (jpeg enable) */
3780 { 0xa2, 0x20 }, /* a2-a5 are undocumented */
3784 { 0x37, 0x00 }, /* SetUsbInit */
3785 { 0x55, 0x02 }, /* 4.096 Mhz audio clock */
3786 /* Enable both fields, YUV Input, disable defect comp (why?) */
3790 { 0x17, 0x50 }, /* undocumented */
3791 { 0x37, 0x00 }, /* undocumented */
3792 { 0x40, 0xff }, /* I2C timeout counter */
3793 { 0x46, 0x00 }, /* I2C clock prescaler */
3794 { 0x59, 0x04 }, /* new from windrv 090403 */
3795 { 0xff, 0x00 }, /* undocumented */
3796 /* windows reads 0x55 at this point, why? */
3799 static const struct ov_regvals mode_init_519[] = {
3800 { 0x5d, 0x03 }, /* Turn off suspend mode */
3801 { 0x53, 0x9f }, /* was 9b in 1.65-1.08 */
3802 { OV519_R54_EN_CLK1, 0x0f }, /* bit2 (jpeg enable) */
3803 { 0xa2, 0x20 }, /* a2-a5 are undocumented */
3807 { 0x37, 0x00 }, /* SetUsbInit */
3808 { 0x55, 0x02 }, /* 4.096 Mhz audio clock */
3809 /* Enable both fields, YUV Input, disable defect comp (why?) */
3811 { 0x17, 0x50 }, /* undocumented */
3812 { 0x37, 0x00 }, /* undocumented */
3813 { 0x40, 0xff }, /* I2C timeout counter */
3814 { 0x46, 0x00 }, /* I2C clock prescaler */
3815 { 0x59, 0x04 }, /* new from windrv 090403 */
3816 { 0xff, 0x00 }, /* undocumented */
3817 /* windows reads 0x55 at this point, why? */
3820 /******** Set the mode ********/
3821 switch (sd->sensor) {
3823 write_regvals(sd, mode_init_519, ARRAY_SIZE(mode_init_519));
3824 if (sd->sensor == SEN_OV7640 ||
3825 sd->sensor == SEN_OV7648) {
3826 /* Select 8-bit input mode */
3827 reg_w_mask(sd, OV519_R20_DFR, 0x10, 0x10);
3831 return; /* done by ov519_set_mode/fr() */
3833 write_regvals(sd, mode_init_519_ov7670,
3834 ARRAY_SIZE(mode_init_519_ov7670));
3838 reg_w(sd, OV519_R10_H_SIZE, sd->gspca_dev.width >> 4);
3839 reg_w(sd, OV519_R11_V_SIZE, sd->gspca_dev.height >> 3);
3840 if (sd->sensor == SEN_OV7670 &&
3841 sd->gspca_dev.cam.cam_mode[sd->gspca_dev.curr_mode].priv)
3842 reg_w(sd, OV519_R12_X_OFFSETL, 0x04);
3843 else if (sd->sensor == SEN_OV7648 &&
3844 sd->gspca_dev.cam.cam_mode[sd->gspca_dev.curr_mode].priv)
3845 reg_w(sd, OV519_R12_X_OFFSETL, 0x01);
3847 reg_w(sd, OV519_R12_X_OFFSETL, 0x00);
3848 reg_w(sd, OV519_R13_X_OFFSETH, 0x00);
3849 reg_w(sd, OV519_R14_Y_OFFSETL, 0x00);
3850 reg_w(sd, OV519_R15_Y_OFFSETH, 0x00);
3851 reg_w(sd, OV519_R16_DIVIDER, 0x00);
3852 reg_w(sd, OV519_R25_FORMAT, 0x03); /* YUV422 */
3853 reg_w(sd, 0x26, 0x00); /* Undocumented */
3855 /******** Set the framerate ********/
3857 sd->frame_rate = frame_rate;
3859 /* FIXME: These are only valid at the max resolution. */
3861 switch (sd->sensor) {
3864 switch (sd->frame_rate) {
3867 reg_w(sd, 0xa4, 0x0c);
3868 reg_w(sd, 0x23, 0xff);
3871 reg_w(sd, 0xa4, 0x0c);
3872 reg_w(sd, 0x23, 0x1f);
3875 reg_w(sd, 0xa4, 0x0c);
3876 reg_w(sd, 0x23, 0x1b);
3879 reg_w(sd, 0xa4, 0x04);
3880 reg_w(sd, 0x23, 0xff);
3884 reg_w(sd, 0xa4, 0x04);
3885 reg_w(sd, 0x23, 0x1f);
3889 reg_w(sd, 0xa4, 0x04);
3890 reg_w(sd, 0x23, 0x1b);
3896 switch (sd->frame_rate) {
3897 default: /* 15 fps */
3899 reg_w(sd, 0xa4, 0x06);
3900 reg_w(sd, 0x23, 0xff);
3903 reg_w(sd, 0xa4, 0x06);
3904 reg_w(sd, 0x23, 0x1f);
3907 reg_w(sd, 0xa4, 0x06);
3908 reg_w(sd, 0x23, 0x1b);
3912 case SEN_OV7670: /* guesses, based on 7640 */
3913 PDEBUG(D_STREAM, "Setting framerate to %d fps",
3914 (sd->frame_rate == 0) ? 15 : sd->frame_rate);
3915 reg_w(sd, 0xa4, 0x10);
3916 switch (sd->frame_rate) {
3918 reg_w(sd, 0x23, 0xff);
3921 reg_w(sd, 0x23, 0x1b);
3925 reg_w(sd, 0x23, 0xff);
3933 static void mode_init_ov_sensor_regs(struct sd *sd)
3935 struct gspca_dev *gspca_dev;
3936 int qvga, xstart, xend, ystart, yend;
3939 gspca_dev = &sd->gspca_dev;
3940 qvga = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv & 1;
3942 /******** Mode (VGA/QVGA) and sensor specific regs ********/
3943 switch (sd->sensor) {
3945 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
3946 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
3947 i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a);
3948 i2c_w(sd, 0x25, qvga ? 0x30 : 0x60);
3949 i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40);
3950 i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0);
3951 i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20);
3953 case SEN_OV2610AE: {
3957 * 10fps / 5 fps for 1600x1200
3958 * 40fps / 20fps for 800x600
3962 if (sd->frame_rate < 25)
3965 if (sd->frame_rate < 10)
3969 i2c_w(sd, 0x12, qvga ? 0x60 : 0x20);
3974 xstart = (1040 - gspca_dev->width) / 2 + (0x1f << 4);
3975 ystart = (776 - gspca_dev->height) / 2;
3977 xstart = (2076 - gspca_dev->width) / 2 + (0x10 << 4);
3978 ystart = (1544 - gspca_dev->height) / 2;
3980 xend = xstart + gspca_dev->width;
3981 yend = ystart + gspca_dev->height;
3982 /* Writing to the COMH register resets the other windowing regs
3983 to their default values, so we must do this first. */
3984 i2c_w_mask(sd, 0x12, qvga ? 0x40 : 0x00, 0xf0);
3985 i2c_w_mask(sd, 0x32,
3986 (((xend >> 1) & 7) << 3) | ((xstart >> 1) & 7),
3988 i2c_w_mask(sd, 0x03,
3989 (((yend >> 1) & 3) << 2) | ((ystart >> 1) & 3),
3991 i2c_w(sd, 0x17, xstart >> 4);
3992 i2c_w(sd, 0x18, xend >> 4);
3993 i2c_w(sd, 0x19, ystart >> 3);
3994 i2c_w(sd, 0x1a, yend >> 3);
3997 /* For OV8610 qvga means qsvga */
3998 i2c_w_mask(sd, OV7610_REG_COM_C, qvga ? (1 << 5) : 0, 1 << 5);
3999 i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
4000 i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
4001 i2c_w_mask(sd, 0x2d, 0x00, 0x40); /* from windrv 090403 */
4002 i2c_w_mask(sd, 0x28, 0x20, 0x20); /* progressive mode on */
4005 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
4006 i2c_w(sd, 0x35, qvga ? 0x1e : 0x9e);
4007 i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
4008 i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
4013 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
4014 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
4015 i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a);
4016 i2c_w(sd, 0x25, qvga ? 0x30 : 0x60);
4017 i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40);
4018 i2c_w_mask(sd, 0x67, qvga ? 0xb0 : 0x90, 0xf0);
4019 i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20);
4020 i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
4021 i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
4022 if (sd->sensor == SEN_OV76BE)
4023 i2c_w(sd, 0x35, qvga ? 0x1e : 0x9e);
4027 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
4028 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
4029 /* Setting this undocumented bit in qvga mode removes a very
4030 annoying vertical shaking of the image */
4031 i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40);
4033 i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0);
4034 /* Allow higher automatic gain (to allow higher framerates) */
4035 i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20);
4036 i2c_w_mask(sd, 0x12, 0x04, 0x04); /* AWB: 1 */
4039 /* set COM7_FMT_VGA or COM7_FMT_QVGA
4040 * do we need to set anything else?
4041 * HSTART etc are set in set_ov_sensor_window itself */
4042 i2c_w_mask(sd, OV7670_R12_COM7,
4043 qvga ? OV7670_COM7_FMT_QVGA : OV7670_COM7_FMT_VGA,
4044 OV7670_COM7_FMT_MASK);
4045 i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
4046 i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_AWB,
4048 if (qvga) { /* QVGA from ov7670.c by
4049 * Jonathan Corbet */
4060 /* OV7670 hardware window registers are split across
4061 * multiple locations */
4062 i2c_w(sd, OV7670_R17_HSTART, xstart >> 3);
4063 i2c_w(sd, OV7670_R18_HSTOP, xend >> 3);
4064 v = i2c_r(sd, OV7670_R32_HREF);
4065 v = (v & 0xc0) | ((xend & 0x7) << 3) | (xstart & 0x07);
4066 msleep(10); /* need to sleep between read and write to
4068 i2c_w(sd, OV7670_R32_HREF, v);
4070 i2c_w(sd, OV7670_R19_VSTART, ystart >> 2);
4071 i2c_w(sd, OV7670_R1A_VSTOP, yend >> 2);
4072 v = i2c_r(sd, OV7670_R03_VREF);
4073 v = (v & 0xc0) | ((yend & 0x3) << 2) | (ystart & 0x03);
4074 msleep(10); /* need to sleep between read and write to
4076 i2c_w(sd, OV7670_R03_VREF, v);
4079 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
4080 i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
4081 i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
4085 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
4086 i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
4092 /******** Clock programming ********/
4093 i2c_w(sd, 0x11, sd->clockdiv);
4096 /* this function works for bridge ov519 and sensors ov7660 and ov7670 only */
4097 static void sethvflip(struct gspca_dev *gspca_dev)
4099 struct sd *sd = (struct sd *) gspca_dev;
4101 if (sd->gspca_dev.streaming)
4102 reg_w(sd, OV519_R51_RESET1, 0x0f); /* block stream */
4103 i2c_w_mask(sd, OV7670_R1E_MVFP,
4104 OV7670_MVFP_MIRROR * sd->ctrls[HFLIP].val
4105 | OV7670_MVFP_VFLIP * sd->ctrls[VFLIP].val,
4106 OV7670_MVFP_MIRROR | OV7670_MVFP_VFLIP);
4107 if (sd->gspca_dev.streaming)
4108 reg_w(sd, OV519_R51_RESET1, 0x00); /* restart stream */
4111 static void set_ov_sensor_window(struct sd *sd)
4113 struct gspca_dev *gspca_dev;
4115 int hwsbase, hwebase, vwsbase, vwebase, hwscale, vwscale;
4117 /* mode setup is fully handled in mode_init_ov_sensor_regs for these */
4118 switch (sd->sensor) {
4123 mode_init_ov_sensor_regs(sd);
4131 gspca_dev = &sd->gspca_dev;
4132 qvga = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv & 1;
4133 crop = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv & 2;
4135 /* The different sensor ICs handle setting up of window differently.
4136 * IF YOU SET IT WRONG, YOU WILL GET ALL ZERO ISOC DATA FROM OV51x!! */
4137 switch (sd->sensor) {
4148 vwsbase = vwebase = 0x05;
4157 if (sd->sensor == SEN_OV66308AF && qvga)
4158 /* HDG: this fixes U and V getting swapped */
4169 hwsbase = 0x2f; /* From 7620.SET (spec is wrong) */
4171 vwsbase = vwebase = 0x05;
4177 vwsbase = vwebase = 0x03;
4183 switch (sd->sensor) {
4187 if (qvga) { /* QCIF */
4192 vwscale = 1; /* The datasheet says 0;
4197 if (qvga) { /* QSVGA */
4205 default: /* SEN_OV7xx0 */
4206 if (qvga) { /* QVGA */
4215 mode_init_ov_sensor_regs(sd);
4217 i2c_w(sd, 0x17, hwsbase);
4218 i2c_w(sd, 0x18, hwebase + (sd->sensor_width >> hwscale));
4219 i2c_w(sd, 0x19, vwsbase);
4220 i2c_w(sd, 0x1a, vwebase + (sd->sensor_height >> vwscale));
4223 /* -- start the camera -- */
4224 static int sd_start(struct gspca_dev *gspca_dev)
4226 struct sd *sd = (struct sd *) gspca_dev;
4228 /* Default for most bridges, allow bridge_mode_init_regs to override */
4229 sd->sensor_width = sd->gspca_dev.width;
4230 sd->sensor_height = sd->gspca_dev.height;
4232 switch (sd->bridge) {
4234 case BRIDGE_OV511PLUS:
4235 ov511_mode_init_regs(sd);
4238 case BRIDGE_OV518PLUS:
4239 ov518_mode_init_regs(sd);
4242 ov519_mode_init_regs(sd);
4244 /* case BRIDGE_OVFX2: nothing to do */
4245 case BRIDGE_W9968CF:
4246 w9968cf_mode_init_regs(sd);
4250 set_ov_sensor_window(sd);
4252 if (!(sd->gspca_dev.ctrl_dis & (1 << CONTRAST)))
4253 setcontrast(gspca_dev);
4254 if (!(sd->gspca_dev.ctrl_dis & (1 << BRIGHTNESS)))
4255 setbrightness(gspca_dev);
4256 if (!(sd->gspca_dev.ctrl_dis & (1 << EXPOSURE)))
4257 setexposure(gspca_dev);
4258 if (!(sd->gspca_dev.ctrl_dis & (1 << COLORS)))
4259 setcolors(gspca_dev);
4260 if (!(sd->gspca_dev.ctrl_dis & ((1 << HFLIP) | (1 << VFLIP))))
4261 sethvflip(gspca_dev);
4262 if (!(sd->gspca_dev.ctrl_dis & (1 << AUTOBRIGHT)))
4263 setautobright(gspca_dev);
4264 if (!(sd->gspca_dev.ctrl_dis & (1 << AUTOGAIN)))
4265 setautogain(gspca_dev);
4266 if (!(sd->gspca_dev.ctrl_dis & (1 << FREQ)))
4269 /* Force clear snapshot state in case the snapshot button was
4270 pressed while we weren't streaming */
4271 sd->snapshot_needs_reset = 1;
4272 sd_reset_snapshot(gspca_dev);
4274 sd->first_frame = 3;
4277 ov51x_led_control(sd, 1);
4278 return gspca_dev->usb_err;
4281 static void sd_stopN(struct gspca_dev *gspca_dev)
4283 struct sd *sd = (struct sd *) gspca_dev;
4286 ov51x_led_control(sd, 0);
4289 static void sd_stop0(struct gspca_dev *gspca_dev)
4291 struct sd *sd = (struct sd *) gspca_dev;
4293 if (!sd->gspca_dev.present)
4295 if (sd->bridge == BRIDGE_W9968CF)
4298 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
4299 /* If the last button state is pressed, release it now! */
4300 if (sd->snapshot_pressed) {
4301 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
4302 input_sync(gspca_dev->input_dev);
4303 sd->snapshot_pressed = 0;
4306 if (sd->bridge == BRIDGE_OV519)
4307 reg_w(sd, OV519_R57_SNAPSHOT, 0x23);
4310 static void ov51x_handle_button(struct gspca_dev *gspca_dev, u8 state)
4312 struct sd *sd = (struct sd *) gspca_dev;
4314 if (sd->snapshot_pressed != state) {
4315 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
4316 input_report_key(gspca_dev->input_dev, KEY_CAMERA, state);
4317 input_sync(gspca_dev->input_dev);
4320 sd->snapshot_needs_reset = 1;
4322 sd->snapshot_pressed = state;
4324 /* On the ov511 / ov519 we need to reset the button state
4325 multiple times, as resetting does not work as long as the
4326 button stays pressed */
4327 switch (sd->bridge) {
4329 case BRIDGE_OV511PLUS:
4332 sd->snapshot_needs_reset = 1;
4338 static void ov511_pkt_scan(struct gspca_dev *gspca_dev,
4339 u8 *in, /* isoc packet */
4340 int len) /* iso packet length */
4342 struct sd *sd = (struct sd *) gspca_dev;
4344 /* SOF/EOF packets have 1st to 8th bytes zeroed and the 9th
4345 * byte non-zero. The EOF packet has image width/height in the
4346 * 10th and 11th bytes. The 9th byte is given as follows:
4349 * 6: compression enabled
4350 * 5: 422/420/400 modes
4351 * 4: 422/420/400 modes
4353 * 2: snapshot button on
4357 if (!(in[0] | in[1] | in[2] | in[3] | in[4] | in[5] | in[6] | in[7]) &&
4359 ov51x_handle_button(gspca_dev, (in[8] >> 2) & 1);
4362 if ((in[9] + 1) * 8 != gspca_dev->width ||
4363 (in[10] + 1) * 8 != gspca_dev->height) {
4364 PDEBUG(D_ERR, "Invalid frame size, got: %dx%d,"
4365 " requested: %dx%d\n",
4366 (in[9] + 1) * 8, (in[10] + 1) * 8,
4367 gspca_dev->width, gspca_dev->height);
4368 gspca_dev->last_packet_type = DISCARD_PACKET;
4371 /* Add 11 byte footer to frame, might be useful */
4372 gspca_frame_add(gspca_dev, LAST_PACKET, in, 11);
4376 gspca_frame_add(gspca_dev, FIRST_PACKET, in, 0);
4381 /* Ignore the packet number */
4384 /* intermediate packet */
4385 gspca_frame_add(gspca_dev, INTER_PACKET, in, len);
4388 static void ov518_pkt_scan(struct gspca_dev *gspca_dev,
4389 u8 *data, /* isoc packet */
4390 int len) /* iso packet length */
4392 struct sd *sd = (struct sd *) gspca_dev;
4394 /* A false positive here is likely, until OVT gives me
4395 * the definitive SOF/EOF format */
4396 if ((!(data[0] | data[1] | data[2] | data[3] | data[5])) && data[6]) {
4397 ov51x_handle_button(gspca_dev, (data[6] >> 1) & 1);
4398 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
4399 gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
4403 if (gspca_dev->last_packet_type == DISCARD_PACKET)
4406 /* Does this device use packet numbers ? */
4409 if (sd->packet_nr == data[len])
4411 /* The last few packets of the frame (which are all 0's
4412 except that they may contain part of the footer), are
4414 else if (sd->packet_nr == 0 || data[len]) {
4415 PDEBUG(D_ERR, "Invalid packet nr: %d (expect: %d)",
4416 (int)data[len], (int)sd->packet_nr);
4417 gspca_dev->last_packet_type = DISCARD_PACKET;
4422 /* intermediate packet */
4423 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
4426 static void ov519_pkt_scan(struct gspca_dev *gspca_dev,
4427 u8 *data, /* isoc packet */
4428 int len) /* iso packet length */
4430 /* Header of ov519 is 16 bytes:
4431 * Byte Value Description
4435 * 3 0xXX 0x50 = SOF, 0x51 = EOF
4436 * 9 0xXX 0x01 initial frame without data,
4437 * 0x00 standard frame with image
4438 * 14 Lo in EOF: length of image data / 8
4442 if (data[0] == 0xff && data[1] == 0xff && data[2] == 0xff) {
4444 case 0x50: /* start of frame */
4445 /* Don't check the button state here, as the state
4446 usually (always ?) changes at EOF and checking it
4447 here leads to unnecessary snapshot state resets. */
4452 if (data[0] == 0xff || data[1] == 0xd8)
4453 gspca_frame_add(gspca_dev, FIRST_PACKET,
4456 gspca_dev->last_packet_type = DISCARD_PACKET;
4458 case 0x51: /* end of frame */
4459 ov51x_handle_button(gspca_dev, data[11] & 1);
4461 gspca_dev->last_packet_type = DISCARD_PACKET;
4462 gspca_frame_add(gspca_dev, LAST_PACKET,
4468 /* intermediate packet */
4469 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
4472 static void ovfx2_pkt_scan(struct gspca_dev *gspca_dev,
4473 u8 *data, /* isoc packet */
4474 int len) /* iso packet length */
4476 struct sd *sd = (struct sd *) gspca_dev;
4478 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
4480 /* A short read signals EOF */
4481 if (len < OVFX2_BULK_SIZE) {
4482 /* If the frame is short, and it is one of the first ones
4483 the sensor and bridge are still syncing, so drop it. */
4484 if (sd->first_frame) {
4486 if (gspca_dev->image_len <
4487 sd->gspca_dev.width * sd->gspca_dev.height)
4488 gspca_dev->last_packet_type = DISCARD_PACKET;
4490 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
4491 gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
4495 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
4496 u8 *data, /* isoc packet */
4497 int len) /* iso packet length */
4499 struct sd *sd = (struct sd *) gspca_dev;
4501 switch (sd->bridge) {
4503 case BRIDGE_OV511PLUS:
4504 ov511_pkt_scan(gspca_dev, data, len);
4507 case BRIDGE_OV518PLUS:
4508 ov518_pkt_scan(gspca_dev, data, len);
4511 ov519_pkt_scan(gspca_dev, data, len);
4514 ovfx2_pkt_scan(gspca_dev, data, len);
4516 case BRIDGE_W9968CF:
4517 w9968cf_pkt_scan(gspca_dev, data, len);
4522 /* -- management routines -- */
4524 static void setbrightness(struct gspca_dev *gspca_dev)
4526 struct sd *sd = (struct sd *) gspca_dev;
4528 static const struct ov_i2c_regvals brit_7660[][7] = {
4529 {{0x0f, 0x6a}, {0x24, 0x40}, {0x25, 0x2b}, {0x26, 0x90},
4530 {0x27, 0xe0}, {0x28, 0xe0}, {0x2c, 0xe0}},
4531 {{0x0f, 0x6a}, {0x24, 0x50}, {0x25, 0x40}, {0x26, 0xa1},
4532 {0x27, 0xc0}, {0x28, 0xc0}, {0x2c, 0xc0}},
4533 {{0x0f, 0x6a}, {0x24, 0x68}, {0x25, 0x58}, {0x26, 0xc2},
4534 {0x27, 0xa0}, {0x28, 0xa0}, {0x2c, 0xa0}},
4535 {{0x0f, 0x6a}, {0x24, 0x70}, {0x25, 0x68}, {0x26, 0xd3},
4536 {0x27, 0x80}, {0x28, 0x80}, {0x2c, 0x80}},
4537 {{0x0f, 0x6a}, {0x24, 0x80}, {0x25, 0x70}, {0x26, 0xd3},
4538 {0x27, 0x20}, {0x28, 0x20}, {0x2c, 0x20}},
4539 {{0x0f, 0x6a}, {0x24, 0x88}, {0x25, 0x78}, {0x26, 0xd3},
4540 {0x27, 0x40}, {0x28, 0x40}, {0x2c, 0x40}},
4541 {{0x0f, 0x6a}, {0x24, 0x90}, {0x25, 0x80}, {0x26, 0xd4},
4542 {0x27, 0x60}, {0x28, 0x60}, {0x2c, 0x60}}
4545 val = sd->ctrls[BRIGHTNESS].val;
4546 switch (sd->sensor) {
4555 i2c_w(sd, OV7610_REG_BRT, val);
4559 /* 7620 doesn't like manual changes when in auto mode */
4560 if (!sd->ctrls[AUTOBRIGHT].val)
4561 i2c_w(sd, OV7610_REG_BRT, val);
4564 write_i2c_regvals(sd, brit_7660[val],
4565 ARRAY_SIZE(brit_7660[0]));
4569 * i2c_w_mask(sd, OV7670_R13_COM8, 0, OV7670_COM8_AEC); */
4570 i2c_w(sd, OV7670_R55_BRIGHT, ov7670_abs_to_sm(val));
4575 static void setcontrast(struct gspca_dev *gspca_dev)
4577 struct sd *sd = (struct sd *) gspca_dev;
4579 static const struct ov_i2c_regvals contrast_7660[][31] = {
4580 {{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf8}, {0x6f, 0xa0},
4581 {0x70, 0x58}, {0x71, 0x38}, {0x72, 0x30}, {0x73, 0x30},
4582 {0x74, 0x28}, {0x75, 0x28}, {0x76, 0x24}, {0x77, 0x24},
4583 {0x78, 0x22}, {0x79, 0x28}, {0x7a, 0x2a}, {0x7b, 0x34},
4584 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3d}, {0x7f, 0x65},
4585 {0x80, 0x70}, {0x81, 0x77}, {0x82, 0x7d}, {0x83, 0x83},
4586 {0x84, 0x88}, {0x85, 0x8d}, {0x86, 0x96}, {0x87, 0x9f},
4587 {0x88, 0xb0}, {0x89, 0xc4}, {0x8a, 0xd9}},
4588 {{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf8}, {0x6f, 0x94},
4589 {0x70, 0x58}, {0x71, 0x40}, {0x72, 0x30}, {0x73, 0x30},
4590 {0x74, 0x30}, {0x75, 0x30}, {0x76, 0x2c}, {0x77, 0x24},
4591 {0x78, 0x22}, {0x79, 0x28}, {0x7a, 0x2a}, {0x7b, 0x31},
4592 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3d}, {0x7f, 0x62},
4593 {0x80, 0x6d}, {0x81, 0x75}, {0x82, 0x7b}, {0x83, 0x81},
4594 {0x84, 0x87}, {0x85, 0x8d}, {0x86, 0x98}, {0x87, 0xa1},
4595 {0x88, 0xb2}, {0x89, 0xc6}, {0x8a, 0xdb}},
4596 {{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf0}, {0x6f, 0x84},
4597 {0x70, 0x58}, {0x71, 0x48}, {0x72, 0x40}, {0x73, 0x40},
4598 {0x74, 0x28}, {0x75, 0x28}, {0x76, 0x28}, {0x77, 0x24},
4599 {0x78, 0x26}, {0x79, 0x28}, {0x7a, 0x28}, {0x7b, 0x34},
4600 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3c}, {0x7f, 0x5d},
4601 {0x80, 0x68}, {0x81, 0x71}, {0x82, 0x79}, {0x83, 0x81},
4602 {0x84, 0x86}, {0x85, 0x8b}, {0x86, 0x95}, {0x87, 0x9e},
4603 {0x88, 0xb1}, {0x89, 0xc5}, {0x8a, 0xd9}},
4604 {{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf0}, {0x6f, 0x70},
4605 {0x70, 0x58}, {0x71, 0x58}, {0x72, 0x48}, {0x73, 0x48},
4606 {0x74, 0x38}, {0x75, 0x40}, {0x76, 0x34}, {0x77, 0x34},
4607 {0x78, 0x2e}, {0x79, 0x28}, {0x7a, 0x24}, {0x7b, 0x22},
4608 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3c}, {0x7f, 0x58},
4609 {0x80, 0x63}, {0x81, 0x6e}, {0x82, 0x77}, {0x83, 0x80},
4610 {0x84, 0x87}, {0x85, 0x8f}, {0x86, 0x9c}, {0x87, 0xa9},
4611 {0x88, 0xc0}, {0x89, 0xd4}, {0x8a, 0xe6}},
4612 {{0x6c, 0xa0}, {0x6d, 0xf0}, {0x6e, 0x90}, {0x6f, 0x80},
4613 {0x70, 0x70}, {0x71, 0x80}, {0x72, 0x60}, {0x73, 0x60},
4614 {0x74, 0x58}, {0x75, 0x60}, {0x76, 0x4c}, {0x77, 0x38},
4615 {0x78, 0x38}, {0x79, 0x2a}, {0x7a, 0x20}, {0x7b, 0x0e},
4616 {0x7c, 0x0a}, {0x7d, 0x14}, {0x7e, 0x26}, {0x7f, 0x46},
4617 {0x80, 0x54}, {0x81, 0x64}, {0x82, 0x70}, {0x83, 0x7c},
4618 {0x84, 0x87}, {0x85, 0x93}, {0x86, 0xa6}, {0x87, 0xb4},
4619 {0x88, 0xd0}, {0x89, 0xe5}, {0x8a, 0xf5}},
4620 {{0x6c, 0x60}, {0x6d, 0x80}, {0x6e, 0x60}, {0x6f, 0x80},
4621 {0x70, 0x80}, {0x71, 0x80}, {0x72, 0x88}, {0x73, 0x30},
4622 {0x74, 0x70}, {0x75, 0x68}, {0x76, 0x64}, {0x77, 0x50},
4623 {0x78, 0x3c}, {0x79, 0x22}, {0x7a, 0x10}, {0x7b, 0x08},
4624 {0x7c, 0x06}, {0x7d, 0x0e}, {0x7e, 0x1a}, {0x7f, 0x3a},
4625 {0x80, 0x4a}, {0x81, 0x5a}, {0x82, 0x6b}, {0x83, 0x7b},
4626 {0x84, 0x89}, {0x85, 0x96}, {0x86, 0xaf}, {0x87, 0xc3},
4627 {0x88, 0xe1}, {0x89, 0xf2}, {0x8a, 0xfa}},
4628 {{0x6c, 0x20}, {0x6d, 0x40}, {0x6e, 0x20}, {0x6f, 0x60},
4629 {0x70, 0x88}, {0x71, 0xc8}, {0x72, 0xc0}, {0x73, 0xb8},
4630 {0x74, 0xa8}, {0x75, 0xb8}, {0x76, 0x80}, {0x77, 0x5c},
4631 {0x78, 0x26}, {0x79, 0x10}, {0x7a, 0x08}, {0x7b, 0x04},
4632 {0x7c, 0x02}, {0x7d, 0x06}, {0x7e, 0x0a}, {0x7f, 0x22},
4633 {0x80, 0x33}, {0x81, 0x4c}, {0x82, 0x64}, {0x83, 0x7b},
4634 {0x84, 0x90}, {0x85, 0xa7}, {0x86, 0xc7}, {0x87, 0xde},
4635 {0x88, 0xf1}, {0x89, 0xf9}, {0x8a, 0xfd}},
4638 val = sd->ctrls[CONTRAST].val;
4639 switch (sd->sensor) {
4642 i2c_w(sd, OV7610_REG_CNT, val);
4646 i2c_w_mask(sd, OV7610_REG_CNT, val >> 4, 0x0f);
4649 static const u8 ctab[] = {
4650 0x03, 0x09, 0x0b, 0x0f, 0x53, 0x6f, 0x35, 0x7f
4653 /* Use Y gamma control instead. Bit 0 enables it. */
4654 i2c_w(sd, 0x64, ctab[val >> 5]);
4658 case SEN_OV7620AE: {
4659 static const u8 ctab[] = {
4660 0x01, 0x05, 0x09, 0x11, 0x15, 0x35, 0x37, 0x57,
4661 0x5b, 0xa5, 0xa7, 0xc7, 0xc9, 0xcf, 0xef, 0xff
4664 /* Use Y gamma control instead. Bit 0 enables it. */
4665 i2c_w(sd, 0x64, ctab[val >> 4]);
4669 write_i2c_regvals(sd, contrast_7660[val],
4670 ARRAY_SIZE(contrast_7660[0]));
4673 /* check that this isn't just the same as ov7610 */
4674 i2c_w(sd, OV7670_R56_CONTRAS, val >> 1);
4679 static void setexposure(struct gspca_dev *gspca_dev)
4681 struct sd *sd = (struct sd *) gspca_dev;
4683 if (!sd->ctrls[AUTOGAIN].val)
4684 i2c_w(sd, 0x10, sd->ctrls[EXPOSURE].val);
4687 static void setcolors(struct gspca_dev *gspca_dev)
4689 struct sd *sd = (struct sd *) gspca_dev;
4691 static const struct ov_i2c_regvals colors_7660[][6] = {
4692 {{0x4f, 0x28}, {0x50, 0x2a}, {0x51, 0x02}, {0x52, 0x0a},
4693 {0x53, 0x19}, {0x54, 0x23}},
4694 {{0x4f, 0x47}, {0x50, 0x4a}, {0x51, 0x03}, {0x52, 0x11},
4695 {0x53, 0x2c}, {0x54, 0x3e}},
4696 {{0x4f, 0x66}, {0x50, 0x6b}, {0x51, 0x05}, {0x52, 0x19},
4697 {0x53, 0x40}, {0x54, 0x59}},
4698 {{0x4f, 0x84}, {0x50, 0x8b}, {0x51, 0x06}, {0x52, 0x20},
4699 {0x53, 0x53}, {0x54, 0x73}},
4700 {{0x4f, 0xa3}, {0x50, 0xab}, {0x51, 0x08}, {0x52, 0x28},
4701 {0x53, 0x66}, {0x54, 0x8e}},
4704 val = sd->ctrls[COLORS].val;
4705 switch (sd->sensor) {
4712 i2c_w(sd, OV7610_REG_SAT, val);
4716 /* Use UV gamma control instead. Bits 0 & 7 are reserved. */
4717 /* rc = ov_i2c_write(sd->dev, 0x62, (val >> 9) & 0x7e);
4720 i2c_w(sd, OV7610_REG_SAT, val);
4724 i2c_w(sd, OV7610_REG_SAT, val & 0xf0);
4727 write_i2c_regvals(sd, colors_7660[val],
4728 ARRAY_SIZE(colors_7660[0]));
4731 /* supported later once I work out how to do it
4732 * transparently fail now! */
4733 /* set REG_COM13 values for UV sat auto mode */
4738 static void setautobright(struct gspca_dev *gspca_dev)
4740 struct sd *sd = (struct sd *) gspca_dev;
4742 i2c_w_mask(sd, 0x2d, sd->ctrls[AUTOBRIGHT].val ? 0x10 : 0x00, 0x10);
4745 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
4747 struct sd *sd = (struct sd *) gspca_dev;
4749 sd->ctrls[AUTOGAIN].val = val;
4751 gspca_dev->ctrl_inac |= (1 << EXPOSURE);
4753 gspca_dev->ctrl_inac &= ~(1 << EXPOSURE);
4754 sd->ctrls[EXPOSURE].val = i2c_r(sd, 0x10);
4756 if (gspca_dev->streaming)
4757 setautogain(gspca_dev);
4758 return gspca_dev->usb_err;
4761 static void setfreq_i(struct sd *sd)
4763 if (sd->sensor == SEN_OV7660
4764 || sd->sensor == SEN_OV7670) {
4765 switch (sd->ctrls[FREQ].val) {
4766 case 0: /* Banding filter disabled */
4767 i2c_w_mask(sd, OV7670_R13_COM8, 0, OV7670_COM8_BFILT);
4770 i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_BFILT,
4772 i2c_w_mask(sd, OV7670_R3B_COM11, 0x08, 0x18);
4775 i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_BFILT,
4777 i2c_w_mask(sd, OV7670_R3B_COM11, 0x00, 0x18);
4779 case 3: /* Auto hz - ov7670 only */
4780 i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_BFILT,
4782 i2c_w_mask(sd, OV7670_R3B_COM11, OV7670_COM11_HZAUTO,
4787 switch (sd->ctrls[FREQ].val) {
4788 case 0: /* Banding filter disabled */
4789 i2c_w_mask(sd, 0x2d, 0x00, 0x04);
4790 i2c_w_mask(sd, 0x2a, 0x00, 0x80);
4792 case 1: /* 50 hz (filter on and framerate adj) */
4793 i2c_w_mask(sd, 0x2d, 0x04, 0x04);
4794 i2c_w_mask(sd, 0x2a, 0x80, 0x80);
4795 /* 20 fps -> 16.667 fps */
4796 if (sd->sensor == SEN_OV6620 ||
4797 sd->sensor == SEN_OV6630 ||
4798 sd->sensor == SEN_OV66308AF)
4799 i2c_w(sd, 0x2b, 0x5e);
4801 i2c_w(sd, 0x2b, 0xac);
4803 case 2: /* 60 hz (filter on, ...) */
4804 i2c_w_mask(sd, 0x2d, 0x04, 0x04);
4805 if (sd->sensor == SEN_OV6620 ||
4806 sd->sensor == SEN_OV6630 ||
4807 sd->sensor == SEN_OV66308AF) {
4808 /* 20 fps -> 15 fps */
4809 i2c_w_mask(sd, 0x2a, 0x80, 0x80);
4810 i2c_w(sd, 0x2b, 0xa8);
4812 /* no framerate adj. */
4813 i2c_w_mask(sd, 0x2a, 0x00, 0x80);
4819 static void setfreq(struct gspca_dev *gspca_dev)
4821 struct sd *sd = (struct sd *) gspca_dev;
4825 /* Ugly but necessary */
4826 if (sd->bridge == BRIDGE_W9968CF)
4827 w9968cf_set_crop_window(sd);
4830 static int sd_querymenu(struct gspca_dev *gspca_dev,
4831 struct v4l2_querymenu *menu)
4833 struct sd *sd = (struct sd *) gspca_dev;
4836 case V4L2_CID_POWER_LINE_FREQUENCY:
4837 switch (menu->index) {
4838 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
4839 strcpy((char *) menu->name, "NoFliker");
4841 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
4842 strcpy((char *) menu->name, "50 Hz");
4844 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
4845 strcpy((char *) menu->name, "60 Hz");
4848 if (sd->sensor != SEN_OV7670)
4851 strcpy((char *) menu->name, "Automatic");
4859 static int sd_get_jcomp(struct gspca_dev *gspca_dev,
4860 struct v4l2_jpegcompression *jcomp)
4862 struct sd *sd = (struct sd *) gspca_dev;
4864 if (sd->bridge != BRIDGE_W9968CF)
4867 memset(jcomp, 0, sizeof *jcomp);
4868 jcomp->quality = sd->quality;
4869 jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT | V4L2_JPEG_MARKER_DQT |
4870 V4L2_JPEG_MARKER_DRI;
4874 static int sd_set_jcomp(struct gspca_dev *gspca_dev,
4875 struct v4l2_jpegcompression *jcomp)
4877 struct sd *sd = (struct sd *) gspca_dev;
4879 if (sd->bridge != BRIDGE_W9968CF)
4882 if (gspca_dev->streaming)
4885 if (jcomp->quality < QUALITY_MIN)
4886 sd->quality = QUALITY_MIN;
4887 else if (jcomp->quality > QUALITY_MAX)
4888 sd->quality = QUALITY_MAX;
4890 sd->quality = jcomp->quality;
4892 /* Return resulting jcomp params to app */
4893 sd_get_jcomp(gspca_dev, jcomp);
4898 /* sub-driver description */
4899 static const struct sd_desc sd_desc = {
4900 .name = MODULE_NAME,
4902 .nctrls = ARRAY_SIZE(sd_ctrls),
4903 .config = sd_config,
4905 .isoc_init = sd_isoc_init,
4909 .pkt_scan = sd_pkt_scan,
4910 .dq_callback = sd_reset_snapshot,
4911 .querymenu = sd_querymenu,
4912 .get_jcomp = sd_get_jcomp,
4913 .set_jcomp = sd_set_jcomp,
4914 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
4919 /* -- module initialisation -- */
4920 static const struct usb_device_id device_table[] = {
4921 {USB_DEVICE(0x041e, 0x4003), .driver_info = BRIDGE_W9968CF },
4922 {USB_DEVICE(0x041e, 0x4052), .driver_info = BRIDGE_OV519 },
4923 {USB_DEVICE(0x041e, 0x405f), .driver_info = BRIDGE_OV519 },
4924 {USB_DEVICE(0x041e, 0x4060), .driver_info = BRIDGE_OV519 },
4925 {USB_DEVICE(0x041e, 0x4061), .driver_info = BRIDGE_OV519 },
4926 {USB_DEVICE(0x041e, 0x4064),
4927 .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
4928 {USB_DEVICE(0x041e, 0x4067), .driver_info = BRIDGE_OV519 },
4929 {USB_DEVICE(0x041e, 0x4068),
4930 .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
4931 {USB_DEVICE(0x045e, 0x028c), .driver_info = BRIDGE_OV519 },
4932 {USB_DEVICE(0x054c, 0x0154), .driver_info = BRIDGE_OV519 },
4933 {USB_DEVICE(0x054c, 0x0155),
4934 .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
4935 {USB_DEVICE(0x05a9, 0x0511), .driver_info = BRIDGE_OV511 },
4936 {USB_DEVICE(0x05a9, 0x0518), .driver_info = BRIDGE_OV518 },
4937 {USB_DEVICE(0x05a9, 0x0519), .driver_info = BRIDGE_OV519 },
4938 {USB_DEVICE(0x05a9, 0x0530), .driver_info = BRIDGE_OV519 },
4939 {USB_DEVICE(0x05a9, 0x2800), .driver_info = BRIDGE_OVFX2 },
4940 {USB_DEVICE(0x05a9, 0x4519), .driver_info = BRIDGE_OV519 },
4941 {USB_DEVICE(0x05a9, 0x8519), .driver_info = BRIDGE_OV519 },
4942 {USB_DEVICE(0x05a9, 0xa511), .driver_info = BRIDGE_OV511PLUS },
4943 {USB_DEVICE(0x05a9, 0xa518), .driver_info = BRIDGE_OV518PLUS },
4944 {USB_DEVICE(0x0813, 0x0002), .driver_info = BRIDGE_OV511PLUS },
4945 {USB_DEVICE(0x0b62, 0x0059), .driver_info = BRIDGE_OVFX2 },
4946 {USB_DEVICE(0x0e96, 0xc001), .driver_info = BRIDGE_OVFX2 },
4947 {USB_DEVICE(0x1046, 0x9967), .driver_info = BRIDGE_W9968CF },
4948 {USB_DEVICE(0x8020, 0xef04), .driver_info = BRIDGE_OVFX2 },
4952 MODULE_DEVICE_TABLE(usb, device_table);
4954 /* -- device connect -- */
4955 static int sd_probe(struct usb_interface *intf,
4956 const struct usb_device_id *id)
4958 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
4962 static struct usb_driver sd_driver = {
4963 .name = MODULE_NAME,
4964 .id_table = device_table,
4966 .disconnect = gspca_disconnect,
4968 .suspend = gspca_suspend,
4969 .resume = gspca_resume,
4973 /* -- module insert / remove -- */
4974 static int __init sd_mod_init(void)
4976 return usb_register(&sd_driver);
4978 static void __exit sd_mod_exit(void)
4980 usb_deregister(&sd_driver);
4983 module_init(sd_mod_init);
4984 module_exit(sd_mod_exit);
4986 module_param(frame_rate, int, 0644);
4987 MODULE_PARM_DESC(frame_rate, "Frame rate (5, 10, 15, 20 or 30 fps)");