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