xref: /openbmc/linux/drivers/media/usb/gspca/ov519.c (revision df5ce27d)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * OV519 driver
4  *
5  * Copyright (C) 2008-2011 Jean-François Moine <moinejf@free.fr>
6  * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com>
7  *
8  * This module is adapted from the ov51x-jpeg package, which itself
9  * was adapted from the ov511 driver.
10  *
11  * Original copyright for the ov511 driver is:
12  *
13  * Copyright (c) 1999-2006 Mark W. McClelland
14  * Support for OV519, OV8610 Copyright (c) 2003 Joerg Heckenbach
15  * Many improvements by Bret Wallach <bwallac1@san.rr.com>
16  * Color fixes by by Orion Sky Lawlor <olawlor@acm.org> (2/26/2000)
17  * OV7620 fixes by Charl P. Botha <cpbotha@ieee.org>
18  * Changes by Claudio Matsuoka <claudio@conectiva.com>
19  *
20  * ov51x-jpeg original copyright is:
21  *
22  * Copyright (c) 2004-2007 Romain Beauxis <toots@rastageeks.org>
23  * Support for OV7670 sensors was contributed by Sam Skipsey <aoanla@yahoo.com>
24  */
25 
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27 
28 #define MODULE_NAME "ov519"
29 
30 #include <linux/input.h>
31 #include "gspca.h"
32 
33 /* The jpeg_hdr is used by w996Xcf only */
34 /* The CONEX_CAM define for jpeg.h needs renaming, now its used here too */
35 #define CONEX_CAM
36 #include "jpeg.h"
37 
38 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
39 MODULE_DESCRIPTION("OV519 USB Camera Driver");
40 MODULE_LICENSE("GPL");
41 
42 /* global parameters */
43 static int frame_rate;
44 
45 /* Number of times to retry a failed I2C transaction. Increase this if you
46  * are getting "Failed to read sensor ID..." */
47 static int i2c_detect_tries = 10;
48 
49 /* ov519 device descriptor */
50 struct sd {
51 	struct gspca_dev gspca_dev;		/* !! must be the first item */
52 
53 	struct v4l2_ctrl *jpegqual;
54 	struct v4l2_ctrl *freq;
55 	struct { /* h/vflip control cluster */
56 		struct v4l2_ctrl *hflip;
57 		struct v4l2_ctrl *vflip;
58 	};
59 	struct { /* autobrightness/brightness control cluster */
60 		struct v4l2_ctrl *autobright;
61 		struct v4l2_ctrl *brightness;
62 	};
63 
64 	u8 revision;
65 
66 	u8 packet_nr;
67 
68 	char bridge;
69 #define BRIDGE_OV511		0
70 #define BRIDGE_OV511PLUS	1
71 #define BRIDGE_OV518		2
72 #define BRIDGE_OV518PLUS	3
73 #define BRIDGE_OV519		4		/* = ov530 */
74 #define BRIDGE_OVFX2		5
75 #define BRIDGE_W9968CF		6
76 #define BRIDGE_MASK		7
77 
78 	char invert_led;
79 #define BRIDGE_INVERT_LED	8
80 
81 	char snapshot_pressed;
82 	char snapshot_needs_reset;
83 
84 	/* Determined by sensor type */
85 	u8 sif;
86 
87 #define QUALITY_MIN 50
88 #define QUALITY_MAX 70
89 #define QUALITY_DEF 50
90 
91 	u8 stopped;		/* Streaming is temporarily paused */
92 	u8 first_frame;
93 
94 	u8 frame_rate;		/* current Framerate */
95 	u8 clockdiv;		/* clockdiv override */
96 
97 	s8 sensor;		/* Type of image sensor chip (SEN_*) */
98 
99 	u8 sensor_addr;
100 	u16 sensor_width;
101 	u16 sensor_height;
102 	s16 sensor_reg_cache[256];
103 
104 	u8 jpeg_hdr[JPEG_HDR_SZ];
105 };
106 enum sensors {
107 	SEN_OV2610,
108 	SEN_OV2610AE,
109 	SEN_OV3610,
110 	SEN_OV6620,
111 	SEN_OV6630,
112 	SEN_OV66308AF,
113 	SEN_OV7610,
114 	SEN_OV7620,
115 	SEN_OV7620AE,
116 	SEN_OV7640,
117 	SEN_OV7648,
118 	SEN_OV7660,
119 	SEN_OV7670,
120 	SEN_OV76BE,
121 	SEN_OV8610,
122 	SEN_OV9600,
123 };
124 
125 /* Note this is a bit of a hack, but the w9968cf driver needs the code for all
126    the ov sensors which is already present here. When we have the time we
127    really should move the sensor drivers to v4l2 sub drivers. */
128 #include "w996Xcf.c"
129 
130 /* table of the disabled controls */
131 struct ctrl_valid {
132 	unsigned int has_brightness:1;
133 	unsigned int has_contrast:1;
134 	unsigned int has_exposure:1;
135 	unsigned int has_autogain:1;
136 	unsigned int has_sat:1;
137 	unsigned int has_hvflip:1;
138 	unsigned int has_autobright:1;
139 	unsigned int has_freq:1;
140 };
141 
142 static const struct ctrl_valid valid_controls[] = {
143 	[SEN_OV2610] = {
144 		.has_exposure = 1,
145 		.has_autogain = 1,
146 	},
147 	[SEN_OV2610AE] = {
148 		.has_exposure = 1,
149 		.has_autogain = 1,
150 	},
151 	[SEN_OV3610] = {
152 		/* No controls */
153 	},
154 	[SEN_OV6620] = {
155 		.has_brightness = 1,
156 		.has_contrast = 1,
157 		.has_sat = 1,
158 		.has_autobright = 1,
159 		.has_freq = 1,
160 	},
161 	[SEN_OV6630] = {
162 		.has_brightness = 1,
163 		.has_contrast = 1,
164 		.has_sat = 1,
165 		.has_autobright = 1,
166 		.has_freq = 1,
167 	},
168 	[SEN_OV66308AF] = {
169 		.has_brightness = 1,
170 		.has_contrast = 1,
171 		.has_sat = 1,
172 		.has_autobright = 1,
173 		.has_freq = 1,
174 	},
175 	[SEN_OV7610] = {
176 		.has_brightness = 1,
177 		.has_contrast = 1,
178 		.has_sat = 1,
179 		.has_autobright = 1,
180 		.has_freq = 1,
181 	},
182 	[SEN_OV7620] = {
183 		.has_brightness = 1,
184 		.has_contrast = 1,
185 		.has_sat = 1,
186 		.has_autobright = 1,
187 		.has_freq = 1,
188 	},
189 	[SEN_OV7620AE] = {
190 		.has_brightness = 1,
191 		.has_contrast = 1,
192 		.has_sat = 1,
193 		.has_autobright = 1,
194 		.has_freq = 1,
195 	},
196 	[SEN_OV7640] = {
197 		.has_brightness = 1,
198 		.has_sat = 1,
199 		.has_freq = 1,
200 	},
201 	[SEN_OV7648] = {
202 		.has_brightness = 1,
203 		.has_sat = 1,
204 		.has_freq = 1,
205 	},
206 	[SEN_OV7660] = {
207 		.has_brightness = 1,
208 		.has_contrast = 1,
209 		.has_sat = 1,
210 		.has_hvflip = 1,
211 		.has_freq = 1,
212 	},
213 	[SEN_OV7670] = {
214 		.has_brightness = 1,
215 		.has_contrast = 1,
216 		.has_hvflip = 1,
217 		.has_freq = 1,
218 	},
219 	[SEN_OV76BE] = {
220 		.has_brightness = 1,
221 		.has_contrast = 1,
222 		.has_sat = 1,
223 		.has_autobright = 1,
224 		.has_freq = 1,
225 	},
226 	[SEN_OV8610] = {
227 		.has_brightness = 1,
228 		.has_contrast = 1,
229 		.has_sat = 1,
230 		.has_autobright = 1,
231 	},
232 	[SEN_OV9600] = {
233 		.has_exposure = 1,
234 		.has_autogain = 1,
235 	},
236 };
237 
238 static const struct v4l2_pix_format ov519_vga_mode[] = {
239 	{320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
240 		.bytesperline = 320,
241 		.sizeimage = 320 * 240 * 3 / 8 + 590,
242 		.colorspace = V4L2_COLORSPACE_JPEG,
243 		.priv = 1},
244 	{640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
245 		.bytesperline = 640,
246 		.sizeimage = 640 * 480 * 3 / 8 + 590,
247 		.colorspace = V4L2_COLORSPACE_JPEG,
248 		.priv = 0},
249 };
250 static const struct v4l2_pix_format ov519_sif_mode[] = {
251 	{160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
252 		.bytesperline = 160,
253 		.sizeimage = 160 * 120 * 3 / 8 + 590,
254 		.colorspace = V4L2_COLORSPACE_JPEG,
255 		.priv = 3},
256 	{176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
257 		.bytesperline = 176,
258 		.sizeimage = 176 * 144 * 3 / 8 + 590,
259 		.colorspace = V4L2_COLORSPACE_JPEG,
260 		.priv = 1},
261 	{320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
262 		.bytesperline = 320,
263 		.sizeimage = 320 * 240 * 3 / 8 + 590,
264 		.colorspace = V4L2_COLORSPACE_JPEG,
265 		.priv = 2},
266 	{352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
267 		.bytesperline = 352,
268 		.sizeimage = 352 * 288 * 3 / 8 + 590,
269 		.colorspace = V4L2_COLORSPACE_JPEG,
270 		.priv = 0},
271 };
272 
273 /* Note some of the sizeimage values for the ov511 / ov518 may seem
274    larger then necessary, however they need to be this big as the ov511 /
275    ov518 always fills the entire isoc frame, using 0 padding bytes when
276    it doesn't have any data. So with low framerates the amount of data
277    transferred can become quite large (libv4l will remove all the 0 padding
278    in userspace). */
279 static const struct v4l2_pix_format ov518_vga_mode[] = {
280 	{320, 240, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
281 		.bytesperline = 320,
282 		.sizeimage = 320 * 240 * 3,
283 		.colorspace = V4L2_COLORSPACE_JPEG,
284 		.priv = 1},
285 	{640, 480, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
286 		.bytesperline = 640,
287 		.sizeimage = 640 * 480 * 2,
288 		.colorspace = V4L2_COLORSPACE_JPEG,
289 		.priv = 0},
290 };
291 static const struct v4l2_pix_format ov518_sif_mode[] = {
292 	{160, 120, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
293 		.bytesperline = 160,
294 		.sizeimage = 70000,
295 		.colorspace = V4L2_COLORSPACE_JPEG,
296 		.priv = 3},
297 	{176, 144, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
298 		.bytesperline = 176,
299 		.sizeimage = 70000,
300 		.colorspace = V4L2_COLORSPACE_JPEG,
301 		.priv = 1},
302 	{320, 240, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
303 		.bytesperline = 320,
304 		.sizeimage = 320 * 240 * 3,
305 		.colorspace = V4L2_COLORSPACE_JPEG,
306 		.priv = 2},
307 	{352, 288, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
308 		.bytesperline = 352,
309 		.sizeimage = 352 * 288 * 3,
310 		.colorspace = V4L2_COLORSPACE_JPEG,
311 		.priv = 0},
312 };
313 
314 static const struct v4l2_pix_format ov511_vga_mode[] = {
315 	{320, 240, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
316 		.bytesperline = 320,
317 		.sizeimage = 320 * 240 * 3,
318 		.colorspace = V4L2_COLORSPACE_JPEG,
319 		.priv = 1},
320 	{640, 480, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
321 		.bytesperline = 640,
322 		.sizeimage = 640 * 480 * 2,
323 		.colorspace = V4L2_COLORSPACE_JPEG,
324 		.priv = 0},
325 };
326 static const struct v4l2_pix_format ov511_sif_mode[] = {
327 	{160, 120, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
328 		.bytesperline = 160,
329 		.sizeimage = 70000,
330 		.colorspace = V4L2_COLORSPACE_JPEG,
331 		.priv = 3},
332 	{176, 144, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
333 		.bytesperline = 176,
334 		.sizeimage = 70000,
335 		.colorspace = V4L2_COLORSPACE_JPEG,
336 		.priv = 1},
337 	{320, 240, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
338 		.bytesperline = 320,
339 		.sizeimage = 320 * 240 * 3,
340 		.colorspace = V4L2_COLORSPACE_JPEG,
341 		.priv = 2},
342 	{352, 288, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
343 		.bytesperline = 352,
344 		.sizeimage = 352 * 288 * 3,
345 		.colorspace = V4L2_COLORSPACE_JPEG,
346 		.priv = 0},
347 };
348 
349 static const struct v4l2_pix_format ovfx2_ov2610_mode[] = {
350 	{800, 600, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
351 		.bytesperline = 800,
352 		.sizeimage = 800 * 600,
353 		.colorspace = V4L2_COLORSPACE_SRGB,
354 		.priv = 1},
355 	{1600, 1200, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
356 		.bytesperline = 1600,
357 		.sizeimage = 1600 * 1200,
358 		.colorspace = V4L2_COLORSPACE_SRGB},
359 };
360 static const struct v4l2_pix_format ovfx2_ov3610_mode[] = {
361 	{640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
362 		.bytesperline = 640,
363 		.sizeimage = 640 * 480,
364 		.colorspace = V4L2_COLORSPACE_SRGB,
365 		.priv = 1},
366 	{800, 600, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
367 		.bytesperline = 800,
368 		.sizeimage = 800 * 600,
369 		.colorspace = V4L2_COLORSPACE_SRGB,
370 		.priv = 1},
371 	{1024, 768, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
372 		.bytesperline = 1024,
373 		.sizeimage = 1024 * 768,
374 		.colorspace = V4L2_COLORSPACE_SRGB,
375 		.priv = 1},
376 	{1600, 1200, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
377 		.bytesperline = 1600,
378 		.sizeimage = 1600 * 1200,
379 		.colorspace = V4L2_COLORSPACE_SRGB,
380 		.priv = 0},
381 	{2048, 1536, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
382 		.bytesperline = 2048,
383 		.sizeimage = 2048 * 1536,
384 		.colorspace = V4L2_COLORSPACE_SRGB,
385 		.priv = 0},
386 };
387 static const struct v4l2_pix_format ovfx2_ov9600_mode[] = {
388 	{640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
389 		.bytesperline = 640,
390 		.sizeimage = 640 * 480,
391 		.colorspace = V4L2_COLORSPACE_SRGB,
392 		.priv = 1},
393 	{1280, 1024, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
394 		.bytesperline = 1280,
395 		.sizeimage = 1280 * 1024,
396 		.colorspace = V4L2_COLORSPACE_SRGB},
397 };
398 
399 /* Registers common to OV511 / OV518 */
400 #define R51x_FIFO_PSIZE			0x30	/* 2 bytes wide w/ OV518(+) */
401 #define R51x_SYS_RESET			0x50
402 	/* Reset type flags */
403 	#define	OV511_RESET_OMNICE	0x08
404 #define R51x_SYS_INIT			0x53
405 #define R51x_SYS_SNAP			0x52
406 #define R51x_SYS_CUST_ID		0x5f
407 #define R51x_COMP_LUT_BEGIN		0x80
408 
409 /* OV511 Camera interface register numbers */
410 #define R511_CAM_DELAY			0x10
411 #define R511_CAM_EDGE			0x11
412 #define R511_CAM_PXCNT			0x12
413 #define R511_CAM_LNCNT			0x13
414 #define R511_CAM_PXDIV			0x14
415 #define R511_CAM_LNDIV			0x15
416 #define R511_CAM_UV_EN			0x16
417 #define R511_CAM_LINE_MODE		0x17
418 #define R511_CAM_OPTS			0x18
419 
420 #define R511_SNAP_FRAME			0x19
421 #define R511_SNAP_PXCNT			0x1a
422 #define R511_SNAP_LNCNT			0x1b
423 #define R511_SNAP_PXDIV			0x1c
424 #define R511_SNAP_LNDIV			0x1d
425 #define R511_SNAP_UV_EN			0x1e
426 #define R511_SNAP_OPTS			0x1f
427 
428 #define R511_DRAM_FLOW_CTL		0x20
429 #define R511_FIFO_OPTS			0x31
430 #define R511_I2C_CTL			0x40
431 #define R511_SYS_LED_CTL		0x55	/* OV511+ only */
432 #define R511_COMP_EN			0x78
433 #define R511_COMP_LUT_EN		0x79
434 
435 /* OV518 Camera interface register numbers */
436 #define R518_GPIO_OUT			0x56	/* OV518(+) only */
437 #define R518_GPIO_CTL			0x57	/* OV518(+) only */
438 
439 /* OV519 Camera interface register numbers */
440 #define OV519_R10_H_SIZE		0x10
441 #define OV519_R11_V_SIZE		0x11
442 #define OV519_R12_X_OFFSETL		0x12
443 #define OV519_R13_X_OFFSETH		0x13
444 #define OV519_R14_Y_OFFSETL		0x14
445 #define OV519_R15_Y_OFFSETH		0x15
446 #define OV519_R16_DIVIDER		0x16
447 #define OV519_R20_DFR			0x20
448 #define OV519_R25_FORMAT		0x25
449 
450 /* OV519 System Controller register numbers */
451 #define OV519_R51_RESET1		0x51
452 #define OV519_R54_EN_CLK1		0x54
453 #define OV519_R57_SNAPSHOT		0x57
454 
455 #define OV519_GPIO_DATA_OUT0		0x71
456 #define OV519_GPIO_IO_CTRL0		0x72
457 
458 /*#define OV511_ENDPOINT_ADDRESS 1	 * Isoc endpoint number */
459 
460 /*
461  * The FX2 chip does not give us a zero length read at end of frame.
462  * It does, however, give a short read at the end of a frame, if
463  * necessary, rather than run two frames together.
464  *
465  * By choosing the right bulk transfer size, we are guaranteed to always
466  * get a short read for the last read of each frame.  Frame sizes are
467  * always a composite number (width * height, or a multiple) so if we
468  * choose a prime number, we are guaranteed that the last read of a
469  * frame will be short.
470  *
471  * But it isn't that easy: the 2.6 kernel requires a multiple of 4KB,
472  * otherwise EOVERFLOW "babbling" errors occur.  I have not been able
473  * to figure out why.  [PMiller]
474  *
475  * The constant (13 * 4096) is the largest "prime enough" number less than 64KB.
476  *
477  * It isn't enough to know the number of bytes per frame, in case we
478  * have data dropouts or buffer overruns (even though the FX2 double
479  * buffers, there are some pretty strict real time constraints for
480  * isochronous transfer for larger frame sizes).
481  */
482 /*jfm: this value does not work for 800x600 - see isoc_init */
483 #define OVFX2_BULK_SIZE (13 * 4096)
484 
485 /* I2C registers */
486 #define R51x_I2C_W_SID		0x41
487 #define R51x_I2C_SADDR_3	0x42
488 #define R51x_I2C_SADDR_2	0x43
489 #define R51x_I2C_R_SID		0x44
490 #define R51x_I2C_DATA		0x45
491 #define R518_I2C_CTL		0x47	/* OV518(+) only */
492 #define OVFX2_I2C_ADDR		0x00
493 
494 /* I2C ADDRESSES */
495 #define OV7xx0_SID   0x42
496 #define OV_HIRES_SID 0x60		/* OV9xxx / OV2xxx / OV3xxx */
497 #define OV8xx0_SID   0xa0
498 #define OV6xx0_SID   0xc0
499 
500 /* OV7610 registers */
501 #define OV7610_REG_GAIN		0x00	/* gain setting (5:0) */
502 #define OV7610_REG_BLUE		0x01	/* blue channel balance */
503 #define OV7610_REG_RED		0x02	/* red channel balance */
504 #define OV7610_REG_SAT		0x03	/* saturation */
505 #define OV8610_REG_HUE		0x04	/* 04 reserved */
506 #define OV7610_REG_CNT		0x05	/* Y contrast */
507 #define OV7610_REG_BRT		0x06	/* Y brightness */
508 #define OV7610_REG_COM_C	0x14	/* misc common regs */
509 #define OV7610_REG_ID_HIGH	0x1c	/* manufacturer ID MSB */
510 #define OV7610_REG_ID_LOW	0x1d	/* manufacturer ID LSB */
511 #define OV7610_REG_COM_I	0x29	/* misc settings */
512 
513 /* OV7660 and OV7670 registers */
514 #define OV7670_R00_GAIN		0x00	/* Gain lower 8 bits (rest in vref) */
515 #define OV7670_R01_BLUE		0x01	/* blue gain */
516 #define OV7670_R02_RED		0x02	/* red gain */
517 #define OV7670_R03_VREF		0x03	/* Pieces of GAIN, VSTART, VSTOP */
518 #define OV7670_R04_COM1		0x04	/* Control 1 */
519 /*#define OV7670_R07_AECHH	0x07	 * AEC MS 5 bits */
520 #define OV7670_R0C_COM3		0x0c	/* Control 3 */
521 #define OV7670_R0D_COM4		0x0d	/* Control 4 */
522 #define OV7670_R0E_COM5		0x0e	/* All "reserved" */
523 #define OV7670_R0F_COM6		0x0f	/* Control 6 */
524 #define OV7670_R10_AECH		0x10	/* More bits of AEC value */
525 #define OV7670_R11_CLKRC	0x11	/* Clock control */
526 #define OV7670_R12_COM7		0x12	/* Control 7 */
527 #define   OV7670_COM7_FMT_VGA	 0x00
528 /*#define   OV7670_COM7_YUV	 0x00	 * YUV */
529 #define   OV7670_COM7_FMT_QVGA	 0x10	/* QVGA format */
530 #define   OV7670_COM7_FMT_MASK	 0x38
531 #define   OV7670_COM7_RESET	 0x80	/* Register reset */
532 #define OV7670_R13_COM8		0x13	/* Control 8 */
533 #define   OV7670_COM8_AEC	 0x01	/* Auto exposure enable */
534 #define   OV7670_COM8_AWB	 0x02	/* White balance enable */
535 #define   OV7670_COM8_AGC	 0x04	/* Auto gain enable */
536 #define   OV7670_COM8_BFILT	 0x20	/* Band filter enable */
537 #define   OV7670_COM8_AECSTEP	 0x40	/* Unlimited AEC step size */
538 #define   OV7670_COM8_FASTAEC	 0x80	/* Enable fast AGC/AEC */
539 #define OV7670_R14_COM9		0x14	/* Control 9 - gain ceiling */
540 #define OV7670_R15_COM10	0x15	/* Control 10 */
541 #define OV7670_R17_HSTART	0x17	/* Horiz start high bits */
542 #define OV7670_R18_HSTOP	0x18	/* Horiz stop high bits */
543 #define OV7670_R19_VSTART	0x19	/* Vert start high bits */
544 #define OV7670_R1A_VSTOP	0x1a	/* Vert stop high bits */
545 #define OV7670_R1E_MVFP		0x1e	/* Mirror / vflip */
546 #define   OV7670_MVFP_VFLIP	 0x10	/* vertical flip */
547 #define   OV7670_MVFP_MIRROR	 0x20	/* Mirror image */
548 #define OV7670_R24_AEW		0x24	/* AGC upper limit */
549 #define OV7670_R25_AEB		0x25	/* AGC lower limit */
550 #define OV7670_R26_VPT		0x26	/* AGC/AEC fast mode op region */
551 #define OV7670_R32_HREF		0x32	/* HREF pieces */
552 #define OV7670_R3A_TSLB		0x3a	/* lots of stuff */
553 #define OV7670_R3B_COM11	0x3b	/* Control 11 */
554 #define   OV7670_COM11_EXP	 0x02
555 #define   OV7670_COM11_HZAUTO	 0x10	/* Auto detect 50/60 Hz */
556 #define OV7670_R3C_COM12	0x3c	/* Control 12 */
557 #define OV7670_R3D_COM13	0x3d	/* Control 13 */
558 #define   OV7670_COM13_GAMMA	 0x80	/* Gamma enable */
559 #define   OV7670_COM13_UVSAT	 0x40	/* UV saturation auto adjustment */
560 #define OV7670_R3E_COM14	0x3e	/* Control 14 */
561 #define OV7670_R3F_EDGE		0x3f	/* Edge enhancement factor */
562 #define OV7670_R40_COM15	0x40	/* Control 15 */
563 /*#define   OV7670_COM15_R00FF	 0xc0	 *	00 to FF */
564 #define OV7670_R41_COM16	0x41	/* Control 16 */
565 #define   OV7670_COM16_AWBGAIN	 0x08	/* AWB gain enable */
566 /* end of ov7660 common registers */
567 #define OV7670_R55_BRIGHT	0x55	/* Brightness */
568 #define OV7670_R56_CONTRAS	0x56	/* Contrast control */
569 #define OV7670_R69_GFIX		0x69	/* Fix gain control */
570 /*#define OV7670_R8C_RGB444	0x8c	 * RGB 444 control */
571 #define OV7670_R9F_HAECC1	0x9f	/* Hist AEC/AGC control 1 */
572 #define OV7670_RA0_HAECC2	0xa0	/* Hist AEC/AGC control 2 */
573 #define OV7670_RA5_BD50MAX	0xa5	/* 50hz banding step limit */
574 #define OV7670_RA6_HAECC3	0xa6	/* Hist AEC/AGC control 3 */
575 #define OV7670_RA7_HAECC4	0xa7	/* Hist AEC/AGC control 4 */
576 #define OV7670_RA8_HAECC5	0xa8	/* Hist AEC/AGC control 5 */
577 #define OV7670_RA9_HAECC6	0xa9	/* Hist AEC/AGC control 6 */
578 #define OV7670_RAA_HAECC7	0xaa	/* Hist AEC/AGC control 7 */
579 #define OV7670_RAB_BD60MAX	0xab	/* 60hz banding step limit */
580 
581 struct ov_regvals {
582 	u8 reg;
583 	u8 val;
584 };
585 struct ov_i2c_regvals {
586 	u8 reg;
587 	u8 val;
588 };
589 
590 /* Settings for OV2610 camera chip */
591 static const struct ov_i2c_regvals norm_2610[] = {
592 	{ 0x12, 0x80 },	/* reset */
593 };
594 
595 static const struct ov_i2c_regvals norm_2610ae[] = {
596 	{0x12, 0x80},	/* reset */
597 	{0x13, 0xcd},
598 	{0x09, 0x01},
599 	{0x0d, 0x00},
600 	{0x11, 0x80},
601 	{0x12, 0x20},	/* 1600x1200 */
602 	{0x33, 0x0c},
603 	{0x35, 0x90},
604 	{0x36, 0x37},
605 /* ms-win traces */
606 	{0x11, 0x83},	/* clock / 3 ? */
607 	{0x2d, 0x00},	/* 60 Hz filter */
608 	{0x24, 0xb0},	/* normal colors */
609 	{0x25, 0x90},
610 	{0x10, 0x43},
611 };
612 
613 static const struct ov_i2c_regvals norm_3620b[] = {
614 	/*
615 	 * From the datasheet: "Note that after writing to register COMH
616 	 * (0x12) to change the sensor mode, registers related to the
617 	 * sensor's cropping window will be reset back to their default
618 	 * values."
619 	 *
620 	 * "wait 4096 external clock ... to make sure the sensor is
621 	 * stable and ready to access registers" i.e. 160us at 24MHz
622 	 */
623 	{ 0x12, 0x80 }, /* COMH reset */
624 	{ 0x12, 0x00 }, /* QXGA, master */
625 
626 	/*
627 	 * 11 CLKRC "Clock Rate Control"
628 	 * [7] internal frequency doublers: on
629 	 * [6] video port mode: master
630 	 * [5:0] clock divider: 1
631 	 */
632 	{ 0x11, 0x80 },
633 
634 	/*
635 	 * 13 COMI "Common Control I"
636 	 *                  = 192 (0xC0) 11000000
637 	 *    COMI[7] "AEC speed selection"
638 	 *                  =   1 (0x01) 1....... "Faster AEC correction"
639 	 *    COMI[6] "AEC speed step selection"
640 	 *                  =   1 (0x01) .1...... "Big steps, fast"
641 	 *    COMI[5] "Banding filter on off"
642 	 *                  =   0 (0x00) ..0..... "Off"
643 	 *    COMI[4] "Banding filter option"
644 	 *                  =   0 (0x00) ...0.... "Main clock is 48 MHz and
645 	 *                                         the PLL is ON"
646 	 *    COMI[3] "Reserved"
647 	 *                  =   0 (0x00) ....0...
648 	 *    COMI[2] "AGC auto manual control selection"
649 	 *                  =   0 (0x00) .....0.. "Manual"
650 	 *    COMI[1] "AWB auto manual control selection"
651 	 *                  =   0 (0x00) ......0. "Manual"
652 	 *    COMI[0] "Exposure control"
653 	 *                  =   0 (0x00) .......0 "Manual"
654 	 */
655 	{ 0x13, 0xc0 },
656 
657 	/*
658 	 * 09 COMC "Common Control C"
659 	 *                  =   8 (0x08) 00001000
660 	 *    COMC[7:5] "Reserved"
661 	 *                  =   0 (0x00) 000.....
662 	 *    COMC[4] "Sleep Mode Enable"
663 	 *                  =   0 (0x00) ...0.... "Normal mode"
664 	 *    COMC[3:2] "Sensor sampling reset timing selection"
665 	 *                  =   2 (0x02) ....10.. "Longer reset time"
666 	 *    COMC[1:0] "Output drive current select"
667 	 *                  =   0 (0x00) ......00 "Weakest"
668 	 */
669 	{ 0x09, 0x08 },
670 
671 	/*
672 	 * 0C COMD "Common Control D"
673 	 *                  =   8 (0x08) 00001000
674 	 *    COMD[7] "Reserved"
675 	 *                  =   0 (0x00) 0.......
676 	 *    COMD[6] "Swap MSB and LSB at the output port"
677 	 *                  =   0 (0x00) .0...... "False"
678 	 *    COMD[5:3] "Reserved"
679 	 *                  =   1 (0x01) ..001...
680 	 *    COMD[2] "Output Average On Off"
681 	 *                  =   0 (0x00) .....0.. "Output Normal"
682 	 *    COMD[1] "Sensor precharge voltage selection"
683 	 *                  =   0 (0x00) ......0. "Selects internal
684 	 *                                         reference precharge
685 	 *                                         voltage"
686 	 *    COMD[0] "Snapshot option"
687 	 *                  =   0 (0x00) .......0 "Enable live video output
688 	 *                                         after snapshot sequence"
689 	 */
690 	{ 0x0c, 0x08 },
691 
692 	/*
693 	 * 0D COME "Common Control E"
694 	 *                  = 161 (0xA1) 10100001
695 	 *    COME[7] "Output average option"
696 	 *                  =   1 (0x01) 1....... "Output average of 4 pixels"
697 	 *    COME[6] "Anti-blooming control"
698 	 *                  =   0 (0x00) .0...... "Off"
699 	 *    COME[5:3] "Reserved"
700 	 *                  =   4 (0x04) ..100...
701 	 *    COME[2] "Clock output power down pin status"
702 	 *                  =   0 (0x00) .....0.. "Tri-state data output pin
703 	 *                                         on power down"
704 	 *    COME[1] "Data output pin status selection at power down"
705 	 *                  =   0 (0x00) ......0. "Tri-state VSYNC, PCLK,
706 	 *                                         HREF, and CHSYNC pins on
707 	 *                                         power down"
708 	 *    COME[0] "Auto zero circuit select"
709 	 *                  =   1 (0x01) .......1 "On"
710 	 */
711 	{ 0x0d, 0xa1 },
712 
713 	/*
714 	 * 0E COMF "Common Control F"
715 	 *                  = 112 (0x70) 01110000
716 	 *    COMF[7] "System clock selection"
717 	 *                  =   0 (0x00) 0....... "Use 24 MHz system clock"
718 	 *    COMF[6:4] "Reserved"
719 	 *                  =   7 (0x07) .111....
720 	 *    COMF[3] "Manual auto negative offset canceling selection"
721 	 *                  =   0 (0x00) ....0... "Auto detect negative
722 	 *                                         offset and cancel it"
723 	 *    COMF[2:0] "Reserved"
724 	 *                  =   0 (0x00) .....000
725 	 */
726 	{ 0x0e, 0x70 },
727 
728 	/*
729 	 * 0F COMG "Common Control G"
730 	 *                  =  66 (0x42) 01000010
731 	 *    COMG[7] "Optical black output selection"
732 	 *                  =   0 (0x00) 0....... "Disable"
733 	 *    COMG[6] "Black level calibrate selection"
734 	 *                  =   1 (0x01) .1...... "Use optical black pixels
735 	 *                                         to calibrate"
736 	 *    COMG[5:4] "Reserved"
737 	 *                  =   0 (0x00) ..00....
738 	 *    COMG[3] "Channel offset adjustment"
739 	 *                  =   0 (0x00) ....0... "Disable offset adjustment"
740 	 *    COMG[2] "ADC black level calibration option"
741 	 *                  =   0 (0x00) .....0.. "Use B/G line and G/R
742 	 *                                         line to calibrate each
743 	 *                                         channel's black level"
744 	 *    COMG[1] "Reserved"
745 	 *                  =   1 (0x01) ......1.
746 	 *    COMG[0] "ADC black level calibration enable"
747 	 *                  =   0 (0x00) .......0 "Disable"
748 	 */
749 	{ 0x0f, 0x42 },
750 
751 	/*
752 	 * 14 COMJ "Common Control J"
753 	 *                  = 198 (0xC6) 11000110
754 	 *    COMJ[7:6] "AGC gain ceiling"
755 	 *                  =   3 (0x03) 11...... "8x"
756 	 *    COMJ[5:4] "Reserved"
757 	 *                  =   0 (0x00) ..00....
758 	 *    COMJ[3] "Auto banding filter"
759 	 *                  =   0 (0x00) ....0... "Banding filter is always
760 	 *                                         on off depending on
761 	 *                                         COMI[5] setting"
762 	 *    COMJ[2] "VSYNC drop option"
763 	 *                  =   1 (0x01) .....1.. "SYNC is dropped if frame
764 	 *                                         data is dropped"
765 	 *    COMJ[1] "Frame data drop"
766 	 *                  =   1 (0x01) ......1. "Drop frame data if
767 	 *                                         exposure is not within
768 	 *                                         tolerance.  In AEC mode,
769 	 *                                         data is normally dropped
770 	 *                                         when data is out of
771 	 *                                         range."
772 	 *    COMJ[0] "Reserved"
773 	 *                  =   0 (0x00) .......0
774 	 */
775 	{ 0x14, 0xc6 },
776 
777 	/*
778 	 * 15 COMK "Common Control K"
779 	 *                  =   2 (0x02) 00000010
780 	 *    COMK[7] "CHSYNC pin output swap"
781 	 *                  =   0 (0x00) 0....... "CHSYNC"
782 	 *    COMK[6] "HREF pin output swap"
783 	 *                  =   0 (0x00) .0...... "HREF"
784 	 *    COMK[5] "PCLK output selection"
785 	 *                  =   0 (0x00) ..0..... "PCLK always output"
786 	 *    COMK[4] "PCLK edge selection"
787 	 *                  =   0 (0x00) ...0.... "Data valid on falling edge"
788 	 *    COMK[3] "HREF output polarity"
789 	 *                  =   0 (0x00) ....0... "positive"
790 	 *    COMK[2] "Reserved"
791 	 *                  =   0 (0x00) .....0..
792 	 *    COMK[1] "VSYNC polarity"
793 	 *                  =   1 (0x01) ......1. "negative"
794 	 *    COMK[0] "HSYNC polarity"
795 	 *                  =   0 (0x00) .......0 "positive"
796 	 */
797 	{ 0x15, 0x02 },
798 
799 	/*
800 	 * 33 CHLF "Current Control"
801 	 *                  =   9 (0x09) 00001001
802 	 *    CHLF[7:6] "Sensor current control"
803 	 *                  =   0 (0x00) 00......
804 	 *    CHLF[5] "Sensor current range control"
805 	 *                  =   0 (0x00) ..0..... "normal range"
806 	 *    CHLF[4] "Sensor current"
807 	 *                  =   0 (0x00) ...0.... "normal current"
808 	 *    CHLF[3] "Sensor buffer current control"
809 	 *                  =   1 (0x01) ....1... "half current"
810 	 *    CHLF[2] "Column buffer current control"
811 	 *                  =   0 (0x00) .....0.. "normal current"
812 	 *    CHLF[1] "Analog DSP current control"
813 	 *                  =   0 (0x00) ......0. "normal current"
814 	 *    CHLF[1] "ADC current control"
815 	 *                  =   0 (0x00) ......0. "normal current"
816 	 */
817 	{ 0x33, 0x09 },
818 
819 	/*
820 	 * 34 VBLM "Blooming Control"
821 	 *                  =  80 (0x50) 01010000
822 	 *    VBLM[7] "Hard soft reset switch"
823 	 *                  =   0 (0x00) 0....... "Hard reset"
824 	 *    VBLM[6:4] "Blooming voltage selection"
825 	 *                  =   5 (0x05) .101....
826 	 *    VBLM[3:0] "Sensor current control"
827 	 *                  =   0 (0x00) ....0000
828 	 */
829 	{ 0x34, 0x50 },
830 
831 	/*
832 	 * 36 VCHG "Sensor Precharge Voltage Control"
833 	 *                  =   0 (0x00) 00000000
834 	 *    VCHG[7] "Reserved"
835 	 *                  =   0 (0x00) 0.......
836 	 *    VCHG[6:4] "Sensor precharge voltage control"
837 	 *                  =   0 (0x00) .000....
838 	 *    VCHG[3:0] "Sensor array common reference"
839 	 *                  =   0 (0x00) ....0000
840 	 */
841 	{ 0x36, 0x00 },
842 
843 	/*
844 	 * 37 ADC "ADC Reference Control"
845 	 *                  =   4 (0x04) 00000100
846 	 *    ADC[7:4] "Reserved"
847 	 *                  =   0 (0x00) 0000....
848 	 *    ADC[3] "ADC input signal range"
849 	 *                  =   0 (0x00) ....0... "Input signal 1.0x"
850 	 *    ADC[2:0] "ADC range control"
851 	 *                  =   4 (0x04) .....100
852 	 */
853 	{ 0x37, 0x04 },
854 
855 	/*
856 	 * 38 ACOM "Analog Common Ground"
857 	 *                  =  82 (0x52) 01010010
858 	 *    ACOM[7] "Analog gain control"
859 	 *                  =   0 (0x00) 0....... "Gain 1x"
860 	 *    ACOM[6] "Analog black level calibration"
861 	 *                  =   1 (0x01) .1...... "On"
862 	 *    ACOM[5:0] "Reserved"
863 	 *                  =  18 (0x12) ..010010
864 	 */
865 	{ 0x38, 0x52 },
866 
867 	/*
868 	 * 3A FREFA "Internal Reference Adjustment"
869 	 *                  =   0 (0x00) 00000000
870 	 *    FREFA[7:0] "Range"
871 	 *                  =   0 (0x00) 00000000
872 	 */
873 	{ 0x3a, 0x00 },
874 
875 	/*
876 	 * 3C FVOPT "Internal Reference Adjustment"
877 	 *                  =  31 (0x1F) 00011111
878 	 *    FVOPT[7:0] "Range"
879 	 *                  =  31 (0x1F) 00011111
880 	 */
881 	{ 0x3c, 0x1f },
882 
883 	/*
884 	 * 44 Undocumented  =   0 (0x00) 00000000
885 	 *    44[7:0] "It's a secret"
886 	 *                  =   0 (0x00) 00000000
887 	 */
888 	{ 0x44, 0x00 },
889 
890 	/*
891 	 * 40 Undocumented  =   0 (0x00) 00000000
892 	 *    40[7:0] "It's a secret"
893 	 *                  =   0 (0x00) 00000000
894 	 */
895 	{ 0x40, 0x00 },
896 
897 	/*
898 	 * 41 Undocumented  =   0 (0x00) 00000000
899 	 *    41[7:0] "It's a secret"
900 	 *                  =   0 (0x00) 00000000
901 	 */
902 	{ 0x41, 0x00 },
903 
904 	/*
905 	 * 42 Undocumented  =   0 (0x00) 00000000
906 	 *    42[7:0] "It's a secret"
907 	 *                  =   0 (0x00) 00000000
908 	 */
909 	{ 0x42, 0x00 },
910 
911 	/*
912 	 * 43 Undocumented  =   0 (0x00) 00000000
913 	 *    43[7:0] "It's a secret"
914 	 *                  =   0 (0x00) 00000000
915 	 */
916 	{ 0x43, 0x00 },
917 
918 	/*
919 	 * 45 Undocumented  = 128 (0x80) 10000000
920 	 *    45[7:0] "It's a secret"
921 	 *                  = 128 (0x80) 10000000
922 	 */
923 	{ 0x45, 0x80 },
924 
925 	/*
926 	 * 48 Undocumented  = 192 (0xC0) 11000000
927 	 *    48[7:0] "It's a secret"
928 	 *                  = 192 (0xC0) 11000000
929 	 */
930 	{ 0x48, 0xc0 },
931 
932 	/*
933 	 * 49 Undocumented  =  25 (0x19) 00011001
934 	 *    49[7:0] "It's a secret"
935 	 *                  =  25 (0x19) 00011001
936 	 */
937 	{ 0x49, 0x19 },
938 
939 	/*
940 	 * 4B Undocumented  = 128 (0x80) 10000000
941 	 *    4B[7:0] "It's a secret"
942 	 *                  = 128 (0x80) 10000000
943 	 */
944 	{ 0x4b, 0x80 },
945 
946 	/*
947 	 * 4D Undocumented  = 196 (0xC4) 11000100
948 	 *    4D[7:0] "It's a secret"
949 	 *                  = 196 (0xC4) 11000100
950 	 */
951 	{ 0x4d, 0xc4 },
952 
953 	/*
954 	 * 35 VREF "Reference Voltage Control"
955 	 *                  =  76 (0x4c) 01001100
956 	 *    VREF[7:5] "Column high reference control"
957 	 *                  =   2 (0x02) 010..... "higher voltage"
958 	 *    VREF[4:2] "Column low reference control"
959 	 *                  =   3 (0x03) ...011.. "Highest voltage"
960 	 *    VREF[1:0] "Reserved"
961 	 *                  =   0 (0x00) ......00
962 	 */
963 	{ 0x35, 0x4c },
964 
965 	/*
966 	 * 3D Undocumented  =   0 (0x00) 00000000
967 	 *    3D[7:0] "It's a secret"
968 	 *                  =   0 (0x00) 00000000
969 	 */
970 	{ 0x3d, 0x00 },
971 
972 	/*
973 	 * 3E Undocumented  =   0 (0x00) 00000000
974 	 *    3E[7:0] "It's a secret"
975 	 *                  =   0 (0x00) 00000000
976 	 */
977 	{ 0x3e, 0x00 },
978 
979 	/*
980 	 * 3B FREFB "Internal Reference Adjustment"
981 	 *                  =  24 (0x18) 00011000
982 	 *    FREFB[7:0] "Range"
983 	 *                  =  24 (0x18) 00011000
984 	 */
985 	{ 0x3b, 0x18 },
986 
987 	/*
988 	 * 33 CHLF "Current Control"
989 	 *                  =  25 (0x19) 00011001
990 	 *    CHLF[7:6] "Sensor current control"
991 	 *                  =   0 (0x00) 00......
992 	 *    CHLF[5] "Sensor current range control"
993 	 *                  =   0 (0x00) ..0..... "normal range"
994 	 *    CHLF[4] "Sensor current"
995 	 *                  =   1 (0x01) ...1.... "double current"
996 	 *    CHLF[3] "Sensor buffer current control"
997 	 *                  =   1 (0x01) ....1... "half current"
998 	 *    CHLF[2] "Column buffer current control"
999 	 *                  =   0 (0x00) .....0.. "normal current"
1000 	 *    CHLF[1] "Analog DSP current control"
1001 	 *                  =   0 (0x00) ......0. "normal current"
1002 	 *    CHLF[1] "ADC current control"
1003 	 *                  =   0 (0x00) ......0. "normal current"
1004 	 */
1005 	{ 0x33, 0x19 },
1006 
1007 	/*
1008 	 * 34 VBLM "Blooming Control"
1009 	 *                  =  90 (0x5A) 01011010
1010 	 *    VBLM[7] "Hard soft reset switch"
1011 	 *                  =   0 (0x00) 0....... "Hard reset"
1012 	 *    VBLM[6:4] "Blooming voltage selection"
1013 	 *                  =   5 (0x05) .101....
1014 	 *    VBLM[3:0] "Sensor current control"
1015 	 *                  =  10 (0x0A) ....1010
1016 	 */
1017 	{ 0x34, 0x5a },
1018 
1019 	/*
1020 	 * 3B FREFB "Internal Reference Adjustment"
1021 	 *                  =   0 (0x00) 00000000
1022 	 *    FREFB[7:0] "Range"
1023 	 *                  =   0 (0x00) 00000000
1024 	 */
1025 	{ 0x3b, 0x00 },
1026 
1027 	/*
1028 	 * 33 CHLF "Current Control"
1029 	 *                  =   9 (0x09) 00001001
1030 	 *    CHLF[7:6] "Sensor current control"
1031 	 *                  =   0 (0x00) 00......
1032 	 *    CHLF[5] "Sensor current range control"
1033 	 *                  =   0 (0x00) ..0..... "normal range"
1034 	 *    CHLF[4] "Sensor current"
1035 	 *                  =   0 (0x00) ...0.... "normal current"
1036 	 *    CHLF[3] "Sensor buffer current control"
1037 	 *                  =   1 (0x01) ....1... "half current"
1038 	 *    CHLF[2] "Column buffer current control"
1039 	 *                  =   0 (0x00) .....0.. "normal current"
1040 	 *    CHLF[1] "Analog DSP current control"
1041 	 *                  =   0 (0x00) ......0. "normal current"
1042 	 *    CHLF[1] "ADC current control"
1043 	 *                  =   0 (0x00) ......0. "normal current"
1044 	 */
1045 	{ 0x33, 0x09 },
1046 
1047 	/*
1048 	 * 34 VBLM "Blooming Control"
1049 	 *                  =  80 (0x50) 01010000
1050 	 *    VBLM[7] "Hard soft reset switch"
1051 	 *                  =   0 (0x00) 0....... "Hard reset"
1052 	 *    VBLM[6:4] "Blooming voltage selection"
1053 	 *                  =   5 (0x05) .101....
1054 	 *    VBLM[3:0] "Sensor current control"
1055 	 *                  =   0 (0x00) ....0000
1056 	 */
1057 	{ 0x34, 0x50 },
1058 
1059 	/*
1060 	 * 12 COMH "Common Control H"
1061 	 *                  =  64 (0x40) 01000000
1062 	 *    COMH[7] "SRST"
1063 	 *                  =   0 (0x00) 0....... "No-op"
1064 	 *    COMH[6:4] "Resolution selection"
1065 	 *                  =   4 (0x04) .100.... "XGA"
1066 	 *    COMH[3] "Master slave selection"
1067 	 *                  =   0 (0x00) ....0... "Master mode"
1068 	 *    COMH[2] "Internal B/R channel option"
1069 	 *                  =   0 (0x00) .....0.. "B/R use same channel"
1070 	 *    COMH[1] "Color bar test pattern"
1071 	 *                  =   0 (0x00) ......0. "Off"
1072 	 *    COMH[0] "Reserved"
1073 	 *                  =   0 (0x00) .......0
1074 	 */
1075 	{ 0x12, 0x40 },
1076 
1077 	/*
1078 	 * 17 HREFST "Horizontal window start"
1079 	 *                  =  31 (0x1F) 00011111
1080 	 *    HREFST[7:0] "Horizontal window start, 8 MSBs"
1081 	 *                  =  31 (0x1F) 00011111
1082 	 */
1083 	{ 0x17, 0x1f },
1084 
1085 	/*
1086 	 * 18 HREFEND "Horizontal window end"
1087 	 *                  =  95 (0x5F) 01011111
1088 	 *    HREFEND[7:0] "Horizontal Window End, 8 MSBs"
1089 	 *                  =  95 (0x5F) 01011111
1090 	 */
1091 	{ 0x18, 0x5f },
1092 
1093 	/*
1094 	 * 19 VSTRT "Vertical window start"
1095 	 *                  =   0 (0x00) 00000000
1096 	 *    VSTRT[7:0] "Vertical Window Start, 8 MSBs"
1097 	 *                  =   0 (0x00) 00000000
1098 	 */
1099 	{ 0x19, 0x00 },
1100 
1101 	/*
1102 	 * 1A VEND "Vertical window end"
1103 	 *                  =  96 (0x60) 01100000
1104 	 *    VEND[7:0] "Vertical Window End, 8 MSBs"
1105 	 *                  =  96 (0x60) 01100000
1106 	 */
1107 	{ 0x1a, 0x60 },
1108 
1109 	/*
1110 	 * 32 COMM "Common Control M"
1111 	 *                  =  18 (0x12) 00010010
1112 	 *    COMM[7:6] "Pixel clock divide option"
1113 	 *                  =   0 (0x00) 00...... "/1"
1114 	 *    COMM[5:3] "Horizontal window end position, 3 LSBs"
1115 	 *                  =   2 (0x02) ..010...
1116 	 *    COMM[2:0] "Horizontal window start position, 3 LSBs"
1117 	 *                  =   2 (0x02) .....010
1118 	 */
1119 	{ 0x32, 0x12 },
1120 
1121 	/*
1122 	 * 03 COMA "Common Control A"
1123 	 *                  =  74 (0x4A) 01001010
1124 	 *    COMA[7:4] "AWB Update Threshold"
1125 	 *                  =   4 (0x04) 0100....
1126 	 *    COMA[3:2] "Vertical window end line control 2 LSBs"
1127 	 *                  =   2 (0x02) ....10..
1128 	 *    COMA[1:0] "Vertical window start line control 2 LSBs"
1129 	 *                  =   2 (0x02) ......10
1130 	 */
1131 	{ 0x03, 0x4a },
1132 
1133 	/*
1134 	 * 11 CLKRC "Clock Rate Control"
1135 	 *                  = 128 (0x80) 10000000
1136 	 *    CLKRC[7] "Internal frequency doublers on off seclection"
1137 	 *                  =   1 (0x01) 1....... "On"
1138 	 *    CLKRC[6] "Digital video master slave selection"
1139 	 *                  =   0 (0x00) .0...... "Master mode, sensor
1140 	 *                                         provides PCLK"
1141 	 *    CLKRC[5:0] "Clock divider { CLK = PCLK/(1+CLKRC[5:0]) }"
1142 	 *                  =   0 (0x00) ..000000
1143 	 */
1144 	{ 0x11, 0x80 },
1145 
1146 	/*
1147 	 * 12 COMH "Common Control H"
1148 	 *                  =   0 (0x00) 00000000
1149 	 *    COMH[7] "SRST"
1150 	 *                  =   0 (0x00) 0....... "No-op"
1151 	 *    COMH[6:4] "Resolution selection"
1152 	 *                  =   0 (0x00) .000.... "QXGA"
1153 	 *    COMH[3] "Master slave selection"
1154 	 *                  =   0 (0x00) ....0... "Master mode"
1155 	 *    COMH[2] "Internal B/R channel option"
1156 	 *                  =   0 (0x00) .....0.. "B/R use same channel"
1157 	 *    COMH[1] "Color bar test pattern"
1158 	 *                  =   0 (0x00) ......0. "Off"
1159 	 *    COMH[0] "Reserved"
1160 	 *                  =   0 (0x00) .......0
1161 	 */
1162 	{ 0x12, 0x00 },
1163 
1164 	/*
1165 	 * 12 COMH "Common Control H"
1166 	 *                  =  64 (0x40) 01000000
1167 	 *    COMH[7] "SRST"
1168 	 *                  =   0 (0x00) 0....... "No-op"
1169 	 *    COMH[6:4] "Resolution selection"
1170 	 *                  =   4 (0x04) .100.... "XGA"
1171 	 *    COMH[3] "Master slave selection"
1172 	 *                  =   0 (0x00) ....0... "Master mode"
1173 	 *    COMH[2] "Internal B/R channel option"
1174 	 *                  =   0 (0x00) .....0.. "B/R use same channel"
1175 	 *    COMH[1] "Color bar test pattern"
1176 	 *                  =   0 (0x00) ......0. "Off"
1177 	 *    COMH[0] "Reserved"
1178 	 *                  =   0 (0x00) .......0
1179 	 */
1180 	{ 0x12, 0x40 },
1181 
1182 	/*
1183 	 * 17 HREFST "Horizontal window start"
1184 	 *                  =  31 (0x1F) 00011111
1185 	 *    HREFST[7:0] "Horizontal window start, 8 MSBs"
1186 	 *                  =  31 (0x1F) 00011111
1187 	 */
1188 	{ 0x17, 0x1f },
1189 
1190 	/*
1191 	 * 18 HREFEND "Horizontal window end"
1192 	 *                  =  95 (0x5F) 01011111
1193 	 *    HREFEND[7:0] "Horizontal Window End, 8 MSBs"
1194 	 *                  =  95 (0x5F) 01011111
1195 	 */
1196 	{ 0x18, 0x5f },
1197 
1198 	/*
1199 	 * 19 VSTRT "Vertical window start"
1200 	 *                  =   0 (0x00) 00000000
1201 	 *    VSTRT[7:0] "Vertical Window Start, 8 MSBs"
1202 	 *                  =   0 (0x00) 00000000
1203 	 */
1204 	{ 0x19, 0x00 },
1205 
1206 	/*
1207 	 * 1A VEND "Vertical window end"
1208 	 *                  =  96 (0x60) 01100000
1209 	 *    VEND[7:0] "Vertical Window End, 8 MSBs"
1210 	 *                  =  96 (0x60) 01100000
1211 	 */
1212 	{ 0x1a, 0x60 },
1213 
1214 	/*
1215 	 * 32 COMM "Common Control M"
1216 	 *                  =  18 (0x12) 00010010
1217 	 *    COMM[7:6] "Pixel clock divide option"
1218 	 *                  =   0 (0x00) 00...... "/1"
1219 	 *    COMM[5:3] "Horizontal window end position, 3 LSBs"
1220 	 *                  =   2 (0x02) ..010...
1221 	 *    COMM[2:0] "Horizontal window start position, 3 LSBs"
1222 	 *                  =   2 (0x02) .....010
1223 	 */
1224 	{ 0x32, 0x12 },
1225 
1226 	/*
1227 	 * 03 COMA "Common Control A"
1228 	 *                  =  74 (0x4A) 01001010
1229 	 *    COMA[7:4] "AWB Update Threshold"
1230 	 *                  =   4 (0x04) 0100....
1231 	 *    COMA[3:2] "Vertical window end line control 2 LSBs"
1232 	 *                  =   2 (0x02) ....10..
1233 	 *    COMA[1:0] "Vertical window start line control 2 LSBs"
1234 	 *                  =   2 (0x02) ......10
1235 	 */
1236 	{ 0x03, 0x4a },
1237 
1238 	/*
1239 	 * 02 RED "Red Gain Control"
1240 	 *                  = 175 (0xAF) 10101111
1241 	 *    RED[7] "Action"
1242 	 *                  =   1 (0x01) 1....... "gain = 1/(1+bitrev([6:0]))"
1243 	 *    RED[6:0] "Value"
1244 	 *                  =  47 (0x2F) .0101111
1245 	 */
1246 	{ 0x02, 0xaf },
1247 
1248 	/*
1249 	 * 2D ADDVSL "VSYNC Pulse Width"
1250 	 *                  = 210 (0xD2) 11010010
1251 	 *    ADDVSL[7:0] "VSYNC pulse width, LSB"
1252 	 *                  = 210 (0xD2) 11010010
1253 	 */
1254 	{ 0x2d, 0xd2 },
1255 
1256 	/*
1257 	 * 00 GAIN          =  24 (0x18) 00011000
1258 	 *    GAIN[7:6] "Reserved"
1259 	 *                  =   0 (0x00) 00......
1260 	 *    GAIN[5] "Double"
1261 	 *                  =   0 (0x00) ..0..... "False"
1262 	 *    GAIN[4] "Double"
1263 	 *                  =   1 (0x01) ...1.... "True"
1264 	 *    GAIN[3:0] "Range"
1265 	 *                  =   8 (0x08) ....1000
1266 	 */
1267 	{ 0x00, 0x18 },
1268 
1269 	/*
1270 	 * 01 BLUE "Blue Gain Control"
1271 	 *                  = 240 (0xF0) 11110000
1272 	 *    BLUE[7] "Action"
1273 	 *                  =   1 (0x01) 1....... "gain = 1/(1+bitrev([6:0]))"
1274 	 *    BLUE[6:0] "Value"
1275 	 *                  = 112 (0x70) .1110000
1276 	 */
1277 	{ 0x01, 0xf0 },
1278 
1279 	/*
1280 	 * 10 AEC "Automatic Exposure Control"
1281 	 *                  =  10 (0x0A) 00001010
1282 	 *    AEC[7:0] "Automatic Exposure Control, 8 MSBs"
1283 	 *                  =  10 (0x0A) 00001010
1284 	 */
1285 	{ 0x10, 0x0a },
1286 
1287 	{ 0xe1, 0x67 },
1288 	{ 0xe3, 0x03 },
1289 	{ 0xe4, 0x26 },
1290 	{ 0xe5, 0x3e },
1291 	{ 0xf8, 0x01 },
1292 	{ 0xff, 0x01 },
1293 };
1294 
1295 static const struct ov_i2c_regvals norm_6x20[] = {
1296 	{ 0x12, 0x80 }, /* reset */
1297 	{ 0x11, 0x01 },
1298 	{ 0x03, 0x60 },
1299 	{ 0x05, 0x7f }, /* For when autoadjust is off */
1300 	{ 0x07, 0xa8 },
1301 	/* The ratio of 0x0c and 0x0d controls the white point */
1302 	{ 0x0c, 0x24 },
1303 	{ 0x0d, 0x24 },
1304 	{ 0x0f, 0x15 }, /* COMS */
1305 	{ 0x10, 0x75 }, /* AEC Exposure time */
1306 	{ 0x12, 0x24 }, /* Enable AGC */
1307 	{ 0x14, 0x04 },
1308 	/* 0x16: 0x06 helps frame stability with moving objects */
1309 	{ 0x16, 0x06 },
1310 /*	{ 0x20, 0x30 },  * Aperture correction enable */
1311 	{ 0x26, 0xb2 }, /* BLC enable */
1312 	/* 0x28: 0x05 Selects RGB format if RGB on */
1313 	{ 0x28, 0x05 },
1314 	{ 0x2a, 0x04 }, /* Disable framerate adjust */
1315 /*	{ 0x2b, 0xac },  * Framerate; Set 2a[7] first */
1316 	{ 0x2d, 0x85 },
1317 	{ 0x33, 0xa0 }, /* Color Processing Parameter */
1318 	{ 0x34, 0xd2 }, /* Max A/D range */
1319 	{ 0x38, 0x8b },
1320 	{ 0x39, 0x40 },
1321 
1322 	{ 0x3c, 0x39 }, /* Enable AEC mode changing */
1323 	{ 0x3c, 0x3c }, /* Change AEC mode */
1324 	{ 0x3c, 0x24 }, /* Disable AEC mode changing */
1325 
1326 	{ 0x3d, 0x80 },
1327 	/* These next two registers (0x4a, 0x4b) are undocumented.
1328 	 * They control the color balance */
1329 	{ 0x4a, 0x80 },
1330 	{ 0x4b, 0x80 },
1331 	{ 0x4d, 0xd2 }, /* This reduces noise a bit */
1332 	{ 0x4e, 0xc1 },
1333 	{ 0x4f, 0x04 },
1334 /* Do 50-53 have any effect? */
1335 /* Toggle 0x12[2] off and on here? */
1336 };
1337 
1338 static const struct ov_i2c_regvals norm_6x30[] = {
1339 	{ 0x12, 0x80 }, /* Reset */
1340 	{ 0x00, 0x1f }, /* Gain */
1341 	{ 0x01, 0x99 }, /* Blue gain */
1342 	{ 0x02, 0x7c }, /* Red gain */
1343 	{ 0x03, 0xc0 }, /* Saturation */
1344 	{ 0x05, 0x0a }, /* Contrast */
1345 	{ 0x06, 0x95 }, /* Brightness */
1346 	{ 0x07, 0x2d }, /* Sharpness */
1347 	{ 0x0c, 0x20 },
1348 	{ 0x0d, 0x20 },
1349 	{ 0x0e, 0xa0 }, /* Was 0x20, bit7 enables a 2x gain which we need */
1350 	{ 0x0f, 0x05 },
1351 	{ 0x10, 0x9a },
1352 	{ 0x11, 0x00 }, /* Pixel clock = fastest */
1353 	{ 0x12, 0x24 }, /* Enable AGC and AWB */
1354 	{ 0x13, 0x21 },
1355 	{ 0x14, 0x80 },
1356 	{ 0x15, 0x01 },
1357 	{ 0x16, 0x03 },
1358 	{ 0x17, 0x38 },
1359 	{ 0x18, 0xea },
1360 	{ 0x19, 0x04 },
1361 	{ 0x1a, 0x93 },
1362 	{ 0x1b, 0x00 },
1363 	{ 0x1e, 0xc4 },
1364 	{ 0x1f, 0x04 },
1365 	{ 0x20, 0x20 },
1366 	{ 0x21, 0x10 },
1367 	{ 0x22, 0x88 },
1368 	{ 0x23, 0xc0 }, /* Crystal circuit power level */
1369 	{ 0x25, 0x9a }, /* Increase AEC black ratio */
1370 	{ 0x26, 0xb2 }, /* BLC enable */
1371 	{ 0x27, 0xa2 },
1372 	{ 0x28, 0x00 },
1373 	{ 0x29, 0x00 },
1374 	{ 0x2a, 0x84 }, /* 60 Hz power */
1375 	{ 0x2b, 0xa8 }, /* 60 Hz power */
1376 	{ 0x2c, 0xa0 },
1377 	{ 0x2d, 0x95 }, /* Enable auto-brightness */
1378 	{ 0x2e, 0x88 },
1379 	{ 0x33, 0x26 },
1380 	{ 0x34, 0x03 },
1381 	{ 0x36, 0x8f },
1382 	{ 0x37, 0x80 },
1383 	{ 0x38, 0x83 },
1384 	{ 0x39, 0x80 },
1385 	{ 0x3a, 0x0f },
1386 	{ 0x3b, 0x3c },
1387 	{ 0x3c, 0x1a },
1388 	{ 0x3d, 0x80 },
1389 	{ 0x3e, 0x80 },
1390 	{ 0x3f, 0x0e },
1391 	{ 0x40, 0x00 }, /* White bal */
1392 	{ 0x41, 0x00 }, /* White bal */
1393 	{ 0x42, 0x80 },
1394 	{ 0x43, 0x3f }, /* White bal */
1395 	{ 0x44, 0x80 },
1396 	{ 0x45, 0x20 },
1397 	{ 0x46, 0x20 },
1398 	{ 0x47, 0x80 },
1399 	{ 0x48, 0x7f },
1400 	{ 0x49, 0x00 },
1401 	{ 0x4a, 0x00 },
1402 	{ 0x4b, 0x80 },
1403 	{ 0x4c, 0xd0 },
1404 	{ 0x4d, 0x10 }, /* U = 0.563u, V = 0.714v */
1405 	{ 0x4e, 0x40 },
1406 	{ 0x4f, 0x07 }, /* UV avg., col. killer: max */
1407 	{ 0x50, 0xff },
1408 	{ 0x54, 0x23 }, /* Max AGC gain: 18dB */
1409 	{ 0x55, 0xff },
1410 	{ 0x56, 0x12 },
1411 	{ 0x57, 0x81 },
1412 	{ 0x58, 0x75 },
1413 	{ 0x59, 0x01 }, /* AGC dark current comp.: +1 */
1414 	{ 0x5a, 0x2c },
1415 	{ 0x5b, 0x0f }, /* AWB chrominance levels */
1416 	{ 0x5c, 0x10 },
1417 	{ 0x3d, 0x80 },
1418 	{ 0x27, 0xa6 },
1419 	{ 0x12, 0x20 }, /* Toggle AWB */
1420 	{ 0x12, 0x24 },
1421 };
1422 
1423 /* Lawrence Glaister <lg@jfm.bc.ca> reports:
1424  *
1425  * Register 0x0f in the 7610 has the following effects:
1426  *
1427  * 0x85 (AEC method 1): Best overall, good contrast range
1428  * 0x45 (AEC method 2): Very overexposed
1429  * 0xa5 (spec sheet default): Ok, but the black level is
1430  *	shifted resulting in loss of contrast
1431  * 0x05 (old driver setting): very overexposed, too much
1432  *	contrast
1433  */
1434 static const struct ov_i2c_regvals norm_7610[] = {
1435 	{ 0x10, 0xff },
1436 	{ 0x16, 0x06 },
1437 	{ 0x28, 0x24 },
1438 	{ 0x2b, 0xac },
1439 	{ 0x12, 0x00 },
1440 	{ 0x38, 0x81 },
1441 	{ 0x28, 0x24 },	/* 0c */
1442 	{ 0x0f, 0x85 },	/* lg's setting */
1443 	{ 0x15, 0x01 },
1444 	{ 0x20, 0x1c },
1445 	{ 0x23, 0x2a },
1446 	{ 0x24, 0x10 },
1447 	{ 0x25, 0x8a },
1448 	{ 0x26, 0xa2 },
1449 	{ 0x27, 0xc2 },
1450 	{ 0x2a, 0x04 },
1451 	{ 0x2c, 0xfe },
1452 	{ 0x2d, 0x93 },
1453 	{ 0x30, 0x71 },
1454 	{ 0x31, 0x60 },
1455 	{ 0x32, 0x26 },
1456 	{ 0x33, 0x20 },
1457 	{ 0x34, 0x48 },
1458 	{ 0x12, 0x24 },
1459 	{ 0x11, 0x01 },
1460 	{ 0x0c, 0x24 },
1461 	{ 0x0d, 0x24 },
1462 };
1463 
1464 static const struct ov_i2c_regvals norm_7620[] = {
1465 	{ 0x12, 0x80 },		/* reset */
1466 	{ 0x00, 0x00 },		/* gain */
1467 	{ 0x01, 0x80 },		/* blue gain */
1468 	{ 0x02, 0x80 },		/* red gain */
1469 	{ 0x03, 0xc0 },		/* OV7670_R03_VREF */
1470 	{ 0x06, 0x60 },
1471 	{ 0x07, 0x00 },
1472 	{ 0x0c, 0x24 },
1473 	{ 0x0c, 0x24 },
1474 	{ 0x0d, 0x24 },
1475 	{ 0x11, 0x01 },
1476 	{ 0x12, 0x24 },
1477 	{ 0x13, 0x01 },
1478 	{ 0x14, 0x84 },
1479 	{ 0x15, 0x01 },
1480 	{ 0x16, 0x03 },
1481 	{ 0x17, 0x2f },
1482 	{ 0x18, 0xcf },
1483 	{ 0x19, 0x06 },
1484 	{ 0x1a, 0xf5 },
1485 	{ 0x1b, 0x00 },
1486 	{ 0x20, 0x18 },
1487 	{ 0x21, 0x80 },
1488 	{ 0x22, 0x80 },
1489 	{ 0x23, 0x00 },
1490 	{ 0x26, 0xa2 },
1491 	{ 0x27, 0xea },
1492 	{ 0x28, 0x22 }, /* Was 0x20, bit1 enables a 2x gain which we need */
1493 	{ 0x29, 0x00 },
1494 	{ 0x2a, 0x10 },
1495 	{ 0x2b, 0x00 },
1496 	{ 0x2c, 0x88 },
1497 	{ 0x2d, 0x91 },
1498 	{ 0x2e, 0x80 },
1499 	{ 0x2f, 0x44 },
1500 	{ 0x60, 0x27 },
1501 	{ 0x61, 0x02 },
1502 	{ 0x62, 0x5f },
1503 	{ 0x63, 0xd5 },
1504 	{ 0x64, 0x57 },
1505 	{ 0x65, 0x83 },
1506 	{ 0x66, 0x55 },
1507 	{ 0x67, 0x92 },
1508 	{ 0x68, 0xcf },
1509 	{ 0x69, 0x76 },
1510 	{ 0x6a, 0x22 },
1511 	{ 0x6b, 0x00 },
1512 	{ 0x6c, 0x02 },
1513 	{ 0x6d, 0x44 },
1514 	{ 0x6e, 0x80 },
1515 	{ 0x6f, 0x1d },
1516 	{ 0x70, 0x8b },
1517 	{ 0x71, 0x00 },
1518 	{ 0x72, 0x14 },
1519 	{ 0x73, 0x54 },
1520 	{ 0x74, 0x00 },
1521 	{ 0x75, 0x8e },
1522 	{ 0x76, 0x00 },
1523 	{ 0x77, 0xff },
1524 	{ 0x78, 0x80 },
1525 	{ 0x79, 0x80 },
1526 	{ 0x7a, 0x80 },
1527 	{ 0x7b, 0xe2 },
1528 	{ 0x7c, 0x00 },
1529 };
1530 
1531 /* 7640 and 7648. The defaults should be OK for most registers. */
1532 static const struct ov_i2c_regvals norm_7640[] = {
1533 	{ 0x12, 0x80 },
1534 	{ 0x12, 0x14 },
1535 };
1536 
1537 static const struct ov_regvals init_519_ov7660[] = {
1538 	{ 0x5d,	0x03 }, /* Turn off suspend mode */
1539 	{ 0x53,	0x9b }, /* 0x9f enables the (unused) microcontroller */
1540 	{ 0x54,	0x0f }, /* bit2 (jpeg enable) */
1541 	{ 0xa2,	0x20 }, /* a2-a5 are undocumented */
1542 	{ 0xa3,	0x18 },
1543 	{ 0xa4,	0x04 },
1544 	{ 0xa5,	0x28 },
1545 	{ 0x37,	0x00 },	/* SetUsbInit */
1546 	{ 0x55,	0x02 }, /* 4.096 Mhz audio clock */
1547 	/* Enable both fields, YUV Input, disable defect comp (why?) */
1548 	{ 0x20,	0x0c },	/* 0x0d does U <-> V swap */
1549 	{ 0x21,	0x38 },
1550 	{ 0x22,	0x1d },
1551 	{ 0x17,	0x50 }, /* undocumented */
1552 	{ 0x37,	0x00 }, /* undocumented */
1553 	{ 0x40,	0xff }, /* I2C timeout counter */
1554 	{ 0x46,	0x00 }, /* I2C clock prescaler */
1555 };
1556 static const struct ov_i2c_regvals norm_7660[] = {
1557 	{OV7670_R12_COM7, OV7670_COM7_RESET},
1558 	{OV7670_R11_CLKRC, 0x81},
1559 	{0x92, 0x00},			/* DM_LNL */
1560 	{0x93, 0x00},			/* DM_LNH */
1561 	{0x9d, 0x4c},			/* BD50ST */
1562 	{0x9e, 0x3f},			/* BD60ST */
1563 	{OV7670_R3B_COM11, 0x02},
1564 	{OV7670_R13_COM8, 0xf5},
1565 	{OV7670_R10_AECH, 0x00},
1566 	{OV7670_R00_GAIN, 0x00},
1567 	{OV7670_R01_BLUE, 0x7c},
1568 	{OV7670_R02_RED, 0x9d},
1569 	{OV7670_R12_COM7, 0x00},
1570 	{OV7670_R04_COM1, 00},
1571 	{OV7670_R18_HSTOP, 0x01},
1572 	{OV7670_R17_HSTART, 0x13},
1573 	{OV7670_R32_HREF, 0x92},
1574 	{OV7670_R19_VSTART, 0x02},
1575 	{OV7670_R1A_VSTOP, 0x7a},
1576 	{OV7670_R03_VREF, 0x00},
1577 	{OV7670_R0E_COM5, 0x04},
1578 	{OV7670_R0F_COM6, 0x62},
1579 	{OV7670_R15_COM10, 0x00},
1580 	{0x16, 0x02},			/* RSVD */
1581 	{0x1b, 0x00},			/* PSHFT */
1582 	{OV7670_R1E_MVFP, 0x01},
1583 	{0x29, 0x3c},			/* RSVD */
1584 	{0x33, 0x00},			/* CHLF */
1585 	{0x34, 0x07},			/* ARBLM */
1586 	{0x35, 0x84},			/* RSVD */
1587 	{0x36, 0x00},			/* RSVD */
1588 	{0x37, 0x04},			/* ADC */
1589 	{0x39, 0x43},			/* OFON */
1590 	{OV7670_R3A_TSLB, 0x00},
1591 	{OV7670_R3C_COM12, 0x6c},
1592 	{OV7670_R3D_COM13, 0x98},
1593 	{OV7670_R3F_EDGE, 0x23},
1594 	{OV7670_R40_COM15, 0xc1},
1595 	{OV7670_R41_COM16, 0x22},
1596 	{0x6b, 0x0a},			/* DBLV */
1597 	{0xa1, 0x08},			/* RSVD */
1598 	{0x69, 0x80},			/* HV */
1599 	{0x43, 0xf0},			/* RSVD.. */
1600 	{0x44, 0x10},
1601 	{0x45, 0x78},
1602 	{0x46, 0xa8},
1603 	{0x47, 0x60},
1604 	{0x48, 0x80},
1605 	{0x59, 0xba},
1606 	{0x5a, 0x9a},
1607 	{0x5b, 0x22},
1608 	{0x5c, 0xb9},
1609 	{0x5d, 0x9b},
1610 	{0x5e, 0x10},
1611 	{0x5f, 0xe0},
1612 	{0x60, 0x85},
1613 	{0x61, 0x60},
1614 	{0x9f, 0x9d},			/* RSVD */
1615 	{0xa0, 0xa0},			/* DSPC2 */
1616 	{0x4f, 0x60},			/* matrix */
1617 	{0x50, 0x64},
1618 	{0x51, 0x04},
1619 	{0x52, 0x18},
1620 	{0x53, 0x3c},
1621 	{0x54, 0x54},
1622 	{0x55, 0x40},
1623 	{0x56, 0x40},
1624 	{0x57, 0x40},
1625 	{0x58, 0x0d},			/* matrix sign */
1626 	{0x8b, 0xcc},			/* RSVD */
1627 	{0x8c, 0xcc},
1628 	{0x8d, 0xcf},
1629 	{0x6c, 0x40},			/* gamma curve */
1630 	{0x6d, 0xe0},
1631 	{0x6e, 0xa0},
1632 	{0x6f, 0x80},
1633 	{0x70, 0x70},
1634 	{0x71, 0x80},
1635 	{0x72, 0x60},
1636 	{0x73, 0x60},
1637 	{0x74, 0x50},
1638 	{0x75, 0x40},
1639 	{0x76, 0x38},
1640 	{0x77, 0x3c},
1641 	{0x78, 0x32},
1642 	{0x79, 0x1a},
1643 	{0x7a, 0x28},
1644 	{0x7b, 0x24},
1645 	{0x7c, 0x04},			/* gamma curve */
1646 	{0x7d, 0x12},
1647 	{0x7e, 0x26},
1648 	{0x7f, 0x46},
1649 	{0x80, 0x54},
1650 	{0x81, 0x64},
1651 	{0x82, 0x70},
1652 	{0x83, 0x7c},
1653 	{0x84, 0x86},
1654 	{0x85, 0x8e},
1655 	{0x86, 0x9c},
1656 	{0x87, 0xab},
1657 	{0x88, 0xc4},
1658 	{0x89, 0xd1},
1659 	{0x8a, 0xe5},
1660 	{OV7670_R14_COM9, 0x1e},
1661 	{OV7670_R24_AEW, 0x80},
1662 	{OV7670_R25_AEB, 0x72},
1663 	{OV7670_R26_VPT, 0xb3},
1664 	{0x62, 0x80},			/* LCC1 */
1665 	{0x63, 0x80},			/* LCC2 */
1666 	{0x64, 0x06},			/* LCC3 */
1667 	{0x65, 0x00},			/* LCC4 */
1668 	{0x66, 0x01},			/* LCC5 */
1669 	{0x94, 0x0e},			/* RSVD.. */
1670 	{0x95, 0x14},
1671 	{OV7670_R13_COM8, OV7670_COM8_FASTAEC
1672 			| OV7670_COM8_AECSTEP
1673 			| OV7670_COM8_BFILT
1674 			| 0x10
1675 			| OV7670_COM8_AGC
1676 			| OV7670_COM8_AWB
1677 			| OV7670_COM8_AEC},
1678 	{0xa1, 0xc8}
1679 };
1680 static const struct ov_i2c_regvals norm_9600[] = {
1681 	{0x12, 0x80},
1682 	{0x0c, 0x28},
1683 	{0x11, 0x80},
1684 	{0x13, 0xb5},
1685 	{0x14, 0x3e},
1686 	{0x1b, 0x04},
1687 	{0x24, 0xb0},
1688 	{0x25, 0x90},
1689 	{0x26, 0x94},
1690 	{0x35, 0x90},
1691 	{0x37, 0x07},
1692 	{0x38, 0x08},
1693 	{0x01, 0x8e},
1694 	{0x02, 0x85}
1695 };
1696 
1697 /* 7670. Defaults taken from OmniVision provided data,
1698 *  as provided by Jonathan Corbet of OLPC		*/
1699 static const struct ov_i2c_regvals norm_7670[] = {
1700 	{ OV7670_R12_COM7, OV7670_COM7_RESET },
1701 	{ OV7670_R3A_TSLB, 0x04 },		/* OV */
1702 	{ OV7670_R12_COM7, OV7670_COM7_FMT_VGA }, /* VGA */
1703 	{ OV7670_R11_CLKRC, 0x01 },
1704 /*
1705  * Set the hardware window.  These values from OV don't entirely
1706  * make sense - hstop is less than hstart.  But they work...
1707  */
1708 	{ OV7670_R17_HSTART, 0x13 },
1709 	{ OV7670_R18_HSTOP, 0x01 },
1710 	{ OV7670_R32_HREF, 0xb6 },
1711 	{ OV7670_R19_VSTART, 0x02 },
1712 	{ OV7670_R1A_VSTOP, 0x7a },
1713 	{ OV7670_R03_VREF, 0x0a },
1714 
1715 	{ OV7670_R0C_COM3, 0x00 },
1716 	{ OV7670_R3E_COM14, 0x00 },
1717 /* Mystery scaling numbers */
1718 	{ 0x70, 0x3a },
1719 	{ 0x71, 0x35 },
1720 	{ 0x72, 0x11 },
1721 	{ 0x73, 0xf0 },
1722 	{ 0xa2, 0x02 },
1723 /*	{ OV7670_R15_COM10, 0x0 }, */
1724 
1725 /* Gamma curve values */
1726 	{ 0x7a, 0x20 },
1727 	{ 0x7b, 0x10 },
1728 	{ 0x7c, 0x1e },
1729 	{ 0x7d, 0x35 },
1730 	{ 0x7e, 0x5a },
1731 	{ 0x7f, 0x69 },
1732 	{ 0x80, 0x76 },
1733 	{ 0x81, 0x80 },
1734 	{ 0x82, 0x88 },
1735 	{ 0x83, 0x8f },
1736 	{ 0x84, 0x96 },
1737 	{ 0x85, 0xa3 },
1738 	{ 0x86, 0xaf },
1739 	{ 0x87, 0xc4 },
1740 	{ 0x88, 0xd7 },
1741 	{ 0x89, 0xe8 },
1742 
1743 /* AGC and AEC parameters.  Note we start by disabling those features,
1744    then turn them only after tweaking the values. */
1745 	{ OV7670_R13_COM8, OV7670_COM8_FASTAEC
1746 			 | OV7670_COM8_AECSTEP
1747 			 | OV7670_COM8_BFILT },
1748 	{ OV7670_R00_GAIN, 0x00 },
1749 	{ OV7670_R10_AECH, 0x00 },
1750 	{ OV7670_R0D_COM4, 0x40 }, /* magic reserved bit */
1751 	{ OV7670_R14_COM9, 0x18 }, /* 4x gain + magic rsvd bit */
1752 	{ OV7670_RA5_BD50MAX, 0x05 },
1753 	{ OV7670_RAB_BD60MAX, 0x07 },
1754 	{ OV7670_R24_AEW, 0x95 },
1755 	{ OV7670_R25_AEB, 0x33 },
1756 	{ OV7670_R26_VPT, 0xe3 },
1757 	{ OV7670_R9F_HAECC1, 0x78 },
1758 	{ OV7670_RA0_HAECC2, 0x68 },
1759 	{ 0xa1, 0x03 }, /* magic */
1760 	{ OV7670_RA6_HAECC3, 0xd8 },
1761 	{ OV7670_RA7_HAECC4, 0xd8 },
1762 	{ OV7670_RA8_HAECC5, 0xf0 },
1763 	{ OV7670_RA9_HAECC6, 0x90 },
1764 	{ OV7670_RAA_HAECC7, 0x94 },
1765 	{ OV7670_R13_COM8, OV7670_COM8_FASTAEC
1766 			| OV7670_COM8_AECSTEP
1767 			| OV7670_COM8_BFILT
1768 			| OV7670_COM8_AGC
1769 			| OV7670_COM8_AEC },
1770 
1771 /* Almost all of these are magic "reserved" values.  */
1772 	{ OV7670_R0E_COM5, 0x61 },
1773 	{ OV7670_R0F_COM6, 0x4b },
1774 	{ 0x16, 0x02 },
1775 	{ OV7670_R1E_MVFP, 0x07 },
1776 	{ 0x21, 0x02 },
1777 	{ 0x22, 0x91 },
1778 	{ 0x29, 0x07 },
1779 	{ 0x33, 0x0b },
1780 	{ 0x35, 0x0b },
1781 	{ 0x37, 0x1d },
1782 	{ 0x38, 0x71 },
1783 	{ 0x39, 0x2a },
1784 	{ OV7670_R3C_COM12, 0x78 },
1785 	{ 0x4d, 0x40 },
1786 	{ 0x4e, 0x20 },
1787 	{ OV7670_R69_GFIX, 0x00 },
1788 	{ 0x6b, 0x4a },
1789 	{ 0x74, 0x10 },
1790 	{ 0x8d, 0x4f },
1791 	{ 0x8e, 0x00 },
1792 	{ 0x8f, 0x00 },
1793 	{ 0x90, 0x00 },
1794 	{ 0x91, 0x00 },
1795 	{ 0x96, 0x00 },
1796 	{ 0x9a, 0x00 },
1797 	{ 0xb0, 0x84 },
1798 	{ 0xb1, 0x0c },
1799 	{ 0xb2, 0x0e },
1800 	{ 0xb3, 0x82 },
1801 	{ 0xb8, 0x0a },
1802 
1803 /* More reserved magic, some of which tweaks white balance */
1804 	{ 0x43, 0x0a },
1805 	{ 0x44, 0xf0 },
1806 	{ 0x45, 0x34 },
1807 	{ 0x46, 0x58 },
1808 	{ 0x47, 0x28 },
1809 	{ 0x48, 0x3a },
1810 	{ 0x59, 0x88 },
1811 	{ 0x5a, 0x88 },
1812 	{ 0x5b, 0x44 },
1813 	{ 0x5c, 0x67 },
1814 	{ 0x5d, 0x49 },
1815 	{ 0x5e, 0x0e },
1816 	{ 0x6c, 0x0a },
1817 	{ 0x6d, 0x55 },
1818 	{ 0x6e, 0x11 },
1819 	{ 0x6f, 0x9f },			/* "9e for advance AWB" */
1820 	{ 0x6a, 0x40 },
1821 	{ OV7670_R01_BLUE, 0x40 },
1822 	{ OV7670_R02_RED, 0x60 },
1823 	{ OV7670_R13_COM8, OV7670_COM8_FASTAEC
1824 			| OV7670_COM8_AECSTEP
1825 			| OV7670_COM8_BFILT
1826 			| OV7670_COM8_AGC
1827 			| OV7670_COM8_AEC
1828 			| OV7670_COM8_AWB },
1829 
1830 /* Matrix coefficients */
1831 	{ 0x4f, 0x80 },
1832 	{ 0x50, 0x80 },
1833 	{ 0x51, 0x00 },
1834 	{ 0x52, 0x22 },
1835 	{ 0x53, 0x5e },
1836 	{ 0x54, 0x80 },
1837 	{ 0x58, 0x9e },
1838 
1839 	{ OV7670_R41_COM16, OV7670_COM16_AWBGAIN },
1840 	{ OV7670_R3F_EDGE, 0x00 },
1841 	{ 0x75, 0x05 },
1842 	{ 0x76, 0xe1 },
1843 	{ 0x4c, 0x00 },
1844 	{ 0x77, 0x01 },
1845 	{ OV7670_R3D_COM13, OV7670_COM13_GAMMA
1846 			  | OV7670_COM13_UVSAT
1847 			  | 2},		/* was 3 */
1848 	{ 0x4b, 0x09 },
1849 	{ 0xc9, 0x60 },
1850 	{ OV7670_R41_COM16, 0x38 },
1851 	{ 0x56, 0x40 },
1852 
1853 	{ 0x34, 0x11 },
1854 	{ OV7670_R3B_COM11, OV7670_COM11_EXP|OV7670_COM11_HZAUTO },
1855 	{ 0xa4, 0x88 },
1856 	{ 0x96, 0x00 },
1857 	{ 0x97, 0x30 },
1858 	{ 0x98, 0x20 },
1859 	{ 0x99, 0x30 },
1860 	{ 0x9a, 0x84 },
1861 	{ 0x9b, 0x29 },
1862 	{ 0x9c, 0x03 },
1863 	{ 0x9d, 0x4c },
1864 	{ 0x9e, 0x3f },
1865 	{ 0x78, 0x04 },
1866 
1867 /* Extra-weird stuff.  Some sort of multiplexor register */
1868 	{ 0x79, 0x01 },
1869 	{ 0xc8, 0xf0 },
1870 	{ 0x79, 0x0f },
1871 	{ 0xc8, 0x00 },
1872 	{ 0x79, 0x10 },
1873 	{ 0xc8, 0x7e },
1874 	{ 0x79, 0x0a },
1875 	{ 0xc8, 0x80 },
1876 	{ 0x79, 0x0b },
1877 	{ 0xc8, 0x01 },
1878 	{ 0x79, 0x0c },
1879 	{ 0xc8, 0x0f },
1880 	{ 0x79, 0x0d },
1881 	{ 0xc8, 0x20 },
1882 	{ 0x79, 0x09 },
1883 	{ 0xc8, 0x80 },
1884 	{ 0x79, 0x02 },
1885 	{ 0xc8, 0xc0 },
1886 	{ 0x79, 0x03 },
1887 	{ 0xc8, 0x40 },
1888 	{ 0x79, 0x05 },
1889 	{ 0xc8, 0x30 },
1890 	{ 0x79, 0x26 },
1891 };
1892 
1893 static const struct ov_i2c_regvals norm_8610[] = {
1894 	{ 0x12, 0x80 },
1895 	{ 0x00, 0x00 },
1896 	{ 0x01, 0x80 },
1897 	{ 0x02, 0x80 },
1898 	{ 0x03, 0xc0 },
1899 	{ 0x04, 0x30 },
1900 	{ 0x05, 0x30 }, /* was 0x10, new from windrv 090403 */
1901 	{ 0x06, 0x70 }, /* was 0x80, new from windrv 090403 */
1902 	{ 0x0a, 0x86 },
1903 	{ 0x0b, 0xb0 },
1904 	{ 0x0c, 0x20 },
1905 	{ 0x0d, 0x20 },
1906 	{ 0x11, 0x01 },
1907 	{ 0x12, 0x25 },
1908 	{ 0x13, 0x01 },
1909 	{ 0x14, 0x04 },
1910 	{ 0x15, 0x01 }, /* Lin and Win think different about UV order */
1911 	{ 0x16, 0x03 },
1912 	{ 0x17, 0x38 }, /* was 0x2f, new from windrv 090403 */
1913 	{ 0x18, 0xea }, /* was 0xcf, new from windrv 090403 */
1914 	{ 0x19, 0x02 }, /* was 0x06, new from windrv 090403 */
1915 	{ 0x1a, 0xf5 },
1916 	{ 0x1b, 0x00 },
1917 	{ 0x20, 0xd0 }, /* was 0x90, new from windrv 090403 */
1918 	{ 0x23, 0xc0 }, /* was 0x00, new from windrv 090403 */
1919 	{ 0x24, 0x30 }, /* was 0x1d, new from windrv 090403 */
1920 	{ 0x25, 0x50 }, /* was 0x57, new from windrv 090403 */
1921 	{ 0x26, 0xa2 },
1922 	{ 0x27, 0xea },
1923 	{ 0x28, 0x00 },
1924 	{ 0x29, 0x00 },
1925 	{ 0x2a, 0x80 },
1926 	{ 0x2b, 0xc8 }, /* was 0xcc, new from windrv 090403 */
1927 	{ 0x2c, 0xac },
1928 	{ 0x2d, 0x45 }, /* was 0xd5, new from windrv 090403 */
1929 	{ 0x2e, 0x80 },
1930 	{ 0x2f, 0x14 }, /* was 0x01, new from windrv 090403 */
1931 	{ 0x4c, 0x00 },
1932 	{ 0x4d, 0x30 }, /* was 0x10, new from windrv 090403 */
1933 	{ 0x60, 0x02 }, /* was 0x01, new from windrv 090403 */
1934 	{ 0x61, 0x00 }, /* was 0x09, new from windrv 090403 */
1935 	{ 0x62, 0x5f }, /* was 0xd7, new from windrv 090403 */
1936 	{ 0x63, 0xff },
1937 	{ 0x64, 0x53 }, /* new windrv 090403 says 0x57,
1938 			 * maybe that's wrong */
1939 	{ 0x65, 0x00 },
1940 	{ 0x66, 0x55 },
1941 	{ 0x67, 0xb0 },
1942 	{ 0x68, 0xc0 }, /* was 0xaf, new from windrv 090403 */
1943 	{ 0x69, 0x02 },
1944 	{ 0x6a, 0x22 },
1945 	{ 0x6b, 0x00 },
1946 	{ 0x6c, 0x99 }, /* was 0x80, old windrv says 0x00, but
1947 			 * deleting bit7 colors the first images red */
1948 	{ 0x6d, 0x11 }, /* was 0x00, new from windrv 090403 */
1949 	{ 0x6e, 0x11 }, /* was 0x00, new from windrv 090403 */
1950 	{ 0x6f, 0x01 },
1951 	{ 0x70, 0x8b },
1952 	{ 0x71, 0x00 },
1953 	{ 0x72, 0x14 },
1954 	{ 0x73, 0x54 },
1955 	{ 0x74, 0x00 },/* 0x60? - was 0x00, new from windrv 090403 */
1956 	{ 0x75, 0x0e },
1957 	{ 0x76, 0x02 }, /* was 0x02, new from windrv 090403 */
1958 	{ 0x77, 0xff },
1959 	{ 0x78, 0x80 },
1960 	{ 0x79, 0x80 },
1961 	{ 0x7a, 0x80 },
1962 	{ 0x7b, 0x10 }, /* was 0x13, new from windrv 090403 */
1963 	{ 0x7c, 0x00 },
1964 	{ 0x7d, 0x08 }, /* was 0x09, new from windrv 090403 */
1965 	{ 0x7e, 0x08 }, /* was 0xc0, new from windrv 090403 */
1966 	{ 0x7f, 0xfb },
1967 	{ 0x80, 0x28 },
1968 	{ 0x81, 0x00 },
1969 	{ 0x82, 0x23 },
1970 	{ 0x83, 0x0b },
1971 	{ 0x84, 0x00 },
1972 	{ 0x85, 0x62 }, /* was 0x61, new from windrv 090403 */
1973 	{ 0x86, 0xc9 },
1974 	{ 0x87, 0x00 },
1975 	{ 0x88, 0x00 },
1976 	{ 0x89, 0x01 },
1977 	{ 0x12, 0x20 },
1978 	{ 0x12, 0x25 }, /* was 0x24, new from windrv 090403 */
1979 };
1980 
ov7670_abs_to_sm(unsigned char v)1981 static unsigned char ov7670_abs_to_sm(unsigned char v)
1982 {
1983 	if (v > 127)
1984 		return v & 0x7f;
1985 	return (128 - v) | 0x80;
1986 }
1987 
1988 /* Write a OV519 register */
reg_w(struct sd * sd,u16 index,u16 value)1989 static void reg_w(struct sd *sd, u16 index, u16 value)
1990 {
1991 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
1992 	int ret, req = 0;
1993 
1994 	if (sd->gspca_dev.usb_err < 0)
1995 		return;
1996 
1997 	/* Avoid things going to fast for the bridge with a xhci host */
1998 	udelay(150);
1999 
2000 	switch (sd->bridge) {
2001 	case BRIDGE_OV511:
2002 	case BRIDGE_OV511PLUS:
2003 		req = 2;
2004 		break;
2005 	case BRIDGE_OVFX2:
2006 		req = 0x0a;
2007 		fallthrough;
2008 	case BRIDGE_W9968CF:
2009 		gspca_dbg(gspca_dev, D_USBO, "SET %02x %04x %04x\n",
2010 			  req, value, index);
2011 		ret = usb_control_msg(sd->gspca_dev.dev,
2012 			usb_sndctrlpipe(sd->gspca_dev.dev, 0),
2013 			req,
2014 			USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2015 			value, index, NULL, 0, 500);
2016 		goto leave;
2017 	default:
2018 		req = 1;
2019 	}
2020 
2021 	gspca_dbg(gspca_dev, D_USBO, "SET %02x 0000 %04x %02x\n",
2022 		  req, index, value);
2023 	sd->gspca_dev.usb_buf[0] = value;
2024 	ret = usb_control_msg(sd->gspca_dev.dev,
2025 			usb_sndctrlpipe(sd->gspca_dev.dev, 0),
2026 			req,
2027 			USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2028 			0, index,
2029 			sd->gspca_dev.usb_buf, 1, 500);
2030 leave:
2031 	if (ret < 0) {
2032 		gspca_err(gspca_dev, "reg_w %02x failed %d\n", index, ret);
2033 		sd->gspca_dev.usb_err = ret;
2034 		return;
2035 	}
2036 }
2037 
2038 /* Read from a OV519 register, note not valid for the w9968cf!! */
2039 /* returns: negative is error, pos or zero is data */
reg_r(struct sd * sd,u16 index)2040 static int reg_r(struct sd *sd, u16 index)
2041 {
2042 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2043 	int ret;
2044 	int req;
2045 
2046 	if (sd->gspca_dev.usb_err < 0)
2047 		return -1;
2048 
2049 	switch (sd->bridge) {
2050 	case BRIDGE_OV511:
2051 	case BRIDGE_OV511PLUS:
2052 		req = 3;
2053 		break;
2054 	case BRIDGE_OVFX2:
2055 		req = 0x0b;
2056 		break;
2057 	default:
2058 		req = 1;
2059 	}
2060 
2061 	/* Avoid things going to fast for the bridge with a xhci host */
2062 	udelay(150);
2063 	ret = usb_control_msg(sd->gspca_dev.dev,
2064 			usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
2065 			req,
2066 			USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2067 			0, index, sd->gspca_dev.usb_buf, 1, 500);
2068 
2069 	if (ret >= 0) {
2070 		ret = sd->gspca_dev.usb_buf[0];
2071 		gspca_dbg(gspca_dev, D_USBI, "GET %02x 0000 %04x %02x\n",
2072 			  req, index, ret);
2073 	} else {
2074 		gspca_err(gspca_dev, "reg_r %02x failed %d\n", index, ret);
2075 		sd->gspca_dev.usb_err = ret;
2076 		/*
2077 		 * Make sure the result is zeroed to avoid uninitialized
2078 		 * values.
2079 		 */
2080 		gspca_dev->usb_buf[0] = 0;
2081 	}
2082 
2083 	return ret;
2084 }
2085 
2086 /* Read 8 values from a OV519 register */
reg_r8(struct sd * sd,u16 index)2087 static int reg_r8(struct sd *sd,
2088 		  u16 index)
2089 {
2090 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2091 	int ret;
2092 
2093 	if (sd->gspca_dev.usb_err < 0)
2094 		return -1;
2095 
2096 	/* Avoid things going to fast for the bridge with a xhci host */
2097 	udelay(150);
2098 	ret = usb_control_msg(sd->gspca_dev.dev,
2099 			usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
2100 			1,			/* REQ_IO */
2101 			USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2102 			0, index, sd->gspca_dev.usb_buf, 8, 500);
2103 
2104 	if (ret >= 0) {
2105 		ret = sd->gspca_dev.usb_buf[0];
2106 	} else {
2107 		gspca_err(gspca_dev, "reg_r8 %02x failed %d\n", index, ret);
2108 		sd->gspca_dev.usb_err = ret;
2109 		/*
2110 		 * Make sure the buffer is zeroed to avoid uninitialized
2111 		 * values.
2112 		 */
2113 		memset(gspca_dev->usb_buf, 0, 8);
2114 	}
2115 
2116 	return ret;
2117 }
2118 
2119 /*
2120  * Writes bits at positions specified by mask to an OV51x reg. Bits that are in
2121  * the same position as 1's in "mask" are cleared and set to "value". Bits
2122  * that are in the same position as 0's in "mask" are preserved, regardless
2123  * of their respective state in "value".
2124  */
reg_w_mask(struct sd * sd,u16 index,u8 value,u8 mask)2125 static void reg_w_mask(struct sd *sd,
2126 			u16 index,
2127 			u8 value,
2128 			u8 mask)
2129 {
2130 	int ret;
2131 	u8 oldval;
2132 
2133 	if (mask != 0xff) {
2134 		value &= mask;			/* Enforce mask on value */
2135 		ret = reg_r(sd, index);
2136 		if (ret < 0)
2137 			return;
2138 
2139 		oldval = ret & ~mask;		/* Clear the masked bits */
2140 		value |= oldval;		/* Set the desired bits */
2141 	}
2142 	reg_w(sd, index, value);
2143 }
2144 
2145 /*
2146  * Writes multiple (n) byte value to a single register. Only valid with certain
2147  * registers (0x30 and 0xc4 - 0xce).
2148  */
ov518_reg_w32(struct sd * sd,u16 index,u32 value,int n)2149 static void ov518_reg_w32(struct sd *sd, u16 index, u32 value, int n)
2150 {
2151 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2152 	int ret;
2153 
2154 	if (sd->gspca_dev.usb_err < 0)
2155 		return;
2156 
2157 	*((__le32 *) sd->gspca_dev.usb_buf) = __cpu_to_le32(value);
2158 
2159 	/* Avoid things going to fast for the bridge with a xhci host */
2160 	udelay(150);
2161 	ret = usb_control_msg(sd->gspca_dev.dev,
2162 			usb_sndctrlpipe(sd->gspca_dev.dev, 0),
2163 			1 /* REG_IO */,
2164 			USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2165 			0, index,
2166 			sd->gspca_dev.usb_buf, n, 500);
2167 	if (ret < 0) {
2168 		gspca_err(gspca_dev, "reg_w32 %02x failed %d\n", index, ret);
2169 		sd->gspca_dev.usb_err = ret;
2170 	}
2171 }
2172 
ov511_i2c_w(struct sd * sd,u8 reg,u8 value)2173 static void ov511_i2c_w(struct sd *sd, u8 reg, u8 value)
2174 {
2175 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2176 	int rc, retries;
2177 
2178 	gspca_dbg(gspca_dev, D_USBO, "ov511_i2c_w %02x %02x\n", reg, value);
2179 
2180 	/* Three byte write cycle */
2181 	for (retries = 6; ; ) {
2182 		/* Select camera register */
2183 		reg_w(sd, R51x_I2C_SADDR_3, reg);
2184 
2185 		/* Write "value" to I2C data port of OV511 */
2186 		reg_w(sd, R51x_I2C_DATA, value);
2187 
2188 		/* Initiate 3-byte write cycle */
2189 		reg_w(sd, R511_I2C_CTL, 0x01);
2190 
2191 		do {
2192 			rc = reg_r(sd, R511_I2C_CTL);
2193 		} while (rc > 0 && ((rc & 1) == 0)); /* Retry until idle */
2194 
2195 		if (rc < 0)
2196 			return;
2197 
2198 		if ((rc & 2) == 0) /* Ack? */
2199 			break;
2200 		if (--retries < 0) {
2201 			gspca_dbg(gspca_dev, D_USBO, "i2c write retries exhausted\n");
2202 			return;
2203 		}
2204 	}
2205 }
2206 
ov511_i2c_r(struct sd * sd,u8 reg)2207 static int ov511_i2c_r(struct sd *sd, u8 reg)
2208 {
2209 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2210 	int rc, value, retries;
2211 
2212 	/* Two byte write cycle */
2213 	for (retries = 6; ; ) {
2214 		/* Select camera register */
2215 		reg_w(sd, R51x_I2C_SADDR_2, reg);
2216 
2217 		/* Initiate 2-byte write cycle */
2218 		reg_w(sd, R511_I2C_CTL, 0x03);
2219 
2220 		do {
2221 			rc = reg_r(sd, R511_I2C_CTL);
2222 		} while (rc > 0 && ((rc & 1) == 0)); /* Retry until idle */
2223 
2224 		if (rc < 0)
2225 			return rc;
2226 
2227 		if ((rc & 2) == 0) /* Ack? */
2228 			break;
2229 
2230 		/* I2C abort */
2231 		reg_w(sd, R511_I2C_CTL, 0x10);
2232 
2233 		if (--retries < 0) {
2234 			gspca_dbg(gspca_dev, D_USBI, "i2c write retries exhausted\n");
2235 			return -1;
2236 		}
2237 	}
2238 
2239 	/* Two byte read cycle */
2240 	for (retries = 6; ; ) {
2241 		/* Initiate 2-byte read cycle */
2242 		reg_w(sd, R511_I2C_CTL, 0x05);
2243 
2244 		do {
2245 			rc = reg_r(sd, R511_I2C_CTL);
2246 		} while (rc > 0 && ((rc & 1) == 0)); /* Retry until idle */
2247 
2248 		if (rc < 0)
2249 			return rc;
2250 
2251 		if ((rc & 2) == 0) /* Ack? */
2252 			break;
2253 
2254 		/* I2C abort */
2255 		reg_w(sd, R511_I2C_CTL, 0x10);
2256 
2257 		if (--retries < 0) {
2258 			gspca_dbg(gspca_dev, D_USBI, "i2c read retries exhausted\n");
2259 			return -1;
2260 		}
2261 	}
2262 
2263 	value = reg_r(sd, R51x_I2C_DATA);
2264 
2265 	gspca_dbg(gspca_dev, D_USBI, "ov511_i2c_r %02x %02x\n", reg, value);
2266 
2267 	/* This is needed to make i2c_w() work */
2268 	reg_w(sd, R511_I2C_CTL, 0x05);
2269 
2270 	return value;
2271 }
2272 
2273 /*
2274  * The OV518 I2C I/O procedure is different, hence, this function.
2275  * This is normally only called from i2c_w(). Note that this function
2276  * always succeeds regardless of whether the sensor is present and working.
2277  */
ov518_i2c_w(struct sd * sd,u8 reg,u8 value)2278 static void ov518_i2c_w(struct sd *sd,
2279 		u8 reg,
2280 		u8 value)
2281 {
2282 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2283 
2284 	gspca_dbg(gspca_dev, D_USBO, "ov518_i2c_w %02x %02x\n", reg, value);
2285 
2286 	/* Select camera register */
2287 	reg_w(sd, R51x_I2C_SADDR_3, reg);
2288 
2289 	/* Write "value" to I2C data port of OV511 */
2290 	reg_w(sd, R51x_I2C_DATA, value);
2291 
2292 	/* Initiate 3-byte write cycle */
2293 	reg_w(sd, R518_I2C_CTL, 0x01);
2294 
2295 	/* wait for write complete */
2296 	msleep(4);
2297 	reg_r8(sd, R518_I2C_CTL);
2298 }
2299 
2300 /*
2301  * returns: negative is error, pos or zero is data
2302  *
2303  * The OV518 I2C I/O procedure is different, hence, this function.
2304  * This is normally only called from i2c_r(). Note that this function
2305  * always succeeds regardless of whether the sensor is present and working.
2306  */
ov518_i2c_r(struct sd * sd,u8 reg)2307 static int ov518_i2c_r(struct sd *sd, u8 reg)
2308 {
2309 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2310 	int value;
2311 
2312 	/* Select camera register */
2313 	reg_w(sd, R51x_I2C_SADDR_2, reg);
2314 
2315 	/* Initiate 2-byte write cycle */
2316 	reg_w(sd, R518_I2C_CTL, 0x03);
2317 	reg_r8(sd, R518_I2C_CTL);
2318 
2319 	/* Initiate 2-byte read cycle */
2320 	reg_w(sd, R518_I2C_CTL, 0x05);
2321 	reg_r8(sd, R518_I2C_CTL);
2322 
2323 	value = reg_r(sd, R51x_I2C_DATA);
2324 	gspca_dbg(gspca_dev, D_USBI, "ov518_i2c_r %02x %02x\n", reg, value);
2325 	return value;
2326 }
2327 
ovfx2_i2c_w(struct sd * sd,u8 reg,u8 value)2328 static void ovfx2_i2c_w(struct sd *sd, u8 reg, u8 value)
2329 {
2330 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2331 	int ret;
2332 
2333 	if (sd->gspca_dev.usb_err < 0)
2334 		return;
2335 
2336 	ret = usb_control_msg(sd->gspca_dev.dev,
2337 			usb_sndctrlpipe(sd->gspca_dev.dev, 0),
2338 			0x02,
2339 			USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2340 			(u16) value, (u16) reg, NULL, 0, 500);
2341 
2342 	if (ret < 0) {
2343 		gspca_err(gspca_dev, "ovfx2_i2c_w %02x failed %d\n", reg, ret);
2344 		sd->gspca_dev.usb_err = ret;
2345 	}
2346 
2347 	gspca_dbg(gspca_dev, D_USBO, "ovfx2_i2c_w %02x %02x\n", reg, value);
2348 }
2349 
ovfx2_i2c_r(struct sd * sd,u8 reg)2350 static int ovfx2_i2c_r(struct sd *sd, u8 reg)
2351 {
2352 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2353 	int ret;
2354 
2355 	if (sd->gspca_dev.usb_err < 0)
2356 		return -1;
2357 
2358 	ret = usb_control_msg(sd->gspca_dev.dev,
2359 			usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
2360 			0x03,
2361 			USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2362 			0, (u16) reg, sd->gspca_dev.usb_buf, 1, 500);
2363 
2364 	if (ret >= 0) {
2365 		ret = sd->gspca_dev.usb_buf[0];
2366 		gspca_dbg(gspca_dev, D_USBI, "ovfx2_i2c_r %02x %02x\n",
2367 			  reg, ret);
2368 	} else {
2369 		gspca_err(gspca_dev, "ovfx2_i2c_r %02x failed %d\n", reg, ret);
2370 		sd->gspca_dev.usb_err = ret;
2371 	}
2372 
2373 	return ret;
2374 }
2375 
i2c_w(struct sd * sd,u8 reg,u8 value)2376 static void i2c_w(struct sd *sd, u8 reg, u8 value)
2377 {
2378 	if (sd->sensor_reg_cache[reg] == value)
2379 		return;
2380 
2381 	switch (sd->bridge) {
2382 	case BRIDGE_OV511:
2383 	case BRIDGE_OV511PLUS:
2384 		ov511_i2c_w(sd, reg, value);
2385 		break;
2386 	case BRIDGE_OV518:
2387 	case BRIDGE_OV518PLUS:
2388 	case BRIDGE_OV519:
2389 		ov518_i2c_w(sd, reg, value);
2390 		break;
2391 	case BRIDGE_OVFX2:
2392 		ovfx2_i2c_w(sd, reg, value);
2393 		break;
2394 	case BRIDGE_W9968CF:
2395 		w9968cf_i2c_w(sd, reg, value);
2396 		break;
2397 	}
2398 
2399 	if (sd->gspca_dev.usb_err >= 0) {
2400 		/* Up on sensor reset empty the register cache */
2401 		if (reg == 0x12 && (value & 0x80))
2402 			memset(sd->sensor_reg_cache, -1,
2403 				sizeof(sd->sensor_reg_cache));
2404 		else
2405 			sd->sensor_reg_cache[reg] = value;
2406 	}
2407 }
2408 
i2c_r(struct sd * sd,u8 reg)2409 static int i2c_r(struct sd *sd, u8 reg)
2410 {
2411 	int ret = -1;
2412 
2413 	if (sd->sensor_reg_cache[reg] != -1)
2414 		return sd->sensor_reg_cache[reg];
2415 
2416 	switch (sd->bridge) {
2417 	case BRIDGE_OV511:
2418 	case BRIDGE_OV511PLUS:
2419 		ret = ov511_i2c_r(sd, reg);
2420 		break;
2421 	case BRIDGE_OV518:
2422 	case BRIDGE_OV518PLUS:
2423 	case BRIDGE_OV519:
2424 		ret = ov518_i2c_r(sd, reg);
2425 		break;
2426 	case BRIDGE_OVFX2:
2427 		ret = ovfx2_i2c_r(sd, reg);
2428 		break;
2429 	case BRIDGE_W9968CF:
2430 		ret = w9968cf_i2c_r(sd, reg);
2431 		break;
2432 	}
2433 
2434 	if (ret >= 0)
2435 		sd->sensor_reg_cache[reg] = ret;
2436 
2437 	return ret;
2438 }
2439 
2440 /* Writes bits at positions specified by mask to an I2C reg. Bits that are in
2441  * the same position as 1's in "mask" are cleared and set to "value". Bits
2442  * that are in the same position as 0's in "mask" are preserved, regardless
2443  * of their respective state in "value".
2444  */
i2c_w_mask(struct sd * sd,u8 reg,u8 value,u8 mask)2445 static void i2c_w_mask(struct sd *sd,
2446 			u8 reg,
2447 			u8 value,
2448 			u8 mask)
2449 {
2450 	int rc;
2451 	u8 oldval;
2452 
2453 	value &= mask;			/* Enforce mask on value */
2454 	rc = i2c_r(sd, reg);
2455 	if (rc < 0)
2456 		return;
2457 	oldval = rc & ~mask;		/* Clear the masked bits */
2458 	value |= oldval;		/* Set the desired bits */
2459 	i2c_w(sd, reg, value);
2460 }
2461 
2462 /* Temporarily stops OV511 from functioning. Must do this before changing
2463  * registers while the camera is streaming */
ov51x_stop(struct sd * sd)2464 static inline void ov51x_stop(struct sd *sd)
2465 {
2466 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2467 
2468 	gspca_dbg(gspca_dev, D_STREAM, "stopping\n");
2469 	sd->stopped = 1;
2470 	switch (sd->bridge) {
2471 	case BRIDGE_OV511:
2472 	case BRIDGE_OV511PLUS:
2473 		reg_w(sd, R51x_SYS_RESET, 0x3d);
2474 		break;
2475 	case BRIDGE_OV518:
2476 	case BRIDGE_OV518PLUS:
2477 		reg_w_mask(sd, R51x_SYS_RESET, 0x3a, 0x3a);
2478 		break;
2479 	case BRIDGE_OV519:
2480 		reg_w(sd, OV519_R51_RESET1, 0x0f);
2481 		reg_w(sd, OV519_R51_RESET1, 0x00);
2482 		reg_w(sd, 0x22, 0x00);		/* FRAR */
2483 		break;
2484 	case BRIDGE_OVFX2:
2485 		reg_w_mask(sd, 0x0f, 0x00, 0x02);
2486 		break;
2487 	case BRIDGE_W9968CF:
2488 		reg_w(sd, 0x3c, 0x0a05); /* stop USB transfer */
2489 		break;
2490 	}
2491 }
2492 
2493 /* Restarts OV511 after ov511_stop() is called. Has no effect if it is not
2494  * actually stopped (for performance). */
ov51x_restart(struct sd * sd)2495 static inline void ov51x_restart(struct sd *sd)
2496 {
2497 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2498 
2499 	gspca_dbg(gspca_dev, D_STREAM, "restarting\n");
2500 	if (!sd->stopped)
2501 		return;
2502 	sd->stopped = 0;
2503 
2504 	/* Reinitialize the stream */
2505 	switch (sd->bridge) {
2506 	case BRIDGE_OV511:
2507 	case BRIDGE_OV511PLUS:
2508 		reg_w(sd, R51x_SYS_RESET, 0x00);
2509 		break;
2510 	case BRIDGE_OV518:
2511 	case BRIDGE_OV518PLUS:
2512 		reg_w(sd, 0x2f, 0x80);
2513 		reg_w(sd, R51x_SYS_RESET, 0x00);
2514 		break;
2515 	case BRIDGE_OV519:
2516 		reg_w(sd, OV519_R51_RESET1, 0x0f);
2517 		reg_w(sd, OV519_R51_RESET1, 0x00);
2518 		reg_w(sd, 0x22, 0x1d);		/* FRAR */
2519 		break;
2520 	case BRIDGE_OVFX2:
2521 		reg_w_mask(sd, 0x0f, 0x02, 0x02);
2522 		break;
2523 	case BRIDGE_W9968CF:
2524 		reg_w(sd, 0x3c, 0x8a05); /* USB FIFO enable */
2525 		break;
2526 	}
2527 }
2528 
2529 static void ov51x_set_slave_ids(struct sd *sd, u8 slave);
2530 
2531 /* This does an initial reset of an OmniVision sensor and ensures that I2C
2532  * is synchronized. Returns <0 on failure.
2533  */
init_ov_sensor(struct sd * sd,u8 slave)2534 static int init_ov_sensor(struct sd *sd, u8 slave)
2535 {
2536 	int i;
2537 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2538 
2539 	ov51x_set_slave_ids(sd, slave);
2540 
2541 	/* Reset the sensor */
2542 	i2c_w(sd, 0x12, 0x80);
2543 
2544 	/* Wait for it to initialize */
2545 	msleep(150);
2546 
2547 	for (i = 0; i < i2c_detect_tries; i++) {
2548 		if (i2c_r(sd, OV7610_REG_ID_HIGH) == 0x7f &&
2549 		    i2c_r(sd, OV7610_REG_ID_LOW) == 0xa2) {
2550 			gspca_dbg(gspca_dev, D_PROBE, "I2C synced in %d attempt(s)\n",
2551 				  i);
2552 			return 0;
2553 		}
2554 
2555 		/* Reset the sensor */
2556 		i2c_w(sd, 0x12, 0x80);
2557 
2558 		/* Wait for it to initialize */
2559 		msleep(150);
2560 
2561 		/* Dummy read to sync I2C */
2562 		if (i2c_r(sd, 0x00) < 0)
2563 			return -1;
2564 	}
2565 	return -1;
2566 }
2567 
2568 /* Set the read and write slave IDs. The "slave" argument is the write slave,
2569  * and the read slave will be set to (slave + 1).
2570  * This should not be called from outside the i2c I/O functions.
2571  * Sets I2C read and write slave IDs. Returns <0 for error
2572  */
ov51x_set_slave_ids(struct sd * sd,u8 slave)2573 static void ov51x_set_slave_ids(struct sd *sd,
2574 				u8 slave)
2575 {
2576 	switch (sd->bridge) {
2577 	case BRIDGE_OVFX2:
2578 		reg_w(sd, OVFX2_I2C_ADDR, slave);
2579 		return;
2580 	case BRIDGE_W9968CF:
2581 		sd->sensor_addr = slave;
2582 		return;
2583 	}
2584 
2585 	reg_w(sd, R51x_I2C_W_SID, slave);
2586 	reg_w(sd, R51x_I2C_R_SID, slave + 1);
2587 }
2588 
write_regvals(struct sd * sd,const struct ov_regvals * regvals,int n)2589 static void write_regvals(struct sd *sd,
2590 			 const struct ov_regvals *regvals,
2591 			 int n)
2592 {
2593 	while (--n >= 0) {
2594 		reg_w(sd, regvals->reg, regvals->val);
2595 		regvals++;
2596 	}
2597 }
2598 
write_i2c_regvals(struct sd * sd,const struct ov_i2c_regvals * regvals,int n)2599 static void write_i2c_regvals(struct sd *sd,
2600 			const struct ov_i2c_regvals *regvals,
2601 			int n)
2602 {
2603 	while (--n >= 0) {
2604 		i2c_w(sd, regvals->reg, regvals->val);
2605 		regvals++;
2606 	}
2607 }
2608 
2609 /****************************************************************************
2610  *
2611  * OV511 and sensor configuration
2612  *
2613  ***************************************************************************/
2614 
2615 /* This initializes the OV2x10 / OV3610 / OV3620 / OV9600 */
ov_hires_configure(struct sd * sd)2616 static void ov_hires_configure(struct sd *sd)
2617 {
2618 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2619 	int high, low;
2620 
2621 	if (sd->bridge != BRIDGE_OVFX2) {
2622 		gspca_err(gspca_dev, "error hires sensors only supported with ovfx2\n");
2623 		return;
2624 	}
2625 
2626 	gspca_dbg(gspca_dev, D_PROBE, "starting ov hires configuration\n");
2627 
2628 	/* Detect sensor (sub)type */
2629 	high = i2c_r(sd, 0x0a);
2630 	low = i2c_r(sd, 0x0b);
2631 	/* info("%x, %x", high, low); */
2632 	switch (high) {
2633 	case 0x96:
2634 		switch (low) {
2635 		case 0x40:
2636 			gspca_dbg(gspca_dev, D_PROBE, "Sensor is a OV2610\n");
2637 			sd->sensor = SEN_OV2610;
2638 			return;
2639 		case 0x41:
2640 			gspca_dbg(gspca_dev, D_PROBE, "Sensor is a OV2610AE\n");
2641 			sd->sensor = SEN_OV2610AE;
2642 			return;
2643 		case 0xb1:
2644 			gspca_dbg(gspca_dev, D_PROBE, "Sensor is a OV9600\n");
2645 			sd->sensor = SEN_OV9600;
2646 			return;
2647 		}
2648 		break;
2649 	case 0x36:
2650 		if ((low & 0x0f) == 0x00) {
2651 			gspca_dbg(gspca_dev, D_PROBE, "Sensor is a OV3610\n");
2652 			sd->sensor = SEN_OV3610;
2653 			return;
2654 		}
2655 		break;
2656 	}
2657 	gspca_err(gspca_dev, "Error unknown sensor type: %02x%02x\n",
2658 		  high, low);
2659 }
2660 
2661 /* This initializes the OV8110, OV8610 sensor. The OV8110 uses
2662  * the same register settings as the OV8610, since they are very similar.
2663  */
ov8xx0_configure(struct sd * sd)2664 static void ov8xx0_configure(struct sd *sd)
2665 {
2666 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2667 	int rc;
2668 
2669 	gspca_dbg(gspca_dev, D_PROBE, "starting ov8xx0 configuration\n");
2670 
2671 	/* Detect sensor (sub)type */
2672 	rc = i2c_r(sd, OV7610_REG_COM_I);
2673 	if (rc < 0) {
2674 		gspca_err(gspca_dev, "Error detecting sensor type\n");
2675 		return;
2676 	}
2677 	if ((rc & 3) == 1)
2678 		sd->sensor = SEN_OV8610;
2679 	else
2680 		gspca_err(gspca_dev, "Unknown image sensor version: %d\n",
2681 			  rc & 3);
2682 }
2683 
2684 /* This initializes the OV7610, OV7620, or OV76BE sensor. The OV76BE uses
2685  * the same register settings as the OV7610, since they are very similar.
2686  */
ov7xx0_configure(struct sd * sd)2687 static void ov7xx0_configure(struct sd *sd)
2688 {
2689 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2690 	int rc, high, low;
2691 
2692 	gspca_dbg(gspca_dev, D_PROBE, "starting OV7xx0 configuration\n");
2693 
2694 	/* Detect sensor (sub)type */
2695 	rc = i2c_r(sd, OV7610_REG_COM_I);
2696 
2697 	/* add OV7670 here
2698 	 * it appears to be wrongly detected as a 7610 by default */
2699 	if (rc < 0) {
2700 		gspca_err(gspca_dev, "Error detecting sensor type\n");
2701 		return;
2702 	}
2703 	if ((rc & 3) == 3) {
2704 		/* quick hack to make OV7670s work */
2705 		high = i2c_r(sd, 0x0a);
2706 		low = i2c_r(sd, 0x0b);
2707 		/* info("%x, %x", high, low); */
2708 		if (high == 0x76 && (low & 0xf0) == 0x70) {
2709 			gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV76%02x\n",
2710 				  low);
2711 			sd->sensor = SEN_OV7670;
2712 		} else {
2713 			gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV7610\n");
2714 			sd->sensor = SEN_OV7610;
2715 		}
2716 	} else if ((rc & 3) == 1) {
2717 		/* I don't know what's different about the 76BE yet. */
2718 		if (i2c_r(sd, 0x15) & 1) {
2719 			gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV7620AE\n");
2720 			sd->sensor = SEN_OV7620AE;
2721 		} else {
2722 			gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV76BE\n");
2723 			sd->sensor = SEN_OV76BE;
2724 		}
2725 	} else if ((rc & 3) == 0) {
2726 		/* try to read product id registers */
2727 		high = i2c_r(sd, 0x0a);
2728 		if (high < 0) {
2729 			gspca_err(gspca_dev, "Error detecting camera chip PID\n");
2730 			return;
2731 		}
2732 		low = i2c_r(sd, 0x0b);
2733 		if (low < 0) {
2734 			gspca_err(gspca_dev, "Error detecting camera chip VER\n");
2735 			return;
2736 		}
2737 		if (high == 0x76) {
2738 			switch (low) {
2739 			case 0x30:
2740 				gspca_err(gspca_dev, "Sensor is an OV7630/OV7635\n");
2741 				gspca_err(gspca_dev, "7630 is not supported by this driver\n");
2742 				return;
2743 			case 0x40:
2744 				gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV7645\n");
2745 				sd->sensor = SEN_OV7640; /* FIXME */
2746 				break;
2747 			case 0x45:
2748 				gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV7645B\n");
2749 				sd->sensor = SEN_OV7640; /* FIXME */
2750 				break;
2751 			case 0x48:
2752 				gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV7648\n");
2753 				sd->sensor = SEN_OV7648;
2754 				break;
2755 			case 0x60:
2756 				gspca_dbg(gspca_dev, D_PROBE, "Sensor is a OV7660\n");
2757 				sd->sensor = SEN_OV7660;
2758 				break;
2759 			default:
2760 				gspca_err(gspca_dev, "Unknown sensor: 0x76%02x\n",
2761 					  low);
2762 				return;
2763 			}
2764 		} else {
2765 			gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV7620\n");
2766 			sd->sensor = SEN_OV7620;
2767 		}
2768 	} else {
2769 		gspca_err(gspca_dev, "Unknown image sensor version: %d\n",
2770 			  rc & 3);
2771 	}
2772 }
2773 
2774 /* This initializes the OV6620, OV6630, OV6630AE, or OV6630AF sensor. */
ov6xx0_configure(struct sd * sd)2775 static void ov6xx0_configure(struct sd *sd)
2776 {
2777 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2778 	int rc;
2779 
2780 	gspca_dbg(gspca_dev, D_PROBE, "starting OV6xx0 configuration\n");
2781 
2782 	/* Detect sensor (sub)type */
2783 	rc = i2c_r(sd, OV7610_REG_COM_I);
2784 	if (rc < 0) {
2785 		gspca_err(gspca_dev, "Error detecting sensor type\n");
2786 		return;
2787 	}
2788 
2789 	/* Ugh. The first two bits are the version bits, but
2790 	 * the entire register value must be used. I guess OVT
2791 	 * underestimated how many variants they would make. */
2792 	switch (rc) {
2793 	case 0x00:
2794 		sd->sensor = SEN_OV6630;
2795 		pr_warn("WARNING: Sensor is an OV66308. Your camera may have been misdetected in previous driver versions.\n");
2796 		break;
2797 	case 0x01:
2798 		sd->sensor = SEN_OV6620;
2799 		gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV6620\n");
2800 		break;
2801 	case 0x02:
2802 		sd->sensor = SEN_OV6630;
2803 		gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV66308AE\n");
2804 		break;
2805 	case 0x03:
2806 		sd->sensor = SEN_OV66308AF;
2807 		gspca_dbg(gspca_dev, D_PROBE, "Sensor is an OV66308AF\n");
2808 		break;
2809 	case 0x90:
2810 		sd->sensor = SEN_OV6630;
2811 		pr_warn("WARNING: Sensor is an OV66307. Your camera may have been misdetected in previous driver versions.\n");
2812 		break;
2813 	default:
2814 		gspca_err(gspca_dev, "FATAL: Unknown sensor version: 0x%02x\n",
2815 			  rc);
2816 		return;
2817 	}
2818 
2819 	/* Set sensor-specific vars */
2820 	sd->sif = 1;
2821 }
2822 
2823 /* Turns on or off the LED. Only has an effect with OV511+/OV518(+)/OV519 */
ov51x_led_control(struct sd * sd,int on)2824 static void ov51x_led_control(struct sd *sd, int on)
2825 {
2826 	if (sd->invert_led)
2827 		on = !on;
2828 
2829 	switch (sd->bridge) {
2830 	/* OV511 has no LED control */
2831 	case BRIDGE_OV511PLUS:
2832 		reg_w(sd, R511_SYS_LED_CTL, on);
2833 		break;
2834 	case BRIDGE_OV518:
2835 	case BRIDGE_OV518PLUS:
2836 		reg_w_mask(sd, R518_GPIO_OUT, 0x02 * on, 0x02);
2837 		break;
2838 	case BRIDGE_OV519:
2839 		reg_w_mask(sd, OV519_GPIO_DATA_OUT0, on, 1);
2840 		break;
2841 	}
2842 }
2843 
sd_reset_snapshot(struct gspca_dev * gspca_dev)2844 static void sd_reset_snapshot(struct gspca_dev *gspca_dev)
2845 {
2846 	struct sd *sd = (struct sd *) gspca_dev;
2847 
2848 	if (!sd->snapshot_needs_reset)
2849 		return;
2850 
2851 	/* Note it is important that we clear sd->snapshot_needs_reset,
2852 	   before actually clearing the snapshot state in the bridge
2853 	   otherwise we might race with the pkt_scan interrupt handler */
2854 	sd->snapshot_needs_reset = 0;
2855 
2856 	switch (sd->bridge) {
2857 	case BRIDGE_OV511:
2858 	case BRIDGE_OV511PLUS:
2859 		reg_w(sd, R51x_SYS_SNAP, 0x02);
2860 		reg_w(sd, R51x_SYS_SNAP, 0x00);
2861 		break;
2862 	case BRIDGE_OV518:
2863 	case BRIDGE_OV518PLUS:
2864 		reg_w(sd, R51x_SYS_SNAP, 0x02); /* Reset */
2865 		reg_w(sd, R51x_SYS_SNAP, 0x01); /* Enable */
2866 		break;
2867 	case BRIDGE_OV519:
2868 		reg_w(sd, R51x_SYS_RESET, 0x40);
2869 		reg_w(sd, R51x_SYS_RESET, 0x00);
2870 		break;
2871 	}
2872 }
2873 
ov51x_upload_quan_tables(struct sd * sd)2874 static void ov51x_upload_quan_tables(struct sd *sd)
2875 {
2876 	static const unsigned char yQuanTable511[] = {
2877 		0, 1, 1, 2, 2, 3, 3, 4,
2878 		1, 1, 1, 2, 2, 3, 4, 4,
2879 		1, 1, 2, 2, 3, 4, 4, 4,
2880 		2, 2, 2, 3, 4, 4, 4, 4,
2881 		2, 2, 3, 4, 4, 5, 5, 5,
2882 		3, 3, 4, 4, 5, 5, 5, 5,
2883 		3, 4, 4, 4, 5, 5, 5, 5,
2884 		4, 4, 4, 4, 5, 5, 5, 5
2885 	};
2886 
2887 	static const unsigned char uvQuanTable511[] = {
2888 		0, 2, 2, 3, 4, 4, 4, 4,
2889 		2, 2, 2, 4, 4, 4, 4, 4,
2890 		2, 2, 3, 4, 4, 4, 4, 4,
2891 		3, 4, 4, 4, 4, 4, 4, 4,
2892 		4, 4, 4, 4, 4, 4, 4, 4,
2893 		4, 4, 4, 4, 4, 4, 4, 4,
2894 		4, 4, 4, 4, 4, 4, 4, 4,
2895 		4, 4, 4, 4, 4, 4, 4, 4
2896 	};
2897 
2898 	/* OV518 quantization tables are 8x4 (instead of 8x8) */
2899 	static const unsigned char yQuanTable518[] = {
2900 		5, 4, 5, 6, 6, 7, 7, 7,
2901 		5, 5, 5, 5, 6, 7, 7, 7,
2902 		6, 6, 6, 6, 7, 7, 7, 8,
2903 		7, 7, 6, 7, 7, 7, 8, 8
2904 	};
2905 	static const unsigned char uvQuanTable518[] = {
2906 		6, 6, 6, 7, 7, 7, 7, 7,
2907 		6, 6, 6, 7, 7, 7, 7, 7,
2908 		6, 6, 6, 7, 7, 7, 7, 8,
2909 		7, 7, 7, 7, 7, 7, 8, 8
2910 	};
2911 
2912 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
2913 	const unsigned char *pYTable, *pUVTable;
2914 	unsigned char val0, val1;
2915 	int i, size, reg = R51x_COMP_LUT_BEGIN;
2916 
2917 	gspca_dbg(gspca_dev, D_PROBE, "Uploading quantization tables\n");
2918 
2919 	if (sd->bridge == BRIDGE_OV511 || sd->bridge == BRIDGE_OV511PLUS) {
2920 		pYTable = yQuanTable511;
2921 		pUVTable = uvQuanTable511;
2922 		size = 32;
2923 	} else {
2924 		pYTable = yQuanTable518;
2925 		pUVTable = uvQuanTable518;
2926 		size = 16;
2927 	}
2928 
2929 	for (i = 0; i < size; i++) {
2930 		val0 = *pYTable++;
2931 		val1 = *pYTable++;
2932 		val0 &= 0x0f;
2933 		val1 &= 0x0f;
2934 		val0 |= val1 << 4;
2935 		reg_w(sd, reg, val0);
2936 
2937 		val0 = *pUVTable++;
2938 		val1 = *pUVTable++;
2939 		val0 &= 0x0f;
2940 		val1 &= 0x0f;
2941 		val0 |= val1 << 4;
2942 		reg_w(sd, reg + size, val0);
2943 
2944 		reg++;
2945 	}
2946 }
2947 
2948 /* This initializes the OV511/OV511+ and the sensor */
ov511_configure(struct gspca_dev * gspca_dev)2949 static void ov511_configure(struct gspca_dev *gspca_dev)
2950 {
2951 	struct sd *sd = (struct sd *) gspca_dev;
2952 
2953 	/* For 511 and 511+ */
2954 	static const struct ov_regvals init_511[] = {
2955 		{ R51x_SYS_RESET,	0x7f },
2956 		{ R51x_SYS_INIT,	0x01 },
2957 		{ R51x_SYS_RESET,	0x7f },
2958 		{ R51x_SYS_INIT,	0x01 },
2959 		{ R51x_SYS_RESET,	0x3f },
2960 		{ R51x_SYS_INIT,	0x01 },
2961 		{ R51x_SYS_RESET,	0x3d },
2962 	};
2963 
2964 	static const struct ov_regvals norm_511[] = {
2965 		{ R511_DRAM_FLOW_CTL,	0x01 },
2966 		{ R51x_SYS_SNAP,	0x00 },
2967 		{ R51x_SYS_SNAP,	0x02 },
2968 		{ R51x_SYS_SNAP,	0x00 },
2969 		{ R511_FIFO_OPTS,	0x1f },
2970 		{ R511_COMP_EN,		0x00 },
2971 		{ R511_COMP_LUT_EN,	0x03 },
2972 	};
2973 
2974 	static const struct ov_regvals norm_511_p[] = {
2975 		{ R511_DRAM_FLOW_CTL,	0xff },
2976 		{ R51x_SYS_SNAP,	0x00 },
2977 		{ R51x_SYS_SNAP,	0x02 },
2978 		{ R51x_SYS_SNAP,	0x00 },
2979 		{ R511_FIFO_OPTS,	0xff },
2980 		{ R511_COMP_EN,		0x00 },
2981 		{ R511_COMP_LUT_EN,	0x03 },
2982 	};
2983 
2984 	static const struct ov_regvals compress_511[] = {
2985 		{ 0x70, 0x1f },
2986 		{ 0x71, 0x05 },
2987 		{ 0x72, 0x06 },
2988 		{ 0x73, 0x06 },
2989 		{ 0x74, 0x14 },
2990 		{ 0x75, 0x03 },
2991 		{ 0x76, 0x04 },
2992 		{ 0x77, 0x04 },
2993 	};
2994 
2995 	gspca_dbg(gspca_dev, D_PROBE, "Device custom id %x\n",
2996 		  reg_r(sd, R51x_SYS_CUST_ID));
2997 
2998 	write_regvals(sd, init_511, ARRAY_SIZE(init_511));
2999 
3000 	switch (sd->bridge) {
3001 	case BRIDGE_OV511:
3002 		write_regvals(sd, norm_511, ARRAY_SIZE(norm_511));
3003 		break;
3004 	case BRIDGE_OV511PLUS:
3005 		write_regvals(sd, norm_511_p, ARRAY_SIZE(norm_511_p));
3006 		break;
3007 	}
3008 
3009 	/* Init compression */
3010 	write_regvals(sd, compress_511, ARRAY_SIZE(compress_511));
3011 
3012 	ov51x_upload_quan_tables(sd);
3013 }
3014 
3015 /* This initializes the OV518/OV518+ and the sensor */
ov518_configure(struct gspca_dev * gspca_dev)3016 static void ov518_configure(struct gspca_dev *gspca_dev)
3017 {
3018 	struct sd *sd = (struct sd *) gspca_dev;
3019 
3020 	/* For 518 and 518+ */
3021 	static const struct ov_regvals init_518[] = {
3022 		{ R51x_SYS_RESET,	0x40 },
3023 		{ R51x_SYS_INIT,	0xe1 },
3024 		{ R51x_SYS_RESET,	0x3e },
3025 		{ R51x_SYS_INIT,	0xe1 },
3026 		{ R51x_SYS_RESET,	0x00 },
3027 		{ R51x_SYS_INIT,	0xe1 },
3028 		{ 0x46,			0x00 },
3029 		{ 0x5d,			0x03 },
3030 	};
3031 
3032 	static const struct ov_regvals norm_518[] = {
3033 		{ R51x_SYS_SNAP,	0x02 }, /* Reset */
3034 		{ R51x_SYS_SNAP,	0x01 }, /* Enable */
3035 		{ 0x31,			0x0f },
3036 		{ 0x5d,			0x03 },
3037 		{ 0x24,			0x9f },
3038 		{ 0x25,			0x90 },
3039 		{ 0x20,			0x00 },
3040 		{ 0x51,			0x04 },
3041 		{ 0x71,			0x19 },
3042 		{ 0x2f,			0x80 },
3043 	};
3044 
3045 	static const struct ov_regvals norm_518_p[] = {
3046 		{ R51x_SYS_SNAP,	0x02 }, /* Reset */
3047 		{ R51x_SYS_SNAP,	0x01 }, /* Enable */
3048 		{ 0x31,			0x0f },
3049 		{ 0x5d,			0x03 },
3050 		{ 0x24,			0x9f },
3051 		{ 0x25,			0x90 },
3052 		{ 0x20,			0x60 },
3053 		{ 0x51,			0x02 },
3054 		{ 0x71,			0x19 },
3055 		{ 0x40,			0xff },
3056 		{ 0x41,			0x42 },
3057 		{ 0x46,			0x00 },
3058 		{ 0x33,			0x04 },
3059 		{ 0x21,			0x19 },
3060 		{ 0x3f,			0x10 },
3061 		{ 0x2f,			0x80 },
3062 	};
3063 
3064 	/* First 5 bits of custom ID reg are a revision ID on OV518 */
3065 	sd->revision = reg_r(sd, R51x_SYS_CUST_ID) & 0x1f;
3066 	gspca_dbg(gspca_dev, D_PROBE, "Device revision %d\n", sd->revision);
3067 
3068 	write_regvals(sd, init_518, ARRAY_SIZE(init_518));
3069 
3070 	/* Set LED GPIO pin to output mode */
3071 	reg_w_mask(sd, R518_GPIO_CTL, 0x00, 0x02);
3072 
3073 	switch (sd->bridge) {
3074 	case BRIDGE_OV518:
3075 		write_regvals(sd, norm_518, ARRAY_SIZE(norm_518));
3076 		break;
3077 	case BRIDGE_OV518PLUS:
3078 		write_regvals(sd, norm_518_p, ARRAY_SIZE(norm_518_p));
3079 		break;
3080 	}
3081 
3082 	ov51x_upload_quan_tables(sd);
3083 
3084 	reg_w(sd, 0x2f, 0x80);
3085 }
3086 
ov519_configure(struct sd * sd)3087 static void ov519_configure(struct sd *sd)
3088 {
3089 	static const struct ov_regvals init_519[] = {
3090 		{ 0x5a, 0x6d }, /* EnableSystem */
3091 		{ 0x53, 0x9b }, /* don't enable the microcontroller */
3092 		{ OV519_R54_EN_CLK1, 0xff }, /* set bit2 to enable jpeg */
3093 		{ 0x5d, 0x03 },
3094 		{ 0x49, 0x01 },
3095 		{ 0x48, 0x00 },
3096 		/* Set LED pin to output mode. Bit 4 must be cleared or sensor
3097 		 * detection will fail. This deserves further investigation. */
3098 		{ OV519_GPIO_IO_CTRL0,   0xee },
3099 		{ OV519_R51_RESET1, 0x0f },
3100 		{ OV519_R51_RESET1, 0x00 },
3101 		{ 0x22, 0x00 },
3102 		/* windows reads 0x55 at this point*/
3103 	};
3104 
3105 	write_regvals(sd, init_519, ARRAY_SIZE(init_519));
3106 }
3107 
ovfx2_configure(struct sd * sd)3108 static void ovfx2_configure(struct sd *sd)
3109 {
3110 	static const struct ov_regvals init_fx2[] = {
3111 		{ 0x00, 0x60 },
3112 		{ 0x02, 0x01 },
3113 		{ 0x0f, 0x1d },
3114 		{ 0xe9, 0x82 },
3115 		{ 0xea, 0xc7 },
3116 		{ 0xeb, 0x10 },
3117 		{ 0xec, 0xf6 },
3118 	};
3119 
3120 	sd->stopped = 1;
3121 
3122 	write_regvals(sd, init_fx2, ARRAY_SIZE(init_fx2));
3123 }
3124 
3125 /* set the mode */
3126 /* This function works for ov7660 only */
ov519_set_mode(struct sd * sd)3127 static void ov519_set_mode(struct sd *sd)
3128 {
3129 	static const struct ov_regvals bridge_ov7660[2][10] = {
3130 		{{0x10, 0x14}, {0x11, 0x1e}, {0x12, 0x00}, {0x13, 0x00},
3131 		 {0x14, 0x00}, {0x15, 0x00}, {0x16, 0x00}, {0x20, 0x0c},
3132 		 {0x25, 0x01}, {0x26, 0x00}},
3133 		{{0x10, 0x28}, {0x11, 0x3c}, {0x12, 0x00}, {0x13, 0x00},
3134 		 {0x14, 0x00}, {0x15, 0x00}, {0x16, 0x00}, {0x20, 0x0c},
3135 		 {0x25, 0x03}, {0x26, 0x00}}
3136 	};
3137 	static const struct ov_i2c_regvals sensor_ov7660[2][3] = {
3138 		{{0x12, 0x00}, {0x24, 0x00}, {0x0c, 0x0c}},
3139 		{{0x12, 0x00}, {0x04, 0x00}, {0x0c, 0x00}}
3140 	};
3141 	static const struct ov_i2c_regvals sensor_ov7660_2[] = {
3142 		{OV7670_R17_HSTART, 0x13},
3143 		{OV7670_R18_HSTOP, 0x01},
3144 		{OV7670_R32_HREF, 0x92},
3145 		{OV7670_R19_VSTART, 0x02},
3146 		{OV7670_R1A_VSTOP, 0x7a},
3147 		{OV7670_R03_VREF, 0x00},
3148 /*		{0x33, 0x00}, */
3149 /*		{0x34, 0x07}, */
3150 /*		{0x36, 0x00}, */
3151 /*		{0x6b, 0x0a}, */
3152 	};
3153 
3154 	write_regvals(sd, bridge_ov7660[sd->gspca_dev.curr_mode],
3155 			ARRAY_SIZE(bridge_ov7660[0]));
3156 	write_i2c_regvals(sd, sensor_ov7660[sd->gspca_dev.curr_mode],
3157 			ARRAY_SIZE(sensor_ov7660[0]));
3158 	write_i2c_regvals(sd, sensor_ov7660_2,
3159 			ARRAY_SIZE(sensor_ov7660_2));
3160 }
3161 
3162 /* set the frame rate */
3163 /* This function works for sensors ov7640, ov7648 ov7660 and ov7670 only */
ov519_set_fr(struct sd * sd)3164 static void ov519_set_fr(struct sd *sd)
3165 {
3166 	int fr;
3167 	u8 clock;
3168 	/* frame rate table with indices:
3169 	 *	- mode = 0: 320x240, 1: 640x480
3170 	 *	- fr rate = 0: 30, 1: 25, 2: 20, 3: 15, 4: 10, 5: 5
3171 	 *	- reg = 0: bridge a4, 1: bridge 23, 2: sensor 11 (clock)
3172 	 */
3173 	static const u8 fr_tb[2][6][3] = {
3174 		{{0x04, 0xff, 0x00},
3175 		 {0x04, 0x1f, 0x00},
3176 		 {0x04, 0x1b, 0x00},
3177 		 {0x04, 0x15, 0x00},
3178 		 {0x04, 0x09, 0x00},
3179 		 {0x04, 0x01, 0x00}},
3180 		{{0x0c, 0xff, 0x00},
3181 		 {0x0c, 0x1f, 0x00},
3182 		 {0x0c, 0x1b, 0x00},
3183 		 {0x04, 0xff, 0x01},
3184 		 {0x04, 0x1f, 0x01},
3185 		 {0x04, 0x1b, 0x01}},
3186 	};
3187 
3188 	if (frame_rate > 0)
3189 		sd->frame_rate = frame_rate;
3190 	if (sd->frame_rate >= 30)
3191 		fr = 0;
3192 	else if (sd->frame_rate >= 25)
3193 		fr = 1;
3194 	else if (sd->frame_rate >= 20)
3195 		fr = 2;
3196 	else if (sd->frame_rate >= 15)
3197 		fr = 3;
3198 	else if (sd->frame_rate >= 10)
3199 		fr = 4;
3200 	else
3201 		fr = 5;
3202 	reg_w(sd, 0xa4, fr_tb[sd->gspca_dev.curr_mode][fr][0]);
3203 	reg_w(sd, 0x23, fr_tb[sd->gspca_dev.curr_mode][fr][1]);
3204 	clock = fr_tb[sd->gspca_dev.curr_mode][fr][2];
3205 	if (sd->sensor == SEN_OV7660)
3206 		clock |= 0x80;		/* enable double clock */
3207 	ov518_i2c_w(sd, OV7670_R11_CLKRC, clock);
3208 }
3209 
setautogain(struct gspca_dev * gspca_dev,s32 val)3210 static void setautogain(struct gspca_dev *gspca_dev, s32 val)
3211 {
3212 	struct sd *sd = (struct sd *) gspca_dev;
3213 
3214 	i2c_w_mask(sd, 0x13, val ? 0x05 : 0x00, 0x05);
3215 }
3216 
3217 /* this function is called at probe time */
sd_config(struct gspca_dev * gspca_dev,const struct usb_device_id * id)3218 static int sd_config(struct gspca_dev *gspca_dev,
3219 			const struct usb_device_id *id)
3220 {
3221 	struct sd *sd = (struct sd *) gspca_dev;
3222 	struct cam *cam = &gspca_dev->cam;
3223 
3224 	sd->bridge = id->driver_info & BRIDGE_MASK;
3225 	sd->invert_led = (id->driver_info & BRIDGE_INVERT_LED) != 0;
3226 
3227 	switch (sd->bridge) {
3228 	case BRIDGE_OV511:
3229 	case BRIDGE_OV511PLUS:
3230 		cam->cam_mode = ov511_vga_mode;
3231 		cam->nmodes = ARRAY_SIZE(ov511_vga_mode);
3232 		break;
3233 	case BRIDGE_OV518:
3234 	case BRIDGE_OV518PLUS:
3235 		cam->cam_mode = ov518_vga_mode;
3236 		cam->nmodes = ARRAY_SIZE(ov518_vga_mode);
3237 		break;
3238 	case BRIDGE_OV519:
3239 		cam->cam_mode = ov519_vga_mode;
3240 		cam->nmodes = ARRAY_SIZE(ov519_vga_mode);
3241 		break;
3242 	case BRIDGE_OVFX2:
3243 		cam->cam_mode = ov519_vga_mode;
3244 		cam->nmodes = ARRAY_SIZE(ov519_vga_mode);
3245 		cam->bulk_size = OVFX2_BULK_SIZE;
3246 		cam->bulk_nurbs = MAX_NURBS;
3247 		cam->bulk = 1;
3248 		break;
3249 	case BRIDGE_W9968CF:
3250 		cam->cam_mode = w9968cf_vga_mode;
3251 		cam->nmodes = ARRAY_SIZE(w9968cf_vga_mode);
3252 		break;
3253 	}
3254 
3255 	sd->frame_rate = 15;
3256 
3257 	return 0;
3258 }
3259 
3260 /* this function is called at probe and resume time */
sd_init(struct gspca_dev * gspca_dev)3261 static int sd_init(struct gspca_dev *gspca_dev)
3262 {
3263 	struct sd *sd = (struct sd *) gspca_dev;
3264 	struct cam *cam = &gspca_dev->cam;
3265 
3266 	switch (sd->bridge) {
3267 	case BRIDGE_OV511:
3268 	case BRIDGE_OV511PLUS:
3269 		ov511_configure(gspca_dev);
3270 		break;
3271 	case BRIDGE_OV518:
3272 	case BRIDGE_OV518PLUS:
3273 		ov518_configure(gspca_dev);
3274 		break;
3275 	case BRIDGE_OV519:
3276 		ov519_configure(sd);
3277 		break;
3278 	case BRIDGE_OVFX2:
3279 		ovfx2_configure(sd);
3280 		break;
3281 	case BRIDGE_W9968CF:
3282 		w9968cf_configure(sd);
3283 		break;
3284 	}
3285 
3286 	/* The OV519 must be more aggressive about sensor detection since
3287 	 * I2C write will never fail if the sensor is not present. We have
3288 	 * to try to initialize the sensor to detect its presence */
3289 	sd->sensor = -1;
3290 
3291 	/* Test for 76xx */
3292 	if (init_ov_sensor(sd, OV7xx0_SID) >= 0) {
3293 		ov7xx0_configure(sd);
3294 
3295 	/* Test for 6xx0 */
3296 	} else if (init_ov_sensor(sd, OV6xx0_SID) >= 0) {
3297 		ov6xx0_configure(sd);
3298 
3299 	/* Test for 8xx0 */
3300 	} else if (init_ov_sensor(sd, OV8xx0_SID) >= 0) {
3301 		ov8xx0_configure(sd);
3302 
3303 	/* Test for 3xxx / 2xxx */
3304 	} else if (init_ov_sensor(sd, OV_HIRES_SID) >= 0) {
3305 		ov_hires_configure(sd);
3306 	} else {
3307 		gspca_err(gspca_dev, "Can't determine sensor slave IDs\n");
3308 		goto error;
3309 	}
3310 
3311 	if (sd->sensor < 0)
3312 		goto error;
3313 
3314 	ov51x_led_control(sd, 0);	/* turn LED off */
3315 
3316 	switch (sd->bridge) {
3317 	case BRIDGE_OV511:
3318 	case BRIDGE_OV511PLUS:
3319 		if (sd->sif) {
3320 			cam->cam_mode = ov511_sif_mode;
3321 			cam->nmodes = ARRAY_SIZE(ov511_sif_mode);
3322 		}
3323 		break;
3324 	case BRIDGE_OV518:
3325 	case BRIDGE_OV518PLUS:
3326 		if (sd->sif) {
3327 			cam->cam_mode = ov518_sif_mode;
3328 			cam->nmodes = ARRAY_SIZE(ov518_sif_mode);
3329 		}
3330 		break;
3331 	case BRIDGE_OV519:
3332 		if (sd->sif) {
3333 			cam->cam_mode = ov519_sif_mode;
3334 			cam->nmodes = ARRAY_SIZE(ov519_sif_mode);
3335 		}
3336 		break;
3337 	case BRIDGE_OVFX2:
3338 		switch (sd->sensor) {
3339 		case SEN_OV2610:
3340 		case SEN_OV2610AE:
3341 			cam->cam_mode = ovfx2_ov2610_mode;
3342 			cam->nmodes = ARRAY_SIZE(ovfx2_ov2610_mode);
3343 			break;
3344 		case SEN_OV3610:
3345 			cam->cam_mode = ovfx2_ov3610_mode;
3346 			cam->nmodes = ARRAY_SIZE(ovfx2_ov3610_mode);
3347 			break;
3348 		case SEN_OV9600:
3349 			cam->cam_mode = ovfx2_ov9600_mode;
3350 			cam->nmodes = ARRAY_SIZE(ovfx2_ov9600_mode);
3351 			break;
3352 		default:
3353 			if (sd->sif) {
3354 				cam->cam_mode = ov519_sif_mode;
3355 				cam->nmodes = ARRAY_SIZE(ov519_sif_mode);
3356 			}
3357 			break;
3358 		}
3359 		break;
3360 	case BRIDGE_W9968CF:
3361 		if (sd->sif)
3362 			cam->nmodes = ARRAY_SIZE(w9968cf_vga_mode) - 1;
3363 
3364 		/* w9968cf needs initialisation once the sensor is known */
3365 		w9968cf_init(sd);
3366 		break;
3367 	}
3368 
3369 	/* initialize the sensor */
3370 	switch (sd->sensor) {
3371 	case SEN_OV2610:
3372 		write_i2c_regvals(sd, norm_2610, ARRAY_SIZE(norm_2610));
3373 
3374 		/* Enable autogain, autoexpo, awb, bandfilter */
3375 		i2c_w_mask(sd, 0x13, 0x27, 0x27);
3376 		break;
3377 	case SEN_OV2610AE:
3378 		write_i2c_regvals(sd, norm_2610ae, ARRAY_SIZE(norm_2610ae));
3379 
3380 		/* enable autoexpo */
3381 		i2c_w_mask(sd, 0x13, 0x05, 0x05);
3382 		break;
3383 	case SEN_OV3610:
3384 		write_i2c_regvals(sd, norm_3620b, ARRAY_SIZE(norm_3620b));
3385 
3386 		/* Enable autogain, autoexpo, awb, bandfilter */
3387 		i2c_w_mask(sd, 0x13, 0x27, 0x27);
3388 		break;
3389 	case SEN_OV6620:
3390 		write_i2c_regvals(sd, norm_6x20, ARRAY_SIZE(norm_6x20));
3391 		break;
3392 	case SEN_OV6630:
3393 	case SEN_OV66308AF:
3394 		write_i2c_regvals(sd, norm_6x30, ARRAY_SIZE(norm_6x30));
3395 		break;
3396 	default:
3397 /*	case SEN_OV7610: */
3398 /*	case SEN_OV76BE: */
3399 		write_i2c_regvals(sd, norm_7610, ARRAY_SIZE(norm_7610));
3400 		i2c_w_mask(sd, 0x0e, 0x00, 0x40);
3401 		break;
3402 	case SEN_OV7620:
3403 	case SEN_OV7620AE:
3404 		write_i2c_regvals(sd, norm_7620, ARRAY_SIZE(norm_7620));
3405 		break;
3406 	case SEN_OV7640:
3407 	case SEN_OV7648:
3408 		write_i2c_regvals(sd, norm_7640, ARRAY_SIZE(norm_7640));
3409 		break;
3410 	case SEN_OV7660:
3411 		i2c_w(sd, OV7670_R12_COM7, OV7670_COM7_RESET);
3412 		msleep(14);
3413 		reg_w(sd, OV519_R57_SNAPSHOT, 0x23);
3414 		write_regvals(sd, init_519_ov7660,
3415 				ARRAY_SIZE(init_519_ov7660));
3416 		write_i2c_regvals(sd, norm_7660, ARRAY_SIZE(norm_7660));
3417 		sd->gspca_dev.curr_mode = 1;	/* 640x480 */
3418 		ov519_set_mode(sd);
3419 		ov519_set_fr(sd);
3420 		sd_reset_snapshot(gspca_dev);
3421 		ov51x_restart(sd);
3422 		ov51x_stop(sd);			/* not in win traces */
3423 		ov51x_led_control(sd, 0);
3424 		break;
3425 	case SEN_OV7670:
3426 		write_i2c_regvals(sd, norm_7670, ARRAY_SIZE(norm_7670));
3427 		break;
3428 	case SEN_OV8610:
3429 		write_i2c_regvals(sd, norm_8610, ARRAY_SIZE(norm_8610));
3430 		break;
3431 	case SEN_OV9600:
3432 		write_i2c_regvals(sd, norm_9600, ARRAY_SIZE(norm_9600));
3433 
3434 		/* enable autoexpo */
3435 /*		i2c_w_mask(sd, 0x13, 0x05, 0x05); */
3436 		break;
3437 	}
3438 	return gspca_dev->usb_err;
3439 error:
3440 	gspca_err(gspca_dev, "OV519 Config failed\n");
3441 	return -EINVAL;
3442 }
3443 
3444 /* function called at start time before URB creation */
sd_isoc_init(struct gspca_dev * gspca_dev)3445 static int sd_isoc_init(struct gspca_dev *gspca_dev)
3446 {
3447 	struct sd *sd = (struct sd *) gspca_dev;
3448 
3449 	switch (sd->bridge) {
3450 	case BRIDGE_OVFX2:
3451 		if (gspca_dev->pixfmt.width != 800)
3452 			gspca_dev->cam.bulk_size = OVFX2_BULK_SIZE;
3453 		else
3454 			gspca_dev->cam.bulk_size = 7 * 4096;
3455 		break;
3456 	}
3457 	return 0;
3458 }
3459 
3460 /* Set up the OV511/OV511+ with the given image parameters.
3461  *
3462  * Do not put any sensor-specific code in here (including I2C I/O functions)
3463  */
ov511_mode_init_regs(struct sd * sd)3464 static void ov511_mode_init_regs(struct sd *sd)
3465 {
3466 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
3467 	int hsegs, vsegs, packet_size, fps, needed;
3468 	int interlaced = 0;
3469 	struct usb_host_interface *alt;
3470 	struct usb_interface *intf;
3471 
3472 	intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
3473 	alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
3474 	if (!alt) {
3475 		gspca_err(gspca_dev, "Couldn't get altsetting\n");
3476 		sd->gspca_dev.usb_err = -EIO;
3477 		return;
3478 	}
3479 
3480 	if (alt->desc.bNumEndpoints < 1) {
3481 		sd->gspca_dev.usb_err = -ENODEV;
3482 		return;
3483 	}
3484 
3485 	packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
3486 	reg_w(sd, R51x_FIFO_PSIZE, packet_size >> 5);
3487 
3488 	reg_w(sd, R511_CAM_UV_EN, 0x01);
3489 	reg_w(sd, R511_SNAP_UV_EN, 0x01);
3490 	reg_w(sd, R511_SNAP_OPTS, 0x03);
3491 
3492 	/* Here I'm assuming that snapshot size == image size.
3493 	 * I hope that's always true. --claudio
3494 	 */
3495 	hsegs = (sd->gspca_dev.pixfmt.width >> 3) - 1;
3496 	vsegs = (sd->gspca_dev.pixfmt.height >> 3) - 1;
3497 
3498 	reg_w(sd, R511_CAM_PXCNT, hsegs);
3499 	reg_w(sd, R511_CAM_LNCNT, vsegs);
3500 	reg_w(sd, R511_CAM_PXDIV, 0x00);
3501 	reg_w(sd, R511_CAM_LNDIV, 0x00);
3502 
3503 	/* YUV420, low pass filter on */
3504 	reg_w(sd, R511_CAM_OPTS, 0x03);
3505 
3506 	/* Snapshot additions */
3507 	reg_w(sd, R511_SNAP_PXCNT, hsegs);
3508 	reg_w(sd, R511_SNAP_LNCNT, vsegs);
3509 	reg_w(sd, R511_SNAP_PXDIV, 0x00);
3510 	reg_w(sd, R511_SNAP_LNDIV, 0x00);
3511 
3512 	/******** Set the framerate ********/
3513 	if (frame_rate > 0)
3514 		sd->frame_rate = frame_rate;
3515 
3516 	switch (sd->sensor) {
3517 	case SEN_OV6620:
3518 		/* No framerate control, doesn't like higher rates yet */
3519 		sd->clockdiv = 3;
3520 		break;
3521 
3522 	/* Note once the FIXME's in mode_init_ov_sensor_regs() are fixed
3523 	   for more sensors we need to do this for them too */
3524 	case SEN_OV7620:
3525 	case SEN_OV7620AE:
3526 	case SEN_OV7640:
3527 	case SEN_OV7648:
3528 	case SEN_OV76BE:
3529 		if (sd->gspca_dev.pixfmt.width == 320)
3530 			interlaced = 1;
3531 		fallthrough;
3532 	case SEN_OV6630:
3533 	case SEN_OV7610:
3534 	case SEN_OV7670:
3535 		switch (sd->frame_rate) {
3536 		case 30:
3537 		case 25:
3538 			/* Not enough bandwidth to do 640x480 @ 30 fps */
3539 			if (sd->gspca_dev.pixfmt.width != 640) {
3540 				sd->clockdiv = 0;
3541 				break;
3542 			}
3543 			/* For 640x480 case */
3544 			fallthrough;
3545 		default:
3546 /*		case 20: */
3547 /*		case 15: */
3548 			sd->clockdiv = 1;
3549 			break;
3550 		case 10:
3551 			sd->clockdiv = 2;
3552 			break;
3553 		case 5:
3554 			sd->clockdiv = 5;
3555 			break;
3556 		}
3557 		if (interlaced) {
3558 			sd->clockdiv = (sd->clockdiv + 1) * 2 - 1;
3559 			/* Higher then 10 does not work */
3560 			if (sd->clockdiv > 10)
3561 				sd->clockdiv = 10;
3562 		}
3563 		break;
3564 
3565 	case SEN_OV8610:
3566 		/* No framerate control ?? */
3567 		sd->clockdiv = 0;
3568 		break;
3569 	}
3570 
3571 	/* Check if we have enough bandwidth to disable compression */
3572 	fps = (interlaced ? 60 : 30) / (sd->clockdiv + 1) + 1;
3573 	needed = fps * sd->gspca_dev.pixfmt.width *
3574 			sd->gspca_dev.pixfmt.height * 3 / 2;
3575 	/* 1000 isoc packets/sec */
3576 	if (needed > 1000 * packet_size) {
3577 		/* Enable Y and UV quantization and compression */
3578 		reg_w(sd, R511_COMP_EN, 0x07);
3579 		reg_w(sd, R511_COMP_LUT_EN, 0x03);
3580 	} else {
3581 		reg_w(sd, R511_COMP_EN, 0x06);
3582 		reg_w(sd, R511_COMP_LUT_EN, 0x00);
3583 	}
3584 
3585 	reg_w(sd, R51x_SYS_RESET, OV511_RESET_OMNICE);
3586 	reg_w(sd, R51x_SYS_RESET, 0);
3587 }
3588 
3589 /* Sets up the OV518/OV518+ with the given image parameters
3590  *
3591  * OV518 needs a completely different approach, until we can figure out what
3592  * the individual registers do. Also, only 15 FPS is supported now.
3593  *
3594  * Do not put any sensor-specific code in here (including I2C I/O functions)
3595  */
ov518_mode_init_regs(struct sd * sd)3596 static void ov518_mode_init_regs(struct sd *sd)
3597 {
3598 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
3599 	int hsegs, vsegs, packet_size;
3600 	struct usb_host_interface *alt;
3601 	struct usb_interface *intf;
3602 
3603 	intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
3604 	alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
3605 	if (!alt) {
3606 		gspca_err(gspca_dev, "Couldn't get altsetting\n");
3607 		sd->gspca_dev.usb_err = -EIO;
3608 		return;
3609 	}
3610 
3611 	if (alt->desc.bNumEndpoints < 1) {
3612 		sd->gspca_dev.usb_err = -ENODEV;
3613 		return;
3614 	}
3615 
3616 	packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
3617 	ov518_reg_w32(sd, R51x_FIFO_PSIZE, packet_size & ~7, 2);
3618 
3619 	/******** Set the mode ********/
3620 	reg_w(sd, 0x2b, 0);
3621 	reg_w(sd, 0x2c, 0);
3622 	reg_w(sd, 0x2d, 0);
3623 	reg_w(sd, 0x2e, 0);
3624 	reg_w(sd, 0x3b, 0);
3625 	reg_w(sd, 0x3c, 0);
3626 	reg_w(sd, 0x3d, 0);
3627 	reg_w(sd, 0x3e, 0);
3628 
3629 	if (sd->bridge == BRIDGE_OV518) {
3630 		/* Set 8-bit (YVYU) input format */
3631 		reg_w_mask(sd, 0x20, 0x08, 0x08);
3632 
3633 		/* Set 12-bit (4:2:0) output format */
3634 		reg_w_mask(sd, 0x28, 0x80, 0xf0);
3635 		reg_w_mask(sd, 0x38, 0x80, 0xf0);
3636 	} else {
3637 		reg_w(sd, 0x28, 0x80);
3638 		reg_w(sd, 0x38, 0x80);
3639 	}
3640 
3641 	hsegs = sd->gspca_dev.pixfmt.width / 16;
3642 	vsegs = sd->gspca_dev.pixfmt.height / 4;
3643 
3644 	reg_w(sd, 0x29, hsegs);
3645 	reg_w(sd, 0x2a, vsegs);
3646 
3647 	reg_w(sd, 0x39, hsegs);
3648 	reg_w(sd, 0x3a, vsegs);
3649 
3650 	/* Windows driver does this here; who knows why */
3651 	reg_w(sd, 0x2f, 0x80);
3652 
3653 	/******** Set the framerate ********/
3654 	if (sd->bridge == BRIDGE_OV518PLUS && sd->revision == 0 &&
3655 					      sd->sensor == SEN_OV7620AE)
3656 		sd->clockdiv = 0;
3657 	else
3658 		sd->clockdiv = 1;
3659 
3660 	/* Mode independent, but framerate dependent, regs */
3661 	/* 0x51: Clock divider; Only works on some cams which use 2 crystals */
3662 	reg_w(sd, 0x51, 0x04);
3663 	reg_w(sd, 0x22, 0x18);
3664 	reg_w(sd, 0x23, 0xff);
3665 
3666 	if (sd->bridge == BRIDGE_OV518PLUS) {
3667 		switch (sd->sensor) {
3668 		case SEN_OV7620AE:
3669 			/*
3670 			 * HdG: 640x480 needs special handling on device
3671 			 * revision 2, we check for device revision > 0 to
3672 			 * avoid regressions, as we don't know the correct
3673 			 * thing todo for revision 1.
3674 			 *
3675 			 * Also this likely means we don't need to
3676 			 * differentiate between the OV7620 and OV7620AE,
3677 			 * earlier testing hitting this same problem likely
3678 			 * happened to be with revision < 2 cams using an
3679 			 * OV7620 and revision 2 cams using an OV7620AE.
3680 			 */
3681 			if (sd->revision > 0 &&
3682 					sd->gspca_dev.pixfmt.width == 640) {
3683 				reg_w(sd, 0x20, 0x60);
3684 				reg_w(sd, 0x21, 0x1f);
3685 			} else {
3686 				reg_w(sd, 0x20, 0x00);
3687 				reg_w(sd, 0x21, 0x19);
3688 			}
3689 			break;
3690 		case SEN_OV7620:
3691 			reg_w(sd, 0x20, 0x00);
3692 			reg_w(sd, 0x21, 0x19);
3693 			break;
3694 		default:
3695 			reg_w(sd, 0x21, 0x19);
3696 		}
3697 	} else
3698 		reg_w(sd, 0x71, 0x17);	/* Compression-related? */
3699 
3700 	/* FIXME: Sensor-specific */
3701 	/* Bit 5 is what matters here. Of course, it is "reserved" */
3702 	i2c_w(sd, 0x54, 0x23);
3703 
3704 	reg_w(sd, 0x2f, 0x80);
3705 
3706 	if (sd->bridge == BRIDGE_OV518PLUS) {
3707 		reg_w(sd, 0x24, 0x94);
3708 		reg_w(sd, 0x25, 0x90);
3709 		ov518_reg_w32(sd, 0xc4,    400, 2);	/* 190h   */
3710 		ov518_reg_w32(sd, 0xc6,    540, 2);	/* 21ch   */
3711 		ov518_reg_w32(sd, 0xc7,    540, 2);	/* 21ch   */
3712 		ov518_reg_w32(sd, 0xc8,    108, 2);	/* 6ch    */
3713 		ov518_reg_w32(sd, 0xca, 131098, 3);	/* 2001ah */
3714 		ov518_reg_w32(sd, 0xcb,    532, 2);	/* 214h   */
3715 		ov518_reg_w32(sd, 0xcc,   2400, 2);	/* 960h   */
3716 		ov518_reg_w32(sd, 0xcd,     32, 2);	/* 20h    */
3717 		ov518_reg_w32(sd, 0xce,    608, 2);	/* 260h   */
3718 	} else {
3719 		reg_w(sd, 0x24, 0x9f);
3720 		reg_w(sd, 0x25, 0x90);
3721 		ov518_reg_w32(sd, 0xc4,    400, 2);	/* 190h   */
3722 		ov518_reg_w32(sd, 0xc6,    381, 2);	/* 17dh   */
3723 		ov518_reg_w32(sd, 0xc7,    381, 2);	/* 17dh   */
3724 		ov518_reg_w32(sd, 0xc8,    128, 2);	/* 80h    */
3725 		ov518_reg_w32(sd, 0xca, 183331, 3);	/* 2cc23h */
3726 		ov518_reg_w32(sd, 0xcb,    746, 2);	/* 2eah   */
3727 		ov518_reg_w32(sd, 0xcc,   1750, 2);	/* 6d6h   */
3728 		ov518_reg_w32(sd, 0xcd,     45, 2);	/* 2dh    */
3729 		ov518_reg_w32(sd, 0xce,    851, 2);	/* 353h   */
3730 	}
3731 
3732 	reg_w(sd, 0x2f, 0x80);
3733 }
3734 
3735 /* Sets up the OV519 with the given image parameters
3736  *
3737  * OV519 needs a completely different approach, until we can figure out what
3738  * the individual registers do.
3739  *
3740  * Do not put any sensor-specific code in here (including I2C I/O functions)
3741  */
ov519_mode_init_regs(struct sd * sd)3742 static void ov519_mode_init_regs(struct sd *sd)
3743 {
3744 	static const struct ov_regvals mode_init_519_ov7670[] = {
3745 		{ 0x5d,	0x03 }, /* Turn off suspend mode */
3746 		{ 0x53,	0x9f }, /* was 9b in 1.65-1.08 */
3747 		{ OV519_R54_EN_CLK1, 0x0f }, /* bit2 (jpeg enable) */
3748 		{ 0xa2,	0x20 }, /* a2-a5 are undocumented */
3749 		{ 0xa3,	0x18 },
3750 		{ 0xa4,	0x04 },
3751 		{ 0xa5,	0x28 },
3752 		{ 0x37,	0x00 },	/* SetUsbInit */
3753 		{ 0x55,	0x02 }, /* 4.096 Mhz audio clock */
3754 		/* Enable both fields, YUV Input, disable defect comp (why?) */
3755 		{ 0x20,	0x0c },
3756 		{ 0x21,	0x38 },
3757 		{ 0x22,	0x1d },
3758 		{ 0x17,	0x50 }, /* undocumented */
3759 		{ 0x37,	0x00 }, /* undocumented */
3760 		{ 0x40,	0xff }, /* I2C timeout counter */
3761 		{ 0x46,	0x00 }, /* I2C clock prescaler */
3762 		{ 0x59,	0x04 },	/* new from windrv 090403 */
3763 		{ 0xff,	0x00 }, /* undocumented */
3764 		/* windows reads 0x55 at this point, why? */
3765 	};
3766 
3767 	static const struct ov_regvals mode_init_519[] = {
3768 		{ 0x5d,	0x03 }, /* Turn off suspend mode */
3769 		{ 0x53,	0x9f }, /* was 9b in 1.65-1.08 */
3770 		{ OV519_R54_EN_CLK1, 0x0f }, /* bit2 (jpeg enable) */
3771 		{ 0xa2,	0x20 }, /* a2-a5 are undocumented */
3772 		{ 0xa3,	0x18 },
3773 		{ 0xa4,	0x04 },
3774 		{ 0xa5,	0x28 },
3775 		{ 0x37,	0x00 },	/* SetUsbInit */
3776 		{ 0x55,	0x02 }, /* 4.096 Mhz audio clock */
3777 		/* Enable both fields, YUV Input, disable defect comp (why?) */
3778 		{ 0x22,	0x1d },
3779 		{ 0x17,	0x50 }, /* undocumented */
3780 		{ 0x37,	0x00 }, /* undocumented */
3781 		{ 0x40,	0xff }, /* I2C timeout counter */
3782 		{ 0x46,	0x00 }, /* I2C clock prescaler */
3783 		{ 0x59,	0x04 },	/* new from windrv 090403 */
3784 		{ 0xff,	0x00 }, /* undocumented */
3785 		/* windows reads 0x55 at this point, why? */
3786 	};
3787 
3788 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
3789 
3790 	/******** Set the mode ********/
3791 	switch (sd->sensor) {
3792 	default:
3793 		write_regvals(sd, mode_init_519, ARRAY_SIZE(mode_init_519));
3794 		if (sd->sensor == SEN_OV7640 ||
3795 		    sd->sensor == SEN_OV7648) {
3796 			/* Select 8-bit input mode */
3797 			reg_w_mask(sd, OV519_R20_DFR, 0x10, 0x10);
3798 		}
3799 		break;
3800 	case SEN_OV7660:
3801 		return;		/* done by ov519_set_mode/fr() */
3802 	case SEN_OV7670:
3803 		write_regvals(sd, mode_init_519_ov7670,
3804 				ARRAY_SIZE(mode_init_519_ov7670));
3805 		break;
3806 	}
3807 
3808 	reg_w(sd, OV519_R10_H_SIZE,	sd->gspca_dev.pixfmt.width >> 4);
3809 	reg_w(sd, OV519_R11_V_SIZE,	sd->gspca_dev.pixfmt.height >> 3);
3810 	if (sd->sensor == SEN_OV7670 &&
3811 	    sd->gspca_dev.cam.cam_mode[sd->gspca_dev.curr_mode].priv)
3812 		reg_w(sd, OV519_R12_X_OFFSETL, 0x04);
3813 	else if (sd->sensor == SEN_OV7648 &&
3814 	    sd->gspca_dev.cam.cam_mode[sd->gspca_dev.curr_mode].priv)
3815 		reg_w(sd, OV519_R12_X_OFFSETL, 0x01);
3816 	else
3817 		reg_w(sd, OV519_R12_X_OFFSETL, 0x00);
3818 	reg_w(sd, OV519_R13_X_OFFSETH,	0x00);
3819 	reg_w(sd, OV519_R14_Y_OFFSETL,	0x00);
3820 	reg_w(sd, OV519_R15_Y_OFFSETH,	0x00);
3821 	reg_w(sd, OV519_R16_DIVIDER,	0x00);
3822 	reg_w(sd, OV519_R25_FORMAT,	0x03); /* YUV422 */
3823 	reg_w(sd, 0x26,			0x00); /* Undocumented */
3824 
3825 	/******** Set the framerate ********/
3826 	if (frame_rate > 0)
3827 		sd->frame_rate = frame_rate;
3828 
3829 /* FIXME: These are only valid at the max resolution. */
3830 	sd->clockdiv = 0;
3831 	switch (sd->sensor) {
3832 	case SEN_OV7640:
3833 	case SEN_OV7648:
3834 		switch (sd->frame_rate) {
3835 		default:
3836 /*		case 30: */
3837 			reg_w(sd, 0xa4, 0x0c);
3838 			reg_w(sd, 0x23, 0xff);
3839 			break;
3840 		case 25:
3841 			reg_w(sd, 0xa4, 0x0c);
3842 			reg_w(sd, 0x23, 0x1f);
3843 			break;
3844 		case 20:
3845 			reg_w(sd, 0xa4, 0x0c);
3846 			reg_w(sd, 0x23, 0x1b);
3847 			break;
3848 		case 15:
3849 			reg_w(sd, 0xa4, 0x04);
3850 			reg_w(sd, 0x23, 0xff);
3851 			sd->clockdiv = 1;
3852 			break;
3853 		case 10:
3854 			reg_w(sd, 0xa4, 0x04);
3855 			reg_w(sd, 0x23, 0x1f);
3856 			sd->clockdiv = 1;
3857 			break;
3858 		case 5:
3859 			reg_w(sd, 0xa4, 0x04);
3860 			reg_w(sd, 0x23, 0x1b);
3861 			sd->clockdiv = 1;
3862 			break;
3863 		}
3864 		break;
3865 	case SEN_OV8610:
3866 		switch (sd->frame_rate) {
3867 		default:	/* 15 fps */
3868 /*		case 15: */
3869 			reg_w(sd, 0xa4, 0x06);
3870 			reg_w(sd, 0x23, 0xff);
3871 			break;
3872 		case 10:
3873 			reg_w(sd, 0xa4, 0x06);
3874 			reg_w(sd, 0x23, 0x1f);
3875 			break;
3876 		case 5:
3877 			reg_w(sd, 0xa4, 0x06);
3878 			reg_w(sd, 0x23, 0x1b);
3879 			break;
3880 		}
3881 		break;
3882 	case SEN_OV7670:		/* guesses, based on 7640 */
3883 		gspca_dbg(gspca_dev, D_STREAM, "Setting framerate to %d fps\n",
3884 			  (sd->frame_rate == 0) ? 15 : sd->frame_rate);
3885 		reg_w(sd, 0xa4, 0x10);
3886 		switch (sd->frame_rate) {
3887 		case 30:
3888 			reg_w(sd, 0x23, 0xff);
3889 			break;
3890 		case 20:
3891 			reg_w(sd, 0x23, 0x1b);
3892 			break;
3893 		default:
3894 /*		case 15: */
3895 			reg_w(sd, 0x23, 0xff);
3896 			sd->clockdiv = 1;
3897 			break;
3898 		}
3899 		break;
3900 	}
3901 }
3902 
mode_init_ov_sensor_regs(struct sd * sd)3903 static void mode_init_ov_sensor_regs(struct sd *sd)
3904 {
3905 	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
3906 	int qvga, xstart, xend, ystart, yend;
3907 	u8 v;
3908 
3909 	qvga = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv & 1;
3910 
3911 	/******** Mode (VGA/QVGA) and sensor specific regs ********/
3912 	switch (sd->sensor) {
3913 	case SEN_OV2610:
3914 		i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
3915 		i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
3916 		i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a);
3917 		i2c_w(sd, 0x25, qvga ? 0x30 : 0x60);
3918 		i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40);
3919 		i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0);
3920 		i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20);
3921 		return;
3922 	case SEN_OV2610AE: {
3923 		u8 v;
3924 
3925 		/* frame rates:
3926 		 *	10fps / 5 fps for 1600x1200
3927 		 *	40fps / 20fps for 800x600
3928 		 */
3929 		v = 80;
3930 		if (qvga) {
3931 			if (sd->frame_rate < 25)
3932 				v = 0x81;
3933 		} else {
3934 			if (sd->frame_rate < 10)
3935 				v = 0x81;
3936 		}
3937 		i2c_w(sd, 0x11, v);
3938 		i2c_w(sd, 0x12, qvga ? 0x60 : 0x20);
3939 		return;
3940 	    }
3941 	case SEN_OV3610:
3942 		if (qvga) {
3943 			xstart = (1040 - gspca_dev->pixfmt.width) / 2 +
3944 				(0x1f << 4);
3945 			ystart = (776 - gspca_dev->pixfmt.height) / 2;
3946 		} else {
3947 			xstart = (2076 - gspca_dev->pixfmt.width) / 2 +
3948 				(0x10 << 4);
3949 			ystart = (1544 - gspca_dev->pixfmt.height) / 2;
3950 		}
3951 		xend = xstart + gspca_dev->pixfmt.width;
3952 		yend = ystart + gspca_dev->pixfmt.height;
3953 		/* Writing to the COMH register resets the other windowing regs
3954 		   to their default values, so we must do this first. */
3955 		i2c_w_mask(sd, 0x12, qvga ? 0x40 : 0x00, 0xf0);
3956 		i2c_w_mask(sd, 0x32,
3957 			   (((xend >> 1) & 7) << 3) | ((xstart >> 1) & 7),
3958 			   0x3f);
3959 		i2c_w_mask(sd, 0x03,
3960 			   (((yend >> 1) & 3) << 2) | ((ystart >> 1) & 3),
3961 			   0x0f);
3962 		i2c_w(sd, 0x17, xstart >> 4);
3963 		i2c_w(sd, 0x18, xend >> 4);
3964 		i2c_w(sd, 0x19, ystart >> 3);
3965 		i2c_w(sd, 0x1a, yend >> 3);
3966 		return;
3967 	case SEN_OV8610:
3968 		/* For OV8610 qvga means qsvga */
3969 		i2c_w_mask(sd, OV7610_REG_COM_C, qvga ? (1 << 5) : 0, 1 << 5);
3970 		i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
3971 		i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
3972 		i2c_w_mask(sd, 0x2d, 0x00, 0x40); /* from windrv 090403 */
3973 		i2c_w_mask(sd, 0x28, 0x20, 0x20); /* progressive mode on */
3974 		break;
3975 	case SEN_OV7610:
3976 		i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
3977 		i2c_w(sd, 0x35, qvga ? 0x1e : 0x9e);
3978 		i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
3979 		i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
3980 		break;
3981 	case SEN_OV7620:
3982 	case SEN_OV7620AE:
3983 	case SEN_OV76BE:
3984 		i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
3985 		i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
3986 		i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a);
3987 		i2c_w(sd, 0x25, qvga ? 0x30 : 0x60);
3988 		i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40);
3989 		i2c_w_mask(sd, 0x67, qvga ? 0xb0 : 0x90, 0xf0);
3990 		i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20);
3991 		i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
3992 		i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
3993 		if (sd->sensor == SEN_OV76BE)
3994 			i2c_w(sd, 0x35, qvga ? 0x1e : 0x9e);
3995 		break;
3996 	case SEN_OV7640:
3997 	case SEN_OV7648:
3998 		i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
3999 		i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
4000 		/* Setting this undocumented bit in qvga mode removes a very
4001 		   annoying vertical shaking of the image */
4002 		i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40);
4003 		/* Unknown */
4004 		i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0);
4005 		/* Allow higher automatic gain (to allow higher framerates) */
4006 		i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20);
4007 		i2c_w_mask(sd, 0x12, 0x04, 0x04); /* AWB: 1 */
4008 		break;
4009 	case SEN_OV7670:
4010 		/* set COM7_FMT_VGA or COM7_FMT_QVGA
4011 		 * do we need to set anything else?
4012 		 *	HSTART etc are set in set_ov_sensor_window itself */
4013 		i2c_w_mask(sd, OV7670_R12_COM7,
4014 			 qvga ? OV7670_COM7_FMT_QVGA : OV7670_COM7_FMT_VGA,
4015 			 OV7670_COM7_FMT_MASK);
4016 		i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
4017 		i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_AWB,
4018 				OV7670_COM8_AWB);
4019 		if (qvga) {		/* QVGA from ov7670.c by
4020 					 * Jonathan Corbet */
4021 			xstart = 164;
4022 			xend = 28;
4023 			ystart = 14;
4024 			yend = 494;
4025 		} else {		/* VGA */
4026 			xstart = 158;
4027 			xend = 14;
4028 			ystart = 10;
4029 			yend = 490;
4030 		}
4031 		/* OV7670 hardware window registers are split across
4032 		 * multiple locations */
4033 		i2c_w(sd, OV7670_R17_HSTART, xstart >> 3);
4034 		i2c_w(sd, OV7670_R18_HSTOP, xend >> 3);
4035 		v = i2c_r(sd, OV7670_R32_HREF);
4036 		v = (v & 0xc0) | ((xend & 0x7) << 3) | (xstart & 0x07);
4037 		msleep(10);	/* need to sleep between read and write to
4038 				 * same reg! */
4039 		i2c_w(sd, OV7670_R32_HREF, v);
4040 
4041 		i2c_w(sd, OV7670_R19_VSTART, ystart >> 2);
4042 		i2c_w(sd, OV7670_R1A_VSTOP, yend >> 2);
4043 		v = i2c_r(sd, OV7670_R03_VREF);
4044 		v = (v & 0xc0) | ((yend & 0x3) << 2) | (ystart & 0x03);
4045 		msleep(10);	/* need to sleep between read and write to
4046 				 * same reg! */
4047 		i2c_w(sd, OV7670_R03_VREF, v);
4048 		break;
4049 	case SEN_OV6620:
4050 		i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
4051 		i2c_w_mask(sd, 0x13, 0x00, 0x20); /* Select 16 bit data bus */
4052 		i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
4053 		break;
4054 	case SEN_OV6630:
4055 	case SEN_OV66308AF:
4056 		i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
4057 		i2c_w_mask(sd, 0x12, 0x04, 0x06); /* AWB: 1 Test pattern: 0 */
4058 		break;
4059 	case SEN_OV9600: {
4060 		const struct ov_i2c_regvals *vals;
4061 		static const struct ov_i2c_regvals sxga_15[] = {
4062 			{0x11, 0x80}, {0x14, 0x3e}, {0x24, 0x85}, {0x25, 0x75}
4063 		};
4064 		static const struct ov_i2c_regvals sxga_7_5[] = {
4065 			{0x11, 0x81}, {0x14, 0x3e}, {0x24, 0x85}, {0x25, 0x75}
4066 		};
4067 		static const struct ov_i2c_regvals vga_30[] = {
4068 			{0x11, 0x81}, {0x14, 0x7e}, {0x24, 0x70}, {0x25, 0x60}
4069 		};
4070 		static const struct ov_i2c_regvals vga_15[] = {
4071 			{0x11, 0x83}, {0x14, 0x3e}, {0x24, 0x80}, {0x25, 0x70}
4072 		};
4073 
4074 		/* frame rates:
4075 		 *	15fps / 7.5 fps for 1280x1024
4076 		 *	30fps / 15fps for 640x480
4077 		 */
4078 		i2c_w_mask(sd, 0x12, qvga ? 0x40 : 0x00, 0x40);
4079 		if (qvga)
4080 			vals = sd->frame_rate < 30 ? vga_15 : vga_30;
4081 		else
4082 			vals = sd->frame_rate < 15 ? sxga_7_5 : sxga_15;
4083 		write_i2c_regvals(sd, vals, ARRAY_SIZE(sxga_15));
4084 		return;
4085 	    }
4086 	default:
4087 		return;
4088 	}
4089 
4090 	/******** Clock programming ********/
4091 	i2c_w(sd, 0x11, sd->clockdiv);
4092 }
4093 
4094 /* this function works for bridge ov519 and sensors ov7660 and ov7670 only */
sethvflip(struct gspca_dev * gspca_dev,s32 hflip,s32 vflip)4095 static void sethvflip(struct gspca_dev *gspca_dev, s32 hflip, s32 vflip)
4096 {
4097 	struct sd *sd = (struct sd *) gspca_dev;
4098 
4099 	if (sd->gspca_dev.streaming)
4100 		reg_w(sd, OV519_R51_RESET1, 0x0f);	/* block stream */
4101 	i2c_w_mask(sd, OV7670_R1E_MVFP,
4102 		OV7670_MVFP_MIRROR * hflip | OV7670_MVFP_VFLIP * vflip,
4103 		OV7670_MVFP_MIRROR | OV7670_MVFP_VFLIP);
4104 	if (sd->gspca_dev.streaming)
4105 		reg_w(sd, OV519_R51_RESET1, 0x00);	/* restart stream */
4106 }
4107 
set_ov_sensor_window(struct sd * sd)4108 static void set_ov_sensor_window(struct sd *sd)
4109 {
4110 	struct gspca_dev *gspca_dev;
4111 	int qvga, crop;
4112 	int hwsbase, hwebase, vwsbase, vwebase, hwscale, vwscale;
4113 
4114 	/* mode setup is fully handled in mode_init_ov_sensor_regs for these */
4115 	switch (sd->sensor) {
4116 	case SEN_OV2610:
4117 	case SEN_OV2610AE:
4118 	case SEN_OV3610:
4119 	case SEN_OV7670:
4120 	case SEN_OV9600:
4121 		mode_init_ov_sensor_regs(sd);
4122 		return;
4123 	case SEN_OV7660:
4124 		ov519_set_mode(sd);
4125 		ov519_set_fr(sd);
4126 		return;
4127 	}
4128 
4129 	gspca_dev = &sd->gspca_dev;
4130 	qvga = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv & 1;
4131 	crop = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv & 2;
4132 
4133 	/* The different sensor ICs handle setting up of window differently.
4134 	 * IF YOU SET IT WRONG, YOU WILL GET ALL ZERO ISOC DATA FROM OV51x!! */
4135 	switch (sd->sensor) {
4136 	case SEN_OV8610:
4137 		hwsbase = 0x1e;
4138 		hwebase = 0x1e;
4139 		vwsbase = 0x02;
4140 		vwebase = 0x02;
4141 		break;
4142 	case SEN_OV7610:
4143 	case SEN_OV76BE:
4144 		hwsbase = 0x38;
4145 		hwebase = 0x3a;
4146 		vwsbase = vwebase = 0x05;
4147 		break;
4148 	case SEN_OV6620:
4149 	case SEN_OV6630:
4150 	case SEN_OV66308AF:
4151 		hwsbase = 0x38;
4152 		hwebase = 0x3a;
4153 		vwsbase = 0x05;
4154 		vwebase = 0x06;
4155 		if (sd->sensor == SEN_OV66308AF && qvga)
4156 			/* HDG: this fixes U and V getting swapped */
4157 			hwsbase++;
4158 		if (crop) {
4159 			hwsbase += 8;
4160 			hwebase += 8;
4161 			vwsbase += 11;
4162 			vwebase += 11;
4163 		}
4164 		break;
4165 	case SEN_OV7620:
4166 	case SEN_OV7620AE:
4167 		hwsbase = 0x2f;		/* From 7620.SET (spec is wrong) */
4168 		hwebase = 0x2f;
4169 		vwsbase = vwebase = 0x05;
4170 		break;
4171 	case SEN_OV7640:
4172 	case SEN_OV7648:
4173 		hwsbase = 0x1a;
4174 		hwebase = 0x1a;
4175 		vwsbase = vwebase = 0x03;
4176 		break;
4177 	default:
4178 		return;
4179 	}
4180 
4181 	switch (sd->sensor) {
4182 	case SEN_OV6620:
4183 	case SEN_OV6630:
4184 	case SEN_OV66308AF:
4185 		if (qvga) {		/* QCIF */
4186 			hwscale = 0;
4187 			vwscale = 0;
4188 		} else {		/* CIF */
4189 			hwscale = 1;
4190 			vwscale = 1;	/* The datasheet says 0;
4191 					 * it's wrong */
4192 		}
4193 		break;
4194 	case SEN_OV8610:
4195 		if (qvga) {		/* QSVGA */
4196 			hwscale = 1;
4197 			vwscale = 1;
4198 		} else {		/* SVGA */
4199 			hwscale = 2;
4200 			vwscale = 2;
4201 		}
4202 		break;
4203 	default:			/* SEN_OV7xx0 */
4204 		if (qvga) {		/* QVGA */
4205 			hwscale = 1;
4206 			vwscale = 0;
4207 		} else {		/* VGA */
4208 			hwscale = 2;
4209 			vwscale = 1;
4210 		}
4211 	}
4212 
4213 	mode_init_ov_sensor_regs(sd);
4214 
4215 	i2c_w(sd, 0x17, hwsbase);
4216 	i2c_w(sd, 0x18, hwebase + (sd->sensor_width >> hwscale));
4217 	i2c_w(sd, 0x19, vwsbase);
4218 	i2c_w(sd, 0x1a, vwebase + (sd->sensor_height >> vwscale));
4219 }
4220 
4221 /* -- start the camera -- */
sd_start(struct gspca_dev * gspca_dev)4222 static int sd_start(struct gspca_dev *gspca_dev)
4223 {
4224 	struct sd *sd = (struct sd *) gspca_dev;
4225 
4226 	/* Default for most bridges, allow bridge_mode_init_regs to override */
4227 	sd->sensor_width = sd->gspca_dev.pixfmt.width;
4228 	sd->sensor_height = sd->gspca_dev.pixfmt.height;
4229 
4230 	switch (sd->bridge) {
4231 	case BRIDGE_OV511:
4232 	case BRIDGE_OV511PLUS:
4233 		ov511_mode_init_regs(sd);
4234 		break;
4235 	case BRIDGE_OV518:
4236 	case BRIDGE_OV518PLUS:
4237 		ov518_mode_init_regs(sd);
4238 		break;
4239 	case BRIDGE_OV519:
4240 		ov519_mode_init_regs(sd);
4241 		break;
4242 	/* case BRIDGE_OVFX2: nothing to do */
4243 	case BRIDGE_W9968CF:
4244 		w9968cf_mode_init_regs(sd);
4245 		break;
4246 	}
4247 
4248 	set_ov_sensor_window(sd);
4249 
4250 	/* Force clear snapshot state in case the snapshot button was
4251 	   pressed while we weren't streaming */
4252 	sd->snapshot_needs_reset = 1;
4253 	sd_reset_snapshot(gspca_dev);
4254 
4255 	sd->first_frame = 3;
4256 
4257 	ov51x_restart(sd);
4258 	ov51x_led_control(sd, 1);
4259 	return gspca_dev->usb_err;
4260 }
4261 
sd_stopN(struct gspca_dev * gspca_dev)4262 static void sd_stopN(struct gspca_dev *gspca_dev)
4263 {
4264 	struct sd *sd = (struct sd *) gspca_dev;
4265 
4266 	ov51x_stop(sd);
4267 	ov51x_led_control(sd, 0);
4268 }
4269 
sd_stop0(struct gspca_dev * gspca_dev)4270 static void sd_stop0(struct gspca_dev *gspca_dev)
4271 {
4272 	struct sd *sd = (struct sd *) gspca_dev;
4273 
4274 	if (!sd->gspca_dev.present)
4275 		return;
4276 	if (sd->bridge == BRIDGE_W9968CF)
4277 		w9968cf_stop0(sd);
4278 
4279 #if IS_ENABLED(CONFIG_INPUT)
4280 	/* If the last button state is pressed, release it now! */
4281 	if (sd->snapshot_pressed) {
4282 		input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
4283 		input_sync(gspca_dev->input_dev);
4284 		sd->snapshot_pressed = 0;
4285 	}
4286 #endif
4287 	if (sd->bridge == BRIDGE_OV519)
4288 		reg_w(sd, OV519_R57_SNAPSHOT, 0x23);
4289 }
4290 
ov51x_handle_button(struct gspca_dev * gspca_dev,u8 state)4291 static void ov51x_handle_button(struct gspca_dev *gspca_dev, u8 state)
4292 {
4293 	struct sd *sd = (struct sd *) gspca_dev;
4294 
4295 	if (sd->snapshot_pressed != state) {
4296 #if IS_ENABLED(CONFIG_INPUT)
4297 		input_report_key(gspca_dev->input_dev, KEY_CAMERA, state);
4298 		input_sync(gspca_dev->input_dev);
4299 #endif
4300 		if (state)
4301 			sd->snapshot_needs_reset = 1;
4302 
4303 		sd->snapshot_pressed = state;
4304 	} else {
4305 		/* On the ov511 / ov519 we need to reset the button state
4306 		   multiple times, as resetting does not work as long as the
4307 		   button stays pressed */
4308 		switch (sd->bridge) {
4309 		case BRIDGE_OV511:
4310 		case BRIDGE_OV511PLUS:
4311 		case BRIDGE_OV519:
4312 			if (state)
4313 				sd->snapshot_needs_reset = 1;
4314 			break;
4315 		}
4316 	}
4317 }
4318 
ov511_pkt_scan(struct gspca_dev * gspca_dev,u8 * in,int len)4319 static void ov511_pkt_scan(struct gspca_dev *gspca_dev,
4320 			u8 *in,			/* isoc packet */
4321 			int len)		/* iso packet length */
4322 {
4323 	struct sd *sd = (struct sd *) gspca_dev;
4324 
4325 	/* SOF/EOF packets have 1st to 8th bytes zeroed and the 9th
4326 	 * byte non-zero. The EOF packet has image width/height in the
4327 	 * 10th and 11th bytes. The 9th byte is given as follows:
4328 	 *
4329 	 * bit 7: EOF
4330 	 *     6: compression enabled
4331 	 *     5: 422/420/400 modes
4332 	 *     4: 422/420/400 modes
4333 	 *     3: 1
4334 	 *     2: snapshot button on
4335 	 *     1: snapshot frame
4336 	 *     0: even/odd field
4337 	 */
4338 	if (!(in[0] | in[1] | in[2] | in[3] | in[4] | in[5] | in[6] | in[7]) &&
4339 	    (in[8] & 0x08)) {
4340 		ov51x_handle_button(gspca_dev, (in[8] >> 2) & 1);
4341 		if (in[8] & 0x80) {
4342 			/* Frame end */
4343 			if ((in[9] + 1) * 8 != gspca_dev->pixfmt.width ||
4344 			    (in[10] + 1) * 8 != gspca_dev->pixfmt.height) {
4345 				gspca_err(gspca_dev, "Invalid frame size, got: %dx%d, requested: %dx%d\n",
4346 					  (in[9] + 1) * 8, (in[10] + 1) * 8,
4347 					  gspca_dev->pixfmt.width,
4348 					  gspca_dev->pixfmt.height);
4349 				gspca_dev->last_packet_type = DISCARD_PACKET;
4350 				return;
4351 			}
4352 			/* Add 11 byte footer to frame, might be useful */
4353 			gspca_frame_add(gspca_dev, LAST_PACKET, in, 11);
4354 			return;
4355 		} else {
4356 			/* Frame start */
4357 			gspca_frame_add(gspca_dev, FIRST_PACKET, in, 0);
4358 			sd->packet_nr = 0;
4359 		}
4360 	}
4361 
4362 	/* Ignore the packet number */
4363 	len--;
4364 
4365 	/* intermediate packet */
4366 	gspca_frame_add(gspca_dev, INTER_PACKET, in, len);
4367 }
4368 
ov518_pkt_scan(struct gspca_dev * gspca_dev,u8 * data,int len)4369 static void ov518_pkt_scan(struct gspca_dev *gspca_dev,
4370 			u8 *data,			/* isoc packet */
4371 			int len)			/* iso packet length */
4372 {
4373 	struct sd *sd = (struct sd *) gspca_dev;
4374 
4375 	/* A false positive here is likely, until OVT gives me
4376 	 * the definitive SOF/EOF format */
4377 	if ((!(data[0] | data[1] | data[2] | data[3] | data[5])) && data[6]) {
4378 		ov51x_handle_button(gspca_dev, (data[6] >> 1) & 1);
4379 		gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
4380 		gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
4381 		sd->packet_nr = 0;
4382 	}
4383 
4384 	if (gspca_dev->last_packet_type == DISCARD_PACKET)
4385 		return;
4386 
4387 	/* Does this device use packet numbers ? */
4388 	if (len & 7) {
4389 		len--;
4390 		if (sd->packet_nr == data[len])
4391 			sd->packet_nr++;
4392 		/* The last few packets of the frame (which are all 0's
4393 		   except that they may contain part of the footer), are
4394 		   numbered 0 */
4395 		else if (sd->packet_nr == 0 || data[len]) {
4396 			gspca_err(gspca_dev, "Invalid packet nr: %d (expect: %d)\n",
4397 				  (int)data[len], (int)sd->packet_nr);
4398 			gspca_dev->last_packet_type = DISCARD_PACKET;
4399 			return;
4400 		}
4401 	}
4402 
4403 	/* intermediate packet */
4404 	gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
4405 }
4406 
ov519_pkt_scan(struct gspca_dev * gspca_dev,u8 * data,int len)4407 static void ov519_pkt_scan(struct gspca_dev *gspca_dev,
4408 			u8 *data,			/* isoc packet */
4409 			int len)			/* iso packet length */
4410 {
4411 	/* Header of ov519 is 16 bytes:
4412 	 *     Byte     Value      Description
4413 	 *	0	0xff	magic
4414 	 *	1	0xff	magic
4415 	 *	2	0xff	magic
4416 	 *	3	0xXX	0x50 = SOF, 0x51 = EOF
4417 	 *	9	0xXX	0x01 initial frame without data,
4418 	 *			0x00 standard frame with image
4419 	 *	14	Lo	in EOF: length of image data / 8
4420 	 *	15	Hi
4421 	 */
4422 
4423 	if (data[0] == 0xff && data[1] == 0xff && data[2] == 0xff) {
4424 		switch (data[3]) {
4425 		case 0x50:		/* start of frame */
4426 			/* Don't check the button state here, as the state
4427 			   usually (always ?) changes at EOF and checking it
4428 			   here leads to unnecessary snapshot state resets. */
4429 #define HDRSZ 16
4430 			data += HDRSZ;
4431 			len -= HDRSZ;
4432 #undef HDRSZ
4433 			if (data[0] == 0xff || data[1] == 0xd8)
4434 				gspca_frame_add(gspca_dev, FIRST_PACKET,
4435 						data, len);
4436 			else
4437 				gspca_dev->last_packet_type = DISCARD_PACKET;
4438 			return;
4439 		case 0x51:		/* end of frame */
4440 			ov51x_handle_button(gspca_dev, data[11] & 1);
4441 			if (data[9] != 0)
4442 				gspca_dev->last_packet_type = DISCARD_PACKET;
4443 			gspca_frame_add(gspca_dev, LAST_PACKET,
4444 					NULL, 0);
4445 			return;
4446 		}
4447 	}
4448 
4449 	/* intermediate packet */
4450 	gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
4451 }
4452 
ovfx2_pkt_scan(struct gspca_dev * gspca_dev,u8 * data,int len)4453 static void ovfx2_pkt_scan(struct gspca_dev *gspca_dev,
4454 			u8 *data,			/* isoc packet */
4455 			int len)			/* iso packet length */
4456 {
4457 	struct sd *sd = (struct sd *) gspca_dev;
4458 
4459 	gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
4460 
4461 	/* A short read signals EOF */
4462 	if (len < gspca_dev->cam.bulk_size) {
4463 		/* If the frame is short, and it is one of the first ones
4464 		   the sensor and bridge are still syncing, so drop it. */
4465 		if (sd->first_frame) {
4466 			sd->first_frame--;
4467 			if (gspca_dev->image_len <
4468 				  sd->gspca_dev.pixfmt.width *
4469 					sd->gspca_dev.pixfmt.height)
4470 				gspca_dev->last_packet_type = DISCARD_PACKET;
4471 		}
4472 		gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
4473 		gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
4474 	}
4475 }
4476 
sd_pkt_scan(struct gspca_dev * gspca_dev,u8 * data,int len)4477 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
4478 			u8 *data,			/* isoc packet */
4479 			int len)			/* iso packet length */
4480 {
4481 	struct sd *sd = (struct sd *) gspca_dev;
4482 
4483 	switch (sd->bridge) {
4484 	case BRIDGE_OV511:
4485 	case BRIDGE_OV511PLUS:
4486 		ov511_pkt_scan(gspca_dev, data, len);
4487 		break;
4488 	case BRIDGE_OV518:
4489 	case BRIDGE_OV518PLUS:
4490 		ov518_pkt_scan(gspca_dev, data, len);
4491 		break;
4492 	case BRIDGE_OV519:
4493 		ov519_pkt_scan(gspca_dev, data, len);
4494 		break;
4495 	case BRIDGE_OVFX2:
4496 		ovfx2_pkt_scan(gspca_dev, data, len);
4497 		break;
4498 	case BRIDGE_W9968CF:
4499 		w9968cf_pkt_scan(gspca_dev, data, len);
4500 		break;
4501 	}
4502 }
4503 
4504 /* -- management routines -- */
4505 
setbrightness(struct gspca_dev * gspca_dev,s32 val)4506 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
4507 {
4508 	struct sd *sd = (struct sd *) gspca_dev;
4509 	static const struct ov_i2c_regvals brit_7660[][7] = {
4510 		{{0x0f, 0x6a}, {0x24, 0x40}, {0x25, 0x2b}, {0x26, 0x90},
4511 			{0x27, 0xe0}, {0x28, 0xe0}, {0x2c, 0xe0}},
4512 		{{0x0f, 0x6a}, {0x24, 0x50}, {0x25, 0x40}, {0x26, 0xa1},
4513 			{0x27, 0xc0}, {0x28, 0xc0}, {0x2c, 0xc0}},
4514 		{{0x0f, 0x6a}, {0x24, 0x68}, {0x25, 0x58}, {0x26, 0xc2},
4515 			{0x27, 0xa0}, {0x28, 0xa0}, {0x2c, 0xa0}},
4516 		{{0x0f, 0x6a}, {0x24, 0x70}, {0x25, 0x68}, {0x26, 0xd3},
4517 			{0x27, 0x80}, {0x28, 0x80}, {0x2c, 0x80}},
4518 		{{0x0f, 0x6a}, {0x24, 0x80}, {0x25, 0x70}, {0x26, 0xd3},
4519 			{0x27, 0x20}, {0x28, 0x20}, {0x2c, 0x20}},
4520 		{{0x0f, 0x6a}, {0x24, 0x88}, {0x25, 0x78}, {0x26, 0xd3},
4521 			{0x27, 0x40}, {0x28, 0x40}, {0x2c, 0x40}},
4522 		{{0x0f, 0x6a}, {0x24, 0x90}, {0x25, 0x80}, {0x26, 0xd4},
4523 			{0x27, 0x60}, {0x28, 0x60}, {0x2c, 0x60}}
4524 	};
4525 
4526 	switch (sd->sensor) {
4527 	case SEN_OV8610:
4528 	case SEN_OV7610:
4529 	case SEN_OV76BE:
4530 	case SEN_OV6620:
4531 	case SEN_OV6630:
4532 	case SEN_OV66308AF:
4533 	case SEN_OV7640:
4534 	case SEN_OV7648:
4535 		i2c_w(sd, OV7610_REG_BRT, val);
4536 		break;
4537 	case SEN_OV7620:
4538 	case SEN_OV7620AE:
4539 		i2c_w(sd, OV7610_REG_BRT, val);
4540 		break;
4541 	case SEN_OV7660:
4542 		write_i2c_regvals(sd, brit_7660[val],
4543 				ARRAY_SIZE(brit_7660[0]));
4544 		break;
4545 	case SEN_OV7670:
4546 /*win trace
4547  *		i2c_w_mask(sd, OV7670_R13_COM8, 0, OV7670_COM8_AEC); */
4548 		i2c_w(sd, OV7670_R55_BRIGHT, ov7670_abs_to_sm(val));
4549 		break;
4550 	}
4551 }
4552 
setcontrast(struct gspca_dev * gspca_dev,s32 val)4553 static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
4554 {
4555 	struct sd *sd = (struct sd *) gspca_dev;
4556 	static const struct ov_i2c_regvals contrast_7660[][31] = {
4557 		{{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf8}, {0x6f, 0xa0},
4558 		 {0x70, 0x58}, {0x71, 0x38}, {0x72, 0x30}, {0x73, 0x30},
4559 		 {0x74, 0x28}, {0x75, 0x28}, {0x76, 0x24}, {0x77, 0x24},
4560 		 {0x78, 0x22}, {0x79, 0x28}, {0x7a, 0x2a}, {0x7b, 0x34},
4561 		 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3d}, {0x7f, 0x65},
4562 		 {0x80, 0x70}, {0x81, 0x77}, {0x82, 0x7d}, {0x83, 0x83},
4563 		 {0x84, 0x88}, {0x85, 0x8d}, {0x86, 0x96}, {0x87, 0x9f},
4564 		 {0x88, 0xb0}, {0x89, 0xc4}, {0x8a, 0xd9}},
4565 		{{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf8}, {0x6f, 0x94},
4566 		 {0x70, 0x58}, {0x71, 0x40}, {0x72, 0x30}, {0x73, 0x30},
4567 		 {0x74, 0x30}, {0x75, 0x30}, {0x76, 0x2c}, {0x77, 0x24},
4568 		 {0x78, 0x22}, {0x79, 0x28}, {0x7a, 0x2a}, {0x7b, 0x31},
4569 		 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3d}, {0x7f, 0x62},
4570 		 {0x80, 0x6d}, {0x81, 0x75}, {0x82, 0x7b}, {0x83, 0x81},
4571 		 {0x84, 0x87}, {0x85, 0x8d}, {0x86, 0x98}, {0x87, 0xa1},
4572 		 {0x88, 0xb2}, {0x89, 0xc6}, {0x8a, 0xdb}},
4573 		{{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf0}, {0x6f, 0x84},
4574 		 {0x70, 0x58}, {0x71, 0x48}, {0x72, 0x40}, {0x73, 0x40},
4575 		 {0x74, 0x28}, {0x75, 0x28}, {0x76, 0x28}, {0x77, 0x24},
4576 		 {0x78, 0x26}, {0x79, 0x28}, {0x7a, 0x28}, {0x7b, 0x34},
4577 		 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3c}, {0x7f, 0x5d},
4578 		 {0x80, 0x68}, {0x81, 0x71}, {0x82, 0x79}, {0x83, 0x81},
4579 		 {0x84, 0x86}, {0x85, 0x8b}, {0x86, 0x95}, {0x87, 0x9e},
4580 		 {0x88, 0xb1}, {0x89, 0xc5}, {0x8a, 0xd9}},
4581 		{{0x6c, 0xf0}, {0x6d, 0xf0}, {0x6e, 0xf0}, {0x6f, 0x70},
4582 		 {0x70, 0x58}, {0x71, 0x58}, {0x72, 0x48}, {0x73, 0x48},
4583 		 {0x74, 0x38}, {0x75, 0x40}, {0x76, 0x34}, {0x77, 0x34},
4584 		 {0x78, 0x2e}, {0x79, 0x28}, {0x7a, 0x24}, {0x7b, 0x22},
4585 		 {0x7c, 0x0f}, {0x7d, 0x1e}, {0x7e, 0x3c}, {0x7f, 0x58},
4586 		 {0x80, 0x63}, {0x81, 0x6e}, {0x82, 0x77}, {0x83, 0x80},
4587 		 {0x84, 0x87}, {0x85, 0x8f}, {0x86, 0x9c}, {0x87, 0xa9},
4588 		 {0x88, 0xc0}, {0x89, 0xd4}, {0x8a, 0xe6}},
4589 		{{0x6c, 0xa0}, {0x6d, 0xf0}, {0x6e, 0x90}, {0x6f, 0x80},
4590 		 {0x70, 0x70}, {0x71, 0x80}, {0x72, 0x60}, {0x73, 0x60},
4591 		 {0x74, 0x58}, {0x75, 0x60}, {0x76, 0x4c}, {0x77, 0x38},
4592 		 {0x78, 0x38}, {0x79, 0x2a}, {0x7a, 0x20}, {0x7b, 0x0e},
4593 		 {0x7c, 0x0a}, {0x7d, 0x14}, {0x7e, 0x26}, {0x7f, 0x46},
4594 		 {0x80, 0x54}, {0x81, 0x64}, {0x82, 0x70}, {0x83, 0x7c},
4595 		 {0x84, 0x87}, {0x85, 0x93}, {0x86, 0xa6}, {0x87, 0xb4},
4596 		 {0x88, 0xd0}, {0x89, 0xe5}, {0x8a, 0xf5}},
4597 		{{0x6c, 0x60}, {0x6d, 0x80}, {0x6e, 0x60}, {0x6f, 0x80},
4598 		 {0x70, 0x80}, {0x71, 0x80}, {0x72, 0x88}, {0x73, 0x30},
4599 		 {0x74, 0x70}, {0x75, 0x68}, {0x76, 0x64}, {0x77, 0x50},
4600 		 {0x78, 0x3c}, {0x79, 0x22}, {0x7a, 0x10}, {0x7b, 0x08},
4601 		 {0x7c, 0x06}, {0x7d, 0x0e}, {0x7e, 0x1a}, {0x7f, 0x3a},
4602 		 {0x80, 0x4a}, {0x81, 0x5a}, {0x82, 0x6b}, {0x83, 0x7b},
4603 		 {0x84, 0x89}, {0x85, 0x96}, {0x86, 0xaf}, {0x87, 0xc3},
4604 		 {0x88, 0xe1}, {0x89, 0xf2}, {0x8a, 0xfa}},
4605 		{{0x6c, 0x20}, {0x6d, 0x40}, {0x6e, 0x20}, {0x6f, 0x60},
4606 		 {0x70, 0x88}, {0x71, 0xc8}, {0x72, 0xc0}, {0x73, 0xb8},
4607 		 {0x74, 0xa8}, {0x75, 0xb8}, {0x76, 0x80}, {0x77, 0x5c},
4608 		 {0x78, 0x26}, {0x79, 0x10}, {0x7a, 0x08}, {0x7b, 0x04},
4609 		 {0x7c, 0x02}, {0x7d, 0x06}, {0x7e, 0x0a}, {0x7f, 0x22},
4610 		 {0x80, 0x33}, {0x81, 0x4c}, {0x82, 0x64}, {0x83, 0x7b},
4611 		 {0x84, 0x90}, {0x85, 0xa7}, {0x86, 0xc7}, {0x87, 0xde},
4612 		 {0x88, 0xf1}, {0x89, 0xf9}, {0x8a, 0xfd}},
4613 	};
4614 
4615 	switch (sd->sensor) {
4616 	case SEN_OV7610:
4617 	case SEN_OV6620:
4618 		i2c_w(sd, OV7610_REG_CNT, val);
4619 		break;
4620 	case SEN_OV6630:
4621 	case SEN_OV66308AF:
4622 		i2c_w_mask(sd, OV7610_REG_CNT, val >> 4, 0x0f);
4623 		break;
4624 	case SEN_OV8610: {
4625 		static const u8 ctab[] = {
4626 			0x03, 0x09, 0x0b, 0x0f, 0x53, 0x6f, 0x35, 0x7f
4627 		};
4628 
4629 		/* Use Y gamma control instead. Bit 0 enables it. */
4630 		i2c_w(sd, 0x64, ctab[val >> 5]);
4631 		break;
4632 	    }
4633 	case SEN_OV7620:
4634 	case SEN_OV7620AE: {
4635 		static const u8 ctab[] = {
4636 			0x01, 0x05, 0x09, 0x11, 0x15, 0x35, 0x37, 0x57,
4637 			0x5b, 0xa5, 0xa7, 0xc7, 0xc9, 0xcf, 0xef, 0xff
4638 		};
4639 
4640 		/* Use Y gamma control instead. Bit 0 enables it. */
4641 		i2c_w(sd, 0x64, ctab[val >> 4]);
4642 		break;
4643 	    }
4644 	case SEN_OV7660:
4645 		write_i2c_regvals(sd, contrast_7660[val],
4646 					ARRAY_SIZE(contrast_7660[0]));
4647 		break;
4648 	case SEN_OV7670:
4649 		/* check that this isn't just the same as ov7610 */
4650 		i2c_w(sd, OV7670_R56_CONTRAS, val >> 1);
4651 		break;
4652 	}
4653 }
4654 
setexposure(struct gspca_dev * gspca_dev,s32 val)4655 static void setexposure(struct gspca_dev *gspca_dev, s32 val)
4656 {
4657 	struct sd *sd = (struct sd *) gspca_dev;
4658 
4659 	i2c_w(sd, 0x10, val);
4660 }
4661 
setcolors(struct gspca_dev * gspca_dev,s32 val)4662 static void setcolors(struct gspca_dev *gspca_dev, s32 val)
4663 {
4664 	struct sd *sd = (struct sd *) gspca_dev;
4665 	static const struct ov_i2c_regvals colors_7660[][6] = {
4666 		{{0x4f, 0x28}, {0x50, 0x2a}, {0x51, 0x02}, {0x52, 0x0a},
4667 		 {0x53, 0x19}, {0x54, 0x23}},
4668 		{{0x4f, 0x47}, {0x50, 0x4a}, {0x51, 0x03}, {0x52, 0x11},
4669 		 {0x53, 0x2c}, {0x54, 0x3e}},
4670 		{{0x4f, 0x66}, {0x50, 0x6b}, {0x51, 0x05}, {0x52, 0x19},
4671 		 {0x53, 0x40}, {0x54, 0x59}},
4672 		{{0x4f, 0x84}, {0x50, 0x8b}, {0x51, 0x06}, {0x52, 0x20},
4673 		 {0x53, 0x53}, {0x54, 0x73}},
4674 		{{0x4f, 0xa3}, {0x50, 0xab}, {0x51, 0x08}, {0x52, 0x28},
4675 		 {0x53, 0x66}, {0x54, 0x8e}},
4676 	};
4677 
4678 	switch (sd->sensor) {
4679 	case SEN_OV8610:
4680 	case SEN_OV7610:
4681 	case SEN_OV76BE:
4682 	case SEN_OV6620:
4683 	case SEN_OV6630:
4684 	case SEN_OV66308AF:
4685 		i2c_w(sd, OV7610_REG_SAT, val);
4686 		break;
4687 	case SEN_OV7620:
4688 	case SEN_OV7620AE:
4689 		/* Use UV gamma control instead. Bits 0 & 7 are reserved. */
4690 /*		rc = ov_i2c_write(sd->dev, 0x62, (val >> 9) & 0x7e);
4691 		if (rc < 0)
4692 			goto out; */
4693 		i2c_w(sd, OV7610_REG_SAT, val);
4694 		break;
4695 	case SEN_OV7640:
4696 	case SEN_OV7648:
4697 		i2c_w(sd, OV7610_REG_SAT, val & 0xf0);
4698 		break;
4699 	case SEN_OV7660:
4700 		write_i2c_regvals(sd, colors_7660[val],
4701 					ARRAY_SIZE(colors_7660[0]));
4702 		break;
4703 	case SEN_OV7670:
4704 		/* supported later once I work out how to do it
4705 		 * transparently fail now! */
4706 		/* set REG_COM13 values for UV sat auto mode */
4707 		break;
4708 	}
4709 }
4710 
setautobright(struct gspca_dev * gspca_dev,s32 val)4711 static void setautobright(struct gspca_dev *gspca_dev, s32 val)
4712 {
4713 	struct sd *sd = (struct sd *) gspca_dev;
4714 
4715 	i2c_w_mask(sd, 0x2d, val ? 0x10 : 0x00, 0x10);
4716 }
4717 
setfreq_i(struct sd * sd,s32 val)4718 static void setfreq_i(struct sd *sd, s32 val)
4719 {
4720 	if (sd->sensor == SEN_OV7660
4721 	 || sd->sensor == SEN_OV7670) {
4722 		switch (val) {
4723 		case 0: /* Banding filter disabled */
4724 			i2c_w_mask(sd, OV7670_R13_COM8, 0, OV7670_COM8_BFILT);
4725 			break;
4726 		case 1: /* 50 hz */
4727 			i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_BFILT,
4728 				   OV7670_COM8_BFILT);
4729 			i2c_w_mask(sd, OV7670_R3B_COM11, 0x08, 0x18);
4730 			break;
4731 		case 2: /* 60 hz */
4732 			i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_BFILT,
4733 				   OV7670_COM8_BFILT);
4734 			i2c_w_mask(sd, OV7670_R3B_COM11, 0x00, 0x18);
4735 			break;
4736 		case 3: /* Auto hz - ov7670 only */
4737 			i2c_w_mask(sd, OV7670_R13_COM8, OV7670_COM8_BFILT,
4738 				   OV7670_COM8_BFILT);
4739 			i2c_w_mask(sd, OV7670_R3B_COM11, OV7670_COM11_HZAUTO,
4740 				   0x18);
4741 			break;
4742 		}
4743 	} else {
4744 		switch (val) {
4745 		case 0: /* Banding filter disabled */
4746 			i2c_w_mask(sd, 0x2d, 0x00, 0x04);
4747 			i2c_w_mask(sd, 0x2a, 0x00, 0x80);
4748 			break;
4749 		case 1: /* 50 hz (filter on and framerate adj) */
4750 			i2c_w_mask(sd, 0x2d, 0x04, 0x04);
4751 			i2c_w_mask(sd, 0x2a, 0x80, 0x80);
4752 			/* 20 fps -> 16.667 fps */
4753 			if (sd->sensor == SEN_OV6620 ||
4754 			    sd->sensor == SEN_OV6630 ||
4755 			    sd->sensor == SEN_OV66308AF)
4756 				i2c_w(sd, 0x2b, 0x5e);
4757 			else
4758 				i2c_w(sd, 0x2b, 0xac);
4759 			break;
4760 		case 2: /* 60 hz (filter on, ...) */
4761 			i2c_w_mask(sd, 0x2d, 0x04, 0x04);
4762 			if (sd->sensor == SEN_OV6620 ||
4763 			    sd->sensor == SEN_OV6630 ||
4764 			    sd->sensor == SEN_OV66308AF) {
4765 				/* 20 fps -> 15 fps */
4766 				i2c_w_mask(sd, 0x2a, 0x80, 0x80);
4767 				i2c_w(sd, 0x2b, 0xa8);
4768 			} else {
4769 				/* no framerate adj. */
4770 				i2c_w_mask(sd, 0x2a, 0x00, 0x80);
4771 			}
4772 			break;
4773 		}
4774 	}
4775 }
4776 
setfreq(struct gspca_dev * gspca_dev,s32 val)4777 static void setfreq(struct gspca_dev *gspca_dev, s32 val)
4778 {
4779 	struct sd *sd = (struct sd *) gspca_dev;
4780 
4781 	setfreq_i(sd, val);
4782 
4783 	/* Ugly but necessary */
4784 	if (sd->bridge == BRIDGE_W9968CF)
4785 		w9968cf_set_crop_window(sd);
4786 }
4787 
sd_get_jcomp(struct gspca_dev * gspca_dev,struct v4l2_jpegcompression * jcomp)4788 static int sd_get_jcomp(struct gspca_dev *gspca_dev,
4789 			struct v4l2_jpegcompression *jcomp)
4790 {
4791 	struct sd *sd = (struct sd *) gspca_dev;
4792 
4793 	if (sd->bridge != BRIDGE_W9968CF)
4794 		return -ENOTTY;
4795 
4796 	memset(jcomp, 0, sizeof *jcomp);
4797 	jcomp->quality = v4l2_ctrl_g_ctrl(sd->jpegqual);
4798 	jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT | V4L2_JPEG_MARKER_DQT |
4799 			      V4L2_JPEG_MARKER_DRI;
4800 	return 0;
4801 }
4802 
sd_set_jcomp(struct gspca_dev * gspca_dev,const struct v4l2_jpegcompression * jcomp)4803 static int sd_set_jcomp(struct gspca_dev *gspca_dev,
4804 			const struct v4l2_jpegcompression *jcomp)
4805 {
4806 	struct sd *sd = (struct sd *) gspca_dev;
4807 
4808 	if (sd->bridge != BRIDGE_W9968CF)
4809 		return -ENOTTY;
4810 
4811 	v4l2_ctrl_s_ctrl(sd->jpegqual, jcomp->quality);
4812 	return 0;
4813 }
4814 
sd_g_volatile_ctrl(struct v4l2_ctrl * ctrl)4815 static int sd_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
4816 {
4817 	struct gspca_dev *gspca_dev =
4818 		container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
4819 	struct sd *sd = (struct sd *)gspca_dev;
4820 
4821 	gspca_dev->usb_err = 0;
4822 
4823 	switch (ctrl->id) {
4824 	case V4L2_CID_AUTOGAIN:
4825 		gspca_dev->exposure->val = i2c_r(sd, 0x10);
4826 		break;
4827 	}
4828 	return 0;
4829 }
4830 
sd_s_ctrl(struct v4l2_ctrl * ctrl)4831 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
4832 {
4833 	struct gspca_dev *gspca_dev =
4834 		container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
4835 	struct sd *sd = (struct sd *)gspca_dev;
4836 
4837 	gspca_dev->usb_err = 0;
4838 
4839 	if (!gspca_dev->streaming)
4840 		return 0;
4841 
4842 	switch (ctrl->id) {
4843 	case V4L2_CID_BRIGHTNESS:
4844 		setbrightness(gspca_dev, ctrl->val);
4845 		break;
4846 	case V4L2_CID_CONTRAST:
4847 		setcontrast(gspca_dev, ctrl->val);
4848 		break;
4849 	case V4L2_CID_POWER_LINE_FREQUENCY:
4850 		setfreq(gspca_dev, ctrl->val);
4851 		break;
4852 	case V4L2_CID_AUTOBRIGHTNESS:
4853 		if (ctrl->is_new)
4854 			setautobright(gspca_dev, ctrl->val);
4855 		if (!ctrl->val && sd->brightness->is_new)
4856 			setbrightness(gspca_dev, sd->brightness->val);
4857 		break;
4858 	case V4L2_CID_SATURATION:
4859 		setcolors(gspca_dev, ctrl->val);
4860 		break;
4861 	case V4L2_CID_HFLIP:
4862 		sethvflip(gspca_dev, ctrl->val, sd->vflip->val);
4863 		break;
4864 	case V4L2_CID_AUTOGAIN:
4865 		if (ctrl->is_new)
4866 			setautogain(gspca_dev, ctrl->val);
4867 		if (!ctrl->val && gspca_dev->exposure->is_new)
4868 			setexposure(gspca_dev, gspca_dev->exposure->val);
4869 		break;
4870 	case V4L2_CID_JPEG_COMPRESSION_QUALITY:
4871 		return -EBUSY; /* Should never happen, as we grab the ctrl */
4872 	}
4873 	return gspca_dev->usb_err;
4874 }
4875 
4876 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
4877 	.g_volatile_ctrl = sd_g_volatile_ctrl,
4878 	.s_ctrl = sd_s_ctrl,
4879 };
4880 
sd_init_controls(struct gspca_dev * gspca_dev)4881 static int sd_init_controls(struct gspca_dev *gspca_dev)
4882 {
4883 	struct sd *sd = (struct sd *)gspca_dev;
4884 	struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
4885 
4886 	gspca_dev->vdev.ctrl_handler = hdl;
4887 	v4l2_ctrl_handler_init(hdl, 10);
4888 	if (valid_controls[sd->sensor].has_brightness)
4889 		sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
4890 			V4L2_CID_BRIGHTNESS, 0,
4891 			sd->sensor == SEN_OV7660 ? 6 : 255, 1,
4892 			sd->sensor == SEN_OV7660 ? 3 : 127);
4893 	if (valid_controls[sd->sensor].has_contrast) {
4894 		if (sd->sensor == SEN_OV7660)
4895 			v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
4896 				V4L2_CID_CONTRAST, 0, 6, 1, 3);
4897 		else
4898 			v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
4899 				V4L2_CID_CONTRAST, 0, 255, 1,
4900 				(sd->sensor == SEN_OV6630 ||
4901 				 sd->sensor == SEN_OV66308AF) ? 200 : 127);
4902 	}
4903 	if (valid_controls[sd->sensor].has_sat)
4904 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
4905 			V4L2_CID_SATURATION, 0,
4906 			sd->sensor == SEN_OV7660 ? 4 : 255, 1,
4907 			sd->sensor == SEN_OV7660 ? 2 : 127);
4908 	if (valid_controls[sd->sensor].has_exposure)
4909 		gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
4910 			V4L2_CID_EXPOSURE, 0, 255, 1, 127);
4911 	if (valid_controls[sd->sensor].has_hvflip) {
4912 		sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
4913 			V4L2_CID_HFLIP, 0, 1, 1, 0);
4914 		sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
4915 			V4L2_CID_VFLIP, 0, 1, 1, 0);
4916 	}
4917 	if (valid_controls[sd->sensor].has_autobright)
4918 		sd->autobright = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
4919 			V4L2_CID_AUTOBRIGHTNESS, 0, 1, 1, 1);
4920 	if (valid_controls[sd->sensor].has_autogain)
4921 		gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
4922 			V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
4923 	if (valid_controls[sd->sensor].has_freq) {
4924 		if (sd->sensor == SEN_OV7670)
4925 			sd->freq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
4926 				V4L2_CID_POWER_LINE_FREQUENCY,
4927 				V4L2_CID_POWER_LINE_FREQUENCY_AUTO, 0,
4928 				V4L2_CID_POWER_LINE_FREQUENCY_AUTO);
4929 		else
4930 			sd->freq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
4931 				V4L2_CID_POWER_LINE_FREQUENCY,
4932 				V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0, 0);
4933 	}
4934 	if (sd->bridge == BRIDGE_W9968CF)
4935 		sd->jpegqual = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
4936 			V4L2_CID_JPEG_COMPRESSION_QUALITY,
4937 			QUALITY_MIN, QUALITY_MAX, 1, QUALITY_DEF);
4938 
4939 	if (hdl->error) {
4940 		gspca_err(gspca_dev, "Could not initialize controls\n");
4941 		return hdl->error;
4942 	}
4943 	if (gspca_dev->autogain)
4944 		v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, true);
4945 	if (sd->autobright)
4946 		v4l2_ctrl_auto_cluster(2, &sd->autobright, 0, false);
4947 	if (sd->hflip)
4948 		v4l2_ctrl_cluster(2, &sd->hflip);
4949 	return 0;
4950 }
4951 
4952 /* sub-driver description */
4953 static const struct sd_desc sd_desc = {
4954 	.name = MODULE_NAME,
4955 	.config = sd_config,
4956 	.init = sd_init,
4957 	.init_controls = sd_init_controls,
4958 	.isoc_init = sd_isoc_init,
4959 	.start = sd_start,
4960 	.stopN = sd_stopN,
4961 	.stop0 = sd_stop0,
4962 	.pkt_scan = sd_pkt_scan,
4963 	.dq_callback = sd_reset_snapshot,
4964 	.get_jcomp = sd_get_jcomp,
4965 	.set_jcomp = sd_set_jcomp,
4966 #if IS_ENABLED(CONFIG_INPUT)
4967 	.other_input = 1,
4968 #endif
4969 };
4970 
4971 /* -- module initialisation -- */
4972 static const struct usb_device_id device_table[] = {
4973 	{USB_DEVICE(0x041e, 0x4003), .driver_info = BRIDGE_W9968CF },
4974 	{USB_DEVICE(0x041e, 0x4052),
4975 		.driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
4976 	{USB_DEVICE(0x041e, 0x405f), .driver_info = BRIDGE_OV519 },
4977 	{USB_DEVICE(0x041e, 0x4060), .driver_info = BRIDGE_OV519 },
4978 	{USB_DEVICE(0x041e, 0x4061), .driver_info = BRIDGE_OV519 },
4979 	{USB_DEVICE(0x041e, 0x4064), .driver_info = BRIDGE_OV519 },
4980 	{USB_DEVICE(0x041e, 0x4067), .driver_info = BRIDGE_OV519 },
4981 	{USB_DEVICE(0x041e, 0x4068), .driver_info = BRIDGE_OV519 },
4982 	{USB_DEVICE(0x045e, 0x028c),
4983 		.driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
4984 	{USB_DEVICE(0x054c, 0x0154), .driver_info = BRIDGE_OV519 },
4985 	{USB_DEVICE(0x054c, 0x0155), .driver_info = BRIDGE_OV519 },
4986 	{USB_DEVICE(0x05a9, 0x0511), .driver_info = BRIDGE_OV511 },
4987 	{USB_DEVICE(0x05a9, 0x0518), .driver_info = BRIDGE_OV518 },
4988 	{USB_DEVICE(0x05a9, 0x0519),
4989 		.driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
4990 	{USB_DEVICE(0x05a9, 0x0530),
4991 		.driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
4992 	{USB_DEVICE(0x05a9, 0x2800), .driver_info = BRIDGE_OVFX2 },
4993 	{USB_DEVICE(0x05a9, 0x4519), .driver_info = BRIDGE_OV519 },
4994 	{USB_DEVICE(0x05a9, 0x8519), .driver_info = BRIDGE_OV519 },
4995 	{USB_DEVICE(0x05a9, 0xa511), .driver_info = BRIDGE_OV511PLUS },
4996 	{USB_DEVICE(0x05a9, 0xa518), .driver_info = BRIDGE_OV518PLUS },
4997 	{USB_DEVICE(0x0813, 0x0002), .driver_info = BRIDGE_OV511PLUS },
4998 	{USB_DEVICE(0x0b62, 0x0059), .driver_info = BRIDGE_OVFX2 },
4999 	{USB_DEVICE(0x0e96, 0xc001), .driver_info = BRIDGE_OVFX2 },
5000 	{USB_DEVICE(0x1046, 0x9967), .driver_info = BRIDGE_W9968CF },
5001 	{USB_DEVICE(0x8020, 0xef04), .driver_info = BRIDGE_OVFX2 },
5002 	{}
5003 };
5004 
5005 MODULE_DEVICE_TABLE(usb, device_table);
5006 
5007 /* -- device connect -- */
sd_probe(struct usb_interface * intf,const struct usb_device_id * id)5008 static int sd_probe(struct usb_interface *intf,
5009 			const struct usb_device_id *id)
5010 {
5011 	return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
5012 				THIS_MODULE);
5013 }
5014 
5015 static struct usb_driver sd_driver = {
5016 	.name = MODULE_NAME,
5017 	.id_table = device_table,
5018 	.probe = sd_probe,
5019 	.disconnect = gspca_disconnect,
5020 #ifdef CONFIG_PM
5021 	.suspend = gspca_suspend,
5022 	.resume = gspca_resume,
5023 	.reset_resume = gspca_resume,
5024 #endif
5025 };
5026 
5027 module_usb_driver(sd_driver);
5028 
5029 module_param(frame_rate, int, 0644);
5030 MODULE_PARM_DESC(frame_rate, "Frame rate (5, 10, 15, 20 or 30 fps)");
5031