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