V4L/DVB (13553): v4l: Use the video_is_registered function in device drivers
[linux-2.6.git] / drivers / media / video / ov511.c
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         .minor =        -1,
4678 };
4679
4680 /****************************************************************************
4681  *
4682  * OV511 and sensor configuration
4683  *
4684  ***************************************************************************/
4685
4686 /* This initializes the OV7610, OV7620, or OV76BE sensor. The OV76BE uses
4687  * the same register settings as the OV7610, since they are very similar.
4688  */
4689 static int
4690 ov7xx0_configure(struct usb_ov511 *ov)
4691 {
4692         int i, success;
4693         int rc;
4694
4695         /* Lawrence Glaister <lg@jfm.bc.ca> reports:
4696          *
4697          * Register 0x0f in the 7610 has the following effects:
4698          *
4699          * 0x85 (AEC method 1): Best overall, good contrast range
4700          * 0x45 (AEC method 2): Very overexposed
4701          * 0xa5 (spec sheet default): Ok, but the black level is
4702          *      shifted resulting in loss of contrast
4703          * 0x05 (old driver setting): very overexposed, too much
4704          *      contrast
4705          */
4706         static struct ov511_regvals aRegvalsNorm7610[] = {
4707                 { OV511_I2C_BUS, 0x10, 0xff },
4708                 { OV511_I2C_BUS, 0x16, 0x06 },
4709                 { OV511_I2C_BUS, 0x28, 0x24 },
4710                 { OV511_I2C_BUS, 0x2b, 0xac },
4711                 { OV511_I2C_BUS, 0x12, 0x00 },
4712                 { OV511_I2C_BUS, 0x38, 0x81 },
4713                 { OV511_I2C_BUS, 0x28, 0x24 },  /* 0c */
4714                 { OV511_I2C_BUS, 0x0f, 0x85 },  /* lg's setting */
4715                 { OV511_I2C_BUS, 0x15, 0x01 },
4716                 { OV511_I2C_BUS, 0x20, 0x1c },
4717                 { OV511_I2C_BUS, 0x23, 0x2a },
4718                 { OV511_I2C_BUS, 0x24, 0x10 },
4719                 { OV511_I2C_BUS, 0x25, 0x8a },
4720                 { OV511_I2C_BUS, 0x26, 0xa2 },
4721                 { OV511_I2C_BUS, 0x27, 0xc2 },
4722                 { OV511_I2C_BUS, 0x2a, 0x04 },
4723                 { OV511_I2C_BUS, 0x2c, 0xfe },
4724                 { OV511_I2C_BUS, 0x2d, 0x93 },
4725                 { OV511_I2C_BUS, 0x30, 0x71 },
4726                 { OV511_I2C_BUS, 0x31, 0x60 },
4727                 { OV511_I2C_BUS, 0x32, 0x26 },
4728                 { OV511_I2C_BUS, 0x33, 0x20 },
4729                 { OV511_I2C_BUS, 0x34, 0x48 },
4730                 { OV511_I2C_BUS, 0x12, 0x24 },
4731                 { OV511_I2C_BUS, 0x11, 0x01 },
4732                 { OV511_I2C_BUS, 0x0c, 0x24 },
4733                 { OV511_I2C_BUS, 0x0d, 0x24 },
4734                 { OV511_DONE_BUS, 0x0, 0x00 },
4735         };
4736
4737         static struct ov511_regvals aRegvalsNorm7620[] = {
4738                 { OV511_I2C_BUS, 0x00, 0x00 },
4739                 { OV511_I2C_BUS, 0x01, 0x80 },
4740                 { OV511_I2C_BUS, 0x02, 0x80 },
4741                 { OV511_I2C_BUS, 0x03, 0xc0 },
4742                 { OV511_I2C_BUS, 0x06, 0x60 },
4743                 { OV511_I2C_BUS, 0x07, 0x00 },
4744                 { OV511_I2C_BUS, 0x0c, 0x24 },
4745                 { OV511_I2C_BUS, 0x0c, 0x24 },
4746                 { OV511_I2C_BUS, 0x0d, 0x24 },
4747                 { OV511_I2C_BUS, 0x11, 0x01 },
4748                 { OV511_I2C_BUS, 0x12, 0x24 },
4749                 { OV511_I2C_BUS, 0x13, 0x01 },
4750                 { OV511_I2C_BUS, 0x14, 0x84 },
4751                 { OV511_I2C_BUS, 0x15, 0x01 },
4752                 { OV511_I2C_BUS, 0x16, 0x03 },
4753                 { OV511_I2C_BUS, 0x17, 0x2f },
4754                 { OV511_I2C_BUS, 0x18, 0xcf },
4755                 { OV511_I2C_BUS, 0x19, 0x06 },
4756                 { OV511_I2C_BUS, 0x1a, 0xf5 },
4757                 { OV511_I2C_BUS, 0x1b, 0x00 },
4758                 { OV511_I2C_BUS, 0x20, 0x18 },
4759                 { OV511_I2C_BUS, 0x21, 0x80 },
4760                 { OV511_I2C_BUS, 0x22, 0x80 },
4761                 { OV511_I2C_BUS, 0x23, 0x00 },
4762                 { OV511_I2C_BUS, 0x26, 0xa2 },
4763                 { OV511_I2C_BUS, 0x27, 0xea },
4764                 { OV511_I2C_BUS, 0x28, 0x20 },
4765                 { OV511_I2C_BUS, 0x29, 0x00 },
4766                 { OV511_I2C_BUS, 0x2a, 0x10 },
4767                 { OV511_I2C_BUS, 0x2b, 0x00 },
4768                 { OV511_I2C_BUS, 0x2c, 0x88 },
4769                 { OV511_I2C_BUS, 0x2d, 0x91 },
4770                 { OV511_I2C_BUS, 0x2e, 0x80 },
4771                 { OV511_I2C_BUS, 0x2f, 0x44 },
4772                 { OV511_I2C_BUS, 0x60, 0x27 },
4773                 { OV511_I2C_BUS, 0x61, 0x02 },
4774                 { OV511_I2C_BUS, 0x62, 0x5f },
4775                 { OV511_I2C_BUS, 0x63, 0xd5 },
4776                 { OV511_I2C_BUS, 0x64, 0x57 },
4777                 { OV511_I2C_BUS, 0x65, 0x83 },
4778                 { OV511_I2C_BUS, 0x66, 0x55 },
4779                 { OV511_I2C_BUS, 0x67, 0x92 },
4780                 { OV511_I2C_BUS, 0x68, 0xcf },
4781                 { OV511_I2C_BUS, 0x69, 0x76 },
4782                 { OV511_I2C_BUS, 0x6a, 0x22 },
4783                 { OV511_I2C_BUS, 0x6b, 0x00 },
4784                 { OV511_I2C_BUS, 0x6c, 0x02 },
4785                 { OV511_I2C_BUS, 0x6d, 0x44 },
4786                 { OV511_I2C_BUS, 0x6e, 0x80 },
4787                 { OV511_I2C_BUS, 0x6f, 0x1d },
4788                 { OV511_I2C_BUS, 0x70, 0x8b },
4789                 { OV511_I2C_BUS, 0x71, 0x00 },
4790                 { OV511_I2C_BUS, 0x72, 0x14 },
4791                 { OV511_I2C_BUS, 0x73, 0x54 },
4792                 { OV511_I2C_BUS, 0x74, 0x00 },
4793                 { OV511_I2C_BUS, 0x75, 0x8e },
4794                 { OV511_I2C_BUS, 0x76, 0x00 },
4795                 { OV511_I2C_BUS, 0x77, 0xff },
4796                 { OV511_I2C_BUS, 0x78, 0x80 },
4797                 { OV511_I2C_BUS, 0x79, 0x80 },
4798                 { OV511_I2C_BUS, 0x7a, 0x80 },
4799                 { OV511_I2C_BUS, 0x7b, 0xe2 },
4800                 { OV511_I2C_BUS, 0x7c, 0x00 },
4801                 { OV511_DONE_BUS, 0x0, 0x00 },
4802         };
4803
4804         PDEBUG(4, "starting configuration");
4805
4806         /* This looks redundant, but is necessary for WebCam 3 */
4807         ov->primary_i2c_slave = OV7xx0_SID;
4808         if (ov51x_set_slave_ids(ov, OV7xx0_SID) < 0)
4809                 return -1;
4810
4811         if (init_ov_sensor(ov) >= 0) {
4812                 PDEBUG(1, "OV7xx0 sensor initalized (method 1)");
4813         } else {
4814                 /* Reset the 76xx */
4815                 if (i2c_w(ov, 0x12, 0x80) < 0)
4816                         return -1;
4817
4818                 /* Wait for it to initialize */
4819                 msleep(150);
4820
4821                 i = 0;
4822                 success = 0;
4823                 while (i <= i2c_detect_tries) {
4824                         if ((i2c_r(ov, OV7610_REG_ID_HIGH) == 0x7F) &&
4825                             (i2c_r(ov, OV7610_REG_ID_LOW) == 0xA2)) {
4826                                 success = 1;
4827                                 break;
4828                         } else {
4829                                 i++;
4830                         }
4831                 }
4832
4833 // Was (i == i2c_detect_tries) previously. This obviously used to always report
4834 // success. Whether anyone actually depended on that bug is unknown
4835                 if ((i >= i2c_detect_tries) && (success == 0)) {
4836                         err("Failed to read sensor ID. You might not have an");
4837                         err("OV7610/20, or it may be not responding. Report");
4838                         err("this to " EMAIL);
4839                         err("This is only a warning. You can attempt to use");
4840                         err("your camera anyway");
4841 // Only issue a warning for now
4842 //                      return -1;
4843                 } else {
4844                         PDEBUG(1, "OV7xx0 initialized (method 2, %dx)", i+1);
4845                 }
4846         }
4847
4848         /* Detect sensor (sub)type */
4849         rc = i2c_r(ov, OV7610_REG_COM_I);
4850
4851         if (rc < 0) {
4852                 err("Error detecting sensor type");
4853                 return -1;
4854         } else if ((rc & 3) == 3) {
4855                 dev_info(&ov->dev->dev, "Sensor is an OV7610\n");
4856                 ov->sensor = SEN_OV7610;
4857         } else if ((rc & 3) == 1) {
4858                 /* I don't know what's different about the 76BE yet. */
4859                 if (i2c_r(ov, 0x15) & 1)
4860                         dev_info(&ov->dev->dev, "Sensor is an OV7620AE\n");
4861                 else
4862                         dev_info(&ov->dev->dev, "Sensor is an OV76BE\n");
4863
4864                 /* OV511+ will return all zero isoc data unless we
4865                  * configure the sensor as a 7620. Someone needs to
4866                  * find the exact reg. setting that causes this. */
4867                 if (ov->bridge == BRG_OV511PLUS) {
4868                         dev_info(&ov->dev->dev,
4869                                  "Enabling 511+/7620AE workaround\n");
4870                         ov->sensor = SEN_OV7620;
4871                 } else {
4872                         ov->sensor = SEN_OV76BE;
4873                 }
4874         } else if ((rc & 3) == 0) {
4875                 dev_info(&ov->dev->dev, "Sensor is an OV7620\n");
4876                 ov->sensor = SEN_OV7620;
4877         } else {
4878                 err("Unknown image sensor version: %d", rc & 3);
4879                 return -1;
4880         }
4881
4882         if (ov->sensor == SEN_OV7620) {
4883                 PDEBUG(4, "Writing 7620 registers");
4884                 if (write_regvals(ov, aRegvalsNorm7620))
4885                         return -1;
4886         } else {
4887                 PDEBUG(4, "Writing 7610 registers");
4888                 if (write_regvals(ov, aRegvalsNorm7610))
4889                         return -1;
4890         }
4891
4892         /* Set sensor-specific vars */
4893         ov->maxwidth = 640;
4894         ov->maxheight = 480;
4895         ov->minwidth = 64;
4896         ov->minheight = 48;
4897
4898         // FIXME: These do not match the actual settings yet
4899         ov->brightness = 0x80 << 8;
4900         ov->contrast = 0x80 << 8;
4901         ov->colour = 0x80 << 8;
4902         ov->hue = 0x80 << 8;
4903
4904         return 0;
4905 }
4906
4907 /* This initializes the OV6620, OV6630, OV6630AE, or OV6630AF sensor. */
4908 static int
4909 ov6xx0_configure(struct usb_ov511 *ov)
4910 {
4911         int rc;
4912
4913         static struct ov511_regvals aRegvalsNorm6x20[] = {
4914                 { OV511_I2C_BUS, 0x12, 0x80 }, /* reset */
4915                 { OV511_I2C_BUS, 0x11, 0x01 },
4916                 { OV511_I2C_BUS, 0x03, 0x60 },
4917                 { OV511_I2C_BUS, 0x05, 0x7f }, /* For when autoadjust is off */
4918                 { OV511_I2C_BUS, 0x07, 0xa8 },
4919                 /* The ratio of 0x0c and 0x0d  controls the white point */
4920                 { OV511_I2C_BUS, 0x0c, 0x24 },
4921                 { OV511_I2C_BUS, 0x0d, 0x24 },
4922                 { OV511_I2C_BUS, 0x0f, 0x15 }, /* COMS */
4923                 { OV511_I2C_BUS, 0x10, 0x75 }, /* AEC Exposure time */
4924                 { OV511_I2C_BUS, 0x12, 0x24 }, /* Enable AGC */
4925                 { OV511_I2C_BUS, 0x14, 0x04 },
4926                 /* 0x16: 0x06 helps frame stability with moving objects */
4927                 { OV511_I2C_BUS, 0x16, 0x06 },
4928 //              { OV511_I2C_BUS, 0x20, 0x30 }, /* Aperture correction enable */
4929                 { OV511_I2C_BUS, 0x26, 0xb2 }, /* BLC enable */
4930                 /* 0x28: 0x05 Selects RGB format if RGB on */
4931                 { OV511_I2C_BUS, 0x28, 0x05 },
4932                 { OV511_I2C_BUS, 0x2a, 0x04 }, /* Disable framerate adjust */
4933 //              { OV511_I2C_BUS, 0x2b, 0xac }, /* Framerate; Set 2a[7] first */
4934                 { OV511_I2C_BUS, 0x2d, 0x99 },
4935                 { OV511_I2C_BUS, 0x33, 0xa0 }, /* Color Processing Parameter */
4936                 { OV511_I2C_BUS, 0x34, 0xd2 }, /* Max A/D range */
4937                 { OV511_I2C_BUS, 0x38, 0x8b },
4938                 { OV511_I2C_BUS, 0x39, 0x40 },
4939
4940                 { OV511_I2C_BUS, 0x3c, 0x39 }, /* Enable AEC mode changing */
4941                 { OV511_I2C_BUS, 0x3c, 0x3c }, /* Change AEC mode */
4942                 { OV511_I2C_BUS, 0x3c, 0x24 }, /* Disable AEC mode changing */
4943
4944                 { OV511_I2C_BUS, 0x3d, 0x80 },
4945                 /* These next two registers (0x4a, 0x4b) are undocumented. They
4946                  * control the color balance */
4947                 { OV511_I2C_BUS, 0x4a, 0x80 },
4948                 { OV511_I2C_BUS, 0x4b, 0x80 },
4949                 { OV511_I2C_BUS, 0x4d, 0xd2 }, /* This reduces noise a bit */
4950                 { OV511_I2C_BUS, 0x4e, 0xc1 },
4951                 { OV511_I2C_BUS, 0x4f, 0x04 },
4952 // Do 50-53 have any effect?
4953 // Toggle 0x12[2] off and on here?
4954                 { OV511_DONE_BUS, 0x0, 0x00 },  /* END MARKER */
4955         };
4956
4957         static struct ov511_regvals aRegvalsNorm6x30[] = {
4958         /*OK*/  { OV511_I2C_BUS, 0x12, 0x80 }, /* reset */
4959                 { OV511_I2C_BUS, 0x11, 0x00 },
4960         /*OK*/  { OV511_I2C_BUS, 0x03, 0x60 },
4961         /*0A?*/ { OV511_I2C_BUS, 0x05, 0x7f }, /* For when autoadjust is off */
4962                 { OV511_I2C_BUS, 0x07, 0xa8 },
4963                 /* The ratio of 0x0c and 0x0d  controls the white point */
4964         /*OK*/  { OV511_I2C_BUS, 0x0c, 0x24 },
4965         /*OK*/  { OV511_I2C_BUS, 0x0d, 0x24 },
4966         /*A*/   { OV511_I2C_BUS, 0x0e, 0x20 },
4967 //      /*04?*/ { OV511_I2C_BUS, 0x14, 0x80 },
4968                 { OV511_I2C_BUS, 0x16, 0x03 },
4969 //      /*OK*/  { OV511_I2C_BUS, 0x20, 0x30 }, /* Aperture correction enable */
4970                 // 21 & 22? The suggested values look wrong. Go with default
4971         /*A*/   { OV511_I2C_BUS, 0x23, 0xc0 },
4972         /*A*/   { OV511_I2C_BUS, 0x25, 0x9a }, // Check this against default
4973 //      /*OK*/  { OV511_I2C_BUS, 0x26, 0xb2 }, /* BLC enable */
4974
4975                 /* 0x28: 0x05 Selects RGB format if RGB on */
4976 //      /*04?*/ { OV511_I2C_BUS, 0x28, 0x05 },
4977 //      /*04?*/ { OV511_I2C_BUS, 0x28, 0x45 }, // DEBUG: Tristate UV bus
4978
4979         /*OK*/  { OV511_I2C_BUS, 0x2a, 0x04 }, /* Disable framerate adjust */
4980 //      /*OK*/  { OV511_I2C_BUS, 0x2b, 0xac }, /* Framerate; Set 2a[7] first */
4981                 { OV511_I2C_BUS, 0x2d, 0x99 },
4982 //      /*A*/   { OV511_I2C_BUS, 0x33, 0x26 }, // Reserved bits on 6620
4983 //      /*d2?*/ { OV511_I2C_BUS, 0x34, 0x03 }, /* Max A/D range */
4984 //      /*8b?*/ { OV511_I2C_BUS, 0x38, 0x83 },
4985 //      /*40?*/ { OV511_I2C_BUS, 0x39, 0xc0 }, // 6630 adds bit 7
4986 //              { OV511_I2C_BUS, 0x3c, 0x39 }, /* Enable AEC mode changing */
4987 //              { OV511_I2C_BUS, 0x3c, 0x3c }, /* Change AEC mode */
4988 //              { OV511_I2C_BUS, 0x3c, 0x24 }, /* Disable AEC mode changing */
4989                 { OV511_I2C_BUS, 0x3d, 0x80 },
4990 //      /*A*/   { OV511_I2C_BUS, 0x3f, 0x0e },
4991
4992                 /* These next two registers (0x4a, 0x4b) are undocumented. They
4993                  * control the color balance */
4994 //      /*OK?*/ { OV511_I2C_BUS, 0x4a, 0x80 }, // Check these
4995 //      /*OK?*/ { OV511_I2C_BUS, 0x4b, 0x80 },
4996                 { OV511_I2C_BUS, 0x4d, 0x10 }, /* U = 0.563u, V = 0.714v */
4997         /*c1?*/ { OV511_I2C_BUS, 0x4e, 0x40 },
4998
4999                 /* UV average mode, color killer: strongest */
5000                 { OV511_I2C_BUS, 0x4f, 0x07 },
5001
5002                 { OV511_I2C_BUS, 0x54, 0x23 }, /* Max AGC gain: 18dB */
5003                 { OV511_I2C_BUS, 0x57, 0x81 }, /* (default) */
5004                 { OV511_I2C_BUS, 0x59, 0x01 }, /* AGC dark current comp: +1 */
5005                 { OV511_I2C_BUS, 0x5a, 0x2c }, /* (undocumented) */
5006                 { OV511_I2C_BUS, 0x5b, 0x0f }, /* AWB chrominance levels */
5007 //              { OV511_I2C_BUS, 0x5c, 0x10 },
5008                 { OV511_DONE_BUS, 0x0, 0x00 },  /* END MARKER */
5009         };
5010
5011         PDEBUG(4, "starting sensor configuration");
5012
5013         if (init_ov_sensor(ov) < 0) {
5014                 err("Failed to read sensor ID. You might not have an OV6xx0,");
5015                 err("or it may be not responding. Report this to " EMAIL);
5016                 return -1;
5017         } else {
5018                 PDEBUG(1, "OV6xx0 sensor detected");
5019         }
5020
5021         /* Detect sensor (sub)type */
5022         rc = i2c_r(ov, OV7610_REG_COM_I);
5023
5024         if (rc < 0) {
5025                 err("Error detecting sensor type");
5026                 return -1;
5027         }
5028
5029         if ((rc & 3) == 0) {
5030                 ov->sensor = SEN_OV6630;
5031                 dev_info(&ov->dev->dev, "Sensor is an OV6630\n");
5032         } else if ((rc & 3) == 1) {
5033                 ov->sensor = SEN_OV6620;
5034                 dev_info(&ov->dev->dev, "Sensor is an OV6620\n");
5035         } else if ((rc & 3) == 2) {
5036                 ov->sensor = SEN_OV6630;
5037                 dev_info(&ov->dev->dev, "Sensor is an OV6630AE\n");
5038         } else if ((rc & 3) == 3) {
5039                 ov->sensor = SEN_OV6630;
5040                 dev_info(&ov->dev->dev, "Sensor is an OV6630AF\n");
5041         }
5042
5043         /* Set sensor-specific vars */
5044         ov->maxwidth = 352;
5045         ov->maxheight = 288;
5046         ov->minwidth = 64;
5047         ov->minheight = 48;
5048
5049         // FIXME: These do not match the actual settings yet
5050         ov->brightness = 0x80 << 8;
5051         ov->contrast = 0x80 << 8;
5052         ov->colour = 0x80 << 8;
5053         ov->hue = 0x80 << 8;
5054
5055         if (ov->sensor == SEN_OV6620) {
5056                 PDEBUG(4, "Writing 6x20 registers");
5057                 if (write_regvals(ov, aRegvalsNorm6x20))
5058                         return -1;
5059         } else {
5060                 PDEBUG(4, "Writing 6x30 registers");
5061                 if (write_regvals(ov, aRegvalsNorm6x30))
5062                         return -1;
5063         }
5064
5065         return 0;
5066 }
5067
5068 /* This initializes the KS0127 and KS0127B video decoders. */
5069 static int
5070 ks0127_configure(struct usb_ov511 *ov)
5071 {
5072         int rc;
5073
5074 // FIXME: I don't know how to sync or reset it yet
5075 #if 0
5076         if (ov51x_init_ks_sensor(ov) < 0) {
5077                 err("Failed to initialize the KS0127");
5078                 return -1;
5079         } else {
5080                 PDEBUG(1, "KS012x(B) sensor detected");
5081         }
5082 #endif
5083
5084         /* Detect decoder subtype */
5085         rc = i2c_r(ov, 0x00);
5086         if (rc < 0) {
5087                 err("Error detecting sensor type");
5088                 return -1;
5089         } else if (rc & 0x08) {
5090                 rc = i2c_r(ov, 0x3d);
5091                 if (rc < 0) {
5092                         err("Error detecting sensor type");
5093                         return -1;
5094                 } else if ((rc & 0x0f) == 0) {
5095                         dev_info(&ov->dev->dev, "Sensor is a KS0127\n");
5096                         ov->sensor = SEN_KS0127;
5097                 } else if ((rc & 0x0f) == 9) {
5098                         dev_info(&ov->dev->dev, "Sensor is a KS0127B Rev. A\n");
5099                         ov->sensor = SEN_KS0127B;
5100                 }
5101         } else {
5102                 err("Error: Sensor is an unsupported KS0122");
5103                 return -1;
5104         }
5105
5106         /* Set sensor-specific vars */
5107         ov->maxwidth = 640;
5108         ov->maxheight = 480;
5109         ov->minwidth = 64;
5110         ov->minheight = 48;
5111
5112         // FIXME: These do not match the actual settings yet
5113         ov->brightness = 0x80 << 8;
5114         ov->contrast = 0x80 << 8;
5115         ov->colour = 0x80 << 8;
5116         ov->hue = 0x80 << 8;
5117
5118         /* This device is not supported yet. Bail out now... */
5119         err("This sensor is not supported yet.");
5120         return -1;
5121
5122         return 0;
5123 }
5124
5125 /* This initializes the SAA7111A video decoder. */
5126 static int
5127 saa7111a_configure(struct usb_ov511 *ov)
5128 {
5129         int rc;
5130
5131         /* Since there is no register reset command, all registers must be
5132          * written, otherwise gives erratic results */
5133         static struct ov511_regvals aRegvalsNormSAA7111A[] = {
5134                 { OV511_I2C_BUS, 0x06, 0xce },
5135                 { OV511_I2C_BUS, 0x07, 0x00 },
5136                 { OV511_I2C_BUS, 0x10, 0x44 }, /* YUV422, 240/286 lines */
5137                 { OV511_I2C_BUS, 0x0e, 0x01 }, /* NTSC M or PAL BGHI */
5138                 { OV511_I2C_BUS, 0x00, 0x00 },
5139                 { OV511_I2C_BUS, 0x01, 0x00 },
5140                 { OV511_I2C_BUS, 0x03, 0x23 },
5141                 { OV511_I2C_BUS, 0x04, 0x00 },
5142                 { OV511_I2C_BUS, 0x05, 0x00 },
5143                 { OV511_I2C_BUS, 0x08, 0xc8 }, /* Auto field freq */
5144                 { OV511_I2C_BUS, 0x09, 0x01 }, /* Chrom. trap off, APER=0.25 */
5145                 { OV511_I2C_BUS, 0x0a, 0x80 }, /* BRIG=128 */
5146                 { OV511_I2C_BUS, 0x0b, 0x40 }, /* CONT=1.0 */
5147                 { OV511_I2C_BUS, 0x0c, 0x40 }, /* SATN=1.0 */
5148                 { OV511_I2C_BUS, 0x0d, 0x00 }, /* HUE=0 */
5149                 { OV511_I2C_BUS, 0x0f, 0x00 },
5150                 { OV511_I2C_BUS, 0x11, 0x0c },
5151                 { OV511_I2C_BUS, 0x12, 0x00 },
5152                 { OV511_I2C_BUS, 0x13, 0x00 },
5153                 { OV511_I2C_BUS, 0x14, 0x00 },
5154                 { OV511_I2C_BUS, 0x15, 0x00 },
5155                 { OV511_I2C_BUS, 0x16, 0x00 },
5156                 { OV511_I2C_BUS, 0x17, 0x00 },
5157                 { OV511_I2C_BUS, 0x02, 0xc0 },  /* Composite input 0 */
5158                 { OV511_DONE_BUS, 0x0, 0x00 },
5159         };
5160
5161 // FIXME: I don't know how to sync or reset it yet
5162 #if 0
5163         if (ov51x_init_saa_sensor(ov) < 0) {
5164                 err("Failed to initialize the SAA7111A");
5165                 return -1;
5166         } else {
5167                 PDEBUG(1, "SAA7111A sensor detected");
5168         }
5169 #endif
5170
5171         /* 640x480 not supported with PAL */
5172         if (ov->pal) {
5173                 ov->maxwidth = 320;
5174                 ov->maxheight = 240;            /* Even field only */
5175         } else {
5176                 ov->maxwidth = 640;
5177                 ov->maxheight = 480;            /* Even/Odd fields */
5178         }
5179
5180         ov->minwidth = 320;
5181         ov->minheight = 240;            /* Even field only */
5182
5183         ov->has_decoder = 1;
5184         ov->num_inputs = 8;
5185         ov->norm = VIDEO_MODE_AUTO;
5186         ov->stop_during_set = 0;        /* Decoder guarantees stable image */
5187
5188         /* Decoder doesn't change these values, so we use these instead of
5189          * acutally reading the registers (which doesn't work) */
5190         ov->brightness = 0x80 << 8;
5191         ov->contrast = 0x40 << 9;
5192         ov->colour = 0x40 << 9;
5193         ov->hue = 32768;
5194
5195         PDEBUG(4, "Writing SAA7111A registers");
5196         if (write_regvals(ov, aRegvalsNormSAA7111A))
5197                 return -1;
5198
5199         /* Detect version of decoder. This must be done after writing the
5200          * initial regs or the decoder will lock up. */
5201         rc = i2c_r(ov, 0x00);
5202
5203         if (rc < 0) {
5204                 err("Error detecting sensor version");
5205                 return -1;
5206         } else {
5207                 dev_info(&ov->dev->dev,
5208                          "Sensor is an SAA7111A (version 0x%x)\n", rc);
5209                 ov->sensor = SEN_SAA7111A;
5210         }
5211
5212         // FIXME: Fix this for OV518(+)
5213         /* Latch to negative edge of clock. Otherwise, we get incorrect
5214          * colors and jitter in the digital signal. */
5215         if (ov->bclass == BCL_OV511)
5216                 reg_w(ov, 0x11, 0x00);
5217         else
5218                 dev_warn(&ov->dev->dev,
5219                          "SAA7111A not yet supported with OV518/OV518+\n");
5220
5221         return 0;
5222 }
5223
5224 /* This initializes the OV511/OV511+ and the sensor */
5225 static int
5226 ov511_configure(struct usb_ov511 *ov)
5227 {
5228         static struct ov511_regvals aRegvalsInit511[] = {
5229                 { OV511_REG_BUS, R51x_SYS_RESET,        0x7f },
5230                 { OV511_REG_BUS, R51x_SYS_INIT,         0x01 },
5231                 { OV511_REG_BUS, R51x_SYS_RESET,        0x7f },
5232                 { OV511_REG_BUS, R51x_SYS_INIT,         0x01 },
5233                 { OV511_REG_BUS, R51x_SYS_RESET,        0x3f },
5234                 { OV511_REG_BUS, R51x_SYS_INIT,         0x01 },
5235                 { OV511_REG_BUS, R51x_SYS_RESET,        0x3d },
5236                 { OV511_DONE_BUS, 0x0, 0x00},
5237         };
5238
5239         static struct ov511_regvals aRegvalsNorm511[] = {
5240                 { OV511_REG_BUS, R511_DRAM_FLOW_CTL,    0x01 },
5241                 { OV511_REG_BUS, R51x_SYS_SNAP,         0x00 },
5242                 { OV511_REG_BUS, R51x_SYS_SNAP,         0x02 },
5243                 { OV511_REG_BUS, R51x_SYS_SNAP,         0x00 },
5244                 { OV511_REG_BUS, R511_FIFO_OPTS,        0x1f },
5245                 { OV511_REG_BUS, R511_COMP_EN,          0x00 },
5246                 { OV511_REG_BUS, R511_COMP_LUT_EN,      0x03 },
5247                 { OV511_DONE_BUS, 0x0, 0x00 },
5248         };
5249
5250         static struct ov511_regvals aRegvalsNorm511Plus[] = {
5251                 { OV511_REG_BUS, R511_DRAM_FLOW_CTL,    0xff },
5252                 { OV511_REG_BUS, R51x_SYS_SNAP,         0x00 },
5253                 { OV511_REG_BUS, R51x_SYS_SNAP,         0x02 },
5254                 { OV511_REG_BUS, R51x_SYS_SNAP,         0x00 },
5255                 { OV511_REG_BUS, R511_FIFO_OPTS,        0xff },
5256                 { OV511_REG_BUS, R511_COMP_EN,          0x00 },
5257                 { OV511_REG_BUS, R511_COMP_LUT_EN,      0x03 },
5258                 { OV511_DONE_BUS, 0x0, 0x00 },
5259         };
5260
5261         PDEBUG(4, "");
5262
5263         ov->customid = reg_r(ov, R511_SYS_CUST_ID);
5264         if (ov->customid < 0) {
5265                 err("Unable to read camera bridge registers");
5266                 goto error;
5267         }
5268
5269         PDEBUG (1, "CustomID = %d", ov->customid);
5270         ov->desc = symbolic(camlist, ov->customid);
5271         dev_info(&ov->dev->dev, "model: %s\n", ov->desc);
5272
5273         if (0 == strcmp(ov->desc, NOT_DEFINED_STR)) {
5274                 err("Camera type (%d) not recognized", ov->customid);
5275                 err("Please notify " EMAIL " of the name,");
5276                 err("manufacturer, model, and this number of your camera.");
5277                 err("Also include the output of the detection process.");
5278         }
5279
5280         if (ov->customid == 70)         /* USB Life TV (PAL/SECAM) */
5281                 ov->pal = 1;
5282
5283         if (write_regvals(ov, aRegvalsInit511))
5284                 goto error;
5285
5286         if (ov->led_policy == LED_OFF || ov->led_policy == LED_AUTO)
5287                 ov51x_led_control(ov, 0);
5288
5289         /* The OV511+ has undocumented bits in the flow control register.
5290          * Setting it to 0xff fixes the corruption with moving objects. */
5291         if (ov->bridge == BRG_OV511) {
5292                 if (write_regvals(ov, aRegvalsNorm511))
5293                         goto error;
5294         } else if (ov->bridge == BRG_OV511PLUS) {
5295                 if (write_regvals(ov, aRegvalsNorm511Plus))
5296                         goto error;
5297         } else {
5298                 err("Invalid bridge");
5299         }
5300
5301         if (ov511_init_compression(ov))
5302                 goto error;
5303
5304         ov->packet_numbering = 1;
5305         ov511_set_packet_size(ov, 0);
5306
5307         ov->snap_enabled = snapshot;
5308
5309         /* Test for 7xx0 */
5310         PDEBUG(3, "Testing for 0V7xx0");
5311         ov->primary_i2c_slave = OV7xx0_SID;
5312         if (ov51x_set_slave_ids(ov, OV7xx0_SID) < 0)
5313                 goto error;
5314
5315         if (i2c_w(ov, 0x12, 0x80) < 0) {
5316                 /* Test for 6xx0 */
5317                 PDEBUG(3, "Testing for 0V6xx0");
5318                 ov->primary_i2c_slave = OV6xx0_SID;
5319                 if (ov51x_set_slave_ids(ov, OV6xx0_SID) < 0)
5320                         goto error;
5321
5322                 if (i2c_w(ov, 0x12, 0x80) < 0) {
5323                         /* Test for 8xx0 */
5324                         PDEBUG(3, "Testing for 0V8xx0");
5325                         ov->primary_i2c_slave = OV8xx0_SID;
5326                         if (ov51x_set_slave_ids(ov, OV8xx0_SID) < 0)
5327                                 goto error;
5328
5329                         if (i2c_w(ov, 0x12, 0x80) < 0) {
5330                                 /* Test for SAA7111A */
5331                                 PDEBUG(3, "Testing for SAA7111A");
5332                                 ov->primary_i2c_slave = SAA7111A_SID;
5333                                 if (ov51x_set_slave_ids(ov, SAA7111A_SID) < 0)
5334                                         goto error;
5335
5336                                 if (i2c_w(ov, 0x0d, 0x00) < 0) {
5337                                         /* Test for KS0127 */
5338                                         PDEBUG(3, "Testing for KS0127");
5339                                         ov->primary_i2c_slave = KS0127_SID;
5340                                         if (ov51x_set_slave_ids(ov, KS0127_SID) < 0)
5341                                                 goto error;
5342
5343                                         if (i2c_w(ov, 0x10, 0x00) < 0) {
5344                                                 err("Can't determine sensor slave IDs");
5345                                                 goto error;
5346                                         } else {
5347                                                 if (ks0127_configure(ov) < 0) {
5348                                                         err("Failed to configure KS0127");
5349                                                         goto error;
5350                                                 }
5351                                         }
5352                                 } else {
5353                                         if (saa7111a_configure(ov) < 0) {
5354                                                 err("Failed to configure SAA7111A");
5355                                                 goto error;
5356                                         }
5357                                 }
5358                         } else {
5359                                 err("Detected unsupported OV8xx0 sensor");
5360                                 goto error;
5361                         }
5362                 } else {
5363                         if (ov6xx0_configure(ov) < 0) {
5364                                 err("Failed to configure OV6xx0");
5365                                 goto error;
5366                         }
5367                 }
5368         } else {
5369                 if (ov7xx0_configure(ov) < 0) {
5370                         err("Failed to configure OV7xx0");
5371                         goto error;
5372                 }
5373         }
5374
5375         return 0;
5376
5377 error:
5378         err("OV511 Config failed");
5379
5380         return -EBUSY;
5381 }
5382
5383 /* This initializes the OV518/OV518+ and the sensor */
5384 static int
5385 ov518_configure(struct usb_ov511 *ov)
5386 {
5387         /* For 518 and 518+ */
5388         static struct ov511_regvals aRegvalsInit518[] = {
5389                 { OV511_REG_BUS, R51x_SYS_RESET,        0x40 },
5390                 { OV511_REG_BUS, R51x_SYS_INIT,         0xe1 },
5391                 { OV511_REG_BUS, R51x_SYS_RESET,        0x3e },
5392                 { OV511_REG_BUS, R51x_SYS_INIT,         0xe1 },
5393                 { OV511_REG_BUS, R51x_SYS_RESET,        0x00 },
5394                 { OV511_REG_BUS, R51x_SYS_INIT,         0xe1 },
5395                 { OV511_REG_BUS, 0x46,                  0x00 },
5396                 { OV511_REG_BUS, 0x5d,                  0x03 },
5397                 { OV511_DONE_BUS, 0x0, 0x00},
5398         };
5399
5400         static struct ov511_regvals aRegvalsNorm518[] = {
5401                 { OV511_REG_BUS, R51x_SYS_SNAP,         0x02 }, /* Reset */
5402                 { OV511_REG_BUS, R51x_SYS_SNAP,         0x01 }, /* Enable */
5403                 { OV511_REG_BUS, 0x31,                  0x0f },
5404                 { OV511_REG_BUS, 0x5d,                  0x03 },
5405                 { OV511_REG_BUS, 0x24,                  0x9f },
5406                 { OV511_REG_BUS, 0x25,                  0x90 },
5407                 { OV511_REG_BUS, 0x20,                  0x00 },
5408                 { OV511_REG_BUS, 0x51,                  0x04 },
5409                 { OV511_REG_BUS, 0x71,                  0x19 },
5410                 { OV511_DONE_BUS, 0x0, 0x00 },
5411         };
5412
5413         static struct ov511_regvals aRegvalsNorm518Plus[] = {
5414                 { OV511_REG_BUS, R51x_SYS_SNAP,         0x02 }, /* Reset */
5415                 { OV511_REG_BUS, R51x_SYS_SNAP,         0x01 }, /* Enable */
5416                 { OV511_REG_BUS, 0x31,                  0x0f },
5417                 { OV511_REG_BUS, 0x5d,                  0x03 },
5418                 { OV511_REG_BUS, 0x24,                  0x9f },
5419                 { OV511_REG_BUS, 0x25,                  0x90 },
5420                 { OV511_REG_BUS, 0x20,                  0x60 },
5421                 { OV511_REG_BUS, 0x51,                  0x02 },
5422                 { OV511_REG_BUS, 0x71,                  0x19 },
5423                 { OV511_REG_BUS, 0x40,                  0xff },
5424                 { OV511_REG_BUS, 0x41,                  0x42 },
5425                 { OV511_REG_BUS, 0x46,                  0x00 },
5426                 { OV511_REG_BUS, 0x33,                  0x04 },
5427                 { OV511_REG_BUS, 0x21,                  0x19 },
5428                 { OV511_REG_BUS, 0x3f,                  0x10 },
5429                 { OV511_DONE_BUS, 0x0, 0x00 },
5430         };
5431
5432         PDEBUG(4, "");
5433
5434         /* First 5 bits of custom ID reg are a revision ID on OV518 */
5435         dev_info(&ov->dev->dev, "Device revision %d\n",
5436                  0x1F & reg_r(ov, R511_SYS_CUST_ID));
5437
5438         /* Give it the default description */
5439         ov->desc = symbolic(camlist, 0);
5440
5441         if (write_regvals(ov, aRegvalsInit518))
5442                 goto error;
5443
5444         /* Set LED GPIO pin to output mode */
5445         if (reg_w_mask(ov, 0x57, 0x00, 0x02) < 0)
5446                 goto error;
5447
5448         /* LED is off by default with OV518; have to explicitly turn it on */
5449         if (ov->led_policy == LED_OFF || ov->led_policy == LED_AUTO)
5450                 ov51x_led_control(ov, 0);
5451         else
5452                 ov51x_led_control(ov, 1);
5453
5454         /* Don't require compression if dumppix is enabled; otherwise it's
5455          * required. OV518 has no uncompressed mode, to save RAM. */
5456         if (!dumppix && !ov->compress) {
5457                 ov->compress = 1;
5458                 dev_warn(&ov->dev->dev,
5459                          "Compression required with OV518...enabling\n");
5460         }
5461
5462         if (ov->bridge == BRG_OV518) {
5463                 if (write_regvals(ov, aRegvalsNorm518))
5464                         goto error;
5465         } else if (ov->bridge == BRG_OV518PLUS) {
5466                 if (write_regvals(ov, aRegvalsNorm518Plus))
5467                         goto error;
5468         } else {
5469                 err("Invalid bridge");
5470         }
5471
5472         if (reg_w(ov, 0x2f, 0x80) < 0)
5473                 goto error;
5474
5475         if (ov518_init_compression(ov))
5476                 goto error;
5477
5478         if (ov->bridge == BRG_OV518)
5479         {
5480                 struct usb_interface *ifp;
5481                 struct usb_host_interface *alt;
5482                 __u16 mxps = 0;
5483
5484                 ifp = usb_ifnum_to_if(ov->dev, 0);
5485                 if (ifp) {
5486                         alt = usb_altnum_to_altsetting(ifp, 7);
5487                         if (alt)
5488                                 mxps = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
5489                 }
5490
5491                 /* Some OV518s have packet numbering by default, some don't */
5492                 if (mxps == 897)
5493                         ov->packet_numbering = 1;
5494                 else
5495                         ov->packet_numbering = 0;
5496         } else {
5497                 /* OV518+ has packet numbering turned on by default */
5498                 ov->packet_numbering = 1;
5499         }
5500
5501         ov518_set_packet_size(ov, 0);
5502
5503         ov->snap_enabled = snapshot;
5504
5505         /* Test for 76xx */
5506         ov->primary_i2c_slave = OV7xx0_SID;
5507         if (ov51x_set_slave_ids(ov, OV7xx0_SID) < 0)
5508                 goto error;
5509
5510         /* The OV518 must be more aggressive about sensor detection since
5511          * I2C write will never fail if the sensor is not present. We have
5512          * to try to initialize the sensor to detect its presence */
5513
5514         if (init_ov_sensor(ov) < 0) {
5515                 /* Test for 6xx0 */
5516                 ov->primary_i2c_slave = OV6xx0_SID;
5517                 if (ov51x_set_slave_ids(ov, OV6xx0_SID) < 0)
5518                         goto error;
5519
5520                 if (init_ov_sensor(ov) < 0) {
5521                         /* Test for 8xx0 */
5522                         ov->primary_i2c_slave = OV8xx0_SID;
5523                         if (ov51x_set_slave_ids(ov, OV8xx0_SID) < 0)
5524                                 goto error;
5525
5526                         if (init_ov_sensor(ov) < 0) {
5527                                 err("Can't determine sensor slave IDs");
5528                                 goto error;
5529                         } else {
5530                                 err("Detected unsupported OV8xx0 sensor");
5531                                 goto error;
5532                         }
5533                 } else {
5534                         if (ov6xx0_configure(ov) < 0) {
5535                                 err("Failed to configure OV6xx0");
5536                                 goto error;
5537                         }
5538                 }
5539         } else {
5540                 if (ov7xx0_configure(ov) < 0) {
5541                         err("Failed to configure OV7xx0");
5542                         goto error;
5543                 }
5544         }
5545
5546         ov->maxwidth = 352;
5547         ov->maxheight = 288;
5548
5549         // The OV518 cannot go as low as the sensor can
5550         ov->minwidth = 160;
5551         ov->minheight = 120;
5552
5553         return 0;
5554
5555 error:
5556         err("OV518 Config failed");
5557
5558         return -EBUSY;
5559 }
5560
5561 /****************************************************************************
5562  *  sysfs
5563  ***************************************************************************/
5564
5565 static inline struct usb_ov511 *cd_to_ov(struct device *cd)
5566 {
5567         struct video_device *vdev = to_video_device(cd);
5568         return video_get_drvdata(vdev);
5569 }
5570
5571 static ssize_t show_custom_id(struct device *cd,
5572                               struct device_attribute *attr, char *buf)
5573 {
5574         struct usb_ov511 *ov = cd_to_ov(cd);
5575         return sprintf(buf, "%d\n", ov->customid);
5576 }
5577 static DEVICE_ATTR(custom_id, S_IRUGO, show_custom_id, NULL);
5578
5579 static ssize_t show_model(struct device *cd,
5580                           struct device_attribute *attr, char *buf)
5581 {
5582         struct usb_ov511 *ov = cd_to_ov(cd);
5583         return sprintf(buf, "%s\n", ov->desc);
5584 }
5585 static DEVICE_ATTR(model, S_IRUGO, show_model, NULL);
5586
5587 static ssize_t show_bridge(struct device *cd,
5588                            struct device_attribute *attr, char *buf)
5589 {
5590         struct usb_ov511 *ov = cd_to_ov(cd);
5591         return sprintf(buf, "%s\n", symbolic(brglist, ov->bridge));
5592 }
5593 static DEVICE_ATTR(bridge, S_IRUGO, show_bridge, NULL);
5594
5595 static ssize_t show_sensor(struct device *cd,
5596                            struct device_attribute *attr, char *buf)
5597 {
5598         struct usb_ov511 *ov = cd_to_ov(cd);
5599         return sprintf(buf, "%s\n", symbolic(senlist, ov->sensor));
5600 }
5601 static DEVICE_ATTR(sensor, S_IRUGO, show_sensor, NULL);
5602
5603 static ssize_t show_brightness(struct device *cd,
5604                                struct device_attribute *attr, char *buf)
5605 {
5606         struct usb_ov511 *ov = cd_to_ov(cd);
5607         unsigned short x;
5608
5609         if (!ov->dev)
5610                 return -ENODEV;
5611         sensor_get_brightness(ov, &x);
5612         return sprintf(buf, "%d\n", x >> 8);
5613 }
5614 static DEVICE_ATTR(brightness, S_IRUGO, show_brightness, NULL);
5615
5616 static ssize_t show_saturation(struct device *cd,
5617                                struct device_attribute *attr, char *buf)
5618 {
5619         struct usb_ov511 *ov = cd_to_ov(cd);
5620         unsigned short x;
5621
5622         if (!ov->dev)
5623                 return -ENODEV;
5624         sensor_get_saturation(ov, &x);
5625         return sprintf(buf, "%d\n", x >> 8);
5626 }
5627 static DEVICE_ATTR(saturation, S_IRUGO, show_saturation, NULL);
5628
5629 static ssize_t show_contrast(struct device *cd,
5630                              struct device_attribute *attr, char *buf)
5631 {
5632         struct usb_ov511 *ov = cd_to_ov(cd);
5633         unsigned short x;
5634
5635         if (!ov->dev)
5636                 return -ENODEV;
5637         sensor_get_contrast(ov, &x);
5638         return sprintf(buf, "%d\n", x >> 8);
5639 }
5640 static DEVICE_ATTR(contrast, S_IRUGO, show_contrast, NULL);
5641
5642 static ssize_t show_hue(struct device *cd,
5643                         struct device_attribute *attr, char *buf)
5644 {
5645         struct usb_ov511 *ov = cd_to_ov(cd);
5646         unsigned short x;
5647
5648         if (!ov->dev)
5649                 return -ENODEV;
5650         sensor_get_hue(ov, &x);
5651         return sprintf(buf, "%d\n", x >> 8);
5652 }
5653 static DEVICE_ATTR(hue, S_IRUGO, show_hue, NULL);
5654
5655 static ssize_t show_exposure(struct device *cd,
5656                              struct device_attribute *attr, char *buf)
5657 {
5658         struct usb_ov511 *ov = cd_to_ov(cd);
5659         unsigned char exp = 0;
5660
5661         if (!ov->dev)
5662                 return -ENODEV;
5663         sensor_get_exposure(ov, &exp);
5664         return sprintf(buf, "%d\n", exp);
5665 }
5666 static DEVICE_ATTR(exposure, S_IRUGO, show_exposure, NULL);
5667
5668 static int ov_create_sysfs(struct video_device *vdev)
5669 {
5670         int rc;
5671
5672         rc = device_create_file(&vdev->dev, &dev_attr_custom_id);
5673         if (rc) goto err;
5674         rc = device_create_file(&vdev->dev, &dev_attr_model);
5675         if (rc) goto err_id;
5676         rc = device_create_file(&vdev->dev, &dev_attr_bridge);
5677         if (rc) goto err_model;
5678         rc = device_create_file(&vdev->dev, &dev_attr_sensor);
5679         if (rc) goto err_bridge;
5680         rc = device_create_file(&vdev->dev, &dev_attr_brightness);
5681         if (rc) goto err_sensor;
5682         rc = device_create_file(&vdev->dev, &dev_attr_saturation);
5683         if (rc) goto err_bright;
5684         rc = device_create_file(&vdev->dev, &dev_attr_contrast);
5685         if (rc) goto err_sat;
5686         rc = device_create_file(&vdev->dev, &dev_attr_hue);
5687         if (rc) goto err_contrast;
5688         rc = device_create_file(&vdev->dev, &dev_attr_exposure);
5689         if (rc) goto err_hue;
5690
5691         return 0;
5692
5693 err_hue:
5694         device_remove_file(&vdev->dev, &dev_attr_hue);
5695 err_contrast:
5696         device_remove_file(&vdev->dev, &dev_attr_contrast);
5697 err_sat:
5698         device_remove_file(&vdev->dev, &dev_attr_saturation);
5699 err_bright:
5700         device_remove_file(&vdev->dev, &dev_attr_brightness);
5701 err_sensor:
5702         device_remove_file(&vdev->dev, &dev_attr_sensor);
5703 err_bridge:
5704         device_remove_file(&vdev->dev, &dev_attr_bridge);
5705 err_model:
5706         device_remove_file(&vdev->dev, &dev_attr_model);
5707 err_id:
5708         device_remove_file(&vdev->dev, &dev_attr_custom_id);
5709 err:
5710         return rc;
5711 }
5712
5713 /****************************************************************************
5714  *  USB routines
5715  ***************************************************************************/
5716
5717 static int
5718 ov51x_probe(struct usb_interface *intf, const struct usb_device_id *id)
5719 {
5720         struct usb_device *dev = interface_to_usbdev(intf);
5721         struct usb_interface_descriptor *idesc;
5722         struct usb_ov511 *ov;
5723         int i, rc, nr;
5724
5725         PDEBUG(1, "probing for device...");
5726
5727         /* We don't handle multi-config cameras */
5728         if (dev->descriptor.bNumConfigurations != 1)
5729                 return -ENODEV;
5730
5731         idesc = &intf->cur_altsetting->desc;
5732
5733         if (idesc->bInterfaceClass != 0xFF)
5734                 return -ENODEV;
5735         if (idesc->bInterfaceSubClass != 0x00)
5736                 return -ENODEV;
5737
5738         if ((ov = kzalloc(sizeof(*ov), GFP_KERNEL)) == NULL) {
5739                 err("couldn't kmalloc ov struct");
5740                 goto error_out;
5741         }
5742
5743         ov->dev = dev;
5744         ov->iface = idesc->bInterfaceNumber;
5745         ov->led_policy = led;
5746         ov->compress = compress;
5747         ov->lightfreq = lightfreq;
5748         ov->num_inputs = 1;        /* Video decoder init functs. change this */
5749         ov->stop_during_set = !fastset;
5750         ov->backlight = backlight;
5751         ov->mirror = mirror;
5752         ov->auto_brt = autobright;
5753         ov->auto_gain = autogain;
5754         ov->auto_exp = autoexp;
5755
5756         switch (le16_to_cpu(dev->descriptor.idProduct)) {
5757         case PROD_OV511:
5758                 ov->bridge = BRG_OV511;
5759                 ov->bclass = BCL_OV511;
5760                 break;
5761         case PROD_OV511PLUS:
5762                 ov->bridge = BRG_OV511PLUS;
5763                 ov->bclass = BCL_OV511;
5764                 break;
5765         case PROD_OV518:
5766                 ov->bridge = BRG_OV518;
5767                 ov->bclass = BCL_OV518;
5768                 break;
5769         case PROD_OV518PLUS:
5770                 ov->bridge = BRG_OV518PLUS;
5771                 ov->bclass = BCL_OV518;
5772                 break;
5773         case PROD_ME2CAM:
5774                 if (le16_to_cpu(dev->descriptor.idVendor) != VEND_MATTEL)
5775                         goto error;
5776                 ov->bridge = BRG_OV511PLUS;
5777                 ov->bclass = BCL_OV511;
5778                 break;
5779         default:
5780                 err("Unknown product ID 0x%04x", le16_to_cpu(dev->descriptor.idProduct));
5781                 goto error;
5782         }
5783
5784         dev_info(&intf->dev, "USB %s video device found\n",
5785                  symbolic(brglist, ov->bridge));
5786
5787         init_waitqueue_head(&ov->wq);
5788
5789         mutex_init(&ov->lock);  /* to 1 == available */
5790         mutex_init(&ov->buf_lock);
5791         mutex_init(&ov->i2c_lock);
5792         mutex_init(&ov->cbuf_lock);
5793
5794         ov->buf_state = BUF_NOT_ALLOCATED;
5795
5796         if (usb_make_path(dev, ov->usb_path, OV511_USB_PATH_LEN) < 0) {
5797                 err("usb_make_path error");
5798                 goto error;
5799         }
5800
5801         /* Allocate control transfer buffer. */
5802         /* Must be kmalloc()'ed, for DMA compatibility */
5803         ov->cbuf = kmalloc(OV511_CBUF_SIZE, GFP_KERNEL);
5804         if (!ov->cbuf)
5805                 goto error;
5806
5807         if (ov->bclass == BCL_OV518) {
5808                 if (ov518_configure(ov) < 0)
5809                         goto error;
5810         } else {
5811                 if (ov511_configure(ov) < 0)
5812                         goto error;
5813         }
5814
5815         for (i = 0; i < OV511_NUMFRAMES; i++) {
5816                 ov->frame[i].framenum = i;
5817                 init_waitqueue_head(&ov->frame[i].wq);
5818         }
5819
5820         for (i = 0; i < OV511_NUMSBUF; i++) {
5821                 ov->sbuf[i].ov = ov;
5822                 spin_lock_init(&ov->sbuf[i].lock);
5823                 ov->sbuf[i].n = i;
5824         }
5825
5826         /* Unnecessary? (This is done on open(). Need to make sure variables
5827          * are properly initialized without this before removing it, though). */
5828         if (ov51x_set_default_params(ov) < 0)
5829                 goto error;
5830
5831 #ifdef OV511_DEBUG
5832         if (dump_bridge) {
5833                 if (ov->bclass == BCL_OV511)
5834                         ov511_dump_regs(ov);
5835                 else
5836                         ov518_dump_regs(ov);
5837         }
5838 #endif
5839
5840         ov->vdev = video_device_alloc();
5841         if (!ov->vdev)
5842                 goto error;
5843
5844         memcpy(ov->vdev, &vdev_template, sizeof(*ov->vdev));
5845         ov->vdev->parent = &intf->dev;
5846         video_set_drvdata(ov->vdev, ov);
5847
5848         mutex_lock(&ov->lock);
5849
5850         /* Check to see next free device and mark as used */
5851         nr = find_first_zero_bit(&ov511_devused, OV511_MAX_UNIT_VIDEO);
5852
5853         /* Registers device */
5854         if (unit_video[nr] != 0)
5855                 rc = video_register_device(ov->vdev, VFL_TYPE_GRABBER,
5856                                            unit_video[nr]);
5857         else
5858                 rc = video_register_device(ov->vdev, VFL_TYPE_GRABBER, -1);
5859
5860         if (rc < 0) {
5861                 err("video_register_device failed");
5862                 mutex_unlock(&ov->lock);
5863                 goto error;
5864         }
5865
5866         /* Mark device as used */
5867         ov511_devused |= 1 << nr;
5868         ov->nr = nr;
5869
5870         dev_info(&intf->dev, "Device at %s registered to minor %d\n",
5871                  ov->usb_path, ov->vdev->minor);
5872
5873         usb_set_intfdata(intf, ov);
5874         if (ov_create_sysfs(ov->vdev)) {
5875                 err("ov_create_sysfs failed");
5876                 ov511_devused &= ~(1 << nr);
5877                 mutex_unlock(&ov->lock);
5878                 goto error;
5879         }
5880
5881         mutex_lock(&ov->lock);
5882
5883         return 0;
5884
5885 error:
5886         if (ov->vdev) {
5887                 if (!video_is_registered(ov->vdev))
5888                         video_device_release(ov->vdev);
5889                 else
5890                         video_unregister_device(ov->vdev);
5891                 ov->vdev = NULL;
5892         }
5893
5894         if (ov->cbuf) {
5895                 mutex_lock(&ov->cbuf_lock);
5896                 kfree(ov->cbuf);
5897                 ov->cbuf = NULL;
5898                 mutex_unlock(&ov->cbuf_lock);
5899         }
5900
5901         kfree(ov);
5902         ov = NULL;
5903
5904 error_out:
5905         err("Camera initialization failed");
5906         return -EIO;
5907 }
5908
5909 static void
5910 ov51x_disconnect(struct usb_interface *intf)
5911 {
5912         struct usb_ov511 *ov = usb_get_intfdata(intf);
5913         int n;
5914
5915         PDEBUG(3, "");
5916
5917         mutex_lock(&ov->lock);
5918         usb_set_intfdata (intf, NULL);
5919
5920         if (!ov) {
5921                 mutex_unlock(&ov->lock);
5922                 return;
5923         }
5924
5925         /* Free device number */
5926         ov511_devused &= ~(1 << ov->nr);
5927
5928         if (ov->vdev)
5929                 video_unregister_device(ov->vdev);
5930
5931         for (n = 0; n < OV511_NUMFRAMES; n++)
5932                 ov->frame[n].grabstate = FRAME_ERROR;
5933
5934         ov->curframe = -1;
5935
5936         /* This will cause the process to request another frame */
5937         for (n = 0; n < OV511_NUMFRAMES; n++)
5938                 wake_up_interruptible(&ov->frame[n].wq);
5939
5940         wake_up_interruptible(&ov->wq);
5941
5942         ov->streaming = 0;
5943         ov51x_unlink_isoc(ov);
5944         mutex_unlock(&ov->lock);
5945
5946         ov->dev = NULL;
5947
5948         /* Free the memory */
5949         if (ov && !ov->user) {
5950                 mutex_lock(&ov->cbuf_lock);
5951                 kfree(ov->cbuf);
5952                 ov->cbuf = NULL;
5953                 mutex_unlock(&ov->cbuf_lock);
5954
5955                 ov51x_dealloc(ov);
5956                 kfree(ov);
5957                 ov = NULL;
5958         }
5959
5960         PDEBUG(3, "Disconnect complete");
5961 }
5962
5963 static struct usb_driver ov511_driver = {
5964         .name =         "ov511",
5965         .id_table =     device_table,
5966         .probe =        ov51x_probe,
5967         .disconnect =   ov51x_disconnect
5968 };
5969
5970 /****************************************************************************
5971  *
5972  *  Module routines
5973  *
5974  ***************************************************************************/
5975
5976 static int __init
5977 usb_ov511_init(void)
5978 {
5979         int retval;
5980
5981         retval = usb_register(&ov511_driver);
5982         if (retval)
5983                 goto out;
5984
5985         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
5986                DRIVER_DESC "\n");
5987
5988 out:
5989         return retval;
5990 }
5991
5992 static void __exit
5993 usb_ov511_exit(void)
5994 {
5995         usb_deregister(&ov511_driver);
5996         printk(KERN_INFO KBUILD_MODNAME ": driver deregistered\n");
5997 }
5998
5999 module_init(usb_ov511_init);
6000 module_exit(usb_ov511_exit);
6001