git.oblomov.eu Git - linux-2.6/blob - drivers/usb/media/w9968cf.c

   1 /***************************************************************************
   2  * Video4Linux driver for W996[87]CF JPEG USB Dual Mode Camera Chip.       *
   3  *                                                                         *
   4  * Copyright (C) 2002-2004 by Luca Risolia <luca.risolia@studio.unibo.it>  *
   5  *                                                                         *
   6  * - Memory management code from bttv driver by Ralph Metzler,             *
   7  *   Marcus Metzler and Gerd Knorr.                                        *
   8  * - I2C interface to kernel, high-level image sensor control routines and *
   9  *   some symbolic names from OV511 driver by Mark W. McClelland.          *
  10  * - Low-level I2C fast write function by Piotr Czerczak.                  *
  11  * - Low-level I2C read function by Frederic Jouault.                      *
  12  *                                                                         *
  13  * This program is free software; you can redistribute it and/or modify    *
  14  * it under the terms of the GNU General Public License as published by    *
  15  * the Free Software Foundation; either version 2 of the License, or       *
  16  * (at your option) any later version.                                     *
  17  *                                                                         *
  18  * This program is distributed in the hope that it will be useful,         *
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
  21  * GNU General Public License for more details.                            *
  22  *                                                                         *
  23  * You should have received a copy of the GNU General Public License       *
  24  * along with this program; if not, write to the Free Software             *
  25  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.               *
  26  ***************************************************************************/
  27
  28 #include <linux/module.h>
  29 #include <linux/kernel.h>
  30 #include <linux/kmod.h>
  31 #include <linux/init.h>
  32 #include <linux/fs.h>
  33 #include <linux/vmalloc.h>
  34 #include <linux/slab.h>
  35 #include <linux/mm.h>
  36 #include <linux/string.h>
  37 #include <linux/errno.h>
  38 #include <linux/sched.h>
  39 #include <linux/ioctl.h>
  40 #include <linux/delay.h>
  41 #include <linux/stddef.h>
  42 #include <asm/page.h>
  43 #include <asm/uaccess.h>
  44 #include <linux/page-flags.h>
  45 #include <linux/moduleparam.h>
  46
  47 #include "w9968cf.h"
  48 #include "w9968cf_decoder.h"
  49
  50
  51
  52 /****************************************************************************
  53  * Module macros and parameters                                             *
  54  ****************************************************************************/
  55
  56 MODULE_DEVICE_TABLE(usb, winbond_id_table);
  57
  58 MODULE_AUTHOR(W9968CF_MODULE_AUTHOR" "W9968CF_AUTHOR_EMAIL);
  59 MODULE_DESCRIPTION(W9968CF_MODULE_NAME);
  60 MODULE_VERSION(W9968CF_MODULE_VERSION);
  61 MODULE_LICENSE(W9968CF_MODULE_LICENSE);
  62 MODULE_SUPPORTED_DEVICE("Video");
  63
  64 static int ovmod_load = W9968CF_OVMOD_LOAD;
  65 static int vppmod_load = W9968CF_VPPMOD_LOAD;
  66 static unsigned short simcams = W9968CF_SIMCAMS;
  67 static short video_nr[]={[0 ... W9968CF_MAX_DEVICES-1] = -1}; /*-1=first free*/
  68 static unsigned int packet_size[] = {[0 ... W9968CF_MAX_DEVICES-1] =
  69                                      W9968CF_PACKET_SIZE};
  70 static unsigned short max_buffers[] = {[0 ... W9968CF_MAX_DEVICES-1] =
  71                                        W9968CF_BUFFERS};
  72 static int double_buffer[] = {[0 ... W9968CF_MAX_DEVICES-1] =
  73                               W9968CF_DOUBLE_BUFFER};
  74 static int clamping[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_CLAMPING};
  75 static unsigned short filter_type[]= {[0 ... W9968CF_MAX_DEVICES-1] =
  76                                       W9968CF_FILTER_TYPE};
  77 static int largeview[]= {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_LARGEVIEW};
  78 static unsigned short decompression[] = {[0 ... W9968CF_MAX_DEVICES-1] =
  79                                          W9968CF_DECOMPRESSION};
  80 static int upscaling[]= {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_UPSCALING};
  81 static unsigned short force_palette[] = {[0 ... W9968CF_MAX_DEVICES-1] = 0};
  82 static int force_rgb[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_FORCE_RGB};
  83 static int autobright[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_AUTOBRIGHT};
  84 static int autoexp[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_AUTOEXP};
  85 static unsigned short lightfreq[] = {[0 ... W9968CF_MAX_DEVICES-1] =
  86                                      W9968CF_LIGHTFREQ};
  87 static int bandingfilter[] = {[0 ... W9968CF_MAX_DEVICES-1]=
  88                               W9968CF_BANDINGFILTER};
  89 static short clockdiv[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_CLOCKDIV};
  90 static int backlight[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_BACKLIGHT};
  91 static int mirror[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_MIRROR};
  92 static int monochrome[] = {[0 ... W9968CF_MAX_DEVICES-1]=W9968CF_MONOCHROME};
  93 static unsigned int brightness[] = {[0 ... W9968CF_MAX_DEVICES-1] =
  94                                     W9968CF_BRIGHTNESS};
  95 static unsigned int hue[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_HUE};
  96 static unsigned int colour[]={[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_COLOUR};
  97 static unsigned int contrast[] = {[0 ... W9968CF_MAX_DEVICES-1] =
  98                                   W9968CF_CONTRAST};
  99 static unsigned int whiteness[] = {[0 ... W9968CF_MAX_DEVICES-1] =
 100                                    W9968CF_WHITENESS};
 101 #ifdef W9968CF_DEBUG
 102 static unsigned short debug = W9968CF_DEBUG_LEVEL;
 103 static int specific_debug = W9968CF_SPECIFIC_DEBUG;
 104 #endif
 105
 106 static unsigned int param_nv[24]; /* number of values per parameter */
 107
 108 #ifdef CONFIG_KMOD
 109 module_param(ovmod_load, bool, 0644);
 110 module_param(vppmod_load, bool, 0444);
 111 #endif
 112 module_param(simcams, ushort, 0644);
 113 module_param_array(video_nr, short, &param_nv[0], 0444);
 114 module_param_array(packet_size, uint, &param_nv[1], 0444);
 115 module_param_array(max_buffers, ushort, &param_nv[2], 0444);
 116 module_param_array(double_buffer, bool, &param_nv[3], 0444);
 117 module_param_array(clamping, bool, &param_nv[4], 0444);
 118 module_param_array(filter_type, ushort, &param_nv[5], 0444);
 119 module_param_array(largeview, bool, &param_nv[6], 0444);
 120 module_param_array(decompression, ushort, &param_nv[7], 0444);
 121 module_param_array(upscaling, bool, &param_nv[8], 0444);
 122 module_param_array(force_palette, ushort, &param_nv[9], 0444);
 123 module_param_array(force_rgb, ushort, &param_nv[10], 0444);
 124 module_param_array(autobright, bool, &param_nv[11], 0444);
 125 module_param_array(autoexp, bool, &param_nv[12], 0444);
 126 module_param_array(lightfreq, ushort, &param_nv[13], 0444);
 127 module_param_array(bandingfilter, bool, &param_nv[14], 0444);
 128 module_param_array(clockdiv, short, &param_nv[15], 0444);
 129 module_param_array(backlight, bool, &param_nv[16], 0444);
 130 module_param_array(mirror, bool, &param_nv[17], 0444);
 131 module_param_array(monochrome, bool, &param_nv[18], 0444);
 132 module_param_array(brightness, uint, &param_nv[19], 0444);
 133 module_param_array(hue, uint, &param_nv[20], 0444);
 134 module_param_array(colour, uint, &param_nv[21], 0444);
 135 module_param_array(contrast, uint, &param_nv[22], 0444);
 136 module_param_array(whiteness, uint, &param_nv[23], 0444);
 137 #ifdef W9968CF_DEBUG
 138 module_param(debug, ushort, 0644);
 139 module_param(specific_debug, bool, 0644);
 140 #endif
 141
 142 #ifdef CONFIG_KMOD
 143 MODULE_PARM_DESC(ovmod_load,
 144                  "\n<0|1> Automatic 'ovcamchip' module loading."
 145                  "\n0 disabled, 1 enabled."
 146                  "\nIf enabled,'insmod' searches for the required 'ovcamchip'"
 147                  "\nmodule in the system, according to its configuration, and"
 148                  "\nattempts to load that module automatically. This action is"
 149                  "\nperformed once as soon as the 'w9968cf' module is loaded"
 150                  "\ninto memory."
 151                  "\nDefault value is "__MODULE_STRING(W9968CF_OVMOD_LOAD)"."
 152                  "\n");
 153 MODULE_PARM_DESC(vppmod_load,
 154                  "\n<0|1> Automatic 'w9968cf-vpp' module loading."
 155                  "\n0 disabled, 1 enabled."
 156                  "\nIf enabled, every time an application attempts to open a"
 157                  "\ncamera, 'insmod' searches for the video post-processing"
 158                  "\nmodule in the system and loads it automatically (if"
 159                  "\npresent). The optional 'w9968cf-vpp' module adds extra"
 160                  "\n image manipulation functions to the 'w9968cf' module,like"
 161                  "\nsoftware up-scaling,colour conversions and video decoding"
 162                  "\nfor very high frame rates."
 163                  "\nDefault value is "__MODULE_STRING(W9968CF_VPPMOD_LOAD)"."
 164                  "\n");
 165 #endif
 166 MODULE_PARM_DESC(simcams,
 167                  "\n<n> Number of cameras allowed to stream simultaneously."
 168                  "\nn may vary from 0 to "
 169                  __MODULE_STRING(W9968CF_MAX_DEVICES)"."
 170                  "\nDefault value is "__MODULE_STRING(W9968CF_SIMCAMS)"."
 171                  "\n");
 172 MODULE_PARM_DESC(video_nr,
 173                  "\n<-1|n[,...]> Specify V4L minor mode number."
 174                  "\n -1 = use next available (default)"
 175                  "\n  n = use minor number n (integer >= 0)"
 176                  "\nYou can specify up to "__MODULE_STRING(W9968CF_MAX_DEVICES)
 177                  " cameras this way."
 178                  "\nFor example:"
 179                  "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
 180                  "\nthe second camera and use auto for the first"
 181                  "\none and for every other camera."
 182                  "\n");
 183 MODULE_PARM_DESC(packet_size,
 184                  "\n<n[,...]> Specify the maximum data payload"
 185                  "\nsize in bytes for alternate settings, for each device."
 186                  "\nn is scaled between 63 and 1023 "
 187                  "(default is "__MODULE_STRING(W9968CF_PACKET_SIZE)")."
 188                  "\n");
 189 MODULE_PARM_DESC(max_buffers,
 190                  "\n<n[,...]> For advanced users."
 191                  "\nSpecify the maximum number of video frame buffers"
 192                  "\nto allocate for each device, from 2 to "
 193                  __MODULE_STRING(W9968CF_MAX_BUFFERS)
 194                  ". (default is "__MODULE_STRING(W9968CF_BUFFERS)")."
 195                  "\n");
 196 MODULE_PARM_DESC(double_buffer,
 197                  "\n<0|1[,...]> "
 198                  "Hardware double buffering: 0 disabled, 1 enabled."
 199                  "\nIt should be enabled if you want smooth video output: if"
 200                  "\nyou obtain out of sync. video, disable it, or try to"
 201                  "\ndecrease the 'clockdiv' module parameter value."
 202                  "\nDefault value is "__MODULE_STRING(W9968CF_DOUBLE_BUFFER)
 203                  " for every device."
 204                  "\n");
 205 MODULE_PARM_DESC(clamping,
 206                  "\n<0|1[,...]> Video data clamping: 0 disabled, 1 enabled."
 207                  "\nDefault value is "__MODULE_STRING(W9968CF_CLAMPING)
 208                  " for every device."
 209                  "\n");
 210 MODULE_PARM_DESC(filter_type,
 211                  "\n<0|1|2[,...]> Video filter type."
 212                  "\n0 none, 1 (1-2-1) 3-tap filter, "
 213                  "2 (2-3-6-3-2) 5-tap filter."
 214                  "\nDefault value is "__MODULE_STRING(W9968CF_FILTER_TYPE)
 215                  " for every device."
 216                  "\nThe filter is used to reduce noise and aliasing artifacts"
 217                  "\nproduced by the CCD or CMOS image sensor, and the scaling"
 218                  " process."
 219                  "\n");
 220 MODULE_PARM_DESC(largeview,
 221                  "\n<0|1[,...]> Large view: 0 disabled, 1 enabled."
 222                  "\nDefault value is "__MODULE_STRING(W9968CF_LARGEVIEW)
 223                  " for every device."
 224                  "\n");
 225 MODULE_PARM_DESC(upscaling,
 226                  "\n<0|1[,...]> Software scaling (for non-compressed video):"
 227                  "\n0 disabled, 1 enabled."
 228                  "\nDisable it if you have a slow CPU or you don't have"
 229                  " enough memory."
 230                  "\nDefault value is "__MODULE_STRING(W9968CF_UPSCALING)
 231                  " for every device."
 232                  "\nIf 'w9968cf-vpp' is not present, this parameter is"
 233                  " set to 0."
 234                  "\n");
 235 MODULE_PARM_DESC(decompression,
 236                  "\n<0|1|2[,...]> Software video decompression:"
 237                  "\n- 0 disables decompression (doesn't allow formats needing"
 238                  " decompression)"
 239                  "\n- 1 forces decompression (allows formats needing"
 240                  " decompression only);"
 241                  "\n- 2 allows any permitted formats."
 242                  "\nFormats supporting compressed video are YUV422P and"
 243                  " YUV420P/YUV420 "
 244                  "\nin any resolutions where both width and height are "
 245                  "a multiple of 16."
 246                  "\nDefault value is "__MODULE_STRING(W9968CF_DECOMPRESSION)
 247                  " for every device."
 248                  "\nIf 'w9968cf-vpp' is not present, forcing decompression is "
 249                  "\nnot allowed; in this case this parameter is set to 2."
 250                  "\n");
 251 MODULE_PARM_DESC(force_palette,
 252                  "\n<0"
 253                  "|" __MODULE_STRING(VIDEO_PALETTE_UYVY)
 254                  "|" __MODULE_STRING(VIDEO_PALETTE_YUV420)
 255                  "|" __MODULE_STRING(VIDEO_PALETTE_YUV422P)
 256                  "|" __MODULE_STRING(VIDEO_PALETTE_YUV420P)
 257                  "|" __MODULE_STRING(VIDEO_PALETTE_YUYV)
 258                  "|" __MODULE_STRING(VIDEO_PALETTE_YUV422)
 259                  "|" __MODULE_STRING(VIDEO_PALETTE_GREY)
 260                  "|" __MODULE_STRING(VIDEO_PALETTE_RGB555)
 261                  "|" __MODULE_STRING(VIDEO_PALETTE_RGB565)
 262                  "|" __MODULE_STRING(VIDEO_PALETTE_RGB24)
 263                  "|" __MODULE_STRING(VIDEO_PALETTE_RGB32)
 264                  "[,...]>"
 265                  " Force picture palette."
 266                  "\nIn order:"
 267                  "\n- 0 allows any of the following formats:"
 268                  "\n- UYVY    16 bpp - Original video, compression disabled"
 269                  "\n- YUV420  12 bpp - Original video, compression enabled"
 270                  "\n- YUV422P 16 bpp - Original video, compression enabled"
 271                  "\n- YUV420P 12 bpp - Original video, compression enabled"
 272                  "\n- YUVY    16 bpp - Software conversion from UYVY"
 273                  "\n- YUV422  16 bpp - Software conversion from UYVY"
 274                  "\n- GREY     8 bpp - Software conversion from UYVY"
 275                  "\n- RGB555  16 bpp - Software conversion from UYVY"
 276                  "\n- RGB565  16 bpp - Software conversion from UYVY"
 277                  "\n- RGB24   24 bpp - Software conversion from UYVY"
 278                  "\n- RGB32   32 bpp - Software conversion from UYVY"
 279                  "\nWhen not 0, this parameter will override 'decompression'."
 280                  "\nDefault value is 0 for every device."
 281                  "\nInitial palette is "
 282                  __MODULE_STRING(W9968CF_PALETTE_DECOMP_ON)"."
 283                  "\nIf 'w9968cf-vpp' is not present, this parameter is"
 284                  " set to 9 (UYVY)."
 285                  "\n");
 286 MODULE_PARM_DESC(force_rgb,
 287                  "\n<0|1[,...]> Read RGB video data instead of BGR:"
 288                  "\n 1 = use RGB component ordering."
 289                  "\n 0 = use BGR component ordering."
 290                  "\nThis parameter has effect when using RGBX palettes only."
 291                  "\nDefault value is "__MODULE_STRING(W9968CF_FORCE_RGB)
 292                  " for every device."
 293                  "\n");
 294 MODULE_PARM_DESC(autobright,
 295                  "\n<0|1[,...]> Image sensor automatically changes brightness:"
 296                  "\n 0 = no, 1 = yes"
 297                  "\nDefault value is "__MODULE_STRING(W9968CF_AUTOBRIGHT)
 298                  " for every device."
 299                  "\n");
 300 MODULE_PARM_DESC(autoexp,
 301                  "\n<0|1[,...]> Image sensor automatically changes exposure:"
 302                  "\n 0 = no, 1 = yes"
 303                  "\nDefault value is "__MODULE_STRING(W9968CF_AUTOEXP)
 304                  " for every device."
 305                  "\n");
 306 MODULE_PARM_DESC(lightfreq,
 307                  "\n<50|60[,...]> Light frequency in Hz:"
 308                  "\n 50 for European and Asian lighting,"
 309                  " 60 for American lighting."
 310                  "\nDefault value is "__MODULE_STRING(W9968CF_LIGHTFREQ)
 311                  " for every device."
 312                  "\n");
 313 MODULE_PARM_DESC(bandingfilter,
 314                  "\n<0|1[,...]> Banding filter to reduce effects of"
 315                  " fluorescent lighting:"
 316                  "\n 0 disabled, 1 enabled."
 317                  "\nThis filter tries to reduce the pattern of horizontal"
 318                  "\nlight/dark bands caused by some (usually fluorescent)"
 319                  " lighting."
 320                  "\nDefault value is "__MODULE_STRING(W9968CF_BANDINGFILTER)
 321                  " for every device."
 322                  "\n");
 323 MODULE_PARM_DESC(clockdiv,
 324                  "\n<-1|n[,...]> "
 325                  "Force pixel clock divisor to a specific value (for experts):"
 326                  "\n  n may vary from 0 to 127."
 327                  "\n -1 for automatic value."
 328                  "\nSee also the 'double_buffer' module parameter."
 329                  "\nDefault value is "__MODULE_STRING(W9968CF_CLOCKDIV)
 330                  " for every device."
 331                  "\n");
 332 MODULE_PARM_DESC(backlight,
 333                  "\n<0|1[,...]> Objects are lit from behind:"
 334                  "\n 0 = no, 1 = yes"
 335                  "\nDefault value is "__MODULE_STRING(W9968CF_BACKLIGHT)
 336                  " for every device."
 337                  "\n");
 338 MODULE_PARM_DESC(mirror,
 339                  "\n<0|1[,...]> Reverse image horizontally:"
 340                  "\n 0 = no, 1 = yes"
 341                  "\nDefault value is "__MODULE_STRING(W9968CF_MIRROR)
 342                  " for every device."
 343                  "\n");
 344 MODULE_PARM_DESC(monochrome,
 345                  "\n<0|1[,...]> Use image sensor as monochrome sensor:"
 346                  "\n 0 = no, 1 = yes"
 347                  "\nNot all the sensors support monochrome color."
 348                  "\nDefault value is "__MODULE_STRING(W9968CF_MONOCHROME)
 349                  " for every device."
 350                  "\n");
 351 MODULE_PARM_DESC(brightness,
 352                  "\n<n[,...]> Set picture brightness (0-65535)."
 353                  "\nDefault value is "__MODULE_STRING(W9968CF_BRIGHTNESS)
 354                  " for every device."
 355                  "\nThis parameter has no effect if 'autobright' is enabled."
 356                  "\n");
 357 MODULE_PARM_DESC(hue,
 358                  "\n<n[,...]> Set picture hue (0-65535)."
 359                  "\nDefault value is "__MODULE_STRING(W9968CF_HUE)
 360                  " for every device."
 361                  "\n");
 362 MODULE_PARM_DESC(colour,
 363                  "\n<n[,...]> Set picture saturation (0-65535)."
 364                  "\nDefault value is "__MODULE_STRING(W9968CF_COLOUR)
 365                  " for every device."
 366                  "\n");
 367 MODULE_PARM_DESC(contrast,
 368                  "\n<n[,...]> Set picture contrast (0-65535)."
 369                  "\nDefault value is "__MODULE_STRING(W9968CF_CONTRAST)
 370                  " for every device."
 371                  "\n");
 372 MODULE_PARM_DESC(whiteness,
 373                  "\n<n[,...]> Set picture whiteness (0-65535)."
 374                  "\nDefault value is "__MODULE_STRING(W9968CF_WHITENESS)
 375                  " for every device."
 376                  "\n");
 377 #ifdef W9968CF_DEBUG
 378 MODULE_PARM_DESC(debug,
 379                  "\n<n> Debugging information level, from 0 to 6:"
 380                  "\n0 = none (use carefully)"
 381                  "\n1 = critical errors"
 382                  "\n2 = significant informations"
 383                  "\n3 = configuration or general messages"
 384                  "\n4 = warnings"
 385                  "\n5 = called functions"
 386                  "\n6 = function internals"
 387                  "\nLevel 5 and 6 are useful for testing only, when only "
 388                  "one device is used."
 389                  "\nDefault value is "__MODULE_STRING(W9968CF_DEBUG_LEVEL)"."
 390                  "\n");
 391 MODULE_PARM_DESC(specific_debug,
 392                  "\n<0|1> Enable or disable specific debugging messages:"
 393                  "\n0 = print messages concerning every level"
 394                  " <= 'debug' level."
 395                  "\n1 = print messages concerning the level"
 396                  " indicated by 'debug'."
 397                  "\nDefault value is "
 398                  __MODULE_STRING(W9968CF_SPECIFIC_DEBUG)"."
 399                  "\n");
 400 #endif /* W9968CF_DEBUG */
 401
 402
 403
 404 /****************************************************************************
 405  * Some prototypes                                                          *
 406  ****************************************************************************/
 407
 408 /* Video4linux interface */
 409 static struct file_operations w9968cf_fops;
 410 static int w9968cf_open(struct inode*, struct file*);
 411 static int w9968cf_release(struct inode*, struct file*);
 412 static int w9968cf_mmap(struct file*, struct vm_area_struct*);
 413 static int w9968cf_ioctl(struct inode*, struct file*, unsigned, unsigned long);
 414 static ssize_t w9968cf_read(struct file*, char __user *, size_t, loff_t*);
 415 static int w9968cf_v4l_ioctl(struct inode*, struct file*, unsigned int,
 416                              void __user *);
 417
 418 /* USB-specific */
 419 static int w9968cf_start_transfer(struct w9968cf_device*);
 420 static int w9968cf_stop_transfer(struct w9968cf_device*);
 421 static int w9968cf_write_reg(struct w9968cf_device*, u16 value, u16 index);
 422 static int w9968cf_read_reg(struct w9968cf_device*, u16 index);
 423 static int w9968cf_write_fsb(struct w9968cf_device*, u16* data);
 424 static int w9968cf_write_sb(struct w9968cf_device*, u16 value);
 425 static int w9968cf_read_sb(struct w9968cf_device*);
 426 static int w9968cf_upload_quantizationtables(struct w9968cf_device*);
 427 static void w9968cf_urb_complete(struct urb *urb, struct pt_regs *regs);
 428
 429 /* Low-level I2C (SMBus) I/O */
 430 static int w9968cf_smbus_start(struct w9968cf_device*);
 431 static int w9968cf_smbus_stop(struct w9968cf_device*);
 432 static int w9968cf_smbus_write_byte(struct w9968cf_device*, u8 v);
 433 static int w9968cf_smbus_read_byte(struct w9968cf_device*, u8* v);
 434 static int w9968cf_smbus_write_ack(struct w9968cf_device*);
 435 static int w9968cf_smbus_read_ack(struct w9968cf_device*);
 436 static int w9968cf_smbus_refresh_bus(struct w9968cf_device*);
 437 static int w9968cf_i2c_adap_read_byte(struct w9968cf_device* cam,
 438                                       u16 address, u8* value);
 439 static int w9968cf_i2c_adap_read_byte_data(struct w9968cf_device*, u16 address,
 440                                            u8 subaddress, u8* value);
 441 static int w9968cf_i2c_adap_write_byte(struct w9968cf_device*,
 442                                        u16 address, u8 subaddress);
 443 static int w9968cf_i2c_adap_fastwrite_byte_data(struct w9968cf_device*,
 444                                                 u16 address, u8 subaddress,
 445                                                 u8 value);
 446
 447 /* I2C interface to kernel */
 448 static int w9968cf_i2c_init(struct w9968cf_device*);
 449 static int w9968cf_i2c_smbus_xfer(struct i2c_adapter*, u16 addr,
 450                                   unsigned short flags, char read_write,
 451                                   u8 command, int size, union i2c_smbus_data*);
 452 static u32 w9968cf_i2c_func(struct i2c_adapter*);
 453 static int w9968cf_i2c_attach_inform(struct i2c_client*);
 454 static int w9968cf_i2c_detach_inform(struct i2c_client*);
 455 static int w9968cf_i2c_control(struct i2c_adapter*, unsigned int cmd,
 456                                unsigned long arg);
 457
 458 /* Memory management */
 459 static void* rvmalloc(unsigned long size);
 460 static void rvfree(void *mem, unsigned long size);
 461 static void w9968cf_deallocate_memory(struct w9968cf_device*);
 462 static int  w9968cf_allocate_memory(struct w9968cf_device*);
 463
 464 /* High-level image sensor control functions */
 465 static int w9968cf_sensor_set_control(struct w9968cf_device*,int cid,int val);
 466 static int w9968cf_sensor_get_control(struct w9968cf_device*,int cid,int *val);
 467 static int w9968cf_sensor_cmd(struct w9968cf_device*,
 468                               unsigned int cmd, void *arg);
 469 static int w9968cf_sensor_init(struct w9968cf_device*);
 470 static int w9968cf_sensor_update_settings(struct w9968cf_device*);
 471 static int w9968cf_sensor_get_picture(struct w9968cf_device*);
 472 static int w9968cf_sensor_update_picture(struct w9968cf_device*,
 473                                          struct video_picture pict);
 474
 475 /* Other helper functions */
 476 static void w9968cf_configure_camera(struct w9968cf_device*,struct usb_device*,
 477                                      enum w9968cf_model_id,
 478                                      const unsigned short dev_nr);
 479 static void w9968cf_adjust_configuration(struct w9968cf_device*);
 480 static int w9968cf_turn_on_led(struct w9968cf_device*);
 481 static int w9968cf_init_chip(struct w9968cf_device*);
 482 static inline u16 w9968cf_valid_palette(u16 palette);
 483 static inline u16 w9968cf_valid_depth(u16 palette);
 484 static inline u8 w9968cf_need_decompression(u16 palette);
 485 static int w9968cf_set_picture(struct w9968cf_device*, struct video_picture);
 486 static int w9968cf_set_window(struct w9968cf_device*, struct video_window);
 487 static int w9968cf_postprocess_frame(struct w9968cf_device*,
 488                                      struct w9968cf_frame_t*);
 489 static int w9968cf_adjust_window_size(struct w9968cf_device*, u16* w, u16* h);
 490 static void w9968cf_init_framelist(struct w9968cf_device*);
 491 static void w9968cf_push_frame(struct w9968cf_device*, u8 f_num);
 492 static void w9968cf_pop_frame(struct w9968cf_device*,struct w9968cf_frame_t**);
 493 static void w9968cf_release_resources(struct w9968cf_device*);
 494
 495 /* Intermodule communication */
 496 static int w9968cf_vppmod_detect(struct w9968cf_device*);
 497 static void w9968cf_vppmod_release(struct w9968cf_device*);
 498
 499
 500
 501 /****************************************************************************
 502  * Symbolic names                                                           *
 503  ****************************************************************************/
 504
 505 /* Used to represent a list of values and their respective symbolic names */
 506 struct w9968cf_symbolic_list {
 507         const int num;
 508         const char *name;
 509 };
 510
 511 /*--------------------------------------------------------------------------
 512   Returns the name of the matching element in the symbolic_list array. The
 513   end of the list must be marked with an element that has a NULL name.
 514   --------------------------------------------------------------------------*/
 515 static inline const char *
 516 symbolic(struct w9968cf_symbolic_list list[], const int num)
 517 {
 518         int i;
 519
 520         for (i = 0; list[i].name != NULL; i++)
 521                 if (list[i].num == num)
 522                         return (list[i].name);
 523
 524         return "Unknown";
 525 }
 526
 527 static struct w9968cf_symbolic_list camlist[] = {
 528         { W9968CF_MOD_GENERIC, "W996[87]CF JPEG USB Dual Mode Camera" },
 529         { W9968CF_MOD_CLVBWGP, "Creative Labs Video Blaster WebCam Go Plus" },
 530
 531         /* Other cameras (having the same descriptors as Generic W996[87]CF) */
 532         { W9968CF_MOD_ADPVDMA, "Aroma Digi Pen VGA Dual Mode ADG-5000" },
 533         { W9986CF_MOD_AAU, "AVerMedia AVerTV USB" },
 534         { W9968CF_MOD_CLVBWG, "Creative Labs Video Blaster WebCam Go" },
 535         { W9968CF_MOD_LL, "Lebon LDC-035A" },
 536         { W9968CF_MOD_EEEMC, "Ezonics EZ-802 EZMega Cam" },
 537         { W9968CF_MOD_OOE, "OmniVision OV8610-EDE" },
 538         { W9968CF_MOD_ODPVDMPC, "OPCOM Digi Pen VGA Dual Mode Pen Camera" },
 539         { W9968CF_MOD_PDPII, "Pretec Digi Pen-II" },
 540         { W9968CF_MOD_PDP480, "Pretec DigiPen-480" },
 541
 542         {  -1, NULL }
 543 };
 544
 545 static struct w9968cf_symbolic_list senlist[] = {
 546         { CC_OV76BE,   "OV76BE" },
 547         { CC_OV7610,   "OV7610" },
 548         { CC_OV7620,   "OV7620" },
 549         { CC_OV7620AE, "OV7620AE" },
 550         { CC_OV6620,   "OV6620" },
 551         { CC_OV6630,   "OV6630" },
 552         { CC_OV6630AE, "OV6630AE" },
 553         { CC_OV6630AF, "OV6630AF" },
 554         { -1, NULL }
 555 };
 556
 557 /* Video4Linux1 palettes */
 558 static struct w9968cf_symbolic_list v4l1_plist[] = {
 559         { VIDEO_PALETTE_GREY,    "GREY" },
 560         { VIDEO_PALETTE_HI240,   "HI240" },
 561         { VIDEO_PALETTE_RGB565,  "RGB565" },
 562         { VIDEO_PALETTE_RGB24,   "RGB24" },
 563         { VIDEO_PALETTE_RGB32,   "RGB32" },
 564         { VIDEO_PALETTE_RGB555,  "RGB555" },
 565         { VIDEO_PALETTE_YUV422,  "YUV422" },
 566         { VIDEO_PALETTE_YUYV,    "YUYV" },
 567         { VIDEO_PALETTE_UYVY,    "UYVY" },
 568         { VIDEO_PALETTE_YUV420,  "YUV420" },
 569         { VIDEO_PALETTE_YUV411,  "YUV411" },
 570         { VIDEO_PALETTE_RAW,     "RAW" },
 571         { VIDEO_PALETTE_YUV422P, "YUV422P" },
 572         { VIDEO_PALETTE_YUV411P, "YUV411P" },
 573         { VIDEO_PALETTE_YUV420P, "YUV420P" },
 574         { VIDEO_PALETTE_YUV410P, "YUV410P" },
 575         { -1, NULL }
 576 };
 577
 578 /* Decoder error codes: */
 579 static struct w9968cf_symbolic_list decoder_errlist[] = {
 580         { W9968CF_DEC_ERR_CORRUPTED_DATA, "Corrupted data" },
 581         { W9968CF_DEC_ERR_BUF_OVERFLOW,   "Buffer overflow" },
 582         { W9968CF_DEC_ERR_NO_SOI,         "SOI marker not found" },
 583         { W9968CF_DEC_ERR_NO_SOF0,        "SOF0 marker not found" },
 584         { W9968CF_DEC_ERR_NO_SOS,         "SOS marker not found" },
 585         { W9968CF_DEC_ERR_NO_EOI,         "EOI marker not found" },
 586         { -1, NULL }
 587 };
 588
 589 /* URB error codes: */
 590 static struct w9968cf_symbolic_list urb_errlist[] = {
 591         { -ENOMEM,    "No memory for allocation of internal structures" },
 592         { -ENOSPC,    "The host controller's bandwidth is already consumed" },
 593         { -ENOENT,    "URB was canceled by unlink_urb" },
 594         { -EXDEV,     "ISO transfer only partially completed" },
 595         { -EAGAIN,    "Too match scheduled for the future" },
 596         { -ENXIO,     "URB already queued" },
 597         { -EFBIG,     "Too much ISO frames requested" },
 598         { -ENOSR,     "Buffer error (overrun)" },
 599         { -EPIPE,     "Specified endpoint is stalled (device not responding)"},
 600         { -EOVERFLOW, "Babble (bad cable?)" },
 601         { -EPROTO,    "Bit-stuff error (bad cable?)" },
 602         { -EILSEQ,    "CRC/Timeout" },
 603         { -ETIMEDOUT, "NAK (device does not respond)" },
 604         { -1, NULL }
 605 };
 606
 607
 608
 609 /****************************************************************************
 610  * Memory management functions                                              *
 611  ****************************************************************************/
 612 static void* rvmalloc(unsigned long size)
 613 {
 614         void* mem;
 615         unsigned long adr;
 616
 617         size = PAGE_ALIGN(size);
 618         mem = vmalloc_32(size);
 619         if (!mem)
 620                 return NULL;
 621
 622         memset(mem, 0, size); /* Clear the ram out, no junk to the user */
 623         adr = (unsigned long) mem;
 624         while (size > 0) {
 625                 SetPageReserved(vmalloc_to_page((void *)adr));
 626                 adr += PAGE_SIZE;
 627                 size -= PAGE_SIZE;
 628         }
 629
 630         return mem;
 631 }
 632
 633
 634 static void rvfree(void* mem, unsigned long size)
 635 {
 636         unsigned long adr;
 637
 638         if (!mem)
 639                 return;
 640
 641         adr = (unsigned long) mem;
 642         while ((long) size > 0) {
 643                 ClearPageReserved(vmalloc_to_page((void *)adr));
 644                 adr += PAGE_SIZE;
 645                 size -= PAGE_SIZE;
 646         }
 647         vfree(mem);
 648 }
 649
 650
 651 /*--------------------------------------------------------------------------
 652   Deallocate previously allocated memory.
 653   --------------------------------------------------------------------------*/
 654 static void w9968cf_deallocate_memory(struct w9968cf_device* cam)
 655 {
 656         u8 i;
 657
 658         /* Free the isochronous transfer buffers */
 659         for (i = 0; i < W9968CF_URBS; i++) {
 660                 kfree(cam->transfer_buffer[i]);
 661                 cam->transfer_buffer[i] = NULL;
 662         }
 663
 664         /* Free temporary frame buffer */
 665         if (cam->frame_tmp.buffer) {
 666                 rvfree(cam->frame_tmp.buffer, cam->frame_tmp.size);
 667                 cam->frame_tmp.buffer = NULL;
 668         }
 669
 670         /* Free helper buffer */
 671         if (cam->frame_vpp.buffer) {
 672                 rvfree(cam->frame_vpp.buffer, cam->frame_vpp.size);
 673                 cam->frame_vpp.buffer = NULL;
 674         }
 675
 676         /* Free video frame buffers */
 677         if (cam->frame[0].buffer) {
 678                 rvfree(cam->frame[0].buffer, cam->nbuffers*cam->frame[0].size);
 679                 cam->frame[0].buffer = NULL;
 680         }
 681
 682         cam->nbuffers = 0;
 683
 684         DBG(5, "Memory successfully deallocated")
 685 }
 686
 687
 688 /*--------------------------------------------------------------------------
 689   Allocate memory buffers for USB transfers and video frames.
 690   This function is called by open() only.
 691   Return 0 on success, a negative number otherwise.
 692   --------------------------------------------------------------------------*/
 693 static int w9968cf_allocate_memory(struct w9968cf_device* cam)
 694 {
 695         const u16 p_size = wMaxPacketSize[cam->altsetting-1];
 696         void* buff = NULL;
 697         unsigned long hw_bufsize, vpp_bufsize;
 698         u8 i, bpp;
 699
 700         /* NOTE: Deallocation is done elsewhere in case of error */
 701
 702         /* Calculate the max amount of raw data per frame from the device */
 703         hw_bufsize = cam->maxwidth*cam->maxheight*2;
 704
 705         /* Calculate the max buf. size needed for post-processing routines */
 706         bpp = (w9968cf_vpp) ? 4 : 2;
 707         if (cam->upscaling)
 708                 vpp_bufsize = max(W9968CF_MAX_WIDTH*W9968CF_MAX_HEIGHT*bpp,
 709                                   cam->maxwidth*cam->maxheight*bpp);
 710         else
 711                 vpp_bufsize = cam->maxwidth*cam->maxheight*bpp;
 712
 713         /* Allocate memory for the isochronous transfer buffers */
 714         for (i = 0; i < W9968CF_URBS; i++) {
 715                 if (!(cam->transfer_buffer[i] =
 716                       kmalloc(W9968CF_ISO_PACKETS*p_size, GFP_KERNEL))) {
 717                         DBG(1, "Couldn't allocate memory for the isochronous "
 718                                "transfer buffers (%u bytes)",
 719                             p_size * W9968CF_ISO_PACKETS)
 720                         return -ENOMEM;
 721                 }
 722                 memset(cam->transfer_buffer[i], 0, W9968CF_ISO_PACKETS*p_size);
 723         }
 724
 725         /* Allocate memory for the temporary frame buffer */
 726         if (!(cam->frame_tmp.buffer = rvmalloc(hw_bufsize))) {
 727                 DBG(1, "Couldn't allocate memory for the temporary "
 728                        "video frame buffer (%lu bytes)", hw_bufsize)
 729                 return -ENOMEM;
 730         }
 731         cam->frame_tmp.size = hw_bufsize;
 732         cam->frame_tmp.number = -1;
 733
 734         /* Allocate memory for the helper buffer */
 735         if (w9968cf_vpp) {
 736                 if (!(cam->frame_vpp.buffer = rvmalloc(vpp_bufsize))) {
 737                         DBG(1, "Couldn't allocate memory for the helper buffer"
 738                                " (%lu bytes)", vpp_bufsize)
 739                         return -ENOMEM;
 740                 }
 741                 cam->frame_vpp.size = vpp_bufsize;
 742         } else
 743                 cam->frame_vpp.buffer = NULL;
 744
 745         /* Allocate memory for video frame buffers */
 746         cam->nbuffers = cam->max_buffers;
 747         while (cam->nbuffers >= 2) {
 748                 if ((buff = rvmalloc(cam->nbuffers * vpp_bufsize)))
 749                         break;
 750                 else
 751                         cam->nbuffers--;
 752         }
 753
 754         if (!buff) {
 755                 DBG(1, "Couldn't allocate memory for the video frame buffers")
 756                 cam->nbuffers = 0;
 757                 return -ENOMEM;
 758         }
 759
 760         if (cam->nbuffers != cam->max_buffers)
 761                 DBG(2, "Couldn't allocate memory for %u video frame buffers. "
 762                        "Only memory for %u buffers has been allocated",
 763                     cam->max_buffers, cam->nbuffers)
 764
 765         for (i = 0; i < cam->nbuffers; i++) {
 766                 cam->frame[i].buffer = buff + i*vpp_bufsize;
 767                 cam->frame[i].size = vpp_bufsize;
 768                 cam->frame[i].number = i;
 769                 /* Circular list */
 770                 if (i != cam->nbuffers-1)
 771                         cam->frame[i].next = &cam->frame[i+1];
 772                 else
 773                         cam->frame[i].next = &cam->frame[0];
 774                 cam->frame[i].status = F_UNUSED;
 775         }
 776
 777         DBG(5, "Memory successfully allocated")
 778         return 0;
 779 }
 780
 781
 782
 783 /****************************************************************************
 784  * USB-specific functions                                                   *
 785  ****************************************************************************/
 786
 787 /*--------------------------------------------------------------------------
 788   This is an handler function which is called after the URBs are completed.
 789   It collects multiple data packets coming from the camera by putting them
 790   into frame buffers: one or more zero data length data packets are used to
 791   mark the end of a video frame; the first non-zero data packet is the start
 792   of the next video frame; if an error is encountered in a packet, the entire
 793   video frame is discarded and grabbed again.
 794   If there are no requested frames in the FIFO list, packets are collected into
 795   a temporary buffer.
 796   --------------------------------------------------------------------------*/
 797 static void w9968cf_urb_complete(struct urb *urb, struct pt_regs *regs)
 798 {
 799         struct w9968cf_device* cam = (struct w9968cf_device*)urb->context;
 800         struct w9968cf_frame_t** f;
 801         unsigned int len, status;
 802         void* pos;
 803         u8 i;
 804         int err = 0;
 805
 806         if ((!cam->streaming) || cam->disconnected) {
 807                 DBG(4, "Got interrupt, but not streaming")
 808                 return;
 809         }
 810
 811         /* "(*f)" will be used instead of "cam->frame_current" */
 812         f = &cam->frame_current;
 813
 814         /* If a frame has been requested and we are grabbing into
 815            the temporary frame, we'll switch to that requested frame */
 816         if ((*f) == &cam->frame_tmp && *cam->requested_frame) {
 817                 if (cam->frame_tmp.status == F_GRABBING) {
 818                         w9968cf_pop_frame(cam, &cam->frame_current);
 819                         (*f)->status = F_GRABBING;
 820                         (*f)->length = cam->frame_tmp.length;
 821                         memcpy((*f)->buffer, cam->frame_tmp.buffer,
 822                                (*f)->length);
 823                         DBG(6, "Switched from temp. frame to frame #%d",
 824                             (*f)->number)
 825                 }
 826         }
 827
 828         for (i = 0; i < urb->number_of_packets; i++) {
 829                 len = urb->iso_frame_desc[i].actual_length;
 830                 status = urb->iso_frame_desc[i].status;
 831                 pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;
 832
 833                 if (status && len != 0) {
 834                         DBG(4, "URB failed, error in data packet "
 835                                "(error #%u, %s)",
 836                             status, symbolic(urb_errlist, status))
 837                         (*f)->status = F_ERROR;
 838                         continue;
 839                 }
 840
 841                 if (len) { /* start of frame */
 842
 843                         if ((*f)->status == F_UNUSED) {
 844                                 (*f)->status = F_GRABBING;
 845                                 (*f)->length = 0;
 846                         }
 847
 848                         /* Buffer overflows shouldn't happen, however...*/
 849                         if ((*f)->length + len > (*f)->size) {
 850                                 DBG(4, "Buffer overflow: bad data packets")
 851                                 (*f)->status = F_ERROR;
 852                         }
 853
 854                         if ((*f)->status == F_GRABBING) {
 855                                 memcpy((*f)->buffer + (*f)->length, pos, len);
 856                                 (*f)->length += len;
 857                         }
 858
 859                 } else if ((*f)->status == F_GRABBING) { /* end of frame */
 860
 861                         DBG(6, "Frame #%d successfully grabbed", (*f)->number)
 862
 863                         if (cam->vpp_flag & VPP_DECOMPRESSION) {
 864                                 err = w9968cf_vpp->check_headers((*f)->buffer,
 865                                                                  (*f)->length);
 866                                 if (err) {
 867                                         DBG(4, "Skip corrupted frame: %s",
 868                                             symbolic(decoder_errlist, err))
 869                                         (*f)->status = F_UNUSED;
 870                                         continue; /* grab this frame again */
 871                                 }
 872                         }
 873
 874                         (*f)->status = F_READY;
 875                         (*f)->queued = 0;
 876
 877                         /* Take a pointer to the new frame from the FIFO list.
 878                            If the list is empty,we'll use the temporary frame*/
 879                         if (*cam->requested_frame)
 880                                 w9968cf_pop_frame(cam, &cam->frame_current);
 881                         else {
 882                                 cam->frame_current = &cam->frame_tmp;
 883                                 (*f)->status = F_UNUSED;
 884                         }
 885
 886                 } else if ((*f)->status == F_ERROR)
 887                         (*f)->status = F_UNUSED; /* grab it again */
 888
 889                 PDBGG("Frame length %lu | pack.#%u | pack.len. %u | state %d",
 890                       (unsigned long)(*f)->length, i, len, (*f)->status)
 891
 892         } /* end for */
 893
 894         /* Resubmit this URB */
 895         urb->dev = cam->usbdev;
 896         urb->status = 0;
 897         spin_lock(&cam->urb_lock);
 898         if (cam->streaming)
 899                 if ((err = usb_submit_urb(urb, GFP_ATOMIC))) {
 900                         cam->misconfigured = 1;
 901                         DBG(1, "Couldn't resubmit the URB: error %d, %s",
 902                             err, symbolic(urb_errlist, err))
 903                 }
 904         spin_unlock(&cam->urb_lock);
 905
 906         /* Wake up the user process */
 907         wake_up_interruptible(&cam->wait_queue);
 908 }
 909
 910
 911 /*---------------------------------------------------------------------------
 912   Setup the URB structures for the isochronous transfer.
 913   Submit the URBs so that the data transfer begins.
 914   Return 0 on success, a negative number otherwise.
 915   ---------------------------------------------------------------------------*/
 916 static int w9968cf_start_transfer(struct w9968cf_device* cam)
 917 {
 918         struct usb_device *udev = cam->usbdev;
 919         struct urb* urb;
 920         const u16 p_size = wMaxPacketSize[cam->altsetting-1];
 921         u16 w, h, d;
 922         int vidcapt;
 923         u32 t_size;
 924         int err = 0;
 925         s8 i, j;
 926
 927         for (i = 0; i < W9968CF_URBS; i++) {
 928                 urb = usb_alloc_urb(W9968CF_ISO_PACKETS, GFP_KERNEL);
 929                 cam->urb[i] = urb;
 930                 if (!urb) {
 931                         for (j = 0; j < i; j++)
 932                                 usb_free_urb(cam->urb[j]);
 933                         DBG(1, "Couldn't allocate the URB structures")
 934                         return -ENOMEM;
 935                 }
 936
 937                 urb->dev = udev;
 938                 urb->context = (void*)cam;
 939                 urb->pipe = usb_rcvisocpipe(udev, 1);
 940                 urb->transfer_flags = URB_ISO_ASAP;
 941                 urb->number_of_packets = W9968CF_ISO_PACKETS;
 942                 urb->complete = w9968cf_urb_complete;
 943                 urb->transfer_buffer = cam->transfer_buffer[i];
 944                 urb->transfer_buffer_length = p_size*W9968CF_ISO_PACKETS;
 945                 urb->interval = 1;
 946                 for (j = 0; j < W9968CF_ISO_PACKETS; j++) {
 947                         urb->iso_frame_desc[j].offset = p_size*j;
 948                         urb->iso_frame_desc[j].length = p_size;
 949                 }
 950         }
 951
 952         /* Transfer size per frame, in WORD ! */
 953         d = cam->hw_depth;
 954         w = cam->hw_width;
 955         h = cam->hw_height;
 956
 957         t_size = (w*h*d)/16;
 958
 959         err = w9968cf_write_reg(cam, 0xbf17, 0x00); /* reset everything */
 960         err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* normal operation */
 961
 962         /* Transfer size */
 963         err += w9968cf_write_reg(cam, t_size & 0xffff, 0x3d); /* low bits */
 964         err += w9968cf_write_reg(cam, t_size >> 16, 0x3e);    /* high bits */
 965
 966         if (cam->vpp_flag & VPP_DECOMPRESSION)
 967                 err += w9968cf_upload_quantizationtables(cam);
 968
 969         vidcapt = w9968cf_read_reg(cam, 0x16); /* read picture settings */
 970         err += w9968cf_write_reg(cam, vidcapt|0x8000, 0x16); /* capt. enable */
 971
 972         err += usb_set_interface(udev, 0, cam->altsetting);
 973         err += w9968cf_write_reg(cam, 0x8a05, 0x3c); /* USB FIFO enable */
 974
 975         if (err || (vidcapt < 0)) {
 976                 for (i = 0; i < W9968CF_URBS; i++)
 977                         usb_free_urb(cam->urb[i]);
 978                 DBG(1, "Couldn't tell the camera to start the data transfer")
 979                 return err;
 980         }
 981
 982         w9968cf_init_framelist(cam);
 983
 984         /* Begin to grab into the temporary buffer */
 985         cam->frame_tmp.status = F_UNUSED;
 986         cam->frame_tmp.queued = 0;
 987         cam->frame_current = &cam->frame_tmp;
 988
 989         if (!(cam->vpp_flag & VPP_DECOMPRESSION))
 990                 DBG(5, "Isochronous transfer size: %lu bytes/frame",
 991                     (unsigned long)t_size*2)
 992
 993         DBG(5, "Starting the isochronous transfer...")
 994
 995         cam->streaming = 1;
 996
 997         /* Submit the URBs */
 998         for (i = 0; i < W9968CF_URBS; i++) {
 999                 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
1000                 if (err) {
1001                         cam->streaming = 0;
1002                         for (j = i-1; j >= 0; j--) {
1003                                 usb_kill_urb(cam->urb[j]);
1004                                 usb_free_urb(cam->urb[j]);
1005                         }
1006                         DBG(1, "Couldn't send a transfer request to the "
1007                                "USB core (error #%d, %s)", err,
1008                             symbolic(urb_errlist, err))
1009                         return err;
1010                 }
1011         }
1012
1013         return 0;
1014 }
1015
1016
1017 /*--------------------------------------------------------------------------
1018   Stop the isochronous transfer and set alternate setting to 0 (0Mb/s).
1019   Return 0 on success, a negative number otherwise.
1020   --------------------------------------------------------------------------*/
1021 static int w9968cf_stop_transfer(struct w9968cf_device* cam)
1022 {
1023         struct usb_device *udev = cam->usbdev;
1024         unsigned long lock_flags;
1025         int err = 0;
1026         s8 i;
1027
1028         if (!cam->streaming)
1029                 return 0;
1030
1031         /* This avoids race conditions with usb_submit_urb()
1032            in the URB completition handler */
1033         spin_lock_irqsave(&cam->urb_lock, lock_flags);
1034         cam->streaming = 0;
1035         spin_unlock_irqrestore(&cam->urb_lock, lock_flags);
1036
1037         for (i = W9968CF_URBS-1; i >= 0; i--)
1038                 if (cam->urb[i]) {
1039                         usb_kill_urb(cam->urb[i]);
1040                         usb_free_urb(cam->urb[i]);
1041                         cam->urb[i] = NULL;
1042                 }
1043
1044         if (cam->disconnected)
1045                 goto exit;
1046
1047         err = w9968cf_write_reg(cam, 0x0a05, 0x3c); /* stop USB transfer */
1048         err += usb_set_interface(udev, 0, 0); /* 0 Mb/s */
1049         err += w9968cf_write_reg(cam, 0x0000, 0x39); /* disable JPEG encoder */
1050         err += w9968cf_write_reg(cam, 0x0000, 0x16); /* stop video capture */
1051
1052         if (err) {
1053                 DBG(2, "Failed to tell the camera to stop the isochronous "
1054                        "transfer. However this is not a critical error.")
1055                 return -EIO;
1056         }
1057
1058 exit:
1059         DBG(5, "Isochronous transfer stopped")
1060         return 0;
1061 }
1062
1063
1064 /*--------------------------------------------------------------------------
1065   Write a W9968CF register.
1066   Return 0 on success, -1 otherwise.
1067   --------------------------------------------------------------------------*/
1068 static int w9968cf_write_reg(struct w9968cf_device* cam, u16 value, u16 index)
1069 {
1070         struct usb_device* udev = cam->usbdev;
1071         int res;
1072
1073         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0,
1074                               USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
1075                               value, index, NULL, 0, W9968CF_USB_CTRL_TIMEOUT);
1076
1077         if (res < 0)
1078                 DBG(4, "Failed to write a register "
1079                        "(value 0x%04X, index 0x%02X, error #%d, %s)",
1080                     value, index, res, symbolic(urb_errlist, res))
1081
1082         return (res >= 0) ? 0 : -1;
1083 }
1084
1085
1086 /*--------------------------------------------------------------------------
1087   Read a W9968CF register.
1088   Return the register value on success, -1 otherwise.
1089   --------------------------------------------------------------------------*/
1090 static int w9968cf_read_reg(struct w9968cf_device* cam, u16 index)
1091 {
1092         struct usb_device* udev = cam->usbdev;
1093         u16* buff = cam->control_buffer;
1094         int res;
1095
1096         res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 1,
1097                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1098                               0, index, buff, 2, W9968CF_USB_CTRL_TIMEOUT);
1099
1100         if (res < 0)
1101                 DBG(4, "Failed to read a register "
1102                        "(index 0x%02X, error #%d, %s)",
1103                     index, res, symbolic(urb_errlist, res))
1104
1105         return (res >= 0) ? (int)(*buff) : -1;
1106 }
1107
1108
1109 /*--------------------------------------------------------------------------
1110   Write 64-bit data to the fast serial bus registers.
1111   Return 0 on success, -1 otherwise.
1112   --------------------------------------------------------------------------*/
1113 static int w9968cf_write_fsb(struct w9968cf_device* cam, u16* data)
1114 {
1115         struct usb_device* udev = cam->usbdev;
1116         u16 value;
1117         int res;
1118
1119         value = *data++;
1120
1121         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0,
1122                               USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
1123                               value, 0x06, data, 6, W9968CF_USB_CTRL_TIMEOUT);
1124
1125         if (res < 0)
1126                 DBG(4, "Failed to write the FSB registers "
1127                        "(error #%d, %s)", res, symbolic(urb_errlist, res))
1128
1129         return (res >= 0) ? 0 : -1;
1130 }
1131
1132
1133 /*--------------------------------------------------------------------------
1134   Write data to the serial bus control register.
1135   Return 0 on success, a negative number otherwise.
1136   --------------------------------------------------------------------------*/
1137 static int w9968cf_write_sb(struct w9968cf_device* cam, u16 value)
1138 {
1139         int err = 0;
1140
1141         err = w9968cf_write_reg(cam, value, 0x01);
1142         udelay(W9968CF_I2C_BUS_DELAY);
1143
1144         return err;
1145 }
1146
1147
1148 /*--------------------------------------------------------------------------
1149   Read data from the serial bus control register.
1150   Return 0 on success, a negative number otherwise.
1151   --------------------------------------------------------------------------*/
1152 static int w9968cf_read_sb(struct w9968cf_device* cam)
1153 {
1154         int v = 0;
1155
1156         v = w9968cf_read_reg(cam, 0x01);
1157         udelay(W9968CF_I2C_BUS_DELAY);
1158
1159         return v;
1160 }
1161
1162
1163 /*--------------------------------------------------------------------------
1164   Upload quantization tables for the JPEG compression.
1165   This function is called by w9968cf_start_transfer().
1166   Return 0 on success, a negative number otherwise.
1167   --------------------------------------------------------------------------*/
1168 static int w9968cf_upload_quantizationtables(struct w9968cf_device* cam)
1169 {
1170         u16 a, b;
1171         int err = 0, i, j;
1172
1173         err += w9968cf_write_reg(cam, 0x0010, 0x39); /* JPEG clock enable */
1174
1175         for (i = 0, j = 0; i < 32; i++, j += 2) {
1176                 a = Y_QUANTABLE[j] | ((unsigned)(Y_QUANTABLE[j+1]) << 8);
1177                 b = UV_QUANTABLE[j] | ((unsigned)(UV_QUANTABLE[j+1]) << 8);
1178                 err += w9968cf_write_reg(cam, a, 0x40+i);
1179                 err += w9968cf_write_reg(cam, b, 0x60+i);
1180         }
1181         err += w9968cf_write_reg(cam, 0x0012, 0x39); /* JPEG encoder enable */
1182
1183         return err;
1184 }
1185
1186
1187
1188 /****************************************************************************
1189  * Low-level I2C I/O functions.                                             *
1190  * The adapter supports the following I2C transfer functions:               *
1191  * i2c_adap_fastwrite_byte_data() (at 400 kHz bit frequency only)           *
1192  * i2c_adap_read_byte_data()                                                *
1193  * i2c_adap_read_byte()                                                     *
1194  ****************************************************************************/
1195
1196 static int w9968cf_smbus_start(struct w9968cf_device* cam)
1197 {
1198         int err = 0;
1199
1200         err += w9968cf_write_sb(cam, 0x0011); /* SDE=1, SDA=0, SCL=1 */
1201         err += w9968cf_write_sb(cam, 0x0010); /* SDE=1, SDA=0, SCL=0 */
1202
1203         return err;
1204 }
1205
1206
1207 static int w9968cf_smbus_stop(struct w9968cf_device* cam)
1208 {
1209         int err = 0;
1210
1211         err += w9968cf_write_sb(cam, 0x0011); /* SDE=1, SDA=0, SCL=1 */
1212         err += w9968cf_write_sb(cam, 0x0013); /* SDE=1, SDA=1, SCL=1 */
1213
1214         return err;
1215 }
1216
1217
1218 static int w9968cf_smbus_write_byte(struct w9968cf_device* cam, u8 v)
1219 {
1220         u8 bit;
1221         int err = 0, sda;
1222
1223         for (bit = 0 ; bit < 8 ; bit++) {
1224                 sda = (v & 0x80) ? 2 : 0;
1225                 v <<= 1;
1226                 /* SDE=1, SDA=sda, SCL=0 */
1227                 err += w9968cf_write_sb(cam, 0x10 | sda);
1228                 /* SDE=1, SDA=sda, SCL=1 */
1229                 err += w9968cf_write_sb(cam, 0x11 | sda);
1230                 /* SDE=1, SDA=sda, SCL=0 */
1231                 err += w9968cf_write_sb(cam, 0x10 | sda);
1232         }
1233
1234         return err;
1235 }
1236
1237
1238 static int w9968cf_smbus_read_byte(struct w9968cf_device* cam, u8* v)
1239 {
1240         u8 bit;
1241         int err = 0;
1242
1243         *v = 0;
1244         for (bit = 0 ; bit < 8 ; bit++) {
1245                 *v <<= 1;
1246                 err += w9968cf_write_sb(cam, 0x0013);
1247                 *v |= (w9968cf_read_sb(cam) & 0x0008) ? 1 : 0;
1248                 err += w9968cf_write_sb(cam, 0x0012);
1249         }
1250
1251         return err;
1252 }
1253
1254
1255 static int w9968cf_smbus_write_ack(struct w9968cf_device* cam)
1256 {
1257         int err = 0;
1258
1259         err += w9968cf_write_sb(cam, 0x0010); /* SDE=1, SDA=0, SCL=0 */
1260         err += w9968cf_write_sb(cam, 0x0011); /* SDE=1, SDA=0, SCL=1 */
1261         err += w9968cf_write_sb(cam, 0x0010); /* SDE=1, SDA=0, SCL=0 */
1262
1263         return err;
1264 }
1265
1266
1267 static int w9968cf_smbus_read_ack(struct w9968cf_device* cam)
1268 {
1269         int err = 0, sda;
1270
1271         err += w9968cf_write_sb(cam, 0x0013); /* SDE=1, SDA=1, SCL=1 */
1272         sda = (w9968cf_read_sb(cam) & 0x08) ? 1 : 0; /* sda = SDA */
1273         err += w9968cf_write_sb(cam, 0x0012); /* SDE=1, SDA=1, SCL=0 */
1274         if (sda < 0)
1275                 err += sda;
1276         if (sda == 1) {
1277                 DBG(6, "Couldn't receive the ACK")
1278                 err += -1;
1279         }
1280
1281         return err;
1282 }
1283
1284
1285 /* This seems to refresh the communication through the serial bus */
1286 static int w9968cf_smbus_refresh_bus(struct w9968cf_device* cam)
1287 {
1288         int err = 0, j;
1289
1290         for (j = 1; j <= 10; j++) {
1291                 err = w9968cf_write_reg(cam, 0x0020, 0x01);
1292                 err += w9968cf_write_reg(cam, 0x0000, 0x01);
1293                 if (err)
1294                         break;
1295         }
1296
1297         return err;
1298 }
1299
1300
1301 /* SMBus protocol: S Addr Wr [A] Subaddr [A] Value [A] P */
1302 static int
1303 w9968cf_i2c_adap_fastwrite_byte_data(struct w9968cf_device* cam,
1304                                      u16 address, u8 subaddress,u8 value)
1305 {
1306         u16* data = cam->data_buffer;
1307         int err = 0;
1308
1309         err += w9968cf_smbus_refresh_bus(cam);
1310
1311         /* Enable SBUS outputs */
1312         err += w9968cf_write_sb(cam, 0x0020);
1313
1314         data[0] = 0x082f | ((address & 0x80) ? 0x1500 : 0x0);
1315         data[0] |= (address & 0x40) ? 0x4000 : 0x0;
1316         data[1] = 0x2082 | ((address & 0x40) ? 0x0005 : 0x0);
1317         data[1] |= (address & 0x20) ? 0x0150 : 0x0;
1318         data[1] |= (address & 0x10) ? 0x5400 : 0x0;
1319         data[2] = 0x8208 | ((address & 0x08) ? 0x0015 : 0x0);
1320         data[2] |= (address & 0x04) ? 0x0540 : 0x0;
1321         data[2] |= (address & 0x02) ? 0x5000 : 0x0;
1322         data[3] = 0x1d20 | ((address & 0x02) ? 0x0001 : 0x0);
1323         data[3] |= (address & 0x01) ? 0x0054 : 0x0;
1324
1325         err += w9968cf_write_fsb(cam, data);
1326
1327         data[0] = 0x8208 | ((subaddress & 0x80) ? 0x0015 : 0x0);
1328         data[0] |= (subaddress & 0x40) ? 0x0540 : 0x0;
1329         data[0] |= (subaddress & 0x20) ? 0x5000 : 0x0;
1330         data[1] = 0x0820 | ((subaddress & 0x20) ? 0x0001 : 0x0);
1331         data[1] |= (subaddress & 0x10) ? 0x0054 : 0x0;
1332         data[1] |= (subaddress & 0x08) ? 0x1500 : 0x0;
1333         data[1] |= (subaddress & 0x04) ? 0x4000 : 0x0;
1334         data[2] = 0x2082 | ((subaddress & 0x04) ? 0x0005 : 0x0);
1335         data[2] |= (subaddress & 0x02) ? 0x0150 : 0x0;
1336         data[2] |= (subaddress & 0x01) ? 0x5400 : 0x0;
1337         data[3] = 0x001d;
1338
1339         err += w9968cf_write_fsb(cam, data);
1340
1341         data[0] = 0x8208 | ((value & 0x80) ? 0x0015 : 0x0);
1342         data[0] |= (value & 0x40) ? 0x0540 : 0x0;
1343         data[0] |= (value & 0x20) ? 0x5000 : 0x0;
1344         data[1] = 0x0820 | ((value & 0x20) ? 0x0001 : 0x0);
1345         data[1] |= (value & 0x10) ? 0x0054 : 0x0;
1346         data[1] |= (value & 0x08) ? 0x1500 : 0x0;
1347         data[1] |= (value & 0x04) ? 0x4000 : 0x0;
1348         data[2] = 0x2082 | ((value & 0x04) ? 0x0005 : 0x0);
1349         data[2] |= (value & 0x02) ? 0x0150 : 0x0;
1350         data[2] |= (value & 0x01) ? 0x5400 : 0x0;
1351         data[3] = 0xfe1d;
1352
1353         err += w9968cf_write_fsb(cam, data);
1354
1355         /* Disable SBUS outputs */
1356         err += w9968cf_write_sb(cam, 0x0000);
1357
1358         if (!err)
1359                 DBG(5, "I2C write byte data done, addr.0x%04X, subaddr.0x%02X "
1360                        "value 0x%02X", address, subaddress, value)
1361         else
1362                 DBG(5, "I2C write byte data failed, addr.0x%04X, "
1363                        "subaddr.0x%02X, value 0x%02X",
1364                     address, subaddress, value)
1365
1366         return err;
1367 }
1368
1369
1370 /* SMBus protocol: S Addr Wr [A] Subaddr [A] P S Addr+1 Rd [A] [Value] NA P */
1371 static int
1372 w9968cf_i2c_adap_read_byte_data(struct w9968cf_device* cam,
1373                                 u16 address, u8 subaddress,
1374                                 u8* value)
1375 {
1376         int err = 0;
1377
1378         /* Serial data enable */
1379         err += w9968cf_write_sb(cam, 0x0013); /* don't change ! */
1380
1381         err += w9968cf_smbus_start(cam);
1382         err += w9968cf_smbus_write_byte(cam, address);
1383         err += w9968cf_smbus_read_ack(cam);
1384         err += w9968cf_smbus_write_byte(cam, subaddress);
1385         err += w9968cf_smbus_read_ack(cam);
1386         err += w9968cf_smbus_stop(cam);
1387         err += w9968cf_smbus_start(cam);
1388         err += w9968cf_smbus_write_byte(cam, address + 1);
1389         err += w9968cf_smbus_read_ack(cam);
1390         err += w9968cf_smbus_read_byte(cam, value);
1391         err += w9968cf_smbus_write_ack(cam);
1392         err += w9968cf_smbus_stop(cam);
1393
1394         /* Serial data disable */
1395         err += w9968cf_write_sb(cam, 0x0000);
1396
1397         if (!err)
1398                 DBG(5, "I2C read byte data done, addr.0x%04X, "
1399                        "subaddr.0x%02X, value 0x%02X",
1400                     address, subaddress, *value)
1401         else
1402                 DBG(5, "I2C read byte data failed, addr.0x%04X, "
1403                        "subaddr.0x%02X, wrong value 0x%02X",
1404                     address, subaddress, *value)
1405
1406         return err;
1407 }
1408
1409
1410 /* SMBus protocol: S Addr+1 Rd [A] [Value] NA P */
1411 static int
1412 w9968cf_i2c_adap_read_byte(struct w9968cf_device* cam,
1413                            u16 address, u8* value)
1414 {
1415         int err = 0;
1416
1417         /* Serial data enable */
1418         err += w9968cf_write_sb(cam, 0x0013);
1419
1420         err += w9968cf_smbus_start(cam);
1421         err += w9968cf_smbus_write_byte(cam, address + 1);
1422         err += w9968cf_smbus_read_ack(cam);
1423         err += w9968cf_smbus_read_byte(cam, value);
1424         err += w9968cf_smbus_write_ack(cam);
1425         err += w9968cf_smbus_stop(cam);
1426
1427         /* Serial data disable */
1428         err += w9968cf_write_sb(cam, 0x0000);
1429
1430         if (!err)
1431                 DBG(5, "I2C read byte done, addr.0x%04X, "
1432                        "value 0x%02X", address, *value)
1433         else
1434                 DBG(5, "I2C read byte failed, addr.0x%04X, "
1435                        "wrong value 0x%02X", address, *value)
1436
1437         return err;
1438 }
1439
1440
1441 /* SMBus protocol: S Addr Wr [A] Value [A] P */
1442 static int
1443 w9968cf_i2c_adap_write_byte(struct w9968cf_device* cam,
1444                             u16 address, u8 value)
1445 {
1446         DBG(4, "i2c_write_byte() is an unsupported transfer mode")
1447         return -EINVAL;
1448 }
1449
1450
1451
1452 /****************************************************************************
1453  * I2C interface to kernel                                                  *
1454  ****************************************************************************/
1455
1456 static int
1457 w9968cf_i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
1458                        unsigned short flags, char read_write, u8 command,
1459                        int size, union i2c_smbus_data *data)
1460 {
1461         struct w9968cf_device* cam = i2c_get_adapdata(adapter);
1462         u8 i;
1463         int err = 0;
1464
1465         switch (addr) {
1466                 case OV6xx0_SID:
1467                 case OV7xx0_SID:
1468                         break;
1469                 default:
1470                         DBG(4, "Rejected slave ID 0x%04X", addr)
1471                         return -EINVAL;
1472         }
1473
1474         if (size == I2C_SMBUS_BYTE) {
1475                 /* Why addr <<= 1? See OVXXX0_SID defines in ovcamchip.h */
1476                 addr <<= 1;
1477
1478                 if (read_write == I2C_SMBUS_WRITE)
1479                         err = w9968cf_i2c_adap_write_byte(cam, addr, command);
1480                 else if (read_write == I2C_SMBUS_READ)
1481                         err = w9968cf_i2c_adap_read_byte(cam,addr,&data->byte);
1482
1483         } else if (size == I2C_SMBUS_BYTE_DATA) {
1484                 addr <<= 1;
1485
1486                 if (read_write == I2C_SMBUS_WRITE)
1487                         err = w9968cf_i2c_adap_fastwrite_byte_data(cam, addr,
1488                                                           command, data->byte);
1489                 else if (read_write == I2C_SMBUS_READ) {
1490                         for (i = 1; i <= W9968CF_I2C_RW_RETRIES; i++) {
1491                                 err = w9968cf_i2c_adap_read_byte_data(cam,addr,
1492                                                          command, &data->byte);
1493                                 if (err) {
1494                                         if (w9968cf_smbus_refresh_bus(cam)) {
1495                                                 err = -EIO;
1496                                                 break;
1497                                         }
1498                                 } else
1499                                         break;
1500                         }
1501
1502                 } else
1503                         return -EINVAL;
1504
1505         } else {
1506                 DBG(4, "Unsupported I2C transfer mode (%d)", size)
1507                 return -EINVAL;
1508         }
1509
1510         return err;
1511 }
1512
1513
1514 static u32 w9968cf_i2c_func(struct i2c_adapter* adap)
1515 {
1516         return I2C_FUNC_SMBUS_READ_BYTE |
1517                I2C_FUNC_SMBUS_READ_BYTE_DATA  |
1518                I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
1519 }
1520
1521
1522 static int w9968cf_i2c_attach_inform(struct i2c_client* client)
1523 {
1524         struct w9968cf_device* cam = i2c_get_adapdata(client->adapter);
1525         int id = client->driver->id, err = 0;
1526
1527         if (id == I2C_DRIVERID_OVCAMCHIP) {
1528                 cam->sensor_client = client;
1529                 err = w9968cf_sensor_init(cam);
1530                 if (err) {
1531                         cam->sensor_client = NULL;
1532                         return err;
1533                 }
1534         } else {
1535                 DBG(4, "Rejected client [%s] with driver [%s]",
1536                     client->name, client->driver->driver.name)
1537                 return -EINVAL;
1538         }
1539
1540         DBG(5, "I2C attach client [%s] with driver [%s]",
1541             client->name, client->driver->driver.name)
1542
1543         return 0;
1544 }
1545
1546
1547 static int w9968cf_i2c_detach_inform(struct i2c_client* client)
1548 {
1549         struct w9968cf_device* cam = i2c_get_adapdata(client->adapter);
1550
1551         if (cam->sensor_client == client)
1552                 cam->sensor_client = NULL;
1553
1554         DBG(5, "I2C detach client [%s]", client->name)
1555
1556         return 0;
1557 }
1558
1559
1560 static int
1561 w9968cf_i2c_control(struct i2c_adapter* adapter, unsigned int cmd,
1562                     unsigned long arg)
1563 {
1564         return 0;
1565 }
1566
1567
1568 static int w9968cf_i2c_init(struct w9968cf_device* cam)
1569 {
1570         int err = 0;
1571
1572         static struct i2c_algorithm algo = {
1573                 .smbus_xfer =    w9968cf_i2c_smbus_xfer,
1574                 .algo_control =  w9968cf_i2c_control,
1575                 .functionality = w9968cf_i2c_func,
1576         };
1577
1578         static struct i2c_adapter adap = {
1579                 .id =                I2C_HW_SMBUS_W9968CF,
1580                 .class =             I2C_CLASS_CAM_DIGITAL,
1581                 .owner =             THIS_MODULE,
1582                 .client_register =   w9968cf_i2c_attach_inform,
1583                 .client_unregister = w9968cf_i2c_detach_inform,
1584                 .algo =              &algo,
1585         };
1586
1587         memcpy(&cam->i2c_adapter, &adap, sizeof(struct i2c_adapter));
1588         strcpy(cam->i2c_adapter.name, "w9968cf");
1589         i2c_set_adapdata(&cam->i2c_adapter, cam);
1590
1591         DBG(6, "Registering I2C adapter with kernel...")
1592
1593         err = i2c_add_adapter(&cam->i2c_adapter);
1594         if (err)
1595                 DBG(1, "Failed to register the I2C adapter")
1596         else
1597                 DBG(5, "I2C adapter registered")
1598
1599         return err;
1600 }
1601
1602
1603
1604 /****************************************************************************
1605  * Helper functions                                                         *
1606  ****************************************************************************/
1607
1608 /*--------------------------------------------------------------------------
1609   Turn on the LED on some webcams. A beep should be heard too.
1610   Return 0 on success, a negative number otherwise.
1611   --------------------------------------------------------------------------*/
1612 static int w9968cf_turn_on_led(struct w9968cf_device* cam)
1613 {
1614         int err = 0;
1615
1616         err += w9968cf_write_reg(cam, 0xff00, 0x00); /* power-down */
1617         err += w9968cf_write_reg(cam, 0xbf17, 0x00); /* reset everything */
1618         err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* normal operation */
1619         err += w9968cf_write_reg(cam, 0x0010, 0x01); /* serial bus, SDS high */
1620         err += w9968cf_write_reg(cam, 0x0000, 0x01); /* serial bus, SDS low */
1621         err += w9968cf_write_reg(cam, 0x0010, 0x01); /* ..high 'beep-beep' */
1622
1623         if (err)
1624                 DBG(2, "Couldn't turn on the LED")
1625
1626         DBG(5, "LED turned on")
1627
1628         return err;
1629 }
1630
1631
1632 /*--------------------------------------------------------------------------
1633   Write some registers for the device initialization.
1634   This function is called once on open().
1635   Return 0 on success, a negative number otherwise.
1636   --------------------------------------------------------------------------*/
1637 static int w9968cf_init_chip(struct w9968cf_device* cam)
1638 {
1639         unsigned long hw_bufsize = cam->maxwidth*cam->maxheight*2,
1640                       y0 = 0x0000,
1641                       u0 = y0 + hw_bufsize/2,
1642                       v0 = u0 + hw_bufsize/4,
1643                       y1 = v0 + hw_bufsize/4,
1644                       u1 = y1 + hw_bufsize/2,
1645                       v1 = u1 + hw_bufsize/4;
1646         int err = 0;
1647
1648         err += w9968cf_write_reg(cam, 0xff00, 0x00); /* power off */
1649         err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* power on */
1650
1651         err += w9968cf_write_reg(cam, 0x405d, 0x03); /* DRAM timings */
1652         err += w9968cf_write_reg(cam, 0x0030, 0x04); /* SDRAM timings */
1653
1654         err += w9968cf_write_reg(cam, y0 & 0xffff, 0x20); /* Y buf.0, low */
1655         err += w9968cf_write_reg(cam, y0 >> 16, 0x21);    /* Y buf.0, high */
1656         err += w9968cf_write_reg(cam, u0 & 0xffff, 0x24); /* U buf.0, low */
1657         err += w9968cf_write_reg(cam, u0 >> 16, 0x25);    /* U buf.0, high */
1658         err += w9968cf_write_reg(cam, v0 & 0xffff, 0x28); /* V buf.0, low */
1659         err += w9968cf_write_reg(cam, v0 >> 16, 0x29);    /* V buf.0, high */
1660
1661         err += w9968cf_write_reg(cam, y1 & 0xffff, 0x22); /* Y buf.1, low */
1662         err += w9968cf_write_reg(cam, y1 >> 16, 0x23);    /* Y buf.1, high */
1663         err += w9968cf_write_reg(cam, u1 & 0xffff, 0x26); /* U buf.1, low */
1664         err += w9968cf_write_reg(cam, u1 >> 16, 0x27);    /* U buf.1, high */
1665         err += w9968cf_write_reg(cam, v1 & 0xffff, 0x2a); /* V buf.1, low */
1666         err += w9968cf_write_reg(cam, v1 >> 16, 0x2b);    /* V buf.1, high */
1667
1668         err += w9968cf_write_reg(cam, y1 & 0xffff, 0x32); /* JPEG buf 0 low */
1669         err += w9968cf_write_reg(cam, y1 >> 16, 0x33);    /* JPEG buf 0 high */
1670
1671         err += w9968cf_write_reg(cam, y1 & 0xffff, 0x34); /* JPEG buf 1 low */
1672         err += w9968cf_write_reg(cam, y1 >> 16, 0x35);    /* JPEG bug 1 high */
1673
1674         err += w9968cf_write_reg(cam, 0x0000, 0x36);/* JPEG restart interval */
1675         err += w9968cf_write_reg(cam, 0x0804, 0x37);/*JPEG VLE FIFO threshold*/
1676         err += w9968cf_write_reg(cam, 0x0000, 0x38);/* disable hw up-scaling */
1677         err += w9968cf_write_reg(cam, 0x0000, 0x3f); /* JPEG/MCTL test data */
1678
1679         err += w9968cf_set_picture(cam, cam->picture); /* this before */
1680         err += w9968cf_set_window(cam, cam->window);
1681
1682         if (err)
1683                 DBG(1, "Chip initialization failed")
1684         else
1685                 DBG(5, "Chip successfully initialized")
1686
1687         return err;
1688 }
1689
1690
1691 /*--------------------------------------------------------------------------
1692   Return non-zero if the palette is supported, 0 otherwise.
1693   --------------------------------------------------------------------------*/
1694 static inline u16 w9968cf_valid_palette(u16 palette)
1695 {
1696         u8 i = 0;
1697         while (w9968cf_formatlist[i].palette != 0) {
1698                 if (palette == w9968cf_formatlist[i].palette)
1699                         return palette;
1700                 i++;
1701         }
1702         return 0;
1703 }
1704
1705
1706 /*--------------------------------------------------------------------------
1707   Return the depth corresponding to the given palette.
1708   Palette _must_ be supported !
1709   --------------------------------------------------------------------------*/
1710 static inline u16 w9968cf_valid_depth(u16 palette)
1711 {
1712         u8 i=0;
1713         while (w9968cf_formatlist[i].palette != palette)
1714                 i++;
1715
1716         return w9968cf_formatlist[i].depth;
1717 }
1718
1719
1720 /*--------------------------------------------------------------------------
1721   Return non-zero if the format requires decompression, 0 otherwise.
1722   --------------------------------------------------------------------------*/
1723 static inline u8 w9968cf_need_decompression(u16 palette)
1724 {
1725         u8 i = 0;
1726         while (w9968cf_formatlist[i].palette != 0) {
1727                 if (palette == w9968cf_formatlist[i].palette)
1728                         return w9968cf_formatlist[i].compression;
1729                 i++;
1730         }
1731         return 0;
1732 }
1733
1734
1735 /*--------------------------------------------------------------------------
1736   Change the picture settings of the camera.
1737   Return 0 on success, a negative number otherwise.
1738   --------------------------------------------------------------------------*/
1739 static int
1740 w9968cf_set_picture(struct w9968cf_device* cam, struct video_picture pict)
1741 {
1742         u16 fmt, hw_depth, hw_palette, reg_v = 0x0000;
1743         int err = 0;
1744
1745         /* Make sure we are using a valid depth */
1746         pict.depth = w9968cf_valid_depth(pict.palette);
1747
1748         fmt = pict.palette;
1749
1750         hw_depth = pict.depth; /* depth used by the winbond chip */
1751         hw_palette = pict.palette; /* palette used by the winbond chip */
1752
1753         /* VS & HS polarities */
1754         reg_v = (cam->vs_polarity << 12) | (cam->hs_polarity << 11);
1755
1756         switch (fmt)
1757         {
1758                 case VIDEO_PALETTE_UYVY:
1759                         reg_v |= 0x0000;
1760                         cam->vpp_flag = VPP_NONE;
1761                         break;
1762                 case VIDEO_PALETTE_YUV422P:
1763                         reg_v |= 0x0002;
1764                         cam->vpp_flag = VPP_DECOMPRESSION;
1765                         break;
1766                 case VIDEO_PALETTE_YUV420:
1767                 case VIDEO_PALETTE_YUV420P:
1768                         reg_v |= 0x0003;
1769                         cam->vpp_flag = VPP_DECOMPRESSION;
1770                         break;
1771                 case VIDEO_PALETTE_YUYV:
1772                 case VIDEO_PALETTE_YUV422:
1773                         reg_v |= 0x0000;
1774                         cam->vpp_flag = VPP_SWAP_YUV_BYTES;
1775                         hw_palette = VIDEO_PALETTE_UYVY;
1776                         break;
1777                 /* Original video is used instead of RGBX palettes.
1778                    Software conversion later. */
1779                 case VIDEO_PALETTE_GREY:
1780                 case VIDEO_PALETTE_RGB555:
1781                 case VIDEO_PALETTE_RGB565:
1782                 case VIDEO_PALETTE_RGB24:
1783                 case VIDEO_PALETTE_RGB32:
1784                         reg_v |= 0x0000; /* UYVY 16 bit is used */
1785                         hw_depth = 16;
1786                         hw_palette = VIDEO_PALETTE_UYVY;
1787                         cam->vpp_flag = VPP_UYVY_TO_RGBX;
1788                         break;
1789         }
1790
1791         /* NOTE: due to memory issues, it is better to disable the hardware
1792                  double buffering during compression */
1793         if (cam->double_buffer && !(cam->vpp_flag & VPP_DECOMPRESSION))
1794                 reg_v |= 0x0080;
1795
1796         if (cam->clamping)
1797                 reg_v |= 0x0020;
1798
1799         if (cam->filter_type == 1)
1800                 reg_v |= 0x0008;
1801         else if (cam->filter_type == 2)
1802                 reg_v |= 0x000c;
1803
1804         if ((err = w9968cf_write_reg(cam, reg_v, 0x16)))
1805                 goto error;
1806
1807         if ((err = w9968cf_sensor_update_picture(cam, pict)))
1808                 goto error;
1809
1810         /* If all went well, update the device data structure */
1811         memcpy(&cam->picture, &pict, sizeof(pict));
1812         cam->hw_depth = hw_depth;
1813         cam->hw_palette = hw_palette;
1814
1815         /* Settings changed, so we clear the frame buffers */
1816         memset(cam->frame[0].buffer, 0, cam->nbuffers*cam->frame[0].size);
1817
1818         DBG(4, "Palette is %s, depth is %u bpp",
1819             symbolic(v4l1_plist, pict.palette), pict.depth)
1820
1821         return 0;
1822
1823 error:
1824         DBG(1, "Failed to change picture settings")
1825         return err;
1826 }
1827
1828
1829 /*--------------------------------------------------------------------------
1830   Change the capture area size of the camera.
1831   This function _must_ be called _after_ w9968cf_set_picture().
1832   Return 0 on success, a negative number otherwise.
1833   --------------------------------------------------------------------------*/
1834 static int
1835 w9968cf_set_window(struct w9968cf_device* cam, struct video_window win)
1836 {
1837         u16 x, y, w, h, scx, scy, cw, ch, ax, ay;
1838         unsigned long fw, fh;
1839         struct ovcamchip_window s_win;
1840         int err = 0;
1841
1842         /* Work around to avoid FP arithmetics */
1843         #define __SC(x) ((x) << 10)
1844         #define __UNSC(x) ((x) >> 10)
1845
1846         /* Make sure we are using a supported resolution */
1847         if ((err = w9968cf_adjust_window_size(cam, (u16*)&win.width,
1848                                               (u16*)&win.height)))
1849                 goto error;
1850
1851         /* Scaling factors */
1852         fw = __SC(win.width) / cam->maxwidth;
1853         fh = __SC(win.height) / cam->maxheight;
1854
1855         /* Set up the width and height values used by the chip */
1856         if ((win.width > cam->maxwidth) || (win.height > cam->maxheight)) {
1857                 cam->vpp_flag |= VPP_UPSCALE;
1858                 /* Calculate largest w,h mantaining the same w/h ratio */
1859                 w = (fw >= fh) ? cam->maxwidth : __SC(win.width)/fh;
1860                 h = (fw >= fh) ? __SC(win.height)/fw : cam->maxheight;
1861                 if (w < cam->minwidth) /* just in case */
1862                         w = cam->minwidth;
1863                 if (h < cam->minheight) /* just in case */
1864                         h = cam->minheight;
1865         } else {
1866                 cam->vpp_flag &= ~VPP_UPSCALE;
1867                 w = win.width;
1868                 h = win.height;
1869         }
1870
1871         /* x,y offsets of the cropped area */
1872         scx = cam->start_cropx;
1873         scy = cam->start_cropy;
1874
1875         /* Calculate cropped area manteining the right w/h ratio */
1876         if (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE)) {
1877                 cw = (fw >= fh) ? cam->maxwidth : __SC(win.width)/fh;
1878                 ch = (fw >= fh) ? __SC(win.height)/fw : cam->maxheight;
1879         } else {
1880                 cw = w;
1881                 ch = h;
1882         }
1883
1884         /* Setup the window of the sensor */
1885         s_win.format = VIDEO_PALETTE_UYVY;
1886         s_win.width = cam->maxwidth;
1887         s_win.height = cam->maxheight;
1888         s_win.quarter = 0; /* full progressive video */
1889
1890         /* Center it */
1891         s_win.x = (s_win.width - cw) / 2;
1892         s_win.y = (s_win.height - ch) / 2;
1893
1894         /* Clock divisor */
1895         if (cam->clockdiv >= 0)
1896                 s_win.clockdiv = cam->clockdiv; /* manual override */
1897         else
1898                 switch (cam->sensor) {
1899                         case CC_OV6620:
1900                                 s_win.clockdiv = 0;
1901                                 break;
1902                         case CC_OV6630:
1903                                 s_win.clockdiv = 0;
1904                                 break;
1905                         case CC_OV76BE:
1906                         case CC_OV7610:
1907                         case CC_OV7620:
1908                                 s_win.clockdiv = 0;
1909                                 break;
1910                         default:
1911                                 s_win.clockdiv = W9968CF_DEF_CLOCKDIVISOR;
1912                 }
1913
1914         /* We have to scale win.x and win.y offsets */
1915         if ( (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE))
1916              || (cam->vpp_flag & VPP_UPSCALE) ) {
1917                 ax = __SC(win.x)/fw;
1918                 ay = __SC(win.y)/fh;
1919         } else {
1920                 ax = win.x;
1921                 ay = win.y;
1922         }
1923
1924         if ((ax + cw) > cam->maxwidth)
1925                 ax = cam->maxwidth - cw;
1926
1927         if ((ay + ch) > cam->maxheight)
1928                 ay = cam->maxheight - ch;
1929
1930         /* Adjust win.x, win.y */
1931         if ( (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE))
1932              || (cam->vpp_flag & VPP_UPSCALE) ) {
1933                 win.x = __UNSC(ax*fw);
1934                 win.y = __UNSC(ay*fh);
1935         } else {
1936                 win.x = ax;
1937                 win.y = ay;
1938         }
1939
1940         /* Offsets used by the chip */
1941         x = ax + s_win.x;
1942         y = ay + s_win.y;
1943
1944         /* Go ! */
1945         if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_S_MODE, &s_win)))
1946                 goto error;
1947
1948         err += w9968cf_write_reg(cam, scx + x, 0x10);
1949         err += w9968cf_write_reg(cam, scy + y, 0x11);
1950         err += w9968cf_write_reg(cam, scx + x + cw, 0x12);
1951         err += w9968cf_write_reg(cam, scy + y + ch, 0x13);
1952         err += w9968cf_write_reg(cam, w, 0x14);
1953         err += w9968cf_write_reg(cam, h, 0x15);
1954
1955         /* JPEG width & height */
1956         err += w9968cf_write_reg(cam, w, 0x30);
1957         err += w9968cf_write_reg(cam, h, 0x31);
1958
1959         /* Y & UV frame buffer strides (in WORD) */
1960         if (cam->vpp_flag & VPP_DECOMPRESSION) {
1961                 err += w9968cf_write_reg(cam, w/2, 0x2c);
1962                 err += w9968cf_write_reg(cam, w/4, 0x2d);
1963         } else
1964                 err += w9968cf_write_reg(cam, w, 0x2c);
1965
1966         if (err)
1967                 goto error;
1968
1969         /* If all went well, update the device data structure */
1970         memcpy(&cam->window, &win, sizeof(win));
1971         cam->hw_width = w;
1972         cam->hw_height = h;
1973
1974         /* Settings changed, so we clear the frame buffers */
1975         memset(cam->frame[0].buffer, 0, cam->nbuffers*cam->frame[0].size);
1976
1977         DBG(4, "The capture area is %dx%d, Offset (x,y)=(%u,%u)",
1978             win.width, win.height, win.x, win.y)
1979
1980         PDBGG("x=%u ,y=%u, w=%u, h=%u, ax=%u, ay=%u, s_win.x=%u, s_win.y=%u, "
1981               "cw=%u, ch=%u, win.x=%u, win.y=%u, win.width=%u, win.height=%u",
1982               x, y, w, h, ax, ay, s_win.x, s_win.y, cw, ch, win.x, win.y,
1983               win.width, win.height)
1984
1985         return 0;
1986
1987 error:
1988         DBG(1, "Failed to change the capture area size")
1989         return err;
1990 }
1991
1992
1993 /*--------------------------------------------------------------------------
1994   Adjust the asked values for window width and height.
1995   Return 0 on success, -1 otherwise.
1996   --------------------------------------------------------------------------*/
1997 static int
1998 w9968cf_adjust_window_size(struct w9968cf_device* cam, u16* width, u16* height)
1999 {
2000         u16 maxw, maxh;
2001
2002         if ((*width < cam->minwidth) || (*height < cam->minheight))
2003                 return -ERANGE;
2004
2005         maxw = cam->upscaling && !(cam->vpp_flag & VPP_DECOMPRESSION) &&
2006                w9968cf_vpp ? max((u16)W9968CF_MAX_WIDTH, cam->maxwidth)
2007                            : cam->maxwidth;
2008         maxh = cam->upscaling && !(cam->vpp_flag & VPP_DECOMPRESSION) &&
2009                w9968cf_vpp ? max((u16)W9968CF_MAX_HEIGHT, cam->maxheight)
2010                            : cam->maxheight;
2011
2012         if (*width > maxw)
2013                 *width = maxw;
2014         if (*height > maxh)
2015                 *height = maxh;
2016
2017         if (cam->vpp_flag & VPP_DECOMPRESSION) {
2018                 *width  &= ~15L; /* multiple of 16 */
2019                 *height &= ~15L;
2020         }
2021
2022         PDBGG("Window size adjusted w=%u, h=%u ", *width, *height)
2023
2024         return 0;
2025 }
2026
2027
2028 /*--------------------------------------------------------------------------
2029   Initialize the FIFO list of requested frames.
2030   --------------------------------------------------------------------------*/
2031 static void w9968cf_init_framelist(struct w9968cf_device* cam)
2032 {
2033         u8 i;
2034
2035         for (i = 0; i < cam->nbuffers; i++) {
2036                 cam->requested_frame[i] = NULL;
2037                 cam->frame[i].queued = 0;
2038                 cam->frame[i].status = F_UNUSED;
2039         }
2040 }
2041
2042
2043 /*--------------------------------------------------------------------------
2044   Add a frame in the FIFO list of requested frames.
2045   This function is called in process context.
2046   --------------------------------------------------------------------------*/
2047 static void w9968cf_push_frame(struct w9968cf_device* cam, u8 f_num)
2048 {
2049         u8 f;
2050         unsigned long lock_flags;
2051
2052         spin_lock_irqsave(&cam->flist_lock, lock_flags);
2053
2054         for (f=0; cam->requested_frame[f] != NULL; f++);
2055         cam->requested_frame[f] = &cam->frame[f_num];
2056         cam->frame[f_num].queued = 1;
2057         cam->frame[f_num].status = F_UNUSED; /* clear the status */
2058
2059         spin_unlock_irqrestore(&cam->flist_lock, lock_flags);
2060
2061         DBG(6, "Frame #%u pushed into the FIFO list. Position %u", f_num, f)
2062 }
2063
2064
2065 /*--------------------------------------------------------------------------
2066   Read, store and remove the first pointer in the FIFO list of requested
2067   frames. This function is called in interrupt context.
2068   --------------------------------------------------------------------------*/
2069 static void
2070 w9968cf_pop_frame(struct w9968cf_device* cam, struct w9968cf_frame_t** framep)
2071 {
2072         u8 i;
2073
2074         spin_lock(&cam->flist_lock);
2075
2076         *framep = cam->requested_frame[0];
2077
2078         /* Shift the list of pointers */
2079         for (i = 0; i < cam->nbuffers-1; i++)
2080                 cam->requested_frame[i] = cam->requested_frame[i+1];
2081         cam->requested_frame[i] = NULL;
2082
2083         spin_unlock(&cam->flist_lock);
2084
2085         DBG(6,"Popped frame #%d from the list", (*framep)->number)
2086 }
2087
2088
2089 /*--------------------------------------------------------------------------
2090   High-level video post-processing routine on grabbed frames.
2091   Return 0 on success, a negative number otherwise.
2092   --------------------------------------------------------------------------*/
2093 static int
2094 w9968cf_postprocess_frame(struct w9968cf_device* cam,
2095                           struct w9968cf_frame_t* fr)
2096 {
2097         void *pIn = fr->buffer, *pOut = cam->frame_vpp.buffer, *tmp;
2098         u16 w = cam->window.width,
2099             h = cam->window.height,
2100             d = cam->picture.depth,
2101             fmt = cam->picture.palette,
2102             rgb = cam->force_rgb,
2103             hw_w = cam->hw_width,
2104             hw_h = cam->hw_height,
2105             hw_d = cam->hw_depth;
2106         int err = 0;
2107
2108         #define _PSWAP(pIn, pOut) {tmp = (pIn); (pIn) = (pOut); (pOut) = tmp;}
2109
2110         if (cam->vpp_flag & VPP_DECOMPRESSION) {
2111                 memcpy(pOut, pIn, fr->length);
2112                 _PSWAP(pIn, pOut)
2113                 err = w9968cf_vpp->decode(pIn, fr->length, hw_w, hw_h, pOut);
2114                 PDBGG("Compressed frame length: %lu",(unsigned long)fr->length)
2115                 fr->length = (hw_w*hw_h*hw_d)/8;
2116                 _PSWAP(pIn, pOut)
2117                 if (err) {
2118                         DBG(4, "An error occurred while decoding the frame: "
2119                                "%s", symbolic(decoder_errlist, err))
2120                         return err;
2121                 } else
2122                         DBG(6, "Frame decoded")
2123         }
2124
2125         if (cam->vpp_flag & VPP_SWAP_YUV_BYTES) {
2126                 w9968cf_vpp->swap_yuvbytes(pIn, fr->length);
2127                 DBG(6, "Original UYVY component ordering changed")
2128         }
2129
2130         if (cam->vpp_flag & VPP_UPSCALE) {
2131                 w9968cf_vpp->scale_up(pIn, pOut, hw_w, hw_h, hw_d, w, h);
2132                 fr->length = (w*h*hw_d)/8;
2133                 _PSWAP(pIn, pOut)
2134                 DBG(6, "Vertical up-scaling done: %u,%u,%ubpp->%u,%u",
2135                     hw_w, hw_h, hw_d, w, h)
2136         }
2137
2138         if (cam->vpp_flag & VPP_UYVY_TO_RGBX) {
2139                 w9968cf_vpp->uyvy_to_rgbx(pIn, fr->length, pOut, fmt, rgb);
2140                 fr->length = (w*h*d)/8;
2141                 _PSWAP(pIn, pOut)
2142                 DBG(6, "UYVY-16bit to %s conversion done",
2143                     symbolic(v4l1_plist, fmt))
2144         }
2145
2146         if (pOut == fr->buffer)
2147                 memcpy(fr->buffer, cam->frame_vpp.buffer, fr->length);
2148
2149         return 0;
2150 }
2151
2152
2153
2154 /****************************************************************************
2155  * Image sensor control routines                                            *
2156  ****************************************************************************/
2157
2158 static int
2159 w9968cf_sensor_set_control(struct w9968cf_device* cam, int cid, int val)
2160 {
2161         struct ovcamchip_control ctl;
2162         int err;
2163
2164         ctl.id = cid;
2165         ctl.value = val;
2166
2167         err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_S_CTRL, &ctl);
2168
2169         return err;
2170 }
2171
2172
2173 static int
2174 w9968cf_sensor_get_control(struct w9968cf_device* cam, int cid, int* val)
2175 {
2176         struct ovcamchip_control ctl;
2177         int err;
2178
2179         ctl.id = cid;
2180
2181         err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_G_CTRL, &ctl);
2182         if (!err)
2183                 *val = ctl.value;
2184
2185         return err;
2186 }
2187
2188
2189 static int
2190 w9968cf_sensor_cmd(struct w9968cf_device* cam, unsigned int cmd, void* arg)
2191 {
2192         struct i2c_client* c = cam->sensor_client;
2193         int rc = 0;
2194
2195         if (!c || !c->driver || !c->driver->command)
2196                 return -EINVAL;
2197
2198         rc = c->driver->command(c, cmd, arg);
2199         /* The I2C driver returns -EPERM on non-supported controls */
2200         return (rc < 0 && rc != -EPERM) ? rc : 0;
2201 }
2202
2203
2204 /*--------------------------------------------------------------------------
2205   Update some settings of the image sensor.
2206   Returns: 0 on success, a negative number otherwise.
2207   --------------------------------------------------------------------------*/
2208 static int w9968cf_sensor_update_settings(struct w9968cf_device* cam)
2209 {
2210         int err = 0;
2211
2212         /* Auto brightness */
2213         err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_AUTOBRIGHT,
2214                                          cam->auto_brt);
2215         if (err)
2216                 return err;
2217
2218         /* Auto exposure */
2219         err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_AUTOEXP,
2220                                          cam->auto_exp);
2221         if (err)
2222                 return err;
2223
2224         /* Banding filter */
2225         err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BANDFILT,
2226                                          cam->bandfilt);
2227         if (err)
2228                 return err;
2229
2230         /* Light frequency */
2231         err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_FREQ,
2232                                          cam->lightfreq);
2233         if (err)
2234                 return err;
2235
2236         /* Back light */
2237         err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BACKLIGHT,
2238                                          cam->backlight);
2239         if (err)
2240                 return err;
2241
2242         /* Mirror */
2243         err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_MIRROR,
2244                                          cam->mirror);
2245         if (err)
2246                 return err;
2247
2248         return 0;
2249 }
2250
2251
2252 /*--------------------------------------------------------------------------
2253   Get some current picture settings from the image sensor and update the
2254   internal 'picture' structure of the camera.
2255   Returns: 0 on success, a negative number otherwise.
2256   --------------------------------------------------------------------------*/
2257 static int w9968cf_sensor_get_picture(struct w9968cf_device* cam)
2258 {
2259         int err, v;
2260
2261         err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_CONT, &v);
2262         if (err)
2263                 return err;
2264         cam->picture.contrast = v;
2265
2266         err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_BRIGHT, &v);
2267         if (err)
2268                 return err;
2269         cam->picture.brightness = v;
2270
2271         err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_SAT, &v);
2272         if (err)
2273                 return err;
2274         cam->picture.colour = v;
2275
2276         err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_HUE, &v);
2277         if (err)
2278                 return err;
2279         cam->picture.hue = v;
2280
2281         DBG(5, "Got picture settings from the image sensor")
2282
2283         PDBGG("Brightness, contrast, hue, colour, whiteness are "
2284               "%u,%u,%u,%u,%u", cam->picture.brightness,cam->picture.contrast,
2285               cam->picture.hue, cam->picture.colour, cam->picture.whiteness)
2286
2287         return 0;
2288 }
2289
2290
2291 /*--------------------------------------------------------------------------
2292   Update picture settings of the image sensor.
2293   Returns: 0 on success, a negative number otherwise.
2294   --------------------------------------------------------------------------*/
2295 static int
2296 w9968cf_sensor_update_picture(struct w9968cf_device* cam,
2297                               struct video_picture pict)
2298 {
2299         int err = 0;
2300
2301         if ((!cam->sensor_initialized)
2302             || pict.contrast != cam->picture.contrast) {
2303                 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_CONT,
2304                                                  pict.contrast);
2305                 if (err)
2306                         goto fail;
2307                 DBG(4, "Contrast changed from %u to %u",
2308                     cam->picture.contrast, pict.contrast)
2309                 cam->picture.contrast = pict.contrast;
2310         }
2311
2312         if (((!cam->sensor_initialized) ||
2313             pict.brightness != cam->picture.brightness) && (!cam->auto_brt)) {
2314                 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BRIGHT,
2315                                                  pict.brightness);
2316                 if (err)
2317                         goto fail;
2318                 DBG(4, "Brightness changed from %u to %u",
2319                     cam->picture.brightness, pict.brightness)
2320                 cam->picture.brightness = pict.brightness;
2321         }
2322
2323         if ((!cam->sensor_initialized) || pict.colour != cam->picture.colour) {
2324                 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_SAT,
2325                                                  pict.colour);
2326                 if (err)
2327                         goto fail;
2328                 DBG(4, "Colour changed from %u to %u",
2329                     cam->picture.colour, pict.colour)
2330                 cam->picture.colour = pict.colour;
2331         }
2332
2333         if ((!cam->sensor_initialized) || pict.hue != cam->picture.hue) {
2334                 err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_HUE,
2335                                                  pict.hue);
2336                 if (err)
2337                         goto fail;
2338                 DBG(4, "Hue changed from %u to %u",
2339                     cam->picture.hue, pict.hue)
2340                 cam->picture.hue = pict.hue;
2341         }
2342
2343         return 0;
2344
2345 fail:
2346         DBG(4, "Failed to change sensor picture setting")
2347         return err;
2348 }
2349
2350
2351
2352 /****************************************************************************
2353  * Camera configuration                                                     *
2354  ****************************************************************************/
2355
2356 /*--------------------------------------------------------------------------
2357   This function is called when a supported image sensor is detected.
2358   Return 0 if the initialization succeeds, a negative number otherwise.
2359   --------------------------------------------------------------------------*/
2360 static int w9968cf_sensor_init(struct w9968cf_device* cam)
2361 {
2362         int err = 0;
2363
2364         if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_INITIALIZE,
2365                                       &cam->monochrome)))
2366                 goto error;
2367
2368         if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_Q_SUBTYPE,
2369                                       &cam->sensor)))
2370                 goto error;
2371
2372         /* NOTE: Make sure width and height are a multiple of 16 */
2373         switch (cam->sensor_client->addr) {
2374                 case OV6xx0_SID:
2375                         cam->maxwidth = 352;
2376                         cam->maxheight = 288;
2377                         cam->minwidth = 64;
2378                         cam->minheight = 48;
2379                         break;
2380                 case OV7xx0_SID:
2381                         cam->maxwidth = 640;
2382                         cam->maxheight = 480;
2383                         cam->minwidth = 64;
2384                         cam->minheight = 48;
2385                         break;
2386                 default:
2387                         DBG(1, "Not supported image sensor detected for %s",
2388                             symbolic(camlist, cam->id))
2389                         return -EINVAL;
2390         }
2391
2392         /* These values depend on the ones in the ovxxx0.c sources */
2393         switch (cam->sensor) {
2394                 case CC_OV7620:
2395                         cam->start_cropx = 287;
2396                         cam->start_cropy = 35;
2397                         /* Seems to work around a bug in the image sensor */
2398                         cam->vs_polarity = 1;
2399                         cam->hs_polarity = 1;
2400                         break;
2401                 default:
2402                         cam->start_cropx = 320;
2403                         cam->start_cropy = 35;
2404                         cam->vs_polarity = 1;
2405                         cam->hs_polarity = 0;
2406         }
2407
2408         if ((err = w9968cf_sensor_update_settings(cam)))
2409                 goto error;
2410
2411         if ((err = w9968cf_sensor_update_picture(cam, cam->picture)))
2412                 goto error;
2413
2414         cam->sensor_initialized = 1;
2415
2416         DBG(2, "%s image sensor initialized", symbolic(senlist, cam->sensor))
2417         return 0;
2418
2419 error:
2420         cam->sensor_initialized = 0;
2421         cam->sensor = CC_UNKNOWN;
2422         DBG(1, "Image sensor initialization failed for %s (/dev/video%d). "
2423                "Try to detach and attach this device again",
2424             symbolic(camlist, cam->id), cam->v4ldev->minor)
2425         return err;
2426 }
2427
2428
2429 /*--------------------------------------------------------------------------
2430   Fill some basic fields in the main device data structure.
2431   This function is called once on w9968cf_usb_probe() for each recognized
2432   camera.
2433   --------------------------------------------------------------------------*/
2434 static void
2435 w9968cf_configure_camera(struct w9968cf_device* cam,
2436                          struct usb_device* udev,
2437                          enum w9968cf_model_id mod_id,
2438                          const unsigned short dev_nr)
2439 {
2440         init_MUTEX(&cam->fileop_sem);
2441         init_waitqueue_head(&cam->open);
2442         spin_lock_init(&cam->urb_lock);
2443         spin_lock_init(&cam->flist_lock);
2444
2445         cam->users = 0;
2446         cam->disconnected = 0;
2447         cam->id = mod_id;
2448         cam->sensor = CC_UNKNOWN;
2449         cam->sensor_initialized = 0;
2450
2451         /* Calculate the alternate setting number (from 1 to 16)
2452            according to the 'packet_size' module parameter */
2453         if (packet_size[dev_nr] < W9968CF_MIN_PACKET_SIZE)
2454                 packet_size[dev_nr] = W9968CF_MIN_PACKET_SIZE;
2455         for (cam->altsetting = 1;
2456              packet_size[dev_nr] < wMaxPacketSize[cam->altsetting-1];
2457              cam->altsetting++);
2458
2459         cam->max_buffers = (max_buffers[dev_nr] < 2 ||
2460                             max_buffers[dev_nr] > W9968CF_MAX_BUFFERS)
2461                            ? W9968CF_BUFFERS : (u8)max_buffers[dev_nr];
2462
2463         cam->double_buffer = (double_buffer[dev_nr] == 0 ||
2464                               double_buffer[dev_nr] == 1)
2465                              ? (u8)double_buffer[dev_nr]:W9968CF_DOUBLE_BUFFER;
2466
2467         cam->clamping = (clamping[dev_nr] == 0 || clamping[dev_nr] == 1)
2468                         ? (u8)clamping[dev_nr] : W9968CF_CLAMPING;
2469
2470         cam->filter_type = (filter_type[dev_nr] == 0 ||
2471                             filter_type[dev_nr] == 1 ||
2472                             filter_type[dev_nr] == 2)
2473                            ? (u8)filter_type[dev_nr] : W9968CF_FILTER_TYPE;
2474
2475         cam->capture = 1;
2476
2477         cam->largeview = (largeview[dev_nr] == 0 || largeview[dev_nr] == 1)
2478                          ? (u8)largeview[dev_nr] : W9968CF_LARGEVIEW;
2479
2480         cam->decompression = (decompression[dev_nr] == 0 ||
2481                               decompression[dev_nr] == 1 ||
2482                               decompression[dev_nr] == 2)
2483                              ? (u8)decompression[dev_nr]:W9968CF_DECOMPRESSION;
2484
2485         cam->upscaling = (upscaling[dev_nr] == 0 ||
2486                           upscaling[dev_nr] == 1)
2487                          ? (u8)upscaling[dev_nr] : W9968CF_UPSCALING;
2488
2489         cam->auto_brt = (autobright[dev_nr] == 0 || autobright[dev_nr] == 1)
2490                         ? (u8)autobright[dev_nr] : W9968CF_AUTOBRIGHT;
2491
2492         cam->auto_exp = (autoexp[dev_nr] == 0 || autoexp[dev_nr] == 1)
2493                         ? (u8)autoexp[dev_nr] : W9968CF_AUTOEXP;
2494
2495         cam->lightfreq = (lightfreq[dev_nr] == 50 || lightfreq[dev_nr] == 60)
2496                          ? (u8)lightfreq[dev_nr] : W9968CF_LIGHTFREQ;
2497
2498         cam->bandfilt = (bandingfilter[dev_nr] == 0 ||
2499                          bandingfilter[dev_nr] == 1)
2500                         ? (u8)bandingfilter[dev_nr] : W9968CF_BANDINGFILTER;
2501
2502         cam->backlight = (backlight[dev_nr] == 0 || backlight[dev_nr] == 1)
2503                          ? (u8)backlight[dev_nr] : W9968CF_BACKLIGHT;
2504
2505         cam->clockdiv = (clockdiv[dev_nr] == -1 || clockdiv[dev_nr] >= 0)
2506                         ? (s8)clockdiv[dev_nr] : W9968CF_CLOCKDIV;
2507
2508         cam->mirror = (mirror[dev_nr] == 0 || mirror[dev_nr] == 1)
2509                       ? (u8)mirror[dev_nr] : W9968CF_MIRROR;
2510
2511         cam->monochrome = (monochrome[dev_nr] == 0 || monochrome[dev_nr] == 1)
2512                           ? monochrome[dev_nr] : W9968CF_MONOCHROME;
2513
2514         cam->picture.brightness = (u16)brightness[dev_nr];
2515         cam->picture.hue = (u16)hue[dev_nr];
2516         cam->picture.colour = (u16)colour[dev_nr];
2517         cam->picture.contrast = (u16)contrast[dev_nr];
2518         cam->picture.whiteness = (u16)whiteness[dev_nr];
2519         if (w9968cf_valid_palette((u16)force_palette[dev_nr])) {
2520                 cam->picture.palette = (u16)force_palette[dev_nr];
2521                 cam->force_palette = 1;
2522         } else {
2523                 cam->force_palette = 0;
2524                 if (cam->decompression == 0)
2525                         cam->picture.palette = W9968CF_PALETTE_DECOMP_OFF;
2526                 else if (cam->decompression == 1)
2527                         cam->picture.palette = W9968CF_PALETTE_DECOMP_FORCE;
2528                 else
2529                         cam->picture.palette = W9968CF_PALETTE_DECOMP_ON;
2530         }
2531         cam->picture.depth = w9968cf_valid_depth(cam->picture.palette);
2532
2533         cam->force_rgb = (force_rgb[dev_nr] == 0 || force_rgb[dev_nr] == 1)
2534                          ? (u8)force_rgb[dev_nr] : W9968CF_FORCE_RGB;
2535
2536         cam->window.x = 0;
2537         cam->window.y = 0;
2538         cam->window.width = W9968CF_WIDTH;
2539         cam->window.height = W9968CF_HEIGHT;
2540         cam->window.chromakey = 0;
2541         cam->window.clipcount = 0;
2542         cam->window.flags = 0;
2543
2544         DBG(3, "%s configured with settings #%u:",
2545             symbolic(camlist, cam->id), dev_nr)
2546
2547         DBG(3, "- Data packet size for USB isochrnous transfer: %u bytes",
2548             wMaxPacketSize[cam->altsetting-1])
2549
2550         DBG(3, "- Number of requested video frame buffers: %u",
2551             cam->max_buffers)
2552
2553         if (cam->double_buffer)
2554                 DBG(3, "- Hardware double buffering enabled")
2555         else
2556                 DBG(3, "- Hardware double buffering disabled")
2557
2558         if (cam->filter_type == 0)
2559                 DBG(3, "- Video filtering disabled")
2560         else if (cam->filter_type == 1)
2561                 DBG(3, "- Video filtering enabled: type 1-2-1")
2562         else if (cam->filter_type == 2)
2563                 DBG(3, "- Video filtering enabled: type 2-3-6-3-2")
2564
2565         if (cam->clamping)
2566                 DBG(3, "- Video data clamping (CCIR-601 format) enabled")
2567         else
2568                 DBG(3, "- Video data clamping (CCIR-601 format) disabled")
2569
2570         if (cam->largeview)
2571                 DBG(3, "- Large view enabled")
2572         else
2573                 DBG(3, "- Large view disabled")
2574
2575         if ((cam->decompression) == 0 && (!cam->force_palette))
2576                 DBG(3, "- Decompression disabled")
2577         else if ((cam->decompression) == 1 && (!cam->force_palette))
2578                 DBG(3, "- Decompression forced")
2579         else if ((cam->decompression) == 2 && (!cam->force_palette))
2580                 DBG(3, "- Decompression allowed")
2581
2582         if (cam->upscaling)
2583                 DBG(3, "- Software image scaling enabled")
2584         else
2585                 DBG(3, "- Software image scaling disabled")
2586
2587         if (cam->force_palette)
2588                 DBG(3, "- Image palette forced to %s",
2589                     symbolic(v4l1_plist, cam->picture.palette))
2590
2591         if (cam->force_rgb)
2592                 DBG(3, "- RGB component ordering will be used instead of BGR")
2593
2594         if (cam->auto_brt)
2595                 DBG(3, "- Auto brightness enabled")
2596         else
2597                 DBG(3, "- Auto brightness disabled")
2598
2599         if (cam->auto_exp)
2600                 DBG(3, "- Auto exposure enabled")
2601         else
2602                 DBG(3, "- Auto exposure disabled")
2603
2604         if (cam->backlight)
2605                 DBG(3, "- Backlight exposure algorithm enabled")
2606         else
2607                 DBG(3, "- Backlight exposure algorithm disabled")
2608
2609         if (cam->mirror)
2610                 DBG(3, "- Mirror enabled")
2611         else
2612                 DBG(3, "- Mirror disabled")
2613
2614         if (cam->bandfilt)
2615                 DBG(3, "- Banding filter enabled")
2616         else
2617                 DBG(3, "- Banding filter disabled")
2618
2619         DBG(3, "- Power lighting frequency: %u", cam->lightfreq)
2620
2621         if (cam->clockdiv == -1)
2622                 DBG(3, "- Automatic clock divisor enabled")
2623         else
2624                 DBG(3, "- Clock divisor: %d", cam->clockdiv)
2625
2626         if (cam->monochrome)
2627                 DBG(3, "- Image sensor used as monochrome")
2628         else
2629                 DBG(3, "- Image sensor not used as monochrome")
2630 }
2631
2632
2633 /*--------------------------------------------------------------------------
2634   If the video post-processing module is not loaded, some parameters
2635   must be overridden.
2636   --------------------------------------------------------------------------*/
2637 static void w9968cf_adjust_configuration(struct w9968cf_device* cam)
2638 {
2639         if (!w9968cf_vpp) {
2640                 if (cam->decompression == 1) {
2641                         cam->decompression = 2;
2642                         DBG(2, "Video post-processing module not found: "
2643                                "'decompression' parameter forced to 2")
2644                 }
2645                 if (cam->upscaling) {
2646                         cam->upscaling = 0;
2647                         DBG(2, "Video post-processing module not found: "
2648                                "'upscaling' parameter forced to 0")
2649                 }
2650                 if (cam->picture.palette != VIDEO_PALETTE_UYVY) {
2651                         cam->force_palette = 0;
2652                         DBG(2, "Video post-processing module not found: "
2653                                "'force_palette' parameter forced to 0")
2654                 }
2655                 cam->picture.palette = VIDEO_PALETTE_UYVY;
2656                 cam->picture.depth = w9968cf_valid_depth(cam->picture.palette);
2657         }
2658 }
2659
2660
2661 /*--------------------------------------------------------------------------
2662   Release the resources used by the driver.
2663   This function is called on disconnect
2664   (or on close if deallocation has been deferred)
2665   --------------------------------------------------------------------------*/
2666 static void w9968cf_release_resources(struct w9968cf_device* cam)
2667 {
2668         down(&w9968cf_devlist_sem);
2669
2670         DBG(2, "V4L device deregistered: /dev/video%d", cam->v4ldev->minor)
2671
2672         video_unregister_device(cam->v4ldev);
2673         list_del(&cam->v4llist);
2674         i2c_del_adapter(&cam->i2c_adapter);
2675         w9968cf_deallocate_memory(cam);
2676         kfree(cam->control_buffer);
2677         kfree(cam->data_buffer);
2678
2679         up(&w9968cf_devlist_sem);
2680 }
2681
2682
2683
2684 /****************************************************************************
2685  * Video4Linux interface                                                    *
2686  ****************************************************************************/
2687
2688 static int w9968cf_open(struct inode* inode, struct file* filp)
2689 {
2690         struct w9968cf_device* cam;
2691         int err;
2692
2693         /* This the only safe way to prevent race conditions with disconnect */
2694         if (!down_read_trylock(&w9968cf_disconnect))
2695                 return -ERESTARTSYS;
2696
2697         cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2698
2699         down(&cam->dev_sem);
2700
2701         if (cam->sensor == CC_UNKNOWN) {
2702                 DBG(2, "No supported image sensor has been detected by the "
2703                        "'ovcamchip' module for the %s (/dev/video%d). Make "
2704                        "sure it is loaded *before* (re)connecting the camera.",
2705                     symbolic(camlist, cam->id), cam->v4ldev->minor)
2706                 up(&cam->dev_sem);
2707                 up_read(&w9968cf_disconnect);
2708                 return -ENODEV;
2709         }
2710
2711         if (cam->users) {
2712                 DBG(2, "%s (/dev/video%d) has been already occupied by '%s'",
2713                     symbolic(camlist, cam->id),cam->v4ldev->minor,cam->command)
2714                 if ((filp->f_flags & O_NONBLOCK)||(filp->f_flags & O_NDELAY)) {
2715                         up(&cam->dev_sem);
2716                         up_read(&w9968cf_disconnect);
2717                         return -EWOULDBLOCK;
2718                 }
2719                 up(&cam->dev_sem);
2720                 err = wait_event_interruptible_exclusive(cam->open,
2721                                                          cam->disconnected ||
2722                                                          !cam->users);
2723                 if (err) {
2724                         up_read(&w9968cf_disconnect);
2725                         return err;
2726                 }
2727                 if (cam->disconnected) {
2728                         up_read(&w9968cf_disconnect);
2729                         return -ENODEV;
2730                 }
2731                 down(&cam->dev_sem);
2732         }
2733
2734         DBG(5, "Opening '%s', /dev/video%d ...",
2735             symbolic(camlist, cam->id), cam->v4ldev->minor)
2736
2737         cam->streaming = 0;
2738         cam->misconfigured = 0;
2739
2740         if (!w9968cf_vpp)
2741                 if ((err = w9968cf_vppmod_detect(cam)))
2742                         goto out;
2743
2744         if ((err = w9968cf_allocate_memory(cam)))
2745                 goto deallocate_memory;
2746
2747         if ((err = w9968cf_init_chip(cam)))
2748                 goto deallocate_memory;
2749
2750         if ((err = w9968cf_start_transfer(cam)))
2751                 goto deallocate_memory;
2752
2753         filp->private_data = cam;
2754
2755         cam->users++;
2756         strcpy(cam->command, current->comm);
2757
2758         init_waitqueue_head(&cam->wait_queue);
2759
2760         DBG(5, "Video device is open")
2761
2762         up(&cam->dev_sem);
2763         up_read(&w9968cf_disconnect);
2764
2765         return 0;
2766
2767 deallocate_memory:
2768         w9968cf_deallocate_memory(cam);
2769 out:
2770         DBG(2, "Failed to open the video device")
2771         up(&cam->dev_sem);
2772         up_read(&w9968cf_disconnect);
2773         return err;
2774 }
2775
2776
2777 static int w9968cf_release(struct inode* inode, struct file* filp)
2778 {
2779         struct w9968cf_device* cam;
2780
2781         cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2782
2783         down(&cam->dev_sem); /* prevent disconnect() to be called */
2784
2785         w9968cf_stop_transfer(cam);
2786
2787         w9968cf_vppmod_release(cam);
2788
2789         if (cam->disconnected) {
2790                 w9968cf_release_resources(cam);
2791                 up(&cam->dev_sem);
2792                 kfree(cam);
2793                 return 0;
2794         }
2795
2796         cam->users--;
2797         w9968cf_deallocate_memory(cam);
2798         wake_up_interruptible_nr(&cam->open, 1);
2799
2800         DBG(5, "Video device closed")
2801         up(&cam->dev_sem);
2802         return 0;
2803 }
2804
2805
2806 static ssize_t
2807 w9968cf_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
2808 {
2809         struct w9968cf_device* cam;
2810         struct w9968cf_frame_t* fr;
2811         int err = 0;
2812
2813         cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2814
2815         if (filp->f_flags & O_NONBLOCK)
2816                 return -EWOULDBLOCK;
2817
2818         if (down_interruptible(&cam->fileop_sem))
2819                 return -ERESTARTSYS;
2820
2821         if (cam->disconnected) {
2822                 DBG(2, "Device not present")
2823                 up(&cam->fileop_sem);
2824                 return -ENODEV;
2825         }
2826
2827         if (cam->misconfigured) {
2828                 DBG(2, "The camera is misconfigured. Close and open it again.")
2829                 up(&cam->fileop_sem);
2830                 return -EIO;
2831         }
2832
2833         if (!cam->frame[0].queued)
2834                 w9968cf_push_frame(cam, 0);
2835
2836         if (!cam->frame[1].queued)
2837                 w9968cf_push_frame(cam, 1);
2838
2839         err = wait_event_interruptible(cam->wait_queue,
2840                                        cam->frame[0].status == F_READY ||
2841                                        cam->frame[1].status == F_READY ||
2842                                        cam->disconnected);
2843         if (err) {
2844                 up(&cam->fileop_sem);
2845                 return err;
2846         }
2847         if (cam->disconnected) {
2848                 up(&cam->fileop_sem);
2849                 return -ENODEV;
2850         }
2851
2852         fr = (cam->frame[0].status == F_READY) ? &cam->frame[0]:&cam->frame[1];
2853
2854         if (w9968cf_vpp)
2855                 w9968cf_postprocess_frame(cam, fr);
2856
2857         if (count > fr->length)
2858                 count = fr->length;
2859
2860         if (copy_to_user(buf, fr->buffer, count)) {
2861                 fr->status = F_UNUSED;
2862                 up(&cam->fileop_sem);
2863                 return -EFAULT;
2864         }
2865         *f_pos += count;
2866
2867         fr->status = F_UNUSED;
2868
2869         DBG(5, "%zu bytes read", count)
2870
2871         up(&cam->fileop_sem);
2872         return count;
2873 }
2874
2875
2876 static int w9968cf_mmap(struct file* filp, struct vm_area_struct *vma)
2877 {
2878         struct w9968cf_device* cam = (struct w9968cf_device*)
2879                                      video_get_drvdata(video_devdata(filp));
2880         unsigned long vsize = vma->vm_end - vma->vm_start,
2881                       psize = cam->nbuffers * cam->frame[0].size,
2882                       start = vma->vm_start,
2883                       pos = (unsigned long)cam->frame[0].buffer,
2884                       page;
2885
2886         if (cam->disconnected) {
2887                 DBG(2, "Device not present")
2888                 return -ENODEV;
2889         }
2890
2891         if (cam->misconfigured) {
2892                 DBG(2, "The camera is misconfigured. Close and open it again")
2893                 return -EIO;
2894         }
2895
2896         PDBGG("mmapping %lu bytes...", vsize)
2897
2898         if (vsize > psize - (vma->vm_pgoff << PAGE_SHIFT))
2899                 return -EINVAL;
2900
2901         while (vsize > 0) {
2902                 page = vmalloc_to_pfn((void *)pos);
2903                 if (remap_pfn_range(vma, start, page + vma->vm_pgoff,
2904                                                 PAGE_SIZE, vma->vm_page_prot))
2905                         return -EAGAIN;
2906                 start += PAGE_SIZE;
2907                 pos += PAGE_SIZE;
2908                 vsize -= PAGE_SIZE;
2909         }
2910
2911         DBG(5, "mmap method successfully called")
2912         return 0;
2913 }
2914
2915
2916 static int
2917 w9968cf_ioctl(struct inode* inode, struct file* filp,
2918               unsigned int cmd, unsigned long arg)
2919 {
2920         struct w9968cf_device* cam;
2921         int err;
2922
2923         cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2924
2925         if (down_interruptible(&cam->fileop_sem))
2926                 return -ERESTARTSYS;
2927
2928         if (cam->disconnected) {
2929                 DBG(2, "Device not present")
2930                 up(&cam->fileop_sem);
2931                 return -ENODEV;
2932         }
2933
2934         if (cam->misconfigured) {
2935                 DBG(2, "The camera is misconfigured. Close and open it again.")
2936                 up(&cam->fileop_sem);
2937                 return -EIO;
2938         }
2939
2940         err = w9968cf_v4l_ioctl(inode, filp, cmd, (void __user *)arg);
2941
2942         up(&cam->fileop_sem);
2943         return err;
2944 }
2945
2946
2947 static int w9968cf_v4l_ioctl(struct inode* inode, struct file* filp,
2948                              unsigned int cmd, void __user * arg)
2949 {
2950         struct w9968cf_device* cam;
2951         const char* v4l1_ioctls[] = {
2952                 "?", "CGAP", "GCHAN", "SCHAN", "GTUNER", "STUNER",
2953                 "GPICT", "SPICT", "CCAPTURE", "GWIN", "SWIN", "GFBUF",
2954                 "SFBUF", "KEY", "GFREQ", "SFREQ", "GAUDIO", "SAUDIO",
2955                 "SYNC", "MCAPTURE", "GMBUF", "GUNIT", "GCAPTURE", "SCAPTURE",
2956                 "SPLAYMODE", "SWRITEMODE", "GPLAYINFO", "SMICROCODE",
2957                 "GVBIFMT", "SVBIFMT"
2958         };
2959
2960         #define V4L1_IOCTL(cmd) \
2961                 ((_IOC_NR((cmd)) < ARRAY_SIZE(v4l1_ioctls)) ? \
2962                 v4l1_ioctls[_IOC_NR((cmd))] : "?")
2963
2964         cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
2965
2966         switch (cmd) {
2967
2968         case VIDIOCGCAP: /* get video capability */
2969         {
2970                 struct video_capability cap = {
2971                         .type = VID_TYPE_CAPTURE | VID_TYPE_SCALES,
2972                         .channels = 1,
2973                         .audios = 0,
2974                         .minwidth = cam->minwidth,
2975                         .minheight = cam->minheight,
2976                 };
2977                 sprintf(cap.name, "W996[87]CF USB Camera #%d",
2978                         cam->v4ldev->minor);
2979                 cap.maxwidth = (cam->upscaling && w9968cf_vpp)
2980                                ? max((u16)W9968CF_MAX_WIDTH, cam->maxwidth)
2981                                  : cam->maxwidth;
2982                 cap.maxheight = (cam->upscaling && w9968cf_vpp)
2983                                 ? max((u16)W9968CF_MAX_HEIGHT, cam->maxheight)
2984                                   : cam->maxheight;
2985
2986                 if (copy_to_user(arg, &cap, sizeof(cap)))
2987                         return -EFAULT;
2988
2989                 DBG(5, "VIDIOCGCAP successfully called")
2990                 return 0;
2991         }
2992
2993         case VIDIOCGCHAN: /* get video channel informations */
2994         {
2995                 struct video_channel chan;
2996                 if (copy_from_user(&chan, arg, sizeof(chan)))
2997                         return -EFAULT;
2998
2999                 if (chan.channel != 0)
3000                         return -EINVAL;
3001
3002                 strcpy(chan.name, "Camera");
3003                 chan.tuners = 0;
3004                 chan.flags = 0;
3005                 chan.type = VIDEO_TYPE_CAMERA;
3006                 chan.norm = VIDEO_MODE_AUTO;
3007
3008                 if (copy_to_user(arg, &chan, sizeof(chan)))
3009                         return -EFAULT;
3010
3011                 DBG(5, "VIDIOCGCHAN successfully called")
3012                 return 0;
3013         }
3014
3015         case VIDIOCSCHAN: /* set active channel */
3016         {
3017                 struct video_channel chan;
3018
3019                 if (copy_from_user(&chan, arg, sizeof(chan)))
3020                         return -EFAULT;
3021
3022                 if (chan.channel != 0)
3023                         return -EINVAL;
3024
3025                 DBG(5, "VIDIOCSCHAN successfully called")
3026                 return 0;
3027         }
3028
3029         case VIDIOCGPICT: /* get image properties of the picture */
3030         {
3031                 if (w9968cf_sensor_get_picture(cam))
3032                         return -EIO;
3033
3034                 if (copy_to_user(arg, &cam->picture, sizeof(cam->picture)))
3035                         return -EFAULT;
3036
3037                 DBG(5, "VIDIOCGPICT successfully called")
3038                 return 0;
3039         }
3040
3041         case VIDIOCSPICT: /* change picture settings */
3042         {
3043                 struct video_picture pict;
3044                 int err = 0;
3045
3046                 if (copy_from_user(&pict, arg, sizeof(pict)))
3047                         return -EFAULT;
3048
3049                 if ( (cam->force_palette || !w9968cf_vpp)
3050                      && pict.palette != cam->picture.palette ) {
3051                         DBG(4, "Palette %s rejected: only %s is allowed",
3052                             symbolic(v4l1_plist, pict.palette),
3053                             symbolic(v4l1_plist, cam->picture.palette))
3054                         return -EINVAL;
3055                 }
3056
3057                 if (!w9968cf_valid_palette(pict.palette)) {
3058                         DBG(4, "Palette %s not supported. VIDIOCSPICT failed",
3059                             symbolic(v4l1_plist, pict.palette))
3060                         return -EINVAL;
3061                 }
3062
3063                 if (!cam->force_palette) {
3064                    if (cam->decompression == 0) {
3065                       if (w9968cf_need_decompression(pict.palette)) {
3066                          DBG(4, "Decompression disabled: palette %s is not "
3067                                 "allowed. VIDIOCSPICT failed",
3068                              symbolic(v4l1_plist, pict.palette))
3069                          return -EINVAL;
3070                       }
3071                    } else if (cam->decompression == 1) {
3072                       if (!w9968cf_need_decompression(pict.palette)) {
3073                          DBG(4, "Decompression forced: palette %s is not "
3074                                 "allowed. VIDIOCSPICT failed",
3075                              symbolic(v4l1_plist, pict.palette))
3076                          return -EINVAL;
3077                       }
3078                    }
3079                 }
3080
3081                 if (pict.depth != w9968cf_valid_depth(pict.palette)) {
3082                         DBG(4, "Requested depth %u bpp is not valid for %s "
3083                                "palette: ignored and changed to %u bpp",
3084                             pict.depth, symbolic(v4l1_plist, pict.palette),
3085                             w9968cf_valid_depth(pict.palette))
3086                         pict.depth = w9968cf_valid_depth(pict.palette);
3087                 }
3088
3089                 if (pict.palette != cam->picture.palette) {
3090                         if(*cam->requested_frame
3091                            || cam->frame_current->queued) {
3092                                 err = wait_event_interruptible
3093                                       ( cam->wait_queue,
3094                                         cam->disconnected ||
3095                                         (!*cam->requested_frame &&
3096                                          !cam->frame_current->queued) );
3097                                 if (err)
3098                                         return err;
3099                                 if (cam->disconnected)
3100                                         return -ENODEV;
3101                         }
3102
3103                         if (w9968cf_stop_transfer(cam))
3104                                 goto ioctl_fail;
3105
3106                         if (w9968cf_set_picture(cam, pict))
3107                                 goto ioctl_fail;
3108
3109                         if (w9968cf_start_transfer(cam))
3110                                 goto ioctl_fail;
3111
3112                 } else if (w9968cf_sensor_update_picture(cam, pict))
3113                         return -EIO;
3114
3115
3116                 DBG(5, "VIDIOCSPICT successfully called")
3117                 return 0;
3118         }
3119
3120         case VIDIOCSWIN: /* set capture area */
3121         {
3122                 struct video_window win;
3123                 int err = 0;
3124
3125                 if (copy_from_user(&win, arg, sizeof(win)))
3126                         return -EFAULT;
3127
3128                 DBG(6, "VIDIOCSWIN called: clipcount=%d, flags=%u, "
3129                        "x=%u, y=%u, %ux%u", win.clipcount, win.flags,
3130                     win.x, win.y, win.width, win.height)
3131
3132                 if (win.clipcount != 0 || win.flags != 0)
3133                         return -EINVAL;
3134
3135                 if ((err = w9968cf_adjust_window_size(cam, (u16*)&win.width,
3136                                                       (u16*)&win.height))) {
3137                         DBG(4, "Resolution not supported (%ux%u). "
3138                                "VIDIOCSWIN failed", win.width, win.height)
3139                         return err;
3140                 }
3141
3142                 if (win.x != cam->window.x ||
3143                     win.y != cam->window.y ||
3144                     win.width != cam->window.width ||
3145                     win.height != cam->window.height) {
3146                         if(*cam->requested_frame
3147                            || cam->frame_current->queued) {
3148                                 err = wait_event_interruptible
3149                                       ( cam->wait_queue,
3150                                         cam->disconnected ||
3151                                         (!*cam->requested_frame &&
3152                                          !cam->frame_current->queued) );
3153                                 if (err)
3154                                         return err;
3155                                 if (cam->disconnected)
3156                                         return -ENODEV;
3157                         }
3158
3159                         if (w9968cf_stop_transfer(cam))
3160                                 goto ioctl_fail;
3161
3162                         /* This _must_ be called before set_window() */
3163                         if (w9968cf_set_picture(cam, cam->picture))
3164                                 goto ioctl_fail;
3165
3166                         if (w9968cf_set_window(cam, win))
3167                                 goto ioctl_fail;
3168
3169                         if (w9968cf_start_transfer(cam))
3170                                 goto ioctl_fail;
3171                 }
3172
3173                 DBG(5, "VIDIOCSWIN successfully called. ")
3174                 return 0;
3175         }
3176
3177         case VIDIOCGWIN: /* get current window properties */
3178         {
3179                 if (copy_to_user(arg,&cam->window,sizeof(struct video_window)))
3180                         return -EFAULT;
3181
3182                 DBG(5, "VIDIOCGWIN successfully called")
3183                 return 0;
3184         }
3185
3186         case VIDIOCGMBUF: /* request for memory (mapped) buffer */
3187         {
3188                 struct video_mbuf mbuf;
3189                 u8 i;
3190
3191                 mbuf.size = cam->nbuffers * cam->frame[0].size;
3192                 mbuf.frames = cam->nbuffers;
3193                 for (i = 0; i < cam->nbuffers; i++)
3194                         mbuf.offsets[i] = (unsigned long)cam->frame[i].buffer -
3195                                           (unsigned long)cam->frame[0].buffer;
3196
3197                 if (copy_to_user(arg, &mbuf, sizeof(mbuf)))
3198                         return -EFAULT;
3199
3200                 DBG(5, "VIDIOCGMBUF successfully called")
3201                 return 0;
3202         }
3203
3204         case VIDIOCMCAPTURE: /* start the capture to a frame */
3205         {
3206                 struct video_mmap mmap;
3207                 struct w9968cf_frame_t* fr;
3208                 int err = 0;
3209
3210                 if (copy_from_user(&mmap, arg, sizeof(mmap)))
3211                         return -EFAULT;
3212
3213                 DBG(6, "VIDIOCMCAPTURE called: frame #%u, format=%s, %dx%d",
3214                     mmap.frame, symbolic(v4l1_plist, mmap.format),
3215                     mmap.width, mmap.height)
3216
3217                 if (mmap.frame >= cam->nbuffers) {
3218                         DBG(4, "Invalid frame number (%u). "
3219                                "VIDIOCMCAPTURE failed", mmap.frame)
3220                         return -EINVAL;
3221                 }
3222
3223                 if (mmap.format!=cam->picture.palette &&
3224                     (cam->force_palette || !w9968cf_vpp)) {
3225                         DBG(4, "Palette %s rejected: only %s is allowed",
3226                             symbolic(v4l1_plist, mmap.format),
3227                             symbolic(v4l1_plist, cam->picture.palette))
3228                         return -EINVAL;
3229                 }
3230
3231                 if (!w9968cf_valid_palette(mmap.format)) {
3232                         DBG(4, "Palette %s not supported. "
3233                                "VIDIOCMCAPTURE failed",
3234                             symbolic(v4l1_plist, mmap.format))
3235                         return -EINVAL;
3236                 }
3237
3238                 if (!cam->force_palette) {
3239                    if (cam->decompression == 0) {
3240                       if (w9968cf_need_decompression(mmap.format)) {
3241                          DBG(4, "Decompression disabled: palette %s is not "
3242                                 "allowed. VIDIOCSPICT failed",
3243                              symbolic(v4l1_plist, mmap.format))
3244                          return -EINVAL;
3245                       }
3246                    } else if (cam->decompression == 1) {
3247                       if (!w9968cf_need_decompression(mmap.format)) {
3248                          DBG(4, "Decompression forced: palette %s is not "
3249                                 "allowed. VIDIOCSPICT failed",
3250                              symbolic(v4l1_plist, mmap.format))
3251                          return -EINVAL;
3252                       }
3253                    }
3254                 }
3255
3256                 if ((err = w9968cf_adjust_window_size(cam, (u16*)&mmap.width,
3257                                                       (u16*)&mmap.height))) {
3258                         DBG(4, "Resolution not supported (%dx%d). "
3259                                "VIDIOCMCAPTURE failed",
3260                             mmap.width, mmap.height)
3261                         return err;
3262                 }
3263
3264                 fr = &cam->frame[mmap.frame];
3265
3266                 if (mmap.width  != cam->window.width ||
3267                     mmap.height != cam->window.height ||
3268                     mmap.format != cam->picture.palette) {
3269
3270                         struct video_window win;
3271                         struct video_picture pict;
3272
3273                         if(*cam->requested_frame
3274                            || cam->frame_current->queued) {
3275                                 DBG(6, "VIDIOCMCAPTURE. Change settings for "
3276                                        "frame #%u: %dx%d, format %s. Wait...",
3277                                     mmap.frame, mmap.width, mmap.height,
3278                                     symbolic(v4l1_plist, mmap.format))
3279                                 err = wait_event_interruptible
3280                                       ( cam->wait_queue,
3281                                         cam->disconnected ||
3282                                         (!*cam->requested_frame &&
3283                                          !cam->frame_current->queued) );
3284                                 if (err)
3285                                         return err;
3286                                 if (cam->disconnected)
3287                                         return -ENODEV;
3288                         }
3289
3290                         memcpy(&win, &cam->window, sizeof(win));
3291                         memcpy(&pict, &cam->picture, sizeof(pict));
3292                         win.width = mmap.width;
3293                         win.height = mmap.height;
3294                         pict.palette = mmap.format;
3295
3296                         if (w9968cf_stop_transfer(cam))
3297                                 goto ioctl_fail;
3298
3299                         /* This before set_window */
3300                         if (w9968cf_set_picture(cam, pict))
3301                                 goto ioctl_fail;
3302
3303                         if (w9968cf_set_window(cam, win))
3304                                 goto ioctl_fail;
3305
3306                         if (w9968cf_start_transfer(cam))
3307                                 goto ioctl_fail;
3308
3309                 } else  if (fr->queued) {
3310
3311                         DBG(6, "Wait until frame #%u is free", mmap.frame)
3312
3313                         err = wait_event_interruptible(cam->wait_queue,
3314                                                        cam->disconnected ||
3315                                                        (!fr->queued));
3316                         if (err)
3317                                 return err;
3318                         if (cam->disconnected)
3319                                 return -ENODEV;
3320                 }
3321
3322                 w9968cf_push_frame(cam, mmap.frame);
3323                 DBG(5, "VIDIOCMCAPTURE(%u): successfully called", mmap.frame)
3324                 return 0;
3325         }
3326
3327         case VIDIOCSYNC: /* wait until the capture of a frame is finished */
3328         {
3329                 unsigned int f_num;
3330                 struct w9968cf_frame_t* fr;
3331                 int err = 0;
3332
3333                 if (copy_from_user(&f_num, arg, sizeof(f_num)))
3334                         return -EFAULT;
3335
3336                 if (f_num >= cam->nbuffers) {
3337                         DBG(4, "Invalid frame number (%u). "
3338                                "VIDIOCMCAPTURE failed", f_num)
3339                         return -EINVAL;
3340                 }
3341
3342                 DBG(6, "VIDIOCSYNC called for frame #%u", f_num)
3343
3344                 fr = &cam->frame[f_num];
3345
3346                 switch (fr->status) {
3347                 case F_UNUSED:
3348                         if (!fr->queued) {
3349                                 DBG(4, "VIDIOSYNC: Frame #%u not requested!",
3350                                     f_num)
3351                                 return -EFAULT;
3352                         }
3353                 case F_ERROR:
3354                 case F_GRABBING:
3355                         err = wait_event_interruptible(cam->wait_queue,
3356                                                        (fr->status == F_READY)
3357                                                        || cam->disconnected);
3358                         if (err)
3359                                 return err;
3360                         if (cam->disconnected)
3361                                 return -ENODEV;
3362                         break;
3363                 case F_READY:
3364                         break;
3365                 }
3366
3367                 if (w9968cf_vpp)
3368                         w9968cf_postprocess_frame(cam, fr);
3369
3370                 fr->status = F_UNUSED;
3371
3372                 DBG(5, "VIDIOCSYNC(%u) successfully called", f_num)
3373                 return 0;
3374         }
3375
3376         case VIDIOCGUNIT:/* report the unit numbers of the associated devices*/
3377         {
3378                 struct video_unit unit = {
3379                         .video = cam->v4ldev->minor,
3380                         .vbi = VIDEO_NO_UNIT,
3381                         .radio = VIDEO_NO_UNIT,
3382                         .audio = VIDEO_NO_UNIT,
3383                         .teletext = VIDEO_NO_UNIT,
3384                 };
3385
3386                 if (copy_to_user(arg, &unit, sizeof(unit)))
3387                         return -EFAULT;
3388
3389                 DBG(5, "VIDIOCGUNIT successfully called")
3390                 return 0;
3391         }
3392
3393         case VIDIOCKEY:
3394                 return 0;
3395
3396         case VIDIOCGFBUF:
3397         {
3398                 if (clear_user(arg, sizeof(struct video_buffer)))
3399                         return -EFAULT;
3400
3401                 DBG(5, "VIDIOCGFBUF successfully called")
3402                 return 0;
3403         }
3404
3405         case VIDIOCGTUNER:
3406         {
3407                 struct video_tuner tuner;
3408                 if (copy_from_user(&tuner, arg, sizeof(tuner)))
3409                         return -EFAULT;
3410
3411                 if (tuner.tuner != 0)
3412                         return -EINVAL;
3413
3414                 strcpy(tuner.name, "no_tuner");
3415                 tuner.rangelow = 0;
3416                 tuner.rangehigh = 0;
3417                 tuner.flags = VIDEO_TUNER_NORM;
3418                 tuner.mode = VIDEO_MODE_AUTO;
3419                 tuner.signal = 0xffff;
3420
3421                 if (copy_to_user(arg, &tuner, sizeof(tuner)))
3422                         return -EFAULT;
3423
3424                 DBG(5, "VIDIOCGTUNER successfully called")
3425                 return 0;
3426         }
3427
3428         case VIDIOCSTUNER:
3429         {
3430                 struct video_tuner tuner;
3431                 if (copy_from_user(&tuner, arg, sizeof(tuner)))
3432                         return -EFAULT;
3433
3434                 if (tuner.tuner != 0)
3435                         return -EINVAL;
3436
3437                 if (tuner.mode != VIDEO_MODE_AUTO)
3438                         return -EINVAL;
3439
3440                 DBG(5, "VIDIOCSTUNER successfully called")
3441                 return 0;
3442         }
3443
3444         case VIDIOCSFBUF:
3445         case VIDIOCCAPTURE:
3446         case VIDIOCGFREQ:
3447         case VIDIOCSFREQ:
3448         case VIDIOCGAUDIO:
3449         case VIDIOCSAUDIO:
3450         case VIDIOCSPLAYMODE:
3451         case VIDIOCSWRITEMODE:
3452         case VIDIOCGPLAYINFO:
3453         case VIDIOCSMICROCODE:
3454         case VIDIOCGVBIFMT:
3455         case VIDIOCSVBIFMT:
3456                 DBG(4, "Unsupported V4L1 IOCtl: VIDIOC%s "
3457                        "(type 0x%01X, "
3458                        "n. 0x%01X, "
3459                        "dir. 0x%01X, "
3460                        "size 0x%02X)",
3461                     V4L1_IOCTL(cmd),
3462                     _IOC_TYPE(cmd),_IOC_NR(cmd),_IOC_DIR(cmd),_IOC_SIZE(cmd))
3463
3464                 return -EINVAL;
3465
3466         default:
3467                 DBG(4, "Invalid V4L1 IOCtl: VIDIOC%s "
3468                        "type 0x%01X, "
3469                        "n. 0x%01X, "
3470                        "dir. 0x%01X, "
3471                        "size 0x%02X",
3472                     V4L1_IOCTL(cmd),
3473                     _IOC_TYPE(cmd),_IOC_NR(cmd),_IOC_DIR(cmd),_IOC_SIZE(cmd))
3474
3475                 return -ENOIOCTLCMD;
3476
3477         } /* end of switch */
3478
3479 ioctl_fail:
3480         cam->misconfigured = 1;
3481         DBG(1, "VIDIOC%s failed because of hardware problems. "
3482                "To use the camera, close and open it again.", V4L1_IOCTL(cmd))
3483         return -EFAULT;
3484 }
3485
3486
3487 static struct file_operations w9968cf_fops = {
3488         .owner =   THIS_MODULE,
3489         .open =    w9968cf_open,
3490         .release = w9968cf_release,
3491         .read =    w9968cf_read,
3492         .ioctl =   w9968cf_ioctl,
3493         .compat_ioctl = v4l_compat_ioctl32,
3494         .mmap =    w9968cf_mmap,
3495         .llseek =  no_llseek,
3496 };
3497
3498
3499
3500 /****************************************************************************
3501  * USB probe and V4L registration, disconnect and id_table[] definition     *
3502  ****************************************************************************/
3503
3504 static int
3505 w9968cf_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
3506 {
3507         struct usb_device *udev = interface_to_usbdev(intf);
3508         struct w9968cf_device* cam;
3509         int err = 0;
3510         enum w9968cf_model_id mod_id;
3511         struct list_head* ptr;
3512         u8 sc = 0; /* number of simultaneous cameras */
3513         static unsigned short dev_nr = 0; /* we are handling device number n */
3514
3515         if (le16_to_cpu(udev->descriptor.idVendor)  == winbond_id_table[0].idVendor &&
3516             le16_to_cpu(udev->descriptor.idProduct) == winbond_id_table[0].idProduct)
3517                 mod_id = W9968CF_MOD_CLVBWGP; /* see camlist[] table */
3518         else if (le16_to_cpu(udev->descriptor.idVendor)  == winbond_id_table[1].idVendor &&
3519                  le16_to_cpu(udev->descriptor.idProduct) == winbond_id_table[1].idProduct)
3520                 mod_id = W9968CF_MOD_GENERIC; /* see camlist[] table */
3521         else
3522                 return -ENODEV;
3523
3524         cam = (struct w9968cf_device*)
3525                   kmalloc(sizeof(struct w9968cf_device), GFP_KERNEL);
3526         if (!cam)
3527                 return -ENOMEM;
3528
3529         memset(cam, 0, sizeof(*cam));
3530
3531         init_MUTEX(&cam->dev_sem);
3532         down(&cam->dev_sem);
3533
3534         cam->usbdev = udev;
3535         /* NOTE: a local copy is used to avoid possible race conditions */
3536         memcpy(&cam->dev, &udev->dev, sizeof(struct device));
3537
3538         DBG(2, "%s detected", symbolic(camlist, mod_id))
3539
3540         if (simcams > W9968CF_MAX_DEVICES)
3541                 simcams = W9968CF_SIMCAMS;
3542
3543         /* How many cameras are connected ? */
3544         down(&w9968cf_devlist_sem);
3545         list_for_each(ptr, &w9968cf_dev_list)
3546                 sc++;
3547         up(&w9968cf_devlist_sem);
3548
3549         if (sc >= simcams) {
3550                 DBG(2, "Device rejected: too many connected cameras "
3551                        "(max. %u)", simcams)
3552                 err = -EPERM;
3553                 goto fail;
3554         }
3555
3556
3557         /* Allocate 2 bytes of memory for camera control USB transfers */
3558         if (!(cam->control_buffer = kmalloc(2, GFP_KERNEL))) {
3559                 DBG(1,"Couldn't allocate memory for camera control transfers")
3560                 err = -ENOMEM;
3561                 goto fail;
3562         }
3563         memset(cam->control_buffer, 0, 2);
3564
3565         /* Allocate 8 bytes of memory for USB data transfers to the FSB */
3566         if (!(cam->data_buffer = kmalloc(8, GFP_KERNEL))) {
3567                 DBG(1, "Couldn't allocate memory for data "
3568                        "transfers to the FSB")
3569                 err = -ENOMEM;
3570                 goto fail;
3571         }
3572         memset(cam->data_buffer, 0, 8);
3573
3574         /* Register the V4L device */
3575         cam->v4ldev = video_device_alloc();
3576         if (!cam->v4ldev) {
3577                 DBG(1, "Could not allocate memory for a V4L structure")
3578                 err = -ENOMEM;
3579                 goto fail;
3580         }
3581
3582         strcpy(cam->v4ldev->name, symbolic(camlist, mod_id));
3583         cam->v4ldev->owner = THIS_MODULE;
3584         cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
3585         cam->v4ldev->hardware = VID_HARDWARE_W9968CF;
3586         cam->v4ldev->fops = &w9968cf_fops;
3587         cam->v4ldev->minor = video_nr[dev_nr];
3588         cam->v4ldev->release = video_device_release;
3589         video_set_drvdata(cam->v4ldev, cam);
3590         cam->v4ldev->dev = &cam->dev;
3591
3592         err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
3593                                     video_nr[dev_nr]);
3594         if (err) {
3595                 DBG(1, "V4L device registration failed")
3596                 if (err == -ENFILE && video_nr[dev_nr] == -1)
3597                         DBG(2, "Couldn't find a free /dev/videoX node")
3598                 video_nr[dev_nr] = -1;
3599                 dev_nr = (dev_nr < W9968CF_MAX_DEVICES-1) ? dev_nr+1 : 0;
3600                 goto fail;
3601         }
3602
3603         DBG(2, "V4L device registered as /dev/video%d", cam->v4ldev->minor)
3604
3605         /* Set some basic constants */
3606         w9968cf_configure_camera(cam, udev, mod_id, dev_nr);
3607
3608         /* Add a new entry into the list of V4L registered devices */
3609         down(&w9968cf_devlist_sem);
3610         list_add(&cam->v4llist, &w9968cf_dev_list);
3611         up(&w9968cf_devlist_sem);
3612         dev_nr = (dev_nr < W9968CF_MAX_DEVICES-1) ? dev_nr+1 : 0;
3613
3614         w9968cf_turn_on_led(cam);
3615
3616         w9968cf_i2c_init(cam);
3617
3618         usb_set_intfdata(intf, cam);
3619         up(&cam->dev_sem);
3620         return 0;
3621
3622 fail: /* Free unused memory */
3623         kfree(cam->control_buffer);
3624         kfree(cam->data_buffer);
3625         if (cam->v4ldev)
3626                 video_device_release(cam->v4ldev);
3627         up(&cam->dev_sem);
3628         kfree(cam);
3629         return err;
3630 }
3631
3632
3633 static void w9968cf_usb_disconnect(struct usb_interface* intf)
3634 {
3635         struct w9968cf_device* cam =
3636            (struct w9968cf_device*)usb_get_intfdata(intf);
3637
3638         down_write(&w9968cf_disconnect);
3639
3640         if (cam) {
3641                 /* Prevent concurrent accesses to data */
3642                 down(&cam->dev_sem);
3643
3644                 cam->disconnected = 1;
3645
3646                 DBG(2, "Disconnecting %s...", symbolic(camlist, cam->id))
3647
3648                 wake_up_interruptible_all(&cam->open);
3649
3650                 if (cam->users) {
3651                         DBG(2, "The device is open (/dev/video%d)! "
3652                                "Process name: %s. Deregistration and memory "
3653                                "deallocation are deferred on close.",
3654                             cam->v4ldev->minor, cam->command)
3655                         cam->misconfigured = 1;
3656                         w9968cf_stop_transfer(cam);
3657                         wake_up_interruptible(&cam->wait_queue);
3658                 } else
3659                         w9968cf_release_resources(cam);
3660
3661                 up(&cam->dev_sem);
3662
3663                 if (!cam->users)
3664                         kfree(cam);
3665         }
3666
3667         up_write(&w9968cf_disconnect);
3668 }
3669
3670
3671 static struct usb_driver w9968cf_usb_driver = {
3672         .name =       "w9968cf",
3673         .id_table =   winbond_id_table,
3674         .probe =      w9968cf_usb_probe,
3675         .disconnect = w9968cf_usb_disconnect,
3676 };
3677
3678
3679
3680 /****************************************************************************
3681  * Module init, exit and intermodule communication                          *
3682  ****************************************************************************/
3683
3684 static int w9968cf_vppmod_detect(struct w9968cf_device* cam)
3685 {
3686         if (!w9968cf_vpp)
3687                 if (vppmod_load)
3688                         request_module("w9968cf-vpp");
3689
3690         down(&w9968cf_vppmod_lock);
3691
3692         if (!w9968cf_vpp) {
3693                 DBG(4, "Video post-processing module not detected")
3694                 w9968cf_adjust_configuration(cam);
3695                 goto out;
3696         }
3697
3698         if (!try_module_get(w9968cf_vpp->owner)) {
3699                 DBG(1, "Couldn't increment the reference count of "
3700                        "the video post-processing module")
3701                 up(&w9968cf_vppmod_lock);
3702                 return -ENOSYS;
3703         }
3704
3705         w9968cf_vpp->busy++;
3706
3707         DBG(5, "Video post-processing module detected")
3708
3709 out:
3710         up(&w9968cf_vppmod_lock);
3711         return 0;
3712 }
3713
3714
3715 static void w9968cf_vppmod_release(struct w9968cf_device* cam)
3716 {
3717         down(&w9968cf_vppmod_lock);
3718
3719         if (w9968cf_vpp && w9968cf_vpp->busy) {
3720                 module_put(w9968cf_vpp->owner);
3721                 w9968cf_vpp->busy--;
3722                 wake_up(&w9968cf_vppmod_wait);
3723                 DBG(5, "Video post-processing module released")
3724         }
3725
3726         up(&w9968cf_vppmod_lock);
3727 }
3728
3729
3730 int w9968cf_vppmod_register(struct w9968cf_vpp_t* vpp)
3731 {
3732         down(&w9968cf_vppmod_lock);
3733
3734         if (w9968cf_vpp) {
3735                 KDBG(1, "Video post-processing module already registered")
3736                 up(&w9968cf_vppmod_lock);
3737                 return -EINVAL;
3738         }
3739
3740         w9968cf_vpp = vpp;
3741         w9968cf_vpp->busy = 0;
3742
3743         KDBG(2, "Video post-processing module registered")
3744         up(&w9968cf_vppmod_lock);
3745         return 0;
3746 }
3747
3748
3749 int w9968cf_vppmod_deregister(struct w9968cf_vpp_t* vpp)
3750 {
3751         down(&w9968cf_vppmod_lock);
3752
3753         if (!w9968cf_vpp) {
3754                 up(&w9968cf_vppmod_lock);
3755                 return -EINVAL;
3756         }
3757
3758         if (w9968cf_vpp != vpp) {
3759                 KDBG(1, "Only the owner can unregister the video "
3760                         "post-processing module")
3761                 up(&w9968cf_vppmod_lock);
3762                 return -EINVAL;
3763         }
3764
3765         if (w9968cf_vpp->busy) {
3766                 KDBG(2, "Video post-processing module busy. Wait for it to be "
3767                         "released...")
3768                 up(&w9968cf_vppmod_lock);
3769                 wait_event(w9968cf_vppmod_wait, !w9968cf_vpp->busy);
3770                 w9968cf_vpp = NULL;
3771                 goto out;
3772         }
3773
3774         w9968cf_vpp = NULL;
3775
3776         up(&w9968cf_vppmod_lock);
3777
3778 out:
3779         KDBG(2, "Video post-processing module unregistered")
3780         return 0;
3781 }
3782
3783
3784 static int __init w9968cf_module_init(void)
3785 {
3786         int err;
3787
3788         KDBG(2, W9968CF_MODULE_NAME" "W9968CF_MODULE_VERSION)
3789         KDBG(3, W9968CF_MODULE_AUTHOR)
3790
3791         if (ovmod_load)
3792                 request_module("ovcamchip");
3793
3794         if ((err = usb_register(&w9968cf_usb_driver)))
3795                 return err;
3796
3797         return 0;
3798 }
3799
3800
3801 static void __exit w9968cf_module_exit(void)
3802 {
3803         /* w9968cf_usb_disconnect() will be called */
3804         usb_deregister(&w9968cf_usb_driver);
3805
3806         KDBG(2, W9968CF_MODULE_NAME" deregistered")
3807 }
3808
3809
3810 module_init(w9968cf_module_init);
3811 module_exit(w9968cf_module_exit);
3812
3813
3814 EXPORT_SYMBOL(w9968cf_vppmod_register);
3815 EXPORT_SYMBOL(w9968cf_vppmod_deregister);