drivers/media/video/usbvision/usbvision-core.c

   1 /*
   2  * USB USBVISION Video device driver 0.9.8.3cvs (For Kernel 2.4.19-2.4.32 + 2.6.0-2.6.16)
   3  *
   4  *
   5  *
   6  * Copyright (c) 1999-2005 Joerg Heckenbach <joerg@heckenbach-aw.de>
   7  *
   8  * This module is part of usbvision driver project.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  *
  24  * Let's call the version 0.... until compression decoding is completely
  25  * implemented.
  26  *
  27  * This driver is written by Jose Ignacio Gijon and Joerg Heckenbach.
  28  * It was based on USB CPiA driver written by Peter Pregler,
  29  * Scott J. Bertin and Johannes Erdfelt
  30  * Ideas are taken from bttv driver by Ralph Metzler, Marcus Metzler &
  31  * Gerd Knorr and zoran 36120/36125 driver by Pauline Middelink
  32  * Updates to driver completed by Dwaine P. Garden
  33  *
  34  * History:
  35  *
  36  * Mar. 2000 - 15.12.2000:  (0.0.0 - 0.2.0)
  37  *     Several alpha drivers and the first beta.
  38  *
  39  * Since Dec. 2000:  (0.2.1) or (v2.1)
  40  *     Code changes or updates by Dwaine Garden and every other person.
  41  *
  42  *     Added: New Hauppauge TV device  Vendor  ID: 0x0573
  43  *                                     Product ID: 0x4D01
  44  *            (Thanks to Giovanni Garberoglio)
  45  *
  46  *     Added: UK Hauppauge WinTV-USB   Vendor  ID: 0x0573
  47  *                                     Product ID: 0x4D02
  48  *            (Thanks to Derek Freeman-Jones)
  49  *
  50  * Feb, 2001 - Apr 08, 2001:  (0.3.0)
  51  *     - Some fixes. Driver is now more stable.
  52  *     - Scratch is organized as ring-buffer now for better performance
  53  *     - DGA (overlay) is now supported.
  54  *       !!!!Danger!!!! Clipping is not yet implemented. Your system will
  55  *       crash if your video window leaves the screen!!!
  56  *     - Max. Framesize is set to 320x240. There isn't more memory on the
  57  *       nt1003 video device for the FIFO.
  58  *     - Supported video palettes: RGB565, RGB555, RGB24, RGB32
  59  *
  60  *
  61  * Apr 15, 2001:  (0.3.1-test...)
  62  *     - Clipping is implemented
  63  *     - NTSC is now coloured (Thanks to Dwaine Garden)
  64  *     - Added SECAM colour detection in saa7111-new
  65  *     - Added: French Hauppauge WinTV USB  Vendor ID: 0x0573
  66  *                                          Product ID: 0x4D03
  67  *              (Thanks to Julius Hrivnac)
  68  *     - Added: US Hauppauge WINTV USB  Vendor ID: 0x0573
  69  *                                      Product ID: 0x4D00
  70  *              (Thanks to  Derrick J Brashear)
  71  *     - Changes for adding new devices. There's now a table in usbvision.h.
  72  *       Adding your devices data to the usbvision_device_data table is all
  73  *       you need to add a new device.
  74  *
  75  * May 11, 2001: (0.3.2-test...) (Thanks to Derek Freeman-Jones)
  76  *     - Support YUV422 raw format for people with hardware scaling.
  77  *     - Only power on the device when opened (use option PowerOnAtOpen=0 to disable it).
  78  *     - Turn off audio so we can listen to Line In.
  79  *
  80  * July 5, 2001 - (Patch the driver to run with Kernel 2.4.6)
  81  *     - Fixed a problem with the number of parameters passed to video_register_device.
  82  *
  83  * July 6, 2001 - Added: HAUPPAUGE WINTV-USB FM USA Vendor  ID: 0x0573
  84  *                                                      Product ID: 0x4D10
  85  *       (Thanks to Braddock Gaskill)
  86  *                Added: USBGear USBG-V1 resp. HAMA USB
  87  *                                      Vendor  ID: 0x0573
  88  *                                      Product ID: 0x0003
  89  *       (Thanks to Bradley A. Singletary and Juergen Weigert)
  90  *
  91  * Jan 24, 2002 - (0.3.3-test...)
  92  *     - Moved all global variables that are device specific the usb_usbvision struct
  93  *     - Fixed the 64x48 unchangable image in xawtv when starting it with overlay
  94  *     - Add VideoNorm and TunerType to the usb_device_data table
  95  *     - Checked the audio channels and mute for HAUPPAUGE WinTV USB FM
  96  *     - Implemented the power on when opening the device. But some software opens
  97  *       the device several times when starting. So the i2c parts are just registered
  98  *       by an open, when they become deregistered by the next close. You can speed
  99  *       up tuner detection, when adding "options tuner addr=your_addr" to /etc/modules.conf
 100  *     - Begin to resize the frame in width and height. So it will be possible to watch i.e.
 101  *       384x288 pixels at 23 fps.
 102  *
 103  * Feb 10, 2002
 104  *     - Added radio device
 105  *
 106  *
 107  * Jul 30, 2002 - (Thanks Cameron Maxwell)
 108  *     - Changes to usbvision.h --fixed usbvision device data structure, incorrectly had (0x0573, 0x4d21) for WinTV-USB II, should be 0x4d20.
 109  *     - Changes for device WinTV-USB II (0x0573. 0x4D21).  It does not have a FM tuner.
 110  *     - Added the real device HAUPPAUGE WINTV-USB II (PAL) to the device structure in usbvision.h.
 111  *     - Changes to saa7113-new, the video is 8 bit data for the Phillips SAA7113 not 16bit like SAA7111.
 112  *     - Tuned lots of setup registers for the Phillips SAA7113 video chipset.
 113  *     - Changes to the supplied makefile. (Dwaine Garden) Still needs to be fixed so it will compile modules on different distrubutions.
 114  *
 115  *
 116  * Aug 10, 2002 - (Thanks Mike Klinke)
 117  *     - Changes to usbvision.txt -- Fixed instructions on the location to copy the contents of the tgz file.
 118  *     - Added device WinTV-USB FM Model 621 (0x0573. 0x4D30). There is another device which carries the same name. Kept that device in the device structure.
 119  *
 120  * Aug 12, 2002 - Dwaine Garden
 121  *     - Added the ability to read the NT100x chip for the MaxISOPacketLength and USB Bandwidth
 122  *       Setting of the video device.
 123  *     - Adjustments to the SAA7113H code for proper video output.
 124  *     - Changes to usbvision.h, so all the devices with FM tuners are working.
 125  *
 126  * Feb 10, 2003 - Joerg Heckenbach
 127  *     - fixed endian bug for Motorola PPC
 128  *
 129  * Feb 13, 2003 - Joerg Heckenbach
 130  *     - fixed Vin_Reg setting and presetting from usbvision_device_data()
 131  *
 132  * Apr 19, 2003 - Dwaine Garden
 133  *     - Fixed compiling errors under RedHat v9.0. from uvirt_to_kva and usbvision_mmap. (Thanks Cameron Maxwell)
 134  *     - Changed pte_offset to pte_offset_kernel.
 135  *     - Changed remap_page_range and added additional parameter to function.
 136  *     - Change setup parameters for the D-Link V100 USB device
 137  *     - Added a new device to the usbvision driver.  Pinnacle Studio PCTV USB (PAL) 0x2304 0x0110
 138  *     - Screwed up the sourceforge.net cvs respository!  8*)
 139  *
 140  * Apr 22, 2002 - Dwaine Garden
 141  *     - Added a new device to the usbvision driver. Dazzle DVC-80 (PAL) 0x07d0 0x0004. (Thanks Carl Anderson)
 142  *     - Changes to some of the comments.
 143  *
 144  * June 06, 2002 - Ivan, Dwaine Garden
 145  *     - Ivan updates for fine tuning device parameters without driver recompiling. (Ivan)
 146  *     - Changes to some of the comments. (Dwaine Garden)
 147  *     - Changes to the makefile - Better CPU settings. (Ivan)
 148  *     - Changes to device Hauppauge WinTv-USB III (PAL) FM Model 568 - Fine tuning parameters (Ivan)
 149  *
 150  *
 151  * Oct 16, 2003 - 0.9.0 - Joerg Heckenbach
 152  *     - Implementation of the first part of the decompression algorithm for intra frames.
 153  *       The resolution has to be 320x240. A dynamic adaption of compression deepth is
 154  *       missing yet.
 155  *
 156  * Oct 22, 2003 - 0.9.1 - Joerg Heckenbach
 157  *     - Implementation of the decompression algorithm for inter frames.
 158  *       The resolution still has to be 320x240.
 159  *
 160  * Nov 2003 - Feb 2004 - 0.9.2 to 0.9.3 - Joerg Heckenbach
 161  *     - Implement last unknown compressed block type. But color is still noisy.
 162  *     - Finding criteria for adaptive compression adjustment.
 163  *     - Porting to 2.6 kernels, but still working under 2.4
 164  *
 165  * Feb 04, 2004 - 0.9.4 Joerg Heckenbach
 166  *     - Found bug in color decompression. Color is OK now.
 167  *
 168  * Feb 09, 2004 - 0.9.5 Joerg Heckenbach
 169  *     - Add auto-recognition of chip type NT1003 or NT1004.
 170  *     - Add adaptive compression adjustment.
 171  *     - Patched saa7113 multiplexer switching (Thanks to Orlando F.S. Bordoni)
 172  *
 173  * Feb 24, 2004 - 0.9.6 Joerg Heckenbach
 174  *     - Add a timer to wait before poweroff at close, to save start time in
 175  *       some video applications
 176  *
 177  * Mar 4, 2004 - 0.9.6 Dwaine Garden
 178  *     - Added device Global Village GV-007 (NTSC) to usbvision.h (Thanks to Abe Skolnik)
 179  *     - Forgot to add this device to the driver. 8*)
 180  *
 181  * June 2, 2004 - 0.9.6 Dwaine Garden
 182  *     - Fixed sourceforge.net cvs repository.
 183  *     - Added #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,26) for .owner to help compiling under kernels 2.4.x which do not have the i2c v2.8.x updates.
 184  *     - Added device Hauppauge WinTv-USB III (PAL) FM Model 597 to usbvision.h
 185  *
 186  * July 1, 2004 -0.9.6 Dwaine Garden
 187  *     - Patch was submitted by Hal Finkel to fix the problem with the tuner not working under kernel 2.6.7.
 188  *     - Thanks Hal.....
 189  *
 190  * July 30, 2004 - 0.9.6 Dwaine Garden
 191  *     - Patch was submitted by Tobias Diaz to fix Model ID mismatch in usbvision.h.
 192  *     - Thanks.....
 193  *
 194  * August 12, 2004 - 0.9.6 Dwaine Garden
 195  *     - Updated the readme file so people could install the driver under the configuration file for kernel 2.6.x recompiles.  Now people can use make xconfig!
 196  *     - Added new device "Camtel Technology Corp TVB330-USB FM".
 197  *     - Sourceforge.net CVS has been updated with all the changes.
 198  *
 199  * August 20, 2004 - 0.9.7 Dwaine Garden
 200  *     - Added Device "Hauppauge USB Live Model 600"
 201  *     - Fixed up all the devices which did not have a default tuner type in usbvision.h.  It's best guess, at least until someone with the device tells me otherwise.
 202  *     - Sourceforge.net CVS has been updated with all the changes.
 203  *     - Clean up the driver.
 204  *
 205  * September 13, 2004 - 0.9.8 Dwaine Garden
 206  *     - Changed usbvision_muxsel to address the problem with black & white s-video output for NT1004 devices with saa7114 video decoder.  Thanks to Emmanuel for the patch and testing.
 207  *     - Fixed up SECAM devices which could not properly output video.  Changes to usbmuxsel.  Thanks to Emmanuel for the patch and everyone with a SECAM device which help test.
 208  *     - Removed some commented out code.  Clean up.
 209  *     - Tried to fix up the annoying empty directories in the sourceforge.net cvs.   Fuck it up again.  8*(
 210  *
 211  * November 15, 2004 - 0.9.8 Dwaine Garden
 212  *     - Release new tar - 0.9.8 on sourceforge.net
 213  *     - Added some new devices to usbvision.h WinTV USB Model 602 40201 Rev B282, Hauppague WinTV USB Model 602 40201 Rev B285
 214  *     - Added better compatibility for 2.6.x kernels.
 215  *     - Hardware full screen scaling in grabdisplay mode.
 216  *     - Better support for sysfs.  More code to follow for both video device and radio device. Device information is located at /sys/class/video4linux/video0
 217  *     - Added module_param so loaded module parameters are displayed in sysfs.  Driver parameters should show up in /sys/module/usbvision
 218  *     - Adjusted the SAA7111 registers to match the 2.6.x kernel SAA7111 code. Thanks to the person which helped test.
 219  *     - Changed to wait_event_interruptible. For all the people running Fedora 2.
 220  *     - Added some screenshots of actual video captures on sourceforge.net.
 221  *
 222  * November 24, 2004 - 0.9.8.1cvs Dwaine Garden
 223  *     - Added patch to check for palette and format in VIDIOCSPICT.  Helix Producer should work fine with the driver now.  Thanks Jason Simpson
 224  *     - Two device description changes and two additions for the maintainer of usb.ids.
 225  *
 226  * December 2, 2004 - 0.9.8.1cvs Dwaine Garden
 227  *     - Added patch for YUV420P and YUV422P video output.  Thanks to Alex Smith.
 228  *     - Better support for mythtv.
 229  *
 230  * January 2, 2005 - 0.9.8.1cvs Dwaine Garden
 231  *     - Setup that you can specify which device is used for video.  Default is auto detect next available device number eg.  /dev/videoX
 232  *     - Setup that you can specify which device is used for radio.  Default is auto detect next available device number eg.  /dev/radioX
 233  *     - usb_unlink_urb() is deprecated for synchronous unlinks.  Using usb_kill_urb instead.
 234  *     - usbvision_kvirt_to_pa is deprecated.  Removed.
 235  *     - Changes are related to kernel changes for 2.6.10. (Fedora 4)
 236  *
 237  * February 2, 2005 - 0.9.8.1cvs Dwaine Garden
 238  *     - Added a new device to usbvision.h Dazzle DVC 50.  Thanks to Luiz S.
 239  *
 240  * March 29, 2005 - 0.9.8.1cvs Dwaine Garden
 241  *     - Fixed compile error with saa7113 under kernels 2.6.11+
 242  *     - Added module parameter to help people with Black and White output with using s-video input.  Some cables and input device are wired differently.
 243  *     - Removed the .id from the i2c usbvision template.  There was a change to the i2c with kernels 2.6.11+.
 244  *
 245  * April 9, 2005 - 0.9.8.1cvs Dwaine Garden
 246  *     - Added in the 2.4 and 2.6 readme files the SwitchSVideoInput parameter information.  This will help people setup the right values for the parameter.
 247  *       If your device experiences Black and White images with the S-Video Input.  Set this parameter to 1 when loading the module.
 248  *     - Replaced the wrong 2.6 readme file.  I lost the right version.  Someone sent me the right version by e-mail.  Thanks.
 249  *     - Released new module version on sourceforge.net.  So everyone can enjoy all the fixes and additional device support.
 250  *
 251  * April 20, 2005 - 0.9.8.2cvs Dwaine Garden
 252  *     - Release lock in usbvision_v4l_read_done.  -Thanks to nplanel for the patch.
 253  *     - Additional comments to the driver.
 254  *     - Fixed some spelling mistakes.  8*)
 255  *
 256  * April 23, 2005 - 0.9.8.2cvs Joerg Heckenbach
 257  *     - Found bug in usbvision line counting. Now there should be no spurious lines in the image any longer.
 258  *     - Swapped usbvision_register_video and usbvision_configure_video to fix problem with PowerOnAtOpen=0.
 259  *       Thanks to Erwan Velu
 260  *
 261  * April 26, 2005 - 0.9.8.2cvs Joerg Heckenbach
 262  *     - Fixed problem with rmmod module and oppses. Replaced vfree(usbvision->overlay_base) with iounmap(usbvision->overlay_base).
 263  *     - Added function usb_get_dev(dev) and ; To help with unloading the module multiple times without crashing.
 264  *       (Keep the reference count in kobjects correct)
 265  *
 266  * June 14, 2005 - 0.9.8.2cvs Dwaine
 267  *     - Missed a change in saa7113.c for checking kernel version.  Added conditional if's.
 268  *
 269  * June 15, 2005 - 0.9.8.2cvs Dwaine
 270  *     - Added new device WinTV device VendorId 0573 and ProductId 4d29.
 271  *     - Hacked some support for newer NT1005 devices.  This devices only seem to have one configuration, not multiple configurations like the NT1004.
 272  *
 273  * June 29, 2005 - 0.9.8.2cvs Dwaine
 274  *     - Added new device WinTV device VendorId 0573 and ProductId 4d37.
 275  *     - Because of the first empty entry in usbvision_table, modutils failed to create the necessary entries for modules.usbmap.
 276  *       This means hotplug won't work for usbvision.  Thanks to Gary Ng.
 277  *     - Sent an e-mail to the maintainer of usb.ids.  New devices identified need to be added.
 278  *     - Fixed compile error with saa7113 under kernel 2.6.12.
 279  *
 280  * July 6, 2005 - 0.9.8.2cvs Dwaine
 281  *     - Patch submitted by Gary Ng for two additional procfs entries.  Device Input and Frequency setting.
 282  *
 283  * July 12, 2005 - 0.9.8.2cvs Dwaine
 284  *     - New tuner identified for some devices it's called TCL_MFPE05.  This tuner uses the same API as tuner 38 in tuner.c.
 285  *     - Thanks to lynx31 for contacting Hauppage and asking them.
 286  *     - I have no clue as to which devices use this new tuner, so people will have to contact me and tell me.
 287  *
 288  * July 21, 2005 - 0.9.8.2cvs Dwaine
 289  *     - Patched usbvision.c with missing ifdef kernversion statement so the module will compile with older kernels and v4l.
 290  *     - Thanks to cipe007......
 291  *
 292  * May 19, 2006 - 0.9.8.3cvs Dwaine
 293  *     - Patched usbvision.c and i2c-algo.c so they will compile with kernel 2.6.16
 294  *     - Adjust device "Pinnacle Studio PCTV USB (PAL) FM" values in usbvision.h
 295  *
 296  * May 24, 2006 - 0.9.8.3cvs Dwaine
 297  *     -Pinnacle Studio PCTV USB (NTSC) FM uses saa7111, not saa7113 like first thought.
 298  *     -Updated usbvision.h
 299  *
 300  * Aug 15, 2006 - 0.9.8.3cvs Dwaine
 301  *     -Added saa711x module into cvs, since the newer saa7115 module in newer kernels is v4l2.  The usbvision driver is only v4l.
 302  *     -Updated makefile to put compiled modules into correct location.
 303  *
 304  * Aug 21, 2006 - 0.9.8.3cvs Dwaine
 305  *     -Changed number of bytes for i2c write to 4 as per the NT100X spec sheet.  Thanks to Merlum for finding it.
 306  *     -Remove the radio option for device Hauppauge WinTV USB device Model 40219 Rev E189.  This device does not have a FM radio.  Thanks to Shadwell.
 307  *     -Added radio option for device Hauppauge WinTV USB device Model 40219 Rev E189 again.  Just got an e-mail indicating their device has one.  8*)
 308  *
 309  * Aug 27, 2006 - 0.9.8.3cvs Dwaine
 310  *     -Changed ifdef statement so the usbvision driver will compile with kernels at 2.6.12.
 311  *     -Updated readme files for new updated tuner list for v4l devices.
 312  *
 313  *
 314  *
 315  * TODO:
 316  *     - use submit_urb for all setup packets
 317  *     - Fix memory settings for nt1004. It is 4 times as big as the
 318  *       nt1003 memory.
 319  *     - Add audio on endpoint 3 for nt1004 chip.  Seems impossible, needs a codec interface.  Which one?
 320  *     - Clean up the driver.
 321  *     - optimization for performance.
 322  *     - Add Videotext capability (VBI).  Working on it.....
 323  *     - Check audio for other devices
 324  *     - Add v4l2 interface
 325  *
 326  */
 327
 328 #include <linux/kernel.h>
 329 #include <linux/sched.h>
 330 #include <linux/list.h>
 331 #include <linux/timer.h>
 332 #include <linux/slab.h>
 333 #include <linux/mm.h>
 334 #include <linux/utsname.h>
 335 #include <linux/highmem.h>
 336 #include <linux/smp_lock.h>
 337 #include <linux/videodev.h>
 338 #include <linux/vmalloc.h>
 339 #include <linux/module.h>
 340 #include <linux/init.h>
 341 #include <linux/spinlock.h>
 342 #include <asm/io.h>
 343 #include <linux/videodev2.h>
 344 #include <linux/video_decoder.h>
 345 #include <linux/i2c.h>
 346
 347 #define USBVISION_DRIVER_VERSION_MAJOR 0
 348 #define USBVISION_DRIVER_VERSION_MINOR 8
 349 #define USBVISION_DRIVER_VERSION_PATCHLEVEL 0
 350
 351 #define USBVISION_VERSION __stringify(USBVISION_DRIVER_VERSION_MAJOR) "." __stringify(USBVISION_DRIVER_VERSION_MINOR) "." __stringify(USBVISION_DRIVER_VERSION_PATCHLEVEL) " " USBVISION_DRIVER_VERSION_COMMENT
 352 #define USBVISION_DRIVER_VERSION KERNEL_VERSION(USBVISION_DRIVER_VERSION_MAJOR,USBVISION_DRIVER_VERSION_MINOR,USBVISION_DRIVER_VERSION_PATCHLEVEL)
 353
 354 #include <media/saa7115.h>
 355 #include <media/v4l2-common.h>
 356 #include <media/tuner.h>
 357 #include <media/audiochip.h>
 358
 359         #include <linux/moduleparam.h>
 360         #include <linux/workqueue.h>
 361
 362 #ifdef CONFIG_KMOD
 363 #include <linux/kmod.h>
 364 #endif
 365
 366 #include "usbvision.h"
 367 #include "usbvision_ioctl.h"
 368
 369
 370 #define DRIVER_VERSION "0.9.8.3cvs for Linux kernels 2.4.19-2.4.32 + 2.6.0-2.6.17, compiled at "__DATE__", "__TIME__
 371 #define EMAIL "joerg@heckenbach-aw.de"
 372 #define DRIVER_AUTHOR "Joerg Heckenbach <joerg@heckenbach-aw.de>, Dwaine Garden <DwaineGarden@rogers.com>"
 373 #define DRIVER_DESC "USBVision USB Video Device Driver for Linux"
 374 #define DRIVER_LICENSE "GPL"
 375 #define DRIVER_ALIAS "USBVision"
 376
 377 #define ENABLE_HEXDUMP  0       /* Enable if you need it */
 378
 379
 380 #define USBVISION_DEBUG         /* Turn on debug messages */
 381
 382 #ifdef USBVISION_DEBUG
 383         #define PDEBUG(level, fmt, args...) \
 384                 if (debug & (level)) info("[%s:%d] " fmt, __PRETTY_FUNCTION__, __LINE__ , ## args)
 385 #else
 386         #define PDEBUG(level, fmt, args...) do {} while(0)
 387 #endif
 388
 389 #define DBG_IOCTL       1<<3
 390 #define DBG_IO          1<<4
 391 #define DBG_RIO         1<<5
 392 #define DBG_HEADER      1<<7
 393 #define DBG_PROBE       1<<8
 394 #define DBG_IRQ         1<<9
 395 #define DBG_ISOC        1<<10
 396 #define DBG_PARSE       1<<11
 397 #define DBG_SCRATCH     1<<12
 398 #define DBG_FUNC        1<<13
 399 #define DBG_I2C         1<<14
 400
 401 #define DEBUG(x...)                                                             /* General Debug */
 402 #define IODEBUG(x...)                                                           /* Debug IO */
 403 #define OVDEBUG(x...)                                                           /* Debug overlay */
 404 #define MDEBUG(x...)                                                            /* Debug memory management */
 405
 406 //String operations
 407 #define rmspace(str)    while(*str==' ') str++;
 408 #define goto2next(str)  while(*str!=' ') str++; while(*str==' ') str++;
 409
 410
 411 static int usbvision_nr = 0;                    // sequential number of usbvision device
 412
 413
 414 static const int max_imgwidth = MAX_FRAME_WIDTH;
 415 static const int max_imgheight = MAX_FRAME_HEIGHT;
 416 static const int min_imgwidth = MIN_FRAME_WIDTH;
 417 static const int min_imgheight = MIN_FRAME_HEIGHT;
 418
 419 #define FRAMERATE_MIN   0
 420 #define FRAMERATE_MAX   31
 421
 422
 423 enum {
 424         ISOC_MODE_YUV422 = 0x03,
 425         ISOC_MODE_YUV420 = 0x14,
 426         ISOC_MODE_COMPRESS = 0x60,
 427 };
 428
 429 static struct usbvision_v4l2_format_st usbvision_v4l2_format[] = {
 430         { 1, 1,  8, V4L2_PIX_FMT_GREY    , "GREY" },
 431         { 1, 2, 16, V4L2_PIX_FMT_RGB565  , "RGB565" },
 432         { 1, 3, 24, V4L2_PIX_FMT_RGB24   , "RGB24" },
 433         { 1, 4, 32, V4L2_PIX_FMT_RGB32   , "RGB32" },
 434         { 1, 2, 16, V4L2_PIX_FMT_RGB555  , "RGB555" },
 435         { 1, 2, 16, V4L2_PIX_FMT_YUYV    , "YUV422" },
 436         { 1, 2, 12, V4L2_PIX_FMT_YVU420  , "YUV420P" }, // 1.5 !
 437         { 1, 2, 16, V4L2_PIX_FMT_YUV422P , "YUV422P" }
 438 };
 439
 440 /* supported tv norms */
 441 static struct usbvision_tvnorm tvnorms[] = {
 442         {
 443                 .name = "PAL",
 444                 .id = V4L2_STD_PAL,
 445         }, {
 446                 .name = "NTSC",
 447                 .id = V4L2_STD_NTSC,
 448         }, {
 449                  .name = "SECAM",
 450                  .id = V4L2_STD_SECAM,
 451         }, {
 452                 .name = "PAL-M",
 453                 .id = V4L2_STD_PAL_M,
 454         }
 455 };
 456
 457 #define TVNORMS ARRAY_SIZE(tvnorms)
 458
 459
 460 /*
 461  * The value of 'scratch_buf_size' affects quality of the picture
 462  * in many ways. Shorter buffers may cause loss of data when client
 463  * is too slow. Larger buffers are memory-consuming and take longer
 464  * to work with. This setting can be adjusted, but the default value
 465  * should be OK for most desktop users.
 466  */
 467 #define DEFAULT_SCRATCH_BUF_SIZE        (0x20000)               // 128kB memory scratch buffer
 468 static const int scratch_buf_size = DEFAULT_SCRATCH_BUF_SIZE;
 469
 470 // Function prototypes
 471 static int usbvision_restart_isoc(struct usb_usbvision *usbvision);
 472 static int usbvision_begin_streaming(struct usb_usbvision *usbvision);
 473 static int usbvision_muxsel(struct usb_usbvision *usbvision, int channel);
 474 static int usbvision_i2c_write(void *data, unsigned char addr, char *buf, short len);
 475 static int usbvision_i2c_read(void *data, unsigned char addr, char *buf, short len);
 476 static int usbvision_read_reg(struct usb_usbvision *usbvision, unsigned char reg);
 477 static int usbvision_write_reg(struct usb_usbvision *usbvision, unsigned char reg, unsigned char value);
 478 static int usbvision_request_intra (struct usb_usbvision *usbvision);
 479 static int usbvision_unrequest_intra (struct usb_usbvision *usbvision);
 480 static int usbvision_adjust_compression (struct usb_usbvision *usbvision);
 481 static int usbvision_measure_bandwidth (struct usb_usbvision *usbvision);
 482 static void usbvision_release(struct usb_usbvision *usbvision);
 483 static int usbvision_set_input(struct usb_usbvision *usbvision);
 484 static int usbvision_set_output(struct usb_usbvision *usbvision, int width, int height);
 485 static void usbvision_empty_framequeues(struct usb_usbvision *dev);
 486 static int usbvision_stream_interrupt(struct usb_usbvision *dev);
 487 static void call_i2c_clients(struct usb_usbvision *usbvision, unsigned int cmd, void *arg);
 488
 489
 490 // Bit flags (options)
 491 #define FLAGS_RETRY_VIDIOCSYNC          (1 << 0)
 492 #define FLAGS_MONOCHROME                (1 << 1)
 493 #define FLAGS_DISPLAY_HINTS             (1 << 2)
 494 #define FLAGS_OSD_STATS                 (1 << 3)
 495 #define FLAGS_FORCE_TESTPATTERN         (1 << 4)
 496 #define FLAGS_SEPARATE_FRAMES           (1 << 5)
 497 #define FLAGS_CLEAN_FRAMES              (1 << 6)
 498
 499 // Default initalization of device driver parameters
 500 static int flags = 0;                                   // Set the default Overlay Display mode of the device driver
 501 static int debug = 0;                                   // Set the default Debug Mode of the device driver
 502 static int isocMode = ISOC_MODE_COMPRESS;               // Set the default format for ISOC endpoint
 503 static int adjustCompression = 1;                       // Set the compression to be adaptive
 504 static int dga = 1;                                     // Set the default Direct Graphic Access
 505 static int PowerOnAtOpen = 1;                           // Set the default device to power on at startup
 506 static int SwitchSVideoInput = 0;                       // To help people with Black and White output with using s-video input.  Some cables and input device are wired differently.
 507 static int video_nr = -1;                               // Sequential Number of Video Device
 508 static int radio_nr = -1;                               // Sequential Number of Radio Device
 509 static int vbi_nr = -1;                                 // Sequential Number of VBI Device
 510 static char *CustomDevice=NULL;                         // Set as nothing....
 511
 512 // Grab parameters for the device driver
 513
 514 #if defined(module_param)                               // Showing parameters under SYSFS
 515 module_param(flags, int, 0444);
 516 module_param(debug, int, 0444);
 517 module_param(isocMode, int, 0444);
 518 module_param(adjustCompression, int, 0444);
 519 module_param(dga, int, 0444);
 520 module_param(PowerOnAtOpen, int, 0444);
 521 module_param(SwitchSVideoInput, int, 0444);
 522 module_param(video_nr, int, 0444);
 523 module_param(radio_nr, int, 0444);
 524 module_param(vbi_nr, int, 0444);
 525 module_param(CustomDevice, charp, 0444);
 526 #else                                                   // Old Style
 527 MODULE_PARM(flags, "i");                                // Grab the Overlay Display mode of the device driver
 528 MODULE_PARM(debug, "i");                                // Grab the Debug Mode of the device driver
 529 MODULE_PARM(isocMode, "i");                             // Grab the video format of the video device
 530 MODULE_PARM(adjustCompression, "i");                    // Grab the compression to be adaptive
 531 MODULE_PARM(dga, "i");                                  // Grab the Direct Graphic Access
 532 MODULE_PARM(PowerOnAtOpen, "i");                        // Grab the device to power on at startup
 533 MODULE_PARM(SwitchSVideoInput, "i");                    // To help people with Black and White output with using s-video input.  Some cables and input device are wired differently.
 534 MODULE_PARM(video_nr, "i");                             // video_nr option allows to specify a certain /dev/videoX device (like /dev/video0 or /dev/video1 ...)
 535 MODULE_PARM(radio_nr, "i");                             // radio_nr option allows to specify a certain /dev/radioX device (like /dev/radio0 or /dev/radio1 ...)
 536 MODULE_PARM(vbi_nr, "i");                               // vbi_nr option allows to specify a certain /dev/vbiX device (like /dev/vbi0 or /dev/vbi1 ...)
 537 MODULE_PARM(CustomDevice, "s");                         // .... CustomDevice
 538 #endif
 539
 540 MODULE_PARM_DESC(flags, " Set the default Overlay Display mode of the device driver.  Default: 0 (Off)");
 541 MODULE_PARM_DESC(debug, " Set the default Debug Mode of the device driver.  Default: 0 (Off)");
 542 MODULE_PARM_DESC(isocMode, " Set the default format for ISOC endpoint.  Default: 0x60 (Compression On)");
 543 MODULE_PARM_DESC(adjustCompression, " Set the ADPCM compression for the device.  Default: 1 (On)");
 544 MODULE_PARM_DESC(dga, " Set the Direct Graphic Access for the device.  Default: 1 (On)");
 545 MODULE_PARM_DESC(PowerOnAtOpen, " Set the default device to power on when device is opened.  Default: 1 (On)");
 546 MODULE_PARM_DESC(SwitchSVideoInput, " Set the S-Video input.  Some cables and input device are wired differently. Default: 0 (Off)");
 547 MODULE_PARM_DESC(video_nr, "Set video device number (/dev/videoX).  Default: -1 (autodetect)");
 548 MODULE_PARM_DESC(radio_nr, "Set radio device number (/dev/radioX).  Default: -1 (autodetect)");
 549 MODULE_PARM_DESC(vbi_nr, "Set vbi device number (/dev/vbiX).  Default: -1 (autodetect)");
 550 MODULE_PARM_DESC(CustomDevice, " Define the fine tuning parameters for the device.  Default: null");
 551
 552
 553 // Misc stuff
 554 MODULE_AUTHOR(DRIVER_AUTHOR);
 555 MODULE_DESCRIPTION(DRIVER_DESC);
 556 MODULE_LICENSE(DRIVER_LICENSE);
 557         MODULE_VERSION(DRIVER_VERSION);
 558         MODULE_ALIAS(DRIVER_ALIAS);
 559
 560 #ifdef MODULE
 561 static unsigned int autoload = 1;
 562 #else
 563 static unsigned int autoload = 0;
 564 #endif
 565
 566
 567 /****************************************************************************************/
 568 /* SYSFS Code - Copied from the stv680.c usb module.                                    */
 569 /* Device information is located at /sys/class/video4linux/video0                       */
 570 /* Device parameters information is located at /sys/module/usbvision                    */
 571 /* Device USB Information is located at /sys/bus/usb/drivers/USBVision Video Grabber    */
 572 /****************************************************************************************/
 573
 574
 575 #define YES_NO(x) ((x) ? "Yes" : "No")
 576
 577 static inline struct usb_usbvision *cd_to_usbvision(struct class_device *cd)
 578 {
 579         struct video_device *vdev = to_video_device(cd);
 580         return video_get_drvdata(vdev);
 581 }
 582
 583 static ssize_t show_version(struct class_device *cd, char *buf)
 584 {
 585         return sprintf(buf, "%s\n", DRIVER_VERSION);
 586 }
 587 static CLASS_DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
 588
 589 static ssize_t show_model(struct class_device *class_dev, char *buf)
 590 {
 591         struct video_device *vdev = to_video_device(class_dev);
 592         struct usb_usbvision *usbvision = video_get_drvdata(vdev);
 593         return sprintf(buf, "%s\n", usbvision_device_data[usbvision->DevModel].ModelString);
 594 }
 595 static CLASS_DEVICE_ATTR(model, S_IRUGO, show_model, NULL);
 596
 597 static ssize_t show_hue(struct class_device *class_dev, char *buf)
 598 {
 599         struct video_device *vdev = to_video_device(class_dev);
 600         struct usb_usbvision *usbvision = video_get_drvdata(vdev);
 601         return sprintf(buf, "%d\n", usbvision->hue >> 8);
 602 }
 603 static CLASS_DEVICE_ATTR(hue, S_IRUGO, show_hue, NULL);
 604
 605 static ssize_t show_contrast(struct class_device *class_dev, char *buf)
 606 {
 607         struct video_device *vdev = to_video_device(class_dev);
 608         struct usb_usbvision *usbvision = video_get_drvdata(vdev);
 609         return sprintf(buf, "%d\n", usbvision->contrast >> 8);
 610 }
 611 static CLASS_DEVICE_ATTR(contrast, S_IRUGO, show_contrast, NULL);
 612
 613 static ssize_t show_brightness(struct class_device *class_dev, char *buf)
 614 {
 615         struct video_device *vdev = to_video_device(class_dev);
 616         struct usb_usbvision *usbvision = video_get_drvdata(vdev);
 617         return sprintf(buf, "%d\n", usbvision->brightness >> 8);
 618 }
 619 static CLASS_DEVICE_ATTR(brightness, S_IRUGO, show_brightness, NULL);
 620
 621 static ssize_t show_saturation(struct class_device *class_dev, char *buf)
 622 {
 623         struct video_device *vdev = to_video_device(class_dev);
 624         struct usb_usbvision *usbvision = video_get_drvdata(vdev);
 625         return sprintf(buf, "%d\n", usbvision->saturation >> 8);
 626 }
 627 static CLASS_DEVICE_ATTR(saturation, S_IRUGO, show_saturation, NULL);
 628
 629 static ssize_t show_streaming(struct class_device *class_dev, char *buf)
 630 {
 631         struct video_device *vdev = to_video_device(class_dev);
 632         struct usb_usbvision *usbvision = video_get_drvdata(vdev);
 633         return sprintf(buf, "%s\n", YES_NO(usbvision->streaming==Stream_On?1:0));
 634 }
 635 static CLASS_DEVICE_ATTR(streaming, S_IRUGO, show_streaming, NULL);
 636
 637 static ssize_t show_overlay(struct class_device *class_dev, char *buf)
 638 {
 639         struct video_device *vdev = to_video_device(class_dev);
 640         struct usb_usbvision *usbvision = video_get_drvdata(vdev);
 641         return sprintf(buf, "%s\n", YES_NO(usbvision->overlay));
 642 }
 643 static CLASS_DEVICE_ATTR(overlay, S_IRUGO, show_overlay, NULL);
 644
 645 static ssize_t show_compression(struct class_device *class_dev, char *buf)
 646 {
 647         struct video_device *vdev = to_video_device(class_dev);
 648         struct usb_usbvision *usbvision = video_get_drvdata(vdev);
 649         return sprintf(buf, "%s\n", YES_NO(usbvision->isocMode==ISOC_MODE_COMPRESS));
 650 }
 651 static CLASS_DEVICE_ATTR(compression, S_IRUGO, show_compression, NULL);
 652
 653 static ssize_t show_device_bridge(struct class_device *class_dev, char *buf)
 654 {
 655         struct video_device *vdev = to_video_device(class_dev);
 656         struct usb_usbvision *usbvision = video_get_drvdata(vdev);
 657         return sprintf(buf, "%d\n", usbvision->bridgeType);
 658 }
 659 static CLASS_DEVICE_ATTR(bridge, S_IRUGO, show_device_bridge, NULL);
 660
 661 static void usbvision_create_sysfs(struct video_device *vdev)
 662 {
 663         int res;
 664         if (vdev) {
 665                 res=video_device_create_file(vdev, &class_device_attr_version);
 666                 res=video_device_create_file(vdev, &class_device_attr_model);
 667                 res=video_device_create_file(vdev, &class_device_attr_hue);
 668                 res=video_device_create_file(vdev, &class_device_attr_contrast);
 669                 res=video_device_create_file(vdev, &class_device_attr_brightness);
 670                 res=video_device_create_file(vdev, &class_device_attr_saturation);
 671                 res=video_device_create_file(vdev, &class_device_attr_streaming);
 672                 res=video_device_create_file(vdev, &class_device_attr_overlay);
 673                 res=video_device_create_file(vdev, &class_device_attr_compression);
 674                 res=video_device_create_file(vdev, &class_device_attr_bridge);
 675         }
 676 }
 677
 678 static void usbvision_remove_sysfs(struct video_device *vdev)
 679 {
 680         if (vdev) {
 681                 video_device_remove_file(vdev, &class_device_attr_version);
 682                 video_device_remove_file(vdev, &class_device_attr_model);
 683                 video_device_remove_file(vdev, &class_device_attr_hue);
 684                 video_device_remove_file(vdev, &class_device_attr_contrast);
 685                 video_device_remove_file(vdev, &class_device_attr_brightness);
 686                 video_device_remove_file(vdev, &class_device_attr_saturation);
 687                 video_device_remove_file(vdev, &class_device_attr_streaming);
 688                 video_device_remove_file(vdev, &class_device_attr_overlay);
 689                 video_device_remove_file(vdev, &class_device_attr_compression);
 690                 video_device_remove_file(vdev, &class_device_attr_bridge);
 691         }
 692 }
 693
 694
 695 /*******************************/
 696 /* Memory management functions */
 697 /*******************************/
 698
 699 /*
 700  * Here we want the physical address of the memory.
 701  * This is used when initializing the contents of the area.
 702  */
 703
 704
 705 void *usbvision_rvmalloc(unsigned long size)
 706 {
 707         void *mem;
 708         unsigned long adr;
 709
 710         size = PAGE_ALIGN(size);
 711         mem = vmalloc_32(size);
 712         if (!mem)
 713                 return NULL;
 714
 715         memset(mem, 0, size); /* Clear the ram out, no junk to the user */
 716  adr = (unsigned long) mem;
 717  while (size > 0) {
 718   #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
 719    mem_map_reserve(vmalloc_to_page((void *)adr));
 720   #else
 721    SetPageReserved(vmalloc_to_page((void *)adr));
 722   #endif
 723   adr += PAGE_SIZE;
 724   size -= PAGE_SIZE;
 725  }
 726
 727  return mem;
 728 }
 729
 730 void usbvision_rvfree(void *mem, unsigned long size)
 731 {
 732  unsigned long adr;
 733
 734  if (!mem)
 735   return;
 736
 737  adr = (unsigned long) mem;
 738  while ((long) size > 0) {
 739   #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
 740    mem_map_unreserve(vmalloc_to_page((void *)adr));
 741   #else
 742    ClearPageReserved(vmalloc_to_page((void *)adr));
 743   #endif
 744   adr += PAGE_SIZE;
 745   size -= PAGE_SIZE;
 746  }
 747  vfree(mem);
 748 }
 749
 750
 751
 752
 753
 754
 755 #if ENABLE_HEXDUMP
 756 static void usbvision_hexdump(const unsigned char *data, int len)
 757 {
 758  char tmp[80];
 759  int i, k;
 760
 761  for (i = k = 0; len > 0; i++, len--) {
 762   if (i > 0 && (i % 16 == 0)) {
 763    printk("%s\n", tmp);
 764    k = 0;
 765   }
 766   k += sprintf(&tmp[k], "%02x ", data[i]);
 767  }
 768  if (k > 0)
 769   printk("%s\n", tmp);
 770 }
 771 #endif
 772
 773
 774 /* These procedures handle the scratch ring buffer */
 775 int scratch_len(struct usb_usbvision *usbvision)    /*This returns the amount of data actually in the buffer */
 776 {
 777         int len = usbvision->scratch_write_ptr - usbvision->scratch_read_ptr;
 778         if (len < 0) {
 779                 len += scratch_buf_size;
 780         }
 781         PDEBUG(DBG_SCRATCH, "scratch_len() = %d\n", len);
 782
 783         return len;
 784 }
 785
 786
 787 /* This returns the free space left in the buffer */
 788 int scratch_free(struct usb_usbvision *usbvision)
 789 {
 790         int free = usbvision->scratch_read_ptr - usbvision->scratch_write_ptr;
 791         if (free <= 0) {
 792                 free += scratch_buf_size;
 793         }
 794         if (free) {
 795                 free -= 1;                                                      /* at least one byte in the buffer must */
 796                                                                                 /* left blank, otherwise there is no chance to differ between full and empty */
 797         }
 798         PDEBUG(DBG_SCRATCH, "return %d\n", free);
 799
 800         return free;
 801 }
 802
 803
 804 void *debug_memcpy(void *dest, void *src, size_t len)
 805 {
 806         printk(KERN_DEBUG "memcpy(%p, %p, %d);\n", dest, src, len);
 807         return memcpy(dest, src, len);
 808 }
 809
 810
 811 /* This puts data into the buffer */
 812 int scratch_put(struct usb_usbvision *usbvision, unsigned char *data, int len)
 813 {
 814         int len_part;
 815
 816         if (usbvision->scratch_write_ptr + len < scratch_buf_size) {
 817                 memcpy(usbvision->scratch + usbvision->scratch_write_ptr, data, len);
 818                 usbvision->scratch_write_ptr += len;
 819         }
 820         else {
 821                 len_part = scratch_buf_size - usbvision->scratch_write_ptr;
 822                 memcpy(usbvision->scratch + usbvision->scratch_write_ptr, data, len_part);
 823                 if (len == len_part) {
 824                         usbvision->scratch_write_ptr = 0;                       /* just set write_ptr to zero */
 825                 }
 826                 else {
 827                         memcpy(usbvision->scratch, data + len_part, len - len_part);
 828                         usbvision->scratch_write_ptr = len - len_part;
 829                 }
 830         }
 831
 832         PDEBUG(DBG_SCRATCH, "len=%d, new write_ptr=%d\n", len, usbvision->scratch_write_ptr);
 833
 834         return len;
 835 }
 836
 837 /* This marks the write_ptr as position of new frame header */
 838 void scratch_mark_header(struct usb_usbvision *usbvision)
 839 {
 840         PDEBUG(DBG_SCRATCH, "header at write_ptr=%d\n", usbvision->scratch_headermarker_write_ptr);
 841
 842         usbvision->scratch_headermarker[usbvision->scratch_headermarker_write_ptr] =
 843                                 usbvision->scratch_write_ptr;
 844         usbvision->scratch_headermarker_write_ptr += 1;
 845         usbvision->scratch_headermarker_write_ptr %= USBVISION_NUM_HEADERMARKER;
 846 }
 847
 848 /* This gets data from the buffer at the given "ptr" position */
 849 int scratch_get_extra(struct usb_usbvision *usbvision, unsigned char *data, int *ptr, int len)
 850 {
 851         int len_part;
 852         if (*ptr + len < scratch_buf_size) {
 853                 memcpy(data, usbvision->scratch + *ptr, len);
 854                 *ptr += len;
 855         }
 856         else {
 857                 len_part = scratch_buf_size - *ptr;
 858                 memcpy(data, usbvision->scratch + *ptr, len_part);
 859                 if (len == len_part) {
 860                         *ptr = 0;                                                       /* just set the y_ptr to zero */
 861                 }
 862                 else {
 863                         memcpy(data + len_part, usbvision->scratch, len - len_part);
 864                         *ptr = len - len_part;
 865                 }
 866         }
 867
 868         PDEBUG(DBG_SCRATCH, "len=%d, new ptr=%d\n", len, *ptr);
 869
 870         return len;
 871 }
 872
 873
 874 /* This sets the scratch extra read pointer */
 875 void scratch_set_extra_ptr(struct usb_usbvision *usbvision, int *ptr, int len)
 876 {
 877         *ptr = (usbvision->scratch_read_ptr + len)%scratch_buf_size;
 878
 879         PDEBUG(DBG_SCRATCH, "ptr=%d\n", *ptr);
 880 }
 881
 882
 883 /*This increments the scratch extra read pointer */
 884 void scratch_inc_extra_ptr(int *ptr, int len)
 885 {
 886         *ptr = (*ptr + len) % scratch_buf_size;
 887
 888         PDEBUG(DBG_SCRATCH, "ptr=%d\n", *ptr);
 889 }
 890
 891
 892 /* This gets data from the buffer */
 893 int scratch_get(struct usb_usbvision *usbvision, unsigned char *data, int len)
 894 {
 895         int len_part;
 896         if (usbvision->scratch_read_ptr + len < scratch_buf_size) {
 897                 memcpy(data, usbvision->scratch + usbvision->scratch_read_ptr, len);
 898                 usbvision->scratch_read_ptr += len;
 899         }
 900         else {
 901                 len_part = scratch_buf_size - usbvision->scratch_read_ptr;
 902                 memcpy(data, usbvision->scratch + usbvision->scratch_read_ptr, len_part);
 903                 if (len == len_part) {
 904                         usbvision->scratch_read_ptr = 0;                                /* just set the read_ptr to zero */
 905                 }
 906                 else {
 907                         memcpy(data + len_part, usbvision->scratch, len - len_part);
 908                         usbvision->scratch_read_ptr = len - len_part;
 909                 }
 910         }
 911
 912         PDEBUG(DBG_SCRATCH, "len=%d, new read_ptr=%d\n", len, usbvision->scratch_read_ptr);
 913
 914         return len;
 915 }
 916
 917
 918 /* This sets read pointer to next header and returns it */
 919 int scratch_get_header(struct usb_usbvision *usbvision,struct usbvision_frame_header *header)
 920 {
 921         int errCode = 0;
 922
 923         PDEBUG(DBG_SCRATCH, "from read_ptr=%d", usbvision->scratch_headermarker_read_ptr);
 924
 925         while (usbvision->scratch_headermarker_write_ptr -
 926                 usbvision->scratch_headermarker_read_ptr != 0) {
 927                 usbvision->scratch_read_ptr =
 928                         usbvision->scratch_headermarker[usbvision->scratch_headermarker_read_ptr];
 929                 usbvision->scratch_headermarker_read_ptr += 1;
 930                 usbvision->scratch_headermarker_read_ptr %= USBVISION_NUM_HEADERMARKER;
 931                 scratch_get(usbvision, (unsigned char *)header, USBVISION_HEADER_LENGTH);
 932                 if ((header->magic_1 == USBVISION_MAGIC_1)
 933                          && (header->magic_2 == USBVISION_MAGIC_2)
 934                          && (header->headerLength == USBVISION_HEADER_LENGTH)) {
 935                         errCode = USBVISION_HEADER_LENGTH;
 936                         header->frameWidth  = header->frameWidthLo  + (header->frameWidthHi << 8);
 937                         header->frameHeight = header->frameHeightLo + (header->frameHeightHi << 8);
 938                         break;
 939                 }
 940         }
 941
 942         return errCode;
 943 }
 944
 945
 946 /*This removes len bytes of old data from the buffer */
 947 void scratch_rm_old(struct usb_usbvision *usbvision, int len)
 948 {
 949
 950         usbvision->scratch_read_ptr += len;
 951         usbvision->scratch_read_ptr %= scratch_buf_size;
 952         PDEBUG(DBG_SCRATCH, "read_ptr is now %d\n", usbvision->scratch_read_ptr);
 953 }
 954
 955
 956 /*This resets the buffer - kills all data in it too */
 957 void scratch_reset(struct usb_usbvision *usbvision)
 958 {
 959         PDEBUG(DBG_SCRATCH, "\n");
 960
 961         usbvision->scratch_read_ptr = 0;
 962         usbvision->scratch_write_ptr = 0;
 963         usbvision->scratch_headermarker_read_ptr = 0;
 964         usbvision->scratch_headermarker_write_ptr = 0;
 965         usbvision->isocstate = IsocState_NoFrame;
 966 }
 967
 968
 969
 970 /* Here comes the OVERLAY stuff */
 971
 972 /* Tell the interrupt handler what to to.  */
 973 static
 974 void usbvision_cap(struct usb_usbvision* usbvision, int on)
 975 {
 976         DEBUG(printk(KERN_DEBUG "usbvision_cap: overlay was %d, set it to %d\n", usbvision->overlay, on);)
 977
 978         if (on) {
 979                 usbvision->overlay = 1;
 980         }
 981         else {
 982                 usbvision->overlay = 0;
 983         }
 984 }
 985
 986
 987
 988
 989 /* append a new clipregion to the vector of video_clips */
 990 static
 991 void usbvision_new_clip(struct v4l2_format* vf, struct v4l2_clip* vcp, int x, int y, int w, int h)
 992 {
 993         vcp[vf->fmt.win.clipcount].c.left = x;
 994         vcp[vf->fmt.win.clipcount].c.top = y;
 995         vcp[vf->fmt.win.clipcount].c.width = w;
 996         vcp[vf->fmt.win.clipcount].c.height = h;
 997         vf->fmt.win.clipcount++;
 998 }
 999
1000
1001 #define mark_pixel(x,y)  usbvision->clipmask[((x) + (y) * MAX_FRAME_WIDTH)/32] |= 0x00000001<<((x)%32)
1002 #define clipped_pixel(index) usbvision->clipmask[(index)/32] & (0x00000001<<((index)%32))
1003
1004 static
1005 void usbvision_built_overlay(struct usb_usbvision* usbvision, int count, struct v4l2_clip *vcp)
1006 {
1007         usbvision->overlay_win = usbvision->overlay_base +
1008                 (signed int)usbvision->vid_win.fmt.win.w.left * usbvision->depth / 8 +
1009                 (signed int)usbvision->vid_win.fmt.win.w.top * usbvision->vid_buf.fmt.bytesperline;
1010
1011                 IODEBUG(printk(KERN_DEBUG "built_overlay base=%p, win=%p, bpl=%d, clips=%d, size=%dx%d\n",
1012                                         usbvision->overlay_base, usbvision->overlay_win,
1013                                         usbvision->vid_buf.fmt.bytesperline, count,
1014                                         usbvision->vid_win.fmt.win.w.width, usbvision->vid_win.fmt.win.w.height);)
1015
1016
1017         /* Add here generation of clipping mask */
1018 {
1019         int x_start, x_end, y_start, y_end;
1020         int clip_index, x, y;
1021
1022         memset(usbvision->clipmask, 0, USBVISION_CLIPMASK_SIZE);
1023
1024         OVDEBUG(printk(KERN_DEBUG "clips = %d\n", count);)
1025
1026         for(clip_index = 0; clip_index < count; clip_index++) {
1027                 OVDEBUG(printk(KERN_DEBUG "clip: %d,%d,%d,%d\n", vcp[clip_index].x,
1028                                 vcp[clip_index].y,
1029                                 vcp[clip_index].width,
1030                                 vcp[clip_index].height);)
1031
1032                 x_start = vcp[clip_index].c.left;
1033                 if(x_start >= (int)usbvision->vid_win.fmt.win.w.width) {
1034                         OVDEBUG(printk(KERN_DEBUG "x_start=%d\n", x_start);)
1035                         continue; //clipping window is right of overlay window
1036                 }
1037                 x_end   = x_start + vcp[clip_index].c.width;
1038                 if(x_end <= 0) {
1039                         OVDEBUG(printk(KERN_DEBUG "x_end=%d\n", x_end);)
1040                         continue; //clipping window is left of overlay window
1041                 }
1042
1043                 y_start = vcp[clip_index].c.top;
1044                 if(y_start >= (int)usbvision->vid_win.fmt.win.w.height) {
1045                         OVDEBUG(printk(KERN_DEBUG "y_start=%d\n", y_start);)
1046                         continue; //clipping window is below overlay window
1047                 }
1048                 y_end   = y_start + vcp[clip_index].c.height;
1049                 if(y_end <= 0) {
1050                         OVDEBUG(printk(KERN_DEBUG "y_end=%d\n", y_end);)
1051                         continue; //clipping window is above overlay window
1052                 }
1053
1054                 //clip the clipping window
1055                 if (x_start < 0) {
1056                         x_start = 0;
1057                 }
1058                 if (x_end > (int)usbvision->vid_win.fmt.win.w.width) {
1059                         x_end = (int)usbvision->vid_win.fmt.win.w.width;
1060                 }
1061                 if (y_start < 0) {
1062                         y_start = 0;
1063                 }
1064                 if (y_end > (int)usbvision->vid_win.fmt.win.w.height) {
1065                         y_end = (int)usbvision->vid_win.fmt.win.w.height;
1066                 }
1067
1068                 OVDEBUG(printk(KERN_DEBUG "clip_o: %d,%d,%d,%d\n", x_start,     y_start, x_end, y_end);)
1069
1070
1071
1072                 for(y = y_start; y < y_end; y++) {
1073                         for(x = x_start; x < x_end; x++) {
1074                                 mark_pixel(x,y);
1075                         }
1076                 }
1077         }
1078 }
1079
1080 }
1081
1082
1083
1084 void usbvision_osd_char(struct usb_usbvision *usbvision,
1085                         struct usbvision_frame *frame, int x, int y, int ch)
1086 {
1087         static const unsigned short digits[16] = {
1088                 0xF6DE,         /* 0 */
1089                 0x2492,         /* 1 */
1090                 0xE7CE,         /* 2 */
1091                 0xE79E,         /* 3 */
1092                 0xB792,         /* 4 */
1093                 0xF39E,         /* 5 */
1094                 0xF3DE,         /* 6 */
1095                 0xF492,         /* 7 */
1096                 0xF7DE,         /* 8 */
1097                 0xF79E,         /* 9 */
1098                 0x77DA,         /* a */
1099                 0xD75C,         /* b */
1100                 0xF24E,         /* c */
1101                 0xD6DC,         /* d */
1102                 0xF34E,         /* e */
1103                 0xF348          /* f */
1104         };
1105         unsigned short digit;
1106         int ix, iy;
1107
1108         if ((usbvision == NULL) || (frame == NULL))
1109                 return;
1110
1111         if (ch >= '0' && ch <= '9')
1112                 ch -= '0';
1113         else if (ch >= 'A' && ch <= 'F')
1114                 ch = 10 + (ch - 'A');
1115         else if (ch >= 'a' && ch <= 'f')
1116                 ch = 10 + (ch - 'a');
1117         else
1118                 return;
1119         digit = digits[ch];
1120
1121         for (iy = 0; iy < 5; iy++) {
1122                 for (ix = 0; ix < 3; ix++) {
1123                         if (digit & 0x8000) {
1124                         //      USBVISION_PUTPIXEL(frame, x + ix, y + iy,
1125                         //                      0xFF, 0xFF, 0xFF);
1126                         }
1127                         digit = digit << 1;
1128                 }
1129         }
1130 }
1131
1132
1133 void usbvision_osd_string(struct usb_usbvision *usbvision,
1134                           struct usbvision_frame *frame,
1135                           int x, int y, const char *str)
1136 {
1137         while (*str) {
1138                 usbvision_osd_char(usbvision, frame, x, y, *str);
1139                 str++;
1140                 x += 4;         /* 3 pixels character + 1 space */
1141         }
1142 }
1143
1144 /*
1145  * usb_usbvision_osd_stats()
1146  *
1147  * On screen display of important debugging information.
1148  *
1149  */
1150 void usbvision_osd_stats(struct usb_usbvision *usbvision,
1151                          struct usbvision_frame *frame)
1152 {
1153         const int y_diff = 8;
1154         char tmp[16];
1155         int x = 10;
1156         int y = 10;
1157
1158         sprintf(tmp, "%8x", usbvision->frame_num);
1159         usbvision_osd_string(usbvision, frame, x, y, tmp);
1160         y += y_diff;
1161
1162         sprintf(tmp, "%8lx", usbvision->isocUrbCount);
1163         usbvision_osd_string(usbvision, frame, x, y, tmp);
1164         y += y_diff;
1165
1166         sprintf(tmp, "%8lx", usbvision->urb_length);
1167         usbvision_osd_string(usbvision, frame, x, y, tmp);
1168         y += y_diff;
1169
1170         sprintf(tmp, "%8lx", usbvision->isocDataCount);
1171         usbvision_osd_string(usbvision, frame, x, y, tmp);
1172         y += y_diff;
1173
1174         sprintf(tmp, "%8lx", usbvision->header_count);
1175         usbvision_osd_string(usbvision, frame, x, y, tmp);
1176         y += y_diff;
1177
1178         sprintf(tmp, "%8lx", usbvision->scratch_ovf_count);
1179         usbvision_osd_string(usbvision, frame, x, y, tmp);
1180         y += y_diff;
1181
1182         sprintf(tmp, "%8lx", usbvision->isocSkipCount);
1183         usbvision_osd_string(usbvision, frame, x, y, tmp);
1184         y += y_diff;
1185
1186         sprintf(tmp, "%8lx", usbvision->isocErrCount);
1187         usbvision_osd_string(usbvision, frame, x, y, tmp);
1188         y += y_diff;
1189
1190         sprintf(tmp, "%8x", usbvision->saturation);
1191         usbvision_osd_string(usbvision, frame, x, y, tmp);
1192         y += y_diff;
1193
1194         sprintf(tmp, "%8x", usbvision->hue);
1195         usbvision_osd_string(usbvision, frame, x, y, tmp);
1196         y += y_diff;
1197
1198         sprintf(tmp, "%8x", usbvision->brightness >> 8);
1199         usbvision_osd_string(usbvision, frame, x, y, tmp);
1200         y += y_diff;
1201
1202         sprintf(tmp, "%8x", usbvision->contrast >> 12);
1203         usbvision_osd_string(usbvision, frame, x, y, tmp);
1204         y += y_diff;
1205
1206 }
1207
1208 /*
1209  * usbvision_testpattern()
1210  *
1211  * Procedure forms a test pattern (yellow grid on blue background).
1212  *
1213  * Parameters:
1214  * fullframe:   if TRUE then entire frame is filled, otherwise the procedure
1215  *              continues from the current scanline.
1216  * pmode        0: fill the frame with solid blue color (like on VCR or TV)
1217  *              1: Draw a colored grid
1218  *
1219  */
1220 void usbvision_testpattern(struct usb_usbvision *usbvision, int fullframe,
1221                         int pmode)
1222 {
1223         static const char proc[] = "usbvision_testpattern";
1224         struct usbvision_frame *frame;
1225         unsigned char *f;
1226         int num_cell = 0;
1227         int scan_length = 0;
1228         static int num_pass = 0;
1229
1230         if (usbvision == NULL) {
1231                 printk(KERN_ERR "%s: usbvision == NULL\n", proc);
1232                 return;
1233         }
1234         if (usbvision->curFrame == NULL) {
1235                 printk(KERN_ERR "%s: usbvision->curFrame is NULL.\n", proc);
1236                 return;
1237         }
1238
1239         /* Grab the current frame */
1240         frame = usbvision->curFrame;
1241
1242         /* Optionally start at the beginning */
1243         if (fullframe) {
1244                 frame->curline = 0;
1245                 frame->scanlength = 0;
1246         }
1247
1248         /* Form every scan line */
1249         for (; frame->curline < frame->frmheight; frame->curline++) {
1250                 int i;
1251
1252                 f = frame->data + (usbvision->curwidth * 3 * frame->curline);
1253                 for (i = 0; i < usbvision->curwidth; i++) {
1254                         unsigned char cb = 0x80;
1255                         unsigned char cg = 0;
1256                         unsigned char cr = 0;
1257
1258                         if (pmode == 1) {
1259                                 if (frame->curline % 32 == 0)
1260                                         cb = 0, cg = cr = 0xFF;
1261                                 else if (i % 32 == 0) {
1262                                         if (frame->curline % 32 == 1)
1263                                                 num_cell++;
1264                                         cb = 0, cg = cr = 0xFF;
1265                                 } else {
1266                                         cb =
1267                                             ((num_cell * 7) +
1268                                              num_pass) & 0xFF;
1269                                         cg =
1270                                             ((num_cell * 5) +
1271                                              num_pass * 2) & 0xFF;
1272                                         cr =
1273                                             ((num_cell * 3) +
1274                                              num_pass * 3) & 0xFF;
1275                                 }
1276                         } else {
1277                                 /* Just the blue screen */
1278                         }
1279
1280                         *f++ = cb;
1281                         *f++ = cg;
1282                         *f++ = cr;
1283                         scan_length += 3;
1284                 }
1285         }
1286
1287         frame->grabstate = FrameState_Done;
1288         frame->scanlength += scan_length;
1289         ++num_pass;
1290
1291         /* We do this unconditionally, regardless of FLAGS_OSD_STATS */
1292         usbvision_osd_stats(usbvision, frame);
1293 }
1294
1295 /*
1296  * Here comes the data parsing stuff that is run as interrupt
1297  */
1298
1299 /*
1300  * usbvision_find_header()
1301  *
1302  * Locate one of supported header markers in the scratch buffer.
1303  */
1304 static enum ParseState usbvision_find_header(struct usb_usbvision *usbvision)
1305 {
1306         struct usbvision_frame *frame;
1307         int foundHeader = 0;
1308
1309         if (usbvision->overlay) {
1310                 frame = &usbvision->overlay_frame;
1311         }
1312         else {
1313                 frame = usbvision->curFrame;
1314         }
1315
1316         while (scratch_get_header(usbvision, &frame->isocHeader) == USBVISION_HEADER_LENGTH) {
1317                 // found header in scratch
1318                 PDEBUG(DBG_HEADER, "found header: 0x%02x%02x %d %d %d %d %#x 0x%02x %u %u",
1319                                 frame->isocHeader.magic_2,
1320                                 frame->isocHeader.magic_1,
1321                                 frame->isocHeader.headerLength,
1322                                 frame->isocHeader.frameNum,
1323                                 frame->isocHeader.framePhase,
1324                                 frame->isocHeader.frameLatency,
1325                                 frame->isocHeader.dataFormat,
1326                                 frame->isocHeader.formatParam,
1327                                 frame->isocHeader.frameWidth,
1328                                 frame->isocHeader.frameHeight);
1329
1330                 if (usbvision->requestIntra) {
1331                         if (frame->isocHeader.formatParam & 0x80) {
1332                                 foundHeader = 1;
1333                                 usbvision->lastIsocFrameNum = -1; // do not check for lost frames this time
1334                                 usbvision_unrequest_intra(usbvision);
1335                                 break;
1336                         }
1337                 }
1338                 else {
1339                         foundHeader = 1;
1340                         break;
1341                 }
1342         }
1343
1344         if (foundHeader) {
1345                 frame->frmwidth = frame->isocHeader.frameWidth * usbvision->stretch_width;
1346                 frame->frmheight = frame->isocHeader.frameHeight * usbvision->stretch_height;
1347                 frame->v4l2_linesize = (frame->frmwidth * frame->v4l2_format.depth)>> 3;
1348         }
1349         else { // no header found
1350                 PDEBUG(DBG_HEADER, "skipping scratch data, no header");
1351                 scratch_reset(usbvision);
1352                 return ParseState_EndParse;
1353         }
1354
1355         // found header
1356         if (frame->isocHeader.dataFormat==ISOC_MODE_COMPRESS) {
1357                 //check isocHeader.frameNum for lost frames
1358                 if (usbvision->lastIsocFrameNum >= 0) {
1359                         if (((usbvision->lastIsocFrameNum + 1) % 32) != frame->isocHeader.frameNum) {
1360                                 // unexpected frame drop: need to request new intra frame
1361                                 PDEBUG(DBG_HEADER, "Lost frame before %d on USB", frame->isocHeader.frameNum);
1362                                 usbvision_request_intra(usbvision);
1363                                 return ParseState_NextFrame;
1364                         }
1365                 }
1366                 usbvision->lastIsocFrameNum = frame->isocHeader.frameNum;
1367         }
1368         usbvision->header_count++;
1369         frame->scanstate = ScanState_Lines;
1370         frame->curline = 0;
1371
1372         if (flags & FLAGS_FORCE_TESTPATTERN) {
1373                 usbvision_testpattern(usbvision, 1, 1);
1374                 return ParseState_NextFrame;
1375         }
1376         return ParseState_Continue;
1377 }
1378
1379 static enum ParseState usbvision_parse_lines_422(struct usb_usbvision *usbvision,
1380                                            long *pcopylen)
1381 {
1382         volatile struct usbvision_frame *frame;
1383         unsigned char *f;
1384         int len;
1385         int i;
1386         unsigned char yuyv[4]={180, 128, 10, 128}; // YUV components
1387         unsigned char rv, gv, bv;       // RGB components
1388         int clipmask_index, bytes_per_pixel;
1389         int overlay = usbvision->overlay;
1390         int stretch_bytes, clipmask_add;
1391
1392         if (overlay) {
1393                 frame  = &usbvision->overlay_frame;
1394                 if (usbvision->overlay_base == NULL) {
1395                         //video_buffer is not set yet
1396                         return ParseState_NextFrame;
1397                 }
1398                 f = usbvision->overlay_win + frame->curline *
1399                         usbvision->vid_buf.fmt.bytesperline;
1400         }
1401         else {
1402                 frame  = usbvision->curFrame;
1403                 f = frame->data + (frame->v4l2_linesize * frame->curline);
1404         }
1405
1406         /* Make sure there's enough data for the entire line */
1407         len = (frame->isocHeader.frameWidth * 2)+5;
1408         if (scratch_len(usbvision) < len) {
1409                 PDEBUG(DBG_PARSE, "out of data in line %d, need %u.\n", frame->curline, len);
1410                 return ParseState_Out;
1411         }
1412
1413         if ((frame->curline + 1) >= frame->frmheight) {
1414                 return ParseState_NextFrame;
1415         }
1416
1417         bytes_per_pixel = frame->v4l2_format.bytes_per_pixel;
1418         stretch_bytes = (usbvision->stretch_width - 1) * bytes_per_pixel;
1419         clipmask_index = frame->curline * MAX_FRAME_WIDTH;
1420         clipmask_add = usbvision->stretch_width;
1421
1422         for (i = 0; i < frame->frmwidth; i+=(2 * usbvision->stretch_width)) {
1423
1424                 scratch_get(usbvision, &yuyv[0], 4);
1425
1426                 if((overlay) && (clipped_pixel(clipmask_index))) {
1427                         f += bytes_per_pixel;
1428                 }
1429                 else if (frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
1430                         *f++ = yuyv[0]; // Y
1431                         *f++ = yuyv[3]; // U
1432                 }
1433                 else {
1434
1435                         YUV_TO_RGB_BY_THE_BOOK(yuyv[0], yuyv[1], yuyv[3], rv, gv, bv);
1436                         switch (frame->v4l2_format.format) {
1437                                 case V4L2_PIX_FMT_RGB565:
1438                                         *f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 3));
1439                                         *f++ = (0x07 & (gv >> 5)) | (0xF8 &  rv);
1440                                         break;
1441                                 case V4L2_PIX_FMT_RGB24:
1442                                         *f++ = bv;
1443                                         *f++ = gv;
1444                                         *f++ = rv;
1445                                         break;
1446                                 case V4L2_PIX_FMT_RGB32:
1447                                         *f++ = bv;
1448                                         *f++ = gv;
1449                                         *f++ = rv;
1450                                         f++;
1451                                         break;
1452                                 case V4L2_PIX_FMT_RGB555:
1453                                         *f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 2));
1454                                         *f++ = (0x03 & (gv >> 6)) | (0x7C & (rv >> 1));
1455                                         break;
1456                         }
1457                 }
1458                 clipmask_index += clipmask_add;
1459                 f += stretch_bytes;
1460
1461                 if((overlay) && (clipped_pixel(clipmask_index))) {
1462                         f += bytes_per_pixel;
1463                 }
1464                 else if (frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
1465                         *f++ = yuyv[2]; // Y
1466                         *f++ = yuyv[1]; // V
1467                 }
1468                 else {
1469
1470                         YUV_TO_RGB_BY_THE_BOOK(yuyv[2], yuyv[1], yuyv[3], rv, gv, bv);
1471                         switch (frame->v4l2_format.format) {
1472                                 case V4L2_PIX_FMT_RGB565:
1473                                         *f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 3));
1474                                         *f++ = (0x07 & (gv >> 5)) | (0xF8 &  rv);
1475                                         break;
1476                                 case V4L2_PIX_FMT_RGB24:
1477                                         *f++ = bv;
1478                                         *f++ = gv;
1479                                         *f++ = rv;
1480                                         break;
1481                                 case V4L2_PIX_FMT_RGB32:
1482                                         *f++ = bv;
1483                                         *f++ = gv;
1484                                         *f++ = rv;
1485                                         f++;
1486                                         break;
1487                                 case V4L2_PIX_FMT_RGB555:
1488                                         *f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 2));
1489                                         *f++ = (0x03 & (gv >> 6)) | (0x7C & (rv >> 1));
1490                                         break;
1491                         }
1492                 }
1493                 clipmask_index += clipmask_add;
1494                 f += stretch_bytes;
1495         }
1496
1497         frame->curline += usbvision->stretch_height;
1498         *pcopylen += frame->v4l2_linesize * usbvision->stretch_height;
1499
1500         if (frame->curline >= frame->frmheight) {
1501                 return ParseState_NextFrame;
1502         }
1503         else {
1504                 return ParseState_Continue;
1505         }
1506 }
1507
1508
1509 static int usbvision_decompress(struct usb_usbvision *usbvision,unsigned char *Compressed,
1510                                                                 unsigned char *Decompressed, int *StartPos,
1511                                                                 int *BlockTypeStartPos, int Len)
1512 {
1513         int RestPixel, Idx, MaxPos, Pos, ExtraPos, BlockLen, BlockTypePos, BlockTypeLen;
1514         unsigned char BlockByte, BlockCode, BlockType, BlockTypeByte, Integrator;
1515
1516         Integrator = 0;
1517         Pos = *StartPos;
1518         BlockTypePos = *BlockTypeStartPos;
1519         MaxPos = 396; //Pos + Len;
1520         ExtraPos = Pos;
1521         BlockLen = 0;
1522         BlockByte = 0;
1523         BlockCode = 0;
1524         BlockType = 0;
1525         BlockTypeByte = 0;
1526         BlockTypeLen = 0;
1527         RestPixel = Len;
1528
1529         for (Idx = 0; Idx < Len; Idx++) {
1530
1531                 if (BlockLen == 0) {
1532                         if (BlockTypeLen==0) {
1533                                 BlockTypeByte = Compressed[BlockTypePos];
1534                                 BlockTypePos++;
1535                                 BlockTypeLen = 4;
1536                         }
1537                         BlockType = (BlockTypeByte & 0xC0) >> 6;
1538
1539                         //statistic:
1540                         usbvision->ComprBlockTypes[BlockType]++;
1541
1542                         Pos = ExtraPos;
1543                         if (BlockType == 0) {
1544                                 if(RestPixel >= 24) {
1545                                         Idx += 23;
1546                                         RestPixel -= 24;
1547                                         Integrator = Decompressed[Idx];
1548                                 } else {
1549                                         Idx += RestPixel - 1;
1550                                         RestPixel = 0;
1551                                 }
1552                         } else {
1553                                 BlockCode = Compressed[Pos];
1554                                 Pos++;
1555                                 if (RestPixel >= 24) {
1556                                         BlockLen  = 24;
1557                                 } else {
1558                                         BlockLen = RestPixel;
1559                                 }
1560                                 RestPixel -= BlockLen;
1561                                 ExtraPos = Pos + (BlockLen / 4);
1562                         }
1563                         BlockTypeByte <<= 2;
1564                         BlockTypeLen -= 1;
1565                 }
1566                 if (BlockLen > 0) {
1567                         if ((BlockLen%4) == 0) {
1568                                 BlockByte = Compressed[Pos];
1569                                 Pos++;
1570                         }
1571                         if (BlockType == 1) { //inter Block
1572                                 Integrator = Decompressed[Idx];
1573                         }
1574                         switch (BlockByte & 0xC0) {
1575                                 case 0x03<<6:
1576                                         Integrator += Compressed[ExtraPos];
1577                                         ExtraPos++;
1578                                         break;
1579                                 case 0x02<<6:
1580                                         Integrator += BlockCode;
1581                                         break;
1582                                 case 0x00:
1583                                         Integrator -= BlockCode;
1584                                         break;
1585                         }
1586                         Decompressed[Idx] = Integrator;
1587                         BlockByte <<= 2;
1588                         BlockLen -= 1;
1589                 }
1590         }
1591         *StartPos = ExtraPos;
1592         *BlockTypeStartPos = BlockTypePos;
1593         return Idx;
1594 }
1595
1596
1597 /*
1598  * usbvision_parse_compress()
1599  *
1600  * Parse compressed frame from the scratch buffer, put
1601  * decoded RGB value into the current frame buffer and add the written
1602  * number of bytes (RGB) to the *pcopylen.
1603  *
1604  */
1605 static enum ParseState usbvision_parse_compress(struct usb_usbvision *usbvision,
1606                                            long *pcopylen)
1607 {
1608 #define USBVISION_STRIP_MAGIC           0x5A
1609 #define USBVISION_STRIP_LEN_MAX         400
1610 #define USBVISION_STRIP_HEADER_LEN      3
1611
1612         struct usbvision_frame *frame;
1613         unsigned char *f,*u = NULL ,*v = NULL;
1614         unsigned char StripData[USBVISION_STRIP_LEN_MAX];
1615         unsigned char StripHeader[USBVISION_STRIP_HEADER_LEN];
1616         int Idx, IdxEnd, StripLen, StripPtr, StartBlockPos, BlockPos, BlockTypePos;
1617         int clipmask_index, bytes_per_pixel, rc;
1618         int overlay = usbvision->overlay;
1619         int imageSize;
1620         unsigned char rv, gv, bv;
1621         static unsigned char *Y, *U, *V;
1622
1623         if (overlay) {
1624                 frame  = &usbvision->overlay_frame;
1625                 imageSize = frame->frmwidth * frame->frmheight;
1626                 if (usbvision->overlay_base == NULL) {
1627                         //video_buffer is not set yet
1628                         return ParseState_NextFrame;
1629                 }
1630                 f = usbvision->overlay_win + frame->curline *
1631                         usbvision->vid_buf.fmt.bytesperline;
1632         }
1633         else {
1634                 frame  = usbvision->curFrame;
1635                 imageSize = frame->frmwidth * frame->frmheight;
1636                 if ( (frame->v4l2_format.format == V4L2_PIX_FMT_YUV422P) ||
1637                      (frame->v4l2_format.format == V4L2_PIX_FMT_YVU420) )
1638                 {       // this is a planar format
1639                                                                        //... v4l2_linesize not used here.
1640                         f = frame->data + (frame->width * frame->curline);
1641                 } else
1642                         f = frame->data + (frame->v4l2_linesize * frame->curline);
1643
1644                 if (frame->v4l2_format.format == V4L2_PIX_FMT_YUYV){ //initialise u and v pointers
1645                                                                  // get base of u and b planes add halfoffset
1646
1647                         u = frame->data
1648                                 + imageSize
1649                                 + (frame->frmwidth >>1) * frame->curline ;
1650                         v = u + (imageSize >>1 );
1651
1652                 } else if (frame->v4l2_format.format == V4L2_PIX_FMT_YVU420){
1653
1654                         v = frame->data + imageSize + ((frame->curline* (frame->width))>>2) ;
1655                         u = v + (imageSize >>2) ;
1656                 }
1657         }
1658
1659         if (frame->curline == 0) {
1660                 usbvision_adjust_compression(usbvision);
1661         }
1662
1663         if (scratch_len(usbvision) < USBVISION_STRIP_HEADER_LEN) {
1664                 return ParseState_Out;
1665         }
1666
1667         //get strip header without changing the scratch_read_ptr
1668         scratch_set_extra_ptr(usbvision, &StripPtr, 0);
1669         scratch_get_extra(usbvision, &StripHeader[0], &StripPtr,
1670                                 USBVISION_STRIP_HEADER_LEN);
1671
1672         if (StripHeader[0] != USBVISION_STRIP_MAGIC) {
1673                 // wrong strip magic
1674                 usbvision->stripMagicErrors++;
1675                 return ParseState_NextFrame;
1676         }
1677
1678         if (frame->curline != (int)StripHeader[2]) {
1679                 //line number missmatch error
1680                 usbvision->stripLineNumberErrors++;
1681         }
1682
1683         StripLen = 2 * (unsigned int)StripHeader[1];
1684         if (StripLen > USBVISION_STRIP_LEN_MAX) {
1685                 // strip overrun
1686                 // I think this never happens
1687                 usbvision_request_intra(usbvision);
1688         }
1689
1690         if (scratch_len(usbvision) < StripLen) {
1691                 //there is not enough data for the strip
1692                 return ParseState_Out;
1693         }
1694
1695         if (usbvision->IntraFrameBuffer) {
1696                 Y = usbvision->IntraFrameBuffer + frame->frmwidth * frame->curline;
1697                 U = usbvision->IntraFrameBuffer + imageSize + (frame->frmwidth / 2) * (frame->curline / 2);
1698                 V = usbvision->IntraFrameBuffer + imageSize / 4 * 5 + (frame->frmwidth / 2) * (frame->curline / 2);
1699         }
1700         else {
1701                 return ParseState_NextFrame;
1702         }
1703
1704         bytes_per_pixel = frame->v4l2_format.bytes_per_pixel;
1705         clipmask_index = frame->curline * MAX_FRAME_WIDTH;
1706
1707         scratch_get(usbvision, StripData, StripLen);
1708
1709         IdxEnd = frame->frmwidth;
1710         BlockTypePos = USBVISION_STRIP_HEADER_LEN;
1711         StartBlockPos = BlockTypePos + (IdxEnd - 1) / 96 + (IdxEnd / 2 - 1) / 96 + 2;
1712         BlockPos = StartBlockPos;
1713
1714         usbvision->BlockPos = BlockPos;
1715
1716         if ((rc = usbvision_decompress(usbvision, StripData, Y, &BlockPos, &BlockTypePos, IdxEnd)) != IdxEnd) {
1717                 //return ParseState_Continue;
1718         }
1719         if (StripLen > usbvision->maxStripLen) {
1720                 usbvision->maxStripLen = StripLen;
1721         }
1722
1723         if (frame->curline%2) {
1724                 if ((rc = usbvision_decompress(usbvision, StripData, V, &BlockPos, &BlockTypePos, IdxEnd/2)) != IdxEnd/2) {
1725                 //return ParseState_Continue;
1726                 }
1727         }
1728         else {
1729                 if ((rc = usbvision_decompress(usbvision, StripData, U, &BlockPos, &BlockTypePos, IdxEnd/2)) != IdxEnd/2) {
1730                         //return ParseState_Continue;
1731                 }
1732         }
1733
1734         if (BlockPos > usbvision->comprBlockPos) {
1735                 usbvision->comprBlockPos = BlockPos;
1736         }
1737         if (BlockPos > StripLen) {
1738                 usbvision->stripLenErrors++;
1739         }
1740
1741         for (Idx = 0; Idx < IdxEnd; Idx++) {
1742                 if((overlay) && (clipped_pixel(clipmask_index))) {
1743                         f += bytes_per_pixel;
1744                 }
1745                 else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
1746                         *f++ = Y[Idx];
1747                         *f++ = Idx & 0x01 ? U[Idx/2] : V[Idx/2];
1748                 }
1749                 else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUV422P) {
1750                         *f++ = Y[Idx];
1751                         if ( Idx & 0x01)
1752                                 *u++ = U[Idx>>1] ;
1753                         else
1754                                 *v++ = V[Idx>>1];
1755                 }
1756                 else if (frame->v4l2_format.format == V4L2_PIX_FMT_YVU420) {
1757                         *f++ = Y [Idx];
1758                         if ( !((  Idx & 0x01  ) | (  frame->curline & 0x01  )) ){
1759
1760 /*                               only need do this for 1 in 4 pixels */
1761 /*                               intraframe buffer is YUV420 format */
1762
1763                                 *u++ = U[Idx >>1];
1764                                 *v++ = V[Idx >>1];
1765                         }
1766
1767                 }
1768                 else {
1769                         YUV_TO_RGB_BY_THE_BOOK(Y[Idx], U[Idx/2], V[Idx/2], rv, gv, bv);
1770                         switch (frame->v4l2_format.format) {
1771                                 case V4L2_PIX_FMT_GREY:
1772                                         *f++ = Y[Idx];
1773                                         break;
1774                                 case V4L2_PIX_FMT_RGB555:
1775                                         *f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 2));
1776                                         *f++ = (0x03 & (gv >> 6)) | (0x7C & (rv >> 1));
1777                                         break;
1778                                 case V4L2_PIX_FMT_RGB565:
1779                                         *f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 3));
1780                                         *f++ = (0x07 & (gv >> 5)) | (0xF8 &  rv);
1781                                         break;
1782                                 case V4L2_PIX_FMT_RGB24:
1783                                         *f++ = bv;
1784                                         *f++ = gv;
1785                                         *f++ = rv;
1786                                         break;
1787                                 case V4L2_PIX_FMT_RGB32:
1788                                         *f++ = bv;
1789                                         *f++ = gv;
1790                                         *f++ = rv;
1791                                         f++;
1792                                         break;
1793                         }
1794                 }
1795                 clipmask_index++;
1796         }
1797         /* Deal with non-integer no. of bytes for YUV420P */
1798         if (frame->v4l2_format.format != V4L2_PIX_FMT_YVU420 )
1799                 *pcopylen += frame->v4l2_linesize;
1800         else
1801                 *pcopylen += frame->curline & 0x01 ? frame->v4l2_linesize : frame->v4l2_linesize << 1;
1802
1803         frame->curline += 1;
1804
1805         if (frame->curline >= frame->frmheight) {
1806                 return ParseState_NextFrame;
1807         }
1808         else {
1809                 return ParseState_Continue;
1810         }
1811
1812 }
1813
1814
1815 /*
1816  * usbvision_parse_lines_420()
1817  *
1818  * Parse two lines from the scratch buffer, put
1819  * decoded RGB value into the current frame buffer and add the written
1820  * number of bytes (RGB) to the *pcopylen.
1821  *
1822  */
1823 static enum ParseState usbvision_parse_lines_420(struct usb_usbvision *usbvision,
1824                                            long *pcopylen)
1825 {
1826         struct usbvision_frame *frame;
1827         unsigned char *f_even = NULL, *f_odd = NULL;
1828         unsigned int pixel_per_line, block;
1829         int pixel, block_split;
1830         int y_ptr, u_ptr, v_ptr, y_odd_offset;
1831         const int   y_block_size = 128;
1832         const int  uv_block_size = 64;
1833         const int sub_block_size = 32;
1834         const int y_step[] = { 0, 0, 0, 2 },  y_step_size = 4;
1835         const int uv_step[]= { 0, 0, 0, 4 }, uv_step_size = 4;
1836         unsigned char y[2], u, v;       /* YUV components */
1837         int y_, u_, v_, vb, uvg, ur;
1838         int r_, g_, b_;                 /* RGB components */
1839         unsigned char g;
1840         int clipmask_even_index, clipmask_odd_index, bytes_per_pixel;
1841         int clipmask_add, stretch_bytes;
1842         int overlay = usbvision->overlay;
1843
1844         if (overlay) {
1845                 frame  = &usbvision->overlay_frame;
1846                 if (usbvision->overlay_base == NULL) {
1847                         //video_buffer is not set yet
1848                         return ParseState_NextFrame;
1849                 }
1850                 f_even = usbvision->overlay_win + frame->curline *
1851                          usbvision->vid_buf.fmt.bytesperline;
1852                 f_odd  = f_even + usbvision->vid_buf.fmt.bytesperline * usbvision->stretch_height;
1853         }
1854         else {
1855                 frame  = usbvision->curFrame;
1856                 f_even = frame->data + (frame->v4l2_linesize * frame->curline);
1857                 f_odd  = f_even + frame->v4l2_linesize * usbvision->stretch_height;
1858         }
1859
1860         /* Make sure there's enough data for the entire line */
1861         /* In this mode usbvision transfer 3 bytes for every 2 pixels */
1862         /* I need two lines to decode the color */
1863         bytes_per_pixel = frame->v4l2_format.bytes_per_pixel;
1864         stretch_bytes = (usbvision->stretch_width - 1) * bytes_per_pixel;
1865         clipmask_even_index = frame->curline * MAX_FRAME_WIDTH;
1866         clipmask_odd_index  = clipmask_even_index + MAX_FRAME_WIDTH;
1867         clipmask_add = usbvision->stretch_width;
1868         pixel_per_line = frame->isocHeader.frameWidth;
1869
1870         if (scratch_len(usbvision) < (int)pixel_per_line * 3) {
1871                 //printk(KERN_DEBUG "out of data, need %d\n", len);
1872                 return ParseState_Out;
1873         }
1874
1875         if ((frame->curline + 1) >= frame->frmheight) {
1876                 return ParseState_NextFrame;
1877         }
1878
1879         block_split = (pixel_per_line%y_block_size) ? 1 : 0;    //are some blocks splitted into different lines?
1880
1881         y_odd_offset = (pixel_per_line / y_block_size) * (y_block_size + uv_block_size)
1882                         + block_split * uv_block_size;
1883
1884         scratch_set_extra_ptr(usbvision, &y_ptr, y_odd_offset);
1885         scratch_set_extra_ptr(usbvision, &u_ptr, y_block_size);
1886         scratch_set_extra_ptr(usbvision, &v_ptr, y_odd_offset
1887                         + (4 - block_split) * sub_block_size);
1888
1889         for (block = 0; block < (pixel_per_line / sub_block_size);
1890              block++) {
1891
1892
1893                 for (pixel = 0; pixel < sub_block_size; pixel +=2) {
1894                         scratch_get(usbvision, &y[0], 2);
1895                         scratch_get_extra(usbvision, &u, &u_ptr, 1);
1896                         scratch_get_extra(usbvision, &v, &v_ptr, 1);
1897
1898                         //I don't use the YUV_TO_RGB macro for better performance
1899                         v_ = v - 128;
1900                         u_ = u - 128;
1901                         vb =              132252 * v_;
1902                         uvg= -53281 * u_ - 25625 * v_;
1903                         ur = 104595 * u_;
1904
1905                         if((overlay) && (clipped_pixel(clipmask_even_index))) {
1906                                 f_even += bytes_per_pixel;
1907                         }
1908                         else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
1909                                 *f_even++ = y[0];
1910                                 *f_even++ = v;
1911                         }
1912                         else {
1913                                 y_ = 76284 * (y[0] - 16);
1914
1915                                 b_ = (y_ + vb) >> 16;
1916                                 g_ = (y_ + uvg)>> 16;
1917                                 r_ = (y_ + ur) >> 16;
1918
1919                                 switch (frame->v4l2_format.format) {
1920                                         case V4L2_PIX_FMT_RGB565:
1921                                                 g = LIMIT_RGB(g_);
1922                                                 *f_even++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 3));
1923                                                 *f_even++ = (0x07 & (          g   >> 5)) | (0xF8 & LIMIT_RGB(r_));
1924                                                 break;
1925                                         case V4L2_PIX_FMT_RGB24:
1926                                                 *f_even++ = LIMIT_RGB(b_);
1927                                                 *f_even++ = LIMIT_RGB(g_);
1928                                                 *f_even++ = LIMIT_RGB(r_);
1929                                                 break;
1930                                         case V4L2_PIX_FMT_RGB32:
1931                                                 *f_even++ = LIMIT_RGB(b_);
1932                                                 *f_even++ = LIMIT_RGB(g_);
1933                                                 *f_even++ = LIMIT_RGB(r_);
1934                                                 f_even++;
1935                                                 break;
1936                                         case V4L2_PIX_FMT_RGB555:
1937                                                 g = LIMIT_RGB(g_);
1938                                                 *f_even++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 2));
1939                                                 *f_even++ = (0x03 & (          g   >> 6)) |
1940                                                             (0x7C & (LIMIT_RGB(r_) >> 1));
1941                                                 break;
1942                                 }
1943                         }
1944                         clipmask_even_index += clipmask_add;
1945                         f_even += stretch_bytes;
1946
1947                         if((overlay) && (clipped_pixel(clipmask_even_index))) {
1948                                 f_even += bytes_per_pixel;
1949                         }
1950                         else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
1951                                 *f_even++ = y[1];
1952                                 *f_even++ = u;
1953                         }
1954                         else {
1955                                 y_ = 76284 * (y[1] - 16);
1956
1957                                 b_ = (y_ + vb) >> 16;
1958                                 g_ = (y_ + uvg)>> 16;
1959                                 r_ = (y_ + ur) >> 16;
1960
1961                                 switch (frame->v4l2_format.format) {
1962                                         case V4L2_PIX_FMT_RGB565:
1963                                                 g = LIMIT_RGB(g_);
1964                                                 *f_even++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 3));
1965                                                 *f_even++ = (0x07 & (          g   >> 5)) | (0xF8 & LIMIT_RGB(r_));
1966                                                 break;
1967                                         case V4L2_PIX_FMT_RGB24:
1968                                                 *f_even++ = LIMIT_RGB(b_);
1969                                                 *f_even++ = LIMIT_RGB(g_);
1970                                                 *f_even++ = LIMIT_RGB(r_);
1971                                                 break;
1972                                         case V4L2_PIX_FMT_RGB32:
1973                                                 *f_even++ = LIMIT_RGB(b_);
1974                                                 *f_even++ = LIMIT_RGB(g_);
1975                                                 *f_even++ = LIMIT_RGB(r_);
1976                                                 f_even++;
1977                                                 break;
1978                                         case V4L2_PIX_FMT_RGB555:
1979                                                 g = LIMIT_RGB(g_);
1980                                                 *f_even++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 2));
1981                                                 *f_even++ = (0x03 & (          g   >> 6)) |
1982                                                             (0x7C & (LIMIT_RGB(r_) >> 1));
1983                                                 break;
1984                                 }
1985                         }
1986                         clipmask_even_index += clipmask_add;
1987                         f_even += stretch_bytes;
1988
1989                         scratch_get_extra(usbvision, &y[0], &y_ptr, 2);
1990
1991                         if ((overlay) && (clipped_pixel(clipmask_odd_index))) {
1992                                 f_odd += bytes_per_pixel;
1993                         }
1994                         else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
1995                                 *f_odd++ = y[0];
1996                                 *f_odd++ = v;
1997                         }
1998                         else {
1999                                 y_ = 76284 * (y[0] - 16);
2000
2001                                 b_ = (y_ + vb) >> 16;
2002                                 g_ = (y_ + uvg)>> 16;
2003                                 r_ = (y_ + ur) >> 16;
2004
2005                                 switch (frame->v4l2_format.format) {
2006                                         case V4L2_PIX_FMT_RGB565:
2007                                                 g = LIMIT_RGB(g_);
2008                                                 *f_odd++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 3));
2009                                                 *f_odd++ = (0x07 & (          g   >> 5)) | (0xF8 & LIMIT_RGB(r_));
2010                                                 break;
2011                                         case V4L2_PIX_FMT_RGB24:
2012                                                 *f_odd++ = LIMIT_RGB(b_);
2013                                                 *f_odd++ = LIMIT_RGB(g_);
2014                                                 *f_odd++ = LIMIT_RGB(r_);
2015                                                 break;
2016                                         case V4L2_PIX_FMT_RGB32:
2017                                                 *f_odd++ = LIMIT_RGB(b_);
2018                                                 *f_odd++ = LIMIT_RGB(g_);
2019                                                 *f_odd++ = LIMIT_RGB(r_);
2020                                                 f_odd++;
2021                                                 break;
2022                                         case V4L2_PIX_FMT_RGB555:
2023                                                 g = LIMIT_RGB(g_);
2024                                                 *f_odd++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 2));
2025                                                 *f_odd++ = (0x03 & (          g   >> 6)) |
2026                                                            (0x7C & (LIMIT_RGB(r_) >> 1));
2027                                                 break;
2028                                 }
2029                         }
2030                         clipmask_odd_index += clipmask_add;
2031                         f_odd += stretch_bytes;
2032
2033                         if((overlay) && (clipped_pixel(clipmask_odd_index))) {
2034                                 f_odd += bytes_per_pixel;
2035                         }
2036                         else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
2037                                 *f_odd++ = y[1];
2038                                 *f_odd++ = u;
2039                         }
2040                         else {
2041                                 y_ = 76284 * (y[1] - 16);
2042
2043                                 b_ = (y_ + vb) >> 16;
2044                                 g_ = (y_ + uvg)>> 16;
2045                                 r_ = (y_ + ur) >> 16;
2046
2047                                 switch (frame->v4l2_format.format) {
2048                                         case V4L2_PIX_FMT_RGB565:
2049                                                 g = LIMIT_RGB(g_);
2050                                                 *f_odd++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 3));
2051                                                 *f_odd++ = (0x07 & (          g   >> 5)) | (0xF8 & LIMIT_RGB(r_));
2052                                                 break;
2053                                         case V4L2_PIX_FMT_RGB24:
2054                                                 *f_odd++ = LIMIT_RGB(b_);
2055                                                 *f_odd++ = LIMIT_RGB(g_);
2056                                                 *f_odd++ = LIMIT_RGB(r_);
2057                                                 break;
2058                                         case V4L2_PIX_FMT_RGB32:
2059                                                 *f_odd++ = LIMIT_RGB(b_);
2060                                                 *f_odd++ = LIMIT_RGB(g_);
2061                                                 *f_odd++ = LIMIT_RGB(r_);
2062                                                 f_odd++;
2063                                                 break;
2064                                         case V4L2_PIX_FMT_RGB555:
2065                                                 g = LIMIT_RGB(g_);
2066                                                 *f_odd++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 2));
2067                                                 *f_odd++ = (0x03 & (          g   >> 6)) |
2068                                                            (0x7C & (LIMIT_RGB(r_) >> 1));
2069                                                 break;
2070                                 }
2071                         }
2072                         clipmask_odd_index += clipmask_add;
2073                         f_odd += stretch_bytes;
2074                 }
2075
2076                 scratch_rm_old(usbvision,y_step[block % y_step_size] * sub_block_size);
2077                 scratch_inc_extra_ptr(&y_ptr, y_step[(block + 2 * block_split) % y_step_size]
2078                                 * sub_block_size);
2079                 scratch_inc_extra_ptr(&u_ptr, uv_step[block % uv_step_size]
2080                                 * sub_block_size);
2081                 scratch_inc_extra_ptr(&v_ptr, uv_step[(block + 2 * block_split) % uv_step_size]
2082                                 * sub_block_size);
2083         }
2084
2085         scratch_rm_old(usbvision, pixel_per_line * 3 / 2
2086                         + block_split * sub_block_size);
2087
2088         frame->curline += 2 * usbvision->stretch_height;
2089         *pcopylen += frame->v4l2_linesize * 2 * usbvision->stretch_height;
2090
2091         if (frame->curline >= frame->frmheight)
2092                 return ParseState_NextFrame;
2093         else
2094                 return ParseState_Continue;
2095 }
2096
2097 /*
2098  * usbvision_parse_data()
2099  *
2100  * Generic routine to parse the scratch buffer. It employs either
2101  * usbvision_find_header() or usbvision_parse_lines() to do most
2102  * of work.
2103  *
2104  */
2105 static void usbvision_parse_data(struct usb_usbvision *usbvision)
2106 {
2107         struct usbvision_frame *frame;
2108         enum ParseState newstate;
2109         long copylen = 0;
2110         unsigned long lock_flags;
2111
2112         if (usbvision->overlay) {
2113                 frame = &usbvision->overlay_frame;
2114         }
2115         else {
2116                 frame = usbvision->curFrame;
2117         }
2118
2119         PDEBUG(DBG_PARSE, "parsing len=%d\n", scratch_len(usbvision));
2120
2121         while (1) {
2122
2123                 newstate = ParseState_Out;
2124                 if (scratch_len(usbvision)) {
2125                         if (frame->scanstate == ScanState_Scanning) {
2126                                 newstate = usbvision_find_header(usbvision);
2127                         }
2128                         else if (frame->scanstate == ScanState_Lines) {
2129                                 if (usbvision->isocMode == ISOC_MODE_YUV420) {
2130                                         newstate = usbvision_parse_lines_420(usbvision, &copylen);
2131                                 }
2132                                 else if (usbvision->isocMode == ISOC_MODE_YUV422) {
2133                                         newstate = usbvision_parse_lines_422(usbvision, &copylen);
2134                                 }
2135                                 else if (usbvision->isocMode == ISOC_MODE_COMPRESS) {
2136                                         newstate = usbvision_parse_compress(usbvision, &copylen);
2137                                 }
2138
2139                         }
2140                 }
2141                 if (newstate == ParseState_Continue) {
2142                         continue;
2143                 }
2144                 else if ((newstate == ParseState_NextFrame) || (newstate == ParseState_Out)) {
2145                         break;
2146                 }
2147                 else {
2148                         return; /* ParseState_EndParse */
2149                 }
2150         }
2151
2152         if (newstate == ParseState_NextFrame) {
2153                 frame->grabstate = FrameState_Done;
2154                 do_gettimeofday(&(frame->timestamp));
2155                 frame->sequence = usbvision->frame_num;
2156                 if (usbvision->overlay) {
2157                         frame->grabstate = FrameState_Grabbing;
2158                         frame->scanstate = ScanState_Scanning;
2159                         frame->scanlength = 0;
2160                         copylen = 0;
2161                 }
2162                 else {
2163                         spin_lock_irqsave(&usbvision->queue_lock, lock_flags);
2164                         list_move_tail(&(frame->frame), &usbvision->outqueue);
2165                         usbvision->curFrame = NULL;
2166                         spin_unlock_irqrestore(&usbvision->queue_lock, lock_flags);
2167                 }
2168                 usbvision->frame_num++;
2169
2170                 /* Optionally display statistics on the screen */
2171                 if (flags & FLAGS_OSD_STATS)
2172                         usbvision_osd_stats(usbvision, frame);
2173
2174                 /* This will cause the process to request another frame. */
2175                 if (waitqueue_active(&usbvision->wait_frame)) {
2176                         PDEBUG(DBG_PARSE, "Wake up !");
2177                         wake_up_interruptible(&usbvision->wait_frame);
2178                 }
2179         }
2180         else
2181                 frame->grabstate = FrameState_Grabbing;
2182
2183
2184         /* Update the frame's uncompressed length. */
2185         frame->scanlength += copylen;
2186 }
2187
2188
2189 /*
2190  * Make all of the blocks of data contiguous
2191  */
2192 static int usbvision_compress_isochronous(struct usb_usbvision *usbvision,
2193                                           struct urb *urb)
2194 {
2195         unsigned char *packet_data;
2196         int i, totlen = 0;
2197
2198         for (i = 0; i < urb->number_of_packets; i++) {
2199                 int packet_len = urb->iso_frame_desc[i].actual_length;
2200                 int packet_stat = urb->iso_frame_desc[i].status;
2201
2202                 packet_data = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
2203
2204                 /* Detect and ignore errored packets */
2205                 if (packet_stat) {      // packet_stat != 0 ?????????????
2206                         PDEBUG(DBG_ISOC, "data error: [%d] len=%d, status=%X", i, packet_len, packet_stat);
2207                         usbvision->isocErrCount++;
2208                         continue;
2209                 }
2210
2211                 /* Detect and ignore empty packets */
2212                 if (packet_len < 0) {
2213                         PDEBUG(DBG_ISOC, "error packet [%d]", i);
2214                         usbvision->isocSkipCount++;
2215                         continue;
2216                 }
2217                 else if (packet_len == 0) {     /* Frame end ????? */
2218                         PDEBUG(DBG_ISOC, "null packet [%d]", i);
2219                         usbvision->isocstate=IsocState_NoFrame;
2220                         usbvision->isocSkipCount++;
2221                         continue;
2222                 }
2223                 else if (packet_len > usbvision->isocPacketSize) {
2224                         PDEBUG(DBG_ISOC, "packet[%d] > isocPacketSize", i);
2225                         usbvision->isocSkipCount++;
2226                         continue;
2227                 }
2228
2229                 PDEBUG(DBG_ISOC, "packet ok [%d] len=%d", i, packet_len);
2230
2231                 if (usbvision->isocstate==IsocState_NoFrame) { //new frame begins
2232                         usbvision->isocstate=IsocState_InFrame;
2233                         scratch_mark_header(usbvision);
2234                         usbvision_measure_bandwidth(usbvision);
2235                         PDEBUG(DBG_ISOC, "packet with header");
2236                 }
2237
2238                 /*
2239                  * If usbvision continues to feed us with data but there is no
2240                  * consumption (if, for example, V4L client fell asleep) we
2241                  * may overflow the buffer. We have to move old data over to
2242                  * free room for new data. This is bad for old data. If we
2243                  * just drop new data then it's bad for new data... choose
2244                  * your favorite evil here.
2245                  */
2246                 if (scratch_free(usbvision) < packet_len) {
2247
2248                         usbvision->scratch_ovf_count++;
2249                         PDEBUG(DBG_ISOC, "scratch buf overflow! scr_len: %d, n: %d",
2250                                scratch_len(usbvision), packet_len);
2251                         scratch_rm_old(usbvision, packet_len - scratch_free(usbvision));
2252                 }
2253
2254                 /* Now we know that there is enough room in scratch buffer */
2255                 scratch_put(usbvision, packet_data, packet_len);
2256                 totlen += packet_len;
2257                 usbvision->isocDataCount += packet_len;
2258                 usbvision->isocPacketCount++;
2259         }
2260 #if ENABLE_HEXDUMP
2261         if (totlen > 0) {
2262                 static int foo = 0;
2263                 if (foo < 1) {
2264                         printk(KERN_DEBUG "+%d.\n", usbvision->scratchlen);
2265                         usbvision_hexdump(data0, (totlen > 64) ? 64 : totlen);
2266                         ++foo;
2267                 }
2268         }
2269 #endif
2270  return totlen;
2271 }
2272
2273 static void usbvision_isocIrq(struct urb *urb, struct pt_regs *regs)
2274 {
2275         int errCode = 0;
2276         int len;
2277         struct usb_usbvision *usbvision = urb->context;
2278         int i;
2279         unsigned long startTime = jiffies;
2280         struct usbvision_frame **f;
2281
2282         /* We don't want to do anything if we are about to be removed! */
2283         if (!USBVISION_IS_OPERATIONAL(usbvision))
2284                 return;
2285
2286         f = &usbvision->curFrame;
2287
2288         /* Manage streaming interruption */
2289         if (usbvision->streaming == Stream_Interrupt) {
2290                 usbvision->streaming = Stream_Off;
2291                 if ((*f)) {
2292                         (*f)->grabstate = FrameState_Ready;
2293                         (*f)->scanstate = ScanState_Scanning;
2294                 }
2295                 PDEBUG(DBG_IRQ, "stream interrupted");
2296                 wake_up_interruptible(&usbvision->wait_stream);
2297         }
2298
2299         /* Copy the data received into our scratch buffer */
2300         len = usbvision_compress_isochronous(usbvision, urb);
2301
2302         usbvision->isocUrbCount++;
2303         usbvision->urb_length = len;
2304
2305         if (usbvision->streaming == Stream_On) {
2306
2307                 /* If we collected enough data let's parse! */
2308                 if (scratch_len(usbvision) > USBVISION_HEADER_LENGTH) { /* 12 == header_length */
2309                         /*If we don't have a frame we're current working on, complain */
2310                         if((!list_empty(&(usbvision->inqueue))) || (usbvision->overlay)) {
2311                                 if (!(*f)) {
2312                                         (*f) = list_entry(usbvision->inqueue.next,struct usbvision_frame, frame);
2313                                 }
2314                                 usbvision_parse_data(usbvision);
2315                         }
2316                         else {
2317                                 PDEBUG(DBG_IRQ, "received data, but no one needs it");
2318                                 scratch_reset(usbvision);
2319                         }
2320                 }
2321         }
2322
2323         usbvision->timeInIrq += jiffies - startTime;
2324
2325         for (i = 0; i < USBVISION_URB_FRAMES; i++) {
2326                 urb->iso_frame_desc[i].status = 0;
2327                 urb->iso_frame_desc[i].actual_length = 0;
2328         }
2329
2330         urb->status = 0;
2331         urb->dev = usbvision->dev;
2332         errCode = usb_submit_urb (urb, GFP_ATOMIC);
2333
2334         /* Disable this warning.  By design of the driver. */
2335         //      if(errCode) {
2336         //              err("%s: usb_submit_urb failed: error %d", __FUNCTION__, errCode);
2337         //      }
2338
2339         return;
2340 }
2341
2342 /*************************************/
2343 /* Low level usbvision access functions */
2344 /*************************************/
2345
2346 /*
2347  * usbvision_read_reg()
2348  *
2349  * return  < 0 -> Error
2350  *        >= 0 -> Data
2351  */
2352
2353 static int usbvision_read_reg(struct usb_usbvision *usbvision, unsigned char reg)
2354 {
2355         int errCode = 0;
2356         unsigned char buffer[1];
2357
2358         if (!USBVISION_IS_OPERATIONAL(usbvision))
2359                 return -1;
2360
2361         errCode = usb_control_msg(usbvision->dev, usb_rcvctrlpipe(usbvision->dev, 1),
2362                                 USBVISION_OP_CODE,
2363                                 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
2364                                 0, (__u16) reg, buffer, 1, HZ);
2365
2366         if (errCode < 0) {
2367                 err("%s: failed: error %d", __FUNCTION__, errCode);
2368                 return errCode;
2369         }
2370         return buffer[0];
2371 }
2372
2373 /*
2374  * usbvision_write_reg()
2375  *
2376  * return 1 -> Reg written
2377  *        0 -> usbvision is not yet ready
2378  *       -1 -> Something went wrong
2379  */
2380
2381 static int usbvision_write_reg(struct usb_usbvision *usbvision, unsigned char reg,
2382                             unsigned char value)
2383 {
2384         int errCode = 0;
2385
2386         if (!USBVISION_IS_OPERATIONAL(usbvision))
2387                 return 0;
2388
2389         errCode = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
2390                                 USBVISION_OP_CODE,
2391                                 USB_DIR_OUT | USB_TYPE_VENDOR |
2392                                 USB_RECIP_ENDPOINT, 0, (__u16) reg, &value, 1, HZ);
2393
2394         if (errCode < 0) {
2395                 err("%s: failed: error %d", __FUNCTION__, errCode);
2396         }
2397         return errCode;
2398 }
2399
2400
2401 static void usbvision_ctrlUrb_complete(struct urb *urb, struct pt_regs *regs)
2402 {
2403         struct usb_usbvision *usbvision = (struct usb_usbvision *)urb->context;
2404
2405         PDEBUG(DBG_IRQ, "");
2406         usbvision->ctrlUrbBusy = 0;
2407         if (waitqueue_active(&usbvision->ctrlUrb_wq)) {
2408                 wake_up_interruptible(&usbvision->ctrlUrb_wq);
2409         }
2410 }
2411
2412
2413 static int usbvision_write_reg_irq(struct usb_usbvision *usbvision,int address,
2414                                                                         unsigned char *data, int len)
2415 {
2416         int errCode = 0;
2417
2418         PDEBUG(DBG_IRQ, "");
2419         if (len > 8) {
2420                 return -EFAULT;
2421         }
2422 //      down(&usbvision->ctrlUrbLock);
2423         if (usbvision->ctrlUrbBusy) {
2424 //              up(&usbvision->ctrlUrbLock);
2425                 return -EBUSY;
2426         }
2427         usbvision->ctrlUrbBusy = 1;
2428 //      up(&usbvision->ctrlUrbLock);
2429
2430         usbvision->ctrlUrbSetup.bRequestType = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT;
2431         usbvision->ctrlUrbSetup.bRequest     = USBVISION_OP_CODE;
2432         usbvision->ctrlUrbSetup.wValue       = 0;
2433         usbvision->ctrlUrbSetup.wIndex       = cpu_to_le16(address);
2434         usbvision->ctrlUrbSetup.wLength      = cpu_to_le16(len);
2435         usb_fill_control_urb (usbvision->ctrlUrb, usbvision->dev,
2436                                                         usb_sndctrlpipe(usbvision->dev, 1),
2437                                                         (unsigned char *)&usbvision->ctrlUrbSetup,
2438                                                         (void *)usbvision->ctrlUrbBuffer, len,
2439                                                         usbvision_ctrlUrb_complete,
2440                                                         (void *)usbvision);
2441
2442         memcpy(usbvision->ctrlUrbBuffer, data, len);
2443
2444         errCode = usb_submit_urb(usbvision->ctrlUrb, GFP_ATOMIC);
2445         if (errCode < 0) {
2446                 // error in usb_submit_urb()
2447                 usbvision->ctrlUrbBusy = 0;
2448         }
2449         PDEBUG(DBG_IRQ, "submit %d byte: error %d", len, errCode);
2450         return errCode;
2451 }
2452
2453
2454
2455
2456 static int usbvision_init_compression(struct usb_usbvision *usbvision)
2457 {
2458         int errCode = 0;
2459
2460         usbvision->lastIsocFrameNum = -1;
2461         usbvision->isocDataCount = 0;
2462         usbvision->isocPacketCount = 0;
2463         usbvision->isocSkipCount = 0;
2464         usbvision->comprLevel = 50;
2465         usbvision->lastComprLevel = -1;
2466         usbvision->isocUrbCount = 0;
2467         usbvision->requestIntra = 1;
2468         usbvision->isocMeasureBandwidthCount = 0;
2469
2470         return errCode;
2471 }
2472
2473 /* this function measures the used bandwidth since last call
2474  * return:    0 : no error
2475  * sets usedBandwidth to 1-100 : 1-100% of full bandwidth resp. to isocPacketSize
2476  */
2477 static int usbvision_measure_bandwidth (struct usb_usbvision *usbvision)
2478 {
2479         int errCode = 0;
2480
2481         if (usbvision->isocMeasureBandwidthCount < 2) { // this gives an average bandwidth of 3 frames
2482                 usbvision->isocMeasureBandwidthCount++;
2483                 return errCode;
2484         }
2485         if ((usbvision->isocPacketSize > 0) && (usbvision->isocPacketCount > 0)) {
2486                 usbvision->usedBandwidth = usbvision->isocDataCount /
2487                                         (usbvision->isocPacketCount + usbvision->isocSkipCount) *
2488                                         100 / usbvision->isocPacketSize;
2489         }
2490         usbvision->isocMeasureBandwidthCount = 0;
2491         usbvision->isocDataCount = 0;
2492         usbvision->isocPacketCount = 0;
2493         usbvision->isocSkipCount = 0;
2494         return errCode;
2495 }
2496
2497 static int usbvision_adjust_compression (struct usb_usbvision *usbvision)
2498 {
2499         int errCode = 0;
2500         unsigned char buffer[6];
2501
2502         PDEBUG(DBG_IRQ, "");
2503         if ((adjustCompression) && (usbvision->usedBandwidth > 0)) {
2504                 usbvision->comprLevel += (usbvision->usedBandwidth - 90) / 2;
2505                 RESTRICT_TO_RANGE(usbvision->comprLevel, 0, 100);
2506                 if (usbvision->comprLevel != usbvision->lastComprLevel) {
2507                         int distorsion;
2508                         if (usbvision->bridgeType == BRIDGE_NT1004 || usbvision->bridgeType == BRIDGE_NT1005) {
2509                                 buffer[0] = (unsigned char)(4 + 16 * usbvision->comprLevel / 100);      // PCM Threshold 1
2510                                 buffer[1] = (unsigned char)(4 + 8 * usbvision->comprLevel / 100);       // PCM Threshold 2
2511                                 distorsion = 7 + 248 * usbvision->comprLevel / 100;
2512                                 buffer[2] = (unsigned char)(distorsion & 0xFF);                         // Average distorsion Threshold (inter)
2513                                 buffer[3] = (unsigned char)(distorsion & 0xFF);                         // Average distorsion Threshold (intra)
2514                                 distorsion = 1 + 42 * usbvision->comprLevel / 100;
2515                                 buffer[4] = (unsigned char)(distorsion & 0xFF);                         // Maximum distorsion Threshold (inter)
2516                                 buffer[5] = (unsigned char)(distorsion & 0xFF);                         // Maximum distorsion Threshold (intra)
2517                         }
2518                         else { //BRIDGE_NT1003
2519                                 buffer[0] = (unsigned char)(4 + 16 * usbvision->comprLevel / 100);      // PCM threshold 1
2520                                 buffer[1] = (unsigned char)(4 + 8 * usbvision->comprLevel / 100);       // PCM threshold 2
2521                                 distorsion = 2 + 253 * usbvision->comprLevel / 100;
2522                                 buffer[2] = (unsigned char)(distorsion & 0xFF);                         // distorsion threshold bit0-7
2523                                 buffer[3] = 0;  //(unsigned char)((distorsion >> 8) & 0x0F);            // distorsion threshold bit 8-11
2524                                 distorsion = 0 + 43 * usbvision->comprLevel / 100;
2525                                 buffer[4] = (unsigned char)(distorsion & 0xFF);                         // maximum distorsion bit0-7
2526                                 buffer[5] = 0; //(unsigned char)((distorsion >> 8) & 0x01);             // maximum distorsion bit 8
2527                         }
2528                         errCode = usbvision_write_reg_irq(usbvision, USBVISION_PCM_THR1, buffer, 6);
2529                         if (errCode == 0){
2530                                 PDEBUG(DBG_IRQ, "new compr params %#02x %#02x %#02x %#02x %#02x %#02x", buffer[0],
2531                                                                 buffer[1], buffer[2], buffer[3], buffer[4], buffer[5]);
2532                                 usbvision->lastComprLevel = usbvision->comprLevel;
2533                         }
2534                 }
2535         }
2536         return errCode;
2537 }
2538
2539 static int usbvision_request_intra (struct usb_usbvision *usbvision)
2540 {
2541         int errCode = 0;
2542         unsigned char buffer[1];
2543
2544         PDEBUG(DBG_IRQ, "");
2545         usbvision->requestIntra = 1;
2546         buffer[0] = 1;
2547         usbvision_write_reg_irq(usbvision, USBVISION_FORCE_INTRA, buffer, 1);
2548         return errCode;
2549 }
2550
2551 static int usbvision_unrequest_intra (struct usb_usbvision *usbvision)
2552 {
2553         int errCode = 0;
2554         unsigned char buffer[1];
2555
2556         PDEBUG(DBG_IRQ, "");
2557         usbvision->requestIntra = 0;
2558         buffer[0] = 0;
2559         usbvision_write_reg_irq(usbvision, USBVISION_FORCE_INTRA, buffer, 1);
2560         return errCode;
2561 }
2562
2563 /* ----------------------------------------------------------------------- */
2564 /* I2C functions                                                           */
2565 /* ----------------------------------------------------------------------- */
2566
2567 static void call_i2c_clients(struct usb_usbvision *usbvision, unsigned int cmd,
2568                              void *arg)
2569 {
2570
2571         int i;
2572
2573         for (i = 0; i < USBVISION_I2C_CLIENTS_MAX; i++) {
2574                 if (NULL == usbvision->i2c_clients[i])
2575                         continue;
2576                 if (NULL == usbvision->i2c_clients[i]->driver->command)
2577                         continue;
2578                 usbvision->i2c_clients[i]->driver->command(usbvision->i2c_clients[i], cmd, arg);
2579         }
2580 }
2581
2582 static int attach_inform(struct i2c_client *client)
2583 {
2584         struct usb_usbvision *usbvision;
2585         struct tuner_setup tun_addr;
2586         int i;
2587
2588         #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
2589                 usbvision = (struct usb_usbvision *)client->adapter->data;
2590         #else
2591                 usbvision = (struct usb_usbvision *)i2c_get_adapdata(client->adapter);
2592         #endif
2593
2594         for (i = 0; i < USBVISION_I2C_CLIENTS_MAX; i++) {
2595                 if (usbvision->i2c_clients[i] == NULL ||
2596                     usbvision->i2c_clients[i]->driver->id ==
2597                     client->driver->id) {
2598                         usbvision->i2c_clients[i] = client;
2599                         break;
2600                 }
2601         }
2602         if ((usbvision->have_tuner) && (usbvision->tuner_type != -1)) {
2603                 tun_addr.mode_mask = T_ANALOG_TV;
2604                 tun_addr.type = usbvision->tuner_type;
2605                 tun_addr.addr = ADDR_UNSET;
2606                 client->driver->command(client,TUNER_SET_TYPE_ADDR, &tun_addr);
2607                 call_i2c_clients(usbvision, VIDIOC_INT_RESET, NULL);
2608                 call_i2c_clients(usbvision, VIDIOC_S_INPUT, &usbvision->ctl_input);
2609                 call_i2c_clients(usbvision, VIDIOC_STREAMON, NULL);
2610         }
2611         call_i2c_clients(usbvision, VIDIOC_S_STD, &usbvision->tvnorm->id);
2612
2613         PDEBUG(DBG_I2C, "usbvision[%d] attaches %s", usbvision->nr, client->name);
2614
2615         return 0;
2616 }
2617
2618 static int detach_inform(struct i2c_client *client)
2619 {
2620         struct usb_usbvision *usbvision;
2621         int i;
2622
2623         #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
2624                 usbvision = (struct usb_usbvision *)client->adapter->data;
2625         #else
2626                 usbvision = (struct usb_usbvision *)i2c_get_adapdata(client->adapter);
2627         #endif
2628
2629         PDEBUG(DBG_I2C, "usbvision[%d] detaches %s", usbvision->nr, client->name);
2630         for (i = 0; i < USBVISION_I2C_CLIENTS_MAX; i++) {
2631                 if (NULL != usbvision->i2c_clients[i] &&
2632                     usbvision->i2c_clients[i]->driver->id ==
2633                     client->driver->id) {
2634                         usbvision->i2c_clients[i] = NULL;
2635                         break;
2636                 }
2637         }
2638         return 0;
2639 }
2640
2641 static int
2642 usbvision_i2c_read_max4(struct usb_usbvision *usbvision, unsigned char addr,
2643                      char *buf, short len)
2644 {
2645         int rc, retries;
2646
2647         for (retries = 5;;) {
2648                 rc = usbvision_write_reg(usbvision, USBVISION_SER_ADRS, addr);
2649                 if (rc < 0)
2650                         return rc;
2651
2652                 /* Initiate byte read cycle                    */
2653                 /* USBVISION_SER_CONT <- d0-d2 n. of bytes to r/w */
2654                 /*                    d3 0=Wr 1=Rd             */
2655                 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
2656                                       (len & 0x07) | 0x18);
2657                 if (rc < 0)
2658                         return rc;
2659
2660                 /* Test for Busy and ACK */
2661                 do {
2662                         /* USBVISION_SER_CONT -> d4 == 0 busy */
2663                         rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
2664                 } while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */
2665                 if (rc < 0)
2666                         return rc;
2667
2668                 /* USBVISION_SER_CONT -> d5 == 1 Not ack */
2669                 if ((rc & 0x20) == 0)   /* Ack? */
2670                         break;
2671
2672                 /* I2C abort */
2673                 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);
2674                 if (rc < 0)
2675                         return rc;
2676
2677                 if (--retries < 0)
2678                         return -1;
2679         }
2680
2681         switch (len) {
2682         case 4:
2683                 buf[3] = usbvision_read_reg(usbvision, USBVISION_SER_DAT4);
2684         case 3:
2685                 buf[2] = usbvision_read_reg(usbvision, USBVISION_SER_DAT3);
2686         case 2:
2687                 buf[1] = usbvision_read_reg(usbvision, USBVISION_SER_DAT2);
2688         case 1:
2689                 buf[0] = usbvision_read_reg(usbvision, USBVISION_SER_DAT1);
2690                 break;
2691         default:
2692                 printk(KERN_ERR
2693                        "usbvision_i2c_read_max4: buffer length > 4\n");
2694         }
2695
2696         if (debug & DBG_I2C) {
2697                 int idx;
2698                 for (idx = 0; idx < len; idx++) {
2699                         PDEBUG(DBG_I2C, "read %x from address %x", (unsigned char)buf[idx], addr);
2700                 }
2701         }
2702         return len;
2703 }
2704
2705
2706 static int usbvision_i2c_write_max4(struct usb_usbvision *usbvision,
2707                                  unsigned char addr, const char *buf,
2708                                  short len)
2709 {
2710         int rc, retries;
2711         int i;
2712         unsigned char value[6];
2713         unsigned char ser_cont;
2714
2715         ser_cont = (len & 0x07) | 0x10;
2716
2717         value[0] = addr;
2718         value[1] = ser_cont;
2719         for (i = 0; i < len; i++)
2720                 value[i + 2] = buf[i];
2721
2722         for (retries = 5;;) {
2723                 rc = usb_control_msg(usbvision->dev,
2724                                      usb_sndctrlpipe(usbvision->dev, 1),
2725                                      USBVISION_OP_CODE,
2726                                      USB_DIR_OUT | USB_TYPE_VENDOR |
2727                                      USB_RECIP_ENDPOINT, 0,
2728                                      (__u16) USBVISION_SER_ADRS, value,
2729                                      len + 2, HZ);
2730
2731                 if (rc < 0)
2732                         return rc;
2733
2734                 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
2735                                       (len & 0x07) | 0x10);
2736                 if (rc < 0)
2737                         return rc;
2738
2739                 /* Test for Busy and ACK */
2740                 do {
2741                         rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
2742                 } while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */
2743                 if (rc < 0)
2744                         return rc;
2745
2746                 if ((rc & 0x20) == 0)   /* Ack? */
2747                         break;
2748
2749                 /* I2C abort */
2750                 usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);
2751
2752                 if (--retries < 0)
2753                         return -1;
2754
2755         }
2756
2757         if (debug & DBG_I2C) {
2758                 int idx;
2759                 for (idx = 0; idx < len; idx++) {
2760                         PDEBUG(DBG_I2C, "wrote %x at address %x", (unsigned char)buf[idx], addr);
2761                 }
2762         }
2763         return len;
2764 }
2765
2766 static int usbvision_i2c_write(void *data, unsigned char addr, char *buf,
2767                             short len)
2768 {
2769         char *bufPtr = buf;
2770         int retval;
2771         int wrcount = 0;
2772         int count;
2773         int maxLen = 4;
2774         struct usb_usbvision *usbvision = (struct usb_usbvision *) data;
2775
2776         while (len > 0) {
2777                 count = (len > maxLen) ? maxLen : len;
2778                 retval = usbvision_i2c_write_max4(usbvision, addr, bufPtr, count);
2779                 if (retval > 0) {
2780                         len -= count;
2781                         bufPtr += count;
2782                         wrcount += count;
2783                 } else
2784                         return (retval < 0) ? retval : -EFAULT;
2785         }
2786         return wrcount;
2787 }
2788
2789 static int usbvision_i2c_read(void *data, unsigned char addr, char *buf,
2790                            short len)
2791 {
2792         char temp[4];
2793         int retval, i;
2794         int rdcount = 0;
2795         int count;
2796         struct usb_usbvision *usbvision = (struct usb_usbvision *) data;
2797
2798         while (len > 0) {
2799                 count = (len > 3) ? 4 : len;
2800                 retval = usbvision_i2c_read_max4(usbvision, addr, temp, count);
2801                 if (retval > 0) {
2802                         for (i = 0; i < len; i++)
2803                                 buf[rdcount + i] = temp[i];
2804                         len -= count;
2805                         rdcount += count;
2806                 } else
2807                         return (retval < 0) ? retval : -EFAULT;
2808         }
2809         return rdcount;
2810 }
2811
2812 static struct i2c_algo_usb_data i2c_algo_template = {
2813         .data           = NULL,
2814         .inb            = usbvision_i2c_read,
2815         .outb           = usbvision_i2c_write,
2816         .udelay         = 10,
2817         .mdelay         = 10,
2818         .timeout        = 100,
2819 };
2820
2821 static struct i2c_adapter i2c_adap_template = {
2822         .owner             = THIS_MODULE,
2823         .name              = "usbvision",
2824         .id                = I2C_HW_B_BT848, /* FIXME */
2825         .algo              = NULL,
2826         .algo_data         = NULL,
2827         .client_register   = attach_inform,
2828         .client_unregister = detach_inform,
2829 #if defined (I2C_ADAP_CLASS_TV_ANALOG)
2830         .class             = I2C_ADAP_CLASS_TV_ANALOG,
2831 #elif defined (I2C_CLASS_TV_ANALOG)
2832         .class             = I2C_CLASS_TV_ANALOG,
2833 #endif
2834 };
2835
2836 static struct i2c_client i2c_client_template = {
2837         .name           = "usbvision internal",
2838         .flags          = 0,
2839         .addr           = 0,
2840         .adapter        = NULL,
2841         .driver         = NULL,
2842 };
2843
2844 static int usbvision_init_i2c(struct usb_usbvision *usbvision)
2845 {
2846         memcpy(&usbvision->i2c_adap, &i2c_adap_template,
2847                sizeof(struct i2c_adapter));
2848         memcpy(&usbvision->i2c_algo, &i2c_algo_template,
2849                sizeof(struct i2c_algo_usb_data));
2850         memcpy(&usbvision->i2c_client, &i2c_client_template,
2851                sizeof(struct i2c_client));
2852
2853         sprintf(usbvision->i2c_adap.name + strlen(usbvision->i2c_adap.name),
2854                 " #%d", usbvision->vdev->minor & 0x1f);
2855         PDEBUG(DBG_I2C, "Adaptername: %s", usbvision->i2c_adap.name);
2856
2857         i2c_set_adapdata(&usbvision->i2c_adap, usbvision);
2858         i2c_set_clientdata(&usbvision->i2c_client, usbvision);
2859         i2c_set_algo_usb_data(&usbvision->i2c_algo, usbvision);
2860
2861         usbvision->i2c_adap.algo_data = &usbvision->i2c_algo;
2862         usbvision->i2c_client.adapter = &usbvision->i2c_adap;
2863
2864         if (usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_IIC_LRNACK) < 0) {
2865                 printk(KERN_ERR "usbvision_init_i2c: can't wirte reg\n");
2866                 return -EBUSY;
2867         }
2868
2869 #ifdef CONFIG_KMOD
2870         /* Request the load of the i2c modules we need */
2871         if (autoload) {
2872                 switch (usbvision_device_data[usbvision->DevModel].Codec) {
2873                         case CODEC_SAA7113:
2874                                 request_module("saa7115");
2875                                 break;
2876                         case CODEC_SAA7111:
2877                                 request_module("saa7115");
2878                                 break;
2879                 }
2880                 if (usbvision_device_data[usbvision->DevModel].Tuner == 1) {
2881                         request_module("tuner");
2882                 }
2883         }
2884 #endif
2885
2886         usbvision->i2c_ok = usbvision_i2c_usb_add_bus(&usbvision->i2c_adap);
2887
2888         return usbvision->i2c_ok;
2889
2890 }
2891
2892
2893 /****************************/
2894 /* usbvision utility functions */
2895 /****************************/
2896
2897 static int usbvision_power_off(struct usb_usbvision *usbvision)
2898 {
2899         int errCode = 0;
2900
2901         PDEBUG(DBG_FUNC, "");
2902
2903         errCode = usbvision_write_reg(usbvision, USBVISION_PWR_REG, USBVISION_SSPND_EN);
2904         if (errCode == 1) {
2905                 usbvision->power = 0;
2906         }
2907         PDEBUG(DBG_FUNC, "%s: errCode %d", (errCode!=1)?"ERROR":"power is off", errCode);
2908         return errCode;
2909 }
2910
2911
2912 // to call usbvision_power_off from task queue
2913 static void call_usbvision_power_off(void *_usbvision)
2914 {
2915         struct usb_usbvision *usbvision = _usbvision;
2916
2917         PDEBUG(DBG_FUNC, "");
2918         down_interruptible(&usbvision->lock);
2919         if(usbvision->user == 0) {
2920                 usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
2921                 usbvision_power_off(usbvision);
2922                 usbvision->initialized = 0;
2923         }
2924         up(&usbvision->lock);
2925 }
2926
2927
2928 /*
2929  * usbvision_set_video_format()
2930  *
2931  */
2932 static int usbvision_set_video_format(struct usb_usbvision *usbvision, int format)
2933 {
2934         static const char proc[] = "usbvision_set_video_format";
2935         int rc;
2936         unsigned char value[2];
2937
2938         if (!USBVISION_IS_OPERATIONAL(usbvision))
2939                 return 0;
2940
2941         PDEBUG(DBG_FUNC, "isocMode %#02x", format);
2942
2943         if ((format != ISOC_MODE_YUV422)
2944             && (format != ISOC_MODE_YUV420)
2945             && (format != ISOC_MODE_COMPRESS)) {
2946                 printk(KERN_ERR "usbvision: unknown video format %02x, using default YUV420",
2947                        format);
2948                 format = ISOC_MODE_YUV420;
2949         }
2950         value[0] = 0x0A;  //TODO: See the effect of the filter
2951         value[1] = format;
2952         rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
2953                              USBVISION_OP_CODE,
2954                              USB_DIR_OUT | USB_TYPE_VENDOR |
2955                              USB_RECIP_ENDPOINT, 0,
2956                              (__u16) USBVISION_FILT_CONT, value, 2, HZ);
2957
2958         if (rc < 0) {
2959                 printk(KERN_ERR "%s: ERROR=%d. USBVISION stopped - "
2960                        "reconnect or reload driver.\n", proc, rc);
2961         }
2962         usbvision->isocMode = format;
2963         return rc;
2964 }
2965
2966 /*
2967  * usbvision_set_output()
2968  *
2969  */
2970
2971 static int usbvision_set_output(struct usb_usbvision *usbvision, int width,
2972                                   int height)
2973 {
2974         int errCode = 0;
2975         int UsbWidth, UsbHeight;
2976         unsigned int frameRate=0, frameDrop=0;
2977         unsigned char value[4];
2978
2979         if (!USBVISION_IS_OPERATIONAL(usbvision)) {
2980                 return 0;
2981         }
2982
2983         if (width > MAX_USB_WIDTH) {
2984                 UsbWidth = width / 2;
2985                 usbvision->stretch_width = 2;
2986         }
2987         else {
2988                 UsbWidth = width;
2989                 usbvision->stretch_width = 1;
2990         }
2991
2992         if (height > MAX_USB_HEIGHT) {
2993                 UsbHeight = height / 2;
2994                 usbvision->stretch_height = 2;
2995         }
2996         else {
2997                 UsbHeight = height;
2998                 usbvision->stretch_height = 1;
2999         }
3000
3001         RESTRICT_TO_RANGE(UsbWidth, MIN_FRAME_WIDTH, MAX_USB_WIDTH);
3002         UsbWidth &= ~(MIN_FRAME_WIDTH-1);
3003         RESTRICT_TO_RANGE(UsbHeight, MIN_FRAME_HEIGHT, MAX_USB_HEIGHT);
3004         UsbHeight &= ~(1);
3005
3006         PDEBUG(DBG_FUNC, "usb %dx%d; screen %dx%d; stretch %dx%d",
3007                                                 UsbWidth, UsbHeight, width, height,
3008                                                 usbvision->stretch_width, usbvision->stretch_height);
3009
3010         /* I'll not rewrite the same values */
3011         if ((UsbWidth != usbvision->curwidth) || (UsbHeight != usbvision->curheight)) {
3012                 value[0] = UsbWidth & 0xff;             //LSB
3013                 value[1] = (UsbWidth >> 8) & 0x03;      //MSB
3014                 value[2] = UsbHeight & 0xff;            //LSB
3015                 value[3] = (UsbHeight >> 8) & 0x03;     //MSB
3016
3017                 errCode = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
3018                              USBVISION_OP_CODE,
3019                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
3020                                  0, (__u16) USBVISION_LXSIZE_O, value, 4, HZ);
3021
3022                 if (errCode < 0) {
3023                         err("%s failed: error %d", __FUNCTION__, errCode);
3024                         return errCode;
3025                 }
3026                 usbvision->curwidth = usbvision->stretch_width * UsbWidth;
3027                 usbvision->curheight = usbvision->stretch_height * UsbHeight;
3028         }
3029
3030         if (usbvision->isocMode == ISOC_MODE_YUV422) {
3031                 frameRate = (usbvision->isocPacketSize * 1000) / (UsbWidth * UsbHeight * 2);
3032         }
3033         else if (usbvision->isocMode == ISOC_MODE_YUV420) {
3034                 frameRate = (usbvision->isocPacketSize * 1000) / ((UsbWidth * UsbHeight * 12) / 8);
3035         }
3036         else {
3037                 frameRate = FRAMERATE_MAX;
3038         }
3039
3040         if (usbvision->tvnorm->id & V4L2_STD_625_50) {
3041                 frameDrop = frameRate * 32 / 25 - 1;
3042         }
3043         else if (usbvision->tvnorm->id & V4L2_STD_525_60) {
3044                 frameDrop = frameRate * 32 / 30 - 1;
3045         }
3046
3047         RESTRICT_TO_RANGE(frameDrop, FRAMERATE_MIN, FRAMERATE_MAX);
3048
3049         PDEBUG(DBG_FUNC, "frameRate %d fps, frameDrop %d", frameRate, frameDrop);
3050
3051         frameDrop = FRAMERATE_MAX;      // We can allow the maximum here, because dropping is controlled
3052
3053         /* frameDrop = 7; => framePhase = 1, 5, 9, 13, 17, 21, 25, 0, 4, 8, ...
3054                 => frameSkip = 4;
3055                 => frameRate = (7 + 1) * 25 / 32 = 200 / 32 = 6.25;
3056
3057            frameDrop = 9; => framePhase = 1, 5, 8, 11, 14, 17, 21, 24, 27, 1, 4, 8, ...
3058             => frameSkip = 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 4, ...
3059                 => frameRate = (9 + 1) * 25 / 32 = 250 / 32 = 7.8125;
3060         */
3061         errCode = usbvision_write_reg(usbvision, USBVISION_FRM_RATE, frameDrop);
3062         return errCode;
3063 }
3064
3065
3066 /*
3067  * usbvision_empty_framequeues()
3068  * prepare queues for incoming and outgoing frames
3069  */
3070 static void usbvision_empty_framequeues(struct usb_usbvision *usbvision)
3071 {
3072         u32 i;
3073
3074         INIT_LIST_HEAD(&(usbvision->inqueue));
3075         INIT_LIST_HEAD(&(usbvision->outqueue));
3076
3077         for (i = 0; i < USBVISION_NUMFRAMES; i++) {
3078                 usbvision->frame[i].grabstate = FrameState_Unused;
3079                 usbvision->frame[i].bytes_read = 0;
3080         }
3081 }
3082
3083 /*
3084  * usbvision_stream_interrupt()
3085  * stops streaming
3086  */
3087 static int usbvision_stream_interrupt(struct usb_usbvision *usbvision)
3088 {
3089         int ret = 0;
3090
3091         /* stop reading from the device */
3092
3093         usbvision->streaming = Stream_Interrupt;
3094         ret = wait_event_timeout(usbvision->wait_stream,
3095                                  (usbvision->streaming == Stream_Off),
3096                                  msecs_to_jiffies(USBVISION_NUMSBUF*USBVISION_URB_FRAMES));
3097         return ret;
3098 }
3099
3100 /*
3101  * usbvision_set_compress_params()
3102  *
3103  */
3104
3105 static int usbvision_set_compress_params(struct usb_usbvision *usbvision)
3106 {
3107         static const char proc[] = "usbvision_set_compresion_params: ";
3108         int rc;
3109         unsigned char value[6];
3110
3111         value[0] = 0x0F;    // Intra-Compression cycle
3112         value[1] = 0x01;    // Reg.45 one line per strip
3113         value[2] = 0x00;    // Reg.46 Force intra mode on all new frames
3114         value[3] = 0x00;    // Reg.47 FORCE_UP <- 0 normal operation (not force)
3115         value[4] = 0xA2;    // Reg.48 BUF_THR I'm not sure if this does something in not compressed mode.
3116         value[5] = 0x00;    // Reg.49 DVI_YUV This has nothing to do with compression
3117
3118         //catched values for NT1004
3119         // value[0] = 0xFF; // Never apply intra mode automatically
3120         // value[1] = 0xF1; // Use full frame height for virtual strip width; One line per strip
3121         // value[2] = 0x01; // Force intra mode on all new frames
3122         // value[3] = 0x00; // Strip size 400 Bytes; do not force up
3123         // value[4] = 0xA2; //
3124         if (!USBVISION_IS_OPERATIONAL(usbvision))
3125                 return 0;
3126
3127         rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
3128                              USBVISION_OP_CODE,
3129                              USB_DIR_OUT | USB_TYPE_VENDOR |
3130                              USB_RECIP_ENDPOINT, 0,
3131                              (__u16) USBVISION_INTRA_CYC, value, 5, HZ);
3132
3133         if (rc < 0) {
3134                 printk(KERN_ERR "%sERROR=%d. USBVISION stopped - "
3135                        "reconnect or reload driver.\n", proc, rc);
3136                 return rc;
3137         }
3138
3139         if (usbvision->bridgeType == BRIDGE_NT1004) {
3140                 value[0] =  20; // PCM Threshold 1
3141                 value[1] =  12; // PCM Threshold 2
3142                 value[2] = 255; // Distorsion Threshold inter
3143                 value[3] = 255; // Distorsion Threshold intra
3144                 value[4] =  43; // Max Distorsion inter
3145                 value[5] =  43; // Max Distorsion intra
3146         }
3147         else {
3148                 value[0] =  20; // PCM Threshold 1
3149                 value[1] =  12; // PCM Threshold 2
3150                 value[2] = 255; // Distorsion Threshold d7-d0
3151                 value[3] =   0; // Distorsion Threshold d11-d8
3152                 value[4] =  43; // Max Distorsion d7-d0
3153                 value[5] =   0; // Max Distorsion d8
3154         }
3155
3156         if (!USBVISION_IS_OPERATIONAL(usbvision))
3157                 return 0;
3158
3159         rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
3160                              USBVISION_OP_CODE,
3161                              USB_DIR_OUT | USB_TYPE_VENDOR |
3162                              USB_RECIP_ENDPOINT, 0,
3163                              (__u16) USBVISION_PCM_THR1, value, 6, HZ);
3164
3165         if (rc < 0) {
3166                 printk(KERN_ERR "%sERROR=%d. USBVISION stopped - "
3167                        "reconnect or reload driver.\n", proc, rc);
3168                 return rc;
3169         }
3170
3171
3172         return rc;
3173 }
3174
3175
3176 /*
3177  * usbvision_set_input()
3178  *
3179  * Set the input (saa711x, ...) size x y and other misc input params
3180  * I've no idea if this parameters are right
3181  *
3182  */
3183 static int usbvision_set_input(struct usb_usbvision *usbvision)
3184 {
3185         static const char proc[] = "usbvision_set_input: ";
3186         int rc;
3187         unsigned char value[8];
3188         unsigned char dvi_yuv_value;
3189
3190         if (!USBVISION_IS_OPERATIONAL(usbvision))
3191                 return 0;
3192
3193         /* Set input format expected from decoder*/
3194         if (usbvision_device_data[usbvision->DevModel].Vin_Reg1 >= 0) {
3195                 value[0] = usbvision_device_data[usbvision->DevModel].Vin_Reg1 & 0xff;
3196         } else if(usbvision_device_data[usbvision->DevModel].Codec == CODEC_SAA7113) {
3197                 /* SAA7113 uses 8 bit output */
3198                 value[0] = USBVISION_8_422_SYNC;
3199         } else {
3200                 /* I'm sure only about d2-d0 [010] 16 bit 4:2:2 usin sync pulses
3201                  * as that is how saa7111 is configured */
3202                 value[0] = USBVISION_16_422_SYNC;
3203                 /* | USBVISION_VSNC_POL | USBVISION_VCLK_POL);*/
3204         }
3205
3206         rc = usbvision_write_reg(usbvision, USBVISION_VIN_REG1, value[0]);
3207         if (rc < 0) {
3208                 printk(KERN_ERR "%sERROR=%d. USBVISION stopped - "
3209                        "reconnect or reload driver.\n", proc, rc);
3210                 return rc;
3211         }
3212
3213
3214         if (usbvision->tvnorm->id & V4L2_STD_PAL) {
3215                 value[0] = 0xC0;
3216                 value[1] = 0x02;        //0x02C0 -> 704 Input video line length
3217                 value[2] = 0x20;
3218                 value[3] = 0x01;        //0x0120 -> 288 Input video n. of lines
3219                 value[4] = 0x60;
3220                 value[5] = 0x00;        //0x0060 -> 96 Input video h offset
3221                 value[6] = 0x16;
3222                 value[7] = 0x00;        //0x0016 -> 22 Input video v offset
3223         } else if (usbvision->tvnorm->id & V4L2_STD_SECAM) {
3224                 value[0] = 0xC0;
3225                 value[1] = 0x02;        //0x02C0 -> 704 Input video line length
3226                 value[2] = 0x20;
3227                 value[3] = 0x01;        //0x0120 -> 288 Input video n. of lines
3228                 value[4] = 0x01;
3229                 value[5] = 0x00;        //0x0001 -> 01 Input video h offset
3230                 value[6] = 0x01;
3231                 value[7] = 0x00;        //0x0001 -> 01 Input video v offset
3232         } else {        /* V4L2_STD_NTSC */
3233                 value[0] = 0xD0;
3234                 value[1] = 0x02;        //0x02D0 -> 720 Input video line length
3235                 value[2] = 0xF0;
3236                 value[3] = 0x00;        //0x00F0 -> 240 Input video number of lines
3237                 value[4] = 0x50;
3238                 value[5] = 0x00;        //0x0050 -> 80 Input video h offset
3239                 value[6] = 0x10;
3240                 value[7] = 0x00;        //0x0010 -> 16 Input video v offset
3241         }
3242
3243         if (usbvision_device_data[usbvision->DevModel].X_Offset >= 0) {
3244                 value[4]=usbvision_device_data[usbvision->DevModel].X_Offset & 0xff;
3245                 value[5]=(usbvision_device_data[usbvision->DevModel].X_Offset & 0x0300) >> 8;
3246         }
3247
3248         if (usbvision_device_data[usbvision->DevModel].Y_Offset >= 0) {
3249                 value[6]=usbvision_device_data[usbvision->DevModel].Y_Offset & 0xff;
3250                 value[7]=(usbvision_device_data[usbvision->DevModel].Y_Offset & 0x0300) >> 8;
3251         }
3252
3253         rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
3254                              USBVISION_OP_CODE, /* USBVISION specific code */
3255                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT, 0,
3256                              (__u16) USBVISION_LXSIZE_I, value, 8, HZ);
3257         if (rc < 0) {
3258                 printk(KERN_ERR "%sERROR=%d. USBVISION stopped - "
3259                        "reconnect or reload driver.\n", proc, rc);
3260                 return rc;
3261         }
3262
3263
3264         dvi_yuv_value = 0x00;   /* U comes after V, Ya comes after U/V, Yb comes after Yb */
3265
3266         if(usbvision_device_data[usbvision->DevModel].Dvi_yuv >= 0){
3267                 dvi_yuv_value = usbvision_device_data[usbvision->DevModel].Dvi_yuv & 0xff;
3268         }
3269         else if(usbvision_device_data[usbvision->DevModel].Codec == CODEC_SAA7113) {
3270         /* This changes as the fine sync control changes. Further investigation necessary */
3271                 dvi_yuv_value = 0x06;
3272         }
3273
3274         return (usbvision_write_reg(usbvision, USBVISION_DVI_YUV, dvi_yuv_value));
3275 }
3276
3277
3278 /*
3279  * usbvision_set_dram_settings()
3280  *
3281  * Set the buffer address needed by the usbvision dram to operate
3282  * This values has been taken with usbsnoop.
3283  *
3284  */
3285
3286 static int usbvision_set_dram_settings(struct usb_usbvision *usbvision)
3287 {
3288         int rc;
3289         unsigned char value[8];
3290
3291         if (usbvision->isocMode == ISOC_MODE_COMPRESS) {
3292                 value[0] = 0x42;
3293                 value[1] = 0x71;
3294                 value[2] = 0xff;
3295                 value[3] = 0x00;
3296                 value[4] = 0x98;
3297                 value[5] = 0xe0;
3298                 value[6] = 0x71;
3299                 value[7] = 0xff;
3300                 // UR:  0x0E200-0x3FFFF = 204288 Words (1 Word = 2 Byte)
3301                 // FDL: 0x00000-0x0E099 =  57498 Words
3302                 // VDW: 0x0E3FF-0x3FFFF
3303         }
3304         else {
3305                 value[0] = 0x42;
3306                 value[1] = 0x00;
3307                 value[2] = 0xff;
3308                 value[3] = 0x00;
3309                 value[4] = 0x00;
3310                 value[5] = 0x00;
3311                 value[6] = 0x00;
3312                 value[7] = 0xff;
3313         }
3314         /* These are the values of the address of the video buffer,
3315          * they have to be loaded into the USBVISION_DRM_PRM1-8
3316          *
3317          * Start address of video output buffer for read:       drm_prm1-2 -> 0x00000
3318          * End address of video output buffer for read:         drm_prm1-3 -> 0x1ffff
3319          * Start address of video frame delay buffer:           drm_prm1-4 -> 0x20000
3320          *    Only used in compressed mode
3321          * End address of video frame delay buffer:             drm_prm1-5-6 -> 0x3ffff
3322          *    Only used in compressed mode
3323          * Start address of video output buffer for write:      drm_prm1-7 -> 0x00000
3324          * End address of video output buffer for write:        drm_prm1-8 -> 0x1ffff
3325          */
3326
3327         if (!USBVISION_IS_OPERATIONAL(usbvision))
3328                 return 0;
3329
3330         rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
3331                              USBVISION_OP_CODE, /* USBVISION specific code */
3332                              USB_DIR_OUT | USB_TYPE_VENDOR |
3333                              USB_RECIP_ENDPOINT, 0,
3334                              (__u16) USBVISION_DRM_PRM1, value, 8, HZ);
3335
3336         if (rc < 0) {
3337                 err("%sERROR=%d", __FUNCTION__, rc);
3338                 return rc;
3339         }
3340
3341         /* Restart the video buffer logic */
3342         if ((rc = usbvision_write_reg(usbvision, USBVISION_DRM_CONT, USBVISION_RES_UR |
3343                                    USBVISION_RES_FDL | USBVISION_RES_VDW)) < 0)
3344                 return rc;
3345         rc = usbvision_write_reg(usbvision, USBVISION_DRM_CONT, 0x00);
3346
3347         return rc;
3348 }
3349
3350 /*
3351  * ()
3352  *
3353  * Power on the device, enables suspend-resume logic
3354  * &  reset the isoc End-Point
3355  *
3356  */
3357
3358 static int usbvision_power_on(struct usb_usbvision *usbvision)
3359 {
3360         int errCode = 0;
3361
3362         PDEBUG(DBG_FUNC, "");
3363
3364         usbvision_write_reg(usbvision, USBVISION_PWR_REG, USBVISION_SSPND_EN);
3365         usbvision_write_reg(usbvision, USBVISION_PWR_REG,
3366                          USBVISION_SSPND_EN | USBVISION_RES2);
3367         usbvision_write_reg(usbvision, USBVISION_PWR_REG,
3368                          USBVISION_SSPND_EN | USBVISION_PWR_VID);
3369         errCode = usbvision_write_reg(usbvision, USBVISION_PWR_REG,
3370                                                 USBVISION_SSPND_EN | USBVISION_PWR_VID | USBVISION_RES2);
3371         if (errCode == 1) {
3372                 usbvision->power = 1;
3373         }
3374         PDEBUG(DBG_FUNC, "%s: errCode %d", (errCode<0)?"ERROR":"power is on", errCode);
3375         return errCode;
3376 }
3377
3378
3379 static void usbvision_powerOffTimer(unsigned long data)
3380 {
3381         struct usb_usbvision *usbvision = (void *) data;
3382
3383         PDEBUG(DBG_FUNC, "");
3384         del_timer(&usbvision->powerOffTimer);
3385         INIT_WORK(&usbvision->powerOffWork, call_usbvision_power_off, usbvision);
3386         (void) schedule_work(&usbvision->powerOffWork);
3387
3388 }
3389
3390
3391 /*
3392  * usbvision_begin_streaming()
3393  * Sure you have to put bit 7 to 0, if not incoming frames are droped, but no
3394  * idea about the rest
3395  */
3396 static int usbvision_begin_streaming(struct usb_usbvision *usbvision)
3397 {
3398         int errCode = 0;
3399
3400         if (usbvision->isocMode == ISOC_MODE_COMPRESS) {
3401                 usbvision_init_compression(usbvision);
3402         }
3403         errCode = usbvision_write_reg(usbvision, USBVISION_VIN_REG2, USBVISION_NOHVALID |
3404                                                                                 usbvision->Vin_Reg2_Preset);
3405         return errCode;
3406 }
3407
3408 /*
3409  * usbvision_restart_isoc()
3410  * Not sure yet if touching here PWR_REG make loose the config
3411  */
3412
3413 static int usbvision_restart_isoc(struct usb_usbvision *usbvision)
3414 {
3415         int ret;
3416
3417         if (
3418             (ret =
3419              usbvision_write_reg(usbvision, USBVISION_PWR_REG,
3420                               USBVISION_SSPND_EN | USBVISION_PWR_VID)) < 0)
3421                 return ret;
3422         if (
3423             (ret =
3424              usbvision_write_reg(usbvision, USBVISION_PWR_REG,
3425                               USBVISION_SSPND_EN | USBVISION_PWR_VID |
3426                               USBVISION_RES2)) < 0)
3427                 return ret;
3428         if (
3429             (ret =
3430              usbvision_write_reg(usbvision, USBVISION_VIN_REG2,
3431                               USBVISION_KEEP_BLANK | USBVISION_NOHVALID |
3432                                   usbvision->Vin_Reg2_Preset)) < 0) return ret;
3433
3434         /* TODO: schedule timeout */
3435         while ((usbvision_read_reg(usbvision, USBVISION_STATUS_REG) && 0x01) != 1);
3436
3437         return 0;
3438 }
3439
3440 static int usbvision_audio_on(struct usb_usbvision *usbvision)
3441 {
3442         if (usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, usbvision->AudioChannel) < 0) {
3443                 printk(KERN_ERR "usbvision_audio_on: can't wirte reg\n");
3444                 return -1;
3445         }
3446         DEBUG(printk(KERN_DEBUG "usbvision_audio_on: channel %d\n", usbvision->AudioChannel));
3447         usbvision->AudioMute = 0;
3448         return 0;
3449 }
3450
3451 static int usbvision_audio_mute(struct usb_usbvision *usbvision)
3452 {
3453         if (usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, 0x03) < 0) {
3454                 printk(KERN_ERR "usbvision_audio_mute: can't wirte reg\n");
3455                 return -1;
3456         }
3457         DEBUG(printk(KERN_DEBUG "usbvision_audio_mute: audio mute\n"));
3458         usbvision->AudioMute = 1;
3459         return 0;
3460 }
3461
3462 static int usbvision_audio_off(struct usb_usbvision *usbvision)
3463 {
3464         if (usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, USBVISION_AUDIO_MUTE) < 0) {
3465                 printk(KERN_ERR "usbvision_audio_off: can't wirte reg\n");
3466                 return -1;
3467         }
3468         DEBUG(printk(KERN_DEBUG "usbvision_audio_off: audio off\n"));
3469         usbvision->AudioMute = 0;
3470         usbvision->AudioChannel = USBVISION_AUDIO_MUTE;
3471         return 0;
3472 }
3473
3474 static int usbvision_set_audio(struct usb_usbvision *usbvision, int AudioChannel)
3475 {
3476         if (!usbvision->AudioMute) {
3477                 if (usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, AudioChannel) < 0) {
3478                         printk(KERN_ERR "usbvision_set_audio: can't write iopin register for audio switching\n");
3479                         return -1;
3480                 }
3481         }
3482         DEBUG(printk(KERN_DEBUG "usbvision_set_audio: channel %d\n", AudioChannel));
3483         usbvision->AudioChannel = AudioChannel;
3484         return 0;
3485 }
3486
3487 static int usbvision_setup(struct usb_usbvision *usbvision)
3488 {
3489         usbvision_set_video_format(usbvision, isocMode);
3490         usbvision_set_dram_settings(usbvision);
3491         usbvision_set_compress_params(usbvision);
3492         usbvision_set_input(usbvision);
3493         usbvision_set_output(usbvision, MAX_USB_WIDTH, MAX_USB_HEIGHT);
3494         usbvision_restart_isoc(usbvision);
3495
3496         /* cosas del PCM */
3497         return USBVISION_IS_OPERATIONAL(usbvision);
3498 }
3499
3500
3501 /*
3502  * usbvision_init_isoc()
3503  *
3504  */
3505 static int usbvision_init_isoc(struct usb_usbvision *usbvision)
3506 {
3507         struct usb_device *dev = usbvision->dev;
3508         int bufIdx, errCode, regValue;
3509
3510         if (!USBVISION_IS_OPERATIONAL(usbvision))
3511                 return -EFAULT;
3512
3513         usbvision->curFrame = NULL;
3514         scratch_reset(usbvision);
3515
3516         /* Alternate interface 1 is is the biggest frame size */
3517         errCode = usb_set_interface(dev, usbvision->iface, usbvision->ifaceAltActive);
3518         if (errCode < 0) {
3519                 usbvision->last_error = errCode;
3520                 return -EBUSY;
3521         }
3522
3523         regValue = (16 - usbvision_read_reg(usbvision, USBVISION_ALTER_REG)) & 0x0F;
3524         usbvision->isocPacketSize = (regValue == 0) ? 0 : (regValue * 64) - 1;
3525         PDEBUG(DBG_ISOC, "ISO Packet Length:%d", usbvision->isocPacketSize);
3526
3527         usbvision->usb_bandwidth = regValue >> 1;
3528         PDEBUG(DBG_ISOC, "USB Bandwidth Usage: %dMbit/Sec", usbvision->usb_bandwidth);
3529
3530
3531
3532         /* We double buffer the Iso lists */
3533
3534         for (bufIdx = 0; bufIdx < USBVISION_NUMSBUF; bufIdx++) {
3535                 int j, k;
3536                 struct urb *urb;
3537
3538                 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3539                         urb = usb_alloc_urb(USBVISION_URB_FRAMES);
3540                 #else
3541                         urb = usb_alloc_urb(USBVISION_URB_FRAMES, GFP_KERNEL);
3542                 #endif
3543                 if (urb == NULL) {
3544                         err("%s: usb_alloc_urb() failed", __FUNCTION__);
3545                         return -ENOMEM;
3546                 }
3547                 usbvision->sbuf[bufIdx].urb = urb;
3548                 urb->dev = dev;
3549                 urb->context = usbvision;
3550                 urb->pipe = usb_rcvisocpipe(dev, usbvision->video_endp);
3551         #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3552                 urb->transfer_flags = USB_ISO_ASAP;
3553         #else
3554                 urb->transfer_flags = URB_ISO_ASAP;
3555                 urb->interval = 1;
3556         #endif
3557                 urb->transfer_buffer = usbvision->sbuf[bufIdx].data;
3558                 urb->complete = usbvision_isocIrq;
3559                 urb->number_of_packets = USBVISION_URB_FRAMES;
3560                 urb->transfer_buffer_length =
3561                     usbvision->isocPacketSize * USBVISION_URB_FRAMES;
3562                 for (j = k = 0; j < USBVISION_URB_FRAMES; j++,
3563                      k += usbvision->isocPacketSize) {
3564                         urb->iso_frame_desc[j].offset = k;
3565                         urb->iso_frame_desc[j].length = usbvision->isocPacketSize;
3566                 }
3567         }
3568
3569
3570         /* Submit all URBs */
3571         for (bufIdx = 0; bufIdx < USBVISION_NUMSBUF; bufIdx++) {
3572                 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3573                         errCode = usb_submit_urb(usbvision->sbuf[bufIdx].urb);
3574                 #else
3575                         errCode = usb_submit_urb(usbvision->sbuf[bufIdx].urb, GFP_KERNEL);
3576                 #endif
3577                 if (errCode) {
3578                         err("%s: usb_submit_urb(%d) failed: error %d", __FUNCTION__, bufIdx, errCode);
3579                 }
3580         }
3581
3582         usbvision->streaming = Stream_On;
3583         PDEBUG(DBG_ISOC, "%s: streaming=1 usbvision->video_endp=$%02x", __FUNCTION__, usbvision->video_endp);
3584         return 0;
3585 }
3586
3587 /*
3588  * usbvision_stop_isoc()
3589  *
3590  * This procedure stops streaming and deallocates URBs. Then it
3591  * activates zero-bandwidth alt. setting of the video interface.
3592  *
3593  */
3594 static void usbvision_stop_isoc(struct usb_usbvision *usbvision)
3595 {
3596         int bufIdx, errCode, regValue;
3597
3598         // FIXME : removed the streaming==Stream_Off. This field has not the same signification than before !
3599         if (usbvision->dev == NULL)
3600                 return;
3601
3602         /* Unschedule all of the iso td's */
3603         for (bufIdx = 0; bufIdx < USBVISION_NUMSBUF; bufIdx++) {
3604                 usb_kill_urb(usbvision->sbuf[bufIdx].urb);
3605                 usb_free_urb(usbvision->sbuf[bufIdx].urb);
3606                 usbvision->sbuf[bufIdx].urb = NULL;
3607         }
3608
3609
3610         PDEBUG(DBG_ISOC, "%s: streaming=Stream_Off\n", __FUNCTION__);
3611         usbvision->streaming = Stream_Off;
3612
3613         if (!usbvision->remove_pending) {
3614
3615                 /* Set packet size to 0 */
3616                 errCode = usb_set_interface(usbvision->dev, usbvision->iface,
3617                                       usbvision->ifaceAltInactive);
3618                 if (errCode < 0) {
3619                         err("%s: usb_set_interface() failed: error %d", __FUNCTION__, errCode);
3620                         usbvision->last_error = errCode;
3621                 }
3622                 regValue = (16 - usbvision_read_reg(usbvision, USBVISION_ALTER_REG)) & 0x0F;
3623                 usbvision->isocPacketSize = (regValue == 0) ? 0 : (regValue * 64) - 1;
3624                 PDEBUG(DBG_ISOC, "ISO Packet Length:%d", usbvision->isocPacketSize);
3625
3626                 usbvision->usb_bandwidth = regValue >> 1;
3627                 PDEBUG(DBG_ISOC, "USB Bandwidth Usage: %dMbit/Sec", usbvision->usb_bandwidth);
3628         }
3629 }
3630
3631 static int usbvision_muxsel(struct usb_usbvision *usbvision, int channel)
3632 {
3633         int mode[4];
3634         int audio[]= {1, 0, 0, 0};
3635         struct v4l2_routing route;
3636         //channel 0 is TV with audiochannel 1 (tuner mono)
3637         //channel 1 is Composite with audio channel 0 (line in)
3638         //channel 2 is S-Video with audio channel 0 (line in)
3639         //channel 3 is additional video inputs to the device with audio channel 0 (line in)
3640
3641         RESTRICT_TO_RANGE(channel, 0, usbvision->video_inputs);
3642         usbvision->ctl_input = channel;
3643           route.input = SAA7115_COMPOSITE1;
3644           call_i2c_clients(usbvision, VIDIOC_INT_S_VIDEO_ROUTING,&route);
3645           call_i2c_clients(usbvision, VIDIOC_S_INPUT, &usbvision->ctl_input);
3646
3647         // set the new channel
3648         // Regular USB TV Tuners -> channel: 0 = Television, 1 = Composite, 2 = S-Video
3649         // Four video input devices -> channel: 0 = Chan White, 1 = Chan Green, 2 = Chan Yellow, 3 = Chan Red
3650
3651         switch (usbvision_device_data[usbvision->DevModel].Codec) {
3652                 case CODEC_SAA7113:
3653                         if (SwitchSVideoInput) { // To handle problems with S-Video Input for some devices.  Use SwitchSVideoInput parameter when loading the module.
3654                                 mode[2] = 1;
3655                         }
3656                         else {
3657                                 mode[2] = 7;
3658                         }
3659                         if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) {
3660                                 mode[0] = 0; mode[1] = 2; mode[3] = 3;  // Special for four input devices
3661                         }
3662                         else {
3663                                 mode[0] = 0; mode[1] = 2; //modes for regular saa7113 devices
3664                         }
3665                         break;
3666                 case CODEC_SAA7111:
3667                         mode[0] = 0; mode[1] = 1; mode[2] = 7; //modes for saa7111
3668                         break;
3669                 default:
3670                         mode[0] = 0; mode[1] = 1; mode[2] = 7; //default modes
3671         }
3672         route.input = mode[channel];
3673         call_i2c_clients(usbvision, VIDIOC_INT_S_VIDEO_ROUTING,&route);
3674         usbvision->channel = channel;
3675         usbvision_set_audio(usbvision, audio[channel]);
3676         return 0;
3677 }
3678
3679
3680 /*
3681  * usbvision_open()
3682  *
3683  * This is part of Video 4 Linux API. The driver can be opened by one
3684  * client only (checks internal counter 'usbvision->user'). The procedure
3685  * then allocates buffers needed for video processing.
3686  *
3687  */
3688 static int usbvision_v4l2_open(struct inode *inode, struct file *file)
3689 {
3690         struct video_device *dev = video_devdata(file);
3691         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
3692         const int sb_size = USBVISION_URB_FRAMES * USBVISION_MAX_ISOC_PACKET_SIZE;
3693         int i, errCode = 0;
3694
3695         PDEBUG(DBG_IO, "open");
3696
3697
3698         if (timer_pending(&usbvision->powerOffTimer)) {
3699                 del_timer(&usbvision->powerOffTimer);
3700         }
3701
3702         if (usbvision->user)
3703                 errCode = -EBUSY;
3704         else {
3705                 /* Clean pointers so we know if we allocated something */
3706                 for (i = 0; i < USBVISION_NUMSBUF; i++)
3707                         usbvision->sbuf[i].data = NULL;
3708
3709                 /* Allocate memory for the frame buffers */
3710                 usbvision->max_frame_size = MAX_FRAME_SIZE;
3711                 usbvision->fbuf_size = USBVISION_NUMFRAMES * usbvision->max_frame_size;
3712                 usbvision->fbuf = usbvision_rvmalloc(usbvision->fbuf_size);
3713                 usbvision->scratch = vmalloc(scratch_buf_size);
3714                 scratch_reset(usbvision);
3715                 if ((usbvision->fbuf == NULL) || (usbvision->scratch == NULL)) {
3716                         err("%s: unable to allocate %d bytes for fbuf and %d bytes for scratch",
3717                                         __FUNCTION__, usbvision->fbuf_size, scratch_buf_size);
3718                         errCode = -ENOMEM;
3719                 }
3720                 else {
3721                         spin_lock_init(&usbvision->queue_lock);
3722                         init_waitqueue_head(&usbvision->wait_frame);
3723                         init_waitqueue_head(&usbvision->wait_stream);
3724
3725                         /* Allocate all buffers */
3726                         for (i = 0; i < USBVISION_NUMFRAMES; i++) {
3727                                 usbvision->frame[i].index = i;
3728                                 usbvision->frame[i].grabstate = FrameState_Unused;
3729                                 usbvision->frame[i].data = usbvision->fbuf +
3730                                     i * MAX_FRAME_SIZE;
3731                                 /*
3732                                  * Set default sizes in case IOCTL
3733                                  * (VIDIOCMCAPTURE)
3734                                  * is not used (using read() instead).
3735                                  */
3736                                 usbvision->stretch_width = 1;
3737                                 usbvision->stretch_height = 1;
3738                                 usbvision->frame[i].width = usbvision->curwidth;
3739                                 usbvision->frame[i].height = usbvision->curheight;
3740                                 usbvision->frame[i].bytes_read = 0;
3741                         }
3742                         if (dga) { //set default for DGA
3743                                 usbvision->overlay_frame.grabstate = FrameState_Unused;
3744                                 usbvision->overlay_frame.scanstate = ScanState_Scanning;
3745                                 usbvision->overlay_frame.data = NULL;
3746                                 usbvision->overlay_frame.width = usbvision->curwidth;
3747                                 usbvision->overlay_frame.height = usbvision->curheight;
3748                                 usbvision->overlay_frame.bytes_read = 0;
3749                         }
3750                         for (i = 0; i < USBVISION_NUMSBUF; i++) {
3751                                 usbvision->sbuf[i].data = kzalloc(sb_size, GFP_KERNEL);
3752                                 if (usbvision->sbuf[i].data == NULL) {
3753                                         err("%s: unable to allocate %d bytes for sbuf", __FUNCTION__, sb_size);
3754                                         errCode = -ENOMEM;
3755                                         break;
3756                                 }
3757                         }
3758                 }
3759                 if ((!errCode) && (usbvision->isocMode==ISOC_MODE_COMPRESS)) {
3760                         int IFB_size = MAX_FRAME_WIDTH * MAX_FRAME_HEIGHT * 3 / 2;
3761                         usbvision->IntraFrameBuffer = vmalloc(IFB_size);
3762                         if (usbvision->IntraFrameBuffer == NULL) {
3763                                 err("%s: unable to allocate %d for compr. frame buffer", __FUNCTION__, IFB_size);
3764                                 errCode = -ENOMEM;
3765                         }
3766
3767                 }
3768                 if (errCode) {
3769                         /* Have to free all that memory */
3770                         if (usbvision->fbuf != NULL) {
3771                                 usbvision_rvfree(usbvision->fbuf, usbvision->fbuf_size);
3772                                 usbvision->fbuf = NULL;
3773                         }
3774                         if (usbvision->scratch != NULL) {
3775                                 vfree(usbvision->scratch);
3776                                 usbvision->scratch = NULL;
3777                         }
3778                         for (i = 0; i < USBVISION_NUMSBUF; i++) {
3779                                 if (usbvision->sbuf[i].data != NULL) {
3780                                         kfree(usbvision->sbuf[i].data);
3781                                         usbvision->sbuf[i].data = NULL;
3782                                 }
3783                         }
3784                         if (usbvision->IntraFrameBuffer != NULL) {
3785                                 vfree(usbvision->IntraFrameBuffer);
3786                                 usbvision->IntraFrameBuffer = NULL;
3787                         }
3788                 }
3789         }
3790
3791         /* If so far no errors then we shall start the camera */
3792         if (!errCode) {
3793                 down(&usbvision->lock);
3794                 if (usbvision->power == 0) {
3795                         usbvision_power_on(usbvision);
3796                         usbvision_init_i2c(usbvision);
3797                 }
3798
3799                 /* Send init sequence only once, it's large! */
3800                 if (!usbvision->initialized) {
3801                         int setup_ok = 0;
3802                         setup_ok = usbvision_setup(usbvision);
3803                         if (setup_ok)
3804                                 usbvision->initialized = 1;
3805                         else
3806                                 errCode = -EBUSY;
3807                 }
3808
3809                 if (!errCode) {
3810                         usbvision_begin_streaming(usbvision);
3811                         errCode = usbvision_init_isoc(usbvision);
3812                         usbvision->user++;
3813                 }
3814                 else {
3815                         if (PowerOnAtOpen) {
3816                                 usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
3817                                 usbvision_power_off(usbvision);
3818                                 usbvision->initialized = 0;
3819                         }
3820                 }
3821                 up(&usbvision->lock);
3822         }
3823
3824         if (errCode) {
3825         }
3826
3827         /* prepare queues */
3828         usbvision_empty_framequeues(usbvision);
3829
3830         PDEBUG(DBG_IO, "success");
3831         return errCode;
3832 }
3833
3834 /*
3835  * usbvision_v4l2_close()
3836  *
3837  * This is part of Video 4 Linux API. The procedure
3838  * stops streaming and deallocates all buffers that were earlier
3839  * allocated in usbvision_v4l2_open().
3840  *
3841  */
3842 static int usbvision_v4l2_close(struct inode *inode, struct file *file)
3843 {
3844         struct video_device *dev = video_devdata(file);
3845         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
3846         int i;
3847
3848         PDEBUG(DBG_IO, "close");
3849         down(&usbvision->lock);
3850
3851         usbvision_audio_off(usbvision);
3852         usbvision_restart_isoc(usbvision);
3853         usbvision_stop_isoc(usbvision);
3854
3855         if (usbvision->IntraFrameBuffer != NULL) {
3856                 vfree(usbvision->IntraFrameBuffer);
3857                 usbvision->IntraFrameBuffer = NULL;
3858         }
3859
3860         usbvision_rvfree(usbvision->fbuf, usbvision->fbuf_size);
3861         vfree(usbvision->scratch);
3862         for (i = 0; i < USBVISION_NUMSBUF; i++)
3863                 kfree(usbvision->sbuf[i].data);
3864
3865         usbvision->user--;
3866
3867         if (PowerOnAtOpen) {
3868                 mod_timer(&usbvision->powerOffTimer, jiffies + USBVISION_POWEROFF_TIME);
3869                 usbvision->initialized = 0;
3870         }
3871
3872         up(&usbvision->lock);
3873
3874         if (usbvision->remove_pending) {
3875                 info("%s: Final disconnect", __FUNCTION__);
3876                 usbvision_release(usbvision);
3877         }
3878
3879         PDEBUG(DBG_IO, "success");
3880
3881
3882         return 0;
3883 }
3884
3885
3886 /*
3887  * usbvision_ioctl()
3888  *
3889  * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
3890  *
3891  */
3892 static int usbvision_v4l2_do_ioctl(struct inode *inode, struct file *file,
3893                                  unsigned int cmd, void *arg)
3894 {
3895         struct video_device *dev = video_devdata(file);
3896         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
3897
3898         if (!USBVISION_IS_OPERATIONAL(usbvision))
3899                 return -EFAULT;
3900
3901         //      if (debug & DBG_IOCTL) v4l_printk_ioctl(cmd);
3902
3903         switch (cmd) {
3904                 case UVIOCSREG:
3905                 {
3906                         struct usbvision_reg *usbvision_reg = arg;
3907                         int errCode;
3908
3909                         errCode = usbvision_write_reg(usbvision, usbvision_reg->addr, usbvision_reg->value);
3910
3911                         if (errCode < 0) {
3912                                 err("%s: UVIOCSREG failed: error %d", __FUNCTION__, errCode);
3913                         }
3914                         else {
3915                                 PDEBUG(DBG_IOCTL, "UVIOCSREG addr=0x%02X, value=0x%02X",
3916                                                         usbvision_reg->addr, usbvision_reg->value);
3917                                 errCode = 0;
3918                         }
3919                         return errCode;
3920                 }
3921                 case UVIOCGREG:
3922                 {
3923                         struct usbvision_reg *usbvision_reg = arg;
3924                         int errCode;
3925
3926                         errCode = usbvision_read_reg(usbvision, usbvision_reg->addr);
3927
3928                         if (errCode < 0) {
3929                                 err("%s: UVIOCGREG failed: error %d", __FUNCTION__, errCode);
3930                         }
3931                         else {
3932                                 usbvision_reg->value=(unsigned char)errCode;
3933                                 PDEBUG(DBG_IOCTL, "UVIOCGREG addr=0x%02X, value=0x%02X",
3934                                                         usbvision_reg->addr, usbvision_reg->value);
3935                                 errCode = 0; // No error
3936                         }
3937                         return errCode;
3938                 }
3939                 case VIDIOC_QUERYCAP:
3940                 {
3941                         struct v4l2_capability *vc=arg;
3942
3943                         memset(vc, 0, sizeof(*vc));
3944                         strlcpy(vc->driver, "USBVision", sizeof(vc->driver));
3945                         strlcpy(vc->card, usbvision_device_data[usbvision->DevModel].ModelString,
3946                                 sizeof(vc->card));
3947                         strlcpy(vc->bus_info, usbvision->dev->dev.bus_id,
3948                                 sizeof(vc->bus_info));
3949                         vc->version = USBVISION_DRIVER_VERSION;
3950                         vc->capabilities = V4L2_CAP_VIDEO_CAPTURE |
3951                                 V4L2_CAP_AUDIO |
3952                                 V4L2_CAP_READWRITE |
3953                                 V4L2_CAP_STREAMING |
3954                                 (dga ? (V4L2_FBUF_CAP_LIST_CLIPPING | V4L2_CAP_VIDEO_OVERLAY) : 0) |
3955                                 (usbvision->have_tuner ? V4L2_CAP_TUNER : 0);
3956                         PDEBUG(DBG_IOCTL, "VIDIOC_QUERYCAP");
3957                         return 0;
3958                 }
3959                 case VIDIOC_ENUMINPUT:
3960                 {
3961                         struct v4l2_input *vi = arg;
3962                         int chan;
3963
3964                         if ((vi->index >= usbvision->video_inputs) || (vi->index < 0) )
3965                                 return -EINVAL;
3966                         if (usbvision->have_tuner) {
3967                                 chan = vi->index;
3968                         }
3969                         else {
3970                                 chan = vi->index + 1; //skip Television string
3971                         }
3972                         switch(chan) {
3973                                 case 0:
3974                                         if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) {
3975                                                 strcpy(vi->name, "White Video Input");
3976                                         }
3977                                         else {
3978                                                 strcpy(vi->name, "Television");
3979                                                 vi->type = V4L2_INPUT_TYPE_TUNER;
3980                                                 vi->audioset = 1;
3981                                                 vi->tuner = chan;
3982                                                 vi->std = V4L2_STD_PAL | V4L2_STD_NTSC | V4L2_STD_SECAM;
3983                                         }
3984                                         break;
3985                                 case 1:
3986                                         vi->type = V4L2_INPUT_TYPE_CAMERA;
3987                                         if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) {
3988                                                 strcpy(vi->name, "Green Video Input");
3989                                         }
3990                                         else {
3991                                                 strcpy(vi->name, "Composite Video Input");
3992                                         }
3993                                         vi->std = V4L2_STD_PAL;
3994                                         break;
3995                                 case 2:
3996                                         vi->type = V4L2_INPUT_TYPE_CAMERA;
3997                                         if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) {
3998                                                 strcpy(vi->name, "Yellow Video Input");
3999                                         }
4000                                         else {
4001                                         strcpy(vi->name, "S-Video Input");
4002                                         }
4003                                         vi->std = V4L2_STD_PAL;
4004                                         break;
4005                                 case 3:
4006                                         vi->type = V4L2_INPUT_TYPE_CAMERA;
4007                                         strcpy(vi->name, "Red Video Input");
4008                                         vi->std = V4L2_STD_PAL;
4009                                         break;
4010                         }
4011                         PDEBUG(DBG_IOCTL, "VIDIOC_ENUMINPUT name=%s:%d tuners=%d type=%d norm=%x", vi->name, vi->index, vi->tuner,vi->type,(int)vi->std);
4012                         return 0;
4013                 }
4014                 case VIDIOC_ENUMSTD:
4015                 {
4016                         struct v4l2_standard *e = arg;
4017                         unsigned int i;
4018                         int ret;
4019
4020                         i = e->index;
4021                         if (i >= TVNORMS)
4022                                 return -EINVAL;
4023                         ret = v4l2_video_std_construct(e, tvnorms[e->index].id,
4024                                                        tvnorms[e->index].name);
4025                         e->index = i;
4026                         if (ret < 0)
4027                                 return ret;
4028                         return 0;
4029                 }
4030                 case VIDIOC_G_INPUT:
4031                 {
4032                         int *input = arg;
4033                         *input = usbvision->ctl_input;
4034                         return 0;
4035                 }
4036                 case VIDIOC_S_INPUT:
4037                 {
4038                         int *input = arg;
4039                         if ((*input >= usbvision->video_inputs) || (*input < 0) )
4040                                 return -EINVAL;
4041                         usbvision->ctl_input = *input;
4042
4043                         down(&usbvision->lock);
4044                         usbvision_muxsel(usbvision, usbvision->ctl_input);
4045                         usbvision_set_input(usbvision);
4046                         usbvision_set_output(usbvision, usbvision->curwidth, usbvision->curheight);
4047                         up(&usbvision->lock);
4048                         return 0;
4049                 }
4050                 case VIDIOC_G_STD:
4051                 {
4052                         v4l2_std_id *id = arg;
4053
4054                         *id = usbvision->tvnorm->id;
4055
4056                         PDEBUG(DBG_IOCTL, "VIDIOC_G_STD std_id=%s", usbvision->tvnorm->name);
4057                         return 0;
4058                 }
4059                 case VIDIOC_S_STD:
4060                 {
4061                         v4l2_std_id *id = arg;
4062                         unsigned int i;
4063
4064                         for (i = 0; i < TVNORMS; i++)
4065                                 if (*id == tvnorms[i].id)
4066                                         break;
4067                         if (i == TVNORMS)
4068                                 for (i = 0; i < TVNORMS; i++)
4069                                         if (*id & tvnorms[i].id)
4070                                                 break;
4071                         if (i == TVNORMS)
4072                                 return -EINVAL;
4073
4074                         down(&usbvision->lock);
4075                         usbvision->tvnorm = &tvnorms[i];
4076
4077                         call_i2c_clients(usbvision, VIDIOC_S_STD,
4078                                          &usbvision->tvnorm->id);
4079
4080                         up(&usbvision->lock);
4081
4082                         PDEBUG(DBG_IOCTL, "VIDIOC_S_STD std_id=%s", usbvision->tvnorm->name);
4083                         return 0;
4084                 }
4085                 case VIDIOC_G_TUNER:
4086                 {
4087                         struct v4l2_tuner *vt = arg;
4088
4089                         if (!usbvision->have_tuner || vt->index)        // Only tuner 0
4090                                 return -EINVAL;
4091                         strcpy(vt->name, "Television");
4092                         /* Let clients fill in the remainder of this struct */
4093                         call_i2c_clients(usbvision,VIDIOC_G_TUNER,vt);
4094
4095                         PDEBUG(DBG_IOCTL, "VIDIOC_G_TUNER signal=%x, afc=%x",vt->signal,vt->afc);
4096                         return 0;
4097                 }
4098                 case VIDIOC_S_TUNER:
4099                 {
4100                         struct v4l2_tuner *vt = arg;
4101
4102                         // Only no or one tuner for now
4103                         if (!usbvision->have_tuner || vt->index)
4104                                 return -EINVAL;
4105                         /* let clients handle this */
4106                         call_i2c_clients(usbvision,VIDIOC_S_TUNER,vt);
4107
4108                         PDEBUG(DBG_IOCTL, "VIDIOC_S_TUNER");
4109                         return 0;
4110                 }
4111                 case VIDIOC_G_FREQUENCY:
4112                 {
4113                         struct v4l2_frequency *freq = arg;
4114
4115                         freq->tuner = 0; // Only one tuner
4116                         freq->type = V4L2_TUNER_ANALOG_TV;
4117                         freq->frequency = usbvision->freq;
4118                         PDEBUG(DBG_IOCTL, "VIDIOC_G_FREQUENCY freq=0x%X", (unsigned)freq->frequency);
4119                         return 0;
4120                 }
4121                 case VIDIOC_S_FREQUENCY:
4122                 {
4123                         struct v4l2_frequency *freq = arg;
4124
4125                         // Only no or one tuner for now
4126                         if (!usbvision->have_tuner || freq->tuner)
4127                                 return -EINVAL;
4128
4129                         usbvision->freq = freq->frequency;
4130                         call_i2c_clients(usbvision, cmd, freq);
4131                         PDEBUG(DBG_IOCTL, "VIDIOC_S_FREQUENCY freq=0x%X", (unsigned)freq->frequency);
4132                         return 0;
4133                 }
4134                 case VIDIOC_G_AUDIO:
4135                 {
4136                         struct v4l2_audio *v = arg;
4137                         memset(v,0, sizeof(v));
4138                         strcpy(v->name, "TV");
4139                         PDEBUG(DBG_IOCTL, "VIDIOC_G_AUDIO");
4140                         // FIXME: no more processings ???
4141                         return 0;
4142                 }
4143                 case VIDIOC_S_AUDIO:
4144                 {
4145                         struct v4l2_audio *v = arg;
4146                         if(v->index) {
4147                                 return -EINVAL;
4148                         }
4149                         PDEBUG(DBG_IOCTL, "VIDIOC_S_AUDIO");
4150                         // FIXME: void function ???
4151                         return 0;
4152                 }
4153                 case VIDIOC_QUERYCTRL:
4154                 {
4155                         struct v4l2_queryctrl *ctrl = arg;
4156                         int id=ctrl->id;
4157
4158                         memset(ctrl,0,sizeof(*ctrl));
4159                         ctrl->id=id;
4160
4161                         i2c_clients_command(&usbvision->i2c_adap, cmd, arg);
4162
4163                         if (ctrl->type)
4164                                 return 0;
4165                         else
4166                                 return -EINVAL;
4167
4168                         PDEBUG(DBG_IOCTL,"VIDIOC_QUERYCTRL id=%x value=%x",ctrl->id,ctrl->type);
4169                 }
4170                 case VIDIOC_G_CTRL:
4171                 {
4172                         struct v4l2_control *ctrl = arg;
4173
4174                         PDEBUG(DBG_IOCTL,"VIDIOC_G_CTRL id=%x value=%x",ctrl->id,ctrl->value);
4175                         call_i2c_clients(usbvision, VIDIOC_G_CTRL, ctrl);
4176                         return 0;
4177                 }
4178                 case VIDIOC_S_CTRL:
4179                 {
4180                         struct v4l2_control *ctrl = arg;
4181
4182                         PDEBUG(DBG_IOCTL, "VIDIOC_S_CTRL id=%x value=%x",ctrl->id,ctrl->value);
4183                         call_i2c_clients(usbvision, VIDIOC_S_CTRL, ctrl);
4184                         return 0;
4185                 }
4186                 case VIDIOC_REQBUFS:
4187                 {
4188                         struct v4l2_requestbuffers *vr = arg;
4189                         int ret;
4190
4191                         RESTRICT_TO_RANGE(vr->count,1,USBVISION_NUMFRAMES);
4192
4193                         // Check input validity : the user must do a VIDEO CAPTURE and MMAP method.
4194                         if((vr->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) ||
4195                            (vr->memory != V4L2_MEMORY_MMAP))
4196                                 return -EINVAL;
4197
4198                         // FIXME : before this, we must control if buffers are still mapped.
4199                         // Then interrupt streaming if so...
4200                         if(usbvision->streaming == Stream_On) {
4201                                 if ((ret = usbvision_stream_interrupt(usbvision)))
4202                                     return ret;
4203                         }
4204
4205                         usbvision_empty_framequeues(usbvision);
4206
4207                         usbvision->curFrame = NULL;
4208
4209                         PDEBUG(DBG_IOCTL, "VIDIOC_REQBUFS count=%d",vr->count);
4210                         return 0;
4211                 }
4212                 case VIDIOC_QUERYBUF:
4213                 {
4214                         struct v4l2_buffer *vb = arg;
4215                         struct usbvision_frame *frame;
4216
4217                         // FIXME : must control that buffers are mapped (VIDIOC_REQBUFS has been called)
4218
4219                         if(vb->type != V4L2_CAP_VIDEO_CAPTURE) {
4220                                 return -EINVAL;
4221                         }
4222                         if(vb->index>=USBVISION_NUMFRAMES)  {
4223                                 return -EINVAL;
4224                         }
4225                         // Updating the corresponding frame state
4226                         vb->flags = 0;
4227                         frame = &usbvision->frame[vb->index];
4228                         if(frame->grabstate >= FrameState_Ready)
4229                                 vb->flags |= V4L2_BUF_FLAG_QUEUED;
4230                         if(frame->grabstate >= FrameState_Done)
4231                                 vb->flags |= V4L2_BUF_FLAG_DONE;
4232                         if(frame->grabstate == FrameState_Unused)
4233                                 vb->flags |= V4L2_BUF_FLAG_MAPPED;
4234                         vb->memory = V4L2_MEMORY_MMAP;
4235                         if(vb->index == 0) {
4236                                 vb->m.offset = 0;
4237                         }
4238                         else {
4239                                 vb->m.offset = MAX_FRAME_SIZE;
4240                         }
4241                         vb->memory = V4L2_MEMORY_MMAP;
4242                         vb->field = V4L2_FIELD_NONE;
4243                         vb->length = MAX_FRAME_SIZE;
4244                         vb->timestamp = usbvision->frame[vb->index].timestamp;
4245                         vb->sequence = usbvision->frame[vb->index].sequence;
4246                         return 0;
4247                 }
4248                 case VIDIOC_QBUF:
4249                 {
4250                         struct v4l2_buffer *vb = arg;
4251                         struct usbvision_frame *frame;
4252                         unsigned long lock_flags;
4253
4254                         // FIXME : works only on VIDEO_CAPTURE MODE, MMAP.
4255                         if(vb->type != V4L2_CAP_VIDEO_CAPTURE) {
4256                                 return -EINVAL;
4257                         }
4258                         if(vb->index>=USBVISION_NUMFRAMES)  {
4259                                 return -EINVAL;
4260                         }
4261
4262                         frame = &usbvision->frame[vb->index];
4263
4264                         if (frame->grabstate != FrameState_Unused) {
4265                                 return -EAGAIN;
4266                         }
4267
4268                         /* Mark it as ready and enqueue frame */
4269                         frame->grabstate = FrameState_Ready;
4270                         frame->scanstate = ScanState_Scanning;
4271                         frame->scanlength = 0;  /* Accumulated in usbvision_parse_data() */
4272
4273                         vb->flags &= ~V4L2_BUF_FLAG_DONE;
4274
4275                         /* set v4l2_format index */
4276                         frame->v4l2_format = usbvision->palette;
4277
4278                         spin_lock_irqsave(&usbvision->queue_lock, lock_flags);
4279                         list_add_tail(&usbvision->frame[vb->index].frame, &usbvision->inqueue);
4280                         spin_unlock_irqrestore(&usbvision->queue_lock, lock_flags);
4281
4282                         return 0;
4283                 }
4284                 case VIDIOC_DQBUF:
4285                 {
4286                         struct v4l2_buffer *vb = arg;
4287                         int ret;
4288                         struct usbvision_frame *f;
4289                         unsigned long lock_flags;
4290
4291                         if (vb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
4292                                 return -EINVAL;
4293
4294                         if (list_empty(&(usbvision->outqueue))) {
4295                                 if (usbvision->streaming == Stream_Off)
4296                                         return -EINVAL;
4297                                 ret = wait_event_interruptible
4298                                         (usbvision->wait_frame,
4299                                          !list_empty(&(usbvision->outqueue)));
4300                                 if (ret)
4301                                         return ret;
4302                         }
4303
4304                         spin_lock_irqsave(&usbvision->queue_lock, lock_flags);
4305                         f = list_entry(usbvision->outqueue.next,
4306                                        struct usbvision_frame, frame);
4307                         list_del(usbvision->outqueue.next);
4308                         spin_unlock_irqrestore(&usbvision->queue_lock, lock_flags);
4309
4310                         f->grabstate = FrameState_Unused;
4311
4312                         vb->memory = V4L2_MEMORY_MMAP;
4313                         vb->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE;
4314                         vb->index = f->index;
4315                         vb->sequence = f->sequence;
4316
4317                         return 0;
4318                 }
4319                 case VIDIOC_STREAMON:
4320                 {
4321                         int b=V4L2_BUF_TYPE_VIDEO_CAPTURE;
4322
4323                         if (list_empty(&usbvision->inqueue))
4324                                 return -EINVAL;
4325
4326                         usbvision->streaming = Stream_On;
4327
4328                         call_i2c_clients(usbvision,VIDIOC_STREAMON , &b);
4329
4330                         PDEBUG(DBG_IOCTL, "VIDIOC_STREAMON");
4331
4332                         return 0;
4333                 }
4334                 case VIDIOC_STREAMOFF:
4335                 {
4336                         int *type = arg;
4337                         int b=V4L2_BUF_TYPE_VIDEO_CAPTURE;
4338
4339                         if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
4340                                 return -EINVAL;
4341
4342                         if(usbvision->streaming == Stream_On) {
4343                                 usbvision_stream_interrupt(usbvision);
4344                                 // Stop all video streamings
4345                                 call_i2c_clients(usbvision,VIDIOC_STREAMOFF , &b);
4346                         }
4347                         usbvision_empty_framequeues(usbvision);
4348
4349                         PDEBUG(DBG_IOCTL, "VIDIOC_STREAMOFF");
4350                         return 0;
4351                 }
4352                 case VIDIOC_G_FBUF:
4353                 {
4354                         struct v4l2_framebuffer *vb = arg;
4355
4356                         if (dga) {
4357                                 *vb = usbvision->vid_buf;
4358                         }
4359                         else {
4360                                 memset(vb, 0, sizeof(vb)); //dga not supported, not used
4361                         }
4362                         PDEBUG(DBG_IOCTL, "VIDIOC_G_FBUF base=%p, width=%d, height=%d, pixelformat=%d, bpl=%d",
4363                                vb->base, vb->fmt.width, vb->fmt.height, vb->fmt.pixelformat,vb->fmt.bytesperline);
4364                         return 0;
4365                 }
4366                 case VIDIOC_S_FBUF:
4367                 {
4368                         struct v4l2_framebuffer *vb = arg;
4369                         int formatIdx;
4370
4371                         if (dga == 0) {
4372                                 return -EINVAL;
4373                         }
4374
4375                         if(!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_ADMIN)) {
4376                                 return -EPERM;
4377                         }
4378
4379                         PDEBUG(DBG_IOCTL, "VIDIOC_S_FBUF base=%p, width=%d, height=%d, pixelformat=%d, bpl=%d",
4380                                vb->base, vb->fmt.width, vb->fmt.height, vb->fmt.pixelformat,vb->fmt.bytesperline);
4381
4382                         for (formatIdx=0; formatIdx <= USBVISION_SUPPORTED_PALETTES; formatIdx++) {
4383                                 if (formatIdx == USBVISION_SUPPORTED_PALETTES) {
4384                                         return -EINVAL; // no matching video_format
4385                                 }
4386                                 if ((vb->fmt.pixelformat == usbvision_v4l2_format[formatIdx].format) &&
4387                                     (usbvision_v4l2_format[formatIdx].supported)) {
4388                                         break; //found matching video_format
4389                                 }
4390                         }
4391
4392                         if (vb->fmt.bytesperline<1) {
4393                                 return -EINVAL;
4394                         }
4395                         if (usbvision->overlay) {
4396                                 return -EBUSY;
4397                         }
4398                         down(&usbvision->lock);
4399                         if (usbvision->overlay_base) {
4400                                 iounmap(usbvision->overlay_base);
4401                                 usbvision->vid_buf_valid = 0;
4402                         }
4403                         usbvision->overlay_base = ioremap((ulong)vb->base, vb->fmt.height * vb->fmt.bytesperline);
4404                         if (usbvision->overlay_base) {
4405                                 usbvision->vid_buf_valid = 1;
4406                         }
4407                         usbvision->vid_buf = *vb;
4408                         usbvision->overlay_frame.v4l2_format = usbvision_v4l2_format[formatIdx];
4409                         up(&usbvision->lock);
4410                         return 0;
4411                 }
4412                 case VIDIOC_ENUM_FMT:
4413                 {
4414                         struct v4l2_fmtdesc *vfd = arg;
4415
4416                         if ( (dga == 0) &&
4417                              (vfd->type == V4L2_BUF_TYPE_VIDEO_OVERLAY) &&
4418                              (usbvision->palette.format != V4L2_PIX_FMT_YVU420) &&
4419                              (usbvision->palette.format != V4L2_PIX_FMT_YUV422P) ) {
4420                                 return -EINVAL;
4421                         }
4422                         if(vfd->index>=USBVISION_SUPPORTED_PALETTES-1) {
4423                                 return -EINVAL;
4424                         }
4425                         vfd->flags = 0;
4426                         strcpy(vfd->description,usbvision_v4l2_format[vfd->index].desc);
4427                         vfd->pixelformat = usbvision_v4l2_format[vfd->index].format;
4428                         return 0;
4429                 }
4430                 case VIDIOC_G_FMT:
4431                 {
4432                         struct v4l2_format *vf = arg;
4433
4434                         if ( (dga == 0) &&
4435                              (vf->type == V4L2_BUF_TYPE_VIDEO_OVERLAY) &&
4436                              (usbvision->palette.format != V4L2_PIX_FMT_YVU420) &&
4437                              (usbvision->palette.format != V4L2_PIX_FMT_YUV422P) ) {
4438                                 return -EINVAL;
4439                         }
4440                         down(&usbvision->lock);
4441                         *vf = usbvision->vid_win;
4442                         up(&usbvision->lock);
4443                         PDEBUG(DBG_IOCTL, "VIDIOC_G_FMT x=%d, y=%d, w=%d, h=%d, chroma=%x, clips=%d",
4444                                vf->fmt.win.w.left, vf->fmt.win.w.top, vf->fmt.win.w.width, vf->fmt.win.w.height, vf->fmt.win.chromakey, vf->fmt.win.clipcount);
4445                         return 0;
4446                 }
4447                 case VIDIOC_S_FMT:
4448                 {
4449                         struct v4l2_format *vf = arg;
4450                         struct v4l2_clip *vc=NULL;
4451                         int on,formatIdx;
4452
4453                         if ( (dga == 0) &&
4454                              (vf->type == V4L2_BUF_TYPE_VIDEO_OVERLAY) &&
4455                              (usbvision->palette.format != V4L2_PIX_FMT_YVU420) &&
4456                              (usbvision->palette.format != V4L2_PIX_FMT_YUV422P) ) {
4457                                 return -EINVAL;
4458                         }
4459                         if(vf->type == V4L2_BUF_TYPE_VIDEO_OVERLAY) {
4460                                 if (vf->fmt.win.clipcount>256) {
4461                                         return -EDOM;   /* Too many clips! */
4462                                 }
4463                                 // Do every clips.
4464                                 vc = vmalloc(sizeof(struct v4l2_clip)*(vf->fmt.win.clipcount+4));
4465                                 if (vc == NULL) {
4466                                         return -ENOMEM;
4467                                 }
4468                                 if (vf->fmt.win.clipcount && copy_from_user(vc,vf->fmt.win.clips,sizeof(struct v4l2_clip)*vf->fmt.win.clipcount)) {
4469                                         return -EFAULT;
4470                                 }
4471                                 on = usbvision->overlay;        // Save overlay state
4472                                 if (on) {
4473                                         usbvision_cap(usbvision, 0);
4474                                 }
4475
4476                                 // strange, it seems xawtv sometimes calls us with 0
4477                                 // width and/or height. Ignore these values
4478                                 if (vf->fmt.win.w.left == 0) {
4479                                         vf->fmt.win.w.left = usbvision->vid_win.fmt.win.w.left;
4480                                 }
4481                                 if (vf->fmt.win.w.top == 0) {
4482                                         vf->fmt.win.w.top = usbvision->vid_win.fmt.win.w.top;
4483                                 }
4484
4485                                 // by now we are committed to the new data...
4486                                 down(&usbvision->lock);
4487                                 RESTRICT_TO_RANGE(vf->fmt.win.w.width, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH);
4488                                 RESTRICT_TO_RANGE(vf->fmt.win.w.height, MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT);
4489                                 usbvision->vid_win = *vf;
4490                                 usbvision->overlay_frame.width = vf->fmt.win.w.width;
4491                                 usbvision->overlay_frame.height = vf->fmt.win.w.height;
4492                                 usbvision_set_output(usbvision, vf->fmt.win.w.width, vf->fmt.win.w.height);
4493                                 up(&usbvision->lock);
4494
4495                                 // Impose display clips
4496                                 if (vf->fmt.win.w.left+vf->fmt.win.w.width > (unsigned int)usbvision->vid_buf.fmt.width) {
4497                                         usbvision_new_clip(vf, vc, usbvision->vid_buf.fmt.width-vf->fmt.win.w.left, 0, vf->fmt.win.w.width-1, vf->fmt.win.w.height-1);
4498                                 }
4499                                 if (vf->fmt.win.w.top+vf->fmt.win.w.height > (unsigned int)usbvision->vid_buf.fmt.height) {
4500                                         usbvision_new_clip(vf, vc, 0, usbvision->vid_buf.fmt.height-vf->fmt.win.w.top, vf->fmt.win.w.width-1, vf->fmt.win.w.height-1);
4501                                 }
4502
4503                                 // built the requested clipping zones
4504                                 usbvision_built_overlay(usbvision, vf->fmt.win.clipcount, vc);
4505                                 vfree(vc);
4506
4507                                 // restore overlay state
4508                                 if (on) {
4509                                         usbvision_cap(usbvision, 1);
4510                                 }
4511                                 usbvision->vid_win_valid = 1;
4512                                 PDEBUG(DBG_IOCTL, "VIDIOC_S_FMT overlay x=%d, y=%d, w=%d, h=%d, chroma=%x, clips=%d",
4513                                        vf->fmt.win.w.left, vf->fmt.win.w.top, vf->fmt.win.w.width, vf->fmt.win.w.height, vf->fmt.win.chromakey, vf->fmt.win.clipcount);
4514                         }
4515                         else {
4516                                 /* Find requested format in available ones */
4517                                 for(formatIdx=0;formatIdx<USBVISION_SUPPORTED_PALETTES;formatIdx++) {
4518                                         if(vf->fmt.pix.pixelformat == usbvision_v4l2_format[formatIdx].format) {
4519                                                 usbvision->palette = usbvision_v4l2_format[formatIdx];
4520                                                 break;
4521                                         }
4522                                 }
4523                                 /* robustness */
4524                                 if(formatIdx == USBVISION_SUPPORTED_PALETTES) {
4525                                         return -EINVAL;
4526                                 }
4527                                 usbvision->vid_win.fmt.pix.pixelformat = vf->fmt.pix.pixelformat;
4528                                 usbvision->vid_win.fmt.pix.width = vf->fmt.pix.width; //Image width in pixels.
4529                                 usbvision->vid_win.fmt.pix.height = vf->fmt.pix.height; // Image height in pixels.
4530
4531                                 // by now we are committed to the new data...
4532                                 down(&usbvision->lock);
4533                                 RESTRICT_TO_RANGE(vf->fmt.pix.width, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH);
4534                                 RESTRICT_TO_RANGE(vf->fmt.pix.height, MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT);
4535                                 usbvision->vid_win = *vf;
4536                                 usbvision_set_output(usbvision, vf->fmt.pix.width, vf->fmt.pix.height);
4537                                 up(&usbvision->lock);
4538
4539                                 usbvision->vid_win_valid = 1;
4540                                 PDEBUG(DBG_IOCTL, "VIDIOC_S_FMT grabdisplay w=%d, h=%d, ",
4541                                        vf->fmt.pix.width, vf->fmt.pix.height);
4542                         }
4543                         return 0;
4544                 }
4545                 case VIDIOC_OVERLAY:
4546                 {
4547                         int *v = arg;
4548
4549                         if ( (dga == 0) &&
4550                              (usbvision->palette.format != V4L2_PIX_FMT_YVU420) &&
4551                              (usbvision->palette.format != V4L2_PIX_FMT_YUV422P) ) {
4552                                 PDEBUG(DBG_IOCTL, "VIDIOC_OVERLAY  DGA disabled");
4553                                 return -EINVAL;
4554                         }
4555
4556                         if (*v == 0) {
4557                                 usbvision_cap(usbvision, 0);
4558                         }
4559                         else {
4560                                 // are VIDIOCSFBUF and VIDIOCSWIN done?
4561                                 if ((usbvision->vid_buf_valid == 0) || (usbvision->vid_win_valid == 0)) {
4562                                         PDEBUG(DBG_IOCTL, "VIDIOC_OVERLAY  vid_buf_valid %d; vid_win_valid %d",
4563                                                usbvision->vid_buf_valid, usbvision->vid_win_valid);
4564                                         return -EINVAL;
4565                                 }
4566                                 usbvision_cap(usbvision, 1);
4567                         }
4568                         PDEBUG(DBG_IOCTL, "VIDIOC_OVERLAY %s", (*v)?"on":"off");
4569                         return 0;
4570                 }
4571                 default:
4572                         return -ENOIOCTLCMD;
4573         }
4574         return 0;
4575 }
4576
4577 static int usbvision_v4l2_ioctl(struct inode *inode, struct file *file,
4578                        unsigned int cmd, unsigned long arg)
4579 {
4580         return video_usercopy(inode, file, cmd, arg, usbvision_v4l2_do_ioctl);
4581 }
4582
4583
4584 static ssize_t usbvision_v4l2_read(struct file *file, char *buf,
4585                       size_t count, loff_t *ppos)
4586 {
4587         struct video_device *dev = video_devdata(file);
4588         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
4589         int noblock = file->f_flags & O_NONBLOCK;
4590
4591         int frmx = -1;
4592         int rc = 0;
4593         struct usbvision_frame *frame;
4594 return -EINVAL;
4595         PDEBUG(DBG_IO, "%s: %ld bytes, noblock=%d", __FUNCTION__, (unsigned long)count, noblock);
4596
4597         if (!USBVISION_IS_OPERATIONAL(usbvision) || (buf == NULL))
4598                 return -EFAULT;
4599
4600         down(&usbvision->lock);
4601         //code for testing compression
4602         if (usbvision->isocMode == ISOC_MODE_COMPRESS) {
4603           usbvision->frame[0].v4l2_format = usbvision_v4l2_format[0]; //V4L2_PIX_FMT_GREY;
4604           usbvision->frame[1].v4l2_format = usbvision_v4l2_format[0]; // V4L2_PIX_FMT_GREY;
4605         }
4606
4607         // See if a frame is completed, then use it.
4608         if (usbvision->frame[0].grabstate >= FrameState_Done) // _Done or _Error
4609                 frmx = 0;
4610         else if (usbvision->frame[1].grabstate >= FrameState_Done)// _Done or _Error
4611                 frmx = 1;
4612
4613         if (noblock && (frmx == -1)) {
4614                 count = -EAGAIN;
4615                 goto usbvision_v4l2_read_done;
4616         }
4617
4618         // If no FRAME_DONE, look for a FRAME_GRABBING state.
4619         // See if a frame is in process (grabbing), then use it.
4620         if (frmx == -1) {
4621                 if (usbvision->frame[0].grabstate == FrameState_Grabbing)
4622                         frmx = 0;
4623                 else if (usbvision->frame[1].grabstate == FrameState_Grabbing)
4624                         frmx = 1;
4625         }
4626
4627         // If no frame is active, start one.
4628         if (frmx == -1)
4629         // FIXME: enqueue all inqueue...
4630         /*              usbvision_new_frame(usbvision, frmx = 0); */
4631
4632         frame = &usbvision->frame[frmx];
4633
4634       restart:
4635         if (!USBVISION_IS_OPERATIONAL(usbvision)) {
4636                 count = -EIO;
4637                 goto usbvision_v4l2_read_done;
4638         }
4639         PDEBUG(DBG_IO, "Waiting frame grabbing");
4640         rc = wait_event_interruptible(usbvision->wait_frame, (frame->grabstate == FrameState_Done) ||
4641                                                  (frame->grabstate == FrameState_Error));
4642         if (rc) {
4643                 goto usbvision_v4l2_read_done;
4644         }
4645
4646         if (frame->grabstate == FrameState_Error) {
4647                 frame->bytes_read = 0;
4648                 // FIXME: enqueue all inqueue...
4649 /*              if (usbvision_new_frame(usbvision, frmx)) { */
4650 /*                      err("%s: usbvision_new_frame() failed", __FUNCTION__); */
4651 /*              } */
4652                 goto restart;
4653         }
4654
4655         PDEBUG(DBG_IO, "%s: frmx=%d, bytes_read=%ld, scanlength=%ld", __FUNCTION__,
4656                        frmx, frame->bytes_read, frame->scanlength);
4657
4658         /* copy bytes to user space; we allow for partials reads */
4659         if ((count + frame->bytes_read) > (unsigned long)frame->scanlength)
4660                 count = frame->scanlength - frame->bytes_read;
4661
4662         if (copy_to_user(buf, frame->data + frame->bytes_read, count)) {
4663                 count = -EFAULT;
4664                 goto usbvision_v4l2_read_done;
4665         }
4666
4667         frame->bytes_read += count;
4668         PDEBUG(DBG_IO, "%s: {copy} count used=%ld, new bytes_read=%ld", __FUNCTION__,
4669                        (unsigned long)count, frame->bytes_read);
4670
4671         if (frame->bytes_read >= frame->scanlength) {// All data has been read
4672                 frame->bytes_read = 0;
4673
4674                 /* Mark it as available to be used again. */
4675                 usbvision->frame[frmx].grabstate = FrameState_Unused;
4676                 // FIXME enqueue another frame
4677 /*              if (usbvision_new_frame(usbvision, frmx ? 0 : 1)) */
4678 /*                      err("%s: usbvision_new_frame() failed", __FUNCTION__); */
4679         }
4680
4681 usbvision_v4l2_read_done:
4682         up(&usbvision->lock);
4683         return count;
4684 }
4685
4686 static int usbvision_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
4687 {
4688         struct video_device *dev = video_devdata(file);
4689         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
4690         unsigned long start = vma->vm_start;
4691         unsigned long size  = vma->vm_end-vma->vm_start;
4692
4693         unsigned long page, pos;
4694
4695         if (!USBVISION_IS_OPERATIONAL(usbvision))
4696                 return -EFAULT;
4697
4698         if (size > (((USBVISION_NUMFRAMES * usbvision->max_frame_size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)))
4699                 return -EINVAL;
4700
4701         pos = (unsigned long) usbvision->fbuf;
4702         while (size > 0) {
4703
4704 // Really ugly....
4705         #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)                           //Compatibility for 2.6.10+ kernels
4706                 page = vmalloc_to_pfn((void *)pos);
4707                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
4708                         return -EAGAIN;
4709                 }
4710         #else                                                                      //Compatibility for 2.6.0 - 2.6.9 kernels
4711                 page = usbvision_kvirt_to_pa(pos);
4712                 if (remap_page_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
4713                         return -EAGAIN;
4714                 }
4715         #endif
4716                 start += PAGE_SIZE;
4717                 pos += PAGE_SIZE;
4718                 if (size > PAGE_SIZE)
4719                         size -= PAGE_SIZE;
4720                 else
4721                         size = 0;
4722         }
4723
4724         return 0;
4725 }
4726
4727
4728 /*
4729  * Here comes the stuff for radio on usbvision based devices
4730  *
4731  */
4732 static int usbvision_radio_open(struct inode *inode, struct file *file)
4733 {
4734         struct video_device *dev = video_devdata(file);
4735         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
4736         struct v4l2_frequency freq;
4737         int errCode = 0;
4738
4739         PDEBUG(DBG_RIO, "%s:", __FUNCTION__);
4740
4741         down(&usbvision->lock);
4742
4743         if (usbvision->user) {
4744                 err("%s: Someone tried to open an already opened USBVision Radio!", __FUNCTION__);
4745                 errCode = -EBUSY;
4746         }
4747         else {
4748                 if(PowerOnAtOpen) {
4749                         if (timer_pending(&usbvision->powerOffTimer)) {
4750                                 del_timer(&usbvision->powerOffTimer);
4751                         }
4752                         if (usbvision->power == 0) {
4753                                 usbvision_power_on(usbvision);
4754                                 usbvision_init_i2c(usbvision);
4755                         }
4756                 }
4757
4758                 // If so far no errors then we shall start the radio
4759                 usbvision->radio = 1;
4760                 call_i2c_clients(usbvision,AUDC_SET_RADIO,&usbvision->tuner_type);
4761                 freq.frequency = 1517; //SWR3 @ 94.8MHz
4762                 call_i2c_clients(usbvision, VIDIOC_S_FREQUENCY, &freq);
4763                 usbvision_set_audio(usbvision, USBVISION_AUDIO_RADIO);
4764                 usbvision->user++;
4765         }
4766
4767         if (errCode) {
4768                 if (PowerOnAtOpen) {
4769                         usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
4770                         usbvision_power_off(usbvision);
4771                         usbvision->initialized = 0;
4772                 }
4773         }
4774         up(&usbvision->lock);
4775         return errCode;
4776 }
4777
4778
4779 static int usbvision_radio_close(struct inode *inode, struct file *file)
4780 {
4781         struct video_device *dev = video_devdata(file);
4782         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
4783         int errCode = 0;
4784
4785         PDEBUG(DBG_RIO, "");
4786
4787         down(&usbvision->lock);
4788
4789         usbvision_audio_off(usbvision);
4790         usbvision->radio=0;
4791         usbvision->user--;
4792
4793         if (PowerOnAtOpen) {
4794                 mod_timer(&usbvision->powerOffTimer, jiffies + USBVISION_POWEROFF_TIME);
4795                 usbvision->initialized = 0;
4796         }
4797
4798         up(&usbvision->lock);
4799
4800         if (usbvision->remove_pending) {
4801                 info("%s: Final disconnect", __FUNCTION__);
4802                 usbvision_release(usbvision);
4803         }
4804
4805
4806         PDEBUG(DBG_RIO, "success");
4807
4808         return errCode;
4809 }
4810
4811 static int usbvision_do_radio_ioctl(struct inode *inode, struct file *file,
4812                                  unsigned int cmd, void *arg)
4813 {
4814         struct video_device *dev = video_devdata(file);
4815         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
4816
4817         if (!USBVISION_IS_OPERATIONAL(usbvision))
4818                 return -EIO;
4819
4820         switch (cmd) {
4821                 /***************************
4822                  * V4L2 IOCTLs             *
4823                  ***************************/
4824                 case VIDIOC_QUERYCAP:
4825                 {
4826                         struct v4l2_capability *vc=arg;
4827                         memset(vc, 0, sizeof(struct v4l2_capability));
4828                         strcpy(vc->driver,"usbvision radio");
4829                         strcpy(vc->card,usbvision->vcap.card);
4830                         strcpy(vc->bus_info,"usb");
4831                         vc->version = USBVISION_DRIVER_VERSION;             /* version */
4832                         vc->capabilities = V4L2_CAP_TUNER;          /* capabilities */
4833                         PDEBUG(DBG_RIO, "%s: VIDIOC_QUERYCAP", __FUNCTION__);
4834                         return 0;
4835                 }
4836                 case VIDIOC_QUERYCTRL:
4837                 {
4838                         struct v4l2_queryctrl *qc = arg;
4839                         switch(qc->id)
4840                                 {
4841                                 case V4L2_CID_AUDIO_VOLUME:
4842                                 case V4L2_CID_AUDIO_MUTE:
4843                                         return v4l2_ctrl_query_fill_std(qc);
4844                                         break;
4845                                 default:
4846                                         return -EINVAL;
4847                                 }
4848                         return 0;
4849                 }
4850                 case VIDIOC_G_CTRL:
4851                 {
4852                         struct v4l2_control *ctrl = arg;
4853                         PDEBUG(DBG_IOCTL, "VIDIOC_G_CTRL id=%x value=%x",ctrl->id,ctrl->value);
4854                         switch(ctrl->id) {
4855                         case V4L2_CID_AUDIO_VOLUME:
4856                                 /*      ctrl->value = usbvision->volume; */
4857                                 break;
4858                         case V4L2_CID_AUDIO_MUTE:
4859                                 ctrl->value = usbvision->AudioMute;
4860                                 break;
4861                         default:
4862                                 return -EINVAL;
4863                         }
4864                         return 0;
4865                 }
4866                 case VIDIOC_S_CTRL:
4867                 {
4868                         struct v4l2_control *ctrl = arg;
4869                         call_i2c_clients(usbvision, VIDIOC_S_CTRL, ctrl);
4870
4871                         PDEBUG(DBG_RIO, "%s: VIDIOC_S_CTRL id=%x value=%x", __FUNCTION__,ctrl->id,ctrl->value);
4872                         return 0;
4873                 }
4874                 case VIDIOC_G_TUNER:
4875                 {
4876                         struct v4l2_tuner *vt = arg;
4877
4878                         if (!usbvision->have_tuner || vt->index)        // Only tuner 0
4879                                 return -EINVAL;
4880                         strcpy(vt->name, "Radio");
4881                         vt->type = V4L2_TUNER_RADIO;
4882                         vt->capability = V4L2_TUNER_CAP_STEREO;
4883                         // japan:          76.0 MHz -  89.9 MHz
4884                         // western europe: 87.5 MHz - 108.0 MHz
4885                         // russia:         65.0 MHz - 108.0 MHz
4886                         vt->rangelow = (int)(65*16);;
4887                         vt->rangehigh = (int)(108*16);
4888                         vt->audmode = V4L2_TUNER_MODE_STEREO;
4889                         vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
4890                         call_i2c_clients(usbvision,VIDIOC_G_TUNER,&vt);
4891
4892                         PDEBUG(DBG_RIO, "%s: VIDIOC_G_TUNER signal=%d", __FUNCTION__, vt->signal);
4893                         return 0;
4894                 }
4895                 case VIDIOC_S_TUNER:
4896                 {
4897                         struct v4l2_tuner *vt = arg;
4898
4899                         // Only channel 0 has a tuner
4900                         if((vt->index) || (usbvision->channel)) {
4901                                 return -EINVAL;
4902                         }
4903                         PDEBUG(DBG_RIO, "%s: VIDIOC_S_TUNER", __FUNCTION__);
4904                         return 0;
4905                 }
4906                 case VIDIOC_G_AUDIO:
4907                 {
4908                         struct v4l2_audio *va = arg;
4909                         memset(va,0, sizeof(va));
4910                         va->capability = V4L2_AUDCAP_STEREO;
4911                         strcpy(va->name, "Radio");
4912                         PDEBUG(DBG_IOCTL, "VIDIOC_G_AUDIO");
4913                         return 0;
4914                 }
4915                 case VIDIOC_S_AUDIO:
4916                 {
4917                         struct v4l2_audio *v = arg;
4918                         if(v->index) {
4919                                 return -EINVAL;
4920                         }
4921                         PDEBUG(DBG_IOCTL, "VIDIOC_S_AUDIO");
4922                         // FIXME: void function ???
4923                         return 0;
4924                 }
4925                 case VIDIOC_G_FREQUENCY:
4926                 {
4927                         struct v4l2_frequency *freq = arg;
4928                         freq->tuner = 0; // Only one tuner
4929                         freq->type = V4L2_TUNER_RADIO;
4930                         freq->frequency = usbvision->freq;
4931                         PDEBUG(DBG_RIO, "VIDIOC_G_FREQUENCY freq=0x%X", (unsigned)freq->frequency);
4932                         return 0;
4933                 }
4934                 case VIDIOC_S_FREQUENCY:
4935                 {
4936                         struct v4l2_frequency *freq = arg;
4937                         usbvision->freq = freq->frequency;
4938                         call_i2c_clients(usbvision, cmd, freq);
4939                         PDEBUG(DBG_RIO, "VIDIOC_S_FREQUENCY freq=0x%X", (unsigned)freq->frequency);
4940                         return 0;
4941                 }
4942
4943                 /***************************
4944                  * V4L1 IOCTLs             *
4945                  ***************************/
4946                 case VIDIOCGCAP:
4947                 {
4948                         struct video_capability *vc = arg;
4949
4950                         memset(vc, 0, sizeof(struct video_capability));
4951                         strcpy(vc->name,usbvision->vcap.card);
4952                         vc->type = VID_TYPE_TUNER;
4953                         vc->channels = 1;
4954                         vc->audios = 1;
4955                         PDEBUG(DBG_RIO, "%s: VIDIOCGCAP", __FUNCTION__);
4956                         return 0;
4957                 }
4958                 case VIDIOCGTUNER:
4959                 {
4960                         struct video_tuner *vt = arg;
4961
4962                         if((vt->tuner) || (usbvision->channel)) {       /* Only tuner 0 */
4963                                 return -EINVAL;
4964                         }
4965                         strcpy(vt->name, "Radio");
4966                         // japan:          76.0 MHz -  89.9 MHz
4967                         // western europe: 87.5 MHz - 108.0 MHz
4968                         // russia:         65.0 MHz - 108.0 MHz
4969                         vt->rangelow=(int)(65*16);
4970                         vt->rangehigh=(int)(108*16);
4971                         vt->flags= 0;
4972                         vt->mode = 0;
4973                         call_i2c_clients(usbvision,cmd,vt);
4974                         PDEBUG(DBG_RIO, "%s: VIDIOCGTUNER signal=%d", __FUNCTION__, vt->signal);
4975                         return 0;
4976                 }
4977                 case VIDIOCSTUNER:
4978                 {
4979                         struct video_tuner *vt = arg;
4980
4981                         // Only channel 0 has a tuner
4982                         if((vt->tuner) || (usbvision->channel)) {
4983                                 return -EINVAL;
4984                         }
4985                         PDEBUG(DBG_RIO, "%s: VIDIOCSTUNER", __FUNCTION__);
4986                         return 0;
4987                 }
4988                 case VIDIOCGAUDIO:
4989                 {
4990                         struct video_audio *va = arg;
4991                         memset(va,0, sizeof(struct video_audio));
4992                         call_i2c_clients(usbvision, cmd, va);
4993                         va->flags|=VIDEO_AUDIO_MUTABLE;
4994                         va->volume=1;
4995                         va->step=1;
4996                         strcpy(va->name, "Radio");
4997                         PDEBUG(DBG_RIO, "%s: VIDIOCGAUDIO", __FUNCTION__);
4998                         return 0;
4999                 }
5000                 case VIDIOCSAUDIO:
5001                 {
5002                         struct video_audio *va = arg;
5003                         if(va->audio) {
5004                                 return -EINVAL;
5005                         }
5006
5007                         if(va->flags & VIDEO_AUDIO_MUTE) {
5008                                 if (usbvision_audio_mute(usbvision)) {
5009                                         return -EFAULT;
5010                                 }
5011                         }
5012                         else {
5013                                 if (usbvision_audio_on(usbvision)) {
5014                                         return -EFAULT;
5015                                 }
5016                         }
5017                         PDEBUG(DBG_RIO, "%s: VIDIOCSAUDIO flags=0x%x)", __FUNCTION__, va->flags);
5018                         return 0;
5019                 }
5020                 case VIDIOCGFREQ:
5021                 {
5022                         unsigned long *freq = arg;
5023
5024                         *freq = usbvision->freq;
5025                         PDEBUG(DBG_RIO, "%s: VIDIOCGFREQ freq = %ld00 kHz", __FUNCTION__, (*freq * 10)>>4);
5026                         return 0;
5027                 }
5028                 case VIDIOCSFREQ:
5029                 {
5030                         unsigned long *freq = arg;
5031
5032                         usbvision->freq = *freq;
5033                         call_i2c_clients(usbvision, cmd, freq);
5034                         PDEBUG(DBG_RIO, "%s: VIDIOCSFREQ freq = %ld00 kHz", __FUNCTION__, (*freq * 10)>>4);
5035                         return 0;
5036                 }
5037                 default:
5038                 {
5039                         PDEBUG(DBG_RIO, "%s: Unknown command %x", __FUNCTION__, cmd);
5040                         return -ENOIOCTLCMD;
5041                 }
5042         }
5043         return 0;
5044 }
5045
5046
5047 static int usbvision_radio_ioctl(struct inode *inode, struct file *file,
5048                        unsigned int cmd, unsigned long arg)
5049 {
5050         return video_usercopy(inode, file, cmd, arg, usbvision_do_radio_ioctl);
5051 }
5052
5053
5054 /*
5055  * Here comes the stuff for vbi on usbvision based devices
5056  *
5057  */
5058 static int usbvision_vbi_open(struct inode *inode, struct file *file)
5059 {
5060         struct video_device *dev = video_devdata(file);
5061         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
5062         unsigned long freq;
5063         int errCode = 0;
5064
5065         PDEBUG(DBG_RIO, "%s:", __FUNCTION__);
5066
5067         down(&usbvision->lock);
5068
5069         if (usbvision->user) {
5070                 err("%s: Someone tried to open an already opened USBVision VBI!", __FUNCTION__);
5071                 errCode = -EBUSY;
5072         }
5073         else {
5074                 if(PowerOnAtOpen) {
5075                         if (timer_pending(&usbvision->powerOffTimer)) {
5076                                 del_timer(&usbvision->powerOffTimer);
5077                         }
5078                         if (usbvision->power == 0) {
5079                                 usbvision_power_on(usbvision);
5080                                 usbvision_init_i2c(usbvision);
5081                         }
5082                 }
5083
5084                 // If so far no errors then we shall start the vbi device
5085                 //usbvision->vbi = 1;
5086                 call_i2c_clients(usbvision,AUDC_SET_RADIO,&usbvision->tuner_type);
5087                 freq = 1517; //SWR3 @ 94.8MHz
5088                 call_i2c_clients(usbvision, VIDIOCSFREQ, &freq);
5089                 usbvision_set_audio(usbvision, USBVISION_AUDIO_RADIO);
5090                 usbvision->user++;
5091         }
5092
5093         if (errCode) {
5094                 if (PowerOnAtOpen) {
5095                         usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
5096                         usbvision_power_off(usbvision);
5097                         usbvision->initialized = 0;
5098                 }
5099         }
5100         up(&usbvision->lock);
5101         return errCode;
5102 }
5103
5104 static int usbvision_vbi_close(struct inode *inode, struct file *file)
5105 {
5106         struct video_device *dev = video_devdata(file);
5107         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
5108         int errCode = 0;
5109
5110         PDEBUG(DBG_RIO, "");
5111
5112         down(&usbvision->lock);
5113
5114         usbvision_audio_off(usbvision);
5115         usbvision->vbi=0;
5116         usbvision->user--;
5117
5118         if (PowerOnAtOpen) {
5119                 mod_timer(&usbvision->powerOffTimer, jiffies + USBVISION_POWEROFF_TIME);
5120                 usbvision->initialized = 0;
5121         }
5122
5123         up(&usbvision->lock);
5124
5125         if (usbvision->remove_pending) {
5126                 info("%s: Final disconnect", __FUNCTION__);
5127                 usbvision_release(usbvision);
5128         }
5129
5130
5131         PDEBUG(DBG_RIO, "success");
5132
5133         return errCode;
5134 }
5135
5136 static int usbvision_do_vbi_ioctl(struct inode *inode, struct file *file,
5137                                  unsigned int cmd, void *arg)
5138 {
5139         struct video_device *dev = video_devdata(file);
5140         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
5141
5142         if (!USBVISION_IS_OPERATIONAL(usbvision))
5143                 return -EIO;
5144
5145         switch (cmd) {
5146                 case VIDIOC_QUERYCAP:
5147                 {
5148                         struct v4l2_capability *vc=arg;
5149                         memset(vc, 0, sizeof(struct v4l2_capability));
5150                         strcpy(vc->driver,"usbvision vbi");
5151                         strcpy(vc->card,usbvision->vcap.card);
5152                         strcpy(vc->bus_info,"usb");
5153                         vc->version = USBVISION_DRIVER_VERSION;             /* version */
5154                         vc->capabilities = V4L2_CAP_VBI_CAPTURE;            /* capabilities */
5155                         PDEBUG(DBG_RIO, "%s: VIDIOC_QUERYCAP", __FUNCTION__);
5156                         return 0;
5157                 }
5158                 case VIDIOCGTUNER:
5159                 {
5160                         struct video_tuner *vt = arg;
5161
5162                         if((vt->tuner) || (usbvision->channel)) {       /* Only tuner 0 */
5163                                 return -EINVAL;
5164                         }
5165                         strcpy(vt->name, "vbi");
5166                         // japan:          76.0 MHz -  89.9 MHz
5167                         // western europe: 87.5 MHz - 108.0 MHz
5168                         // russia:         65.0 MHz - 108.0 MHz
5169                         vt->rangelow=(int)(65*16);
5170                         vt->rangehigh=(int)(108*16);
5171                         vt->flags= 0;
5172                         vt->mode = 0;
5173                         call_i2c_clients(usbvision,cmd,vt);
5174                         PDEBUG(DBG_RIO, "%s: VIDIOCGTUNER signal=%d", __FUNCTION__, vt->signal);
5175                         return 0;
5176                 }
5177                 case VIDIOCSTUNER:
5178                 {
5179                         struct video_tuner *vt = arg;
5180
5181                         // Only channel 0 has a tuner
5182                         if((vt->tuner) || (usbvision->channel)) {
5183                                 return -EINVAL;
5184                         }
5185                         PDEBUG(DBG_RIO, "%s: VIDIOCSTUNER", __FUNCTION__);
5186                         return 0;
5187                 }
5188                 case VIDIOCGAUDIO:
5189                 {
5190                         struct video_audio *va = arg;
5191                         memset(va,0, sizeof(struct video_audio));
5192                         call_i2c_clients(usbvision, cmd, va);
5193                         va->flags|=VIDEO_AUDIO_MUTABLE;
5194                         va->volume=1;
5195                         va->step=1;
5196                         strcpy(va->name, "vbi");
5197                         PDEBUG(DBG_RIO, "%s: VIDIOCGAUDIO", __FUNCTION__);
5198                         return 0;
5199                 }
5200                 case VIDIOCSAUDIO:
5201                 {
5202                         struct video_audio *va = arg;
5203                         if(va->audio) {
5204                                 return -EINVAL;
5205                         }
5206
5207                         if(va->flags & VIDEO_AUDIO_MUTE) {
5208                                 if (usbvision_audio_mute(usbvision)) {
5209                                         return -EFAULT;
5210                                 }
5211                         }
5212                         else {
5213                                 if (usbvision_audio_on(usbvision)) {
5214                                         return -EFAULT;
5215                                 }
5216                         }
5217                         PDEBUG(DBG_RIO, "%s: VIDIOCSAUDIO flags=0x%x)", __FUNCTION__, va->flags);
5218                         return 0;
5219                 }
5220                 case VIDIOCGFREQ:
5221                 {
5222                         unsigned long *freq = arg;
5223
5224                         *freq = usbvision->freq;
5225                         PDEBUG(DBG_RIO, "%s: VIDIOCGFREQ freq = %ld00 kHz", __FUNCTION__, (*freq * 10)>>4);
5226                         return 0;
5227                 }
5228                 case VIDIOCSFREQ:
5229                 {
5230                         unsigned long *freq = arg;
5231
5232                         usbvision->freq = *freq;
5233                         call_i2c_clients(usbvision, cmd, freq);
5234                         PDEBUG(DBG_RIO, "%s: VIDIOCSFREQ freq = %ld00 kHz", __FUNCTION__, (*freq * 10)>>4);
5235                         return 0;
5236                 }
5237                 default:
5238                 {
5239                         PDEBUG(DBG_RIO, "%s: Unknown command %d", __FUNCTION__, cmd);
5240                         return -ENOIOCTLCMD;
5241                 }
5242         }
5243         return 0;
5244 }
5245
5246 static int usbvision_vbi_ioctl(struct inode *inode, struct file *file,
5247                        unsigned int cmd, unsigned long arg)
5248 {
5249         return video_usercopy(inode, file, cmd, arg, usbvision_do_vbi_ioctl);
5250 }
5251
5252
5253
5254 static void usbvision_configure_video(struct usb_usbvision *usbvision)
5255 {
5256         int model,i;
5257
5258         if (usbvision == NULL)
5259                 return;
5260
5261         model = usbvision->DevModel;
5262         usbvision->depth = 24;
5263         usbvision->palette = usbvision_v4l2_format[2]; // V4L2_PIX_FMT_RGB24;
5264
5265         if (usbvision_device_data[usbvision->DevModel].Vin_Reg2 >= 0) {
5266                 usbvision->Vin_Reg2_Preset = usbvision_device_data[usbvision->DevModel].Vin_Reg2 & 0xff;
5267         } else {
5268                 usbvision->Vin_Reg2_Preset = 0;
5269         }
5270
5271         memset(&usbvision->vcap, 0, sizeof(usbvision->vcap));
5272         strcpy(usbvision->vcap.driver, "USBVision");
5273         strlcpy(usbvision->vcap.bus_info, usbvision->dev->dev.bus_id,
5274                 sizeof(usbvision->vcap.bus_info));
5275         usbvision->vcap.capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
5276                 (dga ? (V4L2_FBUF_CAP_LIST_CLIPPING | V4L2_CAP_VIDEO_OVERLAY) : 0) |
5277                 (usbvision->have_tuner ? V4L2_CAP_TUNER : 0);
5278         usbvision->vcap.version = USBVISION_DRIVER_VERSION;         /* version */
5279
5280
5281         for (i = 0; i < TVNORMS; i++)
5282                 if (usbvision_device_data[model].VideoNorm == tvnorms[i].mode)
5283                         break;
5284         if (i == TVNORMS)
5285                 i = 0;
5286         usbvision->tvnorm = &tvnorms[i];        /* set default norm */
5287         call_i2c_clients(usbvision, VIDIOC_S_STD,
5288                          &usbvision->tvnorm->id);
5289
5290         usbvision->video_inputs = usbvision_device_data[model].VideoChannels;
5291         usbvision->ctl_input = 0;
5292 /*      usbvision_muxsel(usbvision, usbvision->ctl_input); */
5293
5294         /* This should be here to make i2c clients to be able to register */
5295         usbvision_audio_off(usbvision); //first switch off audio
5296         if (!PowerOnAtOpen) {
5297                 usbvision_power_on(usbvision);  //and then power up the noisy tuner
5298                 usbvision_init_i2c(usbvision);
5299         }
5300 }
5301
5302 //
5303 // Video registration stuff
5304 //
5305
5306 // Video template
5307 static struct file_operations usbvision_fops = {
5308   #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5309         .owner             = THIS_MODULE,
5310   #endif
5311         .open           = usbvision_v4l2_open,
5312         .release        = usbvision_v4l2_close,
5313         .read           = usbvision_v4l2_read,
5314         .mmap           = usbvision_v4l2_mmap,
5315         .ioctl          = usbvision_v4l2_ioctl,
5316         .llseek         = no_llseek,
5317 };
5318 static struct video_device usbvision_video_template = {
5319   #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5320         .owner             = THIS_MODULE,
5321   #endif
5322         .type           = VID_TYPE_TUNER | VID_TYPE_CAPTURE,
5323         .hardware       = VID_HARDWARE_USBVISION,
5324         .fops           = &usbvision_fops,
5325   #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
5326         .name           = "usbvision-video",
5327         .release        = video_device_release,
5328   #endif
5329         .minor          = -1,
5330 };
5331
5332
5333 // Radio template
5334 static struct file_operations usbvision_radio_fops = {
5335   #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5336         .owner             = THIS_MODULE,
5337   #endif
5338         .open           = usbvision_radio_open,
5339         .release        = usbvision_radio_close,
5340         .ioctl          = usbvision_radio_ioctl,
5341         .llseek         = no_llseek,
5342 };
5343
5344 static struct video_device usbvision_radio_template=
5345 {
5346   #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5347         .owner             = THIS_MODULE,
5348   #endif
5349         .type           = VID_TYPE_TUNER,
5350         .hardware       = VID_HARDWARE_USBVISION,
5351         .fops           = &usbvision_radio_fops,
5352   #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
5353         .release        = video_device_release,
5354         .name           = "usbvision-radio",
5355   #endif
5356         .minor          = -1,
5357 };
5358
5359
5360 // vbi template
5361 static struct file_operations usbvision_vbi_fops = {
5362   #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5363         .owner             = THIS_MODULE,
5364   #endif
5365         .open           = usbvision_vbi_open,
5366         .release        = usbvision_vbi_close,
5367         .ioctl          = usbvision_vbi_ioctl,
5368         .llseek         = no_llseek,
5369 };
5370
5371 static struct video_device usbvision_vbi_template=
5372 {
5373   #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5374         .owner             = THIS_MODULE,
5375   #endif
5376         .type           = VID_TYPE_TUNER,
5377         .hardware       = VID_HARDWARE_USBVISION,
5378         .fops           = &usbvision_vbi_fops,
5379   #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
5380         .release        = video_device_release,
5381         .name           = "usbvision-vbi",
5382   #endif
5383         .minor          = -1,
5384 };
5385
5386
5387 static struct video_device *usbvision_vdev_init(struct usb_usbvision *usbvision,
5388                                         struct video_device *vdev_template,
5389                                         char *name)
5390 {
5391         struct usb_device *usb_dev = usbvision->dev;
5392         struct video_device *vdev;
5393
5394         if (usb_dev == NULL) {
5395                 err("%s: usbvision->dev is not set", __FUNCTION__);
5396                 return NULL;
5397         }
5398
5399         vdev = video_device_alloc();
5400         if (NULL == vdev) {
5401                 return NULL;
5402         }
5403         *vdev = *vdev_template;
5404 //      vdev->minor   = -1;
5405         vdev->dev     = &usb_dev->dev;
5406         snprintf(vdev->name, sizeof(vdev->name), "%s", name);
5407         video_set_drvdata(vdev, usbvision);
5408         return vdev;
5409 }
5410
5411 // unregister video4linux devices
5412 static void usbvision_unregister_video(struct usb_usbvision *usbvision)
5413 {
5414         // vbi Device:
5415         if (usbvision->vbi) {
5416                 PDEBUG(DBG_PROBE, "unregister /dev/vbi%d [v4l2]", usbvision->vbi->minor & 0x1f);
5417                 if (usbvision->vbi->minor != -1) {
5418                         video_unregister_device(usbvision->vbi);
5419                 }
5420                 else {
5421                         video_device_release(usbvision->vbi);
5422                 }
5423                 usbvision->vbi = NULL;
5424         }
5425
5426         // Radio Device:
5427         if (usbvision->rdev) {
5428                 PDEBUG(DBG_PROBE, "unregister /dev/radio%d [v4l2]", usbvision->rdev->minor & 0x1f);
5429                 if (usbvision->rdev->minor != -1) {
5430                         video_unregister_device(usbvision->rdev);
5431                 }
5432                 else {
5433                         video_device_release(usbvision->rdev);
5434                 }
5435                 usbvision->rdev = NULL;
5436         }
5437
5438         // Video Device:
5439         if (usbvision->vdev) {
5440                 PDEBUG(DBG_PROBE, "unregister /dev/video%d [v4l2]", usbvision->vdev->minor & 0x1f);
5441                 if (usbvision->vdev->minor != -1) {
5442                         video_unregister_device(usbvision->vdev);
5443                 }
5444                 else {
5445                         video_device_release(usbvision->vdev);
5446                 }
5447                 usbvision->vdev = NULL;
5448         }
5449 }
5450
5451 // register video4linux devices
5452 static int __devinit usbvision_register_video(struct usb_usbvision *usbvision)
5453 {
5454         // Video Device:
5455         usbvision->vdev = usbvision_vdev_init(usbvision, &usbvision_video_template, "USBVision Video");
5456         if (usbvision->vdev == NULL) {
5457                 goto err_exit;
5458         }
5459         if (video_register_device(usbvision->vdev, VFL_TYPE_GRABBER, video_nr)<0) {
5460                 goto err_exit;
5461         }
5462         info("USBVision[%d]: registered USBVision Video device /dev/video%d [v4l2]", usbvision->nr,usbvision->vdev->minor & 0x1f);
5463
5464         // Radio Device:
5465         if (usbvision_device_data[usbvision->DevModel].Radio) {
5466                 // usbvision has radio
5467                 usbvision->rdev = usbvision_vdev_init(usbvision, &usbvision_radio_template, "USBVision Radio");
5468                 if (usbvision->rdev == NULL) {
5469                         goto err_exit;
5470                 }
5471                 if (video_register_device(usbvision->rdev, VFL_TYPE_RADIO, radio_nr)<0) {
5472                         goto err_exit;
5473                 }
5474                 info("USBVision[%d]: registered USBVision Radio device /dev/radio%d [v4l2]", usbvision->nr, usbvision->rdev->minor & 0x1f);
5475         }
5476         // vbi Device:
5477         if (usbvision_device_data[usbvision->DevModel].vbi) {
5478                 usbvision->vbi = usbvision_vdev_init(usbvision, &usbvision_vbi_template, "USBVision VBI");
5479                 if (usbvision->vdev == NULL) {
5480                         goto err_exit;
5481                 }
5482                 if (video_register_device(usbvision->vbi, VFL_TYPE_VBI, vbi_nr)<0) {
5483                         goto err_exit;
5484                 }
5485                 info("USBVision[%d]: registered USBVision VBI device /dev/vbi%d [v4l2] (Not Working Yet!)", usbvision->nr,usbvision->vbi->minor & 0x1f);
5486         }
5487         // all done
5488         return 0;
5489
5490  err_exit:
5491         err("USBVision[%d]: video_register_device() failed", usbvision->nr);
5492         usbvision_unregister_video(usbvision);
5493         return -1;
5494 }
5495
5496 /*
5497  * usbvision_alloc()
5498  *
5499  * This code allocates the struct usb_usbvision. It is filled with default values.
5500  *
5501  * Returns NULL on error, a pointer to usb_usbvision else.
5502  *
5503  */
5504 static struct usb_usbvision *usbvision_alloc(struct usb_device *dev)
5505 {
5506         struct usb_usbvision *usbvision;
5507
5508         if ((usbvision = kzalloc(sizeof(struct usb_usbvision), GFP_KERNEL)) == NULL) {
5509                 goto err_exit;
5510         }
5511
5512         usbvision->dev = dev;
5513
5514         init_MUTEX(&usbvision->lock);   /* to 1 == available */
5515
5516         // prepare control urb for control messages during interrupts
5517         usbvision->ctrlUrb = usb_alloc_urb(USBVISION_URB_FRAMES, GFP_KERNEL);
5518         if (usbvision->ctrlUrb == NULL) {
5519                 goto err_exit;
5520         }
5521         init_waitqueue_head(&usbvision->ctrlUrb_wq);
5522         init_MUTEX(&usbvision->ctrlUrbLock);    /* to 1 == available */
5523
5524         init_timer(&usbvision->powerOffTimer);
5525         usbvision->powerOffTimer.data = (long) usbvision;
5526         usbvision->powerOffTimer.function = usbvision_powerOffTimer;
5527
5528         return usbvision;
5529
5530 err_exit:
5531         if (usbvision && usbvision->ctrlUrb) {
5532                 usb_free_urb(usbvision->ctrlUrb);
5533         }
5534         if (usbvision) {
5535                 kfree(usbvision);
5536         }
5537         return NULL;
5538 }
5539
5540 /*
5541  * usbvision_release()
5542  *
5543  * This code does final release of struct usb_usbvision. This happens
5544  * after the device is disconnected -and- all clients closed their files.
5545  *
5546  */
5547 static void usbvision_release(struct usb_usbvision *usbvision)
5548 {
5549         PDEBUG(DBG_PROBE, "");
5550
5551         down(&usbvision->lock);
5552
5553         if (timer_pending(&usbvision->powerOffTimer)) {
5554                 del_timer(&usbvision->powerOffTimer);
5555         }
5556
5557         usbvision->usbvision_used = 0;
5558         usbvision->initialized = 0;
5559
5560         up(&usbvision->lock);
5561
5562         usbvision_remove_sysfs(usbvision->vdev);
5563         usbvision_unregister_video(usbvision);
5564         if(dga) {
5565                 if (usbvision->overlay_base) {
5566                         iounmap(usbvision->overlay_base);
5567                 }
5568         }
5569
5570         if (usbvision->ctrlUrb) {
5571                 usb_free_urb(usbvision->ctrlUrb);
5572         }
5573
5574         kfree(usbvision);
5575
5576         PDEBUG(DBG_PROBE, "success");
5577 }
5578
5579
5580 /*
5581  * usbvision_probe()
5582  *
5583  * This procedure queries device descriptor and accepts the interface
5584  * if it looks like USBVISION video device
5585  *
5586  */
5587 static int __devinit usbvision_probe(struct usb_interface *intf, const struct usb_device_id *devid)
5588 {
5589         struct usb_device *dev = interface_to_usbdev(intf);
5590         __u8 ifnum = intf->altsetting->desc.bInterfaceNumber;
5591         const struct usb_host_interface *interface;
5592         struct usb_usbvision *usbvision = NULL;
5593         const struct usb_endpoint_descriptor *endpoint;
5594         int model;
5595
5596         PDEBUG(DBG_PROBE, "VID=%#04x, PID=%#04x, ifnum=%u",
5597                                         dev->descriptor.idVendor, dev->descriptor.idProduct, ifnum);
5598         /* Is it an USBVISION video dev? */
5599         model = 0;
5600         for(model = 0; usbvision_device_data[model].idVendor; model++) {
5601                 if (le16_to_cpu(dev->descriptor.idVendor) != usbvision_device_data[model].idVendor) {
5602                         continue;
5603                 }
5604                 if (le16_to_cpu(dev->descriptor.idProduct) != usbvision_device_data[model].idProduct) {
5605                         continue;
5606                 }
5607
5608                 info("%s: %s found", __FUNCTION__, usbvision_device_data[model].ModelString);
5609                 break;
5610         }
5611
5612         if (usbvision_device_data[model].idVendor == 0) {
5613                 return -ENODEV; //no matching device
5614         }
5615         if (usbvision_device_data[model].Interface >= 0) {
5616                 interface = &dev->actconfig->interface[usbvision_device_data[model].Interface]->altsetting[0];
5617         }
5618         else {
5619                 interface = &dev->actconfig->interface[ifnum]->altsetting[0];
5620         }
5621         endpoint = &interface->endpoint[1].desc;
5622         if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_ISOC) {
5623                 err("%s: interface %d. has non-ISO endpoint!", __FUNCTION__, ifnum);
5624                 err("%s: Endpoint attribures %d", __FUNCTION__, endpoint->bmAttributes);
5625                 return -ENODEV;
5626         }
5627         if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) {
5628                 err("%s: interface %d. has ISO OUT endpoint!", __FUNCTION__, ifnum);
5629                 return -ENODEV;
5630         }
5631
5632         usb_get_dev(dev);
5633
5634         if ((usbvision = usbvision_alloc(dev)) == NULL) {
5635                 err("%s: couldn't allocate USBVision struct", __FUNCTION__);
5636                 return -ENOMEM;
5637         }
5638         if (dev->descriptor.bNumConfigurations > 1) {
5639                 usbvision->bridgeType = BRIDGE_NT1004;
5640         }
5641         else if (usbvision_device_data[model].ModelString == "Dazzle Fusion Model DVC-90 Rev 1 (SECAM)") {
5642                 usbvision->bridgeType = BRIDGE_NT1005;
5643         }
5644         else {
5645                 usbvision->bridgeType = BRIDGE_NT1003;
5646         }
5647         PDEBUG(DBG_PROBE, "bridgeType %d", usbvision->bridgeType);
5648
5649         down(&usbvision->lock);
5650
5651         usbvision->nr = usbvision_nr++;
5652
5653         usbvision->have_tuner = usbvision_device_data[model].Tuner;
5654         if (usbvision->have_tuner) {
5655                 usbvision->tuner_type = usbvision_device_data[model].TunerType;
5656         }
5657
5658         usbvision->DevModel = model;
5659         usbvision->remove_pending = 0;
5660         usbvision->last_error = 0;
5661         usbvision->iface = ifnum;
5662         usbvision->ifaceAltInactive = 0;
5663         usbvision->ifaceAltActive = 1;
5664         usbvision->video_endp = endpoint->bEndpointAddress;
5665         usbvision->isocPacketSize = 0;
5666         usbvision->usb_bandwidth = 0;
5667         usbvision->user = 0;
5668
5669         usbvision_register_video(usbvision);
5670         usbvision_configure_video(usbvision);
5671         up(&usbvision->lock);
5672
5673
5674         usb_set_intfdata (intf, usbvision);
5675         usbvision_create_sysfs(usbvision->vdev);
5676
5677         PDEBUG(DBG_PROBE, "success");
5678         return 0;
5679 }
5680
5681
5682 /*
5683  * usbvision_disconnect()
5684  *
5685  * This procedure stops all driver activity, deallocates interface-private
5686  * structure (pointed by 'ptr') and after that driver should be removable
5687  * with no ill consequences.
5688  *
5689  */
5690 static void __devexit usbvision_disconnect(struct usb_interface *intf)
5691 {
5692         struct usb_usbvision *usbvision = usb_get_intfdata(intf);
5693
5694         PDEBUG(DBG_PROBE, "");
5695
5696         if (usbvision == NULL) {
5697                 err("%s: usb_get_intfdata() failed", __FUNCTION__);
5698                 return;
5699         }
5700         usb_set_intfdata (intf, NULL);
5701
5702         down(&usbvision->lock);
5703
5704         // At this time we ask to cancel outstanding URBs
5705         usbvision_stop_isoc(usbvision);
5706
5707         if (usbvision->power) {
5708                 usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
5709                 usbvision_power_off(usbvision);
5710         }
5711         usbvision->remove_pending = 1;  // Now all ISO data will be ignored
5712
5713         usb_put_dev(usbvision->dev);
5714         usbvision->dev = NULL;  // USB device is no more
5715
5716         wake_up_interruptible(&usbvision->wait_frame);
5717         wake_up_interruptible(&usbvision->wait_stream);
5718
5719         up(&usbvision->lock);
5720
5721         if (usbvision->user) {
5722                 info("%s: In use, disconnect pending", __FUNCTION__);
5723         }
5724         else {
5725                 usbvision_release(usbvision);
5726         }
5727
5728         PDEBUG(DBG_PROBE, "success");
5729
5730 }
5731
5732 static struct usb_driver usbvision_driver = {
5733         .name           = "usbvision",
5734         .id_table       = usbvision_table,
5735         .probe          = usbvision_probe,
5736         .disconnect     = usbvision_disconnect
5737 };
5738
5739 /*
5740  * customdevice_process()
5741  *
5742  * This procedure preprocesses CustomDevice parameter if any
5743  *
5744  */
5745 void customdevice_process(void)
5746 {
5747         usbvision_device_data[0]=usbvision_device_data[1];
5748         usbvision_table[0]=usbvision_table[1];
5749
5750         if(CustomDevice)
5751         {
5752                 char *parse=CustomDevice;
5753
5754                 PDEBUG(DBG_PROBE, "CustomDevide=%s", CustomDevice);
5755
5756                 /*format is CustomDevice="0x0573 0x4D31 0 7113 3 PAL 1 1 1 5 -1 -1 -1 -1 -1"
5757                 usbvision_device_data[0].idVendor;
5758                 usbvision_device_data[0].idProduct;
5759                 usbvision_device_data[0].Interface;
5760                 usbvision_device_data[0].Codec;
5761                 usbvision_device_data[0].VideoChannels;
5762                 usbvision_device_data[0].VideoNorm;
5763                 usbvision_device_data[0].AudioChannels;
5764                 usbvision_device_data[0].Radio;
5765                 usbvision_device_data[0].Tuner;
5766                 usbvision_device_data[0].TunerType;
5767                 usbvision_device_data[0].Vin_Reg1;
5768                 usbvision_device_data[0].Vin_Reg2;
5769                 usbvision_device_data[0].X_Offset;
5770                 usbvision_device_data[0].Y_Offset;
5771                 usbvision_device_data[0].Dvi_yuv;
5772                 usbvision_device_data[0].ModelString;
5773                 */
5774
5775                 rmspace(parse);
5776                 usbvision_device_data[0].ModelString="USBVISION Custom Device";
5777
5778                 parse+=2;
5779                 sscanf(parse,"%x",&usbvision_device_data[0].idVendor);
5780                 goto2next(parse);
5781                 PDEBUG(DBG_PROBE, "idVendor=0x%.4X", usbvision_device_data[0].idVendor);
5782                 parse+=2;
5783                 sscanf(parse,"%x",&usbvision_device_data[0].idProduct);
5784                 goto2next(parse);
5785                 PDEBUG(DBG_PROBE, "idProduct=0x%.4X", usbvision_device_data[0].idProduct);
5786                 sscanf(parse,"%d",&usbvision_device_data[0].Interface);
5787                 goto2next(parse);
5788                 PDEBUG(DBG_PROBE, "Interface=%d", usbvision_device_data[0].Interface);
5789                 sscanf(parse,"%d",&usbvision_device_data[0].Codec);
5790                 goto2next(parse);
5791                 PDEBUG(DBG_PROBE, "Codec=%d", usbvision_device_data[0].Codec);
5792                 sscanf(parse,"%d",&usbvision_device_data[0].VideoChannels);
5793                 goto2next(parse);
5794                 PDEBUG(DBG_PROBE, "VideoChannels=%d", usbvision_device_data[0].VideoChannels);
5795
5796                 switch(*parse)
5797                 {
5798                         case 'P':
5799                                 PDEBUG(DBG_PROBE, "VideoNorm=PAL");
5800                                 usbvision_device_data[0].VideoNorm=VIDEO_MODE_PAL;
5801                                 break;
5802
5803                         case 'S':
5804                                 PDEBUG(DBG_PROBE, "VideoNorm=SECAM");
5805                                 usbvision_device_data[0].VideoNorm=VIDEO_MODE_SECAM;
5806                                 break;
5807
5808                         case 'N':
5809                                 PDEBUG(DBG_PROBE, "VideoNorm=NTSC");
5810                                 usbvision_device_data[0].VideoNorm=VIDEO_MODE_NTSC;
5811                                 break;
5812
5813                         default:
5814                                 PDEBUG(DBG_PROBE, "VideoNorm=PAL (by default)");
5815                                 usbvision_device_data[0].VideoNorm=VIDEO_MODE_PAL;
5816                                 break;
5817                 }
5818                 goto2next(parse);
5819
5820                 sscanf(parse,"%d",&usbvision_device_data[0].AudioChannels);
5821                 goto2next(parse);
5822                 PDEBUG(DBG_PROBE, "AudioChannels=%d", usbvision_device_data[0].AudioChannels);
5823                 sscanf(parse,"%d",&usbvision_device_data[0].Radio);
5824                 goto2next(parse);
5825                 PDEBUG(DBG_PROBE, "Radio=%d", usbvision_device_data[0].Radio);
5826                 sscanf(parse,"%d",&usbvision_device_data[0].Tuner);
5827                 goto2next(parse);
5828                 PDEBUG(DBG_PROBE, "Tuner=%d", usbvision_device_data[0].Tuner);
5829                 sscanf(parse,"%d",&usbvision_device_data[0].TunerType);
5830                 goto2next(parse);
5831                 PDEBUG(DBG_PROBE, "TunerType=%d", usbvision_device_data[0].TunerType);
5832                 sscanf(parse,"%d",&usbvision_device_data[0].Vin_Reg1);
5833                 goto2next(parse);
5834                 PDEBUG(DBG_PROBE, "Vin_Reg1=%d", usbvision_device_data[0].Vin_Reg1);
5835                 sscanf(parse,"%d",&usbvision_device_data[0].Vin_Reg2);
5836                 goto2next(parse);
5837                 PDEBUG(DBG_PROBE, "Vin_Reg2=%d", usbvision_device_data[0].Vin_Reg2);
5838                 sscanf(parse,"%d",&usbvision_device_data[0].X_Offset);
5839                 goto2next(parse);
5840                 PDEBUG(DBG_PROBE, "X_Offset=%d", usbvision_device_data[0].X_Offset);
5841                 sscanf(parse,"%d",&usbvision_device_data[0].Y_Offset);
5842                 goto2next(parse);
5843                 PDEBUG(DBG_PROBE, "Y_Offset=%d", usbvision_device_data[0].Y_Offset);
5844                 sscanf(parse,"%d",&usbvision_device_data[0].Dvi_yuv);
5845                 PDEBUG(DBG_PROBE, "Dvi_yuv=%d", usbvision_device_data[0].Dvi_yuv);
5846
5847                 //add to usbvision_table also
5848                 usbvision_table[0].match_flags=USB_DEVICE_ID_MATCH_DEVICE;
5849                 usbvision_table[0].idVendor=usbvision_device_data[0].idVendor;
5850                 usbvision_table[0].idProduct=usbvision_device_data[0].idProduct;
5851
5852         }
5853 }
5854
5855
5856
5857 /*
5858  * usbvision_init()
5859  *
5860  * This code is run to initialize the driver.
5861  *
5862  */
5863 static int __init usbvision_init(void)
5864 {
5865         int errCode;
5866
5867         PDEBUG(DBG_PROBE, "");
5868
5869         PDEBUG(DBG_IOCTL, "IOCTL   debugging is enabled");
5870         PDEBUG(DBG_IO,  "IO      debugging is enabled");
5871         PDEBUG(DBG_RIO,  "RIO     debugging is enabled");
5872         PDEBUG(DBG_HEADER, "HEADER  debugging is enabled");
5873         PDEBUG(DBG_PROBE, "PROBE   debugging is enabled");
5874         PDEBUG(DBG_IRQ,  "IRQ     debugging is enabled");
5875         PDEBUG(DBG_ISOC, "ISOC    debugging is enabled");
5876         PDEBUG(DBG_PARSE, "PARSE   debugging is enabled");
5877         PDEBUG(DBG_SCRATCH, "SCRATCH debugging is enabled");
5878         PDEBUG(DBG_FUNC, "FUNC    debugging is enabled");
5879         PDEBUG(DBG_I2C,  "I2C     debugging is enabled");
5880
5881         /* disable planar mode support unless compression enabled */
5882         if (isocMode != ISOC_MODE_COMPRESS ) {
5883                 // FIXME : not the right way to set supported flag
5884                 usbvision_v4l2_format[6].supported = 0; // V4L2_PIX_FMT_YVU420
5885                 usbvision_v4l2_format[7].supported = 0; // V4L2_PIX_FMT_YUV422P
5886         }
5887
5888         customdevice_process();
5889
5890         errCode = usb_register(&usbvision_driver);
5891
5892         if (errCode == 0) {
5893                 info(DRIVER_DESC " : " DRIVER_VERSION);
5894                 PDEBUG(DBG_PROBE, "success");
5895         }
5896         return errCode;
5897 }
5898
5899 static void __exit usbvision_exit(void)
5900 {
5901  PDEBUG(DBG_PROBE, "");
5902
5903  usb_deregister(&usbvision_driver);
5904  PDEBUG(DBG_PROBE, "success");
5905 }
5906
5907 module_init(usbvision_init);
5908 module_exit(usbvision_exit);
5909
5910 /*
5911  * Overrides for Emacs so that we follow Linus's tabbing style.
5912  * ---------------------------------------------------------------------------
5913  * Local variables:
5914  * c-basic-offset: 8
5915  * End:
5916  */