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