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