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

/*
 * USB USBVISION Video device driver 0.9.8.3cvs (For Kernel 2.4.19-2.4.32 + 2.6.0-2.6.16)
 *
 * 
 *
 * Copyright (c) 1999-2005 Joerg Heckenbach <joerg@heckenbach-aw.de>
 *
 * This module is part of usbvision driver project.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * Let's call the version 0.... until compression decoding is completely
 * implemented.
 *
 * This driver is written by Jose Ignacio Gijon and Joerg Heckenbach.
 * It was based on USB CPiA driver written by Peter Pregler,
 * Scott J. Bertin and Johannes Erdfelt
 * Ideas are taken from bttv driver by Ralph Metzler, Marcus Metzler &
 * Gerd Knorr and zoran 36120/36125 driver by Pauline Middelink
 * Updates to driver completed by Dwaine P. Garden
 *
 * History:
 *
 * Mar. 2000 - 15.12.2000:  (0.0.0 - 0.2.0)
 *     Several alpha drivers and the first beta.
 *
 * Since Dec. 2000:  (0.2.1) or (v2.1)
 *     Code changes or updates by Dwaine Garden and every other person.
 *
 *     Added: New Hauppauge TV device  Vendor  ID: 0x0573
 *                                     Product ID: 0x4D01
 *            (Thanks to Giovanni Garberoglio)
 *
 *     Added: UK Hauppauge WinTV-USB   Vendor  ID: 0x0573
 *                                     Product ID: 0x4D02
 *            (Thanks to Derek Freeman-Jones)
 *
 * Feb, 2001 - Apr 08, 2001:  (0.3.0)
 *     - Some fixes. Driver is now more stable.
 *     - Scratch is organized as ring-buffer now for better performance
 *     - DGA (overlay) is now supported.
 *       !!!!Danger!!!! Clipping is not yet implemented. Your system will
 *       crash if your video window leaves the screen!!!
 *     - Max. Framesize is set to 320x240. There isn't more memory on the
 *       nt1003 video device for the FIFO.
 *     - Supported video palettes: RGB565, RGB555, RGB24, RGB32
 *
 *
 * Apr 15, 2001:  (0.3.1-test...)
 *     - Clipping is implemented
 *     - NTSC is now coloured (Thanks to Dwaine Garden)
 *     - Added SECAM colour detection in saa7111-new
 *     - Added: French Hauppauge WinTV USB  Vendor ID: 0x0573
 *                                          Product ID: 0x4D03
 *              (Thanks to Julius Hrivnac)
 *     - Added: US Hauppauge WINTV USB  Vendor ID: 0x0573
 *                                      Product ID: 0x4D00
 *              (Thanks to  Derrick J Brashear)
 *     - Changes for adding new devices. There's now a table in usbvision.h.
 *       Adding your devices data to the usbvision_device_data table is all
 *       you need to add a new device.
 *
 * May 11, 2001: (0.3.2-test...) (Thanks to Derek Freeman-Jones)
 *     - Support YUV422 raw format for people with hardware scaling.
 *     - Only power on the device when opened (use option PowerOnAtOpen=0 to disable it).
 *     - Turn off audio so we can listen to Line In.
 *
 * July 5, 2001 - (Patch the driver to run with Kernel 2.4.6)
 *     - Fixed a problem with the number of parameters passed to video_register_device.
 *
 * July 6, 2001 - Added: HAUPPAUGE WINTV-USB FM USA Vendor  ID: 0x0573
 *                                              	Product ID: 0x4D10
 *       (Thanks to Braddock Gaskill)
 *                Added: USBGear USBG-V1 resp. HAMA USB
 *                                      Vendor  ID: 0x0573
 *                                      Product ID: 0x0003
 *       (Thanks to Bradley A. Singletary and Juergen Weigert)
 *
 * Jan 24, 2002 - (0.3.3-test...)
 *     - Moved all global variables that are device specific the usb_usbvision struct
 *     - Fixed the 64x48 unchangable image in xawtv when starting it with overlay
 *     - Add VideoNorm and TunerType to the usb_device_data table
 *     - Checked the audio channels and mute for HAUPPAUGE WinTV USB FM
 *     - Implemented the power on when opening the device. But some software opens
 *       the device several times when starting. So the i2c parts are just registered
 *       by an open, when they become deregistered by the next close. You can speed
 *       up tuner detection, when adding "options tuner addr=your_addr" to /etc/modules.conf
 *     - Begin to resize the frame in width and height. So it will be possible to watch i.e.
 *       384x288 pixels at 23 fps.
 *
 * Feb 10, 2002
 *     - Added radio device
 *
 *
 * Jul 30, 2002 - (Thanks Cameron Maxwell)
 *     - Changes to usbvision.h --fixed usbvision device data structure, incorrectly had (0x0573, 0x4d21) for WinTV-USB II, should be 0x4d20.
 *     - Changes for device WinTV-USB II (0x0573. 0x4D21).  It does not have a FM tuner.
 *     - Added the real device HAUPPAUGE WINTV-USB II (PAL) to the device structure in usbvision.h.
 *     - Changes to saa7113-new, the video is 8 bit data for the Phillips SAA7113 not 16bit like SAA7111.
 *     - Tuned lots of setup registers for the Phillips SAA7113 video chipset.
 *     - Changes to the supplied makefile. (Dwaine Garden) Still needs to be fixed so it will compile modules on different distrubutions.
 *
 *
 * Aug 10, 2002 - (Thanks Mike Klinke)
 *     - Changes to usbvision.txt -- Fixed instructions on the location to copy the contents of the tgz file.
 *     - 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.
 *
 * Aug 12, 2002 - Dwaine Garden
 *     - Added the ability to read the NT100x chip for the MaxISOPacketLength and USB Bandwidth
 *       Setting of the video device.
 *     - Adjustments to the SAA7113H code for proper video output.
 *     - Changes to usbvision.h, so all the devices with FM tuners are working.
 *
 * Feb 10, 2003 - Joerg Heckenbach
 *     - fixed endian bug for Motorola PPC
 *
 * Feb 13, 2003 - Joerg Heckenbach
 *     - fixed Vin_Reg setting and presetting from usbvision_device_data()
 *
 * Apr 19, 2003 - Dwaine Garden
 *     - Fixed compiling errors under RedHat v9.0. from uvirt_to_kva and usbvision_mmap. (Thanks Cameron Maxwell)
 *     - Changed pte_offset to pte_offset_kernel.
 *     - Changed remap_page_range and added additional parameter to function.
 *     - Change setup parameters for the D-Link V100 USB device
 *     - Added a new device to the usbvision driver.  Pinnacle Studio PCTV USB (PAL) 0x2304 0x0110
 *     - Screwed up the sourceforge.net cvs respository!  8*)
 *
 * Apr 22, 2002 - Dwaine Garden
 *     - Added a new device to the usbvision driver. Dazzle DVC-80 (PAL) 0x07d0 0x0004. (Thanks Carl Anderson)
 *     - Changes to some of the comments.
 *
 * June 06, 2002 - Ivan, Dwaine Garden
 *     - Ivan updates for fine tuning device parameters without driver recompiling. (Ivan)
 *     - Changes to some of the comments. (Dwaine Garden)
 *     - Changes to the makefile - Better CPU settings. (Ivan)
 *     - Changes to device Hauppauge WinTv-USB III (PAL) FM Model 568 - Fine tuning parameters (Ivan)
 *
 *
 * Oct 16, 2003 - 0.9.0 - Joerg Heckenbach
 *     - Implementation of the first part of the decompression algorithm for intra frames.
 *       The resolution has to be 320x240. A dynamic adaption of compression deepth is
 *       missing yet.
 *
 * Oct 22, 2003 - 0.9.1 - Joerg Heckenbach
 *     - Implementation of the decompression algorithm for inter frames.
 *       The resolution still has to be 320x240.
 *
 * Nov 2003 - Feb 2004 - 0.9.2 to 0.9.3 - Joerg Heckenbach
 *     - Implement last unknown compressed block type. But color is still noisy.
 *     - Finding criteria for adaptive compression adjustment.
 *     - Porting to 2.6 kernels, but still working under 2.4
 *
 * Feb 04, 2004 - 0.9.4 Joerg Heckenbach
 *     - Found bug in color decompression. Color is OK now.
 *
 * Feb 09, 2004 - 0.9.5 Joerg Heckenbach
 *     - Add auto-recognition of chip type NT1003 or NT1004.
 *     - Add adaptive compression adjustment.
 *     - Patched saa7113 multiplexer switching (Thanks to Orlando F.S. Bordoni)
 *
 * Feb 24, 2004 - 0.9.6 Joerg Heckenbach
 *     - Add a timer to wait before poweroff at close, to save start time in
 *       some video applications
 *
 * Mar 4, 2004 - 0.9.6 Dwaine Garden
 *     - Added device Global Village GV-007 (NTSC) to usbvision.h (Thanks to Abe Skolnik)
 *     - Forgot to add this device to the driver. 8*)
 *
 * June 2, 2004 - 0.9.6 Dwaine Garden
 *     - Fixed sourceforge.net cvs repository.
 *     - 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.
 *     - Added device Hauppauge WinTv-USB III (PAL) FM Model 597 to usbvision.h	
 *
 * July 1, 2004 -0.9.6 Dwaine Garden
 *     - Patch was submitted by Hal Finkel to fix the problem with the tuner not working under kernel 2.6.7.
 *     - Thanks Hal.....
 *
 * July 30, 2004 - 0.9.6 Dwaine Garden
 *     - Patch was submitted by Tobias Diaz to fix Model ID mismatch in usbvision.h.
 *     - Thanks.....
 *
 * August 12, 2004 - 0.9.6 Dwaine Garden
 *     - 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!
 *     - Added new device "Camtel Technology Corp TVB330-USB FM".
 *     - Sourceforge.net CVS has been updated with all the changes.
 *
 * August 20, 2004 - 0.9.7 Dwaine Garden
 *     - Added Device "Hauppauge USB Live Model 600"
 *     - 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.
 *     - Sourceforge.net CVS has been updated with all the changes.
 *     - Clean up the driver.
 *
 * September 13, 2004 - 0.9.8 Dwaine Garden
 *     - 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.
 *     - 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.
 *     - Removed some commented out code.  Clean up.
 *     - Tried to fix up the annoying empty directories in the sourceforge.net cvs.   Fuck it up again.  8*(	
 *
 * November 15, 2004 - 0.9.8 Dwaine Garden
 *     - Release new tar - 0.9.8 on sourceforge.net
 *     - Added some new devices to usbvision.h WinTV USB Model 602 40201 Rev B282, Hauppague WinTV USB Model 602 40201 Rev B285
 *     - Added better compatibility for 2.6.x kernels.
 *     - Hardware full screen scaling in grabdisplay mode.
 *     - Better support for sysfs.  More code to follow for both video device and radio device.	Device information is located at /sys/class/video4linux/video0
 *     - Added module_param so loaded module parameters are displayed in sysfs.  Driver parameters should show up in /sys/module/usbvision
 *     - Adjusted the SAA7111 registers to match the 2.6.x kernel SAA7111 code. Thanks to the person which helped test.
 *     - Changed to wait_event_interruptible. For all the people running Fedora 2.
 *     - Added some screenshots of actual video captures on sourceforge.net.
 *
 * November 24, 2004 - 0.9.8.1cvs Dwaine Garden
 *     - Added patch to check for palette and format in VIDIOCSPICT.  Helix Producer should work fine with the driver now.  Thanks Jason Simpson
 *     - Two device description changes and two additions for the maintainer of usb.ids.
 *
 * December 2, 2004 - 0.9.8.1cvs Dwaine Garden
 *     - Added patch for YUV420P and YUV422P video output.  Thanks to Alex Smith.
 *     - Better support for mythtv.
 *
 * January 2, 2005 - 0.9.8.1cvs Dwaine Garden
 *     - Setup that you can specify which device is used for video.  Default is auto detect next available device number eg.  /dev/videoX  
 *     - Setup that you can specify which device is used for radio.  Default is auto detect next available device number eg.  /dev/radioX
 *     - usb_unlink_urb() is deprecated for synchronous unlinks.  Using usb_kill_urb instead.
 *     - usbvision_kvirt_to_pa is deprecated.  Removed.
 *     - Changes are related to kernel changes for 2.6.10. (Fedora 4)
 *
 * February 2, 2005 - 0.9.8.1cvs Dwaine Garden
 *     - Added a new device to usbvision.h Dazzle DVC 50.  Thanks to Luiz S.
 *
 * March 29, 2005 - 0.9.8.1cvs Dwaine Garden
 *     - Fixed compile error with saa7113 under kernels 2.6.11+
 *     - Added module parameter to help people with Black and White output with using s-video input.  Some cables and input device are wired differently.
 *     - Removed the .id from the i2c usbvision template.  There was a change to the i2c with kernels 2.6.11+.
 *
 * April 9, 2005 - 0.9.8.1cvs Dwaine Garden
 *     - 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.
 *       If your device experiences Black and White images with the S-Video Input.  Set this parameter to 1 when loading the module.
 *     - Replaced the wrong 2.6 readme file.  I lost the right version.  Someone sent me the right version by e-mail.  Thanks.
 *     - Released new module version on sourceforge.net.  So everyone can enjoy all the fixes and additional device support.
 *
 * April 20, 2005 - 0.9.8.2cvs Dwaine Garden
 *     - Release lock in usbvision_v4l_read_done.  -Thanks to nplanel for the patch.
 *     - Additional comments to the driver.
 *     - Fixed some spelling mistakes.  8*)	
 *
 * April 23, 2005 - 0.9.8.2cvs Joerg Heckenbach
 *     - Found bug in usbvision line counting. Now there should be no spurious lines in the image any longer.
 *     - Swapped usbvision_register_video and usbvision_configure_video to fix problem with PowerOnAtOpen=0. 
 *       Thanks to Erwan Velu
 *
 * April 26, 2005 - 0.9.8.2cvs Joerg Heckenbach
 *     - Fixed problem with rmmod module and oppses. Replaced vfree(usbvision->overlay_base) with iounmap(usbvision->overlay_base).
 *     - Added function usb_get_dev(dev) and ; To help with unloading the module multiple times without crashing. 
 *       (Keep the reference count in kobjects correct)
 *
 * June 14, 2005 - 0.9.8.2cvs Dwaine
 *     - Missed a change in saa7113.c for checking kernel version.  Added conditional if's.    
 *
 * June 15, 2005 - 0.9.8.2cvs Dwaine
 *     - Added new device WinTV device VendorId 0573 and ProductId 4d29.    
 *     - Hacked some support for newer NT1005 devices.  This devices only seem to have one configuration, not multiple configurations like the NT1004.
 *
 * June 29, 2005 - 0.9.8.2cvs Dwaine
 *     - Added new device WinTV device VendorId 0573 and ProductId 4d37.   
 *     - Because of the first empty entry in usbvision_table, modutils failed to create the necessary entries for modules.usbmap. 
 *       This means hotplug won't work for usbvision.  Thanks to Gary Ng.  
 *     - Sent an e-mail to the maintainer of usb.ids.  New devices identified need to be added.
 *     - Fixed compile error with saa7113 under kernel 2.6.12.	
 *
 * July 6, 2005 - 0.9.8.2cvs Dwaine
 *     - Patch submitted by Gary Ng for two additional procfs entries.  Device Input and Frequency setting.  
 *
 * July 12, 2005 - 0.9.8.2cvs Dwaine
 *     - New tuner identified for some devices it's called TCL_MFPE05.  This tuner uses the same API as tuner 38 in tuner.c.
 *     - Thanks to lynx31 for contacting Hauppage and asking them.
 *     - I have no clue as to which devices use this new tuner, so people will have to contact me and tell me.  
 *
 * July 21, 2005 - 0.9.8.2cvs Dwaine
 *     - Patched usbvision.c with missing ifdef kernversion statement so the module will compile with older kernels and v4l.
 *     - Thanks to cipe007......
 *
 * May 19, 2006 - 0.9.8.3cvs Dwaine
 *     - Patched usbvision.c and i2c-algo.c so they will compile with kernel 2.6.16
 *     - Adjust device "Pinnacle Studio PCTV USB (PAL) FM" values in usbvision.h
 *
 * May 24, 2006 - 0.9.8.3cvs Dwaine
 *     -Pinnacle Studio PCTV USB (NTSC) FM uses saa7111, not saa7113 like first thought.
 *     -Updated usbvision.h
 *
 * Aug 15, 2006 - 0.9.8.3cvs Dwaine
 *     -Added saa711x module into cvs, since the newer saa7115 module in newer kernels is v4l2.  The usbvision driver is only v4l.
 *     -Updated makefile to put compiled modules into correct location.
 *
 * Aug 21, 2006 - 0.9.8.3cvs Dwaine
 *     -Changed number of bytes for i2c write to 4 as per the NT100X spec sheet.  Thanks to Merlum for finding it.
 *     -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.
 *     -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*)
 *   
 * Aug 27, 2006 - 0.9.8.3cvs Dwaine
 *     -Changed ifdef statement so the usbvision driver will compile with kernels at 2.6.12.
 *     -Updated readme files for new updated tuner list for v4l devices.
 *      
 *
 *
 * TODO:
 *     - use submit_urb for all setup packets
 *     - Fix memory settings for nt1004. It is 4 times as big as the
 *       nt1003 memory.
 *     - Add audio on endpoint 3 for nt1004 chip.  Seems impossible, needs a codec interface.  Which one?
 *     - Clean up the driver.
 *     - optimization for performance.
 *     - Add Videotext capability (VBI).  Working on it.....
 *     - Check audio for other devices
 *     - Add v4l2 interface
 *
 */

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/utsname.h>
#include <linux/highmem.h>
#include <linux/smp_lock.h>
#include <linux/videodev.h>
#include <linux/vmalloc.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/usb.h>
#include <asm/io.h>
#include <linux/videodev2.h>
#include <linux/video_decoder.h>
#include <linux/i2c.h>
#include "usbvision-i2c.h"

#define USBVISION_DRIVER_VERSION_MAJOR 0
#define USBVISION_DRIVER_VERSION_MINOR 8
#define USBVISION_DRIVER_VERSION_PATCHLEVEL 0

#define USBVISION_VERSION __stringify(USBVISION_DRIVER_VERSION_MAJOR) "." __stringify(USBVISION_DRIVER_VERSION_MINOR) "." __stringify(USBVISION_DRIVER_VERSION_PATCHLEVEL) " " USBVISION_DRIVER_VERSION_COMMENT
#define USBVISION_DRIVER_VERSION KERNEL_VERSION(USBVISION_DRIVER_VERSION_MAJOR,USBVISION_DRIVER_VERSION_MINOR,USBVISION_DRIVER_VERSION_PATCHLEVEL)

#include <media/saa7115.h> 
#include <media/v4l2-common.h> 
#include <media/tuner.h>
#include <media/audiochip.h>

	#include <linux/moduleparam.h>
	#include <linux/workqueue.h>

#ifdef CONFIG_KMOD
#include <linux/kmod.h>
#endif

#include "usbvision.h"
#include "usbvision_ioctl.h"


#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__
#define EMAIL "joerg@heckenbach-aw.de"
#define DRIVER_AUTHOR "Joerg Heckenbach <joerg@heckenbach-aw.de>, Dwaine Garden <DwaineGarden@rogers.com>"
#define DRIVER_DESC "USBVision USB Video Device Driver for Linux"
#define DRIVER_LICENSE "GPL"
#define DRIVER_ALIAS "USBVision"

#define	ENABLE_HEXDUMP	0	/* Enable if you need it */


#define USBVISION_DEBUG		/* Turn on debug messages */

