drivers/usb/media/ov511.c

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