?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: strip: delete the driver
[linux/fpc-iii.git] / drivers / media / video / ov511.c
blobe0bce8dc74bf40f9147f005da042724704992531
1 /*
2 * OmniVision OV511 Camera-to-USB Bridge Driver
3 *
4 * Copyright (c) 1999-2003 Mark W. McClelland
5 * Original decompression code Copyright 1998-2000 OmniVision Technologies
6 * Many improvements by Bret Wallach <bwallac1@san.rr.com>
7 * Color fixes by by Orion Sky Lawlor <olawlor@acm.org> (2/26/2000)
8 * Snapshot code by Kevin Moore
9 * OV7620 fixes by Charl P. Botha <cpbotha@ieee.org>
10 * Changes by Claudio Matsuoka <claudio@conectiva.com>
11 * Original SAA7111A code by Dave Perks <dperks@ibm.net>
12 * URB error messages from pwc driver by Nemosoft
13 * generic_ioctl() code from videodev.c by Gerd Knorr and Alan Cox
14 * Memory management (rvmalloc) code from bttv driver, by Gerd Knorr and others
15 *
16 * Based on the Linux CPiA driver written by Peter Pregler,
17 * Scott J. Bertin and Johannes Erdfelt.
18 *
19 * Please see the file: Documentation/usb/ov511.txt
20 * and the website at: http://alpha.dyndns.org/ov511
21 * for more info.
22 *
23 * This program is free software; you can redistribute it and/or modify it
24 * under the terms of the GNU General Public License as published by the
25 * Free Software Foundation; either version 2 of the License, or (at your
26 * option) any later version.
27 *
28 * This program is distributed in the hope that it will be useful, but
29 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
30 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
31 * for more details.
32 *
33 * You should have received a copy of the GNU General Public License
34 * along with this program; if not, write to the Free Software Foundation,
35 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
36 */
37
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/vmalloc.h>
41 #include <linux/slab.h>
42 #include <linux/ctype.h>
43 #include <linux/pagemap.h>
44 #include <asm/processor.h>
45 #include <linux/mm.h>
46 #include <linux/device.h>
47
48 #if defined (__i386__)
49 #include <asm/cpufeature.h>
50 #endif
51
52 #include "ov511.h"
53
54 /*
55 * Version Information
56 */
57 #define DRIVER_VERSION "v1.64 for Linux 2.5"
58 #define EMAIL "mark@alpha.dyndns.org"
59 #define DRIVER_AUTHOR "Mark McClelland <mark@alpha.dyndns.org> & Bret Wallach \
60 & Orion Sky Lawlor <olawlor@acm.org> & Kevin Moore & Charl P. Botha \
61 <cpbotha@ieee.org> & Claudio Matsuoka <claudio@conectiva.com>"
62 #define DRIVER_DESC "ov511 USB Camera Driver"
63
64 #define OV511_I2C_RETRIES 3
65 #define ENABLE_Y_QUANTABLE 1
66 #define ENABLE_UV_QUANTABLE 1
67
68 #define OV511_MAX_UNIT_VIDEO 16
69
70 /* Pixel count * bytes per YUV420 pixel (1.5) */
71 #define MAX_FRAME_SIZE(w, h) ((w) * (h) * 3 / 2)
72
73 #define MAX_DATA_SIZE(w, h) (MAX_FRAME_SIZE(w, h) + sizeof(struct timeval))
74
75 /* Max size * bytes per YUV420 pixel (1.5) + one extra isoc frame for safety */
76 #define MAX_RAW_DATA_SIZE(w, h) ((w) * (h) * 3 / 2 + 1024)
77
78 #define FATAL_ERROR(rc) ((rc) < 0 && (rc) != -EPERM)
79
80 /**********************************************************************
81 * Module Parameters
82 * (See ov511.txt for detailed descriptions of these)
83 **********************************************************************/
84
85 /* These variables (and all static globals) default to zero */
86 static int autobright = 1;
87 static int autogain = 1;
88 static int autoexp = 1;
89 static int debug;
90 static int snapshot;
91 static int cams = 1;
92 static int compress;
93 static int testpat;
94 static int dumppix;
95 static int led = 1;
96 static int dump_bridge;
97 static int dump_sensor;
98 static int printph;
99 static int phy = 0x1f;
100 static int phuv = 0x05;
101 static int pvy = 0x06;
102 static int pvuv = 0x06;
103 static int qhy = 0x14;
104 static int qhuv = 0x03;
105 static int qvy = 0x04;
106 static int qvuv = 0x04;
107 static int lightfreq;
108 static int bandingfilter;
109 static int clockdiv = -1;
110 static int packetsize = -1;
111 static int framedrop = -1;
112 static int fastset;
113 static int force_palette;
114 static int backlight;
115 /* Bitmask marking allocated devices from 0 to OV511_MAX_UNIT_VIDEO */
116 static unsigned long ov511_devused;
117 static int unit_video[OV511_MAX_UNIT_VIDEO];
118 static int remove_zeros;
119 static int mirror;
120 static int ov518_color;
121
122 module_param(autobright, int, 0);
123 MODULE_PARM_DESC(autobright, "Sensor automatically changes brightness");
124 module_param(autogain, int, 0);
125 MODULE_PARM_DESC(autogain, "Sensor automatically changes gain");
126 module_param(autoexp, int, 0);
127 MODULE_PARM_DESC(autoexp, "Sensor automatically changes exposure");
128 module_param(debug, int, 0);
129 MODULE_PARM_DESC(debug,
130 "Debug level: 0=none, 1=inits, 2=warning, 3=config, 4=functions, 5=max");
131 module_param(snapshot, int, 0);
132 MODULE_PARM_DESC(snapshot, "Enable snapshot mode");
133 module_param(cams, int, 0);
134 MODULE_PARM_DESC(cams, "Number of simultaneous cameras");
135 module_param(compress, int, 0);
136 MODULE_PARM_DESC(compress, "Turn on compression");
137 module_param(testpat, int, 0);
138 MODULE_PARM_DESC(testpat,
139 "Replace image with vertical bar testpattern (only partially working)");
140 module_param(dumppix, int, 0);
141 MODULE_PARM_DESC(dumppix, "Dump raw pixel data");
142 module_param(led, int, 0);
143 MODULE_PARM_DESC(led,
144 "LED policy (OV511+ or later). 0=off, 1=on (default), 2=auto (on when open)");
145 module_param(dump_bridge, int, 0);
146 MODULE_PARM_DESC(dump_bridge, "Dump the bridge registers");
147 module_param(dump_sensor, int, 0);
148 MODULE_PARM_DESC(dump_sensor, "Dump the sensor registers");
149 module_param(printph, int, 0);
150 MODULE_PARM_DESC(printph, "Print frame start/end headers");
151 module_param(phy, int, 0);
152 MODULE_PARM_DESC(phy, "Prediction range (horiz. Y)");
153 module_param(phuv, int, 0);
154 MODULE_PARM_DESC(phuv, "Prediction range (horiz. UV)");
155 module_param(pvy, int, 0);
156 MODULE_PARM_DESC(pvy, "Prediction range (vert. Y)");
157 module_param(pvuv, int, 0);
158 MODULE_PARM_DESC(pvuv, "Prediction range (vert. UV)");
159 module_param(qhy, int, 0);
160 MODULE_PARM_DESC(qhy, "Quantization threshold (horiz. Y)");
161 module_param(qhuv, int, 0);
162 MODULE_PARM_DESC(qhuv, "Quantization threshold (horiz. UV)");
163 module_param(qvy, int, 0);
164 MODULE_PARM_DESC(qvy, "Quantization threshold (vert. Y)");
165 module_param(qvuv, int, 0);
166 MODULE_PARM_DESC(qvuv, "Quantization threshold (vert. UV)");
167 module_param(lightfreq, int, 0);
168 MODULE_PARM_DESC(lightfreq,
169 "Light frequency. Set to 50 or 60 Hz, or zero for default settings");
170 module_param(bandingfilter, int, 0);
171 MODULE_PARM_DESC(bandingfilter,
172 "Enable banding filter (to reduce effects of fluorescent lighting)");
173 module_param(clockdiv, int, 0);
174 MODULE_PARM_DESC(clockdiv, "Force pixel clock divisor to a specific value");
175 module_param(packetsize, int, 0);
176 MODULE_PARM_DESC(packetsize, "Force a specific isoc packet size");
177 module_param(framedrop, int, 0);
178 MODULE_PARM_DESC(framedrop, "Force a specific frame drop register setting");
179 module_param(fastset, int, 0);
180 MODULE_PARM_DESC(fastset, "Allows picture settings to take effect immediately");
181 module_param(force_palette, int, 0);
182 MODULE_PARM_DESC(force_palette, "Force the palette to a specific value");
183 module_param(backlight, int, 0);
184 MODULE_PARM_DESC(backlight, "For objects that are lit from behind");
185 static unsigned int num_uv;
186 module_param_array(unit_video, int, &num_uv, 0);
187 MODULE_PARM_DESC(unit_video,
188 "Force use of specific minor number(s). 0 is not allowed.");
189 module_param(remove_zeros, int, 0);
190 MODULE_PARM_DESC(remove_zeros,
191 "Remove zero-padding from uncompressed incoming data");
192 module_param(mirror, int, 0);
193 MODULE_PARM_DESC(mirror, "Reverse image horizontally");
194 module_param(ov518_color, int, 0);
195 MODULE_PARM_DESC(ov518_color, "Enable OV518 color (experimental)");
196
197 MODULE_AUTHOR(DRIVER_AUTHOR);
198 MODULE_DESCRIPTION(DRIVER_DESC);
199 MODULE_LICENSE("GPL");
200
201 /**********************************************************************
202 * Miscellaneous Globals
203 **********************************************************************/
204
205 static struct usb_driver ov511_driver;
206
207 /* Number of times to retry a failed I2C transaction. Increase this if you
208 * are getting "Failed to read sensor ID..." */
209 static const int i2c_detect_tries = 5;
210
211 static struct usb_device_id device_table [] = {
212 { USB_DEVICE(VEND_OMNIVISION, PROD_OV511) },
213 { USB_DEVICE(VEND_OMNIVISION, PROD_OV511PLUS) },
214 { USB_DEVICE(VEND_MATTEL, PROD_ME2CAM) },
215 { } /* Terminating entry */
216 };
217
218 MODULE_DEVICE_TABLE (usb, device_table);
219
220 static unsigned char yQuanTable511[] = OV511_YQUANTABLE;
221 static unsigned char uvQuanTable511[] = OV511_UVQUANTABLE;
222 static unsigned char yQuanTable518[] = OV518_YQUANTABLE;
223 static unsigned char uvQuanTable518[] = OV518_UVQUANTABLE;
224
225 /**********************************************************************
226 * Symbolic Names
227 **********************************************************************/
228
229 /* Known OV511-based cameras */
230 static struct symbolic_list camlist[] = {
231 { 0, "Generic Camera (no ID)" },
232 { 1, "Mustek WCam 3X" },
233 { 3, "D-Link DSB-C300" },
234 { 4, "Generic OV511/OV7610" },
235 { 5, "Puretek PT-6007" },
236 { 6, "Lifeview USB Life TV (NTSC)" },
237 { 21, "Creative Labs WebCam 3" },
238 { 22, "Lifeview USB Life TV (PAL D/K+B/G)" },
239 { 36, "Koala-Cam" },
240 { 38, "Lifeview USB Life TV (PAL)" },
241 { 41, "Samsung Anycam MPC-M10" },
242 { 43, "Mtekvision Zeca MV402" },
243 { 46, "Suma eON" },
244 { 70, "Lifeview USB Life TV (PAL/SECAM)" },
245 { 100, "Lifeview RoboCam" },
246 { 102, "AverMedia InterCam Elite" },
247 { 112, "MediaForte MV300" }, /* or OV7110 evaluation kit */
248 { 134, "Ezonics EZCam II" },
249 { 192, "Webeye 2000B" },
250 { 253, "Alpha Vision Tech. AlphaCam SE" },
251 { -1, NULL }
252 };
253
254 /* Video4Linux1 Palettes */
255 static struct symbolic_list v4l1_plist[] = {
256 { VIDEO_PALETTE_GREY, "GREY" },
257 { VIDEO_PALETTE_HI240, "HI240" },
258 { VIDEO_PALETTE_RGB565, "RGB565" },
259 { VIDEO_PALETTE_RGB24, "RGB24" },
260 { VIDEO_PALETTE_RGB32, "RGB32" },
261 { VIDEO_PALETTE_RGB555, "RGB555" },
262 { VIDEO_PALETTE_YUV422, "YUV422" },
263 { VIDEO_PALETTE_YUYV, "YUYV" },
264 { VIDEO_PALETTE_UYVY, "UYVY" },
265 { VIDEO_PALETTE_YUV420, "YUV420" },
266 { VIDEO_PALETTE_YUV411, "YUV411" },
267 { VIDEO_PALETTE_RAW, "RAW" },
268 { VIDEO_PALETTE_YUV422P,"YUV422P" },
269 { VIDEO_PALETTE_YUV411P,"YUV411P" },
270 { VIDEO_PALETTE_YUV420P,"YUV420P" },
271 { VIDEO_PALETTE_YUV410P,"YUV410P" },
272 { -1, NULL }
273 };
274
275 static struct symbolic_list brglist[] = {
276 { BRG_OV511, "OV511" },
277 { BRG_OV511PLUS, "OV511+" },
278 { BRG_OV518, "OV518" },
279 { BRG_OV518PLUS, "OV518+" },
280 { -1, NULL }
281 };
282
283 static struct symbolic_list senlist[] = {
284 { SEN_OV76BE, "OV76BE" },
285 { SEN_OV7610, "OV7610" },
286 { SEN_OV7620, "OV7620" },
287 { SEN_OV7620AE, "OV7620AE" },
288 { SEN_OV6620, "OV6620" },
289 { SEN_OV6630, "OV6630" },
290 { SEN_OV6630AE, "OV6630AE" },
291 { SEN_OV6630AF, "OV6630AF" },
292 { SEN_OV8600, "OV8600" },
293 { SEN_KS0127, "KS0127" },
294 { SEN_KS0127B, "KS0127B" },
295 { SEN_SAA7111A, "SAA7111A" },
296 { -1, NULL }
297 };
298
299 /* URB error codes: */
300 static struct symbolic_list urb_errlist[] = {
301 { -ENOSR, "Buffer error (overrun)" },
302 { -EPIPE, "Stalled (device not responding)" },
303 { -EOVERFLOW, "Babble (device sends too much data)" },
304 { -EPROTO, "Bit-stuff error (bad cable?)" },
305 { -EILSEQ, "CRC/Timeout (bad cable?)" },
306 { -ETIME, "Device does not respond to token" },
307 { -ETIMEDOUT, "Device does not respond to command" },
308 { -1, NULL }
309 };
310
311 /**********************************************************************
312 * Memory management
313 **********************************************************************/
314 static void *
315 rvmalloc(unsigned long size)
316 {
317 void *mem;
318 unsigned long adr;
319
320 size = PAGE_ALIGN(size);
321 mem = vmalloc_32(size);
322 if (!mem)
323 return NULL;
324
325 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
326 adr = (unsigned long) mem;
327 while (size > 0) {
328 SetPageReserved(vmalloc_to_page((void *)adr));
329 adr += PAGE_SIZE;
330 size -= PAGE_SIZE;
331 }
332
333 return mem;
334 }
335
336 static void
337 rvfree(void *mem, unsigned long size)
338 {
339 unsigned long adr;
340
341 if (!mem)
342 return;
343
344 adr = (unsigned long) mem;
345 while ((long) size > 0) {
346 ClearPageReserved(vmalloc_to_page((void *)adr));
347 adr += PAGE_SIZE;
348 size -= PAGE_SIZE;
349 }
350 vfree(mem);
351 }
352
353 /**********************************************************************
354 *
355 * Register I/O
356 *
357 **********************************************************************/
358
359 /* Write an OV51x register */
360 static int
361 reg_w(struct usb_ov511 *ov, unsigned char reg, unsigned char value)
362 {
363 int rc;
364
365 PDEBUG(5, "0x%02X:0x%02X", reg, value);
366
367 mutex_lock(&ov->cbuf_lock);
368 ov->cbuf[0] = value;
369 rc = usb_control_msg(ov->dev,
370 usb_sndctrlpipe(ov->dev, 0),
371 (ov->bclass == BCL_OV518)?1:2 /* REG_IO */,
372 USB_TYPE_VENDOR | USB_RECIP_DEVICE,
373 0, (__u16)reg, &ov->cbuf[0], 1, 1000);
374 mutex_unlock(&ov->cbuf_lock);
375
376 if (rc < 0)
377 err("reg write: error %d: %s", rc, symbolic(urb_errlist, rc));
378
379 return rc;
380 }
381
382 /* Read from an OV51x register */
383 /* returns: negative is error, pos or zero is data */
384 static int
385 reg_r(struct usb_ov511 *ov, unsigned char reg)
386 {
387 int rc;
388
389 mutex_lock(&ov->cbuf_lock);
390 rc = usb_control_msg(ov->dev,
391 usb_rcvctrlpipe(ov->dev, 0),
392 (ov->bclass == BCL_OV518)?1:3 /* REG_IO */,
393 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
394 0, (__u16)reg, &ov->cbuf[0], 1, 1000);
395
396 if (rc < 0) {
397 err("reg read: error %d: %s", rc, symbolic(urb_errlist, rc));
398 } else {
399 rc = ov->cbuf[0];
400 PDEBUG(5, "0x%02X:0x%02X", reg, ov->cbuf[0]);
401 }
402
403 mutex_unlock(&ov->cbuf_lock);
404
405 return rc;
406 }
407
408 /*
409 * Writes bits at positions specified by mask to an OV51x reg. Bits that are in
410 * the same position as 1's in "mask" are cleared and set to "value". Bits
411 * that are in the same position as 0's in "mask" are preserved, regardless
412 * of their respective state in "value".
413 */
414 static int
415 reg_w_mask(struct usb_ov511 *ov,
416 unsigned char reg,
417 unsigned char value,
418 unsigned char mask)
419 {
420 int ret;
421 unsigned char oldval, newval;
422
423 ret = reg_r(ov, reg);
424 if (ret < 0)
425 return ret;
426
427 oldval = (unsigned char) ret;
428 oldval &= (~mask); /* Clear the masked bits */
429 value &= mask; /* Enforce mask on value */
430 newval = oldval | value; /* Set the desired bits */
431
432 return (reg_w(ov, reg, newval));
433 }
434
435 /*
436 * Writes multiple (n) byte value to a single register. Only valid with certain
437 * registers (0x30 and 0xc4 - 0xce).
438 */
439 static int
440 ov518_reg_w32(struct usb_ov511 *ov, unsigned char reg, u32 val, int n)
441 {
442 int rc;
443
444 PDEBUG(5, "0x%02X:%7d, n=%d", reg, val, n);
445
446 mutex_lock(&ov->cbuf_lock);
447
448 *((__le32 *)ov->cbuf) = __cpu_to_le32(val);
449
450 rc = usb_control_msg(ov->dev,
451 usb_sndctrlpipe(ov->dev, 0),
452 1 /* REG_IO */,
453 USB_TYPE_VENDOR | USB_RECIP_DEVICE,
454 0, (__u16)reg, ov->cbuf, n, 1000);
455 mutex_unlock(&ov->cbuf_lock);
456
457 if (rc < 0)
458 err("reg write multiple: error %d: %s", rc,
459 symbolic(urb_errlist, rc));
460
461 return rc;
462 }
463
464 static int
465 ov511_upload_quan_tables(struct usb_ov511 *ov)
466 {
467 unsigned char *pYTable = yQuanTable511;
468 unsigned char *pUVTable = uvQuanTable511;
469 unsigned char val0, val1;
470 int i, rc, reg = R511_COMP_LUT_BEGIN;
471
472 PDEBUG(4, "Uploading quantization tables");
473
474 for (i = 0; i < OV511_QUANTABLESIZE / 2; i++) {
475 if (ENABLE_Y_QUANTABLE) {
476 val0 = *pYTable++;
477 val1 = *pYTable++;
478 val0 &= 0x0f;
479 val1 &= 0x0f;
480 val0 |= val1 << 4;
481 rc = reg_w(ov, reg, val0);
482 if (rc < 0)
483 return rc;
484 }
485
486 if (ENABLE_UV_QUANTABLE) {
487 val0 = *pUVTable++;
488 val1 = *pUVTable++;
489 val0 &= 0x0f;
490 val1 &= 0x0f;
491 val0 |= val1 << 4;
492 rc = reg_w(ov, reg + OV511_QUANTABLESIZE/2, val0);
493 if (rc < 0)
494 return rc;
495 }
496
497 reg++;
498 }
499
500 return 0;
501 }
502
503 /* OV518 quantization tables are 8x4 (instead of 8x8) */
504 static int
505 ov518_upload_quan_tables(struct usb_ov511 *ov)
506 {
507 unsigned char *pYTable = yQuanTable518;
508 unsigned char *pUVTable = uvQuanTable518;
509 unsigned char val0, val1;
510 int i, rc, reg = R511_COMP_LUT_BEGIN;
511
512 PDEBUG(4, "Uploading quantization tables");
513
514 for (i = 0; i < OV518_QUANTABLESIZE / 2; i++) {
515 if (ENABLE_Y_QUANTABLE) {
516 val0 = *pYTable++;
517 val1 = *pYTable++;
518 val0 &= 0x0f;
519 val1 &= 0x0f;
520 val0 |= val1 << 4;
521 rc = reg_w(ov, reg, val0);
522 if (rc < 0)
523 return rc;
524 }
525
526 if (ENABLE_UV_QUANTABLE) {
527 val0 = *pUVTable++;
528 val1 = *pUVTable++;
529 val0 &= 0x0f;
530 val1 &= 0x0f;
531 val0 |= val1 << 4;
532 rc = reg_w(ov, reg + OV518_QUANTABLESIZE/2, val0);
533 if (rc < 0)
534 return rc;
535 }
536
537 reg++;
538 }
539
540 return 0;
541 }
542
543 static int
544 ov51x_reset(struct usb_ov511 *ov, unsigned char reset_type)
545 {
546 int rc;
547
548 /* Setting bit 0 not allowed on 518/518Plus */
549 if (ov->bclass == BCL_OV518)
550 reset_type &= 0xfe;
551
552 PDEBUG(4, "Reset: type=0x%02X", reset_type);
553
554 rc = reg_w(ov, R51x_SYS_RESET, reset_type);
555 rc = reg_w(ov, R51x_SYS_RESET, 0);
556
557 if (rc < 0)
558 err("reset: command failed");
559
560 return rc;
561 }
562
563 /**********************************************************************
564 *
565 * Low-level I2C I/O functions
566 *
567 **********************************************************************/
568
569 /* NOTE: Do not call this function directly!
570 * The OV518 I2C I/O procedure is different, hence, this function.
571 * This is normally only called from i2c_w(). Note that this function
572 * always succeeds regardless of whether the sensor is present and working.
573 */
574 static int
575 ov518_i2c_write_internal(struct usb_ov511 *ov,
576 unsigned char reg,
577 unsigned char value)
578 {
579 int rc;
580
581 PDEBUG(5, "0x%02X:0x%02X", reg, value);
582
583 /* Select camera register */
584 rc = reg_w(ov, R51x_I2C_SADDR_3, reg);
585 if (rc < 0)
586 return rc;
587
588 /* Write "value" to I2C data port of OV511 */
589 rc = reg_w(ov, R51x_I2C_DATA, value);
590 if (rc < 0)
591 return rc;
592
593 /* Initiate 3-byte write cycle */
594 rc = reg_w(ov, R518_I2C_CTL, 0x01);
595 if (rc < 0)
596 return rc;
597
598 return 0;
599 }
600
601 /* NOTE: Do not call this function directly! */
602 static int
603 ov511_i2c_write_internal(struct usb_ov511 *ov,
604 unsigned char reg,
605 unsigned char value)
606 {
607 int rc, retries;
608
609 PDEBUG(5, "0x%02X:0x%02X", reg, value);
610
611 /* Three byte write cycle */
612 for (retries = OV511_I2C_RETRIES; ; ) {
613 /* Select camera register */
614 rc = reg_w(ov, R51x_I2C_SADDR_3, reg);
615 if (rc < 0)
616 break;
617
618 /* Write "value" to I2C data port of OV511 */
619 rc = reg_w(ov, R51x_I2C_DATA, value);
620 if (rc < 0)
621 break;
622
623 /* Initiate 3-byte write cycle */
624 rc = reg_w(ov, R511_I2C_CTL, 0x01);
625 if (rc < 0)
626 break;
627
628 /* Retry until idle */
629 do {
630 rc = reg_r(ov, R511_I2C_CTL);
631 } while (rc > 0 && ((rc&1) == 0));
632 if (rc < 0)
633 break;
634
635 /* Ack? */
636 if ((rc&2) == 0) {
637 rc = 0;
638 break;
639 }
640 #if 0
641 /* I2C abort */
642 reg_w(ov, R511_I2C_CTL, 0x10);
643 #endif
644 if (--retries < 0) {
645 err("i2c write retries exhausted");
646 rc = -1;
647 break;
648 }
649 }
650
651 return rc;
652 }
653
654 /* NOTE: Do not call this function directly!
655 * The OV518 I2C I/O procedure is different, hence, this function.
656 * This is normally only called from i2c_r(). Note that this function
657 * always succeeds regardless of whether the sensor is present and working.
658 */
659 static int
660 ov518_i2c_read_internal(struct usb_ov511 *ov, unsigned char reg)
661 {
662 int rc, value;
663
664 /* Select camera register */
665 rc = reg_w(ov, R51x_I2C_SADDR_2, reg);
666 if (rc < 0)
667 return rc;
668
669 /* Initiate 2-byte write cycle */
670 rc = reg_w(ov, R518_I2C_CTL, 0x03);
671 if (rc < 0)
672 return rc;
673
674 /* Initiate 2-byte read cycle */
675 rc = reg_w(ov, R518_I2C_CTL, 0x05);
676 if (rc < 0)
677 return rc;
678
679 value = reg_r(ov, R51x_I2C_DATA);
680
681 PDEBUG(5, "0x%02X:0x%02X", reg, value);
682
683 return value;
684 }
685
686 /* NOTE: Do not call this function directly!
687 * returns: negative is error, pos or zero is data */
688 static int
689 ov511_i2c_read_internal(struct usb_ov511 *ov, unsigned char reg)
690 {
691 int rc, value, retries;
692
693 /* Two byte write cycle */
694 for (retries = OV511_I2C_RETRIES; ; ) {
695 /* Select camera register */
696 rc = reg_w(ov, R51x_I2C_SADDR_2, reg);
697 if (rc < 0)
698 return rc;
699
700 /* Initiate 2-byte write cycle */
701 rc = reg_w(ov, R511_I2C_CTL, 0x03);
702 if (rc < 0)
703 return rc;
704
705 /* Retry until idle */
706 do {
707 rc = reg_r(ov, R511_I2C_CTL);
708 } while (rc > 0 && ((rc & 1) == 0));
709 if (rc < 0)
710 return rc;
711
712 if ((rc&2) == 0) /* Ack? */
713 break;
714
715 /* I2C abort */
716 reg_w(ov, R511_I2C_CTL, 0x10);
717
718 if (--retries < 0) {
719 err("i2c write retries exhausted");
720 return -1;
721 }
722 }
723
724 /* Two byte read cycle */
725 for (retries = OV511_I2C_RETRIES; ; ) {
726 /* Initiate 2-byte read cycle */
727 rc = reg_w(ov, R511_I2C_CTL, 0x05);
728 if (rc < 0)
729 return rc;
730
731 /* Retry until idle */
732 do {
733 rc = reg_r(ov, R511_I2C_CTL);
734 } while (rc > 0 && ((rc&1) == 0));
735 if (rc < 0)
736 return rc;
737
738 if ((rc&2) == 0) /* Ack? */
739 break;
740
741 /* I2C abort */
742 rc = reg_w(ov, R511_I2C_CTL, 0x10);
743 if (rc < 0)
744 return rc;
745
746 if (--retries < 0) {
747 err("i2c read retries exhausted");
748 return -1;
749 }
750 }
751
752 value = reg_r(ov, R51x_I2C_DATA);
753
754 PDEBUG(5, "0x%02X:0x%02X", reg, value);
755
756 /* This is needed to make i2c_w() work */
757 rc = reg_w(ov, R511_I2C_CTL, 0x05);
758 if (rc < 0)
759 return rc;
760
761 return value;
762 }
763
764 /* returns: negative is error, pos or zero is data */
765 static int
766 i2c_r(struct usb_ov511 *ov, unsigned char reg)
767 {
768 int rc;
769
770 mutex_lock(&ov->i2c_lock);
771
772 if (ov->bclass == BCL_OV518)
773 rc = ov518_i2c_read_internal(ov, reg);
774 else
775 rc = ov511_i2c_read_internal(ov, reg);
776
777 mutex_unlock(&ov->i2c_lock);
778
779 return rc;
780 }
781
782 static int
783 i2c_w(struct usb_ov511 *ov, unsigned char reg, unsigned char value)
784 {
785 int rc;
786
787 mutex_lock(&ov->i2c_lock);
788
789 if (ov->bclass == BCL_OV518)
790 rc = ov518_i2c_write_internal(ov, reg, value);
791 else
792 rc = ov511_i2c_write_internal(ov, reg, value);
793
794 mutex_unlock(&ov->i2c_lock);
795
796 return rc;
797 }
798
799 /* Do not call this function directly! */
800 static int
801 ov51x_i2c_write_mask_internal(struct usb_ov511 *ov,
802 unsigned char reg,
803 unsigned char value,
804 unsigned char mask)
805 {
806 int rc;
807 unsigned char oldval, newval;
808
809 if (mask == 0xff) {
810 newval = value;
811 } else {
812 if (ov->bclass == BCL_OV518)
813 rc = ov518_i2c_read_internal(ov, reg);
814 else
815 rc = ov511_i2c_read_internal(ov, reg);
816 if (rc < 0)
817 return rc;
818
819 oldval = (unsigned char) rc;
820 oldval &= (~mask); /* Clear the masked bits */
821 value &= mask; /* Enforce mask on value */
822 newval = oldval | value; /* Set the desired bits */
823 }
824
825 if (ov->bclass == BCL_OV518)
826 return (ov518_i2c_write_internal(ov, reg, newval));
827 else
828 return (ov511_i2c_write_internal(ov, reg, newval));
829 }
830
831 /* Writes bits at positions specified by mask to an I2C reg. Bits that are in
832 * the same position as 1's in "mask" are cleared and set to "value". Bits
833 * that are in the same position as 0's in "mask" are preserved, regardless
834 * of their respective state in "value".
835 */
836 static int
837 i2c_w_mask(struct usb_ov511 *ov,
838 unsigned char reg,
839 unsigned char value,
840 unsigned char mask)
841 {
842 int rc;
843
844 mutex_lock(&ov->i2c_lock);
845 rc = ov51x_i2c_write_mask_internal(ov, reg, value, mask);
846 mutex_unlock(&ov->i2c_lock);
847
848 return rc;
849 }
850
851 /* Set the read and write slave IDs. The "slave" argument is the write slave,
852 * and the read slave will be set to (slave + 1). ov->i2c_lock should be held
853 * when calling this. This should not be called from outside the i2c I/O
854 * functions.
855 */
856 static int
857 i2c_set_slave_internal(struct usb_ov511 *ov, unsigned char slave)
858 {
859 int rc;
860
861 rc = reg_w(ov, R51x_I2C_W_SID, slave);
862 if (rc < 0)
863 return rc;
864
865 rc = reg_w(ov, R51x_I2C_R_SID, slave + 1);
866 if (rc < 0)
867 return rc;
868
869 return 0;
870 }
871
872 /* Write to a specific I2C slave ID and register, using the specified mask */
873 static int
874 i2c_w_slave(struct usb_ov511 *ov,
875 unsigned char slave,
876 unsigned char reg,
877 unsigned char value,
878 unsigned char mask)
879 {
880 int rc = 0;
881
882 mutex_lock(&ov->i2c_lock);
883
884 /* Set new slave IDs */
885 rc = i2c_set_slave_internal(ov, slave);
886 if (rc < 0)
887 goto out;
888
889 rc = ov51x_i2c_write_mask_internal(ov, reg, value, mask);
890
891 out:
892 /* Restore primary IDs */
893 if (i2c_set_slave_internal(ov, ov->primary_i2c_slave) < 0)
894 err("Couldn't restore primary I2C slave");
895
896 mutex_unlock(&ov->i2c_lock);
897 return rc;
898 }
899
900 /* Read from a specific I2C slave ID and register */
901 static int
902 i2c_r_slave(struct usb_ov511 *ov,
903 unsigned char slave,
904 unsigned char reg)
905 {
906 int rc;
907
908 mutex_lock(&ov->i2c_lock);
909
910 /* Set new slave IDs */
911 rc = i2c_set_slave_internal(ov, slave);
912 if (rc < 0)
913 goto out;
914
915 if (ov->bclass == BCL_OV518)
916 rc = ov518_i2c_read_internal(ov, reg);
917 else
918 rc = ov511_i2c_read_internal(ov, reg);
919
920 out:
921 /* Restore primary IDs */
922 if (i2c_set_slave_internal(ov, ov->primary_i2c_slave) < 0)
923 err("Couldn't restore primary I2C slave");
924
925 mutex_unlock(&ov->i2c_lock);
926 return rc;
927 }
928
929 /* Sets I2C read and write slave IDs. Returns <0 for error */
930 static int
931 ov51x_set_slave_ids(struct usb_ov511 *ov, unsigned char sid)
932 {
933 int rc;
934
935 mutex_lock(&ov->i2c_lock);
936
937 rc = i2c_set_slave_internal(ov, sid);
938 if (rc < 0)
939 goto out;
940
941 // FIXME: Is this actually necessary?
942 rc = ov51x_reset(ov, OV511_RESET_NOREGS);
943 out:
944 mutex_unlock(&ov->i2c_lock);
945 return rc;
946 }
947
948 static int
949 write_regvals(struct usb_ov511 *ov, struct ov511_regvals * pRegvals)
950 {
951 int rc;
952
953 while (pRegvals->bus != OV511_DONE_BUS) {
954 if (pRegvals->bus == OV511_REG_BUS) {
955 if ((rc = reg_w(ov, pRegvals->reg, pRegvals->val)) < 0)
956 return rc;
957 } else if (pRegvals->bus == OV511_I2C_BUS) {
958 if ((rc = i2c_w(ov, pRegvals->reg, pRegvals->val)) < 0)
959 return rc;
960 } else {
961 err("Bad regval array");
962 return -1;
963 }
964 pRegvals++;
965 }
966 return 0;
967 }
968
969 #ifdef OV511_DEBUG
970 static void
971 dump_i2c_range(struct usb_ov511 *ov, int reg1, int regn)
972 {
973 int i, rc;
974
975 for (i = reg1; i <= regn; i++) {
976 rc = i2c_r(ov, i);
977 dev_info(&ov->dev->dev, "Sensor[0x%02X] = 0x%02X\n", i, rc);
978 }
979 }
980
981 static void
982 dump_i2c_regs(struct usb_ov511 *ov)
983 {
984 dev_info(&ov->dev->dev, "I2C REGS\n");
985 dump_i2c_range(ov, 0x00, 0x7C);
986 }
987
988 static void
989 dump_reg_range(struct usb_ov511 *ov, int reg1, int regn)
990 {
991 int i, rc;
992
993 for (i = reg1; i <= regn; i++) {
994 rc = reg_r(ov, i);
995 dev_info(&ov->dev->dev, "OV511[0x%02X] = 0x%02X\n", i, rc);
996 }
997 }
998
999 static void
1000 ov511_dump_regs(struct usb_ov511 *ov)
1001 {
1002 dev_info(&ov->dev->dev, "CAMERA INTERFACE REGS\n");
1003 dump_reg_range(ov, 0x10, 0x1f);
1004 dev_info(&ov->dev->dev, "DRAM INTERFACE REGS\n");
1005 dump_reg_range(ov, 0x20, 0x23);
1006 dev_info(&ov->dev->dev, "ISO FIFO REGS\n");
1007 dump_reg_range(ov, 0x30, 0x31);
1008 dev_info(&ov->dev->dev, "PIO REGS\n");
1009 dump_reg_range(ov, 0x38, 0x39);
1010 dump_reg_range(ov, 0x3e, 0x3e);
1011 dev_info(&ov->dev->dev, "I2C REGS\n");
1012 dump_reg_range(ov, 0x40, 0x49);
1013 dev_info(&ov->dev->dev, "SYSTEM CONTROL REGS\n");
1014 dump_reg_range(ov, 0x50, 0x55);
1015 dump_reg_range(ov, 0x5e, 0x5f);
1016 dev_info(&ov->dev->dev, "OmniCE REGS\n");
1017 dump_reg_range(ov, 0x70, 0x79);
1018 /* NOTE: Quantization tables are not readable. You will get the value
1019 * in reg. 0x79 for every table register */
1020 dump_reg_range(ov, 0x80, 0x9f);
1021 dump_reg_range(ov, 0xa0, 0xbf);
1022
1023 }
1024
1025 static void
1026 ov518_dump_regs(struct usb_ov511 *ov)
1027 {
1028 dev_info(&ov->dev->dev, "VIDEO MODE REGS\n");
1029 dump_reg_range(ov, 0x20, 0x2f);
1030 dev_info(&ov->dev->dev, "DATA PUMP AND SNAPSHOT REGS\n");
1031 dump_reg_range(ov, 0x30, 0x3f);
1032 dev_info(&ov->dev->dev, "I2C REGS\n");
1033 dump_reg_range(ov, 0x40, 0x4f);
1034 dev_info(&ov->dev->dev, "SYSTEM CONTROL AND VENDOR REGS\n");
1035 dump_reg_range(ov, 0x50, 0x5f);
1036 dev_info(&ov->dev->dev, "60 - 6F\n");
1037 dump_reg_range(ov, 0x60, 0x6f);
1038 dev_info(&ov->dev->dev, "70 - 7F\n");
1039 dump_reg_range(ov, 0x70, 0x7f);
1040 dev_info(&ov->dev->dev, "Y QUANTIZATION TABLE\n");
1041 dump_reg_range(ov, 0x80, 0x8f);
1042 dev_info(&ov->dev->dev, "UV QUANTIZATION TABLE\n");
1043 dump_reg_range(ov, 0x90, 0x9f);
1044 dev_info(&ov->dev->dev, "A0 - BF\n");
1045 dump_reg_range(ov, 0xa0, 0xbf);
1046 dev_info(&ov->dev->dev, "CBR\n");
1047 dump_reg_range(ov, 0xc0, 0xcf);
1048 }
1049 #endif
1050
1051 /*****************************************************************************/
1052
1053 /* Temporarily stops OV511 from functioning. Must do this before changing
1054 * registers while the camera is streaming */
1055 static inline int
1056 ov51x_stop(struct usb_ov511 *ov)
1057 {
1058 PDEBUG(4, "stopping");
1059 ov->stopped = 1;
1060 if (ov->bclass == BCL_OV518)
1061 return (reg_w_mask(ov, R51x_SYS_RESET, 0x3a, 0x3a));
1062 else
1063 return (reg_w(ov, R51x_SYS_RESET, 0x3d));
1064 }
1065
1066 /* Restarts OV511 after ov511_stop() is called. Has no effect if it is not
1067 * actually stopped (for performance). */
1068 static inline int
1069 ov51x_restart(struct usb_ov511 *ov)
1070 {
1071 if (ov->stopped) {
1072 PDEBUG(4, "restarting");
1073 ov->stopped = 0;
1074
1075 /* Reinitialize the stream */
1076 if (ov->bclass == BCL_OV518)
1077 reg_w(ov, 0x2f, 0x80);
1078
1079 return (reg_w(ov, R51x_SYS_RESET, 0x00));
1080 }
1081
1082 return 0;
1083 }
1084
1085 /* Sleeps until no frames are active. Returns !0 if got signal */
1086 static int
1087 ov51x_wait_frames_inactive(struct usb_ov511 *ov)
1088 {
1089 return wait_event_interruptible(ov->wq, ov->curframe < 0);
1090 }
1091
1092 /* Resets the hardware snapshot button */
1093 static void
1094 ov51x_clear_snapshot(struct usb_ov511 *ov)
1095 {
1096 if (ov->bclass == BCL_OV511) {
1097 reg_w(ov, R51x_SYS_SNAP, 0x00);
1098 reg_w(ov, R51x_SYS_SNAP, 0x02);
1099 reg_w(ov, R51x_SYS_SNAP, 0x00);
1100 } else if (ov->bclass == BCL_OV518) {
1101 dev_warn(&ov->dev->dev,
1102 "snapshot reset not supported yet on OV518(+)\n");
1103 } else {
1104 dev_err(&ov->dev->dev, "clear snap: invalid bridge type\n");
1105 }
1106 }
1107
1108 #if 0
1109 /* Checks the status of the snapshot button. Returns 1 if it was pressed since
1110 * it was last cleared, and zero in all other cases (including errors) */
1111 static int
1112 ov51x_check_snapshot(struct usb_ov511 *ov)
1113 {
1114 int ret, status = 0;
1115
1116 if (ov->bclass == BCL_OV511) {
1117 ret = reg_r(ov, R51x_SYS_SNAP);
1118 if (ret < 0) {
1119 dev_err(&ov->dev->dev,
1120 "Error checking snspshot status (%d)\n", ret);
1121 } else if (ret & 0x08) {
1122 status = 1;
1123 }
1124 } else if (ov->bclass == BCL_OV518) {
1125 dev_warn(&ov->dev->dev,
1126 "snapshot check not supported yet on OV518(+)\n");
1127 } else {
1128 dev_err(&ov->dev->dev, "clear snap: invalid bridge type\n");
1129 }
1130
1131 return status;
1132 }
1133 #endif
1134
1135 /* This does an initial reset of an OmniVision sensor and ensures that I2C
1136 * is synchronized. Returns <0 for failure.
1137 */
1138 static int
1139 init_ov_sensor(struct usb_ov511 *ov)
1140 {
1141 int i, success;
1142
1143 /* Reset the sensor */
1144 if (i2c_w(ov, 0x12, 0x80) < 0)
1145 return -EIO;
1146
1147 /* Wait for it to initialize */
1148 msleep(150);
1149
1150 for (i = 0, success = 0; i < i2c_detect_tries && !success; i++) {
1151 if ((i2c_r(ov, OV7610_REG_ID_HIGH) == 0x7F) &&
1152 (i2c_r(ov, OV7610_REG_ID_LOW) == 0xA2)) {
1153 success = 1;
1154 continue;
1155 }
1156
1157 /* Reset the sensor */
1158 if (i2c_w(ov, 0x12, 0x80) < 0)
1159 return -EIO;
1160 /* Wait for it to initialize */
1161 msleep(150);
1162 /* Dummy read to sync I2C */
1163 if (i2c_r(ov, 0x00) < 0)
1164 return -EIO;
1165 }
1166
1167 if (!success)
1168 return -EIO;
1169
1170 PDEBUG(1, "I2C synced in %d attempt(s)", i);
1171
1172 return 0;
1173 }
1174
1175 static int
1176 ov511_set_packet_size(struct usb_ov511 *ov, int size)
1177 {
1178 int alt, mult;
1179
1180 if (ov51x_stop(ov) < 0)
1181 return -EIO;
1182
1183 mult = size >> 5;
1184
1185 if (ov->bridge == BRG_OV511) {
1186 if (size == 0)
1187 alt = OV511_ALT_SIZE_0;
1188 else if (size == 257)
1189 alt = OV511_ALT_SIZE_257;
1190 else if (size == 513)
1191 alt = OV511_ALT_SIZE_513;
1192 else if (size == 769)
1193 alt = OV511_ALT_SIZE_769;
1194 else if (size == 993)
1195 alt = OV511_ALT_SIZE_993;
1196 else {
1197 err("Set packet size: invalid size (%d)", size);
1198 return -EINVAL;
1199 }
1200 } else if (ov->bridge == BRG_OV511PLUS) {
1201 if (size == 0)
1202 alt = OV511PLUS_ALT_SIZE_0;
1203 else if (size == 33)
1204 alt = OV511PLUS_ALT_SIZE_33;
1205 else if (size == 129)
1206 alt = OV511PLUS_ALT_SIZE_129;
1207 else if (size == 257)
1208 alt = OV511PLUS_ALT_SIZE_257;
1209 else if (size == 385)
1210 alt = OV511PLUS_ALT_SIZE_385;
1211 else if (size == 513)
1212 alt = OV511PLUS_ALT_SIZE_513;
1213 else if (size == 769)
1214 alt = OV511PLUS_ALT_SIZE_769;
1215 else if (size == 961)
1216 alt = OV511PLUS_ALT_SIZE_961;
1217 else {
1218 err("Set packet size: invalid size (%d)", size);
1219 return -EINVAL;
1220 }
1221 } else {
1222 err("Set packet size: Invalid bridge type");
1223 return -EINVAL;
1224 }
1225
1226 PDEBUG(3, "%d, mult=%d, alt=%d", size, mult, alt);
1227
1228 if (reg_w(ov, R51x_FIFO_PSIZE, mult) < 0)
1229 return -EIO;
1230
1231 if (usb_set_interface(ov->dev, ov->iface, alt) < 0) {
1232 err("Set packet size: set interface error");
1233 return -EBUSY;
1234 }
1235
1236 if (ov51x_reset(ov, OV511_RESET_NOREGS) < 0)
1237 return -EIO;
1238
1239 ov->packet_size = size;
1240
1241 if (ov51x_restart(ov) < 0)
1242 return -EIO;
1243
1244 return 0;
1245 }
1246
1247 /* Note: Unlike the OV511/OV511+, the size argument does NOT include the
1248 * optional packet number byte. The actual size *is* stored in ov->packet_size,
1249 * though. */
1250 static int
1251 ov518_set_packet_size(struct usb_ov511 *ov, int size)
1252 {
1253 int alt;
1254
1255 if (ov51x_stop(ov) < 0)
1256 return -EIO;
1257
1258 if (ov->bclass == BCL_OV518) {
1259 if (size == 0)
1260 alt = OV518_ALT_SIZE_0;
1261 else if (size == 128)
1262 alt = OV518_ALT_SIZE_128;
1263 else if (size == 256)
1264 alt = OV518_ALT_SIZE_256;
1265 else if (size == 384)
1266 alt = OV518_ALT_SIZE_384;
1267 else if (size == 512)
1268 alt = OV518_ALT_SIZE_512;
1269 else if (size == 640)
1270 alt = OV518_ALT_SIZE_640;
1271 else if (size == 768)
1272 alt = OV518_ALT_SIZE_768;
1273 else if (size == 896)
1274 alt = OV518_ALT_SIZE_896;
1275 else {
1276 err("Set packet size: invalid size (%d)", size);
1277 return -EINVAL;
1278 }
1279 } else {
1280 err("Set packet size: Invalid bridge type");
1281 return -EINVAL;
1282 }
1283
1284 PDEBUG(3, "%d, alt=%d", size, alt);
1285
1286 ov->packet_size = size;
1287 if (size > 0) {
1288 /* Program ISO FIFO size reg (packet number isn't included) */
1289 ov518_reg_w32(ov, 0x30, size, 2);
1290
1291 if (ov->packet_numbering)
1292 ++ov->packet_size;
1293 }
1294
1295 if (usb_set_interface(ov->dev, ov->iface, alt) < 0) {
1296 err("Set packet size: set interface error");
1297 return -EBUSY;
1298 }
1299
1300 /* Initialize the stream */
1301 if (reg_w(ov, 0x2f, 0x80) < 0)
1302 return -EIO;
1303
1304 if (ov51x_restart(ov) < 0)
1305 return -EIO;
1306
1307 if (ov51x_reset(ov, OV511_RESET_NOREGS) < 0)
1308 return -EIO;
1309
1310 return 0;
1311 }
1312
1313 /* Upload compression params and quantization tables. Returns 0 for success. */
1314 static int
1315 ov511_init_compression(struct usb_ov511 *ov)
1316 {
1317 int rc = 0;
1318
1319 if (!ov->compress_inited) {
1320 reg_w(ov, 0x70, phy);
1321 reg_w(ov, 0x71, phuv);
1322 reg_w(ov, 0x72, pvy);
1323 reg_w(ov, 0x73, pvuv);
1324 reg_w(ov, 0x74, qhy);
1325 reg_w(ov, 0x75, qhuv);
1326 reg_w(ov, 0x76, qvy);
1327 reg_w(ov, 0x77, qvuv);
1328
1329 if (ov511_upload_quan_tables(ov) < 0) {
1330 err("Error uploading quantization tables");
1331 rc = -EIO;
1332 goto out;
1333 }
1334 }
1335
1336 ov->compress_inited = 1;
1337 out:
1338 return rc;
1339 }
1340
1341 /* Upload compression params and quantization tables. Returns 0 for success. */
1342 static int
1343 ov518_init_compression(struct usb_ov511 *ov)
1344 {
1345 int rc = 0;
1346
1347 if (!ov->compress_inited) {
1348 if (ov518_upload_quan_tables(ov) < 0) {
1349 err("Error uploading quantization tables");
1350 rc = -EIO;
1351 goto out;
1352 }
1353 }
1354
1355 ov->compress_inited = 1;
1356 out:
1357 return rc;
1358 }
1359
1360 /* -------------------------------------------------------------------------- */
1361
1362 /* Sets sensor's contrast setting to "val" */
1363 static int
1364 sensor_set_contrast(struct usb_ov511 *ov, unsigned short val)
1365 {
1366 int rc;
1367
1368 PDEBUG(3, "%d", val);
1369
1370 if (ov->stop_during_set)
1371 if (ov51x_stop(ov) < 0)
1372 return -EIO;
1373
1374 switch (ov->sensor) {
1375 case SEN_OV7610:
1376 case SEN_OV6620:
1377 {
1378 rc = i2c_w(ov, OV7610_REG_CNT, val >> 8);
1379 if (rc < 0)
1380 goto out;
1381 break;
1382 }
1383 case SEN_OV6630:
1384 {
1385 rc = i2c_w_mask(ov, OV7610_REG_CNT, val >> 12, 0x0f);
1386 if (rc < 0)
1387 goto out;
1388 break;
1389 }
1390 case SEN_OV7620:
1391 {
1392 unsigned char ctab[] = {
1393 0x01, 0x05, 0x09, 0x11, 0x15, 0x35, 0x37, 0x57,
1394 0x5b, 0xa5, 0xa7, 0xc7, 0xc9, 0xcf, 0xef, 0xff
1395 };
1396
1397 /* Use Y gamma control instead. Bit 0 enables it. */
1398 rc = i2c_w(ov, 0x64, ctab[val>>12]);
1399 if (rc < 0)
1400 goto out;
1401 break;
1402 }
1403 case SEN_SAA7111A:
1404 {
1405 rc = i2c_w(ov, 0x0b, val >> 9);
1406 if (rc < 0)
1407 goto out;
1408 break;
1409 }
1410 default:
1411 {
1412 PDEBUG(3, "Unsupported with this sensor");
1413 rc = -EPERM;
1414 goto out;
1415 }
1416 }
1417
1418 rc = 0; /* Success */
1419 ov->contrast = val;
1420 out:
1421 if (ov51x_restart(ov) < 0)
1422 return -EIO;
1423
1424 return rc;
1425 }
1426
1427 /* Gets sensor's contrast setting */
1428 static int
1429 sensor_get_contrast(struct usb_ov511 *ov, unsigned short *val)
1430 {
1431 int rc;
1432
1433 switch (ov->sensor) {
1434 case SEN_OV7610:
1435 case SEN_OV6620:
1436 rc = i2c_r(ov, OV7610_REG_CNT);
1437 if (rc < 0)
1438 return rc;
1439 else
1440 *val = rc << 8;
1441 break;
1442 case SEN_OV6630:
1443 rc = i2c_r(ov, OV7610_REG_CNT);
1444 if (rc < 0)
1445 return rc;
1446 else
1447 *val = rc << 12;
1448 break;
1449 case SEN_OV7620:
1450 /* Use Y gamma reg instead. Bit 0 is the enable bit. */
1451 rc = i2c_r(ov, 0x64);
1452 if (rc < 0)
1453 return rc;
1454 else
1455 *val = (rc & 0xfe) << 8;
1456 break;
1457 case SEN_SAA7111A:
1458 *val = ov->contrast;
1459 break;
1460 default:
1461 PDEBUG(3, "Unsupported with this sensor");
1462 return -EPERM;
1463 }
1464
1465 PDEBUG(3, "%d", *val);
1466 ov->contrast = *val;
1467
1468 return 0;
1469 }
1470
1471 /* -------------------------------------------------------------------------- */
1472
1473 /* Sets sensor's brightness setting to "val" */
1474 static int
1475 sensor_set_brightness(struct usb_ov511 *ov, unsigned short val)
1476 {
1477 int rc;
1478
1479 PDEBUG(4, "%d", val);
1480
1481 if (ov->stop_during_set)
1482 if (ov51x_stop(ov) < 0)
1483 return -EIO;
1484
1485 switch (ov->sensor) {
1486 case SEN_OV7610:
1487 case SEN_OV76BE:
1488 case SEN_OV6620:
1489 case SEN_OV6630:
1490 rc = i2c_w(ov, OV7610_REG_BRT, val >> 8);
1491 if (rc < 0)
1492 goto out;
1493 break;
1494 case SEN_OV7620:
1495 /* 7620 doesn't like manual changes when in auto mode */
1496 if (!ov->auto_brt) {
1497 rc = i2c_w(ov, OV7610_REG_BRT, val >> 8);
1498 if (rc < 0)
1499 goto out;
1500 }
1501 break;
1502 case SEN_SAA7111A:
1503 rc = i2c_w(ov, 0x0a, val >> 8);
1504 if (rc < 0)
1505 goto out;
1506 break;
1507 default:
1508 PDEBUG(3, "Unsupported with this sensor");
1509 rc = -EPERM;
1510 goto out;
1511 }
1512
1513 rc = 0; /* Success */
1514 ov->brightness = val;
1515 out:
1516 if (ov51x_restart(ov) < 0)
1517 return -EIO;
1518
1519 return rc;
1520 }
1521
1522 /* Gets sensor's brightness setting */
1523 static int
1524 sensor_get_brightness(struct usb_ov511 *ov, unsigned short *val)
1525 {
1526 int rc;
1527
1528 switch (ov->sensor) {
1529 case SEN_OV7610:
1530 case SEN_OV76BE:
1531 case SEN_OV7620:
1532 case SEN_OV6620:
1533 case SEN_OV6630:
1534 rc = i2c_r(ov, OV7610_REG_BRT);
1535 if (rc < 0)
1536 return rc;
1537 else
1538 *val = rc << 8;
1539 break;
1540 case SEN_SAA7111A:
1541 *val = ov->brightness;
1542 break;
1543 default:
1544 PDEBUG(3, "Unsupported with this sensor");
1545 return -EPERM;
1546 }
1547
1548 PDEBUG(3, "%d", *val);
1549 ov->brightness = *val;
1550
1551 return 0;
1552 }
1553
1554 /* -------------------------------------------------------------------------- */
1555
1556 /* Sets sensor's saturation (color intensity) setting to "val" */
1557 static int
1558 sensor_set_saturation(struct usb_ov511 *ov, unsigned short val)
1559 {
1560 int rc;
1561
1562 PDEBUG(3, "%d", val);
1563
1564 if (ov->stop_during_set)
1565 if (ov51x_stop(ov) < 0)
1566 return -EIO;
1567
1568 switch (ov->sensor) {
1569 case SEN_OV7610:
1570 case SEN_OV76BE:
1571 case SEN_OV6620:
1572 case SEN_OV6630:
1573 rc = i2c_w(ov, OV7610_REG_SAT, val >> 8);
1574 if (rc < 0)
1575 goto out;
1576 break;
1577 case SEN_OV7620:
1578 // /* Use UV gamma control instead. Bits 0 & 7 are reserved. */
1579 // rc = ov_i2c_write(ov->dev, 0x62, (val >> 9) & 0x7e);
1580 // if (rc < 0)
1581 // goto out;
1582 rc = i2c_w(ov, OV7610_REG_SAT, val >> 8);
1583 if (rc < 0)
1584 goto out;
1585 break;
1586 case SEN_SAA7111A:
1587 rc = i2c_w(ov, 0x0c, val >> 9);
1588 if (rc < 0)
1589 goto out;
1590 break;
1591 default:
1592 PDEBUG(3, "Unsupported with this sensor");
1593 rc = -EPERM;
1594 goto out;
1595 }
1596
1597 rc = 0; /* Success */
1598 ov->colour = val;
1599 out:
1600 if (ov51x_restart(ov) < 0)
1601 return -EIO;
1602
1603 return rc;
1604 }
1605
1606 /* Gets sensor's saturation (color intensity) setting */
1607 static int
1608 sensor_get_saturation(struct usb_ov511 *ov, unsigned short *val)
1609 {
1610 int rc;
1611
1612 switch (ov->sensor) {
1613 case SEN_OV7610:
1614 case SEN_OV76BE:
1615 case SEN_OV6620:
1616 case SEN_OV6630:
1617 rc = i2c_r(ov, OV7610_REG_SAT);
1618 if (rc < 0)
1619 return rc;
1620 else
1621 *val = rc << 8;
1622 break;
1623 case SEN_OV7620:
1624 // /* Use UV gamma reg instead. Bits 0 & 7 are reserved. */
1625 // rc = i2c_r(ov, 0x62);
1626 // if (rc < 0)
1627 // return rc;
1628 // else
1629 // *val = (rc & 0x7e) << 9;
1630 rc = i2c_r(ov, OV7610_REG_SAT);
1631 if (rc < 0)
1632 return rc;
1633 else
1634 *val = rc << 8;
1635 break;
1636 case SEN_SAA7111A:
1637 *val = ov->colour;
1638 break;
1639 default:
1640 PDEBUG(3, "Unsupported with this sensor");
1641 return -EPERM;
1642 }
1643
1644 PDEBUG(3, "%d", *val);
1645 ov->colour = *val;
1646
1647 return 0;
1648 }
1649
1650 /* -------------------------------------------------------------------------- */
1651
1652 /* Sets sensor's hue (red/blue balance) setting to "val" */
1653 static int
1654 sensor_set_hue(struct usb_ov511 *ov, unsigned short val)
1655 {
1656 int rc;
1657
1658 PDEBUG(3, "%d", val);
1659
1660 if (ov->stop_during_set)
1661 if (ov51x_stop(ov) < 0)
1662 return -EIO;
1663
1664 switch (ov->sensor) {
1665 case SEN_OV7610:
1666 case SEN_OV6620:
1667 case SEN_OV6630:
1668 rc = i2c_w(ov, OV7610_REG_RED, 0xFF - (val >> 8));
1669 if (rc < 0)
1670 goto out;
1671
1672 rc = i2c_w(ov, OV7610_REG_BLUE, val >> 8);
1673 if (rc < 0)
1674 goto out;
1675 break;
1676 case SEN_OV7620:
1677 // Hue control is causing problems. I will enable it once it's fixed.
1678 #if 0
1679 rc = i2c_w(ov, 0x7a, (unsigned char)(val >> 8) + 0xb);
1680 if (rc < 0)
1681 goto out;
1682
1683 rc = i2c_w(ov, 0x79, (unsigned char)(val >> 8) + 0xb);
1684 if (rc < 0)
1685 goto out;
1686 #endif
1687 break;
1688 case SEN_SAA7111A:
1689 rc = i2c_w(ov, 0x0d, (val + 32768) >> 8);
1690 if (rc < 0)
1691 goto out;
1692 break;
1693 default:
1694 PDEBUG(3, "Unsupported with this sensor");
1695 rc = -EPERM;
1696 goto out;
1697 }
1698
1699 rc = 0; /* Success */
1700 ov->hue = val;
1701 out:
1702 if (ov51x_restart(ov) < 0)
1703 return -EIO;
1704
1705 return rc;
1706 }
1707
1708 /* Gets sensor's hue (red/blue balance) setting */
1709 static int
1710 sensor_get_hue(struct usb_ov511 *ov, unsigned short *val)
1711 {
1712 int rc;
1713
1714 switch (ov->sensor) {
1715 case SEN_OV7610:
1716 case SEN_OV6620:
1717 case SEN_OV6630:
1718 rc = i2c_r(ov, OV7610_REG_BLUE);
1719 if (rc < 0)
1720 return rc;
1721 else
1722 *val = rc << 8;
1723 break;
1724 case SEN_OV7620:
1725 rc = i2c_r(ov, 0x7a);
1726 if (rc < 0)
1727 return rc;
1728 else
1729 *val = rc << 8;
1730 break;
1731 case SEN_SAA7111A:
1732 *val = ov->hue;
1733 break;
1734 default:
1735 PDEBUG(3, "Unsupported with this sensor");
1736 return -EPERM;
1737 }
1738
1739 PDEBUG(3, "%d", *val);
1740 ov->hue = *val;
1741
1742 return 0;
1743 }
1744
1745 /* -------------------------------------------------------------------------- */
1746
1747 static int
1748 sensor_set_picture(struct usb_ov511 *ov, struct video_picture *p)
1749 {
1750 int rc;
1751
1752 PDEBUG(4, "sensor_set_picture");
1753
1754 ov->whiteness = p->whiteness;
1755
1756 /* Don't return error if a setting is unsupported, or rest of settings
1757 * will not be performed */
1758
1759 rc = sensor_set_contrast(ov, p->contrast);
1760 if (FATAL_ERROR(rc))
1761 return rc;
1762
1763 rc = sensor_set_brightness(ov, p->brightness);
1764 if (FATAL_ERROR(rc))
1765 return rc;
1766
1767 rc = sensor_set_saturation(ov, p->colour);
1768 if (FATAL_ERROR(rc))
1769 return rc;
1770
1771 rc = sensor_set_hue(ov, p->hue);
1772 if (FATAL_ERROR(rc))
1773 return rc;
1774
1775 return 0;
1776 }
1777
1778 static int
1779 sensor_get_picture(struct usb_ov511 *ov, struct video_picture *p)
1780 {
1781 int rc;
1782
1783 PDEBUG(4, "sensor_get_picture");
1784
1785 /* Don't return error if a setting is unsupported, or rest of settings
1786 * will not be performed */
1787
1788 rc = sensor_get_contrast(ov, &(p->contrast));
1789 if (FATAL_ERROR(rc))
1790 return rc;
1791
1792 rc = sensor_get_brightness(ov, &(p->brightness));
1793 if (FATAL_ERROR(rc))
1794 return rc;
1795
1796 rc = sensor_get_saturation(ov, &(p->colour));
1797 if (FATAL_ERROR(rc))
1798 return rc;
1799
1800 rc = sensor_get_hue(ov, &(p->hue));
1801 if (FATAL_ERROR(rc))
1802 return rc;
1803
1804 p->whiteness = 105 << 8;
1805
1806 return 0;
1807 }
1808
1809 #if 0
1810 // FIXME: Exposure range is only 0x00-0x7f in interlace mode
1811 /* Sets current exposure for sensor. This only has an effect if auto-exposure
1812 * is off */
1813 static inline int
1814 sensor_set_exposure(struct usb_ov511 *ov, unsigned char val)
1815 {
1816 int rc;
1817
1818 PDEBUG(3, "%d", val);
1819
1820 if (ov->stop_during_set)
1821 if (ov51x_stop(ov) < 0)
1822 return -EIO;
1823
1824 switch (ov->sensor) {
1825 case SEN_OV6620:
1826 case SEN_OV6630:
1827 case SEN_OV7610:
1828 case SEN_OV7620:
1829 case SEN_OV76BE:
1830 case SEN_OV8600:
1831 rc = i2c_w(ov, 0x10, val);
1832 if (rc < 0)
1833 goto out;
1834
1835 break;
1836 case SEN_KS0127:
1837 case SEN_KS0127B:
1838 case SEN_SAA7111A:
1839 PDEBUG(3, "Unsupported with this sensor");
1840 return -EPERM;
1841 default:
1842 err("Sensor not supported for set_exposure");
1843 return -EINVAL;
1844 }
1845
1846 rc = 0; /* Success */
1847 ov->exposure = val;
1848 out:
1849 if (ov51x_restart(ov) < 0)
1850 return -EIO;
1851
1852 return rc;
1853 }
1854 #endif
1855
1856 /* Gets current exposure level from sensor, regardless of whether it is under
1857 * manual control. */
1858 static int
1859 sensor_get_exposure(struct usb_ov511 *ov, unsigned char *val)
1860 {
1861 int rc;
1862
1863 switch (ov->sensor) {
1864 case SEN_OV7610:
1865 case SEN_OV6620:
1866 case SEN_OV6630:
1867 case SEN_OV7620:
1868 case SEN_OV76BE:
1869 case SEN_OV8600:
1870 rc = i2c_r(ov, 0x10);
1871 if (rc < 0)
1872 return rc;
1873 else
1874 *val = rc;
1875 break;
1876 case SEN_KS0127:
1877 case SEN_KS0127B:
1878 case SEN_SAA7111A:
1879 val = NULL;
1880 PDEBUG(3, "Unsupported with this sensor");
1881 return -EPERM;
1882 default:
1883 err("Sensor not supported for get_exposure");
1884 return -EINVAL;
1885 }
1886
1887 PDEBUG(3, "%d", *val);
1888 ov->exposure = *val;
1889
1890 return 0;
1891 }
1892
1893 /* Turns on or off the LED. Only has an effect with OV511+/OV518(+) */
1894 static void
1895 ov51x_led_control(struct usb_ov511 *ov, int enable)
1896 {
1897 PDEBUG(4, " (%s)", enable ? "turn on" : "turn off");
1898
1899 if (ov->bridge == BRG_OV511PLUS)
1900 reg_w(ov, R511_SYS_LED_CTL, enable ? 1 : 0);
1901 else if (ov->bclass == BCL_OV518)
1902 reg_w_mask(ov, R518_GPIO_OUT, enable ? 0x02 : 0x00, 0x02);
1903
1904 return;
1905 }
1906
1907 /* Matches the sensor's internal frame rate to the lighting frequency.
1908 * Valid frequencies are:
1909 * 50 - 50Hz, for European and Asian lighting
1910 * 60 - 60Hz, for American lighting
1911 *
1912 * Tested with: OV7610, OV7620, OV76BE, OV6620
1913 * Unsupported: KS0127, KS0127B, SAA7111A
1914 * Returns: 0 for success
1915 */
1916 static int
1917 sensor_set_light_freq(struct usb_ov511 *ov, int freq)
1918 {
1919 int sixty;
1920
1921 PDEBUG(4, "%d Hz", freq);
1922
1923 if (freq == 60)
1924 sixty = 1;
1925 else if (freq == 50)
1926 sixty = 0;
1927 else {
1928 err("Invalid light freq (%d Hz)", freq);
1929 return -EINVAL;
1930 }
1931
1932 switch (ov->sensor) {
1933 case SEN_OV7610:
1934 i2c_w_mask(ov, 0x2a, sixty?0x00:0x80, 0x80);
1935 i2c_w(ov, 0x2b, sixty?0x00:0xac);
1936 i2c_w_mask(ov, 0x13, 0x10, 0x10);
1937 i2c_w_mask(ov, 0x13, 0x00, 0x10);
1938 break;
1939 case SEN_OV7620:
1940 case SEN_OV76BE:
1941 case SEN_OV8600:
1942 i2c_w_mask(ov, 0x2a, sixty?0x00:0x80, 0x80);
1943 i2c_w(ov, 0x2b, sixty?0x00:0xac);
1944 i2c_w_mask(ov, 0x76, 0x01, 0x01);
1945 break;
1946 case SEN_OV6620:
1947 case SEN_OV6630:
1948 i2c_w(ov, 0x2b, sixty?0xa8:0x28);
1949 i2c_w(ov, 0x2a, sixty?0x84:0xa4);
1950 break;
1951 case SEN_KS0127:
1952 case SEN_KS0127B:
1953 case SEN_SAA7111A:
1954 PDEBUG(5, "Unsupported with this sensor");
1955 return -EPERM;
1956 default:
1957 err("Sensor not supported for set_light_freq");
1958 return -EINVAL;
1959 }
1960
1961 ov->lightfreq = freq;
1962
1963 return 0;
1964 }
1965
1966 /* If enable is true, turn on the sensor's banding filter, otherwise turn it
1967 * off. This filter tries to reduce the pattern of horizontal light/dark bands
1968 * caused by some (usually fluorescent) lighting. The light frequency must be
1969 * set either before or after enabling it with ov51x_set_light_freq().
1970 *
1971 * Tested with: OV7610, OV7620, OV76BE, OV6620.
1972 * Unsupported: KS0127, KS0127B, SAA7111A
1973 * Returns: 0 for success
1974 */
1975 static int
1976 sensor_set_banding_filter(struct usb_ov511 *ov, int enable)
1977 {
1978 int rc;
1979
1980 PDEBUG(4, " (%s)", enable ? "turn on" : "turn off");
1981
1982 if (ov->sensor == SEN_KS0127 || ov->sensor == SEN_KS0127B
1983 || ov->sensor == SEN_SAA7111A) {
1984 PDEBUG(5, "Unsupported with this sensor");
1985 return -EPERM;
1986 }
1987
1988 rc = i2c_w_mask(ov, 0x2d, enable?0x04:0x00, 0x04);
1989 if (rc < 0)
1990 return rc;
1991
1992 ov->bandfilt = enable;
1993
1994 return 0;
1995 }
1996
1997 /* If enable is true, turn on the sensor's auto brightness control, otherwise
1998 * turn it off.
1999 *
2000 * Unsupported: KS0127, KS0127B, SAA7111A
2001 * Returns: 0 for success
2002 */
2003 static int
2004 sensor_set_auto_brightness(struct usb_ov511 *ov, int enable)
2005 {
2006 int rc;
2007
2008 PDEBUG(4, " (%s)", enable ? "turn on" : "turn off");
2009
2010 if (ov->sensor == SEN_KS0127 || ov->sensor == SEN_KS0127B
2011 || ov->sensor == SEN_SAA7111A) {
2012 PDEBUG(5, "Unsupported with this sensor");
2013 return -EPERM;
2014 }
2015
2016 rc = i2c_w_mask(ov, 0x2d, enable?0x10:0x00, 0x10);
2017 if (rc < 0)
2018 return rc;
2019
2020 ov->auto_brt = enable;
2021
2022 return 0;
2023 }
2024
2025 /* If enable is true, turn on the sensor's auto exposure control, otherwise
2026 * turn it off.
2027 *
2028 * Unsupported: KS0127, KS0127B, SAA7111A
2029 * Returns: 0 for success
2030 */
2031 static int
2032 sensor_set_auto_exposure(struct usb_ov511 *ov, int enable)
2033 {
2034 PDEBUG(4, " (%s)", enable ? "turn on" : "turn off");
2035
2036 switch (ov->sensor) {
2037 case SEN_OV7610:
2038 i2c_w_mask(ov, 0x29, enable?0x00:0x80, 0x80);
2039 break;
2040 case SEN_OV6620:
2041 case SEN_OV7620:
2042 case SEN_OV76BE:
2043 case SEN_OV8600:
2044 i2c_w_mask(ov, 0x13, enable?0x01:0x00, 0x01);
2045 break;
2046 case SEN_OV6630:
2047 i2c_w_mask(ov, 0x28, enable?0x00:0x10, 0x10);
2048 break;
2049 case SEN_KS0127:
2050 case SEN_KS0127B:
2051 case SEN_SAA7111A:
2052 PDEBUG(5, "Unsupported with this sensor");
2053 return -EPERM;
2054 default:
2055 err("Sensor not supported for set_auto_exposure");
2056 return -EINVAL;
2057 }
2058
2059 ov->auto_exp = enable;
2060
2061 return 0;
2062 }
2063
2064 /* Modifies the sensor's exposure algorithm to allow proper exposure of objects
2065 * that are illuminated from behind.
2066 *
2067 * Tested with: OV6620, OV7620
2068 * Unsupported: OV7610, OV76BE, KS0127, KS0127B, SAA7111A
2069 * Returns: 0 for success
2070 */
2071 static int
2072 sensor_set_backlight(struct usb_ov511 *ov, int enable)
2073 {
2074 PDEBUG(4, " (%s)", enable ? "turn on" : "turn off");
2075
2076 switch (ov->sensor) {
2077 case SEN_OV7620:
2078 case SEN_OV8600:
2079 i2c_w_mask(ov, 0x68, enable?0xe0:0xc0, 0xe0);
2080 i2c_w_mask(ov, 0x29, enable?0x08:0x00, 0x08);
2081 i2c_w_mask(ov, 0x28, enable?0x02:0x00, 0x02);
2082 break;
2083 case SEN_OV6620:
2084 i2c_w_mask(ov, 0x4e, enable?0xe0:0xc0, 0xe0);
2085 i2c_w_mask(ov, 0x29, enable?0x08:0x00, 0x08);
2086 i2c_w_mask(ov, 0x0e, enable?0x80:0x00, 0x80);
2087 break;
2088 case SEN_OV6630:
2089 i2c_w_mask(ov, 0x4e, enable?0x80:0x60, 0xe0);
2090 i2c_w_mask(ov, 0x29, enable?0x08:0x00, 0x08);
2091 i2c_w_mask(ov, 0x28, enable?0x02:0x00, 0x02);
2092 break;
2093 case SEN_OV7610:
2094 case SEN_OV76BE:
2095 case SEN_KS0127:
2096 case SEN_KS0127B:
2097 case SEN_SAA7111A:
2098 PDEBUG(5, "Unsupported with this sensor");
2099 return -EPERM;
2100 default:
2101 err("Sensor not supported for set_backlight");
2102 return -EINVAL;
2103 }
2104
2105 ov->backlight = enable;
2106
2107 return 0;
2108 }
2109
2110 static int
2111 sensor_set_mirror(struct usb_ov511 *ov, int enable)
2112 {
2113 PDEBUG(4, " (%s)", enable ? "turn on" : "turn off");
2114
2115 switch (ov->sensor) {
2116 case SEN_OV6620:
2117 case SEN_OV6630:
2118 case SEN_OV7610:
2119 case SEN_OV7620:
2120 case SEN_OV76BE:
2121 case SEN_OV8600:
2122 i2c_w_mask(ov, 0x12, enable?0x40:0x00, 0x40);
2123 break;
2124 case SEN_KS0127:
2125 case SEN_KS0127B:
2126 case SEN_SAA7111A:
2127 PDEBUG(5, "Unsupported with this sensor");
2128 return -EPERM;
2129 default:
2130 err("Sensor not supported for set_mirror");
2131 return -EINVAL;
2132 }
2133
2134 ov->mirror = enable;
2135
2136 return 0;
2137 }
2138
2139 /* Returns number of bits per pixel (regardless of where they are located;
2140 * planar or not), or zero for unsupported format.
2141 */
2142 static inline int
2143 get_depth(int palette)
2144 {
2145 switch (palette) {
2146 case VIDEO_PALETTE_GREY: return 8;
2147 case VIDEO_PALETTE_YUV420: return 12;
2148 case VIDEO_PALETTE_YUV420P: return 12; /* Planar */
2149 default: return 0; /* Invalid format */
2150 }
2151 }
2152
2153 /* Bytes per frame. Used by read(). Return of 0 indicates error */
2154 static inline long int
2155 get_frame_length(struct ov511_frame *frame)
2156 {
2157 if (!frame)
2158 return 0;
2159 else
2160 return ((frame->width * frame->height
2161 * get_depth(frame->format)) >> 3);
2162 }
2163
2164 static int
2165 mode_init_ov_sensor_regs(struct usb_ov511 *ov, int width, int height,
2166 int mode, int sub_flag, int qvga)
2167 {
2168 int clock;
2169
2170 /******** Mode (VGA/QVGA) and sensor specific regs ********/
2171
2172 switch (ov->sensor) {
2173 case SEN_OV7610:
2174 i2c_w(ov, 0x14, qvga?0x24:0x04);
2175 // FIXME: Does this improve the image quality or frame rate?
2176 #if 0
2177 i2c_w_mask(ov, 0x28, qvga?0x00:0x20, 0x20);
2178 i2c_w(ov, 0x24, 0x10);
2179 i2c_w(ov, 0x25, qvga?0x40:0x8a);
2180 i2c_w(ov, 0x2f, qvga?0x30:0xb0);
2181 i2c_w(ov, 0x35, qvga?0x1c:0x9c);
2182 #endif
2183 break;
2184 case SEN_OV7620:
2185 // i2c_w(ov, 0x2b, 0x00);
2186 i2c_w(ov, 0x14, qvga?0xa4:0x84);
2187 i2c_w_mask(ov, 0x28, qvga?0x00:0x20, 0x20);
2188 i2c_w(ov, 0x24, qvga?0x20:0x3a);
2189 i2c_w(ov, 0x25, qvga?0x30:0x60);
2190 i2c_w_mask(ov, 0x2d, qvga?0x40:0x00, 0x40);
2191 i2c_w_mask(ov, 0x67, qvga?0xf0:0x90, 0xf0);
2192 i2c_w_mask(ov, 0x74, qvga?0x20:0x00, 0x20);
2193 break;
2194 case SEN_OV76BE:
2195 // i2c_w(ov, 0x2b, 0x00);
2196 i2c_w(ov, 0x14, qvga?0xa4:0x84);
2197 // FIXME: Enable this once 7620AE uses 7620 initial settings
2198 #if 0
2199 i2c_w_mask(ov, 0x28, qvga?0x00:0x20, 0x20);
2200 i2c_w(ov, 0x24, qvga?0x20:0x3a);
2201 i2c_w(ov, 0x25, qvga?0x30:0x60);
2202 i2c_w_mask(ov, 0x2d, qvga?0x40:0x00, 0x40);
2203 i2c_w_mask(ov, 0x67, qvga?0xb0:0x90, 0xf0);
2204 i2c_w_mask(ov, 0x74, qvga?0x20:0x00, 0x20);
2205 #endif
2206 break;
2207 case SEN_OV6620:
2208 i2c_w(ov, 0x14, qvga?0x24:0x04);
2209 break;
2210 case SEN_OV6630:
2211 i2c_w(ov, 0x14, qvga?0xa0:0x80);
2212 break;
2213 default:
2214 err("Invalid sensor");
2215 return -EINVAL;
2216 }
2217
2218 /******** Palette-specific regs ********/
2219
2220 if (mode == VIDEO_PALETTE_GREY) {
2221 if (ov->sensor == SEN_OV7610 || ov->sensor == SEN_OV76BE) {
2222 /* these aren't valid on the OV6620/OV7620/6630? */
2223 i2c_w_mask(ov, 0x0e, 0x40, 0x40);
2224 }
2225
2226 if (ov->sensor == SEN_OV6630 && ov->bridge == BRG_OV518
2227 && ov518_color) {
2228 i2c_w_mask(ov, 0x12, 0x00, 0x10);
2229 i2c_w_mask(ov, 0x13, 0x00, 0x20);
2230 } else {
2231 i2c_w_mask(ov, 0x13, 0x20, 0x20);
2232 }
2233 } else {
2234 if (ov->sensor == SEN_OV7610 || ov->sensor == SEN_OV76BE) {
2235 /* not valid on the OV6620/OV7620/6630? */
2236 i2c_w_mask(ov, 0x0e, 0x00, 0x40);
2237 }
2238
2239 /* The OV518 needs special treatment. Although both the OV518
2240 * and the OV6630 support a 16-bit video bus, only the 8 bit Y
2241 * bus is actually used. The UV bus is tied to ground.
2242 * Therefore, the OV6630 needs to be in 8-bit multiplexed
2243 * output mode */
2244
2245 if (ov->sensor == SEN_OV6630 && ov->bridge == BRG_OV518
2246 && ov518_color) {
2247 i2c_w_mask(ov, 0x12, 0x10, 0x10);
2248 i2c_w_mask(ov, 0x13, 0x20, 0x20);
2249 } else {
2250 i2c_w_mask(ov, 0x13, 0x00, 0x20);
2251 }
2252 }
2253
2254 /******** Clock programming ********/
2255
2256 /* The OV6620 needs special handling. This prevents the
2257 * severe banding that normally occurs */
2258 if (ov->sensor == SEN_OV6620 || ov->sensor == SEN_OV6630)
2259 {
2260 /* Clock down */
2261
2262 i2c_w(ov, 0x2a, 0x04);
2263
2264 if (ov->compress) {
2265 // clock = 0; /* This ensures the highest frame rate */
2266 clock = 3;
2267 } else if (clockdiv == -1) { /* If user didn't override it */
2268 clock = 3; /* Gives better exposure time */
2269 } else {
2270 clock = clockdiv;
2271 }
2272
2273 PDEBUG(4, "Setting clock divisor to %d", clock);
2274
2275 i2c_w(ov, 0x11, clock);
2276
2277 i2c_w(ov, 0x2a, 0x84);
2278 /* This next setting is critical. It seems to improve
2279 * the gain or the contrast. The "reserved" bits seem
2280 * to have some effect in this case. */
2281 i2c_w(ov, 0x2d, 0x85);
2282 }
2283 else
2284 {
2285 if (ov->compress) {
2286 clock = 1; /* This ensures the highest frame rate */
2287 } else if (clockdiv == -1) { /* If user didn't override it */
2288 /* Calculate and set the clock divisor */
2289 clock = ((sub_flag ? ov->subw * ov->subh
2290 : width * height)
2291 * (mode == VIDEO_PALETTE_GREY ? 2 : 3) / 2)
2292 / 66000;
2293 } else {
2294 clock = clockdiv;
2295 }
2296
2297 PDEBUG(4, "Setting clock divisor to %d", clock);
2298
2299 i2c_w(ov, 0x11, clock);
2300 }
2301
2302 /******** Special Features ********/
2303
2304 if (framedrop >= 0)
2305 i2c_w(ov, 0x16, framedrop);
2306
2307 /* Test Pattern */
2308 i2c_w_mask(ov, 0x12, (testpat?0x02:0x00), 0x02);
2309
2310 /* Enable auto white balance */
2311 i2c_w_mask(ov, 0x12, 0x04, 0x04);
2312
2313 // This will go away as soon as ov51x_mode_init_sensor_regs()
2314 // is fully tested.
2315 /* 7620/6620/6630? don't have register 0x35, so play it safe */
2316 if (ov->sensor == SEN_OV7610 || ov->sensor == SEN_OV76BE) {
2317 if (width == 640 && height == 480)
2318 i2c_w(ov, 0x35, 0x9e);
2319 else
2320 i2c_w(ov, 0x35, 0x1e);
2321 }
2322
2323 return 0;
2324 }
2325
2326 static int
2327 set_ov_sensor_window(struct usb_ov511 *ov, int width, int height, int mode,
2328 int sub_flag)
2329 {
2330 int ret;
2331 int hwsbase, hwebase, vwsbase, vwebase, hwsize, vwsize;
2332 int hoffset, voffset, hwscale = 0, vwscale = 0;
2333
2334 /* The different sensor ICs handle setting up of window differently.
2335 * IF YOU SET IT WRONG, YOU WILL GET ALL ZERO ISOC DATA FROM OV51x!!! */
2336 switch (ov->sensor) {
2337 case SEN_OV7610:
2338 case SEN_OV76BE:
2339 hwsbase = 0x38;
2340 hwebase = 0x3a;
2341 vwsbase = vwebase = 0x05;
2342 break;
2343 case SEN_OV6620:
2344 case SEN_OV6630:
2345 hwsbase = 0x38;
2346 hwebase = 0x3a;
2347 vwsbase = 0x05;
2348 vwebase = 0x06;
2349 break;
2350 case SEN_OV7620:
2351 hwsbase = 0x2f; /* From 7620.SET (spec is wrong) */
2352 hwebase = 0x2f;
2353 vwsbase = vwebase = 0x05;
2354 break;
2355 default:
2356 err("Invalid sensor");
2357 return -EINVAL;
2358 }
2359
2360 if (ov->sensor == SEN_OV6620 || ov->sensor == SEN_OV6630) {
2361 /* Note: OV518(+) does downsample on its own) */
2362 if ((width > 176 && height > 144)
2363 || ov->bclass == BCL_OV518) { /* CIF */
2364 ret = mode_init_ov_sensor_regs(ov, width, height,
2365 mode, sub_flag, 0);
2366 if (ret < 0)
2367 return ret;
2368 hwscale = 1;
2369 vwscale = 1; /* The datasheet says 0; it's wrong */
2370 hwsize = 352;
2371 vwsize = 288;
2372 } else if (width > 176 || height > 144) {
2373 err("Illegal dimensions");
2374 return -EINVAL;
2375 } else { /* QCIF */
2376 ret = mode_init_ov_sensor_regs(ov, width, height,
2377 mode, sub_flag, 1);
2378 if (ret < 0)
2379 return ret;
2380 hwsize = 176;
2381 vwsize = 144;
2382 }
2383 } else {
2384 if (width > 320 && height > 240) { /* VGA */
2385 ret = mode_init_ov_sensor_regs(ov, width, height,
2386 mode, sub_flag, 0);
2387 if (ret < 0)
2388 return ret;
2389 hwscale = 2;
2390 vwscale = 1;
2391 hwsize = 640;
2392 vwsize = 480;
2393 } else if (width > 320 || height > 240) {
2394 err("Illegal dimensions");
2395 return -EINVAL;
2396 } else { /* QVGA */
2397 ret = mode_init_ov_sensor_regs(ov, width, height,
2398 mode, sub_flag, 1);
2399 if (ret < 0)
2400 return ret;
2401 hwscale = 1;
2402 hwsize = 320;
2403 vwsize = 240;
2404 }
2405 }
2406
2407 /* Center the window */
2408 hoffset = ((hwsize - width) / 2) >> hwscale;
2409 voffset = ((vwsize - height) / 2) >> vwscale;
2410
2411 /* FIXME! - This needs to be changed to support 160x120 and 6620!!! */
2412 if (sub_flag) {
2413 i2c_w(ov, 0x17, hwsbase+(ov->subx>>hwscale));
2414 i2c_w(ov, 0x18, hwebase+((ov->subx+ov->subw)>>hwscale));
2415 i2c_w(ov, 0x19, vwsbase+(ov->suby>>vwscale));
2416 i2c_w(ov, 0x1a, vwebase+((ov->suby+ov->subh)>>vwscale));
2417 } else {
2418 i2c_w(ov, 0x17, hwsbase + hoffset);
2419 i2c_w(ov, 0x18, hwebase + hoffset + (hwsize>>hwscale));
2420 i2c_w(ov, 0x19, vwsbase + voffset);
2421 i2c_w(ov, 0x1a, vwebase + voffset + (vwsize>>vwscale));
2422 }
2423
2424 #ifdef OV511_DEBUG
2425 if (dump_sensor)
2426 dump_i2c_regs(ov);
2427 #endif
2428
2429 return 0;
2430 }
2431
2432 /* Set up the OV511/OV511+ with the given image parameters.
2433 *
2434 * Do not put any sensor-specific code in here (including I2C I/O functions)
2435 */
2436 static int
2437 ov511_mode_init_regs(struct usb_ov511 *ov,
2438 int width, int height, int mode, int sub_flag)
2439 {
2440 int hsegs, vsegs;
2441
2442 if (sub_flag) {
2443 width = ov->subw;
2444 height = ov->subh;
2445 }
2446
2447 PDEBUG(3, "width:%d, height:%d, mode:%d, sub:%d",
2448 width, height, mode, sub_flag);
2449
2450 // FIXME: This should be moved to a 7111a-specific function once
2451 // subcapture is dealt with properly
2452 if (ov->sensor == SEN_SAA7111A) {
2453 if (width == 320 && height == 240) {
2454 /* No need to do anything special */
2455 } else if (width == 640 && height == 480) {
2456 /* Set the OV511 up as 320x480, but keep the
2457 * V4L resolution as 640x480 */
2458 width = 320;
2459 } else {
2460 err("SAA7111A only allows 320x240 or 640x480");
2461 return -EINVAL;
2462 }
2463 }
2464
2465 /* Make sure width and height are a multiple of 8 */
2466 if (width % 8 || height % 8) {
2467 err("Invalid size (%d, %d) (mode = %d)", width, height, mode);
2468 return -EINVAL;
2469 }
2470
2471 if (width < ov->minwidth || height < ov->minheight) {
2472 err("Requested dimensions are too small");
2473 return -EINVAL;
2474 }
2475
2476 if (ov51x_stop(ov) < 0)
2477 return -EIO;
2478
2479 if (mode == VIDEO_PALETTE_GREY) {
2480 reg_w(ov, R511_CAM_UV_EN, 0x00);
2481 reg_w(ov, R511_SNAP_UV_EN, 0x00);
2482 reg_w(ov, R511_SNAP_OPTS, 0x01);
2483 } else {
2484 reg_w(ov, R511_CAM_UV_EN, 0x01);
2485 reg_w(ov, R511_SNAP_UV_EN, 0x01);
2486 reg_w(ov, R511_SNAP_OPTS, 0x03);
2487 }
2488
2489 /* Here I'm assuming that snapshot size == image size.
2490 * I hope that's always true. --claudio
2491 */
2492 hsegs = (width >> 3) - 1;
2493 vsegs = (height >> 3) - 1;
2494
2495 reg_w(ov, R511_CAM_PXCNT, hsegs);
2496 reg_w(ov, R511_CAM_LNCNT, vsegs);
2497 reg_w(ov, R511_CAM_PXDIV, 0x00);
2498 reg_w(ov, R511_CAM_LNDIV, 0x00);
2499
2500 /* YUV420, low pass filter on */
2501 reg_w(ov, R511_CAM_OPTS, 0x03);
2502
2503 /* Snapshot additions */
2504 reg_w(ov, R511_SNAP_PXCNT, hsegs);
2505 reg_w(ov, R511_SNAP_LNCNT, vsegs);
2506 reg_w(ov, R511_SNAP_PXDIV, 0x00);
2507 reg_w(ov, R511_SNAP_LNDIV, 0x00);
2508
2509 if (ov->compress) {
2510 /* Enable Y and UV quantization and compression */
2511 reg_w(ov, R511_COMP_EN, 0x07);
2512 reg_w(ov, R511_COMP_LUT_EN, 0x03);
2513 ov51x_reset(ov, OV511_RESET_OMNICE);
2514 }
2515
2516 if (ov51x_restart(ov) < 0)
2517 return -EIO;
2518
2519 return 0;
2520 }
2521
2522 /* Sets up the OV518/OV518+ with the given image parameters
2523 *
2524 * OV518 needs a completely different approach, until we can figure out what
2525 * the individual registers do. Also, only 15 FPS is supported now.
2526 *
2527 * Do not put any sensor-specific code in here (including I2C I/O functions)
2528 */
2529 static int
2530 ov518_mode_init_regs(struct usb_ov511 *ov,
2531 int width, int height, int mode, int sub_flag)
2532 {
2533 int hsegs, vsegs, hi_res;
2534
2535 if (sub_flag) {
2536 width = ov->subw;
2537 height = ov->subh;
2538 }
2539
2540 PDEBUG(3, "width:%d, height:%d, mode:%d, sub:%d",
2541 width, height, mode, sub_flag);
2542
2543 if (width % 16 || height % 8) {
2544 err("Invalid size (%d, %d)", width, height);
2545 return -EINVAL;
2546 }
2547
2548 if (width < ov->minwidth || height < ov->minheight) {
2549 err("Requested dimensions are too small");
2550 return -EINVAL;
2551 }
2552
2553 if (width >= 320 && height >= 240) {
2554 hi_res = 1;
2555 } else if (width >= 320 || height >= 240) {
2556 err("Invalid width/height combination (%d, %d)", width, height);
2557 return -EINVAL;
2558 } else {
2559 hi_res = 0;
2560 }
2561
2562 if (ov51x_stop(ov) < 0)
2563 return -EIO;
2564
2565 /******** Set the mode ********/
2566
2567 reg_w(ov, 0x2b, 0);
2568 reg_w(ov, 0x2c, 0);
2569 reg_w(ov, 0x2d, 0);
2570 reg_w(ov, 0x2e, 0);
2571 reg_w(ov, 0x3b, 0);
2572 reg_w(ov, 0x3c, 0);
2573 reg_w(ov, 0x3d, 0);
2574 reg_w(ov, 0x3e, 0);
2575
2576 if (ov->bridge == BRG_OV518 && ov518_color) {
2577 /* OV518 needs U and V swapped */
2578 i2c_w_mask(ov, 0x15, 0x00, 0x01);
2579
2580 if (mode == VIDEO_PALETTE_GREY) {
2581 /* Set 16-bit input format (UV data are ignored) */
2582 reg_w_mask(ov, 0x20, 0x00, 0x08);
2583
2584 /* Set 8-bit (4:0:0) output format */
2585 reg_w_mask(ov, 0x28, 0x00, 0xf0);
2586 reg_w_mask(ov, 0x38, 0x00, 0xf0);
2587 } else {
2588 /* Set 8-bit (YVYU) input format */
2589 reg_w_mask(ov, 0x20, 0x08, 0x08);
2590
2591 /* Set 12-bit (4:2:0) output format */
2592 reg_w_mask(ov, 0x28, 0x80, 0xf0);
2593 reg_w_mask(ov, 0x38, 0x80, 0xf0);
2594 }
2595 } else {
2596 reg_w(ov, 0x28, (mode == VIDEO_PALETTE_GREY) ? 0x00:0x80);
2597 reg_w(ov, 0x38, (mode == VIDEO_PALETTE_GREY) ? 0x00:0x80);
2598 }
2599
2600 hsegs = width / 16;
2601 vsegs = height / 4;
2602
2603 reg_w(ov, 0x29, hsegs);
2604 reg_w(ov, 0x2a, vsegs);
2605
2606 reg_w(ov, 0x39, hsegs);
2607 reg_w(ov, 0x3a, vsegs);
2608
2609 /* Windows driver does this here; who knows why */
2610 reg_w(ov, 0x2f, 0x80);
2611
2612 /******** Set the framerate (to 15 FPS) ********/
2613
2614 /* Mode independent, but framerate dependent, regs */
2615 reg_w(ov, 0x51, 0x02); /* Clock divider; lower==faster */
2616 reg_w(ov, 0x22, 0x18);
2617 reg_w(ov, 0x23, 0xff);
2618
2619 if (ov->bridge == BRG_OV518PLUS)
2620 reg_w(ov, 0x21, 0x19);
2621 else
2622 reg_w(ov, 0x71, 0x19); /* Compression-related? */
2623
2624 // FIXME: Sensor-specific
2625 /* Bit 5 is what matters here. Of course, it is "reserved" */
2626 i2c_w(ov, 0x54, 0x23);
2627
2628 reg_w(ov, 0x2f, 0x80);
2629
2630 if (ov->bridge == BRG_OV518PLUS) {
2631 reg_w(ov, 0x24, 0x94);
2632 reg_w(ov, 0x25, 0x90);
2633 ov518_reg_w32(ov, 0xc4, 400, 2); /* 190h */
2634 ov518_reg_w32(ov, 0xc6, 540, 2); /* 21ch */
2635 ov518_reg_w32(ov, 0xc7, 540, 2); /* 21ch */
2636 ov518_reg_w32(ov, 0xc8, 108, 2); /* 6ch */
2637 ov518_reg_w32(ov, 0xca, 131098, 3); /* 2001ah */
2638 ov518_reg_w32(ov, 0xcb, 532, 2); /* 214h */
2639 ov518_reg_w32(ov, 0xcc, 2400, 2); /* 960h */
2640 ov518_reg_w32(ov, 0xcd, 32, 2); /* 20h */
2641 ov518_reg_w32(ov, 0xce, 608, 2); /* 260h */
2642 } else {
2643 reg_w(ov, 0x24, 0x9f);
2644 reg_w(ov, 0x25, 0x90);
2645 ov518_reg_w32(ov, 0xc4, 400, 2); /* 190h */
2646 ov518_reg_w32(ov, 0xc6, 500, 2); /* 1f4h */
2647 ov518_reg_w32(ov, 0xc7, 500, 2); /* 1f4h */
2648 ov518_reg_w32(ov, 0xc8, 142, 2); /* 8eh */
2649 ov518_reg_w32(ov, 0xca, 131098, 3); /* 2001ah */
2650 ov518_reg_w32(ov, 0xcb, 532, 2); /* 214h */
2651 ov518_reg_w32(ov, 0xcc, 2000, 2); /* 7d0h */
2652 ov518_reg_w32(ov, 0xcd, 32, 2); /* 20h */
2653 ov518_reg_w32(ov, 0xce, 608, 2); /* 260h */
2654 }
2655
2656 reg_w(ov, 0x2f, 0x80);
2657
2658 if (ov51x_restart(ov) < 0)
2659 return -EIO;
2660
2661 /* Reset it just for good measure */
2662 if (ov51x_reset(ov, OV511_RESET_NOREGS) < 0)
2663 return -EIO;
2664
2665 return 0;
2666 }
2667
2668 /* This is a wrapper around the OV511, OV518, and sensor specific functions */
2669 static int
2670 mode_init_regs(struct usb_ov511 *ov,
2671 int width, int height, int mode, int sub_flag)
2672 {
2673 int rc = 0;
2674
2675 if (!ov || !ov->dev)
2676 return -EFAULT;
2677
2678 if (ov->bclass == BCL_OV518) {
2679 rc = ov518_mode_init_regs(ov, width, height, mode, sub_flag);
2680 } else {
2681 rc = ov511_mode_init_regs(ov, width, height, mode, sub_flag);
2682 }
2683
2684 if (FATAL_ERROR(rc))
2685 return rc;
2686
2687 switch (ov->sensor) {
2688 case SEN_OV7610:
2689 case SEN_OV7620:
2690 case SEN_OV76BE:
2691 case SEN_OV8600:
2692 case SEN_OV6620:
2693 case SEN_OV6630:
2694 rc = set_ov_sensor_window(ov, width, height, mode, sub_flag);
2695 break;
2696 case SEN_KS0127:
2697 case SEN_KS0127B:
2698 err("KS0127-series decoders not supported yet");
2699 rc = -EINVAL;
2700 break;
2701 case SEN_SAA7111A:
2702 // rc = mode_init_saa_sensor_regs(ov, width, height, mode,
2703 // sub_flag);
2704
2705 PDEBUG(1, "SAA status = 0x%02X", i2c_r(ov, 0x1f));
2706 break;
2707 default:
2708 err("Unknown sensor");
2709 rc = -EINVAL;
2710 }
2711
2712 if (FATAL_ERROR(rc))
2713 return rc;
2714
2715 /* Sensor-independent settings */
2716 rc = sensor_set_auto_brightness(ov, ov->auto_brt);
2717 if (FATAL_ERROR(rc))
2718 return rc;
2719
2720 rc = sensor_set_auto_exposure(ov, ov->auto_exp);
2721 if (FATAL_ERROR(rc))
2722 return rc;
2723
2724 rc = sensor_set_banding_filter(ov, bandingfilter);
2725 if (FATAL_ERROR(rc))
2726 return rc;
2727
2728 if (ov->lightfreq) {
2729 rc = sensor_set_light_freq(ov, lightfreq);
2730 if (FATAL_ERROR(rc))
2731 return rc;
2732 }
2733
2734 rc = sensor_set_backlight(ov, ov->backlight);
2735 if (FATAL_ERROR(rc))
2736 return rc;
2737
2738 rc = sensor_set_mirror(ov, ov->mirror);
2739 if (FATAL_ERROR(rc))
2740 return rc;
2741
2742 return 0;
2743 }
2744
2745 /* This sets the default image parameters. This is useful for apps that use
2746 * read() and do not set these.
2747 */
2748 static int
2749 ov51x_set_default_params(struct usb_ov511 *ov)
2750 {
2751 int i;
2752
2753 /* Set default sizes in case IOCTL (VIDIOCMCAPTURE) is not used
2754 * (using read() instead). */
2755 for (i = 0; i < OV511_NUMFRAMES; i++) {
2756 ov->frame[i].width = ov->maxwidth;
2757 ov->frame[i].height = ov->maxheight;
2758 ov->frame[i].bytes_read = 0;
2759 if (force_palette)
2760 ov->frame[i].format = force_palette;
2761 else
2762 ov->frame[i].format = VIDEO_PALETTE_YUV420;
2763
2764 ov->frame[i].depth = get_depth(ov->frame[i].format);
2765 }
2766
2767 PDEBUG(3, "%dx%d, %s", ov->maxwidth, ov->maxheight,
2768 symbolic(v4l1_plist, ov->frame[0].format));
2769
2770 /* Initialize to max width/height, YUV420 or RGB24 (if supported) */
2771 if (mode_init_regs(ov, ov->maxwidth, ov->maxheight,
2772 ov->frame[0].format, 0) < 0)
2773 return -EINVAL;
2774
2775 return 0;
2776 }
2777
2778 /**********************************************************************
2779 *
2780 * Video decoder stuff
2781 *
2782 **********************************************************************/
2783
2784 /* Set analog input port of decoder */
2785 static int
2786 decoder_set_input(struct usb_ov511 *ov, int input)
2787 {
2788 PDEBUG(4, "port %d", input);
2789
2790 switch (ov->sensor) {
2791 case SEN_SAA7111A:
2792 {
2793 /* Select mode */
2794 i2c_w_mask(ov, 0x02, input, 0x07);
2795 /* Bypass chrominance trap for modes 4..7 */
2796 i2c_w_mask(ov, 0x09, (input > 3) ? 0x80:0x00, 0x80);
2797 break;
2798 }
2799 default:
2800 return -EINVAL;
2801 }
2802
2803 return 0;
2804 }
2805
2806 /* Get ASCII name of video input */
2807 static int
2808 decoder_get_input_name(struct usb_ov511 *ov, int input, char *name)
2809 {
2810 switch (ov->sensor) {
2811 case SEN_SAA7111A:
2812 {
2813 if (input < 0 || input > 7)
2814 return -EINVAL;
2815 else if (input < 4)
2816 sprintf(name, "CVBS-%d", input);
2817 else // if (input < 8)
2818 sprintf(name, "S-Video-%d", input - 4);
2819 break;
2820 }
2821 default:
2822 sprintf(name, "%s", "Camera");
2823 }
2824
2825 return 0;
2826 }
2827
2828 /* Set norm (NTSC, PAL, SECAM, AUTO) */
2829 static int
2830 decoder_set_norm(struct usb_ov511 *ov, int norm)
2831 {
2832 PDEBUG(4, "%d", norm);
2833
2834 switch (ov->sensor) {
2835 case SEN_SAA7111A:
2836 {
2837 int reg_8, reg_e;
2838
2839 if (norm == VIDEO_MODE_NTSC) {
2840 reg_8 = 0x40; /* 60 Hz */
2841 reg_e = 0x00; /* NTSC M / PAL BGHI */
2842 } else if (norm == VIDEO_MODE_PAL) {
2843 reg_8 = 0x00; /* 50 Hz */
2844 reg_e = 0x00; /* NTSC M / PAL BGHI */
2845 } else if (norm == VIDEO_MODE_AUTO) {
2846 reg_8 = 0x80; /* Auto field detect */
2847 reg_e = 0x00; /* NTSC M / PAL BGHI */
2848 } else if (norm == VIDEO_MODE_SECAM) {
2849 reg_8 = 0x00; /* 50 Hz */
2850 reg_e = 0x50; /* SECAM / PAL 4.43 */
2851 } else {
2852 return -EINVAL;
2853 }
2854
2855 i2c_w_mask(ov, 0x08, reg_8, 0xc0);
2856 i2c_w_mask(ov, 0x0e, reg_e, 0x70);
2857 break;
2858 }
2859 default:
2860 return -EINVAL;
2861 }
2862
2863 return 0;
2864 }
2865
2866 /**********************************************************************
2867 *
2868 * Raw data parsing
2869 *
2870 **********************************************************************/
2871
2872 /* Copies a 64-byte segment at pIn to an 8x8 block at pOut. The width of the
2873 * image at pOut is specified by w.
2874 */
2875 static inline void
2876 make_8x8(unsigned char *pIn, unsigned char *pOut, int w)
2877 {
2878 unsigned char *pOut1 = pOut;
2879 int x, y;
2880
2881 for (y = 0; y < 8; y++) {
2882 pOut1 = pOut;
2883 for (x = 0; x < 8; x++) {
2884 *pOut1++ = *pIn++;
2885 }
2886 pOut += w;
2887 }
2888 }
2889
2890 /*
2891 * For RAW BW (YUV 4:0:0) images, data show up in 256 byte segments.
2892 * The segments represent 4 squares of 8x8 pixels as follows:
2893 *
2894 * 0 1 ... 7 64 65 ... 71 ... 192 193 ... 199
2895 * 8 9 ... 15 72 73 ... 79 200 201 ... 207
2896 * ... ... ...
2897 * 56 57 ... 63 120 121 ... 127 248 249 ... 255
2898 *
2899 */
2900 static void
2901 yuv400raw_to_yuv400p(struct ov511_frame *frame,
2902 unsigned char *pIn0, unsigned char *pOut0)
2903 {
2904 int x, y;
2905 unsigned char *pIn, *pOut, *pOutLine;
2906
2907 /* Copy Y */
2908 pIn = pIn0;
2909 pOutLine = pOut0;
2910 for (y = 0; y < frame->rawheight - 1; y += 8) {
2911 pOut = pOutLine;
2912 for (x = 0; x < frame->rawwidth - 1; x += 8) {
2913 make_8x8(pIn, pOut, frame->rawwidth);
2914 pIn += 64;
2915 pOut += 8;
2916 }
2917 pOutLine += 8 * frame->rawwidth;
2918 }
2919 }
2920
2921 /*
2922 * For YUV 4:2:0 images, the data show up in 384 byte segments.
2923 * The first 64 bytes of each segment are U, the next 64 are V. The U and
2924 * V are arranged as follows:
2925 *
2926 * 0 1 ... 7
2927 * 8 9 ... 15
2928 * ...
2929 * 56 57 ... 63
2930 *
2931 * U and V are shipped at half resolution (1 U,V sample -> one 2x2 block).
2932 *
2933 * The next 256 bytes are full resolution Y data and represent 4 squares
2934 * of 8x8 pixels as follows:
2935 *
2936 * 0 1 ... 7 64 65 ... 71 ... 192 193 ... 199
2937 * 8 9 ... 15 72 73 ... 79 200 201 ... 207
2938 * ... ... ...
2939 * 56 57 ... 63 120 121 ... 127 ... 248 249 ... 255
2940 *
2941 * Note that the U and V data in one segment represent a 16 x 16 pixel
2942 * area, but the Y data represent a 32 x 8 pixel area. If the width is not an
2943 * even multiple of 32, the extra 8x8 blocks within a 32x8 block belong to the
2944 * next horizontal stripe.
2945 *
2946 * If dumppix module param is set, _parse_data just dumps the incoming segments,
2947 * verbatim, in order, into the frame. When used with vidcat -f ppm -s 640x480
2948 * this puts the data on the standard output and can be analyzed with the
2949 * parseppm.c utility I wrote. That's a much faster way for figuring out how
2950 * these data are scrambled.
2951 */
2952
2953 /* Converts from raw, uncompressed segments at pIn0 to a YUV420P frame at pOut0.
2954 *
2955 * FIXME: Currently only handles width and height that are multiples of 16
2956 */
2957 static void
2958 yuv420raw_to_yuv420p(struct ov511_frame *frame,
2959 unsigned char *pIn0, unsigned char *pOut0)
2960 {
2961 int k, x, y;
2962 unsigned char *pIn, *pOut, *pOutLine;
2963 const unsigned int a = frame->rawwidth * frame->rawheight;
2964 const unsigned int w = frame->rawwidth / 2;
2965
2966 /* Copy U and V */
2967 pIn = pIn0;
2968 pOutLine = pOut0 + a;
2969 for (y = 0; y < frame->rawheight - 1; y += 16) {
2970 pOut = pOutLine;
2971 for (x = 0; x < frame->rawwidth - 1; x += 16) {
2972 make_8x8(pIn, pOut, w);
2973 make_8x8(pIn + 64, pOut + a/4, w);
2974 pIn += 384;
2975 pOut += 8;
2976 }
2977 pOutLine += 8 * w;
2978 }
2979
2980 /* Copy Y */
2981 pIn = pIn0 + 128;
2982 pOutLine = pOut0;
2983 k = 0;
2984 for (y = 0; y < frame->rawheight - 1; y += 8) {
2985 pOut = pOutLine;
2986 for (x = 0; x < frame->rawwidth - 1; x += 8) {
2987 make_8x8(pIn, pOut, frame->rawwidth);
2988 pIn += 64;
2989 pOut += 8;
2990 if ((++k) > 3) {
2991 k = 0;
2992 pIn += 128;
2993 }
2994 }
2995 pOutLine += 8 * frame->rawwidth;
2996 }
2997 }
2998
2999 /**********************************************************************
3000 *
3001 * Decompression
3002 *
3003 **********************************************************************/
3004
3005 static int
3006 request_decompressor(struct usb_ov511 *ov)
3007 {
3008 if (ov->bclass == BCL_OV511 || ov->bclass == BCL_OV518) {
3009 err("No decompressor available");
3010 } else {
3011 err("Unknown bridge");
3012 }
3013
3014 return -ENOSYS;
3015 }
3016
3017 static void
3018 decompress(struct usb_ov511 *ov, struct ov511_frame *frame,
3019 unsigned char *pIn0, unsigned char *pOut0)
3020 {
3021 if (!ov->decomp_ops)
3022 if (request_decompressor(ov))
3023 return;
3024
3025 }
3026
3027 /**********************************************************************
3028 *
3029 * Format conversion
3030 *
3031 **********************************************************************/
3032
3033 /* Fuses even and odd fields together, and doubles width.
3034 * INPUT: an odd field followed by an even field at pIn0, in YUV planar format
3035 * OUTPUT: a normal YUV planar image, with correct aspect ratio
3036 */
3037 static void
3038 deinterlace(struct ov511_frame *frame, int rawformat,
3039 unsigned char *pIn0, unsigned char *pOut0)
3040 {
3041 const int fieldheight = frame->rawheight / 2;
3042 const int fieldpix = fieldheight * frame->rawwidth;
3043 const int w = frame->width;
3044 int x, y;
3045 unsigned char *pInEven, *pInOdd, *pOut;
3046
3047 PDEBUG(5, "fieldheight=%d", fieldheight);
3048
3049 if (frame->rawheight != frame->height) {
3050 err("invalid height");
3051 return;
3052 }
3053
3054 if ((frame->rawwidth * 2) != frame->width) {
3055 err("invalid width");
3056 return;
3057 }
3058
3059 /* Y */
3060 pInOdd = pIn0;
3061 pInEven = pInOdd + fieldpix;
3062 pOut = pOut0;
3063 for (y = 0; y < fieldheight; y++) {
3064 for (x = 0; x < frame->rawwidth; x++) {
3065 *pOut = *pInEven;
3066 *(pOut+1) = *pInEven++;
3067 *(pOut+w) = *pInOdd;
3068 *(pOut+w+1) = *pInOdd++;
3069 pOut += 2;
3070 }
3071 pOut += w;
3072 }
3073
3074 if (rawformat == RAWFMT_YUV420) {
3075 /* U */
3076 pInOdd = pIn0 + fieldpix * 2;
3077 pInEven = pInOdd + fieldpix / 4;
3078 for (y = 0; y < fieldheight / 2; y++) {
3079 for (x = 0; x < frame->rawwidth / 2; x++) {
3080 *pOut = *pInEven;
3081 *(pOut+1) = *pInEven++;
3082 *(pOut+w/2) = *pInOdd;
3083 *(pOut+w/2+1) = *pInOdd++;
3084 pOut += 2;
3085 }
3086 pOut += w/2;
3087 }
3088 /* V */
3089 pInOdd = pIn0 + fieldpix * 2 + fieldpix / 2;
3090 pInEven = pInOdd + fieldpix / 4;
3091 for (y = 0; y < fieldheight / 2; y++) {
3092 for (x = 0; x < frame->rawwidth / 2; x++) {
3093 *pOut = *pInEven;
3094 *(pOut+1) = *pInEven++;
3095 *(pOut+w/2) = *pInOdd;
3096 *(pOut+w/2+1) = *pInOdd++;
3097 pOut += 2;
3098 }
3099 pOut += w/2;
3100 }
3101 }
3102 }
3103
3104 static void
3105 ov51x_postprocess_grey(struct usb_ov511 *ov, struct ov511_frame *frame)
3106 {
3107 /* Deinterlace frame, if necessary */
3108 if (ov->sensor == SEN_SAA7111A && frame->rawheight >= 480) {
3109 if (frame->compressed)
3110 decompress(ov, frame, frame->rawdata,
3111 frame->tempdata);
3112 else
3113 yuv400raw_to_yuv400p(frame, frame->rawdata,
3114 frame->tempdata);
3115
3116 deinterlace(frame, RAWFMT_YUV400, frame->tempdata,
3117 frame->data);
3118 } else {
3119 if (frame->compressed)
3120 decompress(ov, frame, frame->rawdata,
3121 frame->data);
3122 else
3123 yuv400raw_to_yuv400p(frame, frame->rawdata,
3124 frame->data);
3125 }
3126 }
3127
3128 /* Process raw YUV420 data into standard YUV420P */
3129 static void
3130 ov51x_postprocess_yuv420(struct usb_ov511 *ov, struct ov511_frame *frame)
3131 {
3132 /* Deinterlace frame, if necessary */
3133 if (ov->sensor == SEN_SAA7111A && frame->rawheight >= 480) {
3134 if (frame->compressed)
3135 decompress(ov, frame, frame->rawdata, frame->tempdata);
3136 else
3137 yuv420raw_to_yuv420p(frame, frame->rawdata,
3138 frame->tempdata);
3139
3140 deinterlace(frame, RAWFMT_YUV420, frame->tempdata,
3141 frame->data);
3142 } else {
3143 if (frame->compressed)
3144 decompress(ov, frame, frame->rawdata, frame->data);
3145 else
3146 yuv420raw_to_yuv420p(frame, frame->rawdata,
3147 frame->data);
3148 }
3149 }
3150
3151 /* Post-processes the specified frame. This consists of:
3152 * 1. Decompress frame, if necessary
3153 * 2. Deinterlace frame and scale to proper size, if necessary
3154 * 3. Convert from YUV planar to destination format, if necessary
3155 * 4. Fix the RGB offset, if necessary
3156 */
3157 static void
3158 ov51x_postprocess(struct usb_ov511 *ov, struct ov511_frame *frame)
3159 {
3160 if (dumppix) {
3161 memset(frame->data, 0,
3162 MAX_DATA_SIZE(ov->maxwidth, ov->maxheight));
3163 PDEBUG(4, "Dumping %d bytes", frame->bytes_recvd);
3164 memcpy(frame->data, frame->rawdata, frame->bytes_recvd);
3165 } else {
3166 switch (frame->format) {
3167 case VIDEO_PALETTE_GREY:
3168 ov51x_postprocess_grey(ov, frame);
3169 break;
3170 case VIDEO_PALETTE_YUV420:
3171 case VIDEO_PALETTE_YUV420P:
3172 ov51x_postprocess_yuv420(ov, frame);
3173 break;
3174 default:
3175 err("Cannot convert data to %s",
3176 symbolic(v4l1_plist, frame->format));
3177 }
3178 }
3179 }
3180
3181 /**********************************************************************
3182 *
3183 * OV51x data transfer, IRQ handler
3184 *
3185 **********************************************************************/
3186
3187 static inline void
3188 ov511_move_data(struct usb_ov511 *ov, unsigned char *in, int n)
3189 {
3190 int num, offset;
3191 int pnum = in[ov->packet_size - 1]; /* Get packet number */
3192 int max_raw = MAX_RAW_DATA_SIZE(ov->maxwidth, ov->maxheight);
3193 struct ov511_frame *frame = &ov->frame[ov->curframe];
3194 struct timeval *ts;
3195
3196 /* SOF/EOF packets have 1st to 8th bytes zeroed and the 9th
3197 * byte non-zero. The EOF packet has image width/height in the
3198 * 10th and 11th bytes. The 9th byte is given as follows:
3199 *
3200 * bit 7: EOF
3201 * 6: compression enabled
3202 * 5: 422/420/400 modes
3203 * 4: 422/420/400 modes
3204 * 3: 1
3205 * 2: snapshot button on
3206 * 1: snapshot frame
3207 * 0: even/odd field
3208 */
3209
3210 if (printph) {
3211 dev_info(&ov->dev->dev,
3212 "ph(%3d): %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x\n",
3213 pnum, in[0], in[1], in[2], in[3], in[4], in[5], in[6],
3214 in[7], in[8], in[9], in[10], in[11]);
3215 }
3216
3217 /* Check for SOF/EOF packet */
3218 if ((in[0] | in[1] | in[2] | in[3] | in[4] | in[5] | in[6] | in[7]) ||
3219 (~in[8] & 0x08))
3220 goto check_middle;
3221
3222 /* Frame end */
3223 if (in[8] & 0x80) {
3224 ts = (struct timeval *)(frame->data
3225 + MAX_FRAME_SIZE(ov->maxwidth, ov->maxheight));
3226 do_gettimeofday(ts);
3227
3228 /* Get the actual frame size from the EOF header */
3229 frame->rawwidth = ((int)(in[9]) + 1) * 8;
3230 frame->rawheight = ((int)(in[10]) + 1) * 8;
3231
3232 PDEBUG(4, "Frame end, frame=%d, pnum=%d, w=%d, h=%d, recvd=%d",
3233 ov->curframe, pnum, frame->rawwidth, frame->rawheight,
3234 frame->bytes_recvd);
3235
3236 /* Validate the header data */
3237 RESTRICT_TO_RANGE(frame->rawwidth, ov->minwidth, ov->maxwidth);
3238 RESTRICT_TO_RANGE(frame->rawheight, ov->minheight,
3239 ov->maxheight);
3240
3241 /* Don't allow byte count to exceed buffer size */
3242 RESTRICT_TO_RANGE(frame->bytes_recvd, 8, max_raw);
3243
3244 if (frame->scanstate == STATE_LINES) {
3245 int nextf;
3246
3247 frame->grabstate = FRAME_DONE;
3248 wake_up_interruptible(&frame->wq);
3249
3250 /* If next frame is ready or grabbing,
3251 * point to it */
3252 nextf = (ov->curframe + 1) % OV511_NUMFRAMES;
3253 if (ov->frame[nextf].grabstate == FRAME_READY
3254 || ov->frame[nextf].grabstate == FRAME_GRABBING) {
3255 ov->curframe = nextf;
3256 ov->frame[nextf].scanstate = STATE_SCANNING;
3257 } else {
3258 if (frame->grabstate == FRAME_DONE) {
3259 PDEBUG(4, "** Frame done **");
3260 } else {
3261 PDEBUG(4, "Frame not ready? state = %d",
3262 ov->frame[nextf].grabstate);
3263 }
3264
3265 ov->curframe = -1;
3266 }
3267 } else {
3268 PDEBUG(5, "Frame done, but not scanning");
3269 }
3270 /* Image corruption caused by misplaced frame->segment = 0
3271 * fixed by carlosf@conectiva.com.br
3272 */
3273 } else {
3274 /* Frame start */
3275 PDEBUG(4, "Frame start, framenum = %d", ov->curframe);
3276
3277 /* Check to see if it's a snapshot frame */
3278 /* FIXME?? Should the snapshot reset go here? Performance? */
3279 if (in[8] & 0x02) {
3280 frame->snapshot = 1;
3281 PDEBUG(3, "snapshot detected");
3282 }
3283
3284 frame->scanstate = STATE_LINES;
3285 frame->bytes_recvd = 0;
3286 frame->compressed = in[8] & 0x40;
3287 }
3288
3289 check_middle:
3290 /* Are we in a frame? */
3291 if (frame->scanstate != STATE_LINES) {
3292 PDEBUG(5, "Not in a frame; packet skipped");
3293 return;
3294 }
3295
3296 /* If frame start, skip header */
3297 if (frame->bytes_recvd == 0)
3298 offset = 9;
3299 else
3300 offset = 0;
3301
3302 num = n - offset - 1;
3303
3304 /* Dump all data exactly as received */
3305 if (dumppix == 2) {
3306 frame->bytes_recvd += n - 1;
3307 if (frame->bytes_recvd <= max_raw)
3308 memcpy(frame->rawdata + frame->bytes_recvd - (n - 1),
3309 in, n - 1);
3310 else
3311 PDEBUG(3, "Raw data buffer overrun!! (%d)",
3312 frame->bytes_recvd - max_raw);
3313 } else if (!frame->compressed && !remove_zeros) {
3314 frame->bytes_recvd += num;
3315 if (frame->bytes_recvd <= max_raw)
3316 memcpy(frame->rawdata + frame->bytes_recvd - num,
3317 in + offset, num);
3318 else
3319 PDEBUG(3, "Raw data buffer overrun!! (%d)",
3320 frame->bytes_recvd - max_raw);
3321 } else { /* Remove all-zero FIFO lines (aligned 32-byte blocks) */
3322 int b, read = 0, allzero, copied = 0;
3323 if (offset) {
3324 frame->bytes_recvd += 32 - offset; // Bytes out
3325 memcpy(frame->rawdata, in + offset, 32 - offset);
3326 read += 32;
3327 }
3328
3329 while (read < n - 1) {
3330 allzero = 1;
3331 for (b = 0; b < 32; b++) {
3332 if (in[read + b]) {
3333 allzero = 0;
3334 break;
3335 }
3336 }
3337
3338 if (allzero) {
3339 /* Don't copy it */
3340 } else {
3341 if (frame->bytes_recvd + copied + 32 <= max_raw)
3342 {
3343 memcpy(frame->rawdata
3344 + frame->bytes_recvd + copied,
3345 in + read, 32);
3346 copied += 32;
3347 } else {
3348 PDEBUG(3, "Raw data buffer overrun!!");
3349 }
3350 }
3351 read += 32;
3352 }
3353
3354 frame->bytes_recvd += copied;
3355 }
3356 }
3357
3358 static inline void
3359 ov518_move_data(struct usb_ov511 *ov, unsigned char *in, int n)
3360 {
3361 int max_raw = MAX_RAW_DATA_SIZE(ov->maxwidth, ov->maxheight);
3362 struct ov511_frame *frame = &ov->frame[ov->curframe];
3363 struct timeval *ts;
3364
3365 /* Don't copy the packet number byte */
3366 if (ov->packet_numbering)
3367 --n;
3368
3369 /* A false positive here is likely, until OVT gives me
3370 * the definitive SOF/EOF format */
3371 if ((!(in[0] | in[1] | in[2] | in[3] | in[5])) && in[6]) {
3372 if (printph) {
3373 dev_info(&ov->dev->dev,
3374 "ph: %2x %2x %2x %2x %2x %2x %2x %2x\n",
3375 in[0], in[1], in[2], in[3], in[4], in[5],
3376 in[6], in[7]);
3377 }
3378
3379 if (frame->scanstate == STATE_LINES) {
3380 PDEBUG(4, "Detected frame end/start");
3381 goto eof;
3382 } else { //scanstate == STATE_SCANNING
3383 /* Frame start */
3384 PDEBUG(4, "Frame start, framenum = %d", ov->curframe);
3385 goto sof;
3386 }
3387 } else {
3388 goto check_middle;
3389 }
3390
3391 eof:
3392 ts = (struct timeval *)(frame->data
3393 + MAX_FRAME_SIZE(ov->maxwidth, ov->maxheight));
3394 do_gettimeofday(ts);
3395
3396 PDEBUG(4, "Frame end, curframe = %d, hw=%d, vw=%d, recvd=%d",
3397 ov->curframe,
3398 (int)(in[9]), (int)(in[10]), frame->bytes_recvd);
3399
3400 // FIXME: Since we don't know the header formats yet,
3401 // there is no way to know what the actual image size is
3402 frame->rawwidth = frame->width;
3403 frame->rawheight = frame->height;
3404
3405 /* Validate the header data */
3406 RESTRICT_TO_RANGE(frame->rawwidth, ov->minwidth, ov->maxwidth);
3407 RESTRICT_TO_RANGE(frame->rawheight, ov->minheight, ov->maxheight);
3408
3409 /* Don't allow byte count to exceed buffer size */
3410 RESTRICT_TO_RANGE(frame->bytes_recvd, 8, max_raw);
3411
3412 if (frame->scanstate == STATE_LINES) {
3413 int nextf;
3414
3415 frame->grabstate = FRAME_DONE;
3416 wake_up_interruptible(&frame->wq);
3417
3418 /* If next frame is ready or grabbing,
3419 * point to it */
3420 nextf = (ov->curframe + 1) % OV511_NUMFRAMES;
3421 if (ov->frame[nextf].grabstate == FRAME_READY
3422 || ov->frame[nextf].grabstate == FRAME_GRABBING) {
3423 ov->curframe = nextf;
3424 ov->frame[nextf].scanstate = STATE_SCANNING;
3425 frame = &ov->frame[nextf];
3426 } else {
3427 if (frame->grabstate == FRAME_DONE) {
3428 PDEBUG(4, "** Frame done **");
3429 } else {
3430 PDEBUG(4, "Frame not ready? state = %d",
3431 ov->frame[nextf].grabstate);
3432 }
3433
3434 ov->curframe = -1;
3435 PDEBUG(4, "SOF dropped (no active frame)");
3436 return; /* Nowhere to store this frame */
3437 }
3438 }
3439 sof:
3440 PDEBUG(4, "Starting capture on frame %d", frame->framenum);
3441
3442 // Snapshot not reverse-engineered yet.
3443 #if 0
3444 /* Check to see if it's a snapshot frame */
3445 /* FIXME?? Should the snapshot reset go here? Performance? */
3446 if (in[8] & 0x02) {
3447 frame->snapshot = 1;
3448 PDEBUG(3, "snapshot detected");
3449 }
3450 #endif
3451 frame->scanstate = STATE_LINES;
3452 frame->bytes_recvd = 0;
3453 frame->compressed = 1;
3454
3455 check_middle:
3456 /* Are we in a frame? */
3457 if (frame->scanstate != STATE_LINES) {
3458 PDEBUG(4, "scanstate: no SOF yet");
3459 return;
3460 }
3461
3462 /* Dump all data exactly as received */
3463 if (dumppix == 2) {
3464 frame->bytes_recvd += n;
3465 if (frame->bytes_recvd <= max_raw)
3466 memcpy(frame->rawdata + frame->bytes_recvd - n, in, n);
3467 else
3468 PDEBUG(3, "Raw data buffer overrun!! (%d)",
3469 frame->bytes_recvd - max_raw);
3470 } else {
3471 /* All incoming data are divided into 8-byte segments. If the
3472 * segment contains all zero bytes, it must be skipped. These
3473 * zero-segments allow the OV518 to mainain a constant data rate
3474 * regardless of the effectiveness of the compression. Segments
3475 * are aligned relative to the beginning of each isochronous
3476 * packet. The first segment in each image is a header (the
3477 * decompressor skips it later).
3478 */
3479
3480 int b, read = 0, allzero, copied = 0;
3481
3482 while (read < n) {
3483 allzero = 1;
3484 for (b = 0; b < 8; b++) {
3485 if (in[read + b]) {
3486 allzero = 0;
3487 break;
3488 }
3489 }
3490
3491 if (allzero) {
3492 /* Don't copy it */
3493 } else {
3494 if (frame->bytes_recvd + copied + 8 <= max_raw)
3495 {
3496 memcpy(frame->rawdata
3497 + frame->bytes_recvd + copied,
3498 in + read, 8);
3499 copied += 8;
3500 } else {
3501 PDEBUG(3, "Raw data buffer overrun!!");
3502 }
3503 }
3504 read += 8;
3505 }
3506 frame->bytes_recvd += copied;
3507 }
3508 }
3509
3510 static void
3511 ov51x_isoc_irq(struct urb *urb)
3512 {
3513 int i;
3514 struct usb_ov511 *ov;
3515 struct ov511_sbuf *sbuf;
3516
3517 if (!urb->context) {
3518 PDEBUG(4, "no context");
3519 return;
3520 }
3521
3522 sbuf = urb->context;
3523 ov = sbuf->ov;
3524
3525 if (!ov || !ov->dev || !ov->user) {
3526 PDEBUG(4, "no device, or not open");
3527 return;
3528 }
3529
3530 if (!ov->streaming) {
3531 PDEBUG(4, "hmmm... not streaming, but got interrupt");
3532 return;
3533 }
3534
3535 if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
3536 PDEBUG(4, "URB unlinked");
3537 return;
3538 }
3539
3540 if (urb->status != -EINPROGRESS && urb->status != 0) {
3541 err("ERROR: urb->status=%d: %s", urb->status,
3542 symbolic(urb_errlist, urb->status));
3543 }
3544
3545 /* Copy the data received into our frame buffer */
3546 PDEBUG(5, "sbuf[%d]: Moving %d packets", sbuf->n,
3547 urb->number_of_packets);
3548 for (i = 0; i < urb->number_of_packets; i++) {
3549 /* Warning: Don't call *_move_data() if no frame active! */
3550 if (ov->curframe >= 0) {
3551 int n = urb->iso_frame_desc[i].actual_length;
3552 int st = urb->iso_frame_desc[i].status;
3553 unsigned char *cdata;
3554
3555 urb->iso_frame_desc[i].actual_length = 0;
3556 urb->iso_frame_desc[i].status = 0;
3557
3558 cdata = urb->transfer_buffer
3559 + urb->iso_frame_desc[i].offset;
3560
3561 if (!n) {
3562 PDEBUG(4, "Zero-length packet");
3563 continue;
3564 }
3565
3566 if (st)
3567 PDEBUG(2, "data error: [%d] len=%d, status=%d",
3568 i, n, st);
3569
3570 if (ov->bclass == BCL_OV511)
3571 ov511_move_data(ov, cdata, n);
3572 else if (ov->bclass == BCL_OV518)
3573 ov518_move_data(ov, cdata, n);
3574 else
3575 err("Unknown bridge device (%d)", ov->bridge);
3576
3577 } else if (waitqueue_active(&ov->wq)) {
3578 wake_up_interruptible(&ov->wq);
3579 }
3580 }
3581
3582 /* Resubmit this URB */
3583 urb->dev = ov->dev;
3584 if ((i = usb_submit_urb(urb, GFP_ATOMIC)) != 0)
3585 err("usb_submit_urb() ret %d", i);
3586
3587 return;
3588 }
3589
3590 /****************************************************************************
3591 *
3592 * Stream initialization and termination
3593 *
3594 ***************************************************************************/
3595
3596 static int
3597 ov51x_init_isoc(struct usb_ov511 *ov)
3598 {
3599 struct urb *urb;
3600 int fx, err, n, i, size;
3601
3602 PDEBUG(3, "*** Initializing capture ***");
3603
3604 ov->curframe = -1;
3605
3606 if (ov->bridge == BRG_OV511) {
3607 if (cams == 1)
3608 size = 993;
3609 else if (cams == 2)
3610 size = 513;
3611 else if (cams == 3 || cams == 4)
3612 size = 257;
3613 else {
3614 err("\"cams\" parameter too high!");
3615 return -1;
3616 }
3617 } else if (ov->bridge == BRG_OV511PLUS) {
3618 if (cams == 1)
3619 size = 961;
3620 else if (cams == 2)
3621 size = 513;
3622 else if (cams == 3 || cams == 4)
3623 size = 257;
3624 else if (cams >= 5 && cams <= 8)
3625 size = 129;
3626 else if (cams >= 9 && cams <= 31)
3627 size = 33;
3628 else {
3629 err("\"cams\" parameter too high!");
3630 return -1;
3631 }
3632 } else if (ov->bclass == BCL_OV518) {
3633 if (cams == 1)
3634 size = 896;
3635 else if (cams == 2)
3636 size = 512;
3637 else if (cams == 3 || cams == 4)
3638 size = 256;
3639 else if (cams >= 5 && cams <= 8)
3640 size = 128;
3641 else {
3642 err("\"cams\" parameter too high!");
3643 return -1;
3644 }
3645 } else {
3646 err("invalid bridge type");
3647 return -1;
3648 }
3649
3650 // FIXME: OV518 is hardcoded to 15 FPS (alternate 5) for now
3651 if (ov->bclass == BCL_OV518) {
3652 if (packetsize == -1) {
3653 ov518_set_packet_size(ov, 640);
3654 } else {
3655 dev_info(&ov->dev->dev, "Forcing packet size to %d\n",
3656 packetsize);
3657 ov518_set_packet_size(ov, packetsize);
3658 }
3659 } else {
3660 if (packetsize == -1) {
3661 ov511_set_packet_size(ov, size);
3662 } else {
3663 dev_info(&ov->dev->dev, "Forcing packet size to %d\n",
3664 packetsize);
3665 ov511_set_packet_size(ov, packetsize);
3666 }
3667 }
3668
3669 for (n = 0; n < OV511_NUMSBUF; n++) {
3670 urb = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);
3671 if (!urb) {
3672 err("init isoc: usb_alloc_urb ret. NULL");
3673 for (i = 0; i < n; i++)
3674 usb_free_urb(ov->sbuf[i].urb);
3675 return -ENOMEM;
3676 }
3677 ov->sbuf[n].urb = urb;
3678 urb->dev = ov->dev;
3679 urb->context = &ov->sbuf[n];
3680 urb->pipe = usb_rcvisocpipe(ov->dev, OV511_ENDPOINT_ADDRESS);
3681 urb->transfer_flags = URB_ISO_ASAP;
3682 urb->transfer_buffer = ov->sbuf[n].data;
3683 urb->complete = ov51x_isoc_irq;
3684 urb->number_of_packets = FRAMES_PER_DESC;
3685 urb->transfer_buffer_length = ov->packet_size * FRAMES_PER_DESC;
3686 urb->interval = 1;
3687 for (fx = 0; fx < FRAMES_PER_DESC; fx++) {
3688 urb->iso_frame_desc[fx].offset = ov->packet_size * fx;
3689 urb->iso_frame_desc[fx].length = ov->packet_size;
3690 }
3691 }
3692
3693 ov->streaming = 1;
3694
3695 for (n = 0; n < OV511_NUMSBUF; n++) {
3696 ov->sbuf[n].urb->dev = ov->dev;
3697 err = usb_submit_urb(ov->sbuf[n].urb, GFP_KERNEL);
3698 if (err) {
3699 err("init isoc: usb_submit_urb(%d) ret %d", n, err);
3700 return err;
3701 }
3702 }
3703
3704 return 0;
3705 }
3706
3707 static void
3708 ov51x_unlink_isoc(struct usb_ov511 *ov)
3709 {
3710 int n;
3711
3712 /* Unschedule all of the iso td's */
3713 for (n = OV511_NUMSBUF - 1; n >= 0; n--) {
3714 if (ov->sbuf[n].urb) {
3715 usb_kill_urb(ov->sbuf[n].urb);
3716 usb_free_urb(ov->sbuf[n].urb);
3717 ov->sbuf[n].urb = NULL;
3718 }
3719 }
3720 }
3721
3722 static void
3723 ov51x_stop_isoc(struct usb_ov511 *ov)
3724 {
3725 if (!ov->streaming || !ov->dev)
3726 return;
3727
3728 PDEBUG(3, "*** Stopping capture ***");
3729
3730 if (ov->bclass == BCL_OV518)
3731 ov518_set_packet_size(ov, 0);
3732 else
3733 ov511_set_packet_size(ov, 0);
3734
3735 ov->streaming = 0;
3736
3737 ov51x_unlink_isoc(ov);
3738 }
3739
3740 static int
3741 ov51x_new_frame(struct usb_ov511 *ov, int framenum)
3742 {
3743 struct ov511_frame *frame;
3744 int newnum;
3745
3746 PDEBUG(4, "ov->curframe = %d, framenum = %d", ov->curframe, framenum);
3747
3748 if (!ov->dev)
3749 return -1;
3750
3751 /* If we're not grabbing a frame right now and the other frame is */
3752 /* ready to be grabbed into, then use it instead */
3753 if (ov->curframe == -1) {
3754 newnum = (framenum - 1 + OV511_NUMFRAMES) % OV511_NUMFRAMES;
3755 if (ov->frame[newnum].grabstate == FRAME_READY)
3756 framenum = newnum;
3757 } else
3758 return 0;
3759
3760 frame = &ov->frame[framenum];
3761
3762 PDEBUG(4, "framenum = %d, width = %d, height = %d", framenum,
3763 frame->width, frame->height);
3764
3765 frame->grabstate = FRAME_GRABBING;
3766 frame->scanstate = STATE_SCANNING;
3767 frame->snapshot = 0;
3768
3769 ov->curframe = framenum;
3770
3771 /* Make sure it's not too big */
3772 if (frame->width > ov->maxwidth)
3773 frame->width = ov->maxwidth;
3774
3775 frame->width &= ~7L; /* Multiple of 8 */
3776
3777 if (frame->height > ov->maxheight)
3778 frame->height = ov->maxheight;
3779
3780 frame->height &= ~3L; /* Multiple of 4 */
3781
3782 return 0;
3783 }
3784
3785 /****************************************************************************
3786 *
3787 * Buffer management
3788 *
3789 ***************************************************************************/
3790
3791 /*
3792 * - You must acquire buf_lock before entering this function.
3793 * - Because this code will free any non-null pointer, you must be sure to null
3794 * them if you explicitly free them somewhere else!
3795 */
3796 static void
3797 ov51x_do_dealloc(struct usb_ov511 *ov)
3798 {
3799 int i;
3800 PDEBUG(4, "entered");
3801
3802 if (ov->fbuf) {
3803 rvfree(ov->fbuf, OV511_NUMFRAMES
3804 * MAX_DATA_SIZE(ov->maxwidth, ov->maxheight));
3805 ov->fbuf = NULL;
3806 }
3807
3808 vfree(ov->rawfbuf);
3809 ov->rawfbuf = NULL;
3810
3811 vfree(ov->tempfbuf);
3812 ov->tempfbuf = NULL;
3813
3814 for (i = 0; i < OV511_NUMSBUF; i++) {
3815 kfree(ov->sbuf[i].data);
3816 ov->sbuf[i].data = NULL;
3817 }
3818
3819 for (i = 0; i < OV511_NUMFRAMES; i++) {
3820 ov->frame[i].data = NULL;
3821 ov->frame[i].rawdata = NULL;
3822 ov->frame[i].tempdata = NULL;
3823 if (ov->frame[i].compbuf) {
3824 free_page((unsigned long) ov->frame[i].compbuf);
3825 ov->frame[i].compbuf = NULL;
3826 }
3827 }
3828
3829 PDEBUG(4, "buffer memory deallocated");
3830 ov->buf_state = BUF_NOT_ALLOCATED;
3831 PDEBUG(4, "leaving");
3832 }
3833
3834 static int
3835 ov51x_alloc(struct usb_ov511 *ov)
3836 {
3837 int i;
3838 const int w = ov->maxwidth;
3839 const int h = ov->maxheight;
3840 const int data_bufsize = OV511_NUMFRAMES * MAX_DATA_SIZE(w, h);
3841 const int raw_bufsize = OV511_NUMFRAMES * MAX_RAW_DATA_SIZE(w, h);
3842
3843 PDEBUG(4, "entered");
3844 mutex_lock(&ov->buf_lock);
3845
3846 if (ov->buf_state == BUF_ALLOCATED)
3847 goto out;
3848
3849 ov->fbuf = rvmalloc(data_bufsize);
3850 if (!ov->fbuf)
3851 goto error;
3852
3853 ov->rawfbuf = vmalloc(raw_bufsize);
3854 if (!ov->rawfbuf)
3855 goto error;
3856
3857 memset(ov->rawfbuf, 0, raw_bufsize);
3858
3859 ov->tempfbuf = vmalloc(raw_bufsize);
3860 if (!ov->tempfbuf)
3861 goto error;
3862
3863 memset(ov->tempfbuf, 0, raw_bufsize);
3864
3865 for (i = 0; i < OV511_NUMSBUF; i++) {
3866 ov->sbuf[i].data = kmalloc(FRAMES_PER_DESC *
3867 MAX_FRAME_SIZE_PER_DESC, GFP_KERNEL);
3868 if (!ov->sbuf[i].data)
3869 goto error;
3870
3871 PDEBUG(4, "sbuf[%d] @ %p", i, ov->sbuf[i].data);
3872 }
3873
3874 for (i = 0; i < OV511_NUMFRAMES; i++) {
3875 ov->frame[i].data = ov->fbuf + i * MAX_DATA_SIZE(w, h);
3876 ov->frame[i].rawdata = ov->rawfbuf
3877 + i * MAX_RAW_DATA_SIZE(w, h);
3878 ov->frame[i].tempdata = ov->tempfbuf
3879 + i * MAX_RAW_DATA_SIZE(w, h);
3880
3881 ov->frame[i].compbuf =
3882 (unsigned char *) __get_free_page(GFP_KERNEL);
3883 if (!ov->frame[i].compbuf)
3884 goto error;
3885
3886 PDEBUG(4, "frame[%d] @ %p", i, ov->frame[i].data);
3887 }
3888
3889 ov->buf_state = BUF_ALLOCATED;
3890 out:
3891 mutex_unlock(&ov->buf_lock);
3892 PDEBUG(4, "leaving");
3893 return 0;
3894 error:
3895 ov51x_do_dealloc(ov);
3896 mutex_unlock(&ov->buf_lock);
3897 PDEBUG(4, "errored");
3898 return -ENOMEM;
3899 }
3900
3901 static void
3902 ov51x_dealloc(struct usb_ov511 *ov)
3903 {
3904 PDEBUG(4, "entered");
3905 mutex_lock(&ov->buf_lock);
3906 ov51x_do_dealloc(ov);
3907 mutex_unlock(&ov->buf_lock);
3908 PDEBUG(4, "leaving");
3909 }
3910
3911 /****************************************************************************
3912 *
3913 * V4L 1 API
3914 *
3915 ***************************************************************************/
3916
3917 static int
3918 ov51x_v4l1_open(struct file *file)
3919 {
3920 struct video_device *vdev = video_devdata(file);
3921 struct usb_ov511 *ov = video_get_drvdata(vdev);
3922 int err, i;
3923
3924 PDEBUG(4, "opening");
3925
3926 mutex_lock(&ov->lock);
3927
3928 err = -EBUSY;
3929 if (ov->user)
3930 goto out;
3931
3932 ov->sub_flag = 0;
3933
3934 /* In case app doesn't set them... */
3935 err = ov51x_set_default_params(ov);
3936 if (err < 0)
3937 goto out;
3938
3939 /* Make sure frames are reset */
3940 for (i = 0; i < OV511_NUMFRAMES; i++) {
3941 ov->frame[i].grabstate = FRAME_UNUSED;
3942 ov->frame[i].bytes_read = 0;
3943 }
3944
3945 /* If compression is on, make sure now that a
3946 * decompressor can be loaded */
3947 if (ov->compress && !ov->decomp_ops) {
3948 err = request_decompressor(ov);
3949 if (err && !dumppix)
3950 goto out;
3951 }
3952
3953 err = ov51x_alloc(ov);
3954 if (err < 0)
3955 goto out;
3956
3957 err = ov51x_init_isoc(ov);
3958 if (err) {
3959 ov51x_dealloc(ov);
3960 goto out;
3961 }
3962
3963 ov->user++;
3964 file->private_data = vdev;
3965
3966 if (ov->led_policy == LED_AUTO)
3967 ov51x_led_control(ov, 1);
3968
3969 out:
3970 mutex_unlock(&ov->lock);
3971 return err;
3972 }
3973
3974 static int
3975 ov51x_v4l1_close(struct file *file)
3976 {
3977 struct video_device *vdev = file->private_data;
3978 struct usb_ov511 *ov = video_get_drvdata(vdev);
3979
3980 PDEBUG(4, "ov511_close");
3981
3982 mutex_lock(&ov->lock);
3983
3984 ov->user--;
3985 ov51x_stop_isoc(ov);
3986
3987 if (ov->led_policy == LED_AUTO)
3988 ov51x_led_control(ov, 0);
3989
3990 if (ov->dev)
3991 ov51x_dealloc(ov);
3992
3993 mutex_unlock(&ov->lock);
3994
3995 /* Device unplugged while open. Only a minimum of unregistration is done
3996 * here; the disconnect callback already did the rest. */
3997 if (!ov->dev) {
3998 mutex_lock(&ov->cbuf_lock);
3999 kfree(ov->cbuf);
4000 ov->cbuf = NULL;
4001 mutex_unlock(&ov->cbuf_lock);
4002
4003 ov51x_dealloc(ov);
4004 kfree(ov);
4005 ov = NULL;
4006 }
4007
4008 file->private_data = NULL;
4009 return 0;
4010 }
4011
4012 /* Do not call this function directly! */
4013 static long
4014 ov51x_v4l1_ioctl_internal(struct file *file, unsigned int cmd, void *arg)
4015 {
4016 struct video_device *vdev = file->private_data;
4017 struct usb_ov511 *ov = video_get_drvdata(vdev);
4018 PDEBUG(5, "IOCtl: 0x%X", cmd);
4019
4020 if (!ov->dev)
4021 return -EIO;
4022
4023 switch (cmd) {
4024 case VIDIOCGCAP:
4025 {
4026 struct video_capability *b = arg;
4027
4028 PDEBUG(4, "VIDIOCGCAP");
4029
4030 memset(b, 0, sizeof(struct video_capability));
4031 sprintf(b->name, "%s USB Camera",
4032 symbolic(brglist, ov->bridge));
4033 b->type = VID_TYPE_CAPTURE | VID_TYPE_SUBCAPTURE;
4034 b->channels = ov->num_inputs;
4035 b->audios = 0;
4036 b->maxwidth = ov->maxwidth;
4037 b->maxheight = ov->maxheight;
4038 b->minwidth = ov->minwidth;
4039 b->minheight = ov->minheight;
4040
4041 return 0;
4042 }
4043 case VIDIOCGCHAN:
4044 {
4045 struct video_channel *v = arg;
4046
4047 PDEBUG(4, "VIDIOCGCHAN");
4048
4049 if ((unsigned)(v->channel) >= ov->num_inputs) {
4050 err("Invalid channel (%d)", v->channel);
4051 return -EINVAL;
4052 }
4053
4054 v->norm = ov->norm;
4055 v->type = VIDEO_TYPE_CAMERA;
4056 v->flags = 0;
4057 // v->flags |= (ov->has_decoder) ? VIDEO_VC_NORM : 0;
4058 v->tuners = 0;
4059 decoder_get_input_name(ov, v->channel, v->name);
4060
4061 return 0;
4062 }
4063 case VIDIOCSCHAN:
4064 {
4065 struct video_channel *v = arg;
4066 int err;
4067
4068 PDEBUG(4, "VIDIOCSCHAN");
4069
4070 /* Make sure it's not a camera */
4071 if (!ov->has_decoder) {
4072 if (v->channel == 0)
4073 return 0;
4074 else
4075 return -EINVAL;
4076 }
4077
4078 if (v->norm != VIDEO_MODE_PAL &&
4079 v->norm != VIDEO_MODE_NTSC &&
4080 v->norm != VIDEO_MODE_SECAM &&
4081 v->norm != VIDEO_MODE_AUTO) {
4082 err("Invalid norm (%d)", v->norm);
4083 return -EINVAL;
4084 }
4085
4086 if ((unsigned)(v->channel) >= ov->num_inputs) {
4087 err("Invalid channel (%d)", v->channel);
4088 return -EINVAL;
4089 }
4090
4091 err = decoder_set_input(ov, v->channel);
4092 if (err)
4093 return err;
4094
4095 err = decoder_set_norm(ov, v->norm);
4096 if (err)
4097 return err;
4098
4099 return 0;
4100 }
4101 case VIDIOCGPICT:
4102 {
4103 struct video_picture *p = arg;
4104
4105 PDEBUG(4, "VIDIOCGPICT");
4106
4107 memset(p, 0, sizeof(struct video_picture));
4108 if (sensor_get_picture(ov, p))
4109 return -EIO;
4110
4111 /* Can we get these from frame[0]? -claudio? */
4112 p->depth = ov->frame[0].depth;
4113 p->palette = ov->frame[0].format;
4114
4115 return 0;
4116 }
4117 case VIDIOCSPICT:
4118 {
4119 struct video_picture *p = arg;
4120 int i, rc;
4121
4122 PDEBUG(4, "VIDIOCSPICT");
4123
4124 if (!get_depth(p->palette))
4125 return -EINVAL;
4126
4127 if (sensor_set_picture(ov, p))
4128 return -EIO;
4129
4130 if (force_palette && p->palette != force_palette) {
4131 dev_info(&ov->dev->dev, "Palette rejected (%s)\n",
4132 symbolic(v4l1_plist, p->palette));
4133 return -EINVAL;
4134 }
4135
4136 // FIXME: Format should be independent of frames
4137 if (p->palette != ov->frame[0].format) {
4138 PDEBUG(4, "Detected format change");
4139
4140 rc = ov51x_wait_frames_inactive(ov);
4141 if (rc)
4142 return rc;
4143
4144 mode_init_regs(ov, ov->frame[0].width,
4145 ov->frame[0].height, p->palette, ov->sub_flag);
4146 }
4147
4148 PDEBUG(4, "Setting depth=%d, palette=%s",
4149 p->depth, symbolic(v4l1_plist, p->palette));
4150
4151 for (i = 0; i < OV511_NUMFRAMES; i++) {
4152 ov->frame[i].depth = p->depth;
4153 ov->frame[i].format = p->palette;
4154 }
4155
4156 return 0;
4157 }
4158 case VIDIOCGCAPTURE:
4159 {
4160 int *vf = arg;
4161
4162 PDEBUG(4, "VIDIOCGCAPTURE");
4163
4164 ov->sub_flag = *vf;
4165 return 0;
4166 }
4167 case VIDIOCSCAPTURE:
4168 {
4169 struct video_capture *vc = arg;
4170
4171 PDEBUG(4, "VIDIOCSCAPTURE");
4172
4173 if (vc->flags)
4174 return -EINVAL;
4175 if (vc->decimation)
4176 return -EINVAL;
4177
4178 vc->x &= ~3L;
4179 vc->y &= ~1L;
4180 vc->y &= ~31L;
4181
4182 if (vc->width == 0)
4183 vc->width = 32;
4184
4185 vc->height /= 16;
4186 vc->height *= 16;
4187 if (vc->height == 0)
4188 vc->height = 16;
4189
4190 ov->subx = vc->x;
4191 ov->suby = vc->y;
4192 ov->subw = vc->width;
4193 ov->subh = vc->height;
4194
4195 return 0;
4196 }
4197 case VIDIOCSWIN:
4198 {
4199 struct video_window *vw = arg;
4200 int i, rc;
4201
4202 PDEBUG(4, "VIDIOCSWIN: %dx%d", vw->width, vw->height);
4203
4204 #if 0
4205 if (vw->flags)
4206 return -EINVAL;
4207 if (vw->clipcount)
4208 return -EINVAL;
4209 if (vw->height != ov->maxheight)
4210 return -EINVAL;
4211 if (vw->width != ov->maxwidth)
4212 return -EINVAL;
4213 #endif
4214
4215 rc = ov51x_wait_frames_inactive(ov);
4216 if (rc)
4217 return rc;
4218
4219 rc = mode_init_regs(ov, vw->width, vw->height,
4220 ov->frame[0].format, ov->sub_flag);
4221 if (rc < 0)
4222 return rc;
4223
4224 for (i = 0; i < OV511_NUMFRAMES; i++) {
4225 ov->frame[i].width = vw->width;
4226 ov->frame[i].height = vw->height;
4227 }
4228
4229 return 0;
4230 }
4231 case VIDIOCGWIN:
4232 {
4233 struct video_window *vw = arg;
4234
4235 memset(vw, 0, sizeof(struct video_window));
4236 vw->x = 0; /* FIXME */
4237 vw->y = 0;
4238 vw->width = ov->frame[0].width;
4239 vw->height = ov->frame[0].height;
4240 vw->flags = 30;
4241
4242 PDEBUG(4, "VIDIOCGWIN: %dx%d", vw->width, vw->height);
4243
4244 return 0;
4245 }
4246 case VIDIOCGMBUF:
4247 {
4248 struct video_mbuf *vm = arg;
4249 int i;
4250
4251 PDEBUG(4, "VIDIOCGMBUF");
4252
4253 memset(vm, 0, sizeof(struct video_mbuf));
4254 vm->size = OV511_NUMFRAMES
4255 * MAX_DATA_SIZE(ov->maxwidth, ov->maxheight);
4256 vm->frames = OV511_NUMFRAMES;
4257
4258 vm->offsets[0] = 0;
4259 for (i = 1; i < OV511_NUMFRAMES; i++) {
4260 vm->offsets[i] = vm->offsets[i-1]
4261 + MAX_DATA_SIZE(ov->maxwidth, ov->maxheight);
4262 }
4263
4264 return 0;
4265 }
4266 case VIDIOCMCAPTURE:
4267 {
4268 struct video_mmap *vm = arg;
4269 int rc, depth;
4270 unsigned int f = vm->frame;
4271
4272 PDEBUG(4, "VIDIOCMCAPTURE: frame: %d, %dx%d, %s", f, vm->width,
4273 vm->height, symbolic(v4l1_plist, vm->format));
4274
4275 depth = get_depth(vm->format);
4276 if (!depth) {
4277 PDEBUG(2, "VIDIOCMCAPTURE: invalid format (%s)",
4278 symbolic(v4l1_plist, vm->format));
4279 return -EINVAL;
4280 }
4281
4282 if (f >= OV511_NUMFRAMES) {
4283 err("VIDIOCMCAPTURE: invalid frame (%d)", f);
4284 return -EINVAL;
4285 }
4286
4287 if (vm->width > ov->maxwidth
4288 || vm->height > ov->maxheight) {
4289 err("VIDIOCMCAPTURE: requested dimensions too big");
4290 return -EINVAL;
4291 }
4292
4293 if (ov->frame[f].grabstate == FRAME_GRABBING) {
4294 PDEBUG(4, "VIDIOCMCAPTURE: already grabbing");
4295 return -EBUSY;
4296 }
4297
4298 if (force_palette && (vm->format != force_palette)) {
4299 PDEBUG(2, "palette rejected (%s)",
4300 symbolic(v4l1_plist, vm->format));
4301 return -EINVAL;
4302 }
4303
4304 if ((ov->frame[f].width != vm->width) ||
4305 (ov->frame[f].height != vm->height) ||
4306 (ov->frame[f].format != vm->format) ||
4307 (ov->frame[f].sub_flag != ov->sub_flag) ||
4308 (ov->frame[f].depth != depth)) {
4309 PDEBUG(4, "VIDIOCMCAPTURE: change in image parameters");
4310
4311 rc = ov51x_wait_frames_inactive(ov);
4312 if (rc)
4313 return rc;
4314
4315 rc = mode_init_regs(ov, vm->width, vm->height,
4316 vm->format, ov->sub_flag);
4317 #if 0
4318 if (rc < 0) {
4319 PDEBUG(1, "Got error while initializing regs ");
4320 return ret;
4321 }
4322 #endif
4323 ov->frame[f].width = vm->width;
4324 ov->frame[f].height = vm->height;
4325 ov->frame[f].format = vm->format;
4326 ov->frame[f].sub_flag = ov->sub_flag;
4327 ov->frame[f].depth = depth;
4328 }
4329
4330 /* Mark it as ready */
4331 ov->frame[f].grabstate = FRAME_READY;
4332
4333 PDEBUG(4, "VIDIOCMCAPTURE: renewing frame %d", f);
4334
4335 return ov51x_new_frame(ov, f);
4336 }
4337 case VIDIOCSYNC:
4338 {
4339 unsigned int fnum = *((unsigned int *) arg);
4340 struct ov511_frame *frame;
4341 int rc;
4342
4343 if (fnum >= OV511_NUMFRAMES) {
4344 err("VIDIOCSYNC: invalid frame (%d)", fnum);
4345 return -EINVAL;
4346 }
4347
4348 frame = &ov->frame[fnum];
4349
4350 PDEBUG(4, "syncing to frame %d, grabstate = %d", fnum,
4351 frame->grabstate);
4352
4353 switch (frame->grabstate) {
4354 case FRAME_UNUSED:
4355 return -EINVAL;
4356 case FRAME_READY:
4357 case FRAME_GRABBING:
4358 case FRAME_ERROR:
4359 redo:
4360 if (!ov->dev)
4361 return -EIO;
4362
4363 rc = wait_event_interruptible(frame->wq,
4364 (frame->grabstate == FRAME_DONE)
4365 || (frame->grabstate == FRAME_ERROR));
4366
4367 if (rc)
4368 return rc;
4369
4370 if (frame->grabstate == FRAME_ERROR) {
4371 if ((rc = ov51x_new_frame(ov, fnum)) < 0)
4372 return rc;
4373 goto redo;
4374 }
4375 /* Fall through */
4376 case FRAME_DONE:
4377 if (ov->snap_enabled && !frame->snapshot) {
4378 if ((rc = ov51x_new_frame(ov, fnum)) < 0)
4379 return rc;
4380 goto redo;
4381 }
4382
4383 frame->grabstate = FRAME_UNUSED;
4384
4385 /* Reset the hardware snapshot button */
4386 /* FIXME - Is this the best place for this? */
4387 if ((ov->snap_enabled) && (frame->snapshot)) {
4388 frame->snapshot = 0;
4389 ov51x_clear_snapshot(ov);
4390 }
4391
4392 /* Decompression, format conversion, etc... */
4393 ov51x_postprocess(ov, frame);
4394
4395 break;
4396 } /* end switch */
4397
4398 return 0;
4399 }
4400 case VIDIOCGFBUF:
4401 {
4402 struct video_buffer *vb = arg;
4403
4404 PDEBUG(4, "VIDIOCGFBUF");
4405
4406 memset(vb, 0, sizeof(struct video_buffer));
4407
4408 return 0;
4409 }
4410 case VIDIOCGUNIT:
4411 {
4412 struct video_unit *vu = arg;
4413
4414 PDEBUG(4, "VIDIOCGUNIT");
4415
4416 memset(vu, 0, sizeof(struct video_unit));
4417
4418 vu->video = ov->vdev->minor;
4419 vu->vbi = VIDEO_NO_UNIT;
4420 vu->radio = VIDEO_NO_UNIT;
4421 vu->audio = VIDEO_NO_UNIT;
4422 vu->teletext = VIDEO_NO_UNIT;
4423
4424 return 0;
4425 }
4426 case OV511IOC_WI2C:
4427 {
4428 struct ov511_i2c_struct *w = arg;
4429
4430 return i2c_w_slave(ov, w->slave, w->reg, w->value, w->mask);
4431 }
4432 case OV511IOC_RI2C:
4433 {
4434 struct ov511_i2c_struct *r = arg;
4435 int rc;
4436
4437 rc = i2c_r_slave(ov, r->slave, r->reg);
4438 if (rc < 0)
4439 return rc;
4440
4441 r->value = rc;
4442 return 0;
4443 }
4444 default:
4445 PDEBUG(3, "Unsupported IOCtl: 0x%X", cmd);
4446 return -ENOIOCTLCMD;
4447 } /* end switch */
4448
4449 return 0;
4450 }
4451
4452 static long
4453 ov51x_v4l1_ioctl(struct file *file,
4454 unsigned int cmd, unsigned long arg)
4455 {
4456 struct video_device *vdev = file->private_data;
4457 struct usb_ov511 *ov = video_get_drvdata(vdev);
4458 int rc;
4459
4460 if (mutex_lock_interruptible(&ov->lock))
4461 return -EINTR;
4462
4463 rc = video_usercopy(file, cmd, arg, ov51x_v4l1_ioctl_internal);
4464
4465 mutex_unlock(&ov->lock);
4466 return rc;
4467 }
4468
4469 static ssize_t
4470 ov51x_v4l1_read(struct file *file, char __user *buf, size_t cnt, loff_t *ppos)
4471 {
4472 struct video_device *vdev = file->private_data;
4473 int noblock = file->f_flags&O_NONBLOCK;
4474 unsigned long count = cnt;
4475 struct usb_ov511 *ov = video_get_drvdata(vdev);
4476 int i, rc = 0, frmx = -1;
4477 struct ov511_frame *frame;
4478
4479 if (mutex_lock_interruptible(&ov->lock))
4480 return -EINTR;
4481
4482 PDEBUG(4, "%ld bytes, noblock=%d", count, noblock);
4483
4484 if (!vdev || !buf) {
4485 rc = -EFAULT;
4486 goto error;
4487 }
4488
4489 if (!ov->dev) {
4490 rc = -EIO;
4491 goto error;
4492 }
4493
4494 // FIXME: Only supports two frames
4495 /* See if a frame is completed, then use it. */
4496 if (ov->frame[0].grabstate >= FRAME_DONE) /* _DONE or _ERROR */
4497 frmx = 0;
4498 else if (ov->frame[1].grabstate >= FRAME_DONE)/* _DONE or _ERROR */
4499 frmx = 1;
4500
4501 /* If nonblocking we return immediately */
4502 if (noblock && (frmx == -1)) {
4503 rc = -EAGAIN;
4504 goto error;
4505 }
4506
4507 /* If no FRAME_DONE, look for a FRAME_GRABBING state. */
4508 /* See if a frame is in process (grabbing), then use it. */
4509 if (frmx == -1) {
4510 if (ov->frame[0].grabstate == FRAME_GRABBING)
4511 frmx = 0;
4512 else if (ov->frame[1].grabstate == FRAME_GRABBING)
4513 frmx = 1;
4514 }
4515
4516 /* If no frame is active, start one. */
4517 if (frmx == -1) {
4518 if ((rc = ov51x_new_frame(ov, frmx = 0))) {
4519 err("read: ov51x_new_frame error");
4520 goto error;
4521 }
4522 }
4523
4524 frame = &ov->frame[frmx];
4525
4526 restart:
4527 if (!ov->dev) {
4528 rc = -EIO;
4529 goto error;
4530 }
4531
4532 /* Wait while we're grabbing the image */
4533 PDEBUG(4, "Waiting image grabbing");
4534 rc = wait_event_interruptible(frame->wq,
4535 (frame->grabstate == FRAME_DONE)
4536 || (frame->grabstate == FRAME_ERROR));
4537
4538 if (rc)
4539 goto error;
4540
4541 PDEBUG(4, "Got image, frame->grabstate = %d", frame->grabstate);
4542 PDEBUG(4, "bytes_recvd = %d", frame->bytes_recvd);
4543
4544 if (frame->grabstate == FRAME_ERROR) {
4545 frame->bytes_read = 0;
4546 err("** ick! ** Errored frame %d", ov->curframe);
4547 if (ov51x_new_frame(ov, frmx)) {
4548 err("read: ov51x_new_frame error");
4549 goto error;
4550 }
4551 goto restart;
4552 }
4553
4554
4555 /* Repeat until we get a snapshot frame */
4556 if (ov->snap_enabled)
4557 PDEBUG(4, "Waiting snapshot frame");
4558 if (ov->snap_enabled && !frame->snapshot) {
4559 frame->bytes_read = 0;
4560 if ((rc = ov51x_new_frame(ov, frmx))) {
4561 err("read: ov51x_new_frame error");
4562 goto error;
4563 }
4564 goto restart;
4565 }
4566
4567 /* Clear the snapshot */
4568 if (ov->snap_enabled && frame->snapshot) {
4569 frame->snapshot = 0;
4570 ov51x_clear_snapshot(ov);
4571 }
4572
4573 /* Decompression, format conversion, etc... */
4574 ov51x_postprocess(ov, frame);
4575
4576 PDEBUG(4, "frmx=%d, bytes_read=%ld, length=%ld", frmx,
4577 frame->bytes_read,
4578 get_frame_length(frame));
4579
4580 /* copy bytes to user space; we allow for partials reads */
4581 // if ((count + frame->bytes_read)
4582 // > get_frame_length((struct ov511_frame *)frame))
4583 // count = frame->scanlength - frame->bytes_read;
4584
4585 /* FIXME - count hardwired to be one frame... */
4586 count = get_frame_length(frame);
4587
4588 PDEBUG(4, "Copy to user space: %ld bytes", count);
4589 if ((i = copy_to_user(buf, frame->data + frame->bytes_read, count))) {
4590 PDEBUG(4, "Copy failed! %d bytes not copied", i);
4591 rc = -EFAULT;
4592 goto error;
4593 }
4594
4595 frame->bytes_read += count;
4596 PDEBUG(4, "{copy} count used=%ld, new bytes_read=%ld",
4597 count, frame->bytes_read);
4598
4599 /* If all data have been read... */
4600 if (frame->bytes_read
4601 >= get_frame_length(frame)) {
4602 frame->bytes_read = 0;
4603
4604 // FIXME: Only supports two frames
4605 /* Mark it as available to be used again. */
4606 ov->frame[frmx].grabstate = FRAME_UNUSED;
4607 if ((rc = ov51x_new_frame(ov, !frmx))) {
4608 err("ov51x_new_frame returned error");
4609 goto error;
4610 }
4611 }
4612
4613 PDEBUG(4, "read finished, returning %ld (sweet)", count);
4614
4615 mutex_unlock(&ov->lock);
4616 return count;
4617
4618 error:
4619 mutex_unlock(&ov->lock);
4620 return rc;
4621 }
4622
4623 static int
4624 ov51x_v4l1_mmap(struct file *file, struct vm_area_struct *vma)
4625 {
4626 struct video_device *vdev = file->private_data;
4627 unsigned long start = vma->vm_start;
4628 unsigned long size = vma->vm_end - vma->vm_start;
4629 struct usb_ov511 *ov = video_get_drvdata(vdev);
4630 unsigned long page, pos;
4631
4632 if (ov->dev == NULL)
4633 return -EIO;
4634
4635 PDEBUG(4, "mmap: %ld (%lX) bytes", size, size);
4636
4637 if (size > (((OV511_NUMFRAMES
4638 * MAX_DATA_SIZE(ov->maxwidth, ov->maxheight)
4639 + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))))
4640 return -EINVAL;
4641
4642 if (mutex_lock_interruptible(&ov->lock))
4643 return -EINTR;
4644
4645 pos = (unsigned long)ov->fbuf;
4646 while (size > 0) {
4647 page = vmalloc_to_pfn((void *)pos);
4648 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
4649 mutex_unlock(&ov->lock);
4650 return -EAGAIN;
4651 }
4652 start += PAGE_SIZE;
4653 pos += PAGE_SIZE;
4654 if (size > PAGE_SIZE)
4655 size -= PAGE_SIZE;
4656 else
4657 size = 0;
4658 }
4659
4660 mutex_unlock(&ov->lock);
4661 return 0;
4662 }
4663
4664 static const struct v4l2_file_operations ov511_fops = {
4665 .owner = THIS_MODULE,
4666 .open = ov51x_v4l1_open,
4667 .release = ov51x_v4l1_close,
4668 .read = ov51x_v4l1_read,
4669 .mmap = ov51x_v4l1_mmap,
4670 .ioctl = ov51x_v4l1_ioctl,
4671 };
4672
4673 static struct video_device vdev_template = {
4674 .name = "OV511 USB Camera",
4675 .fops = &ov511_fops,
4676 .release = video_device_release,
4677 };
4678
4679 /****************************************************************************
4680 *
4681 * OV511 and sensor configuration
4682 *
4683 ***************************************************************************/
4684
4685 /* This initializes the OV7610, OV7620, or OV76BE sensor. The OV76BE uses
4686 * the same register settings as the OV7610, since they are very similar.
4687 */
4688 static int
4689 ov7xx0_configure(struct usb_ov511 *ov)
4690 {
4691 int i, success;
4692 int rc;
4693
4694 /* Lawrence Glaister <lg@jfm.bc.ca> reports:
4695 *
4696 * Register 0x0f in the 7610 has the following effects:
4697 *
4698 * 0x85 (AEC method 1): Best overall, good contrast range
4699 * 0x45 (AEC method 2): Very overexposed
4700 * 0xa5 (spec sheet default): Ok, but the black level is
4701 * shifted resulting in loss of contrast
4702 * 0x05 (old driver setting): very overexposed, too much
4703 * contrast
4704 */
4705 static struct ov511_regvals aRegvalsNorm7610[] = {
4706 { OV511_I2C_BUS, 0x10, 0xff },
4707 { OV511_I2C_BUS, 0x16, 0x06 },
4708 { OV511_I2C_BUS, 0x28, 0x24 },
4709 { OV511_I2C_BUS, 0x2b, 0xac },
4710 { OV511_I2C_BUS, 0x12, 0x00 },
4711 { OV511_I2C_BUS, 0x38, 0x81 },
4712 { OV511_I2C_BUS, 0x28, 0x24 }, /* 0c */
4713 { OV511_I2C_BUS, 0x0f, 0x85 }, /* lg's setting */
4714 { OV511_I2C_BUS, 0x15, 0x01 },
4715 { OV511_I2C_BUS, 0x20, 0x1c },
4716 { OV511_I2C_BUS, 0x23, 0x2a },
4717 { OV511_I2C_BUS, 0x24, 0x10 },
4718 { OV511_I2C_BUS, 0x25, 0x8a },
4719 { OV511_I2C_BUS, 0x26, 0xa2 },
4720 { OV511_I2C_BUS, 0x27, 0xc2 },
4721 { OV511_I2C_BUS, 0x2a, 0x04 },
4722 { OV511_I2C_BUS, 0x2c, 0xfe },
4723 { OV511_I2C_BUS, 0x2d, 0x93 },
4724 { OV511_I2C_BUS, 0x30, 0x71 },
4725 { OV511_I2C_BUS, 0x31, 0x60 },
4726 { OV511_I2C_BUS, 0x32, 0x26 },
4727 { OV511_I2C_BUS, 0x33, 0x20 },
4728 { OV511_I2C_BUS, 0x34, 0x48 },
4729 { OV511_I2C_BUS, 0x12, 0x24 },
4730 { OV511_I2C_BUS, 0x11, 0x01 },
4731 { OV511_I2C_BUS, 0x0c, 0x24 },
4732 { OV511_I2C_BUS, 0x0d, 0x24 },
4733 { OV511_DONE_BUS, 0x0, 0x00 },
4734 };
4735
4736 static struct ov511_regvals aRegvalsNorm7620[] = {
4737 { OV511_I2C_BUS, 0x00, 0x00 },
4738 { OV511_I2C_BUS, 0x01, 0x80 },
4739 { OV511_I2C_BUS, 0x02, 0x80 },
4740 { OV511_I2C_BUS, 0x03, 0xc0 },
4741 { OV511_I2C_BUS, 0x06, 0x60 },
4742 { OV511_I2C_BUS, 0x07, 0x00 },
4743 { OV511_I2C_BUS, 0x0c, 0x24 },
4744 { OV511_I2C_BUS, 0x0c, 0x24 },
4745 { OV511_I2C_BUS, 0x0d, 0x24 },
4746 { OV511_I2C_BUS, 0x11, 0x01 },
4747 { OV511_I2C_BUS, 0x12, 0x24 },
4748 { OV511_I2C_BUS, 0x13, 0x01 },
4749 { OV511_I2C_BUS, 0x14, 0x84 },
4750 { OV511_I2C_BUS, 0x15, 0x01 },
4751 { OV511_I2C_BUS, 0x16, 0x03 },
4752 { OV511_I2C_BUS, 0x17, 0x2f },
4753 { OV511_I2C_BUS, 0x18, 0xcf },
4754 { OV511_I2C_BUS, 0x19, 0x06 },
4755 { OV511_I2C_BUS, 0x1a, 0xf5 },
4756 { OV511_I2C_BUS, 0x1b, 0x00 },
4757 { OV511_I2C_BUS, 0x20, 0x18 },
4758 { OV511_I2C_BUS, 0x21, 0x80 },
4759 { OV511_I2C_BUS, 0x22, 0x80 },
4760 { OV511_I2C_BUS, 0x23, 0x00 },
4761 { OV511_I2C_BUS, 0x26, 0xa2 },
4762 { OV511_I2C_BUS, 0x27, 0xea },
4763 { OV511_I2C_BUS, 0x28, 0x20 },
4764 { OV511_I2C_BUS, 0x29, 0x00 },
4765 { OV511_I2C_BUS, 0x2a, 0x10 },
4766 { OV511_I2C_BUS, 0x2b, 0x00 },
4767 { OV511_I2C_BUS, 0x2c, 0x88 },
4768 { OV511_I2C_BUS, 0x2d, 0x91 },
4769 { OV511_I2C_BUS, 0x2e, 0x80 },
4770 { OV511_I2C_BUS, 0x2f, 0x44 },
4771 { OV511_I2C_BUS, 0x60, 0x27 },
4772 { OV511_I2C_BUS, 0x61, 0x02 },
4773 { OV511_I2C_BUS, 0x62, 0x5f },
4774 { OV511_I2C_BUS, 0x63, 0xd5 },
4775 { OV511_I2C_BUS, 0x64, 0x57 },
4776 { OV511_I2C_BUS, 0x65, 0x83 },
4777 { OV511_I2C_BUS, 0x66, 0x55 },
4778 { OV511_I2C_BUS, 0x67, 0x92 },
4779 { OV511_I2C_BUS, 0x68, 0xcf },
4780 { OV511_I2C_BUS, 0x69, 0x76 },
4781 { OV511_I2C_BUS, 0x6a, 0x22 },
4782 { OV511_I2C_BUS, 0x6b, 0x00 },
4783 { OV511_I2C_BUS, 0x6c, 0x02 },
4784 { OV511_I2C_BUS, 0x6d, 0x44 },
4785 { OV511_I2C_BUS, 0x6e, 0x80 },
4786 { OV511_I2C_BUS, 0x6f, 0x1d },
4787 { OV511_I2C_BUS, 0x70, 0x8b },
4788 { OV511_I2C_BUS, 0x71, 0x00 },
4789 { OV511_I2C_BUS, 0x72, 0x14 },
4790 { OV511_I2C_BUS, 0x73, 0x54 },
4791 { OV511_I2C_BUS, 0x74, 0x00 },
4792 { OV511_I2C_BUS, 0x75, 0x8e },
4793 { OV511_I2C_BUS, 0x76, 0x00 },
4794 { OV511_I2C_BUS, 0x77, 0xff },
4795 { OV511_I2C_BUS, 0x78, 0x80 },
4796 { OV511_I2C_BUS, 0x79, 0x80 },
4797 { OV511_I2C_BUS, 0x7a, 0x80 },
4798 { OV511_I2C_BUS, 0x7b, 0xe2 },
4799 { OV511_I2C_BUS, 0x7c, 0x00 },
4800 { OV511_DONE_BUS, 0x0, 0x00 },
4801 };
4802
4803 PDEBUG(4, "starting configuration");
4804
4805 /* This looks redundant, but is necessary for WebCam 3 */
4806 ov->primary_i2c_slave = OV7xx0_SID;
4807 if (ov51x_set_slave_ids(ov, OV7xx0_SID) < 0)
4808 return -1;
4809
4810 if (init_ov_sensor(ov) >= 0) {
4811 PDEBUG(1, "OV7xx0 sensor initalized (method 1)");
4812 } else {
4813 /* Reset the 76xx */
4814 if (i2c_w(ov, 0x12, 0x80) < 0)
4815 return -1;
4816
4817 /* Wait for it to initialize */
4818 msleep(150);
4819
4820 i = 0;
4821 success = 0;
4822 while (i <= i2c_detect_tries) {
4823 if ((i2c_r(ov, OV7610_REG_ID_HIGH) == 0x7F) &&
4824 (i2c_r(ov, OV7610_REG_ID_LOW) == 0xA2)) {
4825 success = 1;
4826 break;
4827 } else {
4828 i++;
4829 }
4830 }
4831
4832 // Was (i == i2c_detect_tries) previously. This obviously used to always report
4833 // success. Whether anyone actually depended on that bug is unknown
4834 if ((i >= i2c_detect_tries) && (success == 0)) {
4835 err("Failed to read sensor ID. You might not have an");
4836 err("OV7610/20, or it may be not responding. Report");
4837 err("this to " EMAIL);
4838 err("This is only a warning. You can attempt to use");
4839 err("your camera anyway");
4840 // Only issue a warning for now
4841 // return -1;
4842 } else {
4843 PDEBUG(1, "OV7xx0 initialized (method 2, %dx)", i+1);
4844 }
4845 }
4846
4847 /* Detect sensor (sub)type */
4848 rc = i2c_r(ov, OV7610_REG_COM_I);
4849
4850 if (rc < 0) {
4851 err("Error detecting sensor type");
4852 return -1;
4853 } else if ((rc & 3) == 3) {
4854 dev_info(&ov->dev->dev, "Sensor is an OV7610\n");
4855 ov->sensor = SEN_OV7610;
4856 } else if ((rc & 3) == 1) {
4857 /* I don't know what's different about the 76BE yet. */
4858 if (i2c_r(ov, 0x15) & 1)
4859 dev_info(&ov->dev->dev, "Sensor is an OV7620AE\n");
4860 else
4861 dev_info(&ov->dev->dev, "Sensor is an OV76BE\n");
4862
4863 /* OV511+ will return all zero isoc data unless we
4864 * configure the sensor as a 7620. Someone needs to
4865 * find the exact reg. setting that causes this. */
4866 if (ov->bridge == BRG_OV511PLUS) {
4867 dev_info(&ov->dev->dev,
4868 "Enabling 511+/7620AE workaround\n");
4869 ov->sensor = SEN_OV7620;
4870 } else {
4871 ov->sensor = SEN_OV76BE;
4872 }
4873 } else if ((rc & 3) == 0) {
4874 dev_info(&ov->dev->dev, "Sensor is an OV7620\n");
4875 ov->sensor = SEN_OV7620;
4876 } else {
4877 err("Unknown image sensor version: %d", rc & 3);
4878 return -1;
4879 }
4880
4881 if (ov->sensor == SEN_OV7620) {
4882 PDEBUG(4, "Writing 7620 registers");
4883 if (write_regvals(ov, aRegvalsNorm7620))
4884 return -1;
4885 } else {
4886 PDEBUG(4, "Writing 7610 registers");
4887 if (write_regvals(ov, aRegvalsNorm7610))
4888 return -1;
4889 }
4890
4891 /* Set sensor-specific vars */
4892 ov->maxwidth = 640;
4893 ov->maxheight = 480;
4894 ov->minwidth = 64;
4895 ov->minheight = 48;
4896
4897 // FIXME: These do not match the actual settings yet
4898 ov->brightness = 0x80 << 8;
4899 ov->contrast = 0x80 << 8;
4900 ov->colour = 0x80 << 8;
4901 ov->hue = 0x80 << 8;
4902
4903 return 0;
4904 }
4905
4906 /* This initializes the OV6620, OV6630, OV6630AE, or OV6630AF sensor. */
4907 static int
4908 ov6xx0_configure(struct usb_ov511 *ov)
4909 {
4910 int rc;
4911
4912 static struct ov511_regvals aRegvalsNorm6x20[] = {
4913 { OV511_I2C_BUS, 0x12, 0x80 }, /* reset */
4914 { OV511_I2C_BUS, 0x11, 0x01 },
4915 { OV511_I2C_BUS, 0x03, 0x60 },
4916 { OV511_I2C_BUS, 0x05, 0x7f }, /* For when autoadjust is off */
4917 { OV511_I2C_BUS, 0x07, 0xa8 },
4918 /* The ratio of 0x0c and 0x0d controls the white point */
4919 { OV511_I2C_BUS, 0x0c, 0x24 },
4920 { OV511_I2C_BUS, 0x0d, 0x24 },
4921 { OV511_I2C_BUS, 0x0f, 0x15 }, /* COMS */
4922 { OV511_I2C_BUS, 0x10, 0x75 }, /* AEC Exposure time */
4923 { OV511_I2C_BUS, 0x12, 0x24 }, /* Enable AGC */
4924 { OV511_I2C_BUS, 0x14, 0x04 },
4925 /* 0x16: 0x06 helps frame stability with moving objects */
4926 { OV511_I2C_BUS, 0x16, 0x06 },
4927 // { OV511_I2C_BUS, 0x20, 0x30 }, /* Aperture correction enable */
4928 { OV511_I2C_BUS, 0x26, 0xb2 }, /* BLC enable */
4929 /* 0x28: 0x05 Selects RGB format if RGB on */
4930 { OV511_I2C_BUS, 0x28, 0x05 },
4931 { OV511_I2C_BUS, 0x2a, 0x04 }, /* Disable framerate adjust */
4932 // { OV511_I2C_BUS, 0x2b, 0xac }, /* Framerate; Set 2a[7] first */
4933 { OV511_I2C_BUS, 0x2d, 0x99 },
4934 { OV511_I2C_BUS, 0x33, 0xa0 }, /* Color Processing Parameter */
4935 { OV511_I2C_BUS, 0x34, 0xd2 }, /* Max A/D range */
4936 { OV511_I2C_BUS, 0x38, 0x8b },
4937 { OV511_I2C_BUS, 0x39, 0x40 },
4938
4939 { OV511_I2C_BUS, 0x3c, 0x39 }, /* Enable AEC mode changing */
4940 { OV511_I2C_BUS, 0x3c, 0x3c }, /* Change AEC mode */
4941 { OV511_I2C_BUS, 0x3c, 0x24 }, /* Disable AEC mode changing */
4942
4943 { OV511_I2C_BUS, 0x3d, 0x80 },
4944 /* These next two registers (0x4a, 0x4b) are undocumented. They
4945 * control the color balance */
4946 { OV511_I2C_BUS, 0x4a, 0x80 },
4947 { OV511_I2C_BUS, 0x4b, 0x80 },
4948 { OV511_I2C_BUS, 0x4d, 0xd2 }, /* This reduces noise a bit */
4949 { OV511_I2C_BUS, 0x4e, 0xc1 },
4950 { OV511_I2C_BUS, 0x4f, 0x04 },
4951 // Do 50-53 have any effect?
4952 // Toggle 0x12[2] off and on here?
4953 { OV511_DONE_BUS, 0x0, 0x00 }, /* END MARKER */
4954 };
4955
4956 static struct ov511_regvals aRegvalsNorm6x30[] = {
4957 /*OK*/ { OV511_I2C_BUS, 0x12, 0x80 }, /* reset */
4958 { OV511_I2C_BUS, 0x11, 0x00 },
4959 /*OK*/ { OV511_I2C_BUS, 0x03, 0x60 },
4960 /*0A?*/ { OV511_I2C_BUS, 0x05, 0x7f }, /* For when autoadjust is off */
4961 { OV511_I2C_BUS, 0x07, 0xa8 },
4962 /* The ratio of 0x0c and 0x0d controls the white point */
4963 /*OK*/ { OV511_I2C_BUS, 0x0c, 0x24 },
4964 /*OK*/ { OV511_I2C_BUS, 0x0d, 0x24 },
4965 /*A*/ { OV511_I2C_BUS, 0x0e, 0x20 },
4966 // /*04?*/ { OV511_I2C_BUS, 0x14, 0x80 },
4967 { OV511_I2C_BUS, 0x16, 0x03 },
4968 // /*OK*/ { OV511_I2C_BUS, 0x20, 0x30 }, /* Aperture correction enable */
4969 // 21 & 22? The suggested values look wrong. Go with default
4970 /*A*/ { OV511_I2C_BUS, 0x23, 0xc0 },
4971 /*A*/ { OV511_I2C_BUS, 0x25, 0x9a }, // Check this against default
4972 // /*OK*/ { OV511_I2C_BUS, 0x26, 0xb2 }, /* BLC enable */
4973
4974 /* 0x28: 0x05 Selects RGB format if RGB on */
4975 // /*04?*/ { OV511_I2C_BUS, 0x28, 0x05 },
4976 // /*04?*/ { OV511_I2C_BUS, 0x28, 0x45 }, // DEBUG: Tristate UV bus
4977
4978 /*OK*/ { OV511_I2C_BUS, 0x2a, 0x04 }, /* Disable framerate adjust */
4979 // /*OK*/ { OV511_I2C_BUS, 0x2b, 0xac }, /* Framerate; Set 2a[7] first */
4980 { OV511_I2C_BUS, 0x2d, 0x99 },
4981 // /*A*/ { OV511_I2C_BUS, 0x33, 0x26 }, // Reserved bits on 6620
4982 // /*d2?*/ { OV511_I2C_BUS, 0x34, 0x03 }, /* Max A/D range */
4983 // /*8b?*/ { OV511_I2C_BUS, 0x38, 0x83 },
4984 // /*40?*/ { OV511_I2C_BUS, 0x39, 0xc0 }, // 6630 adds bit 7
4985 // { OV511_I2C_BUS, 0x3c, 0x39 }, /* Enable AEC mode changing */
4986 // { OV511_I2C_BUS, 0x3c, 0x3c }, /* Change AEC mode */
4987 // { OV511_I2C_BUS, 0x3c, 0x24 }, /* Disable AEC mode changing */
4988 { OV511_I2C_BUS, 0x3d, 0x80 },
4989 // /*A*/ { OV511_I2C_BUS, 0x3f, 0x0e },
4990
4991 /* These next two registers (0x4a, 0x4b) are undocumented. They
4992 * control the color balance */
4993 // /*OK?*/ { OV511_I2C_BUS, 0x4a, 0x80 }, // Check these
4994 // /*OK?*/ { OV511_I2C_BUS, 0x4b, 0x80 },
4995 { OV511_I2C_BUS, 0x4d, 0x10 }, /* U = 0.563u, V = 0.714v */
4996 /*c1?*/ { OV511_I2C_BUS, 0x4e, 0x40 },
4997
4998 /* UV average mode, color killer: strongest */
4999 { OV511_I2C_BUS, 0x4f, 0x07 },
5000
5001 { OV511_I2C_BUS, 0x54, 0x23 }, /* Max AGC gain: 18dB */
5002 { OV511_I2C_BUS, 0x57, 0x81 }, /* (default) */
5003 { OV511_I2C_BUS, 0x59, 0x01 }, /* AGC dark current comp: +1 */
5004 { OV511_I2C_BUS, 0x5a, 0x2c }, /* (undocumented) */
5005 { OV511_I2C_BUS, 0x5b, 0x0f }, /* AWB chrominance levels */
5006 // { OV511_I2C_BUS, 0x5c, 0x10 },
5007 { OV511_DONE_BUS, 0x0, 0x00 }, /* END MARKER */
5008 };
5009
5010 PDEBUG(4, "starting sensor configuration");
5011
5012 if (init_ov_sensor(ov) < 0) {
5013 err("Failed to read sensor ID. You might not have an OV6xx0,");
5014 err("or it may be not responding. Report this to " EMAIL);
5015 return -1;
5016 } else {
5017 PDEBUG(1, "OV6xx0 sensor detected");
5018 }
5019
5020 /* Detect sensor (sub)type */
5021 rc = i2c_r(ov, OV7610_REG_COM_I);
5022
5023 if (rc < 0) {
5024 err("Error detecting sensor type");
5025 return -1;
5026 }
5027
5028 if ((rc & 3) == 0) {
5029 ov->sensor = SEN_OV6630;
5030 dev_info(&ov->dev->dev, "Sensor is an OV6630\n");
5031 } else if ((rc & 3) == 1) {
5032 ov->sensor = SEN_OV6620;
5033 dev_info(&ov->dev->dev, "Sensor is an OV6620\n");
5034 } else if ((rc & 3) == 2) {
5035 ov->sensor = SEN_OV6630;
5036 dev_info(&ov->dev->dev, "Sensor is an OV6630AE\n");
5037 } else if ((rc & 3) == 3) {
5038 ov->sensor = SEN_OV6630;
5039 dev_info(&ov->dev->dev, "Sensor is an OV6630AF\n");
5040 }
5041
5042 /* Set sensor-specific vars */
5043 ov->maxwidth = 352;
5044 ov->maxheight = 288;
5045 ov->minwidth = 64;
5046 ov->minheight = 48;
5047
5048 // FIXME: These do not match the actual settings yet
5049 ov->brightness = 0x80 << 8;
5050 ov->contrast = 0x80 << 8;
5051 ov->colour = 0x80 << 8;
5052 ov->hue = 0x80 << 8;
5053
5054 if (ov->sensor == SEN_OV6620) {
5055 PDEBUG(4, "Writing 6x20 registers");
5056 if (write_regvals(ov, aRegvalsNorm6x20))
5057 return -1;
5058 } else {
5059 PDEBUG(4, "Writing 6x30 registers");
5060 if (write_regvals(ov, aRegvalsNorm6x30))
5061 return -1;
5062 }
5063
5064 return 0;
5065 }
5066
5067 /* This initializes the KS0127 and KS0127B video decoders. */
5068 static int
5069 ks0127_configure(struct usb_ov511 *ov)
5070 {
5071 int rc;
5072
5073 // FIXME: I don't know how to sync or reset it yet
5074 #if 0
5075 if (ov51x_init_ks_sensor(ov) < 0) {
5076 err("Failed to initialize the KS0127");
5077 return -1;
5078 } else {
5079 PDEBUG(1, "KS012x(B) sensor detected");
5080 }
5081 #endif
5082
5083 /* Detect decoder subtype */
5084 rc = i2c_r(ov, 0x00);
5085 if (rc < 0) {
5086 err("Error detecting sensor type");
5087 return -1;
5088 } else if (rc & 0x08) {
5089 rc = i2c_r(ov, 0x3d);
5090 if (rc < 0) {
5091 err("Error detecting sensor type");
5092 return -1;
5093 } else if ((rc & 0x0f) == 0) {
5094 dev_info(&ov->dev->dev, "Sensor is a KS0127\n");
5095 ov->sensor = SEN_KS0127;
5096 } else if ((rc & 0x0f) == 9) {
5097 dev_info(&ov->dev->dev, "Sensor is a KS0127B Rev. A\n");
5098 ov->sensor = SEN_KS0127B;
5099 }
5100 } else {
5101 err("Error: Sensor is an unsupported KS0122");
5102 return -1;
5103 }
5104
5105 /* Set sensor-specific vars */
5106 ov->maxwidth = 640;
5107 ov->maxheight = 480;
5108 ov->minwidth = 64;
5109 ov->minheight = 48;
5110
5111 // FIXME: These do not match the actual settings yet
5112 ov->brightness = 0x80 << 8;
5113 ov->contrast = 0x80 << 8;
5114 ov->colour = 0x80 << 8;
5115 ov->hue = 0x80 << 8;
5116
5117 /* This device is not supported yet. Bail out now... */
5118 err("This sensor is not supported yet.");
5119 return -1;
5120
5121 return 0;
5122 }
5123
5124 /* This initializes the SAA7111A video decoder. */
5125 static int
5126 saa7111a_configure(struct usb_ov511 *ov)
5127 {
5128 int rc;
5129
5130 /* Since there is no register reset command, all registers must be
5131 * written, otherwise gives erratic results */
5132 static struct ov511_regvals aRegvalsNormSAA7111A[] = {
5133 { OV511_I2C_BUS, 0x06, 0xce },
5134 { OV511_I2C_BUS, 0x07, 0x00 },
5135 { OV511_I2C_BUS, 0x10, 0x44 }, /* YUV422, 240/286 lines */
5136 { OV511_I2C_BUS, 0x0e, 0x01 }, /* NTSC M or PAL BGHI */
5137 { OV511_I2C_BUS, 0x00, 0x00 },
5138 { OV511_I2C_BUS, 0x01, 0x00 },
5139 { OV511_I2C_BUS, 0x03, 0x23 },
5140 { OV511_I2C_BUS, 0x04, 0x00 },
5141 { OV511_I2C_BUS, 0x05, 0x00 },
5142 { OV511_I2C_BUS, 0x08, 0xc8 }, /* Auto field freq */
5143 { OV511_I2C_BUS, 0x09, 0x01 }, /* Chrom. trap off, APER=0.25 */
5144 { OV511_I2C_BUS, 0x0a, 0x80 }, /* BRIG=128 */
5145 { OV511_I2C_BUS, 0x0b, 0x40 }, /* CONT=1.0 */
5146 { OV511_I2C_BUS, 0x0c, 0x40 }, /* SATN=1.0 */
5147 { OV511_I2C_BUS, 0x0d, 0x00 }, /* HUE=0 */
5148 { OV511_I2C_BUS, 0x0f, 0x00 },
5149 { OV511_I2C_BUS, 0x11, 0x0c },
5150 { OV511_I2C_BUS, 0x12, 0x00 },
5151 { OV511_I2C_BUS, 0x13, 0x00 },
5152 { OV511_I2C_BUS, 0x14, 0x00 },
5153 { OV511_I2C_BUS, 0x15, 0x00 },
5154 { OV511_I2C_BUS, 0x16, 0x00 },
5155 { OV511_I2C_BUS, 0x17, 0x00 },
5156 { OV511_I2C_BUS, 0x02, 0xc0 }, /* Composite input 0 */
5157 { OV511_DONE_BUS, 0x0, 0x00 },
5158 };
5159
5160 // FIXME: I don't know how to sync or reset it yet
5161 #if 0
5162 if (ov51x_init_saa_sensor(ov) < 0) {
5163 err("Failed to initialize the SAA7111A");
5164 return -1;
5165 } else {
5166 PDEBUG(1, "SAA7111A sensor detected");
5167 }
5168 #endif
5169
5170 /* 640x480 not supported with PAL */
5171 if (ov->pal) {
5172 ov->maxwidth = 320;
5173 ov->maxheight = 240; /* Even field only */
5174 } else {
5175 ov->maxwidth = 640;
5176 ov->maxheight = 480; /* Even/Odd fields */
5177 }
5178
5179 ov->minwidth = 320;
5180 ov->minheight = 240; /* Even field only */
5181
5182 ov->has_decoder = 1;
5183 ov->num_inputs = 8;
5184 ov->norm = VIDEO_MODE_AUTO;
5185 ov->stop_during_set = 0; /* Decoder guarantees stable image */
5186
5187 /* Decoder doesn't change these values, so we use these instead of
5188 * acutally reading the registers (which doesn't work) */
5189 ov->brightness = 0x80 << 8;
5190 ov->contrast = 0x40 << 9;
5191 ov->colour = 0x40 << 9;
5192 ov->hue = 32768;
5193
5194 PDEBUG(4, "Writing SAA7111A registers");
5195 if (write_regvals(ov, aRegvalsNormSAA7111A))
5196 return -1;
5197
5198 /* Detect version of decoder. This must be done after writing the
5199 * initial regs or the decoder will lock up. */
5200 rc = i2c_r(ov, 0x00);
5201
5202 if (rc < 0) {
5203 err("Error detecting sensor version");
5204 return -1;
5205 } else {
5206 dev_info(&ov->dev->dev,
5207 "Sensor is an SAA7111A (version 0x%x)\n", rc);
5208 ov->sensor = SEN_SAA7111A;
5209 }
5210
5211 // FIXME: Fix this for OV518(+)
5212 /* Latch to negative edge of clock. Otherwise, we get incorrect
5213 * colors and jitter in the digital signal. */
5214 if (ov->bclass == BCL_OV511)
5215 reg_w(ov, 0x11, 0x00);
5216 else
5217 dev_warn(&ov->dev->dev,
5218 "SAA7111A not yet supported with OV518/OV518+\n");
5219
5220 return 0;
5221 }
5222
5223 /* This initializes the OV511/OV511+ and the sensor */
5224 static int
5225 ov511_configure(struct usb_ov511 *ov)
5226 {
5227 static struct ov511_regvals aRegvalsInit511[] = {
5228 { OV511_REG_BUS, R51x_SYS_RESET, 0x7f },
5229 { OV511_REG_BUS, R51x_SYS_INIT, 0x01 },
5230 { OV511_REG_BUS, R51x_SYS_RESET, 0x7f },
5231 { OV511_REG_BUS, R51x_SYS_INIT, 0x01 },
5232 { OV511_REG_BUS, R51x_SYS_RESET, 0x3f },
5233 { OV511_REG_BUS, R51x_SYS_INIT, 0x01 },
5234 { OV511_REG_BUS, R51x_SYS_RESET, 0x3d },
5235 { OV511_DONE_BUS, 0x0, 0x00},
5236 };
5237
5238 static struct ov511_regvals aRegvalsNorm511[] = {
5239 { OV511_REG_BUS, R511_DRAM_FLOW_CTL, 0x01 },
5240 { OV511_REG_BUS, R51x_SYS_SNAP, 0x00 },
5241 { OV511_REG_BUS, R51x_SYS_SNAP, 0x02 },
5242 { OV511_REG_BUS, R51x_SYS_SNAP, 0x00 },
5243 { OV511_REG_BUS, R511_FIFO_OPTS, 0x1f },
5244 { OV511_REG_BUS, R511_COMP_EN, 0x00 },
5245 { OV511_REG_BUS, R511_COMP_LUT_EN, 0x03 },
5246 { OV511_DONE_BUS, 0x0, 0x00 },
5247 };
5248
5249 static struct ov511_regvals aRegvalsNorm511Plus[] = {
5250 { OV511_REG_BUS, R511_DRAM_FLOW_CTL, 0xff },
5251 { OV511_REG_BUS, R51x_SYS_SNAP, 0x00 },
5252 { OV511_REG_BUS, R51x_SYS_SNAP, 0x02 },
5253 { OV511_REG_BUS, R51x_SYS_SNAP, 0x00 },
5254 { OV511_REG_BUS, R511_FIFO_OPTS, 0xff },
5255 { OV511_REG_BUS, R511_COMP_EN, 0x00 },
5256 { OV511_REG_BUS, R511_COMP_LUT_EN, 0x03 },
5257 { OV511_DONE_BUS, 0x0, 0x00 },
5258 };
5259
5260 PDEBUG(4, "");
5261
5262 ov->customid = reg_r(ov, R511_SYS_CUST_ID);
5263 if (ov->customid < 0) {
5264 err("Unable to read camera bridge registers");
5265 goto error;
5266 }
5267
5268 PDEBUG (1, "CustomID = %d", ov->customid);
5269 ov->desc = symbolic(camlist, ov->customid);
5270 dev_info(&ov->dev->dev, "model: %s\n", ov->desc);
5271
5272 if (0 == strcmp(ov->desc, NOT_DEFINED_STR)) {
5273 err("Camera type (%d) not recognized", ov->customid);
5274 err("Please notify " EMAIL " of the name,");
5275 err("manufacturer, model, and this number of your camera.");
5276 err("Also include the output of the detection process.");
5277 }
5278
5279 if (ov->customid == 70) /* USB Life TV (PAL/SECAM) */
5280 ov->pal = 1;
5281
5282 if (write_regvals(ov, aRegvalsInit511))
5283 goto error;
5284
5285 if (ov->led_policy == LED_OFF || ov->led_policy == LED_AUTO)
5286 ov51x_led_control(ov, 0);
5287
5288 /* The OV511+ has undocumented bits in the flow control register.
5289 * Setting it to 0xff fixes the corruption with moving objects. */
5290 if (ov->bridge == BRG_OV511) {
5291 if (write_regvals(ov, aRegvalsNorm511))
5292 goto error;
5293 } else if (ov->bridge == BRG_OV511PLUS) {
5294 if (write_regvals(ov, aRegvalsNorm511Plus))
5295 goto error;
5296 } else {
5297 err("Invalid bridge");
5298 }
5299
5300 if (ov511_init_compression(ov))
5301 goto error;
5302
5303 ov->packet_numbering = 1;
5304 ov511_set_packet_size(ov, 0);
5305
5306 ov->snap_enabled = snapshot;
5307
5308 /* Test for 7xx0 */
5309 PDEBUG(3, "Testing for 0V7xx0");
5310 ov->primary_i2c_slave = OV7xx0_SID;
5311 if (ov51x_set_slave_ids(ov, OV7xx0_SID) < 0)
5312 goto error;
5313
5314 if (i2c_w(ov, 0x12, 0x80) < 0) {
5315 /* Test for 6xx0 */
5316 PDEBUG(3, "Testing for 0V6xx0");
5317 ov->primary_i2c_slave = OV6xx0_SID;
5318 if (ov51x_set_slave_ids(ov, OV6xx0_SID) < 0)
5319 goto error;
5320
5321 if (i2c_w(ov, 0x12, 0x80) < 0) {
5322 /* Test for 8xx0 */
5323 PDEBUG(3, "Testing for 0V8xx0");
5324 ov->primary_i2c_slave = OV8xx0_SID;
5325 if (ov51x_set_slave_ids(ov, OV8xx0_SID) < 0)
5326 goto error;
5327
5328 if (i2c_w(ov, 0x12, 0x80) < 0) {
5329 /* Test for SAA7111A */
5330 PDEBUG(3, "Testing for SAA7111A");
5331 ov->primary_i2c_slave = SAA7111A_SID;
5332 if (ov51x_set_slave_ids(ov, SAA7111A_SID) < 0)
5333 goto error;
5334
5335 if (i2c_w(ov, 0x0d, 0x00) < 0) {
5336 /* Test for KS0127 */
5337 PDEBUG(3, "Testing for KS0127");
5338 ov->primary_i2c_slave = KS0127_SID;
5339 if (ov51x_set_slave_ids(ov, KS0127_SID) < 0)
5340 goto error;
5341
5342 if (i2c_w(ov, 0x10, 0x00) < 0) {
5343 err("Can't determine sensor slave IDs");
5344 goto error;
5345 } else {
5346 if (ks0127_configure(ov) < 0) {
5347 err("Failed to configure KS0127");
5348 goto error;
5349 }
5350 }
5351 } else {
5352 if (saa7111a_configure(ov) < 0) {
5353 err("Failed to configure SAA7111A");
5354 goto error;
5355 }
5356 }
5357 } else {
5358 err("Detected unsupported OV8xx0 sensor");
5359 goto error;
5360 }
5361 } else {
5362 if (ov6xx0_configure(ov) < 0) {
5363 err("Failed to configure OV6xx0");
5364 goto error;
5365 }
5366 }
5367 } else {
5368 if (ov7xx0_configure(ov) < 0) {
5369 err("Failed to configure OV7xx0");
5370 goto error;
5371 }
5372 }
5373
5374 return 0;
5375
5376 error:
5377 err("OV511 Config failed");
5378
5379 return -EBUSY;
5380 }
5381
5382 /* This initializes the OV518/OV518+ and the sensor */
5383 static int
5384 ov518_configure(struct usb_ov511 *ov)
5385 {
5386 /* For 518 and 518+ */
5387 static struct ov511_regvals aRegvalsInit518[] = {
5388 { OV511_REG_BUS, R51x_SYS_RESET, 0x40 },
5389 { OV511_REG_BUS, R51x_SYS_INIT, 0xe1 },
5390 { OV511_REG_BUS, R51x_SYS_RESET, 0x3e },
5391 { OV511_REG_BUS, R51x_SYS_INIT, 0xe1 },
5392 { OV511_REG_BUS, R51x_SYS_RESET, 0x00 },
5393 { OV511_REG_BUS, R51x_SYS_INIT, 0xe1 },
5394 { OV511_REG_BUS, 0x46, 0x00 },
5395 { OV511_REG_BUS, 0x5d, 0x03 },
5396 { OV511_DONE_BUS, 0x0, 0x00},
5397 };
5398
5399 static struct ov511_regvals aRegvalsNorm518[] = {
5400 { OV511_REG_BUS, R51x_SYS_SNAP, 0x02 }, /* Reset */
5401 { OV511_REG_BUS, R51x_SYS_SNAP, 0x01 }, /* Enable */
5402 { OV511_REG_BUS, 0x31, 0x0f },
5403 { OV511_REG_BUS, 0x5d, 0x03 },
5404 { OV511_REG_BUS, 0x24, 0x9f },
5405 { OV511_REG_BUS, 0x25, 0x90 },
5406 { OV511_REG_BUS, 0x20, 0x00 },
5407 { OV511_REG_BUS, 0x51, 0x04 },
5408 { OV511_REG_BUS, 0x71, 0x19 },
5409 { OV511_DONE_BUS, 0x0, 0x00 },
5410 };
5411
5412 static struct ov511_regvals aRegvalsNorm518Plus[] = {
5413 { OV511_REG_BUS, R51x_SYS_SNAP, 0x02 }, /* Reset */
5414 { OV511_REG_BUS, R51x_SYS_SNAP, 0x01 }, /* Enable */
5415 { OV511_REG_BUS, 0x31, 0x0f },
5416 { OV511_REG_BUS, 0x5d, 0x03 },
5417 { OV511_REG_BUS, 0x24, 0x9f },
5418 { OV511_REG_BUS, 0x25, 0x90 },
5419 { OV511_REG_BUS, 0x20, 0x60 },
5420 { OV511_REG_BUS, 0x51, 0x02 },
5421 { OV511_REG_BUS, 0x71, 0x19 },
5422 { OV511_REG_BUS, 0x40, 0xff },
5423 { OV511_REG_BUS, 0x41, 0x42 },
5424 { OV511_REG_BUS, 0x46, 0x00 },
5425 { OV511_REG_BUS, 0x33, 0x04 },
5426 { OV511_REG_BUS, 0x21, 0x19 },
5427 { OV511_REG_BUS, 0x3f, 0x10 },
5428 { OV511_DONE_BUS, 0x0, 0x00 },
5429 };
5430
5431 PDEBUG(4, "");
5432
5433 /* First 5 bits of custom ID reg are a revision ID on OV518 */
5434 dev_info(&ov->dev->dev, "Device revision %d\n",
5435 0x1F & reg_r(ov, R511_SYS_CUST_ID));
5436
5437 /* Give it the default description */
5438 ov->desc = symbolic(camlist, 0);
5439
5440 if (write_regvals(ov, aRegvalsInit518))
5441 goto error;
5442
5443 /* Set LED GPIO pin to output mode */
5444 if (reg_w_mask(ov, 0x57, 0x00, 0x02) < 0)
5445 goto error;
5446
5447 /* LED is off by default with OV518; have to explicitly turn it on */
5448 if (ov->led_policy == LED_OFF || ov->led_policy == LED_AUTO)
5449 ov51x_led_control(ov, 0);
5450 else
5451 ov51x_led_control(ov, 1);
5452
5453 /* Don't require compression if dumppix is enabled; otherwise it's
5454 * required. OV518 has no uncompressed mode, to save RAM. */
5455 if (!dumppix && !ov->compress) {
5456 ov->compress = 1;
5457 dev_warn(&ov->dev->dev,
5458 "Compression required with OV518...enabling\n");
5459 }
5460
5461 if (ov->bridge == BRG_OV518) {
5462 if (write_regvals(ov, aRegvalsNorm518))
5463 goto error;
5464 } else if (ov->bridge == BRG_OV518PLUS) {
5465 if (write_regvals(ov, aRegvalsNorm518Plus))
5466 goto error;
5467 } else {
5468 err("Invalid bridge");
5469 }
5470
5471 if (reg_w(ov, 0x2f, 0x80) < 0)
5472 goto error;
5473
5474 if (ov518_init_compression(ov))
5475 goto error;
5476
5477 if (ov->bridge == BRG_OV518)
5478 {
5479 struct usb_interface *ifp;
5480 struct usb_host_interface *alt;
5481 __u16 mxps = 0;
5482
5483 ifp = usb_ifnum_to_if(ov->dev, 0);
5484 if (ifp) {
5485 alt = usb_altnum_to_altsetting(ifp, 7);
5486 if (alt)
5487 mxps = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
5488 }
5489
5490 /* Some OV518s have packet numbering by default, some don't */
5491 if (mxps == 897)
5492 ov->packet_numbering = 1;
5493 else
5494 ov->packet_numbering = 0;
5495 } else {
5496 /* OV518+ has packet numbering turned on by default */
5497 ov->packet_numbering = 1;
5498 }
5499
5500 ov518_set_packet_size(ov, 0);
5501
5502 ov->snap_enabled = snapshot;
5503
5504 /* Test for 76xx */
5505 ov->primary_i2c_slave = OV7xx0_SID;
5506 if (ov51x_set_slave_ids(ov, OV7xx0_SID) < 0)
5507 goto error;
5508
5509 /* The OV518 must be more aggressive about sensor detection since
5510 * I2C write will never fail if the sensor is not present. We have
5511 * to try to initialize the sensor to detect its presence */
5512
5513 if (init_ov_sensor(ov) < 0) {
5514 /* Test for 6xx0 */
5515 ov->primary_i2c_slave = OV6xx0_SID;
5516 if (ov51x_set_slave_ids(ov, OV6xx0_SID) < 0)
5517 goto error;
5518
5519 if (init_ov_sensor(ov) < 0) {
5520 /* Test for 8xx0 */
5521 ov->primary_i2c_slave = OV8xx0_SID;
5522 if (ov51x_set_slave_ids(ov, OV8xx0_SID) < 0)
5523 goto error;
5524
5525 if (init_ov_sensor(ov) < 0) {
5526 err("Can't determine sensor slave IDs");
5527 goto error;
5528 } else {
5529 err("Detected unsupported OV8xx0 sensor");
5530 goto error;
5531 }
5532 } else {
5533 if (ov6xx0_configure(ov) < 0) {
5534 err("Failed to configure OV6xx0");
5535 goto error;
5536 }
5537 }
5538 } else {
5539 if (ov7xx0_configure(ov) < 0) {
5540 err("Failed to configure OV7xx0");
5541 goto error;
5542 }
5543 }
5544
5545 ov->maxwidth = 352;
5546 ov->maxheight = 288;
5547
5548 // The OV518 cannot go as low as the sensor can
5549 ov->minwidth = 160;
5550 ov->minheight = 120;
5551
5552 return 0;
5553
5554 error:
5555 err("OV518 Config failed");
5556
5557 return -EBUSY;
5558 }
5559
5560 /****************************************************************************
5561 * sysfs
5562 ***************************************************************************/
5563
5564 static inline struct usb_ov511 *cd_to_ov(struct device *cd)
5565 {
5566 struct video_device *vdev = to_video_device(cd);
5567 return video_get_drvdata(vdev);
5568 }
5569
5570 static ssize_t show_custom_id(struct device *cd,
5571 struct device_attribute *attr, char *buf)
5572 {
5573 struct usb_ov511 *ov = cd_to_ov(cd);
5574 return sprintf(buf, "%d\n", ov->customid);
5575 }
5576 static DEVICE_ATTR(custom_id, S_IRUGO, show_custom_id, NULL);
5577
5578 static ssize_t show_model(struct device *cd,
5579 struct device_attribute *attr, char *buf)
5580 {
5581 struct usb_ov511 *ov = cd_to_ov(cd);
5582 return sprintf(buf, "%s\n", ov->desc);
5583 }
5584 static DEVICE_ATTR(model, S_IRUGO, show_model, NULL);
5585
5586 static ssize_t show_bridge(struct device *cd,
5587 struct device_attribute *attr, char *buf)
5588 {
5589 struct usb_ov511 *ov = cd_to_ov(cd);
5590 return sprintf(buf, "%s\n", symbolic(brglist, ov->bridge));
5591 }
5592 static DEVICE_ATTR(bridge, S_IRUGO, show_bridge, NULL);
5593
5594 static ssize_t show_sensor(struct device *cd,
5595 struct device_attribute *attr, char *buf)
5596 {
5597 struct usb_ov511 *ov = cd_to_ov(cd);
5598 return sprintf(buf, "%s\n", symbolic(senlist, ov->sensor));
5599 }
5600 static DEVICE_ATTR(sensor, S_IRUGO, show_sensor, NULL);
5601
5602 static ssize_t show_brightness(struct device *cd,
5603 struct device_attribute *attr, char *buf)
5604 {
5605 struct usb_ov511 *ov = cd_to_ov(cd);
5606 unsigned short x;
5607
5608 if (!ov->dev)
5609 return -ENODEV;
5610 sensor_get_brightness(ov, &x);
5611 return sprintf(buf, "%d\n", x >> 8);
5612 }
5613 static DEVICE_ATTR(brightness, S_IRUGO, show_brightness, NULL);
5614
5615 static ssize_t show_saturation(struct device *cd,
5616 struct device_attribute *attr, char *buf)
5617 {
5618 struct usb_ov511 *ov = cd_to_ov(cd);
5619 unsigned short x;
5620
5621 if (!ov->dev)
5622 return -ENODEV;
5623 sensor_get_saturation(ov, &x);
5624 return sprintf(buf, "%d\n", x >> 8);
5625 }
5626 static DEVICE_ATTR(saturation, S_IRUGO, show_saturation, NULL);
5627
5628 static ssize_t show_contrast(struct device *cd,
5629 struct device_attribute *attr, char *buf)
5630 {
5631 struct usb_ov511 *ov = cd_to_ov(cd);
5632 unsigned short x;
5633
5634 if (!ov->dev)
5635 return -ENODEV;
5636 sensor_get_contrast(ov, &x);
5637 return sprintf(buf, "%d\n", x >> 8);
5638 }
5639 static DEVICE_ATTR(contrast, S_IRUGO, show_contrast, NULL);
5640
5641 static ssize_t show_hue(struct device *cd,
5642 struct device_attribute *attr, char *buf)
5643 {
5644 struct usb_ov511 *ov = cd_to_ov(cd);
5645 unsigned short x;
5646
5647 if (!ov->dev)
5648 return -ENODEV;
5649 sensor_get_hue(ov, &x);
5650 return sprintf(buf, "%d\n", x >> 8);
5651 }
5652 static DEVICE_ATTR(hue, S_IRUGO, show_hue, NULL);
5653
5654 static ssize_t show_exposure(struct device *cd,
5655 struct device_attribute *attr, char *buf)
5656 {
5657 struct usb_ov511 *ov = cd_to_ov(cd);
5658 unsigned char exp = 0;
5659
5660 if (!ov->dev)
5661 return -ENODEV;
5662 sensor_get_exposure(ov, &exp);
5663 return sprintf(buf, "%d\n", exp);
5664 }
5665 static DEVICE_ATTR(exposure, S_IRUGO, show_exposure, NULL);
5666
5667 static int ov_create_sysfs(struct video_device *vdev)
5668 {
5669 int rc;
5670
5671 rc = device_create_file(&vdev->dev, &dev_attr_custom_id);
5672 if (rc) goto err;
5673 rc = device_create_file(&vdev->dev, &dev_attr_model);
5674 if (rc) goto err_id;
5675 rc = device_create_file(&vdev->dev, &dev_attr_bridge);
5676 if (rc) goto err_model;
5677 rc = device_create_file(&vdev->dev, &dev_attr_sensor);
5678 if (rc) goto err_bridge;
5679 rc = device_create_file(&vdev->dev, &dev_attr_brightness);
5680 if (rc) goto err_sensor;
5681 rc = device_create_file(&vdev->dev, &dev_attr_saturation);
5682 if (rc) goto err_bright;
5683 rc = device_create_file(&vdev->dev, &dev_attr_contrast);
5684 if (rc) goto err_sat;
5685 rc = device_create_file(&vdev->dev, &dev_attr_hue);
5686 if (rc) goto err_contrast;
5687 rc = device_create_file(&vdev->dev, &dev_attr_exposure);
5688 if (rc) goto err_hue;
5689
5690 return 0;
5691
5692 err_hue:
5693 device_remove_file(&vdev->dev, &dev_attr_hue);
5694 err_contrast:
5695 device_remove_file(&vdev->dev, &dev_attr_contrast);
5696 err_sat:
5697 device_remove_file(&vdev->dev, &dev_attr_saturation);
5698 err_bright:
5699 device_remove_file(&vdev->dev, &dev_attr_brightness);
5700 err_sensor:
5701 device_remove_file(&vdev->dev, &dev_attr_sensor);
5702 err_bridge:
5703 device_remove_file(&vdev->dev, &dev_attr_bridge);
5704 err_model:
5705 device_remove_file(&vdev->dev, &dev_attr_model);
5706 err_id:
5707 device_remove_file(&vdev->dev, &dev_attr_custom_id);
5708 err:
5709 return rc;
5710 }
5711
5712 /****************************************************************************
5713 * USB routines
5714 ***************************************************************************/
5715
5716 static int
5717 ov51x_probe(struct usb_interface *intf, const struct usb_device_id *id)
5718 {
5719 struct usb_device *dev = interface_to_usbdev(intf);
5720 struct usb_interface_descriptor *idesc;
5721 struct usb_ov511 *ov;
5722 int i, rc, nr;
5723
5724 PDEBUG(1, "probing for device...");
5725
5726 /* We don't handle multi-config cameras */
5727 if (dev->descriptor.bNumConfigurations != 1)
5728 return -ENODEV;
5729
5730 idesc = &intf->cur_altsetting->desc;
5731
5732 if (idesc->bInterfaceClass != 0xFF)
5733 return -ENODEV;
5734 if (idesc->bInterfaceSubClass != 0x00)
5735 return -ENODEV;
5736
5737 if ((ov = kzalloc(sizeof(*ov), GFP_KERNEL)) == NULL) {
5738 err("couldn't kmalloc ov struct");
5739 goto error_out;
5740 }
5741
5742 ov->dev = dev;
5743 ov->iface = idesc->bInterfaceNumber;
5744 ov->led_policy = led;
5745 ov->compress = compress;
5746 ov->lightfreq = lightfreq;
5747 ov->num_inputs = 1; /* Video decoder init functs. change this */
5748 ov->stop_during_set = !fastset;
5749 ov->backlight = backlight;
5750 ov->mirror = mirror;
5751 ov->auto_brt = autobright;
5752 ov->auto_gain = autogain;
5753 ov->auto_exp = autoexp;
5754
5755 switch (le16_to_cpu(dev->descriptor.idProduct)) {
5756 case PROD_OV511:
5757 ov->bridge = BRG_OV511;
5758 ov->bclass = BCL_OV511;
5759 break;
5760 case PROD_OV511PLUS:
5761 ov->bridge = BRG_OV511PLUS;
5762 ov->bclass = BCL_OV511;
5763 break;
5764 case PROD_OV518:
5765 ov->bridge = BRG_OV518;
5766 ov->bclass = BCL_OV518;
5767 break;
5768 case PROD_OV518PLUS:
5769 ov->bridge = BRG_OV518PLUS;
5770 ov->bclass = BCL_OV518;
5771 break;
5772 case PROD_ME2CAM:
5773 if (le16_to_cpu(dev->descriptor.idVendor) != VEND_MATTEL)
5774 goto error;
5775 ov->bridge = BRG_OV511PLUS;
5776 ov->bclass = BCL_OV511;
5777 break;
5778 default:
5779 err("Unknown product ID 0x%04x", le16_to_cpu(dev->descriptor.idProduct));
5780 goto error;
5781 }
5782
5783 dev_info(&intf->dev, "USB %s video device found\n",
5784 symbolic(brglist, ov->bridge));
5785
5786 init_waitqueue_head(&ov->wq);
5787
5788 mutex_init(&ov->lock); /* to 1 == available */
5789 mutex_init(&ov->buf_lock);
5790 mutex_init(&ov->i2c_lock);
5791 mutex_init(&ov->cbuf_lock);
5792
5793 ov->buf_state = BUF_NOT_ALLOCATED;
5794
5795 if (usb_make_path(dev, ov->usb_path, OV511_USB_PATH_LEN) < 0) {
5796 err("usb_make_path error");
5797 goto error;
5798 }
5799
5800 /* Allocate control transfer buffer. */
5801 /* Must be kmalloc()'ed, for DMA compatibility */
5802 ov->cbuf = kmalloc(OV511_CBUF_SIZE, GFP_KERNEL);
5803 if (!ov->cbuf)
5804 goto error;
5805
5806 if (ov->bclass == BCL_OV518) {
5807 if (ov518_configure(ov) < 0)
5808 goto error;
5809 } else {
5810 if (ov511_configure(ov) < 0)
5811 goto error;
5812 }
5813
5814 for (i = 0; i < OV511_NUMFRAMES; i++) {
5815 ov->frame[i].framenum = i;
5816 init_waitqueue_head(&ov->frame[i].wq);
5817 }
5818
5819 for (i = 0; i < OV511_NUMSBUF; i++) {
5820 ov->sbuf[i].ov = ov;
5821 spin_lock_init(&ov->sbuf[i].lock);
5822 ov->sbuf[i].n = i;
5823 }
5824
5825 /* Unnecessary? (This is done on open(). Need to make sure variables
5826 * are properly initialized without this before removing it, though). */
5827 if (ov51x_set_default_params(ov) < 0)
5828 goto error;
5829
5830 #ifdef OV511_DEBUG
5831 if (dump_bridge) {
5832 if (ov->bclass == BCL_OV511)
5833 ov511_dump_regs(ov);
5834 else
5835 ov518_dump_regs(ov);
5836 }
5837 #endif
5838
5839 ov->vdev = video_device_alloc();
5840 if (!ov->vdev)
5841 goto error;
5842
5843 memcpy(ov->vdev, &vdev_template, sizeof(*ov->vdev));
5844 ov->vdev->parent = &intf->dev;
5845 video_set_drvdata(ov->vdev, ov);
5846
5847 mutex_lock(&ov->lock);
5848
5849 /* Check to see next free device and mark as used */
5850 nr = find_first_zero_bit(&ov511_devused, OV511_MAX_UNIT_VIDEO);
5851
5852 /* Registers device */
5853 if (unit_video[nr] != 0)
5854 rc = video_register_device(ov->vdev, VFL_TYPE_GRABBER,
5855 unit_video[nr]);
5856 else
5857 rc = video_register_device(ov->vdev, VFL_TYPE_GRABBER, -1);
5858
5859 if (rc < 0) {
5860 err("video_register_device failed");
5861 mutex_unlock(&ov->lock);
5862 goto error;
5863 }
5864
5865 /* Mark device as used */
5866 ov511_devused |= 1 << nr;
5867 ov->nr = nr;
5868
5869 dev_info(&intf->dev, "Device at %s registered to %s\n",
5870 ov->usb_path, video_device_node_name(ov->vdev));
5871
5872 usb_set_intfdata(intf, ov);
5873 if (ov_create_sysfs(ov->vdev)) {
5874 err("ov_create_sysfs failed");
5875 ov511_devused &= ~(1 << nr);
5876 mutex_unlock(&ov->lock);
5877 goto error;
5878 }
5879
5880 mutex_unlock(&ov->lock);
5881
5882 return 0;
5883
5884 error:
5885 if (ov->vdev) {
5886 if (!video_is_registered(ov->vdev))
5887 video_device_release(ov->vdev);
5888 else
5889 video_unregister_device(ov->vdev);
5890 ov->vdev = NULL;
5891 }
5892
5893 if (ov->cbuf) {
5894 mutex_lock(&ov->cbuf_lock);
5895 kfree(ov->cbuf);
5896 ov->cbuf = NULL;
5897 mutex_unlock(&ov->cbuf_lock);
5898 }
5899
5900 kfree(ov);
5901 ov = NULL;
5902
5903 error_out:
5904 err("Camera initialization failed");
5905 return -EIO;
5906 }
5907
5908 static void
5909 ov51x_disconnect(struct usb_interface *intf)
5910 {
5911 struct usb_ov511 *ov = usb_get_intfdata(intf);
5912 int n;
5913
5914 PDEBUG(3, "");
5915
5916 mutex_lock(&ov->lock);
5917 usb_set_intfdata (intf, NULL);
5918
5919 if (!ov) {
5920 mutex_unlock(&ov->lock);
5921 return;
5922 }
5923
5924 /* Free device number */
5925 ov511_devused &= ~(1 << ov->nr);
5926
5927 if (ov->vdev)
5928 video_unregister_device(ov->vdev);
5929
5930 for (n = 0; n < OV511_NUMFRAMES; n++)
5931 ov->frame[n].grabstate = FRAME_ERROR;
5932
5933 ov->curframe = -1;
5934
5935 /* This will cause the process to request another frame */
5936 for (n = 0; n < OV511_NUMFRAMES; n++)
5937 wake_up_interruptible(&ov->frame[n].wq);
5938
5939 wake_up_interruptible(&ov->wq);
5940
5941 ov->streaming = 0;
5942 ov51x_unlink_isoc(ov);
5943 mutex_unlock(&ov->lock);
5944
5945 ov->dev = NULL;
5946
5947 /* Free the memory */
5948 if (ov && !ov->user) {
5949 mutex_lock(&ov->cbuf_lock);
5950 kfree(ov->cbuf);
5951 ov->cbuf = NULL;
5952 mutex_unlock(&ov->cbuf_lock);
5953
5954 ov51x_dealloc(ov);
5955 kfree(ov);
5956 ov = NULL;
5957 }
5958
5959 PDEBUG(3, "Disconnect complete");
5960 }
5961
5962 static struct usb_driver ov511_driver = {
5963 .name = "ov511",
5964 .id_table = device_table,
5965 .probe = ov51x_probe,
5966 .disconnect = ov51x_disconnect
5967 };
5968
5969 /****************************************************************************
5970 *
5971 * Module routines
5972 *
5973 ***************************************************************************/
5974
5975 static int __init
5976 usb_ov511_init(void)
5977 {
5978 int retval;
5979
5980 retval = usb_register(&ov511_driver);
5981 if (retval)
5982 goto out;
5983
5984 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
5985 DRIVER_DESC "\n");
5986
5987 out:
5988 return retval;
5989 }
5990
5991 static void __exit
5992 usb_ov511_exit(void)
5993 {
5994 usb_deregister(&ov511_driver);
5995 printk(KERN_INFO KBUILD_MODNAME ": driver deregistered\n");
5996 }
5997
5998 module_init(usb_ov511_init);
5999 module_exit(usb_ov511_exit);
6000
Linux with added FPC-III support