#ifdef USBVISION_DEBUG
	#define PDEBUG(level, fmt, args...) \
		if (debug & (level)) info("[%s:%d] " fmt, __PRETTY_FUNCTION__, __LINE__ , ## args)
#else
	#define PDEBUG(level, fmt, args...) do {} while(0)
#endif

#define DBG_IOCTL	1<<3
#define DBG_IO		1<<4
#define DBG_RIO		1<<5
#define DBG_HEADER	1<<7
#define DBG_PROBE	1<<8
#define DBG_IRQ		1<<9
#define DBG_ISOC	1<<10
#define DBG_PARSE	1<<11
#define DBG_SCRATCH	1<<12
#define DBG_FUNC	1<<13
#define DBG_I2C		1<<14

#define DEBUG(x...) 								/* General Debug */
#define IODEBUG(x...)								/* Debug IO */
#define OVDEBUG(x...) 								/* Debug overlay */
#define MDEBUG(x...)								/* Debug memory management */

//String operations
#define rmspace(str)	while(*str==' ') str++;
#define goto2next(str)	while(*str!=' ') str++; while(*str==' ') str++;


static int usbvision_nr = 0;			// sequential number of usbvision device


static const int max_imgwidth = MAX_FRAME_WIDTH;
static const int max_imgheight = MAX_FRAME_HEIGHT;
static const int min_imgwidth = MIN_FRAME_WIDTH;
static const int min_imgheight = MIN_FRAME_HEIGHT;

#define FRAMERATE_MIN	0
#define FRAMERATE_MAX	31


enum {
	ISOC_MODE_YUV422 = 0x03,
	ISOC_MODE_YUV420 = 0x14,
	ISOC_MODE_COMPRESS = 0x60,
};

/*
 * The value of 'scratch_buf_size' affects quality of the picture
 * in many ways. Shorter buffers may cause loss of data when client
 * is too slow. Larger buffers are memory-consuming and take longer
 * to work with. This setting can be adjusted, but the default value
 * should be OK for most desktop users.
 */
#define DEFAULT_SCRATCH_BUF_SIZE	(0x20000)		// 128kB memory scratch buffer
static const int scratch_buf_size = DEFAULT_SCRATCH_BUF_SIZE;

static int init_brightness = 128;	// Initalize the brightness of the video device
static int init_contrast = 192;		// Initalize the contrast of the video device
static int init_saturation = 128;	// Initalize the staturation mode of the video device
static int init_hue = 128;		// Initalize the Hue settings of the video device

// Function prototypes
static int usbvision_restart_isoc(struct usb_usbvision *usbvision);
static int usbvision_begin_streaming(struct usb_usbvision *usbvision);
static int usbvision_muxsel(struct usb_usbvision *usbvision, int channel, int norm);
static int usbvision_i2c_write(void *data, unsigned char addr, char *buf, short len);
static int usbvision_i2c_read(void *data, unsigned char addr, char *buf, short len);
static int usbvision_read_reg(struct usb_usbvision *usbvision, unsigned char reg);
static int usbvision_write_reg(struct usb_usbvision *usbvision, unsigned char reg, unsigned char value);
static int usbvision_request_intra (struct usb_usbvision *usbvision);
static int usbvision_unrequest_intra (struct usb_usbvision *usbvision);
static int usbvision_adjust_compression (struct usb_usbvision *usbvision);
static int usbvision_measure_bandwidth (struct usb_usbvision *usbvision);
static void usbvision_release(struct usb_usbvision *usbvision);
static int usbvision_set_input(struct usb_usbvision *usbvision); 
static int usbvision_set_output(struct usb_usbvision *usbvision, int width, int height); 
static void call_i2c_clients(struct usb_usbvision *usbvision, unsigned int cmd, void *arg); 


// Bit flags (options)
#define FLAGS_RETRY_VIDIOCSYNC		(1 << 0)
#define	FLAGS_MONOCHROME		(1 << 1)
#define FLAGS_DISPLAY_HINTS		(1 << 2)
#define FLAGS_OSD_STATS			(1 << 3)
#define FLAGS_FORCE_TESTPATTERN		(1 << 4)
#define FLAGS_SEPARATE_FRAMES		(1 << 5)
#define FLAGS_CLEAN_FRAMES		(1 << 6)

// Default initalization of device driver parameters
static int flags = 0;					// Set the default Overlay Display mode of the device driver
static int debug = 0;					// Set the default Debug Mode of the device driver
static int isocMode = ISOC_MODE_COMPRESS;		// Set the default format for ISOC endpoint
static int adjustCompression = 1;			// Set the compression to be adaptive
static int dga = 1;					// Set the default Direct Graphic Access
static int PowerOnAtOpen = 1;				// Set the default device to power on at startup
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.
static int video_nr = -1;			        // Sequential Number of Video Device
static int radio_nr = -1;			        // Sequential Number of Radio Device
static int vbi_nr = -1;					// Sequential Number of VBI Device
static char *CustomDevice=NULL;				// Set as nothing....

// Grab parameters for the device driver

#if defined(module_param)                               // Showing parameters under SYSFS
module_param(flags, int, 0444);
module_param(debug, int, 0444);
module_param(isocMode, int, 0444);
module_param(adjustCompression, int, 0444);
module_param(dga, int, 0444);
module_param(PowerOnAtOpen, int, 0444);
module_param(SwitchSVideoInput, int, 0444);
module_param(video_nr, int, 0444);
module_param(radio_nr, int, 0444);
module_param(vbi_nr, int, 0444);
module_param(CustomDevice, charp, 0444);
#else							// Old Style
MODULE_PARM(flags, "i");				// Grab the Overlay Display mode of the device driver
MODULE_PARM(debug, "i");				// Grab the Debug Mode of the device driver
MODULE_PARM(isocMode, "i");				// Grab the video format of the video device
MODULE_PARM(adjustCompression, "i");			// Grab the compression to be adaptive
MODULE_PARM(dga, "i");					// Grab the Direct Graphic Access
MODULE_PARM(PowerOnAtOpen, "i");			// Grab the device to power on at startup
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.
MODULE_PARM(video_nr, "i");				// video_nr option allows to specify a certain /dev/videoX device (like /dev/video0 or /dev/video1 ...)                 
MODULE_PARM(radio_nr, "i");				// radio_nr option allows to specify a certain /dev/radioX device (like /dev/radio0 or /dev/radio1 ...)
MODULE_PARM(vbi_nr, "i");				// vbi_nr option allows to specify a certain /dev/vbiX device (like /dev/vbi0 or /dev/vbi1 ...)
MODULE_PARM(CustomDevice, "s");			        // .... CustomDevice
#endif

MODULE_PARM_DESC(flags,	" Set the default Overlay Display mode of the device driver.  Default: 0 (Off)");
MODULE_PARM_DESC(debug, " Set the default Debug Mode of the device driver.  Default: 0 (Off)");
MODULE_PARM_DESC(isocMode, " Set the default format for ISOC endpoint.  Default: 0x60 (Compression On)");
MODULE_PARM_DESC(adjustCompression, " Set the ADPCM compression for the device.  Default: 1 (On)");
MODULE_PARM_DESC(dga, " Set the Direct Graphic Access for the device.  Default: 1 (On)");
MODULE_PARM_DESC(PowerOnAtOpen, " Set the default device to power on when device is opened.  Default: 1 (On)");
MODULE_PARM_DESC(SwitchSVideoInput, " Set the S-Video input.  Some cables and input device are wired differently. Default: 0 (Off)");
MODULE_PARM_DESC(video_nr, "Set video device number (/dev/videoX).  Default: -1 (autodetect)");
MODULE_PARM_DESC(radio_nr, "Set radio device number (/dev/radioX).  Default: -1 (autodetect)");
MODULE_PARM_DESC(vbi_nr, "Set vbi device number (/dev/vbiX).  Default: -1 (autodetect)");
MODULE_PARM_DESC(CustomDevice, " Define the fine tuning parameters for the device.  Default: null");


// Misc stuff
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE(DRIVER_LICENSE);
	MODULE_VERSION(DRIVER_VERSION);
	MODULE_ALIAS(DRIVER_ALIAS); 

#ifdef MODULE
static unsigned int autoload = 1;
#else
static unsigned int autoload = 0;
#endif


/****************************************************************************************/
/* SYSFS Code - Copied from the stv680.c usb module.		                        */
/* Device information is located at /sys/class/video4linux/video0	                */
/* Device parameters information is located at /sys/module/usbvision                    */
/* Device USB Information is located at /sys/bus/usb/drivers/USBVision Video Grabber    */
/****************************************************************************************/


#define YES_NO(x) ((x) ? "Yes" : "No")

static inline struct usb_usbvision *cd_to_usbvision(struct class_device *cd)
{
	struct video_device *vdev = to_video_device(cd);
	return video_get_drvdata(vdev);
}

static ssize_t show_version(struct class_device *cd, char *buf)
{
	return sprintf(buf, "%s\n", DRIVER_VERSION);
} 
static CLASS_DEVICE_ATTR(version, S_IRUGO, show_version, NULL);

static ssize_t show_model(struct class_device *class_dev, char *buf)
{
	struct video_device *vdev = to_video_device(class_dev);	
	struct usb_usbvision *usbvision = video_get_drvdata(vdev);	
	return sprintf(buf, "%s\n", usbvision_device_data[usbvision->DevModel].ModelString);
} 
static CLASS_DEVICE_ATTR(model, S_IRUGO, show_model, NULL);

static ssize_t show_hue(struct class_device *class_dev, char *buf)
{
	struct video_device *vdev = to_video_device(class_dev);	
	struct usb_usbvision *usbvision = video_get_drvdata(vdev);	
	return sprintf(buf, "%d\n", usbvision->hue >> 8);
} 
static CLASS_DEVICE_ATTR(hue, S_IRUGO, show_hue, NULL);

static ssize_t show_contrast(struct class_device *class_dev, char *buf)
{
	struct video_device *vdev = to_video_device(class_dev);	
	struct usb_usbvision *usbvision = video_get_drvdata(vdev);	
	return sprintf(buf, "%d\n", usbvision->contrast >> 8);
} 
static CLASS_DEVICE_ATTR(contrast, S_IRUGO, show_contrast, NULL);

static ssize_t show_brightness(struct class_device *class_dev, char *buf)
{
	struct video_device *vdev = to_video_device(class_dev);	
	struct usb_usbvision *usbvision = video_get_drvdata(vdev);	
	return sprintf(buf, "%d\n", usbvision->brightness >> 8);
} 
static CLASS_DEVICE_ATTR(brightness, S_IRUGO, show_brightness, NULL);

static ssize_t show_saturation(struct class_device *class_dev, char *buf)
{
	struct video_device *vdev = to_video_device(class_dev);	
	struct usb_usbvision *usbvision = video_get_drvdata(vdev);	
	return sprintf(buf, "%d\n", usbvision->saturation >> 8);
} 
static CLASS_DEVICE_ATTR(saturation, S_IRUGO, show_saturation, NULL);

static ssize_t show_streaming(struct class_device *class_dev, char *buf)
{
	struct video_device *vdev = to_video_device(class_dev);	
	struct usb_usbvision *usbvision = video_get_drvdata(vdev);	
	return sprintf(buf, "%s\n", YES_NO(usbvision->streaming));
} 
static CLASS_DEVICE_ATTR(streaming, S_IRUGO, show_streaming, NULL);

static ssize_t show_overlay(struct class_device *class_dev, char *buf)
{
	struct video_device *vdev = to_video_device(class_dev);	
	struct usb_usbvision *usbvision = video_get_drvdata(vdev);	
	return sprintf(buf, "%s\n", YES_NO(usbvision->overlay));
} 
static CLASS_DEVICE_ATTR(overlay, S_IRUGO, show_overlay, NULL);

static ssize_t show_compression(struct class_device *class_dev, char *buf)
{
	struct video_device *vdev = to_video_device(class_dev);	
	struct usb_usbvision *usbvision = video_get_drvdata(vdev);	
	return sprintf(buf, "%s\n", YES_NO(usbvision->isocMode==ISOC_MODE_COMPRESS));
} 
static CLASS_DEVICE_ATTR(compression, S_IRUGO, show_compression, NULL);

static ssize_t show_device_bridge(struct class_device *class_dev, char *buf)
{
	struct video_device *vdev = to_video_device(class_dev);	
	struct usb_usbvision *usbvision = video_get_drvdata(vdev);	
	return sprintf(buf, "%d\n", usbvision->bridgeType);
} 
static CLASS_DEVICE_ATTR(bridge, S_IRUGO, show_device_bridge, NULL);

static void usbvision_create_sysfs(struct video_device *vdev)
{
	if (vdev) {
		video_device_create_file(vdev, &class_device_attr_version);
		video_device_create_file(vdev, &class_device_attr_model);
		video_device_create_file(vdev, &class_device_attr_hue);
		video_device_create_file(vdev, &class_device_attr_contrast);
		video_device_create_file(vdev, &class_device_attr_brightness);
		video_device_create_file(vdev, &class_device_attr_saturation);
		video_device_create_file(vdev, &class_device_attr_streaming);
		video_device_create_file(vdev, &class_device_attr_overlay);
		video_device_create_file(vdev, &class_device_attr_compression);
		video_device_create_file(vdev, &class_device_attr_bridge);
	}
}

static void usbvision_remove_sysfs(struct video_device *vdev)
{
	if (vdev) {
		video_device_remove_file(vdev, &class_device_attr_version);
		video_device_remove_file(vdev, &class_device_attr_model);
		video_device_remove_file(vdev, &class_device_attr_hue);
		video_device_remove_file(vdev, &class_device_attr_contrast);
		video_device_remove_file(vdev, &class_device_attr_brightness);
		video_device_remove_file(vdev, &class_device_attr_saturation);
		video_device_remove_file(vdev, &class_device_attr_streaming);
		video_device_remove_file(vdev, &class_device_attr_overlay);
		video_device_remove_file(vdev, &class_device_attr_compression);
		video_device_remove_file(vdev, &class_device_attr_bridge);
	}
}


/*******************************/
/* Memory management functions */
/*******************************/

/*
 * Here we want the physical address of the memory.
 * This is used when initializing the contents of the area.
 */


void *usbvision_rvmalloc(unsigned long size)
{
	void *mem;
	unsigned long adr;

	size = PAGE_ALIGN(size);
	mem = vmalloc_32(size);
	if (!mem)
		return NULL;

	memset(mem, 0, size); /* Clear the ram out, no junk to the user */
 adr = (unsigned long) mem;
 while (size > 0) {
  #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
   mem_map_reserve(vmalloc_to_page((void *)adr));
  #else
   SetPageReserved(vmalloc_to_page((void *)adr));
  #endif
  adr += PAGE_SIZE;
  size -= PAGE_SIZE;
 }

 return mem;
}

void usbvision_rvfree(void *mem, unsigned long size)
{
 unsigned long adr;

 if (!mem)
  return;

 adr = (unsigned long) mem;
 while ((long) size > 0) {
  #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
   mem_map_unreserve(vmalloc_to_page((void *)adr));
  #else
   ClearPageReserved(vmalloc_to_page((void *)adr));
  #endif
  adr += PAGE_SIZE;
  size -= PAGE_SIZE;
 }
 vfree(mem);
}






#if ENABLE_HEXDUMP
static void usbvision_hexdump(const unsigned char *data, int len)
{
 char tmp[80];
 int i, k;

 for (i = k = 0; len > 0; i++, len--) {
  if (i > 0 && (i % 16 == 0)) {
   printk("%s\n", tmp);
   k = 0;
  }
  k += sprintf(&tmp[k], "%02x ", data[i]);
 }
 if (k > 0)
  printk("%s\n", tmp);
}
#endif


/* These procedures handle the scratch ring buffer */
int scratch_len(struct usb_usbvision *usbvision)    /*This returns the amount of data actually in the buffer */
{
	int len = usbvision->scratch_write_ptr - usbvision->scratch_read_ptr;
	if (len < 0) {
		len += scratch_buf_size;
	}
	PDEBUG(DBG_SCRATCH, "scratch_len() = %d\n", len);

	return len;
}


/* This returns the free space left in the buffer */
int scratch_free(struct usb_usbvision *usbvision)
{
	int free = usbvision->scratch_read_ptr - usbvision->scratch_write_ptr;
	if (free <= 0) {
		free += scratch_buf_size;
	}
	if (free) {
		free -= 1;							/* at least one byte in the buffer must */
										/* left blank, otherwise there is no chance to differ between full and empty */
	}
	PDEBUG(DBG_SCRATCH, "return %d\n", free);

	return free;
}


void *debug_memcpy(void *dest, void *src, size_t len)
{
	printk(KERN_DEBUG "memcpy(%p, %p, %d);\n", dest, src, len);
	return memcpy(dest, src, len);
}


/* This puts data into the buffer */
int scratch_put(struct usb_usbvision *usbvision, unsigned char *data, int len)
{
	int len_part;

	if (usbvision->scratch_write_ptr + len < scratch_buf_size) {
		memcpy(usbvision->scratch + usbvision->scratch_write_ptr, data, len);
		usbvision->scratch_write_ptr += len;
	}
	else {
		len_part = scratch_buf_size - usbvision->scratch_write_ptr;
		memcpy(usbvision->scratch + usbvision->scratch_write_ptr, data, len_part);
		if (len == len_part) {
			usbvision->scratch_write_ptr = 0;			/* just set write_ptr to zero */
		}
		else {
			memcpy(usbvision->scratch, data + len_part, len - len_part);
			usbvision->scratch_write_ptr = len - len_part;
		}
	}

	PDEBUG(DBG_SCRATCH, "len=%d, new write_ptr=%d\n", len, usbvision->scratch_write_ptr);

	return len;
}

/* This marks the write_ptr as position of new frame header */
void scratch_mark_header(struct usb_usbvision *usbvision)
{
	PDEBUG(DBG_SCRATCH, "header at write_ptr=%d\n", usbvision->scratch_headermarker_write_ptr);

	usbvision->scratch_headermarker[usbvision->scratch_headermarker_write_ptr] =
				usbvision->scratch_write_ptr;
	usbvision->scratch_headermarker_write_ptr += 1;
	usbvision->scratch_headermarker_write_ptr %= USBVISION_NUM_HEADERMARKER;
}

/* This gets data from the buffer at the given "ptr" position */
int scratch_get_extra(struct usb_usbvision *usbvision, unsigned char *data, int *ptr, int len)
{
	int len_part;
	if (*ptr + len < scratch_buf_size) {
		memcpy(data, usbvision->scratch + *ptr, len);
		*ptr += len;
	}
	else {
		len_part = scratch_buf_size - *ptr;
		memcpy(data, usbvision->scratch + *ptr, len_part);
		if (len == len_part) {
			*ptr = 0;							/* just set the y_ptr to zero */
		}
		else {
			memcpy(data + len_part, usbvision->scratch, len - len_part);
			*ptr = len - len_part;
		}
	}

	PDEBUG(DBG_SCRATCH, "len=%d, new ptr=%d\n", len, *ptr);

	return len;
}


/* This sets the scratch extra read pointer */
void scratch_set_extra_ptr(struct usb_usbvision *usbvision, int *ptr, int len)
{
	*ptr = (usbvision->scratch_read_ptr + len)%scratch_buf_size;

	PDEBUG(DBG_SCRATCH, "ptr=%d\n", *ptr);
}


/*This increments the scratch extra read pointer */
void scratch_inc_extra_ptr(int *ptr, int len)
{
	*ptr = (*ptr + len) % scratch_buf_size;

	PDEBUG(DBG_SCRATCH, "ptr=%d\n", *ptr);
}


/* This gets data from the buffer */
int scratch_get(struct usb_usbvision *usbvision, unsigned char *data, int len)
{
	int len_part;
	if (usbvision->scratch_read_ptr + len < scratch_buf_size) {
		memcpy(data, usbvision->scratch + usbvision->scratch_read_ptr, len);
		usbvision->scratch_read_ptr += len;
	}
	else {
		len_part = scratch_buf_size - usbvision->scratch_read_ptr;
		memcpy(data, usbvision->scratch + usbvision->scratch_read_ptr, len_part);
		if (len == len_part) {
			usbvision->scratch_read_ptr = 0;				/* just set the read_ptr to zero */
		}
		else {
			memcpy(data + len_part, usbvision->scratch, len - len_part);
			usbvision->scratch_read_ptr = len - len_part;
		}
	}

	PDEBUG(DBG_SCRATCH, "len=%d, new read_ptr=%d\n", len, usbvision->scratch_read_ptr);

	return len;
}


/* This sets read pointer to next header and returns it */
int scratch_get_header(struct usb_usbvision *usbvision,struct usbvision_frame_header *header)
{
	int errCode = 0;

	PDEBUG(DBG_SCRATCH, "from read_ptr=%d", usbvision->scratch_headermarker_read_ptr);

	while (usbvision->scratch_headermarker_write_ptr -
		usbvision->scratch_headermarker_read_ptr != 0) {
		usbvision->scratch_read_ptr =
			usbvision->scratch_headermarker[usbvision->scratch_headermarker_read_ptr];
		usbvision->scratch_headermarker_read_ptr += 1;
		usbvision->scratch_headermarker_read_ptr %= USBVISION_NUM_HEADERMARKER;
		scratch_get(usbvision, (unsigned char *)header, USBVISION_HEADER_LENGTH);
		if ((header->magic_1 == USBVISION_MAGIC_1)
			 && (header->magic_2 == USBVISION_MAGIC_2)
			 && (header->headerLength == USBVISION_HEADER_LENGTH)) {
			errCode = USBVISION_HEADER_LENGTH;
			header->frameWidth  = header->frameWidthLo  + (header->frameWidthHi << 8);
			header->frameHeight = header->frameHeightLo + (header->frameHeightHi << 8);
			break;
		}
	}

	return errCode;
}


/*This removes len bytes of old data from the buffer */
void scratch_rm_old(struct usb_usbvision *usbvision, int len)
{

	usbvision->scratch_read_ptr += len;
	usbvision->scratch_read_ptr %= scratch_buf_size;
	PDEBUG(DBG_SCRATCH, "read_ptr is now %d\n", usbvision->scratch_read_ptr);
}


/*This resets the buffer - kills all data in it too */
void scratch_reset(struct usb_usbvision *usbvision)
{
	PDEBUG(DBG_SCRATCH, "\n");

	usbvision->scratch_read_ptr = 0;
	usbvision->scratch_write_ptr = 0;
	usbvision->scratch_headermarker_read_ptr = 0;
	usbvision->scratch_headermarker_write_ptr = 0;
	usbvision->isocstate = IsocState_NoFrame;
}



/* Here comes the OVERLAY stuff */

/* Tell the interrupt handler what to to.  */
static
void usbvision_cap(struct usb_usbvision* usbvision, int on)
{
	DEBUG(printk(KERN_DEBUG "usbvision_cap: overlay was %d, set it to %d\n", usbvision->overlay, on);)

	if (on) {
		usbvision->overlay = 1;
	}
	else {
		usbvision->overlay = 0;
	}
}




/* append a new clipregion to the vector of video_clips */
static
void usbvision_new_clip(struct v4l2_format* vf, struct v4l2_clip* vcp, int x, int y, int w, int h)
{
	vcp[vf->fmt.win.clipcount].c.left = x;
	vcp[vf->fmt.win.clipcount].c.top = y;
	vcp[vf->fmt.win.clipcount].c.width = w;
	vcp[vf->fmt.win.clipcount].c.height = h;
	vf->fmt.win.clipcount++;
}


#define mark_pixel(x,y)  usbvision->clipmask[((x) + (y) * MAX_FRAME_WIDTH)/32] |= 0x00000001<<((x)%32)
#define clipped_pixel(index) usbvision->clipmask[(index)/32] & (0x00000001<<((index)%32))

static
void usbvision_built_overlay(struct usb_usbvision* usbvision, int count, struct v4l2_clip *vcp)
{
	usbvision->overlay_win = usbvision->overlay_base +
		(signed int)usbvision->vid_win.fmt.win.w.left * usbvision->depth / 8 +
		(signed int)usbvision->vid_win.fmt.win.w.top * usbvision->vid_buf.fmt.bytesperline;

		IODEBUG(printk(KERN_DEBUG "built_overlay base=%p, win=%p, bpl=%d, clips=%d, size=%dx%d\n",
					usbvision->overlay_base, usbvision->overlay_win,
					usbvision->vid_buf.fmt.bytesperline, count,
					usbvision->vid_win.fmt.win.w.width, usbvision->vid_win.fmt.win.w.height);)


	/* Add here generation of clipping mask */
{
	int x_start, x_end, y_start, y_end;
	int clip_index, x, y;

	memset(usbvision->clipmask, 0, USBVISION_CLIPMASK_SIZE);

	OVDEBUG(printk(KERN_DEBUG "clips = %d\n", count);)

	for(clip_index = 0; clip_index < count; clip_index++) {
		OVDEBUG(printk(KERN_DEBUG "clip: %d,%d,%d,%d\n", vcp[clip_index].x,
				vcp[clip_index].y,
				vcp[clip_index].width,
				vcp[clip_index].height);)

		x_start = vcp[clip_index].c.left;
		if(x_start >= (int)usbvision->vid_win.fmt.win.w.width) {
			OVDEBUG(printk(KERN_DEBUG "x_start=%d\n", x_start);)
			continue; //clipping window is right of overlay window
		}
		x_end	= x_start + vcp[clip_index].c.width;
		if(x_end <= 0) {
			OVDEBUG(printk(KERN_DEBUG "x_end=%d\n", x_end);)
			continue; //clipping window is left of overlay window
		}

		y_start = vcp[clip_index].c.top;
		if(y_start >= (int)usbvision->vid_win.fmt.win.w.height) {
			OVDEBUG(printk(KERN_DEBUG "y_start=%d\n", y_start);)
			continue; //clipping window is below overlay window
		}
		y_end   = y_start + vcp[clip_index].c.height;
		if(y_end <= 0) {
			OVDEBUG(printk(KERN_DEBUG "y_end=%d\n", y_end);)
			continue; //clipping window is above overlay window
		}

		//clip the clipping window
		if (x_start < 0) {
			x_start = 0;
		}
		if (x_end > (int)usbvision->vid_win.fmt.win.w.width) {
			x_end = (int)usbvision->vid_win.fmt.win.w.width;
		}
		if (y_start < 0) {
			y_start = 0;
		}
		if (y_end > (int)usbvision->vid_win.fmt.win.w.height) {
			y_end = (int)usbvision->vid_win.fmt.win.w.height;
		}

		OVDEBUG(printk(KERN_DEBUG "clip_o: %d,%d,%d,%d\n", x_start,	y_start, x_end, y_end);)



		for(y = y_start; y < y_end; y++) {
			for(x = x_start; x < x_end; x++) {
				mark_pixel(x,y);
			}
		}
	}
}

}



void usbvision_osd_char(struct usb_usbvision *usbvision,
			struct usbvision_frame *frame, int x, int y, int ch)
{
	static const unsigned short digits[16] = {
		0xF6DE,		/* 0 */
		0x2492,		/* 1 */
		0xE7CE,		/* 2 */
		0xE79E,		/* 3 */
		0xB792,		/* 4 */
		0xF39E,		/* 5 */
		0xF3DE,		/* 6 */
		0xF492,		/* 7 */
		0xF7DE,		/* 8 */
		0xF79E,		/* 9 */
		0x77DA,		/* a */
		0xD75C,		/* b */
		0xF24E,		/* c */
		0xD6DC,		/* d */
		0xF34E,		/* e */
		0xF348		/* f */
	};
	unsigned short digit;
	int ix, iy;

	if ((usbvision == NULL) || (frame == NULL))
		return;

	if (ch >= '0' && ch <= '9')
		ch -= '0';
	else if (ch >= 'A' && ch <= 'F')
		ch = 10 + (ch - 'A');
	else if (ch >= 'a' && ch <= 'f')
		ch = 10 + (ch - 'a');
	else
		return;
	digit = digits[ch];

	for (iy = 0; iy < 5; iy++) {
		for (ix = 0; ix < 3; ix++) {
			if (digit & 0x8000) {
			//	USBVISION_PUTPIXEL(frame, x + ix, y + iy,
			//			0xFF, 0xFF, 0xFF);
			}
			digit = digit << 1;
		}
	}
}


void usbvision_osd_string(struct usb_usbvision *usbvision,
			  struct usbvision_frame *frame,
			  int x, int y, const char *str)
{
	while (*str) {
		usbvision_osd_char(usbvision, frame, x, y, *str);
		str++;
		x += 4;		/* 3 pixels character + 1 space */
	}
}

/*
 * usb_usbvision_osd_stats()
 *
 * On screen display of important debugging information.
 *
 */
void usbvision_osd_stats(struct usb_usbvision *usbvision,
			 struct usbvision_frame *frame)
{
	const int y_diff = 8;
	char tmp[16];
	int x = 10;
	int y = 10;

	sprintf(tmp, "%8x", usbvision->frame_num);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->isocUrbCount);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->urb_length);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->isocDataCount);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->header_count);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->scratch_ovf_count);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->isocSkipCount);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->isocErrCount);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8x", usbvision->saturation);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8x", usbvision->hue);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8x", usbvision->brightness >> 8);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8x", usbvision->contrast >> 12);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

}

/*
 * usbvision_testpattern()
 *
 * Procedure forms a test pattern (yellow grid on blue background).
 *
 * Parameters:
 * fullframe:   if TRUE then entire frame is filled, otherwise the procedure
 *	        continues from the current scanline.
 * pmode	0: fill the frame with solid blue color (like on VCR or TV)
 *	        1: Draw a colored grid
 *
 */
void usbvision_testpattern(struct usb_usbvision *usbvision, int fullframe,
			int pmode)
{
	static const char proc[] = "usbvision_testpattern";
	struct usbvision_frame *frame;
	unsigned char *f;
	int num_cell = 0;
	int scan_length = 0;
	static int num_pass = 0;

	if (usbvision == NULL) {
		printk(KERN_ERR "%s: usbvision == NULL\n", proc);
		return;
	}
	if ((usbvision->curFrameNum < 0)
	    || (usbvision->curFrameNum >= USBVISION_NUMFRAMES)) {
		printk(KERN_ERR "%s: usbvision->curFrameNum=%d.\n", proc,
		       usbvision->curFrameNum);
		return;
	}

	/* Grab the current frame */
	frame = &usbvision->frame[usbvision->curFrameNum];

	/* Optionally start at the beginning */
	if (fullframe) {
		frame->curline = 0;
		frame->scanlength = 0;
	}

	/* Form every scan line */
	for (; frame->curline < frame->frmheight; frame->curline++) {
		int i;

		f = frame->data + (usbvision->curwidth * 3 * frame->curline);
		for (i = 0; i < usbvision->curwidth; i++) {
			unsigned char cb = 0x80;
			unsigned char cg = 0;
			unsigned char cr = 0;

			if (pmode == 1) {
				if (frame->curline % 32 == 0)
					cb = 0, cg = cr = 0xFF;
				else if (i % 32 == 0) {
					if (frame->curline % 32 == 1)
						num_cell++;
					cb = 0, cg = cr = 0xFF;
				} else {
					cb =
					    ((num_cell * 7) +
					     num_pass) & 0xFF;
					cg =
					    ((num_cell * 5) +
					     num_pass * 2) & 0xFF;
					cr =
					    ((num_cell * 3) +
					     num_pass * 3) & 0xFF;
				}
			} else {
				/* Just the blue screen */
			}

			*f++ = cb;
			*f++ = cg;
			*f++ = cr;
			scan_length += 3;
		}
	}

	frame->grabstate = FrameState_Done;
	frame->scanlength += scan_length;
	++num_pass;

	/* We do this unconditionally, regardless of FLAGS_OSD_STATS */
	usbvision_osd_stats(usbvision, frame);
}

/*
 * Here comes the data parsing stuff that is run as interrupt
 */

/*
 * usbvision_find_header()
 *
 * Locate one of supported header markers in the scratch buffer.
 */
static enum ParseState usbvision_find_header(struct usb_usbvision *usbvision)
{
	struct usbvision_frame *frame;
	int foundHeader = 0;

	if (usbvision->overlay) {
		frame = &usbvision->overlay_frame;
	}
	else {
		frame = &usbvision->frame[usbvision->curFrameNum];
	}

	while (scratch_get_header(usbvision, &frame->isocHeader) == USBVISION_HEADER_LENGTH) {
		// found header in scratch
		PDEBUG(DBG_HEADER, "found header: 0x%02x%02x %d %d %d %d %#x 0x%02x %u %u",
				frame->isocHeader.magic_2,
				frame->isocHeader.magic_1,
				frame->isocHeader.headerLength,
				frame->isocHeader.frameNum,
				frame->isocHeader.framePhase,
				frame->isocHeader.frameLatency,
				frame->isocHeader.dataFormat,
				frame->isocHeader.formatParam,
				frame->isocHeader.frameWidth,
				frame->isocHeader.frameHeight);

		if (usbvision->requestIntra) {
			if (frame->isocHeader.formatParam & 0x80) {
				foundHeader = 1;
				usbvision->lastIsocFrameNum = -1; // do not check for lost frames this time
				usbvision_unrequest_intra(usbvision);
				break;
			}
		}
		else {
			foundHeader = 1;
			break;
		}
	}

