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