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