	if (foundHeader) {
		frame->frmwidth = frame->isocHeader.frameWidth * usbvision->stretch_width;
		frame->frmheight = frame->isocHeader.frameHeight * usbvision->stretch_height;
		frame->v4l2_linesize = (frame->frmwidth * frame->v4l2_format.depth)>> 3;
		usbvision->curFrame = frame;
	}
	else { // no header found
		PDEBUG(DBG_HEADER, "skipping scratch data, no header");
		scratch_reset(usbvision);
		return ParseState_EndParse;
	}

	// found header
	if (frame->isocHeader.dataFormat==ISOC_MODE_COMPRESS) {
		//check isocHeader.frameNum for lost frames
		if (usbvision->lastIsocFrameNum >= 0) {
			if (((usbvision->lastIsocFrameNum + 1) % 32) != frame->isocHeader.frameNum) {
				// unexpected frame drop: need to request new intra frame
				PDEBUG(DBG_HEADER, "Lost frame before %d on USB", frame->isocHeader.frameNum);
				usbvision_request_intra(usbvision);
				return ParseState_NextFrame;
			}
		}
		usbvision->lastIsocFrameNum = frame->isocHeader.frameNum;
	}
	usbvision->header_count++;
	frame->scanstate = ScanState_Lines;
	frame->curline = 0;

	if (flags & FLAGS_FORCE_TESTPATTERN) {
		usbvision_testpattern(usbvision, 1, 1);
		return ParseState_NextFrame;
	}
	return ParseState_Continue;
}

static enum ParseState usbvision_parse_lines_422(struct usb_usbvision *usbvision,
					   long *pcopylen)
{
	volatile struct usbvision_frame *frame;
	unsigned char *f;
	int len;
	int i;
	unsigned char yuyv[4]={180, 128, 10, 128}; // YUV components
	unsigned char rv, gv, bv;	// RGB components
	int clipmask_index, bytes_per_pixel;
	int overlay = usbvision->overlay;
	int stretch_bytes, clipmask_add;

	if (overlay) {
		frame  = &usbvision->overlay_frame;
		if (usbvision->overlay_base == NULL) {
			//video_buffer is not set yet
			return ParseState_NextFrame;
		}
		f = usbvision->overlay_win + frame->curline *
			usbvision->vid_buf.fmt.bytesperline;
	}
	else {
		frame  = &usbvision->frame[usbvision->curFrameNum];
		f = frame->data + (frame->v4l2_linesize * frame->curline);
	}

	/* Make sure there's enough data for the entire line */
	len = (frame->isocHeader.frameWidth * 2)+5;
	if (scratch_len(usbvision) < len) {
		PDEBUG(DBG_PARSE, "out of data in line %d, need %u.\n", frame->curline, len);
		return ParseState_Out;
	}

	if ((frame->curline + 1) >= frame->frmheight) {
		return ParseState_NextFrame;
	}

	bytes_per_pixel = frame->v4l2_format.bytes_per_pixel;
	stretch_bytes = (usbvision->stretch_width - 1) * bytes_per_pixel;
	clipmask_index = frame->curline * MAX_FRAME_WIDTH;
	clipmask_add = usbvision->stretch_width;

	for (i = 0; i < frame->frmwidth; i+=(2 * usbvision->stretch_width)) {

		scratch_get(usbvision, &yuyv[0], 4);

		if((overlay) && (clipped_pixel(clipmask_index))) {
			f += bytes_per_pixel;
		}
		else if (frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
			*f++ = yuyv[0]; // Y
			*f++ = yuyv[3]; // U
		}
		else {

			YUV_TO_RGB_BY_THE_BOOK(yuyv[0], yuyv[1], yuyv[3], rv, gv, bv);
			switch (frame->v4l2_format.format) {
				case V4L2_PIX_FMT_RGB565:
					*f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 3));
					*f++ = (0x07 & (gv >> 5)) | (0xF8 &  rv);
					break;
				case V4L2_PIX_FMT_RGB24:
					*f++ = bv;
					*f++ = gv;
					*f++ = rv;
					break;
				case V4L2_PIX_FMT_RGB32:
					*f++ = bv;
					*f++ = gv;
					*f++ = rv;
					f++;
					break;
				case V4L2_PIX_FMT_RGB555:
					*f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 2));
					*f++ = (0x03 & (gv >> 6)) | (0x7C & (rv >> 1));
					break;
			}
		}
		clipmask_index += clipmask_add;
		f += stretch_bytes;

		if((overlay) && (clipped_pixel(clipmask_index))) {
			f += bytes_per_pixel;
		}
		else if (frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
			*f++ = yuyv[2]; // Y
			*f++ = yuyv[1]; // V
		}
		else {

			YUV_TO_RGB_BY_THE_BOOK(yuyv[2], yuyv[1], yuyv[3], rv, gv, bv);
			switch (frame->v4l2_format.format) {
				case V4L2_PIX_FMT_RGB565:
					*f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 3));
					*f++ = (0x07 & (gv >> 5)) | (0xF8 &  rv);
					break;
				case V4L2_PIX_FMT_RGB24:
					*f++ = bv;
					*f++ = gv;
					*f++ = rv;
					break;
				case V4L2_PIX_FMT_RGB32:
					*f++ = bv;
					*f++ = gv;
					*f++ = rv;
					f++;
					break;
				case V4L2_PIX_FMT_RGB555:
					*f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 2));
					*f++ = (0x03 & (gv >> 6)) | (0x7C & (rv >> 1));
					break;
			}
		}
		clipmask_index += clipmask_add;
		f += stretch_bytes;
	}

	frame->curline += usbvision->stretch_height;
	*pcopylen += frame->v4l2_linesize * usbvision->stretch_height;

	if (frame->curline >= frame->frmheight) {
		return ParseState_NextFrame;
	}
	else {
		return ParseState_Continue;
	}
}


static int usbvision_decompress(struct usb_usbvision *usbvision,unsigned char *Compressed,
								unsigned char *Decompressed, int *StartPos,
								int *BlockTypeStartPos, int Len)
{
	int RestPixel, Idx, MaxPos, Pos, ExtraPos, BlockLen, BlockTypePos, BlockTypeLen;
	unsigned char BlockByte, BlockCode, BlockType, BlockTypeByte, Integrator;

	Integrator = 0;
	Pos = *StartPos;
	BlockTypePos = *BlockTypeStartPos;
	MaxPos = 396; //Pos + Len;
	ExtraPos = Pos;
	BlockLen = 0;
	BlockByte = 0;
	BlockCode = 0;
	BlockType = 0;
	BlockTypeByte = 0;
	BlockTypeLen = 0;
	RestPixel = Len;

	for (Idx = 0; Idx < Len; Idx++) {

		if (BlockLen == 0) {
			if (BlockTypeLen==0) {
				BlockTypeByte = Compressed[BlockTypePos];
				BlockTypePos++;
				BlockTypeLen = 4;
			}
			BlockType = (BlockTypeByte & 0xC0) >> 6;

			//statistic:
			usbvision->ComprBlockTypes[BlockType]++;

			Pos = ExtraPos;
			if (BlockType == 0) {
				if(RestPixel >= 24) {
					Idx += 23;
					RestPixel -= 24;
					Integrator = Decompressed[Idx];
				} else {
					Idx += RestPixel - 1;
					RestPixel = 0;
				}
			} else {
				BlockCode = Compressed[Pos];
				Pos++;
				if (RestPixel >= 24) {
					BlockLen  = 24;
				} else {
					BlockLen = RestPixel;
				}
				RestPixel -= BlockLen;
				ExtraPos = Pos + (BlockLen / 4);
			}
			BlockTypeByte <<= 2;
			BlockTypeLen -= 1;
		}
		if (BlockLen > 0) {
			if ((BlockLen%4) == 0) {
				BlockByte = Compressed[Pos];
				Pos++;
			}
			if (BlockType == 1) { //inter Block
				Integrator = Decompressed[Idx];
			}
			switch (BlockByte & 0xC0) {
				case 0x03<<6:
					Integrator += Compressed[ExtraPos];
					ExtraPos++;
					break;
				case 0x02<<6:
					Integrator += BlockCode;
					break;
				case 0x00:
					Integrator -= BlockCode;
					break;
			}
			Decompressed[Idx] = Integrator;
			BlockByte <<= 2;
			BlockLen -= 1;
		}
	}
	*StartPos = ExtraPos;
	*BlockTypeStartPos = BlockTypePos;
	return Idx;
}


/*
 * usbvision_parse_compress()
 *
 * Parse compressed frame from the scratch buffer, put
 * decoded RGB value into the current frame buffer and add the written
 * number of bytes (RGB) to the *pcopylen.
 *
 */
static enum ParseState usbvision_parse_compress(struct usb_usbvision *usbvision,
					   long *pcopylen)
{
#define USBVISION_STRIP_MAGIC		0x5A
#define USBVISION_STRIP_LEN_MAX		400
#define USBVISION_STRIP_HEADER_LEN	3

	struct usbvision_frame *frame;
	unsigned char *f,*u = NULL ,*v = NULL;
	unsigned char StripData[USBVISION_STRIP_LEN_MAX];
	unsigned char StripHeader[USBVISION_STRIP_HEADER_LEN];
	int Idx, IdxEnd, StripLen, StripPtr, StartBlockPos, BlockPos, BlockTypePos;
	int clipmask_index, bytes_per_pixel, rc;
	int overlay = usbvision->overlay;
	int imageSize;
	unsigned char rv, gv, bv;
	static unsigned char *Y, *U, *V;

	if (overlay) {
		frame  = &usbvision->overlay_frame;
		imageSize = frame->frmwidth * frame->frmheight; 
		if (usbvision->overlay_base == NULL) {
			//video_buffer is not set yet
			return ParseState_NextFrame;
		}
		f = usbvision->overlay_win + frame->curline *
			usbvision->vid_buf.fmt.bytesperline;
	}
	else {
		frame  = &usbvision->frame[usbvision->curFrameNum];
		imageSize = frame->frmwidth * frame->frmheight; 				
		if ( (frame->v4l2_format.format == V4L2_PIX_FMT_YUV422P) ||
		     (frame->v4l2_format.format == V4L2_PIX_FMT_YVU420) )
		{       // this is a planar format 
			                                               //... v4l2_linesize not used here.
			f = frame->data + (frame->width * frame->curline);
		} else 
			f = frame->data + (frame->v4l2_linesize * frame->curline);
		
		if (frame->v4l2_format.format == V4L2_PIX_FMT_YUYV){ //initialise u and v pointers
			                                         // get base of u and b planes add halfoffset
			
			u = frame->data 
				+ imageSize 	
				+ (frame->frmwidth >>1) * frame->curline ;
			v = u + (imageSize >>1 );
			
		} else if (frame->v4l2_format.format == V4L2_PIX_FMT_YVU420){
			
		        v = frame->data + imageSize + ((frame->curline* (frame->width))>>2) ; 
			u = v + (imageSize >>2) ;
		}
	}

	if (frame->curline == 0) {
		usbvision_adjust_compression(usbvision);
	}

	if (scratch_len(usbvision) < USBVISION_STRIP_HEADER_LEN) {
		return ParseState_Out;
	}

	//get strip header without changing the scratch_read_ptr
	scratch_set_extra_ptr(usbvision, &StripPtr, 0);
	scratch_get_extra(usbvision, &StripHeader[0], &StripPtr,
				USBVISION_STRIP_HEADER_LEN);

	if (StripHeader[0] != USBVISION_STRIP_MAGIC) {
		// wrong strip magic
		usbvision->stripMagicErrors++;
		return ParseState_NextFrame;
	}

	if (frame->curline != (int)StripHeader[2]) {
		//line number missmatch error
		usbvision->stripLineNumberErrors++;
	}

	StripLen = 2 * (unsigned int)StripHeader[1];
	if (StripLen > USBVISION_STRIP_LEN_MAX) {
		// strip overrun
		// I think this never happens
		usbvision_request_intra(usbvision);
	}

	if (scratch_len(usbvision) < StripLen) {
		//there is not enough data for the strip
		return ParseState_Out;
	}

	if (usbvision->IntraFrameBuffer) {
		Y = usbvision->IntraFrameBuffer + frame->frmwidth * frame->curline;
		U = usbvision->IntraFrameBuffer + imageSize + (frame->frmwidth / 2) * (frame->curline / 2);
		V = usbvision->IntraFrameBuffer + imageSize / 4 * 5 + (frame->frmwidth / 2) * (frame->curline / 2);
	}
	else {
		return ParseState_NextFrame;
	}

 	bytes_per_pixel = frame->v4l2_format.bytes_per_pixel;
	clipmask_index = frame->curline * MAX_FRAME_WIDTH;

	scratch_get(usbvision, StripData, StripLen);

	IdxEnd = frame->frmwidth;
	BlockTypePos = USBVISION_STRIP_HEADER_LEN;
	StartBlockPos = BlockTypePos + (IdxEnd - 1) / 96 + (IdxEnd / 2 - 1) / 96 + 2;
	BlockPos = StartBlockPos;

	usbvision->BlockPos = BlockPos;

	if ((rc = usbvision_decompress(usbvision, StripData, Y, &BlockPos, &BlockTypePos, IdxEnd)) != IdxEnd) {
		//return ParseState_Continue;
	}
	if (StripLen > usbvision->maxStripLen) {
		usbvision->maxStripLen = StripLen;
	}

	if (frame->curline%2) {
		if ((rc = usbvision_decompress(usbvision, StripData, V, &BlockPos, &BlockTypePos, IdxEnd/2)) != IdxEnd/2) {
		//return ParseState_Continue;
		}
	}
	else {
		if ((rc = usbvision_decompress(usbvision, StripData, U, &BlockPos, &BlockTypePos, IdxEnd/2)) != IdxEnd/2) {
			//return ParseState_Continue;
		}
	}

	if (BlockPos > usbvision->comprBlockPos) {
		usbvision->comprBlockPos = BlockPos;
	}
	if (BlockPos > StripLen) {
		usbvision->stripLenErrors++;
	}
	
	for (Idx = 0; Idx < IdxEnd; Idx++) {
		if((overlay) && (clipped_pixel(clipmask_index))) {
			f += bytes_per_pixel;
		}
		else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
			*f++ = Y[Idx];
			*f++ = Idx & 0x01 ? U[Idx/2] : V[Idx/2];
		}
		else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUV422P) {
			*f++ = Y[Idx];
			if ( Idx & 0x01)
				*u++ = U[Idx>>1] ;
			else
				*v++ = V[Idx>>1];
		}
		else if (frame->v4l2_format.format == V4L2_PIX_FMT_YVU420) {
			*f++ = Y [Idx];
			if ( !((  Idx & 0x01  ) | (  frame->curline & 0x01  )) ){ 
		            
/* 				 only need do this for 1 in 4 pixels */
/* 				 intraframe buffer is YUV420 format */

				*u++ = U[Idx >>1];
				*v++ = V[Idx >>1];
			}
			
		}
		else {
			YUV_TO_RGB_BY_THE_BOOK(Y[Idx], U[Idx/2], V[Idx/2], rv, gv, bv);
			switch (frame->v4l2_format.format) {
				case V4L2_PIX_FMT_GREY:
					*f++ = Y[Idx];
					break;
				case V4L2_PIX_FMT_RGB555:
					*f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 2));
					*f++ = (0x03 & (gv >> 6)) | (0x7C & (rv >> 1));
					break;
				case V4L2_PIX_FMT_RGB565:
					*f++ = (0x1F & (bv >> 3)) | (0xE0 & (gv << 3));
					*f++ = (0x07 & (gv >> 5)) | (0xF8 &  rv);
					break;
				case V4L2_PIX_FMT_RGB24:
					*f++ = bv;
					*f++ = gv;
					*f++ = rv;
					break;
				case V4L2_PIX_FMT_RGB32:
					*f++ = bv;
					*f++ = gv;
					*f++ = rv;
					f++;
					break;
			}
		}
		clipmask_index++;
	}
	/* Deal with non-integer no. of bytes for YUV420P */ 
 	if (frame->v4l2_format.format != V4L2_PIX_FMT_YVU420 ) 
 		*pcopylen += frame->v4l2_linesize; 
 	else 
 		*pcopylen += frame->curline & 0x01 ? frame->v4l2_linesize : frame->v4l2_linesize << 1;  
  
	frame->curline += 1;

	if (frame->curline >= frame->frmheight) {
		return ParseState_NextFrame;
	}
	else {
		return ParseState_Continue;
	}

}


/*
 * usbvision_parse_lines_420()
 *
 * Parse two lines from the scratch buffer, put
 * decoded RGB value into the current frame buffer and add the written
 * number of bytes (RGB) to the *pcopylen.
 *
 */
static enum ParseState usbvision_parse_lines_420(struct usb_usbvision *usbvision,
					   long *pcopylen)
{
	struct usbvision_frame *frame;
	unsigned char *f_even = NULL, *f_odd = NULL;
	unsigned int pixel_per_line, block;
	int pixel, block_split;
	int y_ptr, u_ptr, v_ptr, y_odd_offset;
	const int   y_block_size = 128;
	const int  uv_block_size = 64;
	const int sub_block_size = 32;
	const int y_step[] = { 0, 0, 0, 2 },  y_step_size = 4;
	const int uv_step[]= { 0, 0, 0, 4 }, uv_step_size = 4;
	unsigned char y[2], u, v;	/* YUV components */
	int y_, u_, v_, vb, uvg, ur;
	int r_, g_, b_;			/* RGB components */
	unsigned char g;
	int clipmask_even_index, clipmask_odd_index, bytes_per_pixel;
	int clipmask_add, stretch_bytes;
	int overlay = usbvision->overlay;

	if (overlay) {
		frame  = &usbvision->overlay_frame;
		if (usbvision->overlay_base == NULL) {
			//video_buffer is not set yet
			return ParseState_NextFrame;
		}
		f_even = usbvision->overlay_win + frame->curline *
			 usbvision->vid_buf.fmt.bytesperline;
		f_odd  = f_even + usbvision->vid_buf.fmt.bytesperline * usbvision->stretch_height;
	}
	else {
		frame  = &usbvision->frame[usbvision->curFrameNum];
		f_even = frame->data + (frame->v4l2_linesize * frame->curline);
		f_odd  = f_even + frame->v4l2_linesize * usbvision->stretch_height;
	}

	/* Make sure there's enough data for the entire line */
	/* In this mode usbvision transfer 3 bytes for every 2 pixels */
	/* I need two lines to decode the color */
 	bytes_per_pixel = frame->v4l2_format.bytes_per_pixel;
	stretch_bytes = (usbvision->stretch_width - 1) * bytes_per_pixel;
	clipmask_even_index = frame->curline * MAX_FRAME_WIDTH;
	clipmask_odd_index  = clipmask_even_index + MAX_FRAME_WIDTH;
	clipmask_add = usbvision->stretch_width;
	pixel_per_line = frame->isocHeader.frameWidth;

	if (scratch_len(usbvision) < (int)pixel_per_line * 3) {
		//printk(KERN_DEBUG "out of data, need %d\n", len);
		return ParseState_Out;
	}

	if ((frame->curline + 1) >= frame->frmheight) {
		return ParseState_NextFrame;
	}

	block_split = (pixel_per_line%y_block_size) ? 1 : 0;	//are some blocks splitted into different lines?

	y_odd_offset = (pixel_per_line / y_block_size) * (y_block_size + uv_block_size)
			+ block_split * uv_block_size;

	scratch_set_extra_ptr(usbvision, &y_ptr, y_odd_offset);
	scratch_set_extra_ptr(usbvision, &u_ptr, y_block_size);
	scratch_set_extra_ptr(usbvision, &v_ptr, y_odd_offset
			+ (4 - block_split) * sub_block_size);

	for (block = 0; block < (pixel_per_line / sub_block_size);
	     block++) {


		for (pixel = 0; pixel < sub_block_size; pixel +=2) {
			scratch_get(usbvision, &y[0], 2);
			scratch_get_extra(usbvision, &u, &u_ptr, 1);
			scratch_get_extra(usbvision, &v, &v_ptr, 1);

			//I don't use the YUV_TO_RGB macro for better performance
			v_ = v - 128;
			u_ = u - 128;
			vb =              132252 * v_;
			uvg= -53281 * u_ - 25625 * v_;
			ur = 104595 * u_;

			if((overlay) && (clipped_pixel(clipmask_even_index))) {
				f_even += bytes_per_pixel;
			}
			else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
				*f_even++ = y[0];
				*f_even++ = v;
			}
			else {
				y_ = 76284 * (y[0] - 16);

				b_ = (y_ + vb) >> 16;
				g_ = (y_ + uvg)>> 16;
				r_ = (y_ + ur) >> 16;

				switch (frame->v4l2_format.format) {
					case V4L2_PIX_FMT_RGB565:
						g = LIMIT_RGB(g_);
						*f_even++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 3));
						*f_even++ = (0x07 & (          g   >> 5)) | (0xF8 & LIMIT_RGB(r_));
						break;
					case V4L2_PIX_FMT_RGB24:
						*f_even++ = LIMIT_RGB(b_);
						*f_even++ = LIMIT_RGB(g_);
						*f_even++ = LIMIT_RGB(r_);
						break;
					case V4L2_PIX_FMT_RGB32:
						*f_even++ = LIMIT_RGB(b_);
						*f_even++ = LIMIT_RGB(g_);
						*f_even++ = LIMIT_RGB(r_);
						f_even++;
						break;
					case V4L2_PIX_FMT_RGB555:
						g = LIMIT_RGB(g_);
						*f_even++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 2));
						*f_even++ = (0x03 & (          g   >> 6)) |
							    (0x7C & (LIMIT_RGB(r_) >> 1));
						break;
				}
			}
			clipmask_even_index += clipmask_add;
			f_even += stretch_bytes;

			if((overlay) && (clipped_pixel(clipmask_even_index))) {
				f_even += bytes_per_pixel;
			}
			else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
				*f_even++ = y[1];
				*f_even++ = u;
			}
			else {
				y_ = 76284 * (y[1] - 16);

				b_ = (y_ + vb) >> 16;
				g_ = (y_ + uvg)>> 16;
				r_ = (y_ + ur) >> 16;

				switch (frame->v4l2_format.format) {
					case V4L2_PIX_FMT_RGB565:
						g = LIMIT_RGB(g_);
						*f_even++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 3));
						*f_even++ = (0x07 & (          g   >> 5)) | (0xF8 & LIMIT_RGB(r_));
						break;
					case V4L2_PIX_FMT_RGB24:
						*f_even++ = LIMIT_RGB(b_);
						*f_even++ = LIMIT_RGB(g_);
						*f_even++ = LIMIT_RGB(r_);
						break;
					case V4L2_PIX_FMT_RGB32:
						*f_even++ = LIMIT_RGB(b_);
						*f_even++ = LIMIT_RGB(g_);
						*f_even++ = LIMIT_RGB(r_);
						f_even++;
						break;
					case V4L2_PIX_FMT_RGB555:
						g = LIMIT_RGB(g_);
						*f_even++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 2));
						*f_even++ = (0x03 & (          g   >> 6)) |
							    (0x7C & (LIMIT_RGB(r_) >> 1));
						break;
				}
			}
			clipmask_even_index += clipmask_add;
			f_even += stretch_bytes;

			scratch_get_extra(usbvision, &y[0], &y_ptr, 2);

			if ((overlay) && (clipped_pixel(clipmask_odd_index))) {
				f_odd += bytes_per_pixel;
			}
			else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
				*f_odd++ = y[0];
				*f_odd++ = v;
			}
			else {
				y_ = 76284 * (y[0] - 16);

				b_ = (y_ + vb) >> 16;
				g_ = (y_ + uvg)>> 16;
				r_ = (y_ + ur) >> 16;

				switch (frame->v4l2_format.format) {
					case V4L2_PIX_FMT_RGB565:
						g = LIMIT_RGB(g_);
						*f_odd++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 3));
						*f_odd++ = (0x07 & (          g   >> 5)) | (0xF8 & LIMIT_RGB(r_));
						break;
					case V4L2_PIX_FMT_RGB24:
						*f_odd++ = LIMIT_RGB(b_);
						*f_odd++ = LIMIT_RGB(g_);
						*f_odd++ = LIMIT_RGB(r_);
						break;
					case V4L2_PIX_FMT_RGB32:
						*f_odd++ = LIMIT_RGB(b_);
						*f_odd++ = LIMIT_RGB(g_);
						*f_odd++ = LIMIT_RGB(r_);
						f_odd++;
						break;
					case V4L2_PIX_FMT_RGB555:
						g = LIMIT_RGB(g_);
						*f_odd++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 2));
						*f_odd++ = (0x03 & (          g   >> 6)) |
							   (0x7C & (LIMIT_RGB(r_) >> 1));
						break;
				}
			}
			clipmask_odd_index += clipmask_add;
			f_odd += stretch_bytes;

			if((overlay) && (clipped_pixel(clipmask_odd_index))) {
				f_odd += bytes_per_pixel;
			}
			else if(frame->v4l2_format.format == V4L2_PIX_FMT_YUYV) {
				*f_odd++ = y[1];
				*f_odd++ = u;
			}
			else {
				y_ = 76284 * (y[1] - 16);

				b_ = (y_ + vb) >> 16;
				g_ = (y_ + uvg)>> 16;
				r_ = (y_ + ur) >> 16;

				switch (frame->v4l2_format.format) {
					case V4L2_PIX_FMT_RGB565:
						g = LIMIT_RGB(g_);
						*f_odd++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 3));
						*f_odd++ = (0x07 & (          g   >> 5)) | (0xF8 & LIMIT_RGB(r_));
						break;
					case V4L2_PIX_FMT_RGB24:
						*f_odd++ = LIMIT_RGB(b_);
						*f_odd++ = LIMIT_RGB(g_);
						*f_odd++ = LIMIT_RGB(r_);
						break;
					case V4L2_PIX_FMT_RGB32:
						*f_odd++ = LIMIT_RGB(b_);
						*f_odd++ = LIMIT_RGB(g_);
						*f_odd++ = LIMIT_RGB(r_);
						f_odd++;
						break;
					case V4L2_PIX_FMT_RGB555:
						g = LIMIT_RGB(g_);
						*f_odd++ = (0x1F & (LIMIT_RGB(b_) >> 3)) | (0xE0 & (g << 2));
						*f_odd++ = (0x03 & (          g   >> 6)) |
							   (0x7C & (LIMIT_RGB(r_) >> 1));
						break;
				}
			}
			clipmask_odd_index += clipmask_add;
			f_odd += stretch_bytes;
		}

		scratch_rm_old(usbvision,y_step[block % y_step_size] * sub_block_size);
		scratch_inc_extra_ptr(&y_ptr, y_step[(block + 2 * block_split) % y_step_size]
				* sub_block_size);
		scratch_inc_extra_ptr(&u_ptr, uv_step[block % uv_step_size]
				* sub_block_size);
		scratch_inc_extra_ptr(&v_ptr, uv_step[(block + 2 * block_split) % uv_step_size]
				* sub_block_size);
	}

	scratch_rm_old(usbvision, pixel_per_line * 3 / 2
			+ block_split * sub_block_size);

	frame->curline += 2 * usbvision->stretch_height;
	*pcopylen += frame->v4l2_linesize * 2 * usbvision->stretch_height;

	if (frame->curline >= frame->frmheight)
		return ParseState_NextFrame;
	else
		return ParseState_Continue;
}

/*
 * usbvision_parse_data()
 *
 * Generic routine to parse the scratch buffer. It employs either
 * usbvision_find_header() or usbvision_parse_lines() to do most
 * of work.
 *
 */
static void usbvision_parse_data(struct usb_usbvision *usbvision)
{
	struct usbvision_frame *frame;
	enum ParseState newstate;
	long copylen = 0;

	if (usbvision->overlay) {
		frame = &usbvision->overlay_frame;
	}
	else {
		frame = &usbvision->frame[usbvision->curFrameNum];
	}

	PDEBUG(DBG_PARSE, "parsing len=%d\n", scratch_len(usbvision));


	while (1) {

		newstate = ParseState_Out;
		if (scratch_len(usbvision)) {
			if (frame->scanstate == ScanState_Scanning) {
				newstate = usbvision_find_header(usbvision);
			}
			else if (frame->scanstate == ScanState_Lines) {
				if (usbvision->isocMode == ISOC_MODE_YUV420) {
					newstate = usbvision_parse_lines_420(usbvision, &copylen);
				}
				else if (usbvision->isocMode == ISOC_MODE_YUV422) {
					newstate = usbvision_parse_lines_422(usbvision, &copylen);
				}
				else if (usbvision->isocMode == ISOC_MODE_COMPRESS) {
					newstate = usbvision_parse_compress(usbvision, &copylen);
				}

			}
		}
		if (newstate == ParseState_Continue) {
			continue;
		}
		else if ((newstate == ParseState_NextFrame) || (newstate == ParseState_Out)) {
			break;
		}
		else {
			return;	/* ParseState_EndParse */
		}
	}

	if (newstate == ParseState_NextFrame) {
		frame->grabstate = FrameState_Done;
		do_gettimeofday(&(frame->timestamp));
		frame->sequence = usbvision->frame_num;
		if (usbvision->overlay) {
			frame->grabstate = FrameState_Grabbing;
			frame->scanstate = ScanState_Scanning;
			frame->scanlength = 0;
			copylen = 0;
		}
		else {
			usbvision->curFrameNum = -1;
		}
		usbvision->frame_num++;

		/* Optionally display statistics on the screen */
		if (flags & FLAGS_OSD_STATS)
			usbvision_osd_stats(usbvision, frame);

		/* This will cause the process to request another frame. */
		if (waitqueue_active(&frame->wq)) {
			wake_up_interruptible(&frame->wq);
		}
	}

	/* Update the frame's uncompressed length. */
	frame->scanlength += copylen;
}


/*
 * Make all of the blocks of data contiguous
 */
static int usbvision_compress_isochronous(struct usb_usbvision *usbvision,
				       struct urb *urb)
{
	unsigned char *packet_data;
	int i, totlen = 0;

	for (i = 0; i < urb->number_of_packets; i++) {
		int packet_len = urb->iso_frame_desc[i].actual_length;
		int packet_stat = urb->iso_frame_desc[i].status;

		packet_data = urb->transfer_buffer + urb->iso_frame_desc[i].offset;

		/* Detect and ignore errored packets */
		if (packet_stat) {	// packet_stat != 0 ?????????????
			PDEBUG(DBG_ISOC, "data error: [%d] len=%d, status=%X", i, packet_len, packet_stat);
			usbvision->isocErrCount++;
			continue;
		}

		/* Detect and ignore empty packets */
		if (packet_len < 0) {
			PDEBUG(DBG_ISOC, "error packet [%d]", i);
			usbvision->isocSkipCount++;
			continue;
		}
		else if (packet_len == 0) {	/* Frame end ????? */
			PDEBUG(DBG_ISOC, "null packet [%d]", i);
			usbvision->isocstate=IsocState_NoFrame;
			usbvision->isocSkipCount++;
			continue;
		}
		else if (packet_len > usbvision->isocPacketSize) {
			PDEBUG(DBG_ISOC, "packet[%d] > isocPacketSize", i);
			usbvision->isocSkipCount++;
			continue;
		}

		PDEBUG(DBG_ISOC, "packet ok [%d] len=%d", i, packet_len);

		if (usbvision->isocstate==IsocState_NoFrame) { //new frame begins
			usbvision->isocstate=IsocState_InFrame;
			scratch_mark_header(usbvision);
			usbvision_measure_bandwidth(usbvision);
			PDEBUG(DBG_ISOC, "packet with header");
		}

		/*
		 * If usbvision continues to feed us with data but there is no
		 * consumption (if, for example, V4L client fell asleep) we
		 * may overflow the buffer. We have to move old data over to
		 * free room for new data. This is bad for old data. If we
		 * just drop new data then it's bad for new data... choose
		 * your favorite evil here.
		 */
		if (scratch_free(usbvision) < packet_len) {

			usbvision->scratch_ovf_count++;
			PDEBUG(DBG_ISOC, "scratch buf overflow! scr_len: %d, n: %d",
			       scratch_len(usbvision), packet_len);
			scratch_rm_old(usbvision, packet_len - scratch_free(usbvision));
		}

		/* Now we know that there is enough room in scratch buffer */
		scratch_put(usbvision, packet_data, packet_len);
		totlen += packet_len;
		usbvision->isocDataCount += packet_len;
		usbvision->isocPacketCount++;
	}
#if ENABLE_HEXDUMP
	if (totlen > 0) {
		static int foo = 0;
		if (foo < 1) {
			printk(KERN_DEBUG "+%d.\n", usbvision->scratchlen);
			usbvision_hexdump(data0, (totlen > 64) ? 64 : totlen);
			++foo;
		}
	}
#endif
 return totlen;
}

static void usbvision_isocIrq(struct urb *urb, struct pt_regs *regs)
{
 int errCode = 0;
 int len;
 struct usb_usbvision *usbvision = urb->context;
 int i;
 unsigned long startTime = jiffies;

 /* We don't want to do anything if we are about to be removed! */
 if (!USBVISION_IS_OPERATIONAL(usbvision))
  return;

 if (!usbvision->streaming) {
  PDEBUG(DBG_IRQ, "oops, not streaming, but interrupt");
  return;
 }

 /* Copy the data received into our scratch buffer */
 len = usbvision_compress_isochronous(usbvision, urb);

 usbvision->isocUrbCount++;
 usbvision->urb_length = len;

 for (i = 0; i < USBVISION_URB_FRAMES; i++) {
  urb->iso_frame_desc[i].status = 0;
  urb->iso_frame_desc[i].actual_length = 0;
 }
 	urb->status = 0;
	urb->dev = usbvision->dev;
	errCode = usb_submit_urb (urb, GFP_ATOMIC);

/* Disable this warning.  By design of the driver. */
//	if(errCode) {
//		err("%s: usb_submit_urb failed: error %d", __FUNCTION__, errCode);
//	}

	/* If we collected enough data let's parse! */
	if (scratch_len(usbvision) > USBVISION_HEADER_LENGTH) {	/* 12 == header_length */
		/*If we don't have a frame we're current working on, complain */
		if ((usbvision->curFrameNum >= 0) || (usbvision->overlay))
			usbvision_parse_data(usbvision);
		else {
			PDEBUG(DBG_IRQ, "received data, but no one needs it");
			scratch_reset(usbvision);
		}
	}
	usbvision->timeInIrq += jiffies - startTime;
	return;
}

/*************************************/
/* Low level usbvision access functions */
/*************************************/

/*
 * usbvision_read_reg()
 *
 * return  < 0 -> Error
 *        >= 0 -> Data
 */

static int usbvision_read_reg(struct usb_usbvision *usbvision, unsigned char reg)
{
	int errCode = 0;
	unsigned char buffer[1];

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return -1;

	errCode = usb_control_msg(usbvision->dev, usb_rcvctrlpipe(usbvision->dev, 1),
				USBVISION_OP_CODE,
				USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
				0, (__u16) reg, buffer, 1, HZ);

	if (errCode < 0) {
		err("%s: failed: error %d", __FUNCTION__, errCode);
		return errCode;
	}
	return buffer[0];
}

/*
 * usbvision_write_reg()
 *
 * return 1 -> Reg written
 *        0 -> usbvision is not yet ready
 *       -1 -> Something went wrong
 */

static int usbvision_write_reg(struct usb_usbvision *usbvision, unsigned char reg,
			    unsigned char value)
{
	int errCode = 0;

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return 0;

	errCode = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
				USBVISION_OP_CODE,
				USB_DIR_OUT | USB_TYPE_VENDOR |
				USB_RECIP_ENDPOINT, 0, (__u16) reg, &value, 1, HZ);

	if (errCode < 0) {
		err("%s: failed: error %d", __FUNCTION__, errCode);
	}
	return errCode;
}


static void usbvision_ctrlUrb_complete(struct urb *urb, struct pt_regs *regs)
{
	struct usb_usbvision *usbvision = (struct usb_usbvision *)urb->context;

	PDEBUG(DBG_IRQ, "");
	usbvision->ctrlUrbBusy = 0;
	if (waitqueue_active(&usbvision->ctrlUrb_wq)) {
		wake_up_interruptible(&usbvision->ctrlUrb_wq);
	}
}


static int usbvision_write_reg_irq(struct usb_usbvision *usbvision,int address,
									unsigned char *data, int len)
{
	int errCode = 0;

	PDEBUG(DBG_IRQ, "");
	if (len > 8) {
		return -EFAULT;
	}
//	down(&usbvision->ctrlUrbLock);
	if (usbvision->ctrlUrbBusy) {
//		up(&usbvision->ctrlUrbLock);
		return -EBUSY;
	}
	usbvision->ctrlUrbBusy = 1;
//	up(&usbvision->ctrlUrbLock);

	usbvision->ctrlUrbSetup.bRequestType = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT;
	usbvision->ctrlUrbSetup.bRequest     = USBVISION_OP_CODE;
	usbvision->ctrlUrbSetup.wValue       = 0;
	usbvision->ctrlUrbSetup.wIndex       = cpu_to_le16(address);
	usbvision->ctrlUrbSetup.wLength      = cpu_to_le16(len);
	usb_fill_control_urb (usbvision->ctrlUrb, usbvision->dev,
							usb_sndctrlpipe(usbvision->dev, 1),
							(unsigned char *)&usbvision->ctrlUrbSetup,
							(void *)usbvision->ctrlUrbBuffer, len,
							usbvision_ctrlUrb_complete,
							(void *)usbvision);

	memcpy(usbvision->ctrlUrbBuffer, data, len);

	errCode = usb_submit_urb(usbvision->ctrlUrb, GFP_ATOMIC);
	if (errCode < 0) {
		// error in usb_submit_urb()
		usbvision->ctrlUrbBusy = 0;
	}
	PDEBUG(DBG_IRQ, "submit %d byte: error %d", len, errCode);
	return errCode;
}




static int usbvision_init_compression(struct usb_usbvision *usbvision)
{
	int errCode = 0;

	usbvision->lastIsocFrameNum = -1;
	usbvision->isocDataCount = 0;
	usbvision->isocPacketCount = 0;
	usbvision->isocSkipCount = 0;
	usbvision->comprLevel = 50;
	usbvision->lastComprLevel = -1;
	usbvision->isocUrbCount = 0;
	usbvision->requestIntra = 1;
	usbvision->isocMeasureBandwidthCount = 0;

	return errCode;
}

/* this function measures the used bandwidth since last call
 * return:    0 : no error
 * sets usedBandwidth to 1-100 : 1-100% of full bandwidth resp. to isocPacketSize
 */
static int usbvision_measure_bandwidth (struct usb_usbvision *usbvision)
{
	int errCode = 0;

	if (usbvision->isocMeasureBandwidthCount < 2) { // this gives an average bandwidth of 3 frames
		usbvision->isocMeasureBandwidthCount++;
		return errCode;
	}
	if ((usbvision->isocPacketSize > 0) && (usbvision->isocPacketCount > 0)) {
		usbvision->usedBandwidth = usbvision->isocDataCount /
					(usbvision->isocPacketCount + usbvision->isocSkipCount) *
					100 / usbvision->isocPacketSize;
	}
	usbvision->isocMeasureBandwidthCount = 0;
	usbvision->isocDataCount = 0;
	usbvision->isocPacketCount = 0;
	usbvision->isocSkipCount = 0;
	return errCode;
}

static int usbvision_adjust_compression (struct usb_usbvision *usbvision)
{
	int errCode = 0;
	unsigned char buffer[6];

	PDEBUG(DBG_IRQ, "");
	if ((adjustCompression) && (usbvision->usedBandwidth > 0)) {
		usbvision->comprLevel += (usbvision->usedBandwidth - 90) / 2;
		RESTRICT_TO_RANGE(usbvision->comprLevel, 0, 100);
		if (usbvision->comprLevel != usbvision->lastComprLevel) {
			int distorsion;
			if (usbvision->bridgeType == BRIDGE_NT1004 || usbvision->bridgeType == BRIDGE_NT1005) {
				buffer[0] = (unsigned char)(4 + 16 * usbvision->comprLevel / 100);	// PCM Threshold 1
				buffer[1] = (unsigned char)(4 + 8 * usbvision->comprLevel / 100);	// PCM Threshold 2
				distorsion = 7 + 248 * usbvision->comprLevel / 100;
				buffer[2] = (unsigned char)(distorsion & 0xFF);				// Average distorsion Threshold (inter)
				buffer[3] = (unsigned char)(distorsion & 0xFF);				// Average distorsion Threshold (intra)
				distorsion = 1 + 42 * usbvision->comprLevel / 100;
				buffer[4] = (unsigned char)(distorsion & 0xFF);				// Maximum distorsion Threshold (inter)
				buffer[5] = (unsigned char)(distorsion & 0xFF);				// Maximum distorsion Threshold (intra)
			}
			else { //BRIDGE_NT1003
				buffer[0] = (unsigned char)(4 + 16 * usbvision->comprLevel / 100);	// PCM threshold 1
				buffer[1] = (unsigned char)(4 + 8 * usbvision->comprLevel / 100);	// PCM threshold 2
				distorsion = 2 + 253 * usbvision->comprLevel / 100;
				buffer[2] = (unsigned char)(distorsion & 0xFF);				// distorsion threshold bit0-7
				buffer[3] = 0; 	//(unsigned char)((distorsion >> 8) & 0x0F);		// distorsion threshold bit 8-11
				distorsion = 0 + 43 * usbvision->comprLevel / 100;
				buffer[4] = (unsigned char)(distorsion & 0xFF);				// maximum distorsion bit0-7
				buffer[5] = 0; //(unsigned char)((distorsion >> 8) & 0x01);		// maximum distorsion bit 8
			}
			errCode = usbvision_write_reg_irq(usbvision, USBVISION_PCM_THR1, buffer, 6);
			if (errCode == 0){
				PDEBUG(DBG_IRQ, "new compr params %#02x %#02x %#02x %#02x %#02x %#02x", buffer[0],
								buffer[1], buffer[2], buffer[3], buffer[4], buffer[5]);
				usbvision->lastComprLevel = usbvision->comprLevel;
			}
		}
	}
	return errCode;
}

static int usbvision_request_intra (struct usb_usbvision *usbvision)
{
	int errCode = 0;
	unsigned char buffer[1];

	PDEBUG(DBG_IRQ, "");
	usbvision->requestIntra = 1;
	buffer[0] = 1;
	usbvision_write_reg_irq(usbvision, USBVISION_FORCE_INTRA, buffer, 1);
	return errCode;
}

static int usbvision_unrequest_intra (struct usb_usbvision *usbvision)
{
	int errCode = 0;
	unsigned char buffer[1];

	PDEBUG(DBG_IRQ, "");
	usbvision->requestIntra = 0;
	buffer[0] = 0;
	usbvision_write_reg_irq(usbvision, USBVISION_FORCE_INTRA, buffer, 1);
	return errCode;
}

/* ----------------------------------------------------------------------- */
/* I2C functions                                                           */
/* ----------------------------------------------------------------------- */

static void call_i2c_clients(struct usb_usbvision *usbvision, unsigned int cmd,
			     void *arg)
{

	int i;

	for (i = 0; i < USBVISION_I2C_CLIENTS_MAX; i++) {
		if (NULL == usbvision->i2c_clients[i])
			continue;
		if (NULL == usbvision->i2c_clients[i]->driver->command)
			continue;
		usbvision->i2c_clients[i]->driver->command(usbvision->i2c_clients[i], cmd, arg);
	}
}

static int attach_inform(struct i2c_client *client)
{
	struct usb_usbvision *usbvision;
	struct tuner_setup tun_addr;
	int i;
	v4l2_std_id stdId;

	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
		usbvision = (struct usb_usbvision *)client->adapter->data;
	#else
		usbvision = (struct usb_usbvision *)i2c_get_adapdata(client->adapter);
	#endif

	for (i = 0; i < USBVISION_I2C_CLIENTS_MAX; i++) {
		if (usbvision->i2c_clients[i] == NULL ||
		    usbvision->i2c_clients[i]->driver->id ==
		    client->driver->id) {
			usbvision->i2c_clients[i] = client;
			break;
		}
	}
	if ((usbvision->have_tuner) && (usbvision->tuner_type != -1)) {
		tun_addr.mode_mask = T_ANALOG_TV;
                tun_addr.type = usbvision->tuner_type;
                tun_addr.addr = ADDR_UNSET;
                client->driver->command(client,TUNER_SET_TYPE_ADDR, &tun_addr);
                
		call_i2c_clients(usbvision, VIDIOC_S_INPUT, &usbvision->input.index);
	}
	// FIXME : need to add a call VIDIOC_S_CTRL for each control
/* 	call_i2c_clients(usbvision, DECODER_SET_PICTURE, &usbvision->vpic); */
	stdId = usbvision->input.std;
	call_i2c_clients(usbvision, VIDIOC_S_STD, &stdId);

	PDEBUG(DBG_I2C, "usbvision[%d] attaches %s", usbvision->nr, client->name);

	return 0;
}

static int detach_inform(struct i2c_client *client)
{
	struct usb_usbvision *usbvision;
	int i;

	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
		usbvision = (struct usb_usbvision *)client->adapter->data;
	#else
		usbvision = (struct usb_usbvision *)i2c_get_adapdata(client->adapter);
	#endif

	PDEBUG(DBG_I2C, "usbvision[%d] detaches %s", usbvision->nr, client->name);
	for (i = 0; i < USBVISION_I2C_CLIENTS_MAX; i++) {
		if (NULL != usbvision->i2c_clients[i] &&
		    usbvision->i2c_clients[i]->driver->id ==
		    client->driver->id) {
			usbvision->i2c_clients[i] = NULL;
			break;
		}
	}
	return 0;
}

static int
usbvision_i2c_read_max4(struct usb_usbvision *usbvision, unsigned char addr,
		     char *buf, short len)
{
	int rc, retries;

	for (retries = 5;;) {
		rc = usbvision_write_reg(usbvision, USBVISION_SER_ADRS, addr);
		if (rc < 0)
			return rc;

		/* Initiate byte read cycle                    */
		/* USBVISION_SER_CONT <- d0-d2 n. of bytes to r/w */
		/*                    d3 0=Wr 1=Rd             */
		rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
				      (len & 0x07) | 0x18);
		if (rc < 0)
			return rc;

		/* Test for Busy and ACK */
		do {
			/* USBVISION_SER_CONT -> d4 == 0 busy */
			rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
		} while (rc > 0 && ((rc & 0x10) != 0));	/* Retry while busy */
		if (rc < 0)
			return rc;

		/* USBVISION_SER_CONT -> d5 == 1 Not ack */
		if ((rc & 0x20) == 0)	/* Ack? */
			break;

		/* I2C abort */
		rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);
		if (rc < 0)
			return rc;

		if (--retries < 0)
			return -1;
	}

	switch (len) {
	case 4:
		buf[3] = usbvision_read_reg(usbvision, USBVISION_SER_DAT4);
	case 3:
		buf[2] = usbvision_read_reg(usbvision, USBVISION_SER_DAT3);
	case 2:
		buf[1] = usbvision_read_reg(usbvision, USBVISION_SER_DAT2);
	case 1:
		buf[0] = usbvision_read_reg(usbvision, USBVISION_SER_DAT1);
		break;
	default:
		printk(KERN_ERR
		       "usbvision_i2c_read_max4: buffer length > 4\n");
	}

	if (debug & DBG_I2C) {
		int idx;
		for (idx = 0; idx < len; idx++) {
			PDEBUG(DBG_I2C, "read %x from address %x", (unsigned char)buf[idx], addr);
		}
	}
	return len;
}


static int usbvision_i2c_write_max4(struct usb_usbvision *usbvision,
				 unsigned char addr, const char *buf,
				 short len)
{
	int rc, retries;
	int i;
	unsigned char value[6];
	unsigned char ser_cont;

	ser_cont = (len & 0x07) | 0x10;

	value[0] = addr;
	value[1] = ser_cont;
	for (i = 0; i < len; i++)
		value[i + 2] = buf[i];

	for (retries = 5;;) {
		rc = usb_control_msg(usbvision->dev,
				     usb_sndctrlpipe(usbvision->dev, 1),
				     USBVISION_OP_CODE,
				     USB_DIR_OUT | USB_TYPE_VENDOR |
				     USB_RECIP_ENDPOINT, 0,
				     (__u16) USBVISION_SER_ADRS, value,
				     len + 2, HZ);

		if (rc < 0)
			return rc;

		rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
				      (len & 0x07) | 0x10);
		if (rc < 0)
			return rc;

		/* Test for Busy and ACK */
		do {
			rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
		} while (rc > 0 && ((rc & 0x10) != 0));	/* Retry while busy */
		if (rc < 0)
			return rc;

		if ((rc & 0x20) == 0)	/* Ack? */
			break;

		/* I2C abort */
		usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);

		if (--retries < 0)
			return -1;

	}

	if (debug & DBG_I2C) {
		int idx;
		for (idx = 0; idx < len; idx++) {
			PDEBUG(DBG_I2C, "wrote %x at address %x", (unsigned char)buf[idx], addr);
		}
	}
	return len;
}

static int usbvision_i2c_write(void *data, unsigned char addr, char *buf,
			    short len)
{
	char *bufPtr = buf;
	int retval;
	int wrcount = 0;
	int count;
 	int maxLen = 4;
	struct usb_usbvision *usbvision = (struct usb_usbvision *) data;

	while (len > 0) {
		count = (len > maxLen) ? maxLen : len;
		retval = usbvision_i2c_write_max4(usbvision, addr, bufPtr, count);
		if (retval > 0) {
			len -= count;
			bufPtr += count;
			wrcount += count;
		} else
			return (retval < 0) ? retval : -EFAULT;
	}
	return wrcount;
}

static int usbvision_i2c_read(void *data, unsigned char addr, char *buf,
			   short len)
{
	char temp[4];
	int retval, i;
	int rdcount = 0;
	int count;
	struct usb_usbvision *usbvision = (struct usb_usbvision *) data;

	while (len > 0) {
		count = (len > 3) ? 4 : len;
		retval = usbvision_i2c_read_max4(usbvision, addr, temp, count);
		if (retval > 0) {
			for (i = 0; i < len; i++)
				buf[rdcount + i] = temp[i];
			len -= count;
			rdcount += count;
		} else
			return (retval < 0) ? retval : -EFAULT;
	}
	return rdcount;
}

static struct i2c_algo_usb_data i2c_algo_template = {
	.data		= NULL,
	.inb		= usbvision_i2c_read,
	.outb		= usbvision_i2c_write,
	.udelay		= 10,
	.mdelay		= 10,
	.timeout	= 100,
};

static struct i2c_adapter i2c_adap_template = {
	.owner             = THIS_MODULE,
	.name              = "usbvision",
	.id                = I2C_HW_B_BT848, /* FIXME */
	.algo              = NULL,
	.algo_data         = NULL,
	.client_register   = attach_inform,
	.client_unregister = detach_inform,
#if defined (I2C_ADAP_CLASS_TV_ANALOG)
	.class             = I2C_ADAP_CLASS_TV_ANALOG,
#elif defined (I2C_CLASS_TV_ANALOG)
	.class		   = I2C_CLASS_TV_ANALOG,
#endif
};

static struct i2c_client i2c_client_template = {
	.name		= "usbvision internal",
	.flags		= 0,
	.addr		= 0,
	.adapter	= NULL,
	.driver		= NULL,
};

static int usbvision_init_i2c(struct usb_usbvision *usbvision)
{
	memcpy(&usbvision->i2c_adap, &i2c_adap_template,
	       sizeof(struct i2c_adapter));
	memcpy(&usbvision->i2c_algo, &i2c_algo_template,
	       sizeof(struct i2c_algo_usb_data));
	memcpy(&usbvision->i2c_client, &i2c_client_template,
	       sizeof(struct i2c_client));

	sprintf(usbvision->i2c_adap.name + strlen(usbvision->i2c_adap.name),
		" #%d", usbvision->vdev->minor & 0x1f);
	PDEBUG(DBG_I2C, "Adaptername: %s", usbvision->i2c_adap.name);

	i2c_set_adapdata(&usbvision->i2c_adap, usbvision);
	i2c_set_clientdata(&usbvision->i2c_client, usbvision);
	i2c_set_algo_usb_data(&usbvision->i2c_algo, usbvision);

	usbvision->i2c_adap.algo_data = &usbvision->i2c_algo;
	usbvision->i2c_client.adapter = &usbvision->i2c_adap;

	if (usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_IIC_LRNACK) < 0) {
		printk(KERN_ERR "usbvision_init_i2c: can't wirte reg\n");
		return -EBUSY;
	}

#ifdef CONFIG_KMOD
	/* Request the load of the i2c modules we need */
	if (autoload) {
		switch (usbvision_device_data[usbvision->DevModel].Codec) {
			case CODEC_SAA7113:
				request_module("saa7115");
				break;
			case CODEC_SAA7111:
				request_module("saa7115");
				break;
		}
		if (usbvision_device_data[usbvision->DevModel].Tuner == 1) {
		    	request_module("tuner");
		}
	}
#endif

	usbvision->i2c_ok = usbvision_i2c_usb_add_bus(&usbvision->i2c_adap);

	return usbvision->i2c_ok;

}


/****************************/
/* usbvision utility functions */
/****************************/

static int usbvision_power_off(struct usb_usbvision *usbvision)
{
	int errCode = 0;

	PDEBUG(DBG_FUNC, "");

	errCode = usbvision_write_reg(usbvision, USBVISION_PWR_REG, USBVISION_SSPND_EN);
	if (errCode == 1) {
		usbvision->power = 0;
	}
	PDEBUG(DBG_FUNC, "%s: errCode %d", (errCode!=1)?"ERROR":"power is off", errCode);
	return errCode;
}


// to call usbvision_power_off from task queue
static void call_usbvision_power_off(void *_usbvision)
{
	struct usb_usbvision *usbvision = _usbvision;

	PDEBUG(DBG_FUNC, "");
	down_interruptible(&usbvision->lock);
	if(usbvision->user == 0) {
		usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
		usbvision_power_off(usbvision);
		usbvision->initialized = 0;
	}
	up(&usbvision->lock);
}


/*
 * usbvision_set_video_format()
 *
 */
static int usbvision_set_video_format(struct usb_usbvision *usbvision, int format)
{
	static const char proc[] = "usbvision_set_video_format";
	int rc;
	unsigned char value[2];

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return 0;

	PDEBUG(DBG_FUNC, "isocMode %#02x", format);

	if ((format != ISOC_MODE_YUV422)
	    && (format != ISOC_MODE_YUV420)
	    && (format != ISOC_MODE_COMPRESS)) {
		printk(KERN_ERR "usbvision: unknown video format %02x, using default YUV420",
		       format);
		format = ISOC_MODE_YUV420;
	}
	value[0] = 0x0A;  //TODO: See the effect of the filter
	value[1] = format;
	rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
			     USBVISION_OP_CODE,
			     USB_DIR_OUT | USB_TYPE_VENDOR |
			     USB_RECIP_ENDPOINT, 0,
			     (__u16) USBVISION_FILT_CONT, value, 2, HZ);

	if (rc < 0) {
		printk(KERN_ERR "%s: ERROR=%d. USBVISION stopped - "
		       "reconnect or reload driver.\n", proc, rc);
	}
	usbvision->isocMode = format;
	return rc;
}

/*
 * usbvision_set_output()
 *
 */

static int usbvision_set_output(struct usb_usbvision *usbvision, int width,
				  int height)
{
	int errCode = 0;
	int UsbWidth, UsbHeight;
	unsigned int frameRate=0, frameDrop=0;
	unsigned char value[4];

	if (!USBVISION_IS_OPERATIONAL(usbvision)) {
		return 0;
	}

	if (width > MAX_USB_WIDTH) {
		UsbWidth = width / 2;
		usbvision->stretch_width = 2;
	}
	else {
		UsbWidth = width;
		usbvision->stretch_width = 1;
	}

	if (height > MAX_USB_HEIGHT) {
		UsbHeight = height / 2;
		usbvision->stretch_height = 2;
	}
	else {
		UsbHeight = height;
		usbvision->stretch_height = 1;
	}

	RESTRICT_TO_RANGE(UsbWidth, MIN_FRAME_WIDTH, MAX_USB_WIDTH);
	UsbWidth &= ~(MIN_FRAME_WIDTH-1);
	RESTRICT_TO_RANGE(UsbHeight, MIN_FRAME_HEIGHT, MAX_USB_HEIGHT);
	UsbHeight &= ~(1);

	PDEBUG(DBG_FUNC, "usb %dx%d; screen %dx%d; stretch %dx%d",
						UsbWidth, UsbHeight, width, height,
						usbvision->stretch_width, usbvision->stretch_height);

	/* I'll not rewrite the same values */
	if ((UsbWidth != usbvision->curwidth) || (UsbHeight != usbvision->curheight)) {
		value[0] = UsbWidth & 0xff;		//LSB
		value[1] = (UsbWidth >> 8) & 0x03;	//MSB
		value[2] = UsbHeight & 0xff;		//LSB
		value[3] = (UsbHeight >> 8) & 0x03;	//MSB

		errCode = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
			     USBVISION_OP_CODE,
			     USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
				 0, (__u16) USBVISION_LXSIZE_O, value, 4, HZ);

		if (errCode < 0) {
			err("%s failed: error %d", __FUNCTION__, errCode);
			return errCode;
		}
		usbvision->curwidth = usbvision->stretch_width * UsbWidth;
		usbvision->curheight = usbvision->stretch_height * UsbHeight;
	}

	if (usbvision->isocMode == ISOC_MODE_YUV422) {
		frameRate = (usbvision->isocPacketSize * 1000) / (UsbWidth * UsbHeight * 2);
	}
	else if (usbvision->isocMode == ISOC_MODE_YUV420) {
		frameRate = (usbvision->isocPacketSize * 1000) / ((UsbWidth * UsbHeight * 12) / 8);
	}
	else {
		frameRate = FRAMERATE_MAX;
	}

	if (usbvision->input.std & V4L2_STD_625_50) {
 		frameDrop = frameRate * 32 / 25 - 1;
	}
	else if (usbvision->input.std & V4L2_STD_525_60) {
		frameDrop = frameRate * 32 / 30 - 1;
	}

	RESTRICT_TO_RANGE(frameDrop, FRAMERATE_MIN, FRAMERATE_MAX);

	PDEBUG(DBG_FUNC, "frameRate %d fps, frameDrop %d", frameRate, frameDrop);

	frameDrop = FRAMERATE_MAX; 	// We can allow the maximum here, because dropping is controlled

	/* frameDrop = 7; => framePhase = 1, 5, 9, 13, 17, 21, 25, 0, 4, 8, ...
		=> frameSkip = 4;
		=> frameRate = (7 + 1) * 25 / 32 = 200 / 32 = 6.25;

	   frameDrop = 9; => framePhase = 1, 5, 8, 11, 14, 17, 21, 24, 27, 1, 4, 8, ...
	    => frameSkip = 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 4, ...
		=> frameRate = (9 + 1) * 25 / 32 = 250 / 32 = 7.8125;
	*/
	errCode = usbvision_write_reg(usbvision, USBVISION_FRM_RATE, frameDrop);
	return errCode;
}


/*
 * usbvision_set_compress_params()
 *
 */

static int usbvision_set_compress_params(struct usb_usbvision *usbvision)
{
	static const char proc[] = "usbvision_set_compresion_params: ";
	int rc;
	unsigned char value[6];

	value[0] = 0x0F;    // Intra-Compression cycle
	value[1] = 0x01;    // Reg.45 one line per strip
	value[2] = 0x00;    // Reg.46 Force intra mode on all new frames
	value[3] = 0x00;    // Reg.47 FORCE_UP <- 0 normal operation (not force)
	value[4] = 0xA2;    // Reg.48 BUF_THR I'm not sure if this does something in not compressed mode.
        value[5] = 0x00;    // Reg.49 DVI_YUV This has nothing to do with compression

	//catched values for NT1004
	// value[0] = 0xFF; // Never apply intra mode automatically
	// value[1] = 0xF1; // Use full frame height for virtual strip width; One line per strip
	// value[2] = 0x01; // Force intra mode on all new frames
	// value[3] = 0x00; // Strip size 400 Bytes; do not force up
	// value[4] = 0xA2; //
	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return 0;

	rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
			     USBVISION_OP_CODE,
			     USB_DIR_OUT | USB_TYPE_VENDOR |
			     USB_RECIP_ENDPOINT, 0,
			     (__u16) USBVISION_INTRA_CYC, value, 5, HZ);

	if (rc < 0) {
		printk(KERN_ERR "%sERROR=%d. USBVISION stopped - "
		       "reconnect or reload driver.\n", proc, rc);
		return rc;
	}

	if (usbvision->bridgeType == BRIDGE_NT1004) {
		value[0] =  20; // PCM Threshold 1
		value[1] =  12; // PCM Threshold 2
		value[2] = 255; // Distorsion Threshold inter
		value[3] = 255; // Distorsion Threshold intra
		value[4] =  43; // Max Distorsion inter
		value[5] =  43; // Max Distorsion intra
	}
	else {
		value[0] =  20; // PCM Threshold 1
		value[1] =  12; // PCM Threshold 2
		value[2] = 255; // Distorsion Threshold d7-d0
		value[3] =   0; // Distorsion Threshold d11-d8
		value[4] =  43; // Max Distorsion d7-d0
		value[5] =   0; // Max Distorsion d8
	}

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return 0;

	rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
			     USBVISION_OP_CODE,
			     USB_DIR_OUT | USB_TYPE_VENDOR |
			     USB_RECIP_ENDPOINT, 0,
			     (__u16) USBVISION_PCM_THR1, value, 6, HZ);

	if (rc < 0) {
		printk(KERN_ERR "%sERROR=%d. USBVISION stopped - "
		       "reconnect or reload driver.\n", proc, rc);
		return rc;
	}


	return rc;
}


/*
 * usbvision_set_input()
 *
 * Set the input (saa711x, ...) size x y and other misc input params
 * I've no idea if this parameters are right
 *
 */
static int usbvision_set_input(struct usb_usbvision *usbvision)
{
	static const char proc[] = "usbvision_set_input: ";
	int rc;
	unsigned char value[8];
	unsigned char dvi_yuv_value;

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return 0;

	/* Set input format expected from decoder*/
	if (usbvision_device_data[usbvision->DevModel].Vin_Reg1 >= 0) {
		value[0] = usbvision_device_data[usbvision->DevModel].Vin_Reg1 & 0xff;
	} else if(usbvision_device_data[usbvision->DevModel].Codec == CODEC_SAA7113) {
		/* SAA7113 uses 8 bit output */
		value[0] = USBVISION_8_422_SYNC;
	} else {
		/* I'm sure only about d2-d0 [010] 16 bit 4:2:2 usin sync pulses
		 * as that is how saa7111 is configured */
		value[0] = USBVISION_16_422_SYNC;
		/* | USBVISION_VSNC_POL | USBVISION_VCLK_POL);*/
	}

	rc = usbvision_write_reg(usbvision, USBVISION_VIN_REG1, value[0]);
	if (rc < 0) {
		printk(KERN_ERR "%sERROR=%d. USBVISION stopped - "
		       "reconnect or reload driver.\n", proc, rc);
		return rc;
	}


	if (usbvision->input.std & V4L2_STD_PAL) {
		value[0] = 0xC0;
		value[1] = 0x02;	//0x02C0 -> 704 Input video line length
		value[2] = 0x20;
		value[3] = 0x01;	//0x0120 -> 288 Input video n. of lines
		value[4] = 0x60;
		value[5] = 0x00;	//0x0060 -> 96 Input video h offset
		value[6] = 0x16;
		value[7] = 0x00;	//0x0016 -> 22 Input video v offset
	} else if (usbvision->input.std & V4L2_STD_SECAM) {
		value[0] = 0xC0;
		value[1] = 0x02;	//0x02C0 -> 704 Input video line length
		value[2] = 0x20;
		value[3] = 0x01;	//0x0120 -> 288 Input video n. of lines
		value[4] = 0x01;
		value[5] = 0x00;	//0x0001 -> 01 Input video h offset
		value[6] = 0x01;
		value[7] = 0x00;	//0x0001 -> 01 Input video v offset
	} else {	/* V4L2_STD_NTSC */
		value[0] = 0xD0;
		value[1] = 0x02;	//0x02D0 -> 720 Input video line length
		value[2] = 0xF0;
		value[3] = 0x00;	//0x00F0 -> 240 Input video number of lines
		value[4] = 0x50;
		value[5] = 0x00;	//0x0050 -> 80 Input video h offset
		value[6] = 0x10;
		value[7] = 0x00;	//0x0010 -> 16 Input video v offset
	}

	if (usbvision_device_data[usbvision->DevModel].X_Offset >= 0) {
		value[4]=usbvision_device_data[usbvision->DevModel].X_Offset & 0xff;
		value[5]=(usbvision_device_data[usbvision->DevModel].X_Offset & 0x0300) >> 8;
	}

	if (usbvision_device_data[usbvision->DevModel].Y_Offset >= 0) {
		value[6]=usbvision_device_data[usbvision->DevModel].Y_Offset & 0xff;
		value[7]=(usbvision_device_data[usbvision->DevModel].Y_Offset & 0x0300) >> 8;
	}

	rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
			     USBVISION_OP_CODE,	/* USBVISION specific code */
			     USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT, 0,
			     (__u16) USBVISION_LXSIZE_I, value, 8, HZ);
	if (rc < 0) {
		printk(KERN_ERR "%sERROR=%d. USBVISION stopped - "
		       "reconnect or reload driver.\n", proc, rc);
		return rc;
	}


	dvi_yuv_value = 0x00;	/* U comes after V, Ya comes after U/V, Yb comes after Yb */

	if(usbvision_device_data[usbvision->DevModel].Dvi_yuv >= 0){
		dvi_yuv_value = usbvision_device_data[usbvision->DevModel].Dvi_yuv & 0xff;
	}
	else if(usbvision_device_data[usbvision->DevModel].Codec == CODEC_SAA7113) {
        /* This changes as the fine sync control changes. Further investigation necessary */
		dvi_yuv_value = 0x06;
	}

	return (usbvision_write_reg(usbvision, USBVISION_DVI_YUV, dvi_yuv_value));
}


/*
 * usbvision_set_dram_settings()
 *
 * Set the buffer address needed by the usbvision dram to operate
 * This values has been taken with usbsnoop.
 *
 */

static int usbvision_set_dram_settings(struct usb_usbvision *usbvision)
{
	int rc;
	unsigned char value[8];

	if (usbvision->isocMode == ISOC_MODE_COMPRESS) {
		value[0] = 0x42;
		value[1] = 0x71;
		value[2] = 0xff;
		value[3] = 0x00;
		value[4] = 0x98;
		value[5] = 0xe0;
		value[6] = 0x71;
		value[7] = 0xff;
		// UR:  0x0E200-0x3FFFF = 204288 Words (1 Word = 2 Byte)
		// FDL: 0x00000-0x0E099 =  57498 Words
		// VDW: 0x0E3FF-0x3FFFF
	}
	else {
		value[0] = 0x42;
		value[1] = 0x00;
		value[2] = 0xff;
		value[3] = 0x00;
		value[4] = 0x00;
		value[5] = 0x00;
		value[6] = 0x00;
		value[7] = 0xff;
	}
	/* These are the values of the address of the video buffer,
	 * they have to be loaded into the USBVISION_DRM_PRM1-8
	 *
	 * Start address of video output buffer for read: 	drm_prm1-2 -> 0x00000
	 * End address of video output buffer for read: 	drm_prm1-3 -> 0x1ffff
	 * Start address of video frame delay buffer: 		drm_prm1-4 -> 0x20000
	 *    Only used in compressed mode
	 * End address of video frame delay buffer: 		drm_prm1-5-6 -> 0x3ffff
	 *    Only used in compressed mode
	 * Start address of video output buffer for write: 	drm_prm1-7 -> 0x00000
	 * End address of video output buffer for write: 	drm_prm1-8 -> 0x1ffff
	 */

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return 0;

	rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
			     USBVISION_OP_CODE,	/* USBVISION specific code */
			     USB_DIR_OUT | USB_TYPE_VENDOR |
			     USB_RECIP_ENDPOINT, 0,
			     (__u16) USBVISION_DRM_PRM1, value, 8, HZ);

	if (rc < 0) {
		err("%sERROR=%d", __FUNCTION__, rc);
		return rc;
	}

	/* Restart the video buffer logic */
	if ((rc = usbvision_write_reg(usbvision, USBVISION_DRM_CONT, USBVISION_RES_UR |
				   USBVISION_RES_FDL | USBVISION_RES_VDW)) < 0)
		return rc;
	rc = usbvision_write_reg(usbvision, USBVISION_DRM_CONT, 0x00);

	return rc;
}

/*
 * ()
 *
 * Power on the device, enables suspend-resume logic
 * &  reset the isoc End-Point
 *
 */

static int usbvision_power_on(struct usb_usbvision *usbvision)
{
	int errCode = 0;

	PDEBUG(DBG_FUNC, "");

	usbvision_write_reg(usbvision, USBVISION_PWR_REG, USBVISION_SSPND_EN);
	usbvision_write_reg(usbvision, USBVISION_PWR_REG,
			 USBVISION_SSPND_EN | USBVISION_RES2);
	usbvision_write_reg(usbvision, USBVISION_PWR_REG,
			 USBVISION_SSPND_EN | USBVISION_PWR_VID);
	errCode = usbvision_write_reg(usbvision, USBVISION_PWR_REG,
						USBVISION_SSPND_EN | USBVISION_PWR_VID | USBVISION_RES2);
	if (errCode == 1) {
		usbvision->power = 1;
	}
	PDEBUG(DBG_FUNC, "%s: errCode %d", (errCode<0)?"ERROR":"power is on", errCode);
	return errCode;
}


static void usbvision_powerOffTimer(unsigned long data)
{
	struct usb_usbvision *usbvision = (void *) data;

	PDEBUG(DBG_FUNC, "");
	del_timer(&usbvision->powerOffTimer);
	INIT_WORK(&usbvision->powerOffWork, call_usbvision_power_off, usbvision);
	(void) schedule_work(&usbvision->powerOffWork);
	
}


/*
 * usbvision_begin_streaming()
 * Sure you have to put bit 7 to 0, if not incoming frames are droped, but no
 * idea about the rest
 */
static int usbvision_begin_streaming(struct usb_usbvision *usbvision)
{
	int errCode = 0;

	if (usbvision->isocMode == ISOC_MODE_COMPRESS) {
		usbvision_init_compression(usbvision);
	}
	errCode = usbvision_write_reg(usbvision, USBVISION_VIN_REG2, USBVISION_NOHVALID |
										usbvision->Vin_Reg2_Preset);
	return errCode;
}

/*
 * usbvision_restart_isoc()
 * Not sure yet if touching here PWR_REG make loose the config
 */

static int usbvision_restart_isoc(struct usb_usbvision *usbvision)
{
	int ret;

	if (
	    (ret =
	     usbvision_write_reg(usbvision, USBVISION_PWR_REG,
			      USBVISION_SSPND_EN | USBVISION_PWR_VID)) < 0)
		return ret;
	if (
	    (ret =
	     usbvision_write_reg(usbvision, USBVISION_PWR_REG,
			      USBVISION_SSPND_EN | USBVISION_PWR_VID |
			      USBVISION_RES2)) < 0)
		return ret;
	if (
	    (ret =
	     usbvision_write_reg(usbvision, USBVISION_VIN_REG2,
			      USBVISION_KEEP_BLANK | USBVISION_NOHVALID |
				  usbvision->Vin_Reg2_Preset)) < 0) return ret;

	/* TODO: schedule timeout */
	while ((usbvision_read_reg(usbvision, USBVISION_STATUS_REG) && 0x01) != 1);

	return 0;
}

static int usbvision_audio_on(struct usb_usbvision *usbvision)
{
	if (usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, usbvision->AudioChannel) < 0) {
		printk(KERN_ERR "usbvision_audio_on: can't wirte reg\n");
		return -1;
	}
	DEBUG(printk(KERN_DEBUG "usbvision_audio_on: channel %d\n", usbvision->AudioChannel));
	usbvision->AudioMute = 0;
	return 0;
}

static int usbvision_audio_mute(struct usb_usbvision *usbvision)
{
	if (usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, 0x03) < 0) {
		printk(KERN_ERR "usbvision_audio_mute: can't wirte reg\n");
		return -1;
	}
	DEBUG(printk(KERN_DEBUG "usbvision_audio_mute: audio mute\n"));
	usbvision->AudioMute = 1;
	return 0;
}

static int usbvision_audio_off(struct usb_usbvision *usbvision)
{
	if (usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, USBVISION_AUDIO_MUTE) < 0) {
		printk(KERN_ERR "usbvision_audio_off: can't wirte reg\n");
		return -1;
	}
	DEBUG(printk(KERN_DEBUG "usbvision_audio_off: audio off\n"));
	usbvision->AudioMute = 0;
	usbvision->AudioChannel = USBVISION_AUDIO_MUTE;
	return 0;
}

static int usbvision_set_audio(struct usb_usbvision *usbvision, int AudioChannel)
{
	if (!usbvision->AudioMute) {
		if (usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, AudioChannel) < 0) {
			printk(KERN_ERR "usbvision_set_audio: can't write iopin register for audio switching\n");
			return -1;
		}
	}
	DEBUG(printk(KERN_DEBUG "usbvision_set_audio: channel %d\n", AudioChannel));
	usbvision->AudioChannel = AudioChannel;
	return 0;
}

static int usbvision_setup(struct usb_usbvision *usbvision)
{
	usbvision_set_video_format(usbvision, isocMode);
	usbvision_set_dram_settings(usbvision);
	usbvision_set_compress_params(usbvision);
	usbvision_set_input(usbvision);
	usbvision_set_output(usbvision, MAX_USB_WIDTH, MAX_USB_HEIGHT);
	usbvision_restart_isoc(usbvision);
	
	/* cosas del PCM */
	return USBVISION_IS_OPERATIONAL(usbvision);
}


/*
 * usbvision_init_isoc()
 *
 */
static int usbvision_init_isoc(struct usb_usbvision *usbvision)
{
	struct usb_device *dev = usbvision->dev;
	int bufIdx, errCode, regValue;

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return -EFAULT;

	usbvision->curFrameNum = -1;
	scratch_reset(usbvision);

	/* Alternate interface 1 is is the biggest frame size */
	errCode = usb_set_interface(dev, usbvision->iface, usbvision->ifaceAltActive);
	if (errCode < 0) {
		usbvision->last_error = errCode;
		return -EBUSY;
	}

	regValue = (16 - usbvision_read_reg(usbvision, USBVISION_ALTER_REG)) & 0x0F;
	usbvision->isocPacketSize = (regValue == 0) ? 0 : (regValue * 64) - 1;
	PDEBUG(DBG_ISOC, "ISO Packet Length:%d", usbvision->isocPacketSize);

	usbvision->usb_bandwidth = regValue >> 1;
	PDEBUG(DBG_ISOC, "USB Bandwidth Usage: %dMbit/Sec", usbvision->usb_bandwidth);



	/* We double buffer the Iso lists */

	for (bufIdx = 0; bufIdx < USBVISION_NUMSBUF; bufIdx++) {
		int j, k;
		struct urb *urb;

		#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
			urb = usb_alloc_urb(USBVISION_URB_FRAMES);
		#else
			urb = usb_alloc_urb(USBVISION_URB_FRAMES, GFP_KERNEL);
		#endif
		if (urb == NULL) {
			err("%s: usb_alloc_urb() failed", __FUNCTION__);
			return -ENOMEM;
		}
		usbvision->sbuf[bufIdx].urb = urb;
		urb->dev = dev;
		urb->context = usbvision;
		urb->pipe = usb_rcvisocpipe(dev, usbvision->video_endp);
	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
		urb->transfer_flags = USB_ISO_ASAP;
	#else
		urb->transfer_flags = URB_ISO_ASAP;
		urb->interval = 1;
	#endif
		urb->transfer_buffer = usbvision->sbuf[bufIdx].data;
		urb->complete = usbvision_isocIrq;
		urb->number_of_packets = USBVISION_URB_FRAMES;
		urb->transfer_buffer_length =
		    usbvision->isocPacketSize * USBVISION_URB_FRAMES;
		for (j = k = 0; j < USBVISION_URB_FRAMES; j++,
		     k += usbvision->isocPacketSize) {
			urb->iso_frame_desc[j].offset = k;
			urb->iso_frame_desc[j].length = usbvision->isocPacketSize;
		}
	}


	/* Submit all URBs */
	for (bufIdx = 0; bufIdx < USBVISION_NUMSBUF; bufIdx++) {
		#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
			errCode = usb_submit_urb(usbvision->sbuf[bufIdx].urb);
		#else
			errCode = usb_submit_urb(usbvision->sbuf[bufIdx].urb, GFP_KERNEL);
		#endif
		if (errCode) {
			err("%s: usb_submit_urb(%d) failed: error %d", __FUNCTION__, bufIdx, errCode);
		}
	}

	usbvision->streaming = 1;
	PDEBUG(DBG_ISOC, "%s: streaming=1 usbvision->video_endp=$%02x", __FUNCTION__, usbvision->video_endp);
	return 0;
}

/*
 * usbvision_stop_isoc()
 *
 * This procedure stops streaming and deallocates URBs. Then it
 * activates zero-bandwidth alt. setting of the video interface.
 *
 */
static void usbvision_stop_isoc(struct usb_usbvision *usbvision)
{
	int bufIdx, errCode, regValue;

	if (!usbvision->streaming || (usbvision->dev == NULL))
		return;

	/* Unschedule all of the iso td's */
	for (bufIdx = 0; bufIdx < USBVISION_NUMSBUF; bufIdx++) {
		usb_kill_urb(usbvision->sbuf[bufIdx].urb);
		usb_free_urb(usbvision->sbuf[bufIdx].urb);
		usbvision->sbuf[bufIdx].urb = NULL;
        }


	PDEBUG(DBG_ISOC, "%s: streaming=0\n", __FUNCTION__);
	usbvision->streaming = 0;
			

	if (!usbvision->remove_pending) {

		/* Set packet size to 0 */
		errCode = usb_set_interface(usbvision->dev, usbvision->iface,
				      usbvision->ifaceAltInactive);
		if (errCode < 0) {
			err("%s: usb_set_interface() failed: error %d", __FUNCTION__, errCode);
			usbvision->last_error = errCode;
		}
		regValue = (16 - usbvision_read_reg(usbvision, USBVISION_ALTER_REG)) & 0x0F;
		usbvision->isocPacketSize = (regValue == 0) ? 0 : (regValue * 64) - 1;
		PDEBUG(DBG_ISOC, "ISO Packet Length:%d", usbvision->isocPacketSize);

		usbvision->usb_bandwidth = regValue >> 1;
		PDEBUG(DBG_ISOC, "USB Bandwidth Usage: %dMbit/Sec", usbvision->usb_bandwidth);
	}
}

/*
 * usbvision_new_frame()
 *
 */
static int usbvision_new_frame(struct usb_usbvision *usbvision, int framenum)
{
	struct usbvision_frame *frame;
	int n; //byhec  , width, height;

	/* If we're not grabbing a frame right now and the other frame is */
	/*  ready to be grabbed into, then use it instead */
	if (usbvision->curFrameNum != -1)
		return 0;

	n = (framenum - 1 + USBVISION_NUMFRAMES) % USBVISION_NUMFRAMES;
	if (usbvision->frame[n].grabstate == FrameState_Ready)
		framenum = n;

	frame = &usbvision->frame[framenum];

	frame->grabstate = FrameState_Grabbing;
	frame->scanstate = ScanState_Scanning;
	frame->scanlength = 0;	/* Accumulated in usbvision_parse_data() */
	usbvision->curFrameNum = framenum;

	/*
	 * Normally we would want to copy previous frame into the current one
	 * before we even start filling it with data; this allows us to stop
	 * filling at any moment; top portion of the frame will be new and
	 * bottom portion will stay as it was in previous frame. If we don't
	 * do that then missing chunks of video stream will result in flickering
	 * portions of old data whatever it was before.
	 *
	 * If we choose not to copy previous frame (to, for example, save few
	 * bus cycles - the frame can be pretty large!) then we have an option
	 * to clear the frame before using. If we experience losses in this
	 * mode then missing picture will be black (flickering).
	 *
	 * Finally, if user chooses not to clean the current frame before
	 * filling it with data then the old data will be visible if we fail
	 * to refill entire frame with new data.
	 */
	if (!(flags & FLAGS_SEPARATE_FRAMES)) {
		/* This copies previous frame into this one to mask losses */
		memmove(frame->data, usbvision->frame[1 - framenum].data,
			MAX_FRAME_SIZE);
	} else {
		if (flags & FLAGS_CLEAN_FRAMES) {
			/*This provides a "clean" frame but slows things down */
			memset(frame->data, 0, MAX_FRAME_SIZE);
		}
	}
	return 0;
}

static int usbvision_muxsel(struct usb_usbvision *usbvision, int channel, int norm)
{
	int mode[4];
	int audio[]= {1, 0, 0, 0};	
	struct v4l2_routing route;
	//channel 0 is TV with audiochannel 1 (tuner mono)
	//channel 1 is Composite with audio channel 0 (line in)
	//channel 2 is S-Video with audio channel 0 (line in)
	//channel 3 is additional video inputs to the device with audio channel 0 (line in)

	RESTRICT_TO_RANGE(channel, 0, usbvision->video_inputs);
	/* set the new video norm */
	if (usbvision->input.std != norm) {
	  v4l2_std_id video_command = norm;

	  route.input = SAA7115_COMPOSITE1;
	  call_i2c_clients(usbvision, VIDIOC_INT_S_VIDEO_ROUTING,&route);
	  call_i2c_clients(usbvision, VIDIOC_S_STD, &video_command);
	  usbvision->input.std = norm;
	  call_i2c_clients(usbvision, VIDIOC_S_INPUT, &usbvision->input.index);	//set norm in tuner
	}

	// set the new channel
	// Regular USB TV Tuners -> channel: 0 = Television, 1 = Composite, 2 = S-Video
	// Four video input devices -> channel: 0 = Chan White, 1 = Chan Green, 2 = Chan Yellow, 3 = Chan Red 

	switch (usbvision_device_data[usbvision->DevModel].Codec) {
		case CODEC_SAA7113:
			if (SwitchSVideoInput) { // To handle problems with S-Video Input for some devices.  Use SwitchSVideoInput parameter when loading the module.
				mode[2] = 1;
			}
			else {
				mode[2] = 7;
			}
			if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) { 
				mode[0] = 0; mode[1] = 2; mode[3] = 3;  // Special for four input devices
			}
			else {  
				mode[0] = 0; mode[1] = 2; //modes for regular saa7113 devices
			}
			break;
		case CODEC_SAA7111:
			mode[0] = 0; mode[1] = 1; mode[2] = 7; //modes for saa7111
			break;
		default:
			mode[0] = 0; mode[1] = 1; mode[2] = 7; //default modes
	}
	route.input = mode[channel];
	call_i2c_clients(usbvision, VIDIOC_INT_S_VIDEO_ROUTING,&route);
	usbvision->channel = channel;
	usbvision_set_audio(usbvision, audio[channel]);
	return 0;
}


/*
 * usbvision_open()
 *
 * This is part of Video 4 Linux API. The driver can be opened by one
 * client only (checks internal counter 'usbvision->user'). The procedure
 * then allocates buffers needed for video processing.
 *
 */
static int usbvision_v4l2_open(struct inode *inode, struct file *file)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
	const int sb_size = USBVISION_URB_FRAMES * USBVISION_MAX_ISOC_PACKET_SIZE;
	int i, errCode = 0;

	PDEBUG(DBG_IO, "open");


	if (timer_pending(&usbvision->powerOffTimer)) {
		del_timer(&usbvision->powerOffTimer);
	}

	if (usbvision->user)
		errCode = -EBUSY;
	else {
		/* Clean pointers so we know if we allocated something */
		for (i = 0; i < USBVISION_NUMSBUF; i++)
			usbvision->sbuf[i].data = NULL;

		/* Allocate memory for the frame buffers */
		usbvision->max_frame_size = MAX_FRAME_SIZE;
		usbvision->fbuf_size = USBVISION_NUMFRAMES * usbvision->max_frame_size;
		usbvision->fbuf = usbvision_rvmalloc(usbvision->fbuf_size);
		usbvision->scratch = vmalloc(scratch_buf_size);
		scratch_reset(usbvision);
		if ((usbvision->fbuf == NULL) || (usbvision->scratch == NULL)) {
			err("%s: unable to allocate %d bytes for fbuf and %d bytes for scratch",
					__FUNCTION__, usbvision->fbuf_size, scratch_buf_size);
			errCode = -ENOMEM;
		}
		else {
			/* Allocate all buffers */
			for (i = 0; i < USBVISION_NUMFRAMES; i++) {
				usbvision->frame[i].grabstate = FrameState_Unused;
				usbvision->frame[i].data = usbvision->fbuf +
				    i * MAX_FRAME_SIZE;
				/*
				 * Set default sizes in case IOCTL
				 * (VIDIOCMCAPTURE)
				 * is not used (using read() instead).
				 */
				usbvision->stretch_width = 1;
				usbvision->stretch_height = 1;
				usbvision->frame[i].width = usbvision->curwidth;
				usbvision->frame[i].height = usbvision->curheight;
				usbvision->frame[i].bytes_read = 0;
			}
			if (dga) { //set default for DGA
				usbvision->overlay_frame.grabstate = FrameState_Unused;
				usbvision->overlay_frame.scanstate = ScanState_Scanning;
				usbvision->overlay_frame.data = NULL;
				usbvision->overlay_frame.width = usbvision->curwidth;
				usbvision->overlay_frame.height = usbvision->curheight;
				usbvision->overlay_frame.bytes_read = 0;
			}
			for (i = 0; i < USBVISION_NUMSBUF; i++) {
				usbvision->sbuf[i].data = kzalloc(sb_size, GFP_KERNEL);
				if (usbvision->sbuf[i].data == NULL) {
					err("%s: unable to allocate %d bytes for sbuf", __FUNCTION__, sb_size);
					errCode = -ENOMEM;
					break;
				}
			}
		}
		if ((!errCode) && (usbvision->isocMode==ISOC_MODE_COMPRESS)) {
			int IFB_size = MAX_FRAME_WIDTH * MAX_FRAME_HEIGHT * 3 / 2;
			usbvision->IntraFrameBuffer = vmalloc(IFB_size);
			if (usbvision->IntraFrameBuffer == NULL) {
				err("%s: unable to allocate %d for compr. frame buffer", __FUNCTION__, IFB_size);
				errCode = -ENOMEM;
			}
			
		}
		if (errCode) {
			/* Have to free all that memory */
			if (usbvision->fbuf != NULL) {
				usbvision_rvfree(usbvision->fbuf, usbvision->fbuf_size);
				usbvision->fbuf = NULL;
			}
			if (usbvision->scratch != NULL) {
				vfree(usbvision->scratch);
				usbvision->scratch = NULL;
			}
			for (i = 0; i < USBVISION_NUMSBUF; i++) {
				if (usbvision->sbuf[i].data != NULL) {
					kfree(usbvision->sbuf[i].data);
					usbvision->sbuf[i].data = NULL;
				}
			}
			if (usbvision->IntraFrameBuffer != NULL) {
				vfree(usbvision->IntraFrameBuffer);
				usbvision->IntraFrameBuffer = NULL;
			}
		}
	}

	/* If so far no errors then we shall start the camera */
	if (!errCode) {
		down(&usbvision->lock);
		if (usbvision->power == 0) {
			usbvision_power_on(usbvision);
			usbvision_init_i2c(usbvision);
		}

		/* Send init sequence only once, it's large! */
		if (!usbvision->initialized) {
			int setup_ok = 0;
			setup_ok = usbvision_setup(usbvision);
			if (setup_ok)
				usbvision->initialized = 1;
			else
				errCode = -EBUSY;
		}

		if (!errCode) {
			usbvision_begin_streaming(usbvision);
			errCode = usbvision_init_isoc(usbvision);
			usbvision->user++;
		}
		else {
			if (PowerOnAtOpen) {
				usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
				usbvision_power_off(usbvision);
				usbvision->initialized = 0;
			}
		}
		up(&usbvision->lock);
	}

	if (errCode) {
	}

	PDEBUG(DBG_IO, "success");
	return errCode;
}

/*
 * usbvision_v4l2_close()
 *
 * This is part of Video 4 Linux API. The procedure
 * stops streaming and deallocates all buffers that were earlier
 * allocated in usbvision_v4l2_open().
 *
 */
static int usbvision_v4l2_close(struct inode *inode, struct file *file)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
	int i;

	PDEBUG(DBG_IO, "close");
	down(&usbvision->lock);

	usbvision_audio_off(usbvision);
	usbvision_restart_isoc(usbvision);
	usbvision_stop_isoc(usbvision);

	if (usbvision->IntraFrameBuffer != NULL) {
		vfree(usbvision->IntraFrameBuffer);
		usbvision->IntraFrameBuffer = NULL;
	}

	usbvision_rvfree(usbvision->fbuf, usbvision->fbuf_size);
	vfree(usbvision->scratch);
	for (i = 0; i < USBVISION_NUMSBUF; i++)
		kfree(usbvision->sbuf[i].data);

	usbvision->user--;

	if (PowerOnAtOpen) {
		mod_timer(&usbvision->powerOffTimer, jiffies + USBVISION_POWEROFF_TIME);
		usbvision->initialized = 0;
	}

	up(&usbvision->lock);

	if (usbvision->remove_pending) {
		info("%s: Final disconnect", __FUNCTION__);
		usbvision_release(usbvision);
	}

	PDEBUG(DBG_IO, "success");


	return 0;
}


/*
 * usbvision_ioctl()
 *
 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
 *
 */
static int usbvision_v4l2_do_ioctl(struct inode *inode, struct file *file,
				 unsigned int cmd, void *arg)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return -EFAULT;

	switch (cmd) {
		case UVIOCSREG:
		{
			struct usbvision_reg *usbvision_reg = arg;
			int errCode;

			errCode = usbvision_write_reg(usbvision, usbvision_reg->addr, usbvision_reg->value);

			if (errCode < 0) {
				err("%s: UVIOCSREG failed: error %d", __FUNCTION__, errCode);
			}
			else {
				PDEBUG(DBG_IOCTL, "UVIOCSREG addr=0x%02X, value=0x%02X",
							usbvision_reg->addr, usbvision_reg->value);
				errCode = 0;
			}
			return errCode;
		}
		case UVIOCGREG:
		{
			struct usbvision_reg *usbvision_reg = arg;
			int errCode;

			errCode = usbvision_read_reg(usbvision, usbvision_reg->addr);

			if (errCode < 0) {
				err("%s: UVIOCGREG failed: error %d", __FUNCTION__, errCode);
			}
			else {
				usbvision_reg->value=(unsigned char)errCode;
				PDEBUG(DBG_IOCTL, "UVIOCGREG addr=0x%02X, value=0x%02X",
							usbvision_reg->addr, usbvision_reg->value);
				errCode = 0; // No error
			}
			return errCode;
		}
		case VIDIOC_QUERYCAP:
		{
			struct v4l2_capability *vc=arg;
			*vc = usbvision->vcap;
			PDEBUG(DBG_IOCTL, "VIDIOC_QUERYCAP");
			return 0;
		}
		case VIDIOC_ENUMINPUT:
		{
			struct v4l2_input *vi = arg;
			int chan;

			if ((vi->index >= usbvision->video_inputs) || (vi->index < 0) )
				return -EINVAL;
			if (usbvision->have_tuner) {
				chan = vi->index;
			}
			else {
				chan = vi->index + 1; //skip Television string
			}
			switch(chan) {
				case 0:
					if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) {
						strcpy(vi->name, "White Video Input");
					} 
					else {	
						strcpy(vi->name, "Television");
						vi->type = V4L2_INPUT_TYPE_TUNER;
						vi->audioset = 1;
						vi->tuner = chan;
						vi->std = V4L2_STD_PAL | V4L2_STD_NTSC | V4L2_STD_SECAM;
					}
					break;
				case 1:
				        vi->type = V4L2_INPUT_TYPE_CAMERA;
					if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) {
						strcpy(vi->name, "Green Video Input");
					} 
					else {	
						strcpy(vi->name, "Composite Video Input");
					}
					vi->std = V4L2_STD_PAL;
					break;
				case 2:
				        vi->type = V4L2_INPUT_TYPE_CAMERA;
					if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) {
						strcpy(vi->name, "Yellow Video Input");
					} 
					else {	
					strcpy(vi->name, "S-Video Input");
					}
					vi->std = V4L2_STD_PAL;
					break;
				case 3:
				        vi->type = V4L2_INPUT_TYPE_CAMERA;
					strcpy(vi->name, "Red Video Input");
					vi->std = V4L2_STD_PAL;
					break; 
			}
			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);
			return 0;
		}
		case VIDIOC_ENUMSTD:
		{
			struct v4l2_standard *vs = arg;
			switch(vs->index) {
			case 0:
				vs->id = V4L2_STD_PAL;
				strcpy(vs->name,"PAL");
				vs->frameperiod.numerator   = 1;
				vs->frameperiod.denominator = 25;
				vs->framelines              = 625;
				break;
			case 1:
				vs->id = V4L2_STD_NTSC;
				strcpy(vs->name,"NTSC");
				vs->frameperiod.numerator   = 1001;
				vs->frameperiod.denominator = 30000;
				vs->framelines              = 525;
				break;
			case 2:
				vs->id = V4L2_STD_SECAM;
				strcpy(vs->name,"SECAM");
				vs->frameperiod.numerator   = 1;
				vs->frameperiod.denominator = 25;
				vs->framelines              = 625;
				break;
			default:
				return -EINVAL;
			}
			return 0;
		}
	        case VIDIOC_G_INPUT:
		{
			int *input = arg;
			*input = usbvision->input.index;
			return 0;
		}
	        case VIDIOC_S_INPUT:
		{
			int *input = arg;
			if ((*input >= usbvision->video_inputs) || (*input < 0) )
				return -EINVAL;
			usbvision->input.index = *input;

			down(&usbvision->lock);
			usbvision_muxsel(usbvision, usbvision->input.index, usbvision->input.std);
			usbvision_set_input(usbvision);
			usbvision_set_output(usbvision, usbvision->curwidth, usbvision->curheight);
			up(&usbvision->lock);
			return 0;
		}
 	        case VIDIOC_G_STD:
		{
			v4l2_std_id *std = arg;
			*std = usbvision->input.std;
			PDEBUG(DBG_IOCTL, "VIDIOC_G_STD std_id=%x", (unsigned)*std);
			return 0;
		}
	        case VIDIOC_S_STD:
		{
			v4l2_std_id *std = arg;

			down(&usbvision->lock);
			usbvision_muxsel(usbvision, usbvision->input.index, *std);
			usbvision_set_input(usbvision);
			usbvision_set_output(usbvision, usbvision->curwidth, usbvision->curheight);
			up(&usbvision->lock);

			usbvision->input.std = *std;
			PDEBUG(DBG_IOCTL, "VIDIOC_S_STD std_id=%x", (unsigned)*std);
			return 0;
		}
	        case VIDIOC_G_TUNER:
		{
			struct v4l2_tuner *vt = arg;
			struct v4l2_tuner status;

			if (!usbvision->have_tuner || vt->index)	// Only tuner 0
				return -EINVAL;
			strcpy(vt->name, "Television");
			vt->type = V4L2_TUNER_ANALOG_TV;
			vt->capability = V4L2_TUNER_CAP_NORM;
			vt->rangelow = 0;
			vt->rangehigh = ~0;
			vt->audmode = V4L2_TUNER_MODE_MONO;
			vt->rxsubchans = V4L2_TUNER_SUB_MONO;
			call_i2c_clients(usbvision,VIDIOC_G_TUNER,&status);
			vt->signal = status.signal;

			PDEBUG(DBG_IOCTL, "VIDIOC_G_TUNER");
			return 0;
		}
		case VIDIOC_S_TUNER:
		{
			struct v4l2_tuner *vt = arg;

			// Only no or one tuner for now
			if (!usbvision->have_tuner || vt->index)
				return -EINVAL;
			// FIXME     vt->audmode Radio mode (STEREO/MONO/...)
			// vt->reserved Radio freq
			// usbvision_muxsel(usbvision, vt->index, vt->mode);
			PDEBUG(DBG_IOCTL, "VIDIOC_S_TUNER");
			return 0;
		}
		case VIDIOC_G_FREQUENCY:
		{
			struct v4l2_frequency *freq = arg;
			freq->tuner = 0; // Only one tuner
			freq->type = V4L2_TUNER_ANALOG_TV;
			freq->frequency = usbvision->freq;
			PDEBUG(DBG_IOCTL, "VIDIOC_G_FREQUENCY freq=0x%X", (unsigned)freq->frequency);
			return 0;
		}
		case VIDIOC_S_FREQUENCY:
		{
			struct v4l2_frequency *freq = arg;
			usbvision->freq = freq->frequency;
			call_i2c_clients(usbvision, cmd, freq);
			PDEBUG(DBG_IOCTL, "VIDIOC_S_FREQUENCY freq=0x%X", (unsigned)freq->frequency);
			return 0;
		}
		case VIDIOC_G_AUDIO:
		{
			struct v4l2_audio *v = arg;
			memset(v,0, sizeof(v));
			strcpy(v->name, "TV");
			PDEBUG(DBG_IOCTL, "VIDIOC_G_AUDIO");
			// FIXME: no more processings ???
			return 0;
		}
		case VIDIOC_S_AUDIO:
		{
			struct v4l2_audio *v = arg;
			if(v->index) {
				return -EINVAL;
			}
			PDEBUG(DBG_IOCTL, "VIDIOC_S_AUDIO");
			// FIXME: void function ???
			return 0;
		}
	        case VIDIOC_QUERYCTRL:
		{
			struct v4l2_queryctrl *qc = arg;
			switch(qc->id) {
			case V4L2_CID_BRIGHTNESS:
			case V4L2_CID_HUE:
			case V4L2_CID_SATURATION:
			case V4L2_CID_CONTRAST:
			case V4L2_CID_AUDIO_VOLUME:
			case V4L2_CID_AUDIO_MUTE:
				return v4l2_ctrl_query_fill_std(qc);
				break;
			default:
				return -EINVAL;
			}
			return 0;
		}
		case VIDIOC_G_CTRL:
		{
			struct v4l2_control *ctrl = arg;

			switch (ctrl->id) {
			case V4L2_CID_BRIGHTNESS:
				ctrl->value = usbvision->brightness;
				break;
			case V4L2_CID_CONTRAST:
				ctrl->value = usbvision->contrast;
				break;
			case V4L2_CID_SATURATION:
				ctrl->value = usbvision->saturation;
				break;
			case V4L2_CID_HUE:
				ctrl->value = usbvision->hue;
				break;
			case V4L2_CID_AUDIO_VOLUME:
				/* 	ctrl->value = usbvision->volume; */
				break;
			case V4L2_CID_AUDIO_MUTE:
				ctrl->value = usbvision->AudioMute;
				break;
			default:
				return -EINVAL;
			}
			PDEBUG(DBG_IOCTL, "VIDIOC_G_CTRL id=%x value=%x",ctrl->id,ctrl->value);
			return 0;
		}
		case VIDIOC_S_CTRL:
		{
			struct v4l2_control *ctrl = arg;
			PDEBUG(DBG_IOCTL, "VIDIOC_S_CTRL id=%x value=%x",ctrl->id,ctrl->value);
			call_i2c_clients(usbvision, VIDIOC_S_CTRL, ctrl);
			return 0;
		}
		case VIDIOC_REQBUFS:
		{
			struct v4l2_requestbuffers *vr = arg;
			// FIXME : normally we allocate the requested number of buffers.
			// this driver allocates statically the buffers.
			vr->count = 2;
			if(vr->memory != V4L2_MEMORY_MMAP)
				return -EINVAL;
			return 0;
		}
		case VIDIOC_QUERYBUF:
		{
			struct v4l2_buffer *vb = arg;
			struct usbvision_frame *frame;

			// FIXME : works only on VIDEO_CAPTURE MODE, MMAP.
			if(vb->type != V4L2_CAP_VIDEO_CAPTURE) {
				return -EINVAL;
			}
			if(vb->index>1)  {
				return -EINVAL;
			}
			vb->flags = 0;
			frame = &usbvision->frame[vb->index];
			if(frame->grabstate == FrameState_Grabbing)
				vb->flags |= V4L2_BUF_FLAG_QUEUED;
			if(frame->grabstate >= FrameState_Done)
				vb->flags |= V4L2_BUF_FLAG_DONE;
			if(frame->grabstate == FrameState_Unused)
				vb->flags |= V4L2_BUF_FLAG_MAPPED;
			vb->memory = V4L2_MEMORY_MMAP;
			if(vb->index == 0) {
				vb->m.offset = 0;
			}
			else {
				vb->m.offset = MAX_FRAME_SIZE;
			}
			vb->length = MAX_FRAME_SIZE;
			vb->timestamp = usbvision->frame[vb->index].timestamp;
			vb->sequence = usbvision->frame_num;
			return 0;
		}
	        case VIDIOC_QBUF: // VIDIOCMCAPTURE + VIDIOCSYNC
		{
			struct v4l2_buffer *vb = arg;
			struct usbvision_frame *frame;

			// FIXME : works only on VIDEO_CAPTURE MODE, MMAP.
			if(vb->type != V4L2_CAP_VIDEO_CAPTURE) {
				return -EINVAL;
			}
			if(vb->index>1)  {
				return -EINVAL;
			}

			frame = &usbvision->frame[vb->index];

			if (frame->grabstate == FrameState_Grabbing) {
				return -EBUSY;
			}

			usbvision_set_output(usbvision, usbvision->curwidth, usbvision->curheight);

			/* Mark it as ready */
			frame->grabstate = FrameState_Ready;
			vb->flags &= ~V4L2_BUF_FLAG_DONE;

			/* set v4l2_format index */
			frame->v4l2_format = usbvision->palette;

			return usbvision_new_frame(usbvision, vb->index);
		}
		case VIDIOC_DQBUF:
		{
			struct v4l2_buffer *vb = arg;
			int errCode = 0;

			DECLARE_WAITQUEUE(wait, current);
			// FIXME : not the proper way to get the last filled frame
			vb->index=-1;
			if(usbvision->curFrameNum != -1) vb->index=usbvision->curFrameNum;
			else {
				if(usbvision->frame[1].grabstate >= FrameState_Done)
					vb->index = 1;
				else if(usbvision->frame[0].grabstate >= FrameState_Done)
					vb->index = 0;
				// If no FRAME_DONE, look for a FRAME_GRABBING state.
				// See if a frame is in process (grabbing), then use it.
				if (vb->index == -1) {
					if (usbvision->frame[1].grabstate == FrameState_Grabbing)
						vb->index = 1;
					else if (usbvision->frame[0].grabstate == FrameState_Grabbing)
						vb->index = 0;
				}
			}
			if (vb->index == -1)
				return -EINVAL;

			PDEBUG(DBG_IOCTL, "VIDIOC_DQBUF frame=%d, grabstate=%d",
				       vb->index, usbvision->frame[vb->index].grabstate);

			switch (usbvision->frame[vb->index].grabstate) {
			case FrameState_Unused:
				errCode = -EINVAL;
				break;
			case FrameState_Grabbing:
				add_wait_queue(&usbvision->frame[vb->index].wq, &wait);
				current->state = TASK_INTERRUPTIBLE;
				while (usbvision->frame[vb->index].grabstate == FrameState_Grabbing) {
					schedule();
					if (signal_pending(current)) {
						remove_wait_queue(&usbvision->frame[vb->index].wq, &wait);
						current->state = TASK_RUNNING;
						return -EINTR;
					}
				}
				remove_wait_queue(&usbvision->frame[vb->index].wq, &wait);
				current->state = TASK_RUNNING;
			case FrameState_Ready:
			case FrameState_Error:
			case FrameState_Done:
				errCode = (usbvision->frame[vb->index].grabstate == FrameState_Error) ? -EIO : 0;
				vb->memory = V4L2_MEMORY_MMAP;
				vb->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE;
				vb->sequence = usbvision->frame[vb->index].sequence;
				usbvision->frame[vb->index].grabstate = FrameState_Unused;
				break;
			}

			usbvision->frame[vb->index].grabstate = FrameState_Unused;
			return errCode;
		}
		case VIDIOC_STREAMON:
		{
			int b=V4L2_BUF_TYPE_VIDEO_CAPTURE;
			call_i2c_clients(usbvision,VIDIOC_STREAMON , &b);      
			return 0;
		}
		case VIDIOC_STREAMOFF:
		{
			int b=V4L2_BUF_TYPE_VIDEO_CAPTURE;
			down(&usbvision->lock);
			// Stop all video streamings
			call_i2c_clients(usbvision,VIDIOC_STREAMOFF , &b);
			usbvision->frame_num = -1;
			usbvision->frame[0].grabstate = FrameState_Unused;
			usbvision->frame[1].grabstate = FrameState_Unused;
			up(&usbvision->lock);
			return 0;
		}
	        case VIDIOC_G_FBUF:
		{
			struct v4l2_framebuffer *vb = arg;

			if (dga) {
				*vb = usbvision->vid_buf;
			}
			else {
				memset(vb, 0, sizeof(vb)); //dga not supported, not used
			}
			PDEBUG(DBG_IOCTL, "VIDIOC_G_FBUF base=%p, width=%d, height=%d, pixelformat=%d, bpl=%d",
			       vb->base, vb->fmt.width, vb->fmt.height, vb->fmt.pixelformat,vb->fmt.bytesperline);
			return 0;
		}
		case VIDIOC_S_FBUF:
		{
			struct v4l2_framebuffer *vb = arg;
			int formatIdx;

			if (dga == 0) {
				return -EINVAL;
			}

			if(!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_ADMIN)) {
				return -EPERM;
			}

			PDEBUG(DBG_IOCTL, "VIDIOC_S_FBUF base=%p, width=%d, height=%d, pixelformat=%d, bpl=%d",
			       vb->base, vb->fmt.width, vb->fmt.height, vb->fmt.pixelformat,vb->fmt.bytesperline);

			for (formatIdx=0; formatIdx <= USBVISION_SUPPORTED_PALETTES; formatIdx++) {
				if (formatIdx == USBVISION_SUPPORTED_PALETTES) {
					return -EINVAL; // no matching video_format
				}
				if ((vb->fmt.pixelformat == usbvision_v4l2_format[formatIdx].format) &&
				    (usbvision_v4l2_format[formatIdx].supported)) {
					break; //found matching video_format
				}
			}

			if (vb->fmt.bytesperline<1) {
				return -EINVAL;
			}
			if (usbvision->overlay) {
				return -EBUSY;
			}
			down(&usbvision->lock);
			if (usbvision->overlay_base) {
				iounmap(usbvision->overlay_base);
				usbvision->vid_buf_valid = 0;
			}
			usbvision->overlay_base = ioremap((ulong)vb->base, vb->fmt.height * vb->fmt.bytesperline);
			if (usbvision->overlay_base) {
				usbvision->vid_buf_valid = 1;
			}
			usbvision->vid_buf = *vb;
			usbvision->overlay_frame.v4l2_format = usbvision_v4l2_format[formatIdx];
			up(&usbvision->lock);
			return 0;
		}
		case VIDIOC_ENUM_FMT:
		{
			struct v4l2_fmtdesc *vfd = arg;
			if ( (dga == 0) &&
			     (vfd->type == V4L2_BUF_TYPE_VIDEO_OVERLAY) &&
			     (usbvision->palette.format != V4L2_PIX_FMT_YVU420) &&
			     (usbvision->palette.format != V4L2_PIX_FMT_YUV422P) ) { 
				return -EINVAL;
			}
			if(vfd->index>=USBVISION_SUPPORTED_PALETTES-1) {
				return -EINVAL;
			}
			vfd->flags = 0;
			strcpy(vfd->description,usbvision_v4l2_format[vfd->index].desc);
			vfd->pixelformat = usbvision_v4l2_format[vfd->index].format;
			return 0;
		}
		case VIDIOC_G_FMT:
		{
			struct v4l2_format *vf = arg;
      
			if ( (dga == 0) &&
			     (vf->type == V4L2_BUF_TYPE_VIDEO_OVERLAY) &&
			     (usbvision->palette.format != V4L2_PIX_FMT_YVU420) &&
			     (usbvision->palette.format != V4L2_PIX_FMT_YUV422P) ) { 
				return -EINVAL;
			}
			down(&usbvision->lock);
			*vf = usbvision->vid_win;
			up(&usbvision->lock);
			PDEBUG(DBG_IOCTL, "VIDIOC_G_FMT x=%d, y=%d, w=%d, h=%d, chroma=%x, clips=%d",
			       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);
			return 0;
		}
	        case VIDIOC_S_FMT:
		{
			struct v4l2_format *vf = arg;
			struct v4l2_clip *vc=NULL;
			int on,formatIdx;

			if ( (dga == 0) &&
			     (vf->type == V4L2_BUF_TYPE_VIDEO_OVERLAY) &&
			     (usbvision->palette.format != V4L2_PIX_FMT_YVU420) &&
			     (usbvision->palette.format != V4L2_PIX_FMT_YUV422P) ) { 
				return -EINVAL;
			}
			if(vf->type == V4L2_BUF_TYPE_VIDEO_OVERLAY) {
				if (vf->fmt.win.clipcount>256) {
					return -EDOM;   /* Too many clips! */
				}
				// Do every clips.
				vc = vmalloc(sizeof(struct v4l2_clip)*(vf->fmt.win.clipcount+4));
				if (vc == NULL) {
					return -ENOMEM;
				}
				if (vf->fmt.win.clipcount && copy_from_user(vc,vf->fmt.win.clips,sizeof(struct v4l2_clip)*vf->fmt.win.clipcount)) {
					return -EFAULT;
				}
				on = usbvision->overlay;	// Save overlay state
				if (on) {
					usbvision_cap(usbvision, 0);
				}

				// strange, it seems xawtv sometimes calls us with 0
				// width and/or height. Ignore these values
				if (vf->fmt.win.w.left == 0) {
					vf->fmt.win.w.left = usbvision->vid_win.fmt.win.w.left;
				}
				if (vf->fmt.win.w.top == 0) {
					vf->fmt.win.w.top = usbvision->vid_win.fmt.win.w.top;
				}

				// by now we are committed to the new data...
				down(&usbvision->lock);
				RESTRICT_TO_RANGE(vf->fmt.win.w.width, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH);
				RESTRICT_TO_RANGE(vf->fmt.win.w.height, MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT);
				usbvision->vid_win = *vf;
				usbvision->overlay_frame.width = vf->fmt.win.w.width;
				usbvision->overlay_frame.height = vf->fmt.win.w.height;
				usbvision_set_output(usbvision, vf->fmt.win.w.width, vf->fmt.win.w.height);
				up(&usbvision->lock);

				// Impose display clips
				if (vf->fmt.win.w.left+vf->fmt.win.w.width > (unsigned int)usbvision->vid_buf.fmt.width) {
					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);
				}
				if (vf->fmt.win.w.top+vf->fmt.win.w.height > (unsigned int)usbvision->vid_buf.fmt.height) {
					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);
				}

				// built the requested clipping zones
				usbvision_built_overlay(usbvision, vf->fmt.win.clipcount, vc);
				vfree(vc);

				// restore overlay state
				if (on) {
					usbvision_cap(usbvision, 1);
				}
				usbvision->vid_win_valid = 1;
				PDEBUG(DBG_IOCTL, "VIDIOC_S_FMT overlay x=%d, y=%d, w=%d, h=%d, chroma=%x, clips=%d",
				       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);
			}
			else {
				/* Find requested format in available ones */
				for(formatIdx=0;formatIdx<USBVISION_SUPPORTED_PALETTES;formatIdx++) {
					if(vf->fmt.pix.pixelformat == usbvision_v4l2_format[formatIdx].format) {
						usbvision->palette = usbvision_v4l2_format[formatIdx];
						break;
					}
				}
				/* robustness */
				if(formatIdx == USBVISION_SUPPORTED_PALETTES) {
					return -EINVAL;
				}
				usbvision->vid_win.fmt.pix.pixelformat = vf->fmt.pix.pixelformat;
				usbvision->vid_win.fmt.pix.width = vf->fmt.pix.width; //Image width in pixels.
				usbvision->vid_win.fmt.pix.height = vf->fmt.pix.height; // Image height in pixels.

				// by now we are committed to the new data...
				down(&usbvision->lock);
				RESTRICT_TO_RANGE(vf->fmt.pix.width, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH);
				RESTRICT_TO_RANGE(vf->fmt.pix.height, MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT);
				usbvision->vid_win = *vf;
				usbvision_set_output(usbvision, vf->fmt.pix.width, vf->fmt.pix.height);
				up(&usbvision->lock);

				usbvision->vid_win_valid = 1;
				PDEBUG(DBG_IOCTL, "VIDIOC_S_FMT grabdisplay w=%d, h=%d, ",
				       vf->fmt.pix.width, vf->fmt.pix.height);
			}
			return 0;
		}
		case VIDIOC_OVERLAY:
		{
			int *v = arg;
      
			if ( (dga == 0) &&
			     (usbvision->palette.format != V4L2_PIX_FMT_YVU420) &&
			     (usbvision->palette.format != V4L2_PIX_FMT_YUV422P) ) { 
				PDEBUG(DBG_IOCTL, "VIDIOC_OVERLAY  DGA disabled");
				return -EINVAL;
			}

			if (*v == 0) {
				usbvision_cap(usbvision, 0);
			}
			else {
				// are VIDIOCSFBUF and VIDIOCSWIN done?
				if ((usbvision->vid_buf_valid == 0) || (usbvision->vid_win_valid == 0)) {
					PDEBUG(DBG_IOCTL, "VIDIOC_OVERLAY  vid_buf_valid %d; vid_win_valid %d",
					       usbvision->vid_buf_valid, usbvision->vid_win_valid);
					return -EINVAL;
				}
				usbvision_cap(usbvision, 1);
			}
			PDEBUG(DBG_IOCTL, "VIDIOC_OVERLAY %s", (*v)?"on":"off");
			return 0;
		}
		default:
			return -ENOIOCTLCMD;
	}
	return 0;
}

static int usbvision_v4l2_ioctl(struct inode *inode, struct file *file,
		       unsigned int cmd, unsigned long arg)
{
	return video_usercopy(inode, file, cmd, arg, usbvision_v4l2_do_ioctl);
}


static ssize_t usbvision_v4l2_read(struct file *file, char *buf,
		      size_t count, loff_t *ppos)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
	int noblock = file->f_flags & O_NONBLOCK;

	int frmx = -1;
	int rc = 0;
	struct usbvision_frame *frame;

	PDEBUG(DBG_IO, "%s: %ld bytes, noblock=%d", __FUNCTION__, (unsigned long)count, noblock);

	if (!USBVISION_IS_OPERATIONAL(usbvision) || (buf == NULL))
		return -EFAULT;

	down(&usbvision->lock);
	//code for testing compression
	if (usbvision->isocMode == ISOC_MODE_COMPRESS) {
	  usbvision->frame[0].v4l2_format = usbvision_v4l2_format[0]; //V4L2_PIX_FMT_GREY;
	  usbvision->frame[1].v4l2_format = usbvision_v4l2_format[0]; // V4L2_PIX_FMT_GREY;
	}

	// See if a frame is completed, then use it.
	if (usbvision->frame[0].grabstate >= FrameState_Done) // _Done or _Error
		frmx = 0;
	else if (usbvision->frame[1].grabstate >= FrameState_Done)// _Done or _Error
		frmx = 1;

	if (noblock && (frmx == -1)) {
		count = -EAGAIN;
		goto usbvision_v4l2_read_done;
	}

	// If no FRAME_DONE, look for a FRAME_GRABBING state.
	// See if a frame is in process (grabbing), then use it.
	if (frmx == -1) {
		if (usbvision->frame[0].grabstate == FrameState_Grabbing)
			frmx = 0;
		else if (usbvision->frame[1].grabstate == FrameState_Grabbing)
			frmx = 1;
	}

	// If no frame is active, start one.
	if (frmx == -1)
		usbvision_new_frame(usbvision, frmx = 0);

	frame = &usbvision->frame[frmx];

      restart:
	if (!USBVISION_IS_OPERATIONAL(usbvision)) {
		count = -EIO;
		goto usbvision_v4l2_read_done;
	}
	PDEBUG(DBG_IO, "Waiting frame grabbing");
	rc = wait_event_interruptible(frame->wq, (frame->grabstate == FrameState_Done) || 
						 (frame->grabstate == FrameState_Error));
	if (rc) {
		goto usbvision_v4l2_read_done;
	}

	if (frame->grabstate == FrameState_Error) {
		frame->bytes_read = 0;
		if (usbvision_new_frame(usbvision, frmx)) {
			err("%s: usbvision_new_frame() failed", __FUNCTION__);
		}
		goto restart;
	}

	PDEBUG(DBG_IO, "%s: frmx=%d, bytes_read=%ld, scanlength=%ld", __FUNCTION__,
		       frmx, frame->bytes_read, frame->scanlength);

	/* copy bytes to user space; we allow for partials reads */
	if ((count + frame->bytes_read) > (unsigned long)frame->scanlength)
		count = frame->scanlength - frame->bytes_read;

	if (copy_to_user(buf, frame->data + frame->bytes_read, count)) {
		count = -EFAULT;
		goto usbvision_v4l2_read_done;
	}

	frame->bytes_read += count;
	PDEBUG(DBG_IO, "%s: {copy} count used=%ld, new bytes_read=%ld", __FUNCTION__,
		       (unsigned long)count, frame->bytes_read);

	if (frame->bytes_read >= frame->scanlength) {// All data has been read
		frame->bytes_read = 0;

		/* Mark it as available to be used again. */
		usbvision->frame[frmx].grabstate = FrameState_Unused;
		if (usbvision_new_frame(usbvision, frmx ? 0 : 1))
			err("%s: usbvision_new_frame() failed", __FUNCTION__);
	}

usbvision_v4l2_read_done:
	up(&usbvision->lock);
	return count;
}

static int usbvision_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
	unsigned long start = vma->vm_start;
	unsigned long size  = vma->vm_end-vma->vm_start;

	unsigned long page, pos;

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return -EFAULT;

	if (size > (((USBVISION_NUMFRAMES * usbvision->max_frame_size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)))
		return -EINVAL;

	pos = (unsigned long) usbvision->fbuf;
	while (size > 0) {
		
// Really ugly....
	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)	                   //Compatibility for 2.6.10+ kernels
		page = vmalloc_to_pfn((void *)pos);
		if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) { 
			return -EAGAIN;
		}
	#else                                                                      //Compatibility for 2.6.0 - 2.6.9 kernels
		page = usbvision_kvirt_to_pa(pos);
		if (remap_page_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
			return -EAGAIN;
		}
	#endif
		start += PAGE_SIZE;
		pos += PAGE_SIZE;
		if (size > PAGE_SIZE)
			size -= PAGE_SIZE;
		else
			size = 0;
	}

	return 0;
}


/*
 * Here comes the stuff for radio on usbvision based devices
 *
 */
static int usbvision_radio_open(struct inode *inode, struct file *file)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
	struct v4l2_frequency freq;
	int errCode = 0;

	PDEBUG(DBG_RIO, "%s:", __FUNCTION__);

	down(&usbvision->lock);

	if (usbvision->user) {
		err("%s: Someone tried to open an already opened USBVision Radio!", __FUNCTION__);
		errCode = -EBUSY;
	}
	else {
		if(PowerOnAtOpen) {
			if (timer_pending(&usbvision->powerOffTimer)) {
				del_timer(&usbvision->powerOffTimer);
			}
			if (usbvision->power == 0) {
				usbvision_power_on(usbvision);
				usbvision_init_i2c(usbvision);
			}
		}

		// If so far no errors then we shall start the radio
		usbvision->radio = 1;
		call_i2c_clients(usbvision,AUDC_SET_RADIO,&usbvision->tuner_type);
		freq.frequency = 1517; //SWR3 @ 94.8MHz
		call_i2c_clients(usbvision, VIDIOC_S_FREQUENCY, &freq);
		usbvision_set_audio(usbvision, USBVISION_AUDIO_RADIO);
		usbvision->user++;
	}

	if (errCode) {
		if (PowerOnAtOpen) {
			usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
			usbvision_power_off(usbvision);
			usbvision->initialized = 0;
		}
	}
	up(&usbvision->lock);
	return errCode;
}


static int usbvision_radio_close(struct inode *inode, struct file *file)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
	int errCode = 0;

	PDEBUG(DBG_RIO, "");

	down(&usbvision->lock);

	usbvision_audio_off(usbvision);
	usbvision->radio=0;
	usbvision->user--;

	if (PowerOnAtOpen) {
		mod_timer(&usbvision->powerOffTimer, jiffies + USBVISION_POWEROFF_TIME);
		usbvision->initialized = 0;
	}

	up(&usbvision->lock);

	if (usbvision->remove_pending) {
		info("%s: Final disconnect", __FUNCTION__);
		usbvision_release(usbvision);
	}


	PDEBUG(DBG_RIO, "success");

	return errCode;
}

static int usbvision_do_radio_ioctl(struct inode *inode, struct file *file,
				 unsigned int cmd, void *arg)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return -EIO;

	switch (cmd) {
		/***************************
		 * V4L2 IOCTLs             *
		 ***************************/
 	        case VIDIOC_QUERYCAP:
		{
			struct v4l2_capability *vc=arg;
			memset(vc, 0, sizeof(struct v4l2_capability));
			strcpy(vc->driver,"usbvision radio");
			strcpy(vc->card,usbvision->vcap.card);
			strcpy(vc->bus_info,"usb");
			vc->version = USBVISION_DRIVER_VERSION; 	    /* version */
			vc->capabilities = V4L2_CAP_TUNER; 	    /* capabilities */
			PDEBUG(DBG_RIO, "%s: VIDIOC_QUERYCAP", __FUNCTION__);
			return 0;
		}
      	        case VIDIOC_QUERYCTRL:
		{
			struct v4l2_queryctrl *qc = arg;
			switch(qc->id)
				{
				case V4L2_CID_AUDIO_VOLUME:
				case V4L2_CID_AUDIO_MUTE:
					return v4l2_ctrl_query_fill_std(qc);
					break;
				default:
					return -EINVAL;
				}
			return 0;
		}
       	        case VIDIOC_G_CTRL:
		{
			struct v4l2_control *ctrl = arg;
			PDEBUG(DBG_IOCTL, "VIDIOC_G_CTRL id=%x value=%x",ctrl->id,ctrl->value);
			switch(ctrl->id) {
			case V4L2_CID_AUDIO_VOLUME:
				/* 	ctrl->value = usbvision->volume; */
				break;
			case V4L2_CID_AUDIO_MUTE:
				ctrl->value = usbvision->AudioMute;
				break;
			default:
				return -EINVAL;
			}
			return 0;
		}
	        case VIDIOC_S_CTRL:
		{
			struct v4l2_control *ctrl = arg;
			call_i2c_clients(usbvision, VIDIOC_S_CTRL, ctrl);

			PDEBUG(DBG_RIO, "%s: VIDIOC_S_CTRL id=%x value=%x", __FUNCTION__,ctrl->id,ctrl->value);
			return 0;
		}
 	        case VIDIOC_G_TUNER:
		{
			struct v4l2_tuner *vt = arg;

			if (!usbvision->have_tuner || vt->index)	// Only tuner 0
				return -EINVAL;
			strcpy(vt->name, "Radio");
			vt->type = V4L2_TUNER_RADIO;
			vt->capability = V4L2_TUNER_CAP_STEREO;
			// japan:          76.0 MHz -  89.9 MHz
			// western europe: 87.5 MHz - 108.0 MHz
			// russia:         65.0 MHz - 108.0 MHz
			vt->rangelow = (int)(65*16);;
			vt->rangehigh = (int)(108*16);
			vt->audmode = V4L2_TUNER_MODE_STEREO;
			vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
			call_i2c_clients(usbvision,VIDIOC_G_TUNER,&vt);

			PDEBUG(DBG_RIO, "%s: VIDIOC_G_TUNER signal=%d", __FUNCTION__, vt->signal);
			return 0;
		}
	        case VIDIOC_S_TUNER:
		{
			struct v4l2_tuner *vt = arg;

			// Only channel 0 has a tuner
			if((vt->index) || (usbvision->channel)) {
				return -EINVAL;
			}
			PDEBUG(DBG_RIO, "%s: VIDIOC_S_TUNER", __FUNCTION__);
			return 0;
		}
	        case VIDIOC_G_AUDIO:
		{
			struct v4l2_audio *va = arg;
			memset(va,0, sizeof(va));
			va->capability = V4L2_AUDCAP_STEREO;
			strcpy(va->name, "Radio");
			PDEBUG(DBG_IOCTL, "VIDIOC_G_AUDIO");
			return 0;
		}
	        case VIDIOC_S_AUDIO:
		{
			struct v4l2_audio *v = arg;
			if(v->index) {
				return -EINVAL;
			}
			PDEBUG(DBG_IOCTL, "VIDIOC_S_AUDIO");
			// FIXME: void function ???
			return 0;
		}
	        case VIDIOC_G_FREQUENCY:
		{
			struct v4l2_frequency *freq = arg;
			freq->tuner = 0; // Only one tuner
			freq->type = V4L2_TUNER_RADIO;
			freq->frequency = usbvision->freq;
			PDEBUG(DBG_RIO, "VIDIOC_G_FREQUENCY freq=0x%X", (unsigned)freq->frequency);
			return 0;
		}
	        case VIDIOC_S_FREQUENCY:
		{
			struct v4l2_frequency *freq = arg;
			usbvision->freq = freq->frequency;
			call_i2c_clients(usbvision, cmd, freq);
			PDEBUG(DBG_RIO, "VIDIOC_S_FREQUENCY freq=0x%X", (unsigned)freq->frequency);
			return 0;
		}

		/***************************
		 * V4L1 IOCTLs             *
		 ***************************/
	        case VIDIOCGCAP:
		{
			struct video_capability *vc = arg;

			memset(vc, 0, sizeof(struct video_capability));
			strcpy(vc->name,usbvision->vcap.card);
			vc->type = VID_TYPE_TUNER;
			vc->channels = 1;
			vc->audios = 1;
			PDEBUG(DBG_RIO, "%s: VIDIOCGCAP", __FUNCTION__);
			return 0;
		}
		case VIDIOCGTUNER:
		{
			struct video_tuner *vt = arg;

			if((vt->tuner) || (usbvision->channel)) {	/* Only tuner 0 */
				return -EINVAL;
			}
			strcpy(vt->name, "Radio");
			// japan:          76.0 MHz -  89.9 MHz
			// western europe: 87.5 MHz - 108.0 MHz
			// russia:         65.0 MHz - 108.0 MHz
			vt->rangelow=(int)(65*16);
			vt->rangehigh=(int)(108*16);
			vt->flags= 0;
			vt->mode = 0;
			call_i2c_clients(usbvision,cmd,vt);
			PDEBUG(DBG_RIO, "%s: VIDIOCGTUNER signal=%d", __FUNCTION__, vt->signal);
			return 0;
		}
		case VIDIOCSTUNER:
		{
			struct video_tuner *vt = arg;

			// Only channel 0 has a tuner
			if((vt->tuner) || (usbvision->channel)) {
				return -EINVAL;
			}
			PDEBUG(DBG_RIO, "%s: VIDIOCSTUNER", __FUNCTION__);
			return 0;
		}
		case VIDIOCGAUDIO:
		{
			struct video_audio *va = arg;
			memset(va,0, sizeof(struct video_audio));
			call_i2c_clients(usbvision, cmd, va);
			va->flags|=VIDEO_AUDIO_MUTABLE;
			va->volume=1;
			va->step=1;
			strcpy(va->name, "Radio");
			PDEBUG(DBG_RIO, "%s: VIDIOCGAUDIO", __FUNCTION__);
			return 0;
		}
		case VIDIOCSAUDIO:
		{
			struct video_audio *va = arg;
			if(va->audio) {
				return -EINVAL;
			}

			if(va->flags & VIDEO_AUDIO_MUTE) {
				if (usbvision_audio_mute(usbvision)) {
					return -EFAULT;
				}
			}
			else {
				if (usbvision_audio_on(usbvision)) {
					return -EFAULT;
				}
			}
			PDEBUG(DBG_RIO, "%s: VIDIOCSAUDIO flags=0x%x)", __FUNCTION__, va->flags);
			return 0;
		}
		case VIDIOCGFREQ:
		{
			unsigned long *freq = arg;

			*freq = usbvision->freq;
			PDEBUG(DBG_RIO, "%s: VIDIOCGFREQ freq = %ld00 kHz", __FUNCTION__, (*freq * 10)>>4);
			return 0;
		}
		case VIDIOCSFREQ:
		{
			unsigned long *freq = arg;

			usbvision->freq = *freq;
			call_i2c_clients(usbvision, cmd, freq);
			PDEBUG(DBG_RIO, "%s: VIDIOCSFREQ freq = %ld00 kHz", __FUNCTION__, (*freq * 10)>>4);
			return 0;
		}
		default:
		{
			PDEBUG(DBG_RIO, "%s: Unknown command %x", __FUNCTION__, cmd);
			return -ENOIOCTLCMD;
		}
	}
	return 0;
}


static int usbvision_radio_ioctl(struct inode *inode, struct file *file,
		       unsigned int cmd, unsigned long arg)
{
	return video_usercopy(inode, file, cmd, arg, usbvision_do_radio_ioctl);
}


/*
 * Here comes the stuff for vbi on usbvision based devices
 *
 */
static int usbvision_vbi_open(struct inode *inode, struct file *file)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
	unsigned long freq;
	int errCode = 0;

	PDEBUG(DBG_RIO, "%s:", __FUNCTION__);

	down(&usbvision->lock);

	if (usbvision->user) {
		err("%s: Someone tried to open an already opened USBVision VBI!", __FUNCTION__);
		errCode = -EBUSY;
	}
	else {
		if(PowerOnAtOpen) {
			if (timer_pending(&usbvision->powerOffTimer)) {
				del_timer(&usbvision->powerOffTimer);
			}
			if (usbvision->power == 0) {
				usbvision_power_on(usbvision);
				usbvision_init_i2c(usbvision);
			}
		}

		// If so far no errors then we shall start the vbi device
		//usbvision->vbi = 1;
		call_i2c_clients(usbvision,AUDC_SET_RADIO,&usbvision->tuner_type);
		freq = 1517; //SWR3 @ 94.8MHz
		call_i2c_clients(usbvision, VIDIOCSFREQ, &freq);
		usbvision_set_audio(usbvision, USBVISION_AUDIO_RADIO);
		usbvision->user++;
	}

	if (errCode) {
		if (PowerOnAtOpen) {
			usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
			usbvision_power_off(usbvision);
			usbvision->initialized = 0;
		}
	}
	up(&usbvision->lock);
	return errCode;
}

static int usbvision_vbi_close(struct inode *inode, struct file *file)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
	int errCode = 0;

	PDEBUG(DBG_RIO, "");

	down(&usbvision->lock);

	usbvision_audio_off(usbvision);
	usbvision->vbi=0;
	usbvision->user--;

	if (PowerOnAtOpen) {
		mod_timer(&usbvision->powerOffTimer, jiffies + USBVISION_POWEROFF_TIME);
		usbvision->initialized = 0;
	}

	up(&usbvision->lock);

	if (usbvision->remove_pending) {
		info("%s: Final disconnect", __FUNCTION__);
		usbvision_release(usbvision);
	}


	PDEBUG(DBG_RIO, "success");

	return errCode;
}

static int usbvision_do_vbi_ioctl(struct inode *inode, struct file *file,
				 unsigned int cmd, void *arg)
{
	struct video_device *dev = video_devdata(file);
	struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);

	if (!USBVISION_IS_OPERATIONAL(usbvision))
		return -EIO;

	switch (cmd) {
		case VIDIOC_QUERYCAP:
		{
			struct v4l2_capability *vc=arg;
			memset(vc, 0, sizeof(struct v4l2_capability));
			strcpy(vc->driver,"usbvision vbi");
			strcpy(vc->card,usbvision->vcap.card);
			strcpy(vc->bus_info,"usb");
			vc->version = USBVISION_DRIVER_VERSION; 	    /* version */
			vc->capabilities = V4L2_CAP_VBI_CAPTURE; 	    /* capabilities */
			PDEBUG(DBG_RIO, "%s: VIDIOC_QUERYCAP", __FUNCTION__);
			return 0;
		}
		case VIDIOCGTUNER:
		{
			struct video_tuner *vt = arg;

			if((vt->tuner) || (usbvision->channel)) {	/* Only tuner 0 */
				return -EINVAL;
			}
			strcpy(vt->name, "vbi");
			// japan:          76.0 MHz -  89.9 MHz
			// western europe: 87.5 MHz - 108.0 MHz
			// russia:         65.0 MHz - 108.0 MHz
			vt->rangelow=(int)(65*16);
			vt->rangehigh=(int)(108*16);
			vt->flags= 0;
			vt->mode = 0;
			call_i2c_clients(usbvision,cmd,vt);
			PDEBUG(DBG_RIO, "%s: VIDIOCGTUNER signal=%d", __FUNCTION__, vt->signal);
			return 0;
		}
		case VIDIOCSTUNER:
		{
			struct video_tuner *vt = arg;

			// Only channel 0 has a tuner
			if((vt->tuner) || (usbvision->channel)) {
				return -EINVAL;
			}
			PDEBUG(DBG_RIO, "%s: VIDIOCSTUNER", __FUNCTION__);
			return 0;
		}
		case VIDIOCGAUDIO:
		{
			struct video_audio *va = arg;
			memset(va,0, sizeof(struct video_audio));
			call_i2c_clients(usbvision, cmd, va);
			va->flags|=VIDEO_AUDIO_MUTABLE;
			va->volume=1;
			va->step=1;
			strcpy(va->name, "vbi");
			PDEBUG(DBG_RIO, "%s: VIDIOCGAUDIO", __FUNCTION__);
			return 0;
		}
		case VIDIOCSAUDIO:
		{
			struct video_audio *va = arg;
			if(va->audio) {
				return -EINVAL;
			}

			if(va->flags & VIDEO_AUDIO_MUTE) {
				if (usbvision_audio_mute(usbvision)) {
					return -EFAULT;
				}
			}
			else {
				if (usbvision_audio_on(usbvision)) {
					return -EFAULT;
				}
			}
			PDEBUG(DBG_RIO, "%s: VIDIOCSAUDIO flags=0x%x)", __FUNCTION__, va->flags);
			return 0;
		}
		case VIDIOCGFREQ:
		{
			unsigned long *freq = arg;

			*freq = usbvision->freq;
			PDEBUG(DBG_RIO, "%s: VIDIOCGFREQ freq = %ld00 kHz", __FUNCTION__, (*freq * 10)>>4);
			return 0;
		}
		case VIDIOCSFREQ:
		{
			unsigned long *freq = arg;

			usbvision->freq = *freq;
			call_i2c_clients(usbvision, cmd, freq);
			PDEBUG(DBG_RIO, "%s: VIDIOCSFREQ freq = %ld00 kHz", __FUNCTION__, (*freq * 10)>>4);
			return 0;
		}
		default:
		{
			PDEBUG(DBG_RIO, "%s: Unknown command %d", __FUNCTION__, cmd);
			return -ENOIOCTLCMD;
		}
	}
	return 0;
}

static int usbvision_vbi_ioctl(struct inode *inode, struct file *file,
		       unsigned int cmd, unsigned long arg)
{
	return video_usercopy(inode, file, cmd, arg, usbvision_do_vbi_ioctl);
}



static void usbvision_configure_video(struct usb_usbvision *usbvision)
{
	int model;

	if (usbvision == NULL)
		return;
		
	model = usbvision->DevModel;

	RESTRICT_TO_RANGE(init_brightness, 0, 255);
	RESTRICT_TO_RANGE(init_contrast, 0, 255);
	RESTRICT_TO_RANGE(init_saturation, 0, 255);
	RESTRICT_TO_RANGE(init_hue, 0, 255);
	
	usbvision->saturation = init_saturation << 8;
	usbvision->hue = init_hue << 8;
	usbvision->brightness = init_brightness << 8;
	usbvision->contrast = init_contrast << 8;
	usbvision->depth = 24;
	usbvision->palette = usbvision_v4l2_format[2]; // V4L2_PIX_FMT_RGB24;

	if (usbvision_device_data[usbvision->DevModel].Vin_Reg2 >= 0) {
		usbvision->Vin_Reg2_Preset = usbvision_device_data[usbvision->DevModel].Vin_Reg2 & 0xff;
	} else {
		usbvision->Vin_Reg2_Preset = 0;
	}

	memset(&usbvision->vcap, 0, sizeof(usbvision->vcap));
	strcpy(usbvision->vcap.driver, "USBVision");
	usbvision->vcap.capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
		(dga ? (V4L2_FBUF_CAP_LIST_CLIPPING | V4L2_CAP_VIDEO_OVERLAY) : 0) |
		(usbvision->have_tuner ? V4L2_CAP_TUNER : 0);
	usbvision->vcap.version = USBVISION_DRIVER_VERSION; 	    /* version */

	usbvision->video_inputs = usbvision_device_data[model].VideoChannels;

	memset(&usbvision->input, 0, sizeof(usbvision->input));
	usbvision->input.tuner = 0;
	usbvision->input.type = V4L2_INPUT_TYPE_TUNER|VIDEO_TYPE_CAMERA;
	usbvision->input.std = usbvision_device_data[model].VideoNorm;

	/* This should be here to make i2c clients to be able to register */
	usbvision_audio_off(usbvision);	//first switch off audio
	if (!PowerOnAtOpen) {
		usbvision_power_on(usbvision);	//and then power up the noisy tuner
		usbvision_init_i2c(usbvision);
	}
}

//
// Video registration stuff
//

// Video template
static struct file_operations usbvision_fops = {
  #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
	.owner             = THIS_MODULE,
  #endif
	.open		= usbvision_v4l2_open,
	.release	= usbvision_v4l2_close,
	.read		= usbvision_v4l2_read,
	.mmap		= usbvision_v4l2_mmap,
	.ioctl		= usbvision_v4l2_ioctl,
	.llseek		= no_llseek,
};
static struct video_device usbvision_video_template = {
  #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
	.owner             = THIS_MODULE,
  #endif
	.type		= VID_TYPE_TUNER | VID_TYPE_CAPTURE,
	.hardware	= VID_HARDWARE_USBVISION,
	.fops		= &usbvision_fops,
  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
	.name           = "usbvision-video",
	.release	= video_device_release,
  #endif
	.minor		= -1,
};


// Radio template
static struct file_operations usbvision_radio_fops = {
  #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
	.owner             = THIS_MODULE,
  #endif
	.open		= usbvision_radio_open,
	.release	= usbvision_radio_close,
	.ioctl		= usbvision_radio_ioctl,
	.llseek		= no_llseek,
};

static struct video_device usbvision_radio_template=
{
  #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
	.owner             = THIS_MODULE,
  #endif
	.type		= VID_TYPE_TUNER,
	.hardware	= VID_HARDWARE_USBVISION,
	.fops		= &usbvision_radio_fops,
  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
	.release	= video_device_release,
	.name           = "usbvision-radio",
  #endif
	.minor		= -1,
};


// vbi template
static struct file_operations usbvision_vbi_fops = {
  #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
	.owner             = THIS_MODULE,
  #endif
	.open		= usbvision_vbi_open,
	.release	= usbvision_vbi_close,
	.ioctl		= usbvision_vbi_ioctl,
	.llseek		= no_llseek,
};

static struct video_device usbvision_vbi_template=
{
  #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
	.owner             = THIS_MODULE,
  #endif
	.type		= VID_TYPE_TUNER,
	.hardware	= VID_HARDWARE_USBVISION,
	.fops		= &usbvision_vbi_fops,
  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
	.release	= video_device_release,
	.name           = "usbvision-vbi",
  #endif
	.minor		= -1,
};


static struct video_device *usbvision_vdev_init(struct usb_usbvision *usbvision,
					struct video_device *vdev_template,
					char *name)
{
	struct usb_device *usb_dev = usbvision->dev;
	struct video_device *vdev;

	if (usb_dev == NULL) {
		err("%s: usbvision->dev is not set", __FUNCTION__);
		return NULL;
	}

	vdev = video_device_alloc();
	if (NULL == vdev) {
		return NULL;
	}
	*vdev = *vdev_template;
//	vdev->minor   = -1;
	vdev->dev     = &usb_dev->dev;
	snprintf(vdev->name, sizeof(vdev->name), "%s", name);
	video_set_drvdata(vdev, usbvision);
	return vdev;
}

// unregister video4linux devices
static void usbvision_unregister_video(struct usb_usbvision *usbvision)
{
	// vbi Device:
	if (usbvision->vbi) {
		PDEBUG(DBG_PROBE, "unregister /dev/vbi%d [v4l2]", usbvision->vbi->minor & 0x1f);
		if (usbvision->vbi->minor != -1) {
			video_unregister_device(usbvision->vbi);
		}
		else {
			video_device_release(usbvision->vbi);
		}
		usbvision->vbi = NULL;
	}
	
	// Radio Device:
	if (usbvision->rdev) {
		PDEBUG(DBG_PROBE, "unregister /dev/radio%d [v4l2]", usbvision->rdev->minor & 0x1f);
		if (usbvision->rdev->minor != -1) {
			video_unregister_device(usbvision->rdev);
		}
		else {
			video_device_release(usbvision->rdev);
		}
		usbvision->rdev = NULL;
	}

	// Video Device:
	if (usbvision->vdev) {
		PDEBUG(DBG_PROBE, "unregister /dev/video%d [v4l2]", usbvision->vdev->minor & 0x1f);
		if (usbvision->vdev->minor != -1) {
			video_unregister_device(usbvision->vdev);
		}
		else {
			video_device_release(usbvision->vdev);
		}
		usbvision->vdev = NULL;
	}
}

// register video4linux devices
static int __devinit usbvision_register_video(struct usb_usbvision *usbvision)
{
	// Video Device:
	usbvision->vdev = usbvision_vdev_init(usbvision, &usbvision_video_template, "USBVision Video");
	if (usbvision->vdev == NULL) {
		goto err_exit;
	}
	if (video_register_device(usbvision->vdev, VFL_TYPE_GRABBER, video_nr)<0) {
		goto err_exit;
	}
	info("USBVision[%d]: registered USBVision Video device /dev/video%d [v4l2]", usbvision->nr,usbvision->vdev->minor & 0x1f);

	// Radio Device:
	if (usbvision_device_data[usbvision->DevModel].Radio) {
		// usbvision has radio
		usbvision->rdev = usbvision_vdev_init(usbvision, &usbvision_radio_template, "USBVision Radio");
		if (usbvision->rdev == NULL) {
			goto err_exit;
		}
		if (video_register_device(usbvision->rdev, VFL_TYPE_RADIO, radio_nr)<0) {
			goto err_exit;
		}
		info("USBVision[%d]: registered USBVision Radio device /dev/radio%d [v4l2]", usbvision->nr, usbvision->rdev->minor & 0x1f);
	}
	// vbi Device: 
	if (usbvision_device_data[usbvision->DevModel].vbi) {
		usbvision->vbi = usbvision_vdev_init(usbvision, &usbvision_vbi_template, "USBVision VBI");
		if (usbvision->vdev == NULL) {
			goto err_exit;
		}
		if (video_register_device(usbvision->vbi, VFL_TYPE_VBI, vbi_nr)<0) {
			goto err_exit;
		}
		info("USBVision[%d]: registered USBVision VBI device /dev/vbi%d [v4l2] (Not Working Yet!)", usbvision->nr,usbvision->vbi->minor & 0x1f);
	}
	// all done
	return 0;

 err_exit:
	err("USBVision[%d]: video_register_device() failed", usbvision->nr);
	usbvision_unregister_video(usbvision);
	return -1;
}

/*
 * usbvision_alloc()
 *
 * This code allocates the struct usb_usbvision. It is filled with default values.
 *
 * Returns NULL on error, a pointer to usb_usbvision else.
 *
 */
static struct usb_usbvision *usbvision_alloc(struct usb_device *dev)
{
	struct usb_usbvision *usbvision;
	int FrameIdx;

	if ((usbvision = kzalloc(sizeof(struct usb_usbvision), GFP_KERNEL)) == NULL) {
		goto err_exit;
	}

	usbvision->dev = dev;

	for (FrameIdx = 0; FrameIdx < USBVISION_NUMFRAMES; FrameIdx++) {
		init_waitqueue_head(&usbvision->frame[FrameIdx].wq);
	}
	init_waitqueue_head(&usbvision->overlay_frame.wq);
	init_MUTEX(&usbvision->lock);	/* to 1 == available */

	// prepare control urb for control messages during interrupts
	usbvision->ctrlUrb = usb_alloc_urb(USBVISION_URB_FRAMES, GFP_KERNEL);
	if (usbvision->ctrlUrb == NULL) {
		goto err_exit;
	}
	init_waitqueue_head(&usbvision->ctrlUrb_wq);
	init_MUTEX(&usbvision->ctrlUrbLock);

	init_timer(&usbvision->powerOffTimer);
	usbvision->powerOffTimer.data = (long) usbvision;
	usbvision->powerOffTimer.function = usbvision_powerOffTimer;

	return usbvision;

err_exit:
	if (usbvision && usbvision->ctrlUrb) {
		usb_free_urb(usbvision->ctrlUrb);
	}
	if (usbvision) {
		kfree(usbvision);
	}
	return NULL;
}

/*
 * usbvision_release()
 *
 * This code does final release of struct usb_usbvision. This happens
 * after the device is disconnected -and- all clients closed their files.
 *
 */
static void usbvision_release(struct usb_usbvision *usbvision)
{
	PDEBUG(DBG_PROBE, "");

	down(&usbvision->lock);

	if (timer_pending(&usbvision->powerOffTimer)) {
		del_timer(&usbvision->powerOffTimer);
	}

	usbvision->usbvision_used = 0;
	usbvision->initialized = 0;

	up(&usbvision->lock);

	usbvision_remove_sysfs(usbvision->vdev);
	usbvision_unregister_video(usbvision);
	if(dga) {
		if (usbvision->overlay_base) {
			iounmap(usbvision->overlay_base);
		}
	}

	if (usbvision->ctrlUrb) {
		usb_free_urb(usbvision->ctrlUrb);
	}

	kfree(usbvision);

	PDEBUG(DBG_PROBE, "success");
}


/*
 * usbvision_probe()
 *
 * This procedure queries device descriptor and accepts the interface
 * if it looks like USBVISION video device
 *
 */
static int __devinit usbvision_probe(struct usb_interface *intf, const struct usb_device_id *devid)
{
	struct usb_device *dev = interface_to_usbdev(intf);
	__u8 ifnum = intf->altsetting->desc.bInterfaceNumber;
	const struct usb_host_interface *interface;
	struct usb_usbvision *usbvision = NULL;
	const struct usb_endpoint_descriptor *endpoint;
	int model;

	PDEBUG(DBG_PROBE, "VID=%#04x, PID=%#04x, ifnum=%u",
					dev->descriptor.idVendor, dev->descriptor.idProduct, ifnum);

	/* Is it an USBVISION video dev? */
	model = 0;
	for(model = 0; usbvision_device_data[model].idVendor; model++) {
		if (le16_to_cpu(dev->descriptor.idVendor) != usbvision_device_data[model].idVendor) { 
			continue;
		}
		if (le16_to_cpu(dev->descriptor.idProduct) != usbvision_device_data[model].idProduct) { 
			continue;
		}

		info("%s: %s found", __FUNCTION__, usbvision_device_data[model].ModelString);
		break;
	}

	if (usbvision_device_data[model].idVendor == 0) {
		return -ENODEV; //no matching device
	}
	if (usbvision_device_data[model].Interface >= 0) {
		interface = &dev->actconfig->interface[usbvision_device_data[model].Interface]->altsetting[0];
	}
	else {
		interface = &dev->actconfig->interface[ifnum]->altsetting[0];
	}
	endpoint = &interface->endpoint[1].desc;
	if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_ISOC) {
		err("%s: interface %d. has non-ISO endpoint!", __FUNCTION__, ifnum);
		err("%s: Endpoint attribures %d", __FUNCTION__, endpoint->bmAttributes);
		return -ENODEV;
	}
	if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) {
		err("%s: interface %d. has ISO OUT endpoint!", __FUNCTION__, ifnum);
		return -ENODEV;
	}

	usb_get_dev(dev);
	
	if ((usbvision = usbvision_alloc(dev)) == NULL) {
		err("%s: couldn't allocate USBVision struct", __FUNCTION__);
		return -ENOMEM;
	}
	if (dev->descriptor.bNumConfigurations > 1) {
		usbvision->bridgeType = BRIDGE_NT1004;
	}
	else if (usbvision_device_data[model].ModelString == "Dazzle Fusion Model DVC-90 Rev 1 (SECAM)") {
		usbvision->bridgeType = BRIDGE_NT1005;
	}		
	else {
		usbvision->bridgeType = BRIDGE_NT1003;
	}
	PDEBUG(DBG_PROBE, "bridgeType %d", usbvision->bridgeType);

	down(&usbvision->lock);

	usbvision->nr = usbvision_nr++;

	usbvision->have_tuner = usbvision_device_data[model].Tuner;
	if (usbvision->have_tuner) {
		usbvision->tuner_type = usbvision_device_data[model].TunerType;
	}

	usbvision->DevModel = model;
	usbvision->remove_pending = 0;
	usbvision->last_error = 0;
	usbvision->iface = ifnum;
	usbvision->ifaceAltInactive = 0;
	usbvision->ifaceAltActive = 1;
	usbvision->video_endp = endpoint->bEndpointAddress;
	usbvision->isocPacketSize = 0;
	usbvision->usb_bandwidth = 0;
	usbvision->user = 0;

	usbvision_register_video(usbvision);
	usbvision_configure_video(usbvision);
	up(&usbvision->lock);


	usb_set_intfdata (intf, usbvision);
	usbvision_create_sysfs(usbvision->vdev);	

	PDEBUG(DBG_PROBE, "success");
	return 0;
}


/*
 * usbvision_disconnect()
 *
 * This procedure stops all driver activity, deallocates interface-private
 * structure (pointed by 'ptr') and after that driver should be removable
 * with no ill consequences.
 *
 */
static void __devexit usbvision_disconnect(struct usb_interface *intf)
{
	struct usb_usbvision *usbvision = usb_get_intfdata(intf);

	PDEBUG(DBG_PROBE, "");

	if (usbvision == NULL) {
		err("%s: usb_get_intfdata() failed", __FUNCTION__);
		return;
	}
	usb_set_intfdata (intf, NULL);

	down(&usbvision->lock);

	// At this time we ask to cancel outstanding URBs
	usbvision_stop_isoc(usbvision);

	if (usbvision->power) {
		usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
		usbvision_power_off(usbvision);
	}
	usbvision->remove_pending = 1;	// Now all ISO data will be ignored

	usb_put_dev(usbvision->dev);
	usbvision->dev = NULL;	// USB device is no more

	up(&usbvision->lock);

	if (usbvision->user) {
		info("%s: In use, disconnect pending", __FUNCTION__);
	}
	else {
		usbvision_release(usbvision);
	}

	PDEBUG(DBG_PROBE, "success");

}

MODULE_DEVICE_TABLE (usb, usbvision_table);

static struct usb_driver usbvision_driver = {
	.name		= "usbvision",
	.id_table	= usbvision_table,
	.probe		= usbvision_probe,
	.disconnect	= usbvision_disconnect
};

/*
 * customdevice_process()
 *
 * This procedure preprocesses CustomDevice parameter if any
 *
 */
void customdevice_process(void)
{
	usbvision_device_data[0]=usbvision_device_data[1];
	usbvision_table[0]=usbvision_table[1];

	if(CustomDevice)
	{
		char *parse=CustomDevice;
	
		PDEBUG(DBG_PROBE, "CustomDevide=%s", CustomDevice);

		/*format is CustomDevice="0x0573 0x4D31 0 7113 3 PAL 1 1 1 5 -1 -1 -1 -1 -1"
		usbvision_device_data[0].idVendor;
		usbvision_device_data[0].idProduct;
		usbvision_device_data[0].Interface;
		usbvision_device_data[0].Codec;
		usbvision_device_data[0].VideoChannels;
		usbvision_device_data[0].VideoNorm;
		usbvision_device_data[0].AudioChannels;
		usbvision_device_data[0].Radio;
		usbvision_device_data[0].Tuner;
		usbvision_device_data[0].TunerType;
		usbvision_device_data[0].Vin_Reg1;
		usbvision_device_data[0].Vin_Reg2;
		usbvision_device_data[0].X_Offset;
		usbvision_device_data[0].Y_Offset;
		usbvision_device_data[0].Dvi_yuv;
	 	usbvision_device_data[0].ModelString;
		*/
		
		rmspace(parse);
		usbvision_device_data[0].ModelString="USBVISION Custom Device";

		parse+=2;
		sscanf(parse,"%x",&usbvision_device_data[0].idVendor);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "idVendor=0x%.4X", usbvision_device_data[0].idVendor);
		parse+=2;
		sscanf(parse,"%x",&usbvision_device_data[0].idProduct);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "idProduct=0x%.4X", usbvision_device_data[0].idProduct);
		sscanf(parse,"%d",&usbvision_device_data[0].Interface);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "Interface=%d", usbvision_device_data[0].Interface);
		sscanf(parse,"%d",&usbvision_device_data[0].Codec);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "Codec=%d", usbvision_device_data[0].Codec);
		sscanf(parse,"%d",&usbvision_device_data[0].VideoChannels);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "VideoChannels=%d", usbvision_device_data[0].VideoChannels);

		switch(*parse)
		{
			case 'P':
				PDEBUG(DBG_PROBE, "VideoNorm=PAL");
				usbvision_device_data[0].VideoNorm=VIDEO_MODE_PAL;
				break;

			case 'S':
				PDEBUG(DBG_PROBE, "VideoNorm=SECAM");
				usbvision_device_data[0].VideoNorm=VIDEO_MODE_SECAM;
				break;

			case 'N':
				PDEBUG(DBG_PROBE, "VideoNorm=NTSC");
				usbvision_device_data[0].VideoNorm=VIDEO_MODE_NTSC;
				break;

			default:
				PDEBUG(DBG_PROBE, "VideoNorm=PAL (by default)");
				usbvision_device_data[0].VideoNorm=VIDEO_MODE_PAL;
				break;
		}
		goto2next(parse);

		sscanf(parse,"%d",&usbvision_device_data[0].AudioChannels);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "AudioChannels=%d", usbvision_device_data[0].AudioChannels);
		sscanf(parse,"%d",&usbvision_device_data[0].Radio);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "Radio=%d", usbvision_device_data[0].Radio);
		sscanf(parse,"%d",&usbvision_device_data[0].Tuner);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "Tuner=%d", usbvision_device_data[0].Tuner);
		sscanf(parse,"%d",&usbvision_device_data[0].TunerType);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "TunerType=%d", usbvision_device_data[0].TunerType);
		sscanf(parse,"%d",&usbvision_device_data[0].Vin_Reg1);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "Vin_Reg1=%d", usbvision_device_data[0].Vin_Reg1);
		sscanf(parse,"%d",&usbvision_device_data[0].Vin_Reg2);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "Vin_Reg2=%d", usbvision_device_data[0].Vin_Reg2);
		sscanf(parse,"%d",&usbvision_device_data[0].X_Offset);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "X_Offset=%d", usbvision_device_data[0].X_Offset);
		sscanf(parse,"%d",&usbvision_device_data[0].Y_Offset);
		goto2next(parse);
		PDEBUG(DBG_PROBE, "Y_Offset=%d", usbvision_device_data[0].Y_Offset);
		sscanf(parse,"%d",&usbvision_device_data[0].Dvi_yuv);
		PDEBUG(DBG_PROBE, "Dvi_yuv=%d", usbvision_device_data[0].Dvi_yuv);

		//add to usbvision_table also
		usbvision_table[0].match_flags=USB_DEVICE_ID_MATCH_DEVICE;
		usbvision_table[0].idVendor=usbvision_device_data[0].idVendor;
		usbvision_table[0].idProduct=usbvision_device_data[0].idProduct;

	}
}



/*
 * usbvision_init()
 *
 * This code is run to initialize the driver.
 *
 */
static int __init usbvision_init(void)
{
	int errCode;

	PDEBUG(DBG_PROBE, "");

	PDEBUG(DBG_IOCTL, "IOCTL   debugging is enabled");
	PDEBUG(DBG_IO,  "IO      debugging is enabled");
	PDEBUG(DBG_RIO,  "RIO     debugging is enabled");
	PDEBUG(DBG_HEADER, "HEADER  debugging is enabled");
	PDEBUG(DBG_PROBE, "PROBE   debugging is enabled");
	PDEBUG(DBG_IRQ,  "IRQ     debugging is enabled");
	PDEBUG(DBG_ISOC, "ISOC    debugging is enabled");
	PDEBUG(DBG_PARSE, "PARSE   debugging is enabled");
	PDEBUG(DBG_SCRATCH, "SCRATCH debugging is enabled");
	PDEBUG(DBG_FUNC, "FUNC    debugging is enabled");
	PDEBUG(DBG_I2C,  "I2C     debugging is enabled");

	/* disable planar mode support unless compression enabled */ 
	if (isocMode != ISOC_MODE_COMPRESS ) { 
		// FIXME : not the right way to set supported flag
		usbvision_v4l2_format[6].supported = 0; // V4L2_PIX_FMT_YVU420
		usbvision_v4l2_format[7].supported = 0; // V4L2_PIX_FMT_YUV422P
	} 

	customdevice_process();

	errCode = usb_register(&usbvision_driver);

	if (errCode == 0) {
		info(DRIVER_DESC " : " DRIVER_VERSION);
		PDEBUG(DBG_PROBE, "success");
	}
	return errCode;
}

static void __exit usbvision_exit(void)
{
 PDEBUG(DBG_PROBE, "");

 usb_deregister(&usbvision_driver);
 PDEBUG(DBG_PROBE, "success");
}

module_init(usbvision_init);
module_exit(usbvision_exit);

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */