2 * USB USBVISION Video device driver 0.9.8.3cvs (For Kernel 2.4.19-2.4.32 + 2.6.0-2.6.16)
6 * Copyright (c) 1999-2005 Joerg Heckenbach <joerg@heckenbach-aw.de>
8 * This module is part of usbvision driver project.
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.
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.
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.
24 * Let's call the version 0.... until compression decoding is completely
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
36 * Mar. 2000 - 15.12.2000: (0.0.0 - 0.2.0)
37 * Several alpha drivers and the first beta.
39 * Since Dec. 2000: (0.2.1) or (v2.1)
40 * Code changes or updates by Dwaine Garden and every other person.
42 * Added: New Hauppauge TV device Vendor ID: 0x0573
44 * (Thanks to Giovanni Garberoglio)
46 * Added: UK Hauppauge WinTV-USB Vendor ID: 0x0573
48 * (Thanks to Derek Freeman-Jones)
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
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
67 * (Thanks to Julius Hrivnac)
68 * - Added: US Hauppauge WINTV USB Vendor ID: 0x0573
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.
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.
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.
83 * July 6, 2001 - Added: HAUPPAUGE WINTV-USB FM USA Vendor ID: 0x0573
85 * (Thanks to Braddock Gaskill)
86 * Added: USBGear USBG-V1 resp. HAMA USB
89 * (Thanks to Bradley A. Singletary and Juergen Weigert)
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.
104 * - Added radio device
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.
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.
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.
126 * Feb 10, 2003 - Joerg Heckenbach
127 * - fixed endian bug for Motorola PPC
129 * Feb 13, 2003 - Joerg Heckenbach
130 * - fixed Vin_Reg setting and presetting from usbvision_device_data()
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*)
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.
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)
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
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.
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
165 * Feb 04, 2004 - 0.9.4 Joerg Heckenbach
166 * - Found bug in color decompression. Color is OK now.
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)
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
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*)
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
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.
190 * July 30, 2004 - 0.9.6 Dwaine Garden
191 * - Patch was submitted by Tobias Diaz to fix Model ID mismatch in usbvision.h.
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.
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.
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*(
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.
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.
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.
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)
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.
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+.
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.
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*)
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
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)
266 * June 14, 2005 - 0.9.8.2cvs Dwaine
267 * - Missed a change in saa7113.c for checking kernel version. Added conditional if's.
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.
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.
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.
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.
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......
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
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
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.
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*)
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.
316 * - use submit_urb for all setup packets
317 * - Fix memory settings for nt1004. It is 4 times as big as the
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
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>
343 #include <linux/videodev2.h>
344 #include <linux/video_decoder.h>
345 #include <linux/i2c.h>
347 #define USBVISION_DRIVER_VERSION_MAJOR 0
348 #define USBVISION_DRIVER_VERSION_MINOR 8
349 #define USBVISION_DRIVER_VERSION_PATCHLEVEL 0
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)
354 #include <media/saa7115.h>
355 #include <media/v4l2-common.h>
356 #include <media/tuner.h>
357 #include <media/audiochip.h>
359 #include <linux/moduleparam.h>
360 #include <linux/workqueue.h>
363 #include <linux/kmod.h>
366 #include "usbvision.h"
367 #include "usbvision_ioctl.h"
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"
377 #define ENABLE_HEXDUMP 0 /* Enable if you need it */
380 #define USBVISION_DEBUG /* Turn on debug messages */
382 #ifdef USBVISION_DEBUG
383 #define PDEBUG(level, fmt, args...) \
384 if (debug & (level)) info("[%s:%d] " fmt, __PRETTY_FUNCTION__, __LINE__ , ## args)
386 #define PDEBUG(level, fmt, args...) do {} while(0)
389 #define DBG_IOCTL 1<<3
392 #define DBG_HEADER 1<<7
393 #define DBG_PROBE 1<<8
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
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 */
407 #define rmspace(str) while(*str==' ') str++;
408 #define goto2next(str) while(*str!=' ') str++; while(*str==' ') str++;
411 static int usbvision_nr
= 0; // sequential number of usbvision device
412 static unsigned long usbvision_timestamp
= 0; // timestamp in jiffies of a hundred frame
413 static unsigned long usbvision_counter
= 0; // frame counter
415 static const int max_imgwidth
= MAX_FRAME_WIDTH
;
416 static const int max_imgheight
= MAX_FRAME_HEIGHT
;
417 static const int min_imgwidth
= MIN_FRAME_WIDTH
;
418 static const int min_imgheight
= MIN_FRAME_HEIGHT
;
420 #define FRAMERATE_MIN 0
421 #define FRAMERATE_MAX 31
425 ISOC_MODE_YUV422
= 0x03,
426 ISOC_MODE_YUV420
= 0x14,
427 ISOC_MODE_COMPRESS
= 0x60,
430 static struct usbvision_v4l2_format_st usbvision_v4l2_format
[] = {
431 { 1, 1, 8, V4L2_PIX_FMT_GREY
, "GREY" },
432 { 1, 2, 16, V4L2_PIX_FMT_RGB565
, "RGB565" },
433 { 1, 3, 24, V4L2_PIX_FMT_RGB24
, "RGB24" },
434 { 1, 4, 32, V4L2_PIX_FMT_RGB32
, "RGB32" },
435 { 1, 2, 16, V4L2_PIX_FMT_RGB555
, "RGB555" },
436 { 1, 2, 16, V4L2_PIX_FMT_YUYV
, "YUV422" },
437 { 1, 2, 12, V4L2_PIX_FMT_YVU420
, "YUV420P" }, // 1.5 !
438 { 1, 2, 16, V4L2_PIX_FMT_YUV422P
, "YUV422P" }
441 /* supported tv norms */
442 static struct usbvision_tvnorm tvnorms
[] = {
451 .id
= V4L2_STD_SECAM
,
454 .id
= V4L2_STD_PAL_M
,
458 #define TVNORMS ARRAY_SIZE(tvnorms)
462 * The value of 'scratch_buf_size' affects quality of the picture
463 * in many ways. Shorter buffers may cause loss of data when client
464 * is too slow. Larger buffers are memory-consuming and take longer
465 * to work with. This setting can be adjusted, but the default value
466 * should be OK for most desktop users.
468 #define DEFAULT_SCRATCH_BUF_SIZE (0x20000) // 128kB memory scratch buffer
469 static const int scratch_buf_size
= DEFAULT_SCRATCH_BUF_SIZE
;
471 // Function prototypes
472 static int usbvision_restart_isoc(struct usb_usbvision
*usbvision
);
473 static int usbvision_begin_streaming(struct usb_usbvision
*usbvision
);
474 static int usbvision_muxsel(struct usb_usbvision
*usbvision
, int channel
);
475 static int usbvision_i2c_write(void *data
, unsigned char addr
, char *buf
, short len
);
476 static int usbvision_i2c_read(void *data
, unsigned char addr
, char *buf
, short len
);
477 static int usbvision_read_reg(struct usb_usbvision
*usbvision
, unsigned char reg
);
478 static int usbvision_write_reg(struct usb_usbvision
*usbvision
, unsigned char reg
, unsigned char value
);
479 static int usbvision_request_intra (struct usb_usbvision
*usbvision
);
480 static int usbvision_unrequest_intra (struct usb_usbvision
*usbvision
);
481 static int usbvision_adjust_compression (struct usb_usbvision
*usbvision
);
482 static int usbvision_measure_bandwidth (struct usb_usbvision
*usbvision
);
483 static void usbvision_release(struct usb_usbvision
*usbvision
);
484 static int usbvision_set_input(struct usb_usbvision
*usbvision
);
485 static int usbvision_set_output(struct usb_usbvision
*usbvision
, int width
, int height
);
486 static void usbvision_empty_framequeues(struct usb_usbvision
*dev
);
487 static int usbvision_stream_interrupt(struct usb_usbvision
*dev
);
488 static void call_i2c_clients(struct usb_usbvision
*usbvision
, unsigned int cmd
, void *arg
);
491 // Bit flags (options)
492 #define FLAGS_RETRY_VIDIOCSYNC (1 << 0)
493 #define FLAGS_MONOCHROME (1 << 1)
494 #define FLAGS_DISPLAY_HINTS (1 << 2)
495 #define FLAGS_OSD_STATS (1 << 3)
496 #define FLAGS_FORCE_TESTPATTERN (1 << 4)
497 #define FLAGS_SEPARATE_FRAMES (1 << 5)
498 #define FLAGS_CLEAN_FRAMES (1 << 6)
500 // Default initalization of device driver parameters
501 static int flags
= 0; // Set the default Overlay Display mode of the device driver
502 static int debug
= 0; // Set the default Debug Mode of the device driver
503 static int isocMode
= ISOC_MODE_COMPRESS
; // Set the default format for ISOC endpoint
504 static int adjustCompression
= 1; // Set the compression to be adaptive
505 static int dga
= 1; // Set the default Direct Graphic Access
506 static int PowerOnAtOpen
= 1; // Set the default device to power on at startup
507 static int SwitchSVideoInput
= 0; // To help people with Black and White output with using s-video input. Some cables and input device are wired differently.
508 static int video_nr
= -1; // Sequential Number of Video Device
509 static int radio_nr
= -1; // Sequential Number of Radio Device
510 static int vbi_nr
= -1; // Sequential Number of VBI Device
511 static char *CustomDevice
=NULL
; // Set as nothing....
513 // Grab parameters for the device driver
515 #if defined(module_param) // Showing parameters under SYSFS
516 module_param(flags
, int, 0444);
517 module_param(debug
, int, 0444);
518 module_param(isocMode
, int, 0444);
519 module_param(adjustCompression
, int, 0444);
520 module_param(dga
, int, 0444);
521 module_param(PowerOnAtOpen
, int, 0444);
522 module_param(SwitchSVideoInput
, int, 0444);
523 module_param(video_nr
, int, 0444);
524 module_param(radio_nr
, int, 0444);
525 module_param(vbi_nr
, int, 0444);
526 module_param(CustomDevice
, charp
, 0444);
528 MODULE_PARM(flags
, "i"); // Grab the Overlay Display mode of the device driver
529 MODULE_PARM(debug
, "i"); // Grab the Debug Mode of the device driver
530 MODULE_PARM(isocMode
, "i"); // Grab the video format of the video device
531 MODULE_PARM(adjustCompression
, "i"); // Grab the compression to be adaptive
532 MODULE_PARM(dga
, "i"); // Grab the Direct Graphic Access
533 MODULE_PARM(PowerOnAtOpen
, "i"); // Grab the device to power on at startup
534 MODULE_PARM(SwitchSVideoInput
, "i"); // To help people with Black and White output with using s-video input. Some cables and input device are wired differently.
535 MODULE_PARM(video_nr
, "i"); // video_nr option allows to specify a certain /dev/videoX device (like /dev/video0 or /dev/video1 ...)
536 MODULE_PARM(radio_nr
, "i"); // radio_nr option allows to specify a certain /dev/radioX device (like /dev/radio0 or /dev/radio1 ...)
537 MODULE_PARM(vbi_nr
, "i"); // vbi_nr option allows to specify a certain /dev/vbiX device (like /dev/vbi0 or /dev/vbi1 ...)
538 MODULE_PARM(CustomDevice
, "s"); // .... CustomDevice
541 MODULE_PARM_DESC(flags
, " Set the default Overlay Display mode of the device driver. Default: 0 (Off)");
542 MODULE_PARM_DESC(debug
, " Set the default Debug Mode of the device driver. Default: 0 (Off)");
543 MODULE_PARM_DESC(isocMode
, " Set the default format for ISOC endpoint. Default: 0x60 (Compression On)");
544 MODULE_PARM_DESC(adjustCompression
, " Set the ADPCM compression for the device. Default: 1 (On)");
545 MODULE_PARM_DESC(dga
, " Set the Direct Graphic Access for the device. Default: 1 (On)");
546 MODULE_PARM_DESC(PowerOnAtOpen
, " Set the default device to power on when device is opened. Default: 1 (On)");
547 MODULE_PARM_DESC(SwitchSVideoInput
, " Set the S-Video input. Some cables and input device are wired differently. Default: 0 (Off)");
548 MODULE_PARM_DESC(video_nr
, "Set video device number (/dev/videoX). Default: -1 (autodetect)");
549 MODULE_PARM_DESC(radio_nr
, "Set radio device number (/dev/radioX). Default: -1 (autodetect)");
550 MODULE_PARM_DESC(vbi_nr
, "Set vbi device number (/dev/vbiX). Default: -1 (autodetect)");
551 MODULE_PARM_DESC(CustomDevice
, " Define the fine tuning parameters for the device. Default: null");
555 MODULE_AUTHOR(DRIVER_AUTHOR
);
556 MODULE_DESCRIPTION(DRIVER_DESC
);
557 MODULE_LICENSE(DRIVER_LICENSE
);
558 MODULE_VERSION(DRIVER_VERSION
);
559 MODULE_ALIAS(DRIVER_ALIAS
);
562 static unsigned int autoload
= 1;
564 static unsigned int autoload
= 0;
568 /****************************************************************************************/
569 /* SYSFS Code - Copied from the stv680.c usb module. */
570 /* Device information is located at /sys/class/video4linux/video0 */
571 /* Device parameters information is located at /sys/module/usbvision */
572 /* Device USB Information is located at /sys/bus/usb/drivers/USBVision Video Grabber */
573 /****************************************************************************************/
576 #define YES_NO(x) ((x) ? "Yes" : "No")
578 static inline struct usb_usbvision
*cd_to_usbvision(struct class_device
*cd
)
580 struct video_device
*vdev
= to_video_device(cd
);
581 return video_get_drvdata(vdev
);
584 static ssize_t
show_version(struct class_device
*cd
, char *buf
)
586 return sprintf(buf
, "%s\n", DRIVER_VERSION
);
588 static CLASS_DEVICE_ATTR(version
, S_IRUGO
, show_version
, NULL
);
590 static ssize_t
show_model(struct class_device
*class_dev
, char *buf
)
592 struct video_device
*vdev
= to_video_device(class_dev
);
593 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
594 return sprintf(buf
, "%s\n", usbvision_device_data
[usbvision
->DevModel
].ModelString
);
596 static CLASS_DEVICE_ATTR(model
, S_IRUGO
, show_model
, NULL
);
598 static ssize_t
show_hue(struct class_device
*class_dev
, char *buf
)
600 struct video_device
*vdev
= to_video_device(class_dev
);
601 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
602 return sprintf(buf
, "%d\n", usbvision
->hue
>> 8);
604 static CLASS_DEVICE_ATTR(hue
, S_IRUGO
, show_hue
, NULL
);
606 static ssize_t
show_contrast(struct class_device
*class_dev
, char *buf
)
608 struct video_device
*vdev
= to_video_device(class_dev
);
609 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
610 return sprintf(buf
, "%d\n", usbvision
->contrast
>> 8);
612 static CLASS_DEVICE_ATTR(contrast
, S_IRUGO
, show_contrast
, NULL
);
614 static ssize_t
show_brightness(struct class_device
*class_dev
, char *buf
)
616 struct video_device
*vdev
= to_video_device(class_dev
);
617 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
618 return sprintf(buf
, "%d\n", usbvision
->brightness
>> 8);
620 static CLASS_DEVICE_ATTR(brightness
, S_IRUGO
, show_brightness
, NULL
);
622 static ssize_t
show_saturation(struct class_device
*class_dev
, char *buf
)
624 struct video_device
*vdev
= to_video_device(class_dev
);
625 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
626 return sprintf(buf
, "%d\n", usbvision
->saturation
>> 8);
628 static CLASS_DEVICE_ATTR(saturation
, S_IRUGO
, show_saturation
, NULL
);
630 static ssize_t
show_streaming(struct class_device
*class_dev
, char *buf
)
632 struct video_device
*vdev
= to_video_device(class_dev
);
633 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
634 return sprintf(buf
, "%s\n", YES_NO(usbvision
->streaming
==Stream_On
?1:0));
636 static CLASS_DEVICE_ATTR(streaming
, S_IRUGO
, show_streaming
, NULL
);
638 static ssize_t
show_overlay(struct class_device
*class_dev
, char *buf
)
640 struct video_device
*vdev
= to_video_device(class_dev
);
641 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
642 return sprintf(buf
, "%s\n", YES_NO(usbvision
->overlay
));
644 static CLASS_DEVICE_ATTR(overlay
, S_IRUGO
, show_overlay
, NULL
);
646 static ssize_t
show_compression(struct class_device
*class_dev
, char *buf
)
648 struct video_device
*vdev
= to_video_device(class_dev
);
649 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
650 return sprintf(buf
, "%s\n", YES_NO(usbvision
->isocMode
==ISOC_MODE_COMPRESS
));
652 static CLASS_DEVICE_ATTR(compression
, S_IRUGO
, show_compression
, NULL
);
654 static ssize_t
show_device_bridge(struct class_device
*class_dev
, char *buf
)
656 struct video_device
*vdev
= to_video_device(class_dev
);
657 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
658 return sprintf(buf
, "%d\n", usbvision
->bridgeType
);
660 static CLASS_DEVICE_ATTR(bridge
, S_IRUGO
, show_device_bridge
, NULL
);
662 static void usbvision_create_sysfs(struct video_device
*vdev
)
666 res
=video_device_create_file(vdev
, &class_device_attr_version
);
667 res
=video_device_create_file(vdev
, &class_device_attr_model
);
668 res
=video_device_create_file(vdev
, &class_device_attr_hue
);
669 res
=video_device_create_file(vdev
, &class_device_attr_contrast
);
670 res
=video_device_create_file(vdev
, &class_device_attr_brightness
);
671 res
=video_device_create_file(vdev
, &class_device_attr_saturation
);
672 res
=video_device_create_file(vdev
, &class_device_attr_streaming
);
673 res
=video_device_create_file(vdev
, &class_device_attr_overlay
);
674 res
=video_device_create_file(vdev
, &class_device_attr_compression
);
675 res
=video_device_create_file(vdev
, &class_device_attr_bridge
);
679 static void usbvision_remove_sysfs(struct video_device
*vdev
)
682 video_device_remove_file(vdev
, &class_device_attr_version
);
683 video_device_remove_file(vdev
, &class_device_attr_model
);
684 video_device_remove_file(vdev
, &class_device_attr_hue
);
685 video_device_remove_file(vdev
, &class_device_attr_contrast
);
686 video_device_remove_file(vdev
, &class_device_attr_brightness
);
687 video_device_remove_file(vdev
, &class_device_attr_saturation
);
688 video_device_remove_file(vdev
, &class_device_attr_streaming
);
689 video_device_remove_file(vdev
, &class_device_attr_overlay
);
690 video_device_remove_file(vdev
, &class_device_attr_compression
);
691 video_device_remove_file(vdev
, &class_device_attr_bridge
);
696 /*******************************/
697 /* Memory management functions */
698 /*******************************/
701 * Here we want the physical address of the memory.
702 * This is used when initializing the contents of the area.
706 void *usbvision_rvmalloc(unsigned long size
)
711 size
= PAGE_ALIGN(size
);
712 mem
= vmalloc_32(size
);
716 memset(mem
, 0, size
); /* Clear the ram out, no junk to the user */
717 adr
= (unsigned long) mem
;
719 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
720 mem_map_reserve(vmalloc_to_page((void *)adr
));
722 SetPageReserved(vmalloc_to_page((void *)adr
));
731 void usbvision_rvfree(void *mem
, unsigned long size
)
738 adr
= (unsigned long) mem
;
739 while ((long) size
> 0) {
740 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
741 mem_map_unreserve(vmalloc_to_page((void *)adr
));
743 ClearPageReserved(vmalloc_to_page((void *)adr
));
757 static void usbvision_hexdump(const unsigned char *data
, int len
)
762 for (i
= k
= 0; len
> 0; i
++, len
--) {
763 if (i
> 0 && (i
% 16 == 0)) {
767 k
+= sprintf(&tmp
[k
], "%02x ", data
[i
]);
775 /* These procedures handle the scratch ring buffer */
776 int scratch_len(struct usb_usbvision
*usbvision
) /*This returns the amount of data actually in the buffer */
778 int len
= usbvision
->scratch_write_ptr
- usbvision
->scratch_read_ptr
;
780 len
+= scratch_buf_size
;
782 PDEBUG(DBG_SCRATCH
, "scratch_len() = %d\n", len
);
788 /* This returns the free space left in the buffer */
789 int scratch_free(struct usb_usbvision
*usbvision
)
791 int free
= usbvision
->scratch_read_ptr
- usbvision
->scratch_write_ptr
;
793 free
+= scratch_buf_size
;
796 free
-= 1; /* at least one byte in the buffer must */
797 /* left blank, otherwise there is no chance to differ between full and empty */
799 PDEBUG(DBG_SCRATCH
, "return %d\n", free
);
805 void *debug_memcpy(void *dest
, void *src
, size_t len
)
807 printk(KERN_DEBUG
"memcpy(%p, %p, %d);\n", dest
, src
, len
);
808 return memcpy(dest
, src
, len
);
812 /* This puts data into the buffer */
813 int scratch_put(struct usb_usbvision
*usbvision
, unsigned char *data
, int len
)
817 if (usbvision
->scratch_write_ptr
+ len
< scratch_buf_size
) {
818 memcpy(usbvision
->scratch
+ usbvision
->scratch_write_ptr
, data
, len
);
819 usbvision
->scratch_write_ptr
+= len
;
822 len_part
= scratch_buf_size
- usbvision
->scratch_write_ptr
;
823 memcpy(usbvision
->scratch
+ usbvision
->scratch_write_ptr
, data
, len_part
);
824 if (len
== len_part
) {
825 usbvision
->scratch_write_ptr
= 0; /* just set write_ptr to zero */
828 memcpy(usbvision
->scratch
, data
+ len_part
, len
- len_part
);
829 usbvision
->scratch_write_ptr
= len
- len_part
;
833 PDEBUG(DBG_SCRATCH
, "len=%d, new write_ptr=%d\n", len
, usbvision
->scratch_write_ptr
);
838 /* This marks the write_ptr as position of new frame header */
839 void scratch_mark_header(struct usb_usbvision
*usbvision
)
841 PDEBUG(DBG_SCRATCH
, "header at write_ptr=%d\n", usbvision
->scratch_headermarker_write_ptr
);
843 usbvision
->scratch_headermarker
[usbvision
->scratch_headermarker_write_ptr
] =
844 usbvision
->scratch_write_ptr
;
845 usbvision
->scratch_headermarker_write_ptr
+= 1;
846 usbvision
->scratch_headermarker_write_ptr
%= USBVISION_NUM_HEADERMARKER
;
849 /* This gets data from the buffer at the given "ptr" position */
850 int scratch_get_extra(struct usb_usbvision
*usbvision
, unsigned char *data
, int *ptr
, int len
)
853 if (*ptr
+ len
< scratch_buf_size
) {
854 memcpy(data
, usbvision
->scratch
+ *ptr
, len
);
858 len_part
= scratch_buf_size
- *ptr
;
859 memcpy(data
, usbvision
->scratch
+ *ptr
, len_part
);
860 if (len
== len_part
) {
861 *ptr
= 0; /* just set the y_ptr to zero */
864 memcpy(data
+ len_part
, usbvision
->scratch
, len
- len_part
);
865 *ptr
= len
- len_part
;
869 PDEBUG(DBG_SCRATCH
, "len=%d, new ptr=%d\n", len
, *ptr
);
875 /* This sets the scratch extra read pointer */
876 void scratch_set_extra_ptr(struct usb_usbvision
*usbvision
, int *ptr
, int len
)
878 *ptr
= (usbvision
->scratch_read_ptr
+ len
)%scratch_buf_size
;
880 PDEBUG(DBG_SCRATCH
, "ptr=%d\n", *ptr
);
884 /*This increments the scratch extra read pointer */
885 void scratch_inc_extra_ptr(int *ptr
, int len
)
887 *ptr
= (*ptr
+ len
) % scratch_buf_size
;
889 PDEBUG(DBG_SCRATCH
, "ptr=%d\n", *ptr
);
893 /* This gets data from the buffer */
894 int scratch_get(struct usb_usbvision
*usbvision
, unsigned char *data
, int len
)
897 if (usbvision
->scratch_read_ptr
+ len
< scratch_buf_size
) {
898 memcpy(data
, usbvision
->scratch
+ usbvision
->scratch_read_ptr
, len
);
899 usbvision
->scratch_read_ptr
+= len
;
902 len_part
= scratch_buf_size
- usbvision
->scratch_read_ptr
;
903 memcpy(data
, usbvision
->scratch
+ usbvision
->scratch_read_ptr
, len_part
);
904 if (len
== len_part
) {
905 usbvision
->scratch_read_ptr
= 0; /* just set the read_ptr to zero */
908 memcpy(data
+ len_part
, usbvision
->scratch
, len
- len_part
);
909 usbvision
->scratch_read_ptr
= len
- len_part
;
913 PDEBUG(DBG_SCRATCH
, "len=%d, new read_ptr=%d\n", len
, usbvision
->scratch_read_ptr
);
919 /* This sets read pointer to next header and returns it */
920 int scratch_get_header(struct usb_usbvision
*usbvision
,struct usbvision_frame_header
*header
)
924 PDEBUG(DBG_SCRATCH
, "from read_ptr=%d", usbvision
->scratch_headermarker_read_ptr
);
926 while (usbvision
->scratch_headermarker_write_ptr
-
927 usbvision
->scratch_headermarker_read_ptr
!= 0) {
928 usbvision
->scratch_read_ptr
=
929 usbvision
->scratch_headermarker
[usbvision
->scratch_headermarker_read_ptr
];
930 usbvision
->scratch_headermarker_read_ptr
+= 1;
931 usbvision
->scratch_headermarker_read_ptr
%= USBVISION_NUM_HEADERMARKER
;
932 scratch_get(usbvision
, (unsigned char *)header
, USBVISION_HEADER_LENGTH
);
933 if ((header
->magic_1
== USBVISION_MAGIC_1
)
934 && (header
->magic_2
== USBVISION_MAGIC_2
)
935 && (header
->headerLength
== USBVISION_HEADER_LENGTH
)) {
936 errCode
= USBVISION_HEADER_LENGTH
;
937 header
->frameWidth
= header
->frameWidthLo
+ (header
->frameWidthHi
<< 8);
938 header
->frameHeight
= header
->frameHeightLo
+ (header
->frameHeightHi
<< 8);
947 /*This removes len bytes of old data from the buffer */
948 void scratch_rm_old(struct usb_usbvision
*usbvision
, int len
)
951 usbvision
->scratch_read_ptr
+= len
;
952 usbvision
->scratch_read_ptr
%= scratch_buf_size
;
953 PDEBUG(DBG_SCRATCH
, "read_ptr is now %d\n", usbvision
->scratch_read_ptr
);
957 /*This resets the buffer - kills all data in it too */
958 void scratch_reset(struct usb_usbvision
*usbvision
)
960 PDEBUG(DBG_SCRATCH
, "\n");
962 usbvision
->scratch_read_ptr
= 0;
963 usbvision
->scratch_write_ptr
= 0;
964 usbvision
->scratch_headermarker_read_ptr
= 0;
965 usbvision
->scratch_headermarker_write_ptr
= 0;
966 usbvision
->isocstate
= IsocState_NoFrame
;
971 /* Here comes the OVERLAY stuff */
973 /* Tell the interrupt handler what to to. */
975 void usbvision_cap(struct usb_usbvision
* usbvision
, int on
)
977 DEBUG(printk(KERN_DEBUG
"usbvision_cap: overlay was %d, set it to %d\n", usbvision
->overlay
, on
);)
980 usbvision
->overlay
= 1;
983 usbvision
->overlay
= 0;
990 /* append a new clipregion to the vector of video_clips */
992 void usbvision_new_clip(struct v4l2_format
* vf
, struct v4l2_clip
* vcp
, int x
, int y
, int w
, int h
)
994 vcp
[vf
->fmt
.win
.clipcount
].c
.left
= x
;
995 vcp
[vf
->fmt
.win
.clipcount
].c
.top
= y
;
996 vcp
[vf
->fmt
.win
.clipcount
].c
.width
= w
;
997 vcp
[vf
->fmt
.win
.clipcount
].c
.height
= h
;
998 vf
->fmt
.win
.clipcount
++;
1002 #define mark_pixel(x,y) usbvision->clipmask[((x) + (y) * MAX_FRAME_WIDTH)/32] |= 0x00000001<<((x)%32)
1003 #define clipped_pixel(index) usbvision->clipmask[(index)/32] & (0x00000001<<((index)%32))
1006 void usbvision_built_overlay(struct usb_usbvision
* usbvision
, int count
, struct v4l2_clip
*vcp
)
1008 usbvision
->overlay_win
= usbvision
->overlay_base
+
1009 (signed int)usbvision
->vid_win
.fmt
.win
.w
.left
* usbvision
->depth
/ 8 +
1010 (signed int)usbvision
->vid_win
.fmt
.win
.w
.top
* usbvision
->vid_buf
.fmt
.bytesperline
;
1012 IODEBUG(printk(KERN_DEBUG
"built_overlay base=%p, win=%p, bpl=%d, clips=%d, size=%dx%d\n",
1013 usbvision
->overlay_base
, usbvision
->overlay_win
,
1014 usbvision
->vid_buf
.fmt
.bytesperline
, count
,
1015 usbvision
->vid_win
.fmt
.win
.w
.width
, usbvision
->vid_win
.fmt
.win
.w
.height
);)
1018 /* Add here generation of clipping mask */
1020 int x_start
, x_end
, y_start
, y_end
;
1021 int clip_index
, x
, y
;
1023 memset(usbvision
->clipmask
, 0, USBVISION_CLIPMASK_SIZE
);
1025 OVDEBUG(printk(KERN_DEBUG
"clips = %d\n", count
);)
1027 for(clip_index
= 0; clip_index
< count
; clip_index
++) {
1028 OVDEBUG(printk(KERN_DEBUG
"clip: %d,%d,%d,%d\n", vcp
[clip_index
].x
,
1030 vcp
[clip_index
].width
,
1031 vcp
[clip_index
].height
);)
1033 x_start
= vcp
[clip_index
].c
.left
;
1034 if(x_start
>= (int)usbvision
->vid_win
.fmt
.win
.w
.width
) {
1035 OVDEBUG(printk(KERN_DEBUG
"x_start=%d\n", x_start
);)
1036 continue; //clipping window is right of overlay window
1038 x_end
= x_start
+ vcp
[clip_index
].c
.width
;
1040 OVDEBUG(printk(KERN_DEBUG
"x_end=%d\n", x_end
);)
1041 continue; //clipping window is left of overlay window
1044 y_start
= vcp
[clip_index
].c
.top
;
1045 if(y_start
>= (int)usbvision
->vid_win
.fmt
.win
.w
.height
) {
1046 OVDEBUG(printk(KERN_DEBUG
"y_start=%d\n", y_start
);)
1047 continue; //clipping window is below overlay window
1049 y_end
= y_start
+ vcp
[clip_index
].c
.height
;
1051 OVDEBUG(printk(KERN_DEBUG
"y_end=%d\n", y_end
);)
1052 continue; //clipping window is above overlay window
1055 //clip the clipping window
1059 if (x_end
> (int)usbvision
->vid_win
.fmt
.win
.w
.width
) {
1060 x_end
= (int)usbvision
->vid_win
.fmt
.win
.w
.width
;
1065 if (y_end
> (int)usbvision
->vid_win
.fmt
.win
.w
.height
) {
1066 y_end
= (int)usbvision
->vid_win
.fmt
.win
.w
.height
;
1069 OVDEBUG(printk(KERN_DEBUG
"clip_o: %d,%d,%d,%d\n", x_start
, y_start
, x_end
, y_end
);)
1073 for(y
= y_start
; y
< y_end
; y
++) {
1074 for(x
= x_start
; x
< x_end
; x
++) {
1085 void usbvision_osd_char(struct usb_usbvision
*usbvision
,
1086 struct usbvision_frame
*frame
, int x
, int y
, int ch
)
1088 static const unsigned short digits
[16] = {
1106 unsigned short digit
;
1109 if ((usbvision
== NULL
) || (frame
== NULL
))
1112 if (ch
>= '0' && ch
<= '9')
1114 else if (ch
>= 'A' && ch
<= 'F')
1115 ch
= 10 + (ch
- 'A');
1116 else if (ch
>= 'a' && ch
<= 'f')
1117 ch
= 10 + (ch
- 'a');
1122 for (iy
= 0; iy
< 5; iy
++) {
1123 for (ix
= 0; ix
< 3; ix
++) {
1124 if (digit
& 0x8000) {
1125 // USBVISION_PUTPIXEL(frame, x + ix, y + iy,
1126 // 0xFF, 0xFF, 0xFF);
1134 void usbvision_osd_string(struct usb_usbvision
*usbvision
,
1135 struct usbvision_frame
*frame
,
1136 int x
, int y
, const char *str
)
1139 usbvision_osd_char(usbvision
, frame
, x
, y
, *str
);
1141 x
+= 4; /* 3 pixels character + 1 space */
1146 * usb_usbvision_osd_stats()
1148 * On screen display of important debugging information.
1151 void usbvision_osd_stats(struct usb_usbvision
*usbvision
,
1152 struct usbvision_frame
*frame
)
1154 const int y_diff
= 8;
1159 sprintf(tmp
, "%8x", usbvision
->frame_num
);
1160 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1163 sprintf(tmp
, "%8lx", usbvision
->isocUrbCount
);
1164 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1167 sprintf(tmp
, "%8lx", usbvision
->urb_length
);
1168 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1171 sprintf(tmp
, "%8lx", usbvision
->isocDataCount
);
1172 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1175 sprintf(tmp
, "%8lx", usbvision
->header_count
);
1176 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1179 sprintf(tmp
, "%8lx", usbvision
->scratch_ovf_count
);
1180 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1183 sprintf(tmp
, "%8lx", usbvision
->isocSkipCount
);
1184 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1187 sprintf(tmp
, "%8lx", usbvision
->isocErrCount
);
1188 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1191 sprintf(tmp
, "%8x", usbvision
->saturation
);
1192 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1195 sprintf(tmp
, "%8x", usbvision
->hue
);
1196 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1199 sprintf(tmp
, "%8x", usbvision
->brightness
>> 8);
1200 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1203 sprintf(tmp
, "%8x", usbvision
->contrast
>> 12);
1204 usbvision_osd_string(usbvision
, frame
, x
, y
, tmp
);
1210 * usbvision_testpattern()
1212 * Procedure forms a test pattern (yellow grid on blue background).
1215 * fullframe: if TRUE then entire frame is filled, otherwise the procedure
1216 * continues from the current scanline.
1217 * pmode 0: fill the frame with solid blue color (like on VCR or TV)
1218 * 1: Draw a colored grid
1221 void usbvision_testpattern(struct usb_usbvision
*usbvision
, int fullframe
,
1224 static const char proc
[] = "usbvision_testpattern";
1225 struct usbvision_frame
*frame
;
1228 int scan_length
= 0;
1229 static int num_pass
= 0;
1231 if (usbvision
== NULL
) {
1232 printk(KERN_ERR
"%s: usbvision == NULL\n", proc
);
1235 if (usbvision
->curFrame
== NULL
) {
1236 printk(KERN_ERR
"%s: usbvision->curFrame is NULL.\n", proc
);
1240 /* Grab the current frame */
1241 frame
= usbvision
->curFrame
;
1243 /* Optionally start at the beginning */
1246 frame
->scanlength
= 0;
1249 /* Form every scan line */
1250 for (; frame
->curline
< frame
->frmheight
; frame
->curline
++) {
1253 f
= frame
->data
+ (usbvision
->curwidth
* 3 * frame
->curline
);
1254 for (i
= 0; i
< usbvision
->curwidth
; i
++) {
1255 unsigned char cb
= 0x80;
1256 unsigned char cg
= 0;
1257 unsigned char cr
= 0;
1260 if (frame
->curline
% 32 == 0)
1261 cb
= 0, cg
= cr
= 0xFF;
1262 else if (i
% 32 == 0) {
1263 if (frame
->curline
% 32 == 1)
1265 cb
= 0, cg
= cr
= 0xFF;
1272 num_pass
* 2) & 0xFF;
1275 num_pass
* 3) & 0xFF;
1278 /* Just the blue screen */
1288 frame
->grabstate
= FrameState_Done
;
1289 frame
->scanlength
+= scan_length
;
1292 /* We do this unconditionally, regardless of FLAGS_OSD_STATS */
1293 usbvision_osd_stats(usbvision
, frame
);
1297 * Here comes the data parsing stuff that is run as interrupt
1301 * usbvision_find_header()
1303 * Locate one of supported header markers in the scratch buffer.
1305 static enum ParseState
usbvision_find_header(struct usb_usbvision
*usbvision
)
1307 struct usbvision_frame
*frame
;
1308 int foundHeader
= 0;
1310 if (usbvision
->overlay
) {
1311 frame
= &usbvision
->overlay_frame
;
1314 frame
= usbvision
->curFrame
;
1317 while (scratch_get_header(usbvision
, &frame
->isocHeader
) == USBVISION_HEADER_LENGTH
) {
1318 // found header in scratch
1319 PDEBUG(DBG_HEADER
, "found header: 0x%02x%02x %d %d %d %d %#x 0x%02x %u %u",
1320 frame
->isocHeader
.magic_2
,
1321 frame
->isocHeader
.magic_1
,
1322 frame
->isocHeader
.headerLength
,
1323 frame
->isocHeader
.frameNum
,
1324 frame
->isocHeader
.framePhase
,
1325 frame
->isocHeader
.frameLatency
,
1326 frame
->isocHeader
.dataFormat
,
1327 frame
->isocHeader
.formatParam
,
1328 frame
->isocHeader
.frameWidth
,
1329 frame
->isocHeader
.frameHeight
);
1331 if (usbvision
->requestIntra
) {
1332 if (frame
->isocHeader
.formatParam
& 0x80) {
1334 usbvision
->lastIsocFrameNum
= -1; // do not check for lost frames this time
1335 usbvision_unrequest_intra(usbvision
);
1346 frame
->frmwidth
= frame
->isocHeader
.frameWidth
* usbvision
->stretch_width
;
1347 frame
->frmheight
= frame
->isocHeader
.frameHeight
* usbvision
->stretch_height
;
1348 frame
->v4l2_linesize
= (frame
->frmwidth
* frame
->v4l2_format
.depth
)>> 3;
1350 else { // no header found
1351 PDEBUG(DBG_HEADER
, "skipping scratch data, no header");
1352 scratch_reset(usbvision
);
1353 return ParseState_EndParse
;
1357 if (frame
->isocHeader
.dataFormat
==ISOC_MODE_COMPRESS
) {
1358 //check isocHeader.frameNum for lost frames
1359 if (usbvision
->lastIsocFrameNum
>= 0) {
1360 if (((usbvision
->lastIsocFrameNum
+ 1) % 32) != frame
->isocHeader
.frameNum
) {
1361 // unexpected frame drop: need to request new intra frame
1362 PDEBUG(DBG_HEADER
, "Lost frame before %d on USB", frame
->isocHeader
.frameNum
);
1363 usbvision_request_intra(usbvision
);
1364 return ParseState_NextFrame
;
1367 usbvision
->lastIsocFrameNum
= frame
->isocHeader
.frameNum
;
1369 usbvision
->header_count
++;
1370 frame
->scanstate
= ScanState_Lines
;
1373 if (flags
& FLAGS_FORCE_TESTPATTERN
) {
1374 usbvision_testpattern(usbvision
, 1, 1);
1375 return ParseState_NextFrame
;
1377 return ParseState_Continue
;
1380 static enum ParseState
usbvision_parse_lines_422(struct usb_usbvision
*usbvision
,
1383 volatile struct usbvision_frame
*frame
;
1387 unsigned char yuyv
[4]={180, 128, 10, 128}; // YUV components
1388 unsigned char rv
, gv
, bv
; // RGB components
1389 int clipmask_index
, bytes_per_pixel
;
1390 int overlay
= usbvision
->overlay
;
1391 int stretch_bytes
, clipmask_add
;
1394 frame
= &usbvision
->overlay_frame
;
1395 if (usbvision
->overlay_base
== NULL
) {
1396 //video_buffer is not set yet
1397 return ParseState_NextFrame
;
1399 f
= usbvision
->overlay_win
+ frame
->curline
*
1400 usbvision
->vid_buf
.fmt
.bytesperline
;
1403 frame
= usbvision
->curFrame
;
1404 f
= frame
->data
+ (frame
->v4l2_linesize
* frame
->curline
);
1407 /* Make sure there's enough data for the entire line */
1408 len
= (frame
->isocHeader
.frameWidth
* 2)+5;
1409 if (scratch_len(usbvision
) < len
) {
1410 PDEBUG(DBG_PARSE
, "out of data in line %d, need %u.\n", frame
->curline
, len
);
1411 return ParseState_Out
;
1414 if ((frame
->curline
+ 1) >= frame
->frmheight
) {
1415 return ParseState_NextFrame
;
1418 bytes_per_pixel
= frame
->v4l2_format
.bytes_per_pixel
;
1419 stretch_bytes
= (usbvision
->stretch_width
- 1) * bytes_per_pixel
;
1420 clipmask_index
= frame
->curline
* MAX_FRAME_WIDTH
;
1421 clipmask_add
= usbvision
->stretch_width
;
1423 for (i
= 0; i
< frame
->frmwidth
; i
+=(2 * usbvision
->stretch_width
)) {
1425 scratch_get(usbvision
, &yuyv
[0], 4);
1427 if((overlay
) && (clipped_pixel(clipmask_index
))) {
1428 f
+= bytes_per_pixel
;
1430 else if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1431 *f
++ = yuyv
[0]; // Y
1432 *f
++ = yuyv
[3]; // U
1436 YUV_TO_RGB_BY_THE_BOOK(yuyv
[0], yuyv
[1], yuyv
[3], rv
, gv
, bv
);
1437 switch (frame
->v4l2_format
.format
) {
1438 case V4L2_PIX_FMT_RGB565
:
1439 *f
++ = (0x1F & (bv
>> 3)) | (0xE0 & (gv
<< 3));
1440 *f
++ = (0x07 & (gv
>> 5)) | (0xF8 & rv
);
1442 case V4L2_PIX_FMT_RGB24
:
1447 case V4L2_PIX_FMT_RGB32
:
1453 case V4L2_PIX_FMT_RGB555
:
1454 *f
++ = (0x1F & (bv
>> 3)) | (0xE0 & (gv
<< 2));
1455 *f
++ = (0x03 & (gv
>> 6)) | (0x7C & (rv
>> 1));
1459 clipmask_index
+= clipmask_add
;
1462 if((overlay
) && (clipped_pixel(clipmask_index
))) {
1463 f
+= bytes_per_pixel
;
1465 else if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1466 *f
++ = yuyv
[2]; // Y
1467 *f
++ = yuyv
[1]; // V
1471 YUV_TO_RGB_BY_THE_BOOK(yuyv
[2], yuyv
[1], yuyv
[3], rv
, gv
, bv
);
1472 switch (frame
->v4l2_format
.format
) {
1473 case V4L2_PIX_FMT_RGB565
:
1474 *f
++ = (0x1F & (bv
>> 3)) | (0xE0 & (gv
<< 3));
1475 *f
++ = (0x07 & (gv
>> 5)) | (0xF8 & rv
);
1477 case V4L2_PIX_FMT_RGB24
:
1482 case V4L2_PIX_FMT_RGB32
:
1488 case V4L2_PIX_FMT_RGB555
:
1489 *f
++ = (0x1F & (bv
>> 3)) | (0xE0 & (gv
<< 2));
1490 *f
++ = (0x03 & (gv
>> 6)) | (0x7C & (rv
>> 1));
1494 clipmask_index
+= clipmask_add
;
1498 frame
->curline
+= usbvision
->stretch_height
;
1499 *pcopylen
+= frame
->v4l2_linesize
* usbvision
->stretch_height
;
1501 if (frame
->curline
>= frame
->frmheight
) {
1502 return ParseState_NextFrame
;
1505 return ParseState_Continue
;
1510 static int usbvision_decompress(struct usb_usbvision
*usbvision
,unsigned char *Compressed
,
1511 unsigned char *Decompressed
, int *StartPos
,
1512 int *BlockTypeStartPos
, int Len
)
1514 int RestPixel
, Idx
, MaxPos
, Pos
, ExtraPos
, BlockLen
, BlockTypePos
, BlockTypeLen
;
1515 unsigned char BlockByte
, BlockCode
, BlockType
, BlockTypeByte
, Integrator
;
1519 BlockTypePos
= *BlockTypeStartPos
;
1520 MaxPos
= 396; //Pos + Len;
1530 for (Idx
= 0; Idx
< Len
; Idx
++) {
1532 if (BlockLen
== 0) {
1533 if (BlockTypeLen
==0) {
1534 BlockTypeByte
= Compressed
[BlockTypePos
];
1538 BlockType
= (BlockTypeByte
& 0xC0) >> 6;
1541 usbvision
->ComprBlockTypes
[BlockType
]++;
1544 if (BlockType
== 0) {
1545 if(RestPixel
>= 24) {
1548 Integrator
= Decompressed
[Idx
];
1550 Idx
+= RestPixel
- 1;
1554 BlockCode
= Compressed
[Pos
];
1556 if (RestPixel
>= 24) {
1559 BlockLen
= RestPixel
;
1561 RestPixel
-= BlockLen
;
1562 ExtraPos
= Pos
+ (BlockLen
/ 4);
1564 BlockTypeByte
<<= 2;
1568 if ((BlockLen
%4) == 0) {
1569 BlockByte
= Compressed
[Pos
];
1572 if (BlockType
== 1) { //inter Block
1573 Integrator
= Decompressed
[Idx
];
1575 switch (BlockByte
& 0xC0) {
1577 Integrator
+= Compressed
[ExtraPos
];
1581 Integrator
+= BlockCode
;
1584 Integrator
-= BlockCode
;
1587 Decompressed
[Idx
] = Integrator
;
1592 *StartPos
= ExtraPos
;
1593 *BlockTypeStartPos
= BlockTypePos
;
1599 * usbvision_parse_compress()
1601 * Parse compressed frame from the scratch buffer, put
1602 * decoded RGB value into the current frame buffer and add the written
1603 * number of bytes (RGB) to the *pcopylen.
1606 static enum ParseState
usbvision_parse_compress(struct usb_usbvision
*usbvision
,
1609 #define USBVISION_STRIP_MAGIC 0x5A
1610 #define USBVISION_STRIP_LEN_MAX 400
1611 #define USBVISION_STRIP_HEADER_LEN 3
1613 struct usbvision_frame
*frame
;
1614 unsigned char *f
,*u
= NULL
,*v
= NULL
;
1615 unsigned char StripData
[USBVISION_STRIP_LEN_MAX
];
1616 unsigned char StripHeader
[USBVISION_STRIP_HEADER_LEN
];
1617 int Idx
, IdxEnd
, StripLen
, StripPtr
, StartBlockPos
, BlockPos
, BlockTypePos
;
1618 int clipmask_index
, bytes_per_pixel
, rc
;
1619 int overlay
= usbvision
->overlay
;
1621 unsigned char rv
, gv
, bv
;
1622 static unsigned char *Y
, *U
, *V
;
1625 frame
= &usbvision
->overlay_frame
;
1626 imageSize
= frame
->frmwidth
* frame
->frmheight
;
1627 if (usbvision
->overlay_base
== NULL
) {
1628 //video_buffer is not set yet
1629 return ParseState_NextFrame
;
1631 f
= usbvision
->overlay_win
+ frame
->curline
*
1632 usbvision
->vid_buf
.fmt
.bytesperline
;
1635 frame
= usbvision
->curFrame
;
1636 imageSize
= frame
->frmwidth
* frame
->frmheight
;
1637 if ( (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUV422P
) ||
1638 (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YVU420
) )
1639 { // this is a planar format
1640 //... v4l2_linesize not used here.
1641 f
= frame
->data
+ (frame
->width
* frame
->curline
);
1643 f
= frame
->data
+ (frame
->v4l2_linesize
* frame
->curline
);
1645 if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
){ //initialise u and v pointers
1646 // get base of u and b planes add halfoffset
1650 + (frame
->frmwidth
>>1) * frame
->curline
;
1651 v
= u
+ (imageSize
>>1 );
1653 } else if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YVU420
){
1655 v
= frame
->data
+ imageSize
+ ((frame
->curline
* (frame
->width
))>>2) ;
1656 u
= v
+ (imageSize
>>2) ;
1660 if (frame
->curline
== 0) {
1661 usbvision_adjust_compression(usbvision
);
1664 if (scratch_len(usbvision
) < USBVISION_STRIP_HEADER_LEN
) {
1665 return ParseState_Out
;
1668 //get strip header without changing the scratch_read_ptr
1669 scratch_set_extra_ptr(usbvision
, &StripPtr
, 0);
1670 scratch_get_extra(usbvision
, &StripHeader
[0], &StripPtr
,
1671 USBVISION_STRIP_HEADER_LEN
);
1673 if (StripHeader
[0] != USBVISION_STRIP_MAGIC
) {
1674 // wrong strip magic
1675 usbvision
->stripMagicErrors
++;
1676 return ParseState_NextFrame
;
1679 if (frame
->curline
!= (int)StripHeader
[2]) {
1680 //line number missmatch error
1681 usbvision
->stripLineNumberErrors
++;
1684 StripLen
= 2 * (unsigned int)StripHeader
[1];
1685 if (StripLen
> USBVISION_STRIP_LEN_MAX
) {
1687 // I think this never happens
1688 usbvision_request_intra(usbvision
);
1691 if (scratch_len(usbvision
) < StripLen
) {
1692 //there is not enough data for the strip
1693 return ParseState_Out
;
1696 if (usbvision
->IntraFrameBuffer
) {
1697 Y
= usbvision
->IntraFrameBuffer
+ frame
->frmwidth
* frame
->curline
;
1698 U
= usbvision
->IntraFrameBuffer
+ imageSize
+ (frame
->frmwidth
/ 2) * (frame
->curline
/ 2);
1699 V
= usbvision
->IntraFrameBuffer
+ imageSize
/ 4 * 5 + (frame
->frmwidth
/ 2) * (frame
->curline
/ 2);
1702 return ParseState_NextFrame
;
1705 bytes_per_pixel
= frame
->v4l2_format
.bytes_per_pixel
;
1706 clipmask_index
= frame
->curline
* MAX_FRAME_WIDTH
;
1708 scratch_get(usbvision
, StripData
, StripLen
);
1710 IdxEnd
= frame
->frmwidth
;
1711 BlockTypePos
= USBVISION_STRIP_HEADER_LEN
;
1712 StartBlockPos
= BlockTypePos
+ (IdxEnd
- 1) / 96 + (IdxEnd
/ 2 - 1) / 96 + 2;
1713 BlockPos
= StartBlockPos
;
1715 usbvision
->BlockPos
= BlockPos
;
1717 if ((rc
= usbvision_decompress(usbvision
, StripData
, Y
, &BlockPos
, &BlockTypePos
, IdxEnd
)) != IdxEnd
) {
1718 //return ParseState_Continue;
1720 if (StripLen
> usbvision
->maxStripLen
) {
1721 usbvision
->maxStripLen
= StripLen
;
1724 if (frame
->curline
%2) {
1725 if ((rc
= usbvision_decompress(usbvision
, StripData
, V
, &BlockPos
, &BlockTypePos
, IdxEnd
/2)) != IdxEnd
/2) {
1726 //return ParseState_Continue;
1730 if ((rc
= usbvision_decompress(usbvision
, StripData
, U
, &BlockPos
, &BlockTypePos
, IdxEnd
/2)) != IdxEnd
/2) {
1731 //return ParseState_Continue;
1735 if (BlockPos
> usbvision
->comprBlockPos
) {
1736 usbvision
->comprBlockPos
= BlockPos
;
1738 if (BlockPos
> StripLen
) {
1739 usbvision
->stripLenErrors
++;
1742 for (Idx
= 0; Idx
< IdxEnd
; Idx
++) {
1743 if((overlay
) && (clipped_pixel(clipmask_index
))) {
1744 f
+= bytes_per_pixel
;
1746 else if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1748 *f
++ = Idx
& 0x01 ? U
[Idx
/2] : V
[Idx
/2];
1750 else if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUV422P
) {
1757 else if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YVU420
) {
1759 if ( !(( Idx
& 0x01 ) | ( frame
->curline
& 0x01 )) ){
1761 /* only need do this for 1 in 4 pixels */
1762 /* intraframe buffer is YUV420 format */
1770 YUV_TO_RGB_BY_THE_BOOK(Y
[Idx
], U
[Idx
/2], V
[Idx
/2], rv
, gv
, bv
);
1771 switch (frame
->v4l2_format
.format
) {
1772 case V4L2_PIX_FMT_GREY
:
1775 case V4L2_PIX_FMT_RGB555
:
1776 *f
++ = (0x1F & (bv
>> 3)) | (0xE0 & (gv
<< 2));
1777 *f
++ = (0x03 & (gv
>> 6)) | (0x7C & (rv
>> 1));
1779 case V4L2_PIX_FMT_RGB565
:
1780 *f
++ = (0x1F & (bv
>> 3)) | (0xE0 & (gv
<< 3));
1781 *f
++ = (0x07 & (gv
>> 5)) | (0xF8 & rv
);
1783 case V4L2_PIX_FMT_RGB24
:
1788 case V4L2_PIX_FMT_RGB32
:
1798 /* Deal with non-integer no. of bytes for YUV420P */
1799 if (frame
->v4l2_format
.format
!= V4L2_PIX_FMT_YVU420
)
1800 *pcopylen
+= frame
->v4l2_linesize
;
1802 *pcopylen
+= frame
->curline
& 0x01 ? frame
->v4l2_linesize
: frame
->v4l2_linesize
<< 1;
1804 frame
->curline
+= 1;
1806 if (frame
->curline
>= frame
->frmheight
) {
1807 return ParseState_NextFrame
;
1810 return ParseState_Continue
;
1817 * usbvision_parse_lines_420()
1819 * Parse two lines from the scratch buffer, put
1820 * decoded RGB value into the current frame buffer and add the written
1821 * number of bytes (RGB) to the *pcopylen.
1824 static enum ParseState
usbvision_parse_lines_420(struct usb_usbvision
*usbvision
,
1827 struct usbvision_frame
*frame
;
1828 unsigned char *f_even
= NULL
, *f_odd
= NULL
;
1829 unsigned int pixel_per_line
, block
;
1830 int pixel
, block_split
;
1831 int y_ptr
, u_ptr
, v_ptr
, y_odd_offset
;
1832 const int y_block_size
= 128;
1833 const int uv_block_size
= 64;
1834 const int sub_block_size
= 32;
1835 const int y_step
[] = { 0, 0, 0, 2 }, y_step_size
= 4;
1836 const int uv_step
[]= { 0, 0, 0, 4 }, uv_step_size
= 4;
1837 unsigned char y
[2], u
, v
; /* YUV components */
1838 int y_
, u_
, v_
, vb
, uvg
, ur
;
1839 int r_
, g_
, b_
; /* RGB components */
1841 int clipmask_even_index
, clipmask_odd_index
, bytes_per_pixel
;
1842 int clipmask_add
, stretch_bytes
;
1843 int overlay
= usbvision
->overlay
;
1846 frame
= &usbvision
->overlay_frame
;
1847 if (usbvision
->overlay_base
== NULL
) {
1848 //video_buffer is not set yet
1849 return ParseState_NextFrame
;
1851 f_even
= usbvision
->overlay_win
+ frame
->curline
*
1852 usbvision
->vid_buf
.fmt
.bytesperline
;
1853 f_odd
= f_even
+ usbvision
->vid_buf
.fmt
.bytesperline
* usbvision
->stretch_height
;
1856 frame
= usbvision
->curFrame
;
1857 f_even
= frame
->data
+ (frame
->v4l2_linesize
* frame
->curline
);
1858 f_odd
= f_even
+ frame
->v4l2_linesize
* usbvision
->stretch_height
;
1861 /* Make sure there's enough data for the entire line */
1862 /* In this mode usbvision transfer 3 bytes for every 2 pixels */
1863 /* I need two lines to decode the color */
1864 bytes_per_pixel
= frame
->v4l2_format
.bytes_per_pixel
;
1865 stretch_bytes
= (usbvision
->stretch_width
- 1) * bytes_per_pixel
;
1866 clipmask_even_index
= frame
->curline
* MAX_FRAME_WIDTH
;
1867 clipmask_odd_index
= clipmask_even_index
+ MAX_FRAME_WIDTH
;
1868 clipmask_add
= usbvision
->stretch_width
;
1869 pixel_per_line
= frame
->isocHeader
.frameWidth
;
1871 if (scratch_len(usbvision
) < (int)pixel_per_line
* 3) {
1872 //printk(KERN_DEBUG "out of data, need %d\n", len);
1873 return ParseState_Out
;
1876 if ((frame
->curline
+ 1) >= frame
->frmheight
) {
1877 return ParseState_NextFrame
;
1880 block_split
= (pixel_per_line
%y_block_size
) ? 1 : 0; //are some blocks splitted into different lines?
1882 y_odd_offset
= (pixel_per_line
/ y_block_size
) * (y_block_size
+ uv_block_size
)
1883 + block_split
* uv_block_size
;
1885 scratch_set_extra_ptr(usbvision
, &y_ptr
, y_odd_offset
);
1886 scratch_set_extra_ptr(usbvision
, &u_ptr
, y_block_size
);
1887 scratch_set_extra_ptr(usbvision
, &v_ptr
, y_odd_offset
1888 + (4 - block_split
) * sub_block_size
);
1890 for (block
= 0; block
< (pixel_per_line
/ sub_block_size
);
1894 for (pixel
= 0; pixel
< sub_block_size
; pixel
+=2) {
1895 scratch_get(usbvision
, &y
[0], 2);
1896 scratch_get_extra(usbvision
, &u
, &u_ptr
, 1);
1897 scratch_get_extra(usbvision
, &v
, &v_ptr
, 1);
1899 //I don't use the YUV_TO_RGB macro for better performance
1903 uvg
= -53281 * u_
- 25625 * v_
;
1906 if((overlay
) && (clipped_pixel(clipmask_even_index
))) {
1907 f_even
+= bytes_per_pixel
;
1909 else if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1914 y_
= 76284 * (y
[0] - 16);
1916 b_
= (y_
+ vb
) >> 16;
1917 g_
= (y_
+ uvg
)>> 16;
1918 r_
= (y_
+ ur
) >> 16;
1920 switch (frame
->v4l2_format
.format
) {
1921 case V4L2_PIX_FMT_RGB565
:
1923 *f_even
++ = (0x1F & (LIMIT_RGB(b_
) >> 3)) | (0xE0 & (g
<< 3));
1924 *f_even
++ = (0x07 & ( g
>> 5)) | (0xF8 & LIMIT_RGB(r_
));
1926 case V4L2_PIX_FMT_RGB24
:
1927 *f_even
++ = LIMIT_RGB(b_
);
1928 *f_even
++ = LIMIT_RGB(g_
);
1929 *f_even
++ = LIMIT_RGB(r_
);
1931 case V4L2_PIX_FMT_RGB32
:
1932 *f_even
++ = LIMIT_RGB(b_
);
1933 *f_even
++ = LIMIT_RGB(g_
);
1934 *f_even
++ = LIMIT_RGB(r_
);
1937 case V4L2_PIX_FMT_RGB555
:
1939 *f_even
++ = (0x1F & (LIMIT_RGB(b_
) >> 3)) | (0xE0 & (g
<< 2));
1940 *f_even
++ = (0x03 & ( g
>> 6)) |
1941 (0x7C & (LIMIT_RGB(r_
) >> 1));
1945 clipmask_even_index
+= clipmask_add
;
1946 f_even
+= stretch_bytes
;
1948 if((overlay
) && (clipped_pixel(clipmask_even_index
))) {
1949 f_even
+= bytes_per_pixel
;
1951 else if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1956 y_
= 76284 * (y
[1] - 16);
1958 b_
= (y_
+ vb
) >> 16;
1959 g_
= (y_
+ uvg
)>> 16;
1960 r_
= (y_
+ ur
) >> 16;
1962 switch (frame
->v4l2_format
.format
) {
1963 case V4L2_PIX_FMT_RGB565
:
1965 *f_even
++ = (0x1F & (LIMIT_RGB(b_
) >> 3)) | (0xE0 & (g
<< 3));
1966 *f_even
++ = (0x07 & ( g
>> 5)) | (0xF8 & LIMIT_RGB(r_
));
1968 case V4L2_PIX_FMT_RGB24
:
1969 *f_even
++ = LIMIT_RGB(b_
);
1970 *f_even
++ = LIMIT_RGB(g_
);
1971 *f_even
++ = LIMIT_RGB(r_
);
1973 case V4L2_PIX_FMT_RGB32
:
1974 *f_even
++ = LIMIT_RGB(b_
);
1975 *f_even
++ = LIMIT_RGB(g_
);
1976 *f_even
++ = LIMIT_RGB(r_
);
1979 case V4L2_PIX_FMT_RGB555
:
1981 *f_even
++ = (0x1F & (LIMIT_RGB(b_
) >> 3)) | (0xE0 & (g
<< 2));
1982 *f_even
++ = (0x03 & ( g
>> 6)) |
1983 (0x7C & (LIMIT_RGB(r_
) >> 1));
1987 clipmask_even_index
+= clipmask_add
;
1988 f_even
+= stretch_bytes
;
1990 scratch_get_extra(usbvision
, &y
[0], &y_ptr
, 2);
1992 if ((overlay
) && (clipped_pixel(clipmask_odd_index
))) {
1993 f_odd
+= bytes_per_pixel
;
1995 else if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
2000 y_
= 76284 * (y
[0] - 16);
2002 b_
= (y_
+ vb
) >> 16;
2003 g_
= (y_
+ uvg
)>> 16;
2004 r_
= (y_
+ ur
) >> 16;
2006 switch (frame
->v4l2_format
.format
) {
2007 case V4L2_PIX_FMT_RGB565
:
2009 *f_odd
++ = (0x1F & (LIMIT_RGB(b_
) >> 3)) | (0xE0 & (g
<< 3));
2010 *f_odd
++ = (0x07 & ( g
>> 5)) | (0xF8 & LIMIT_RGB(r_
));
2012 case V4L2_PIX_FMT_RGB24
:
2013 *f_odd
++ = LIMIT_RGB(b_
);
2014 *f_odd
++ = LIMIT_RGB(g_
);
2015 *f_odd
++ = LIMIT_RGB(r_
);
2017 case V4L2_PIX_FMT_RGB32
:
2018 *f_odd
++ = LIMIT_RGB(b_
);
2019 *f_odd
++ = LIMIT_RGB(g_
);
2020 *f_odd
++ = LIMIT_RGB(r_
);
2023 case V4L2_PIX_FMT_RGB555
:
2025 *f_odd
++ = (0x1F & (LIMIT_RGB(b_
) >> 3)) | (0xE0 & (g
<< 2));
2026 *f_odd
++ = (0x03 & ( g
>> 6)) |
2027 (0x7C & (LIMIT_RGB(r_
) >> 1));
2031 clipmask_odd_index
+= clipmask_add
;
2032 f_odd
+= stretch_bytes
;
2034 if((overlay
) && (clipped_pixel(clipmask_odd_index
))) {
2035 f_odd
+= bytes_per_pixel
;
2037 else if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
2042 y_
= 76284 * (y
[1] - 16);
2044 b_
= (y_
+ vb
) >> 16;
2045 g_
= (y_
+ uvg
)>> 16;
2046 r_
= (y_
+ ur
) >> 16;
2048 switch (frame
->v4l2_format
.format
) {
2049 case V4L2_PIX_FMT_RGB565
:
2051 *f_odd
++ = (0x1F & (LIMIT_RGB(b_
) >> 3)) | (0xE0 & (g
<< 3));
2052 *f_odd
++ = (0x07 & ( g
>> 5)) | (0xF8 & LIMIT_RGB(r_
));
2054 case V4L2_PIX_FMT_RGB24
:
2055 *f_odd
++ = LIMIT_RGB(b_
);
2056 *f_odd
++ = LIMIT_RGB(g_
);
2057 *f_odd
++ = LIMIT_RGB(r_
);
2059 case V4L2_PIX_FMT_RGB32
:
2060 *f_odd
++ = LIMIT_RGB(b_
);
2061 *f_odd
++ = LIMIT_RGB(g_
);
2062 *f_odd
++ = LIMIT_RGB(r_
);
2065 case V4L2_PIX_FMT_RGB555
:
2067 *f_odd
++ = (0x1F & (LIMIT_RGB(b_
) >> 3)) | (0xE0 & (g
<< 2));
2068 *f_odd
++ = (0x03 & ( g
>> 6)) |
2069 (0x7C & (LIMIT_RGB(r_
) >> 1));
2073 clipmask_odd_index
+= clipmask_add
;
2074 f_odd
+= stretch_bytes
;
2077 scratch_rm_old(usbvision
,y_step
[block
% y_step_size
] * sub_block_size
);
2078 scratch_inc_extra_ptr(&y_ptr
, y_step
[(block
+ 2 * block_split
) % y_step_size
]
2080 scratch_inc_extra_ptr(&u_ptr
, uv_step
[block
% uv_step_size
]
2082 scratch_inc_extra_ptr(&v_ptr
, uv_step
[(block
+ 2 * block_split
) % uv_step_size
]
2086 scratch_rm_old(usbvision
, pixel_per_line
* 3 / 2
2087 + block_split
* sub_block_size
);
2089 frame
->curline
+= 2 * usbvision
->stretch_height
;
2090 *pcopylen
+= frame
->v4l2_linesize
* 2 * usbvision
->stretch_height
;
2092 if (frame
->curline
>= frame
->frmheight
)
2093 return ParseState_NextFrame
;
2095 return ParseState_Continue
;
2099 * usbvision_parse_data()
2101 * Generic routine to parse the scratch buffer. It employs either
2102 * usbvision_find_header() or usbvision_parse_lines() to do most
2106 static void usbvision_parse_data(struct usb_usbvision
*usbvision
)
2108 struct usbvision_frame
*frame
;
2109 enum ParseState newstate
;
2111 unsigned long lock_flags
;
2113 if (usbvision
->overlay
) {
2114 frame
= &usbvision
->overlay_frame
;
2117 frame
= usbvision
->curFrame
;
2120 PDEBUG(DBG_PARSE
, "parsing len=%d\n", scratch_len(usbvision
));
2124 newstate
= ParseState_Out
;
2125 if (scratch_len(usbvision
)) {
2126 if (frame
->scanstate
== ScanState_Scanning
) {
2127 newstate
= usbvision_find_header(usbvision
);
2129 else if (frame
->scanstate
== ScanState_Lines
) {
2130 if (usbvision
->isocMode
== ISOC_MODE_YUV420
) {
2131 newstate
= usbvision_parse_lines_420(usbvision
, ©len
);
2133 else if (usbvision
->isocMode
== ISOC_MODE_YUV422
) {
2134 newstate
= usbvision_parse_lines_422(usbvision
, ©len
);
2136 else if (usbvision
->isocMode
== ISOC_MODE_COMPRESS
) {
2137 newstate
= usbvision_parse_compress(usbvision
, ©len
);
2142 if (newstate
== ParseState_Continue
) {
2145 else if ((newstate
== ParseState_NextFrame
) || (newstate
== ParseState_Out
)) {
2149 return; /* ParseState_EndParse */
2153 if (newstate
== ParseState_NextFrame
) {
2154 frame
->grabstate
= FrameState_Done
;
2155 do_gettimeofday(&(frame
->timestamp
));
2156 frame
->sequence
= usbvision
->frame_num
;
2157 if (usbvision
->overlay
) {
2158 frame
->grabstate
= FrameState_Grabbing
;
2159 frame
->scanstate
= ScanState_Scanning
;
2160 frame
->scanlength
= 0;
2164 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
2165 list_move_tail(&(frame
->frame
), &usbvision
->outqueue
);
2166 usbvision
->curFrame
= NULL
;
2167 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
2169 usbvision
->frame_num
++;
2171 /* Optionally display statistics on the screen */
2172 if (flags
& FLAGS_OSD_STATS
)
2173 usbvision_osd_stats(usbvision
, frame
);
2175 /* This will cause the process to request another frame. */
2176 if (waitqueue_active(&usbvision
->wait_frame
)) {
2177 PDEBUG(DBG_PARSE
, "Wake up !");
2178 wake_up_interruptible(&usbvision
->wait_frame
);
2182 frame
->grabstate
= FrameState_Grabbing
;
2185 /* Update the frame's uncompressed length. */
2186 frame
->scanlength
+= copylen
;
2191 * Make all of the blocks of data contiguous
2193 static int usbvision_compress_isochronous(struct usb_usbvision
*usbvision
,
2196 unsigned char *packet_data
;
2199 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
2200 int packet_len
= urb
->iso_frame_desc
[i
].actual_length
;
2201 int packet_stat
= urb
->iso_frame_desc
[i
].status
;
2203 packet_data
= urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
2205 /* Detect and ignore errored packets */
2206 if (packet_stat
) { // packet_stat != 0 ?????????????
2207 PDEBUG(DBG_ISOC
, "data error: [%d] len=%d, status=%X", i
, packet_len
, packet_stat
);
2208 usbvision
->isocErrCount
++;
2212 /* Detect and ignore empty packets */
2213 if (packet_len
< 0) {
2214 PDEBUG(DBG_ISOC
, "error packet [%d]", i
);
2215 usbvision
->isocSkipCount
++;
2218 else if (packet_len
== 0) { /* Frame end ????? */
2219 PDEBUG(DBG_ISOC
, "null packet [%d]", i
);
2220 usbvision
->isocstate
=IsocState_NoFrame
;
2221 usbvision
->isocSkipCount
++;
2224 else if (packet_len
> usbvision
->isocPacketSize
) {
2225 PDEBUG(DBG_ISOC
, "packet[%d] > isocPacketSize", i
);
2226 usbvision
->isocSkipCount
++;
2230 PDEBUG(DBG_ISOC
, "packet ok [%d] len=%d", i
, packet_len
);
2232 if (usbvision
->isocstate
==IsocState_NoFrame
) { //new frame begins
2233 usbvision
->isocstate
=IsocState_InFrame
;
2234 scratch_mark_header(usbvision
);
2235 usbvision_measure_bandwidth(usbvision
);
2236 PDEBUG(DBG_ISOC
, "packet with header");
2240 * If usbvision continues to feed us with data but there is no
2241 * consumption (if, for example, V4L client fell asleep) we
2242 * may overflow the buffer. We have to move old data over to
2243 * free room for new data. This is bad for old data. If we
2244 * just drop new data then it's bad for new data... choose
2245 * your favorite evil here.
2247 if (scratch_free(usbvision
) < packet_len
) {
2249 usbvision
->scratch_ovf_count
++;
2250 PDEBUG(DBG_ISOC
, "scratch buf overflow! scr_len: %d, n: %d",
2251 scratch_len(usbvision
), packet_len
);
2252 scratch_rm_old(usbvision
, packet_len
- scratch_free(usbvision
));
2255 /* Now we know that there is enough room in scratch buffer */
2256 scratch_put(usbvision
, packet_data
, packet_len
);
2257 totlen
+= packet_len
;
2258 usbvision
->isocDataCount
+= packet_len
;
2259 usbvision
->isocPacketCount
++;
2265 printk(KERN_DEBUG
"+%d.\n", usbvision
->scratchlen
);
2266 usbvision_hexdump(data0
, (totlen
> 64) ? 64 : totlen
);
2274 static void usbvision_isocIrq(struct urb
*urb
, struct pt_regs
*regs
)
2278 struct usb_usbvision
*usbvision
= urb
->context
;
2280 unsigned long startTime
= jiffies
;
2281 struct usbvision_frame
**f
;
2283 /* We don't want to do anything if we are about to be removed! */
2284 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2287 f
= &usbvision
->curFrame
;
2289 /* Manage streaming interruption */
2290 if (usbvision
->streaming
== Stream_Interrupt
) {
2291 usbvision
->streaming
= Stream_Idle
;
2293 (*f
)->grabstate
= FrameState_Ready
;
2294 (*f
)->scanstate
= ScanState_Scanning
;
2296 PDEBUG(DBG_IRQ
, "stream interrupted");
2297 wake_up_interruptible(&usbvision
->wait_stream
);
2300 /* Copy the data received into our scratch buffer */
2301 len
= usbvision_compress_isochronous(usbvision
, urb
);
2303 usbvision
->isocUrbCount
++;
2304 usbvision
->urb_length
= len
;
2306 if (usbvision
->streaming
== Stream_On
) {
2308 /* If we collected enough data let's parse! */
2309 if (scratch_len(usbvision
) > USBVISION_HEADER_LENGTH
) { /* 12 == header_length */
2310 /*If we don't have a frame we're current working on, complain */
2311 if((!list_empty(&(usbvision
->inqueue
))) || (usbvision
->overlay
)) {
2313 (*f
) = list_entry(usbvision
->inqueue
.next
,struct usbvision_frame
, frame
);
2315 usbvision_parse_data(usbvision
);
2318 PDEBUG(DBG_IRQ
, "received data, but no one needs it");
2319 scratch_reset(usbvision
);
2324 usbvision
->timeInIrq
+= jiffies
- startTime
;
2326 for (i
= 0; i
< USBVISION_URB_FRAMES
; i
++) {
2327 urb
->iso_frame_desc
[i
].status
= 0;
2328 urb
->iso_frame_desc
[i
].actual_length
= 0;
2332 urb
->dev
= usbvision
->dev
;
2333 errCode
= usb_submit_urb (urb
, GFP_ATOMIC
);
2335 /* Disable this warning. By design of the driver. */
2337 // err("%s: usb_submit_urb failed: error %d", __FUNCTION__, errCode);
2343 /*************************************/
2344 /* Low level usbvision access functions */
2345 /*************************************/
2348 * usbvision_read_reg()
2350 * return < 0 -> Error
2354 static int usbvision_read_reg(struct usb_usbvision
*usbvision
, unsigned char reg
)
2357 unsigned char buffer
[1];
2359 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2362 errCode
= usb_control_msg(usbvision
->dev
, usb_rcvctrlpipe(usbvision
->dev
, 1),
2364 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
,
2365 0, (__u16
) reg
, buffer
, 1, HZ
);
2368 err("%s: failed: error %d", __FUNCTION__
, errCode
);
2375 * usbvision_write_reg()
2377 * return 1 -> Reg written
2378 * 0 -> usbvision is not yet ready
2379 * -1 -> Something went wrong
2382 static int usbvision_write_reg(struct usb_usbvision
*usbvision
, unsigned char reg
,
2383 unsigned char value
)
2387 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2390 errCode
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
2392 USB_DIR_OUT
| USB_TYPE_VENDOR
|
2393 USB_RECIP_ENDPOINT
, 0, (__u16
) reg
, &value
, 1, HZ
);
2396 err("%s: failed: error %d", __FUNCTION__
, errCode
);
2402 static void usbvision_ctrlUrb_complete(struct urb
*urb
, struct pt_regs
*regs
)
2404 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*)urb
->context
;
2406 PDEBUG(DBG_IRQ
, "");
2407 usbvision
->ctrlUrbBusy
= 0;
2408 if (waitqueue_active(&usbvision
->ctrlUrb_wq
)) {
2409 wake_up_interruptible(&usbvision
->ctrlUrb_wq
);
2414 static int usbvision_write_reg_irq(struct usb_usbvision
*usbvision
,int address
,
2415 unsigned char *data
, int len
)
2419 PDEBUG(DBG_IRQ
, "");
2423 // down(&usbvision->ctrlUrbLock);
2424 if (usbvision
->ctrlUrbBusy
) {
2425 // up(&usbvision->ctrlUrbLock);
2428 usbvision
->ctrlUrbBusy
= 1;
2429 // up(&usbvision->ctrlUrbLock);
2431 usbvision
->ctrlUrbSetup
.bRequestType
= USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
;
2432 usbvision
->ctrlUrbSetup
.bRequest
= USBVISION_OP_CODE
;
2433 usbvision
->ctrlUrbSetup
.wValue
= 0;
2434 usbvision
->ctrlUrbSetup
.wIndex
= cpu_to_le16(address
);
2435 usbvision
->ctrlUrbSetup
.wLength
= cpu_to_le16(len
);
2436 usb_fill_control_urb (usbvision
->ctrlUrb
, usbvision
->dev
,
2437 usb_sndctrlpipe(usbvision
->dev
, 1),
2438 (unsigned char *)&usbvision
->ctrlUrbSetup
,
2439 (void *)usbvision
->ctrlUrbBuffer
, len
,
2440 usbvision_ctrlUrb_complete
,
2443 memcpy(usbvision
->ctrlUrbBuffer
, data
, len
);
2445 errCode
= usb_submit_urb(usbvision
->ctrlUrb
, GFP_ATOMIC
);
2447 // error in usb_submit_urb()
2448 usbvision
->ctrlUrbBusy
= 0;
2450 PDEBUG(DBG_IRQ
, "submit %d byte: error %d", len
, errCode
);
2457 static int usbvision_init_compression(struct usb_usbvision
*usbvision
)
2461 usbvision
->lastIsocFrameNum
= -1;
2462 usbvision
->isocDataCount
= 0;
2463 usbvision
->isocPacketCount
= 0;
2464 usbvision
->isocSkipCount
= 0;
2465 usbvision
->comprLevel
= 50;
2466 usbvision
->lastComprLevel
= -1;
2467 usbvision
->isocUrbCount
= 0;
2468 usbvision
->requestIntra
= 1;
2469 usbvision
->isocMeasureBandwidthCount
= 0;
2474 /* this function measures the used bandwidth since last call
2475 * return: 0 : no error
2476 * sets usedBandwidth to 1-100 : 1-100% of full bandwidth resp. to isocPacketSize
2478 static int usbvision_measure_bandwidth (struct usb_usbvision
*usbvision
)
2482 if (usbvision
->isocMeasureBandwidthCount
< 2) { // this gives an average bandwidth of 3 frames
2483 usbvision
->isocMeasureBandwidthCount
++;
2486 if ((usbvision
->isocPacketSize
> 0) && (usbvision
->isocPacketCount
> 0)) {
2487 usbvision
->usedBandwidth
= usbvision
->isocDataCount
/
2488 (usbvision
->isocPacketCount
+ usbvision
->isocSkipCount
) *
2489 100 / usbvision
->isocPacketSize
;
2491 usbvision
->isocMeasureBandwidthCount
= 0;
2492 usbvision
->isocDataCount
= 0;
2493 usbvision
->isocPacketCount
= 0;
2494 usbvision
->isocSkipCount
= 0;
2498 static int usbvision_adjust_compression (struct usb_usbvision
*usbvision
)
2501 unsigned char buffer
[6];
2503 PDEBUG(DBG_IRQ
, "");
2504 if ((adjustCompression
) && (usbvision
->usedBandwidth
> 0)) {
2505 usbvision
->comprLevel
+= (usbvision
->usedBandwidth
- 90) / 2;
2506 RESTRICT_TO_RANGE(usbvision
->comprLevel
, 0, 100);
2507 if (usbvision
->comprLevel
!= usbvision
->lastComprLevel
) {
2509 if (usbvision
->bridgeType
== BRIDGE_NT1004
|| usbvision
->bridgeType
== BRIDGE_NT1005
) {
2510 buffer
[0] = (unsigned char)(4 + 16 * usbvision
->comprLevel
/ 100); // PCM Threshold 1
2511 buffer
[1] = (unsigned char)(4 + 8 * usbvision
->comprLevel
/ 100); // PCM Threshold 2
2512 distorsion
= 7 + 248 * usbvision
->comprLevel
/ 100;
2513 buffer
[2] = (unsigned char)(distorsion
& 0xFF); // Average distorsion Threshold (inter)
2514 buffer
[3] = (unsigned char)(distorsion
& 0xFF); // Average distorsion Threshold (intra)
2515 distorsion
= 1 + 42 * usbvision
->comprLevel
/ 100;
2516 buffer
[4] = (unsigned char)(distorsion
& 0xFF); // Maximum distorsion Threshold (inter)
2517 buffer
[5] = (unsigned char)(distorsion
& 0xFF); // Maximum distorsion Threshold (intra)
2519 else { //BRIDGE_NT1003
2520 buffer
[0] = (unsigned char)(4 + 16 * usbvision
->comprLevel
/ 100); // PCM threshold 1
2521 buffer
[1] = (unsigned char)(4 + 8 * usbvision
->comprLevel
/ 100); // PCM threshold 2
2522 distorsion
= 2 + 253 * usbvision
->comprLevel
/ 100;
2523 buffer
[2] = (unsigned char)(distorsion
& 0xFF); // distorsion threshold bit0-7
2524 buffer
[3] = 0; //(unsigned char)((distorsion >> 8) & 0x0F); // distorsion threshold bit 8-11
2525 distorsion
= 0 + 43 * usbvision
->comprLevel
/ 100;
2526 buffer
[4] = (unsigned char)(distorsion
& 0xFF); // maximum distorsion bit0-7
2527 buffer
[5] = 0; //(unsigned char)((distorsion >> 8) & 0x01); // maximum distorsion bit 8
2529 errCode
= usbvision_write_reg_irq(usbvision
, USBVISION_PCM_THR1
, buffer
, 6);
2531 PDEBUG(DBG_IRQ
, "new compr params %#02x %#02x %#02x %#02x %#02x %#02x", buffer
[0],
2532 buffer
[1], buffer
[2], buffer
[3], buffer
[4], buffer
[5]);
2533 usbvision
->lastComprLevel
= usbvision
->comprLevel
;
2540 static int usbvision_request_intra (struct usb_usbvision
*usbvision
)
2543 unsigned char buffer
[1];
2545 PDEBUG(DBG_IRQ
, "");
2546 usbvision
->requestIntra
= 1;
2548 usbvision_write_reg_irq(usbvision
, USBVISION_FORCE_INTRA
, buffer
, 1);
2552 static int usbvision_unrequest_intra (struct usb_usbvision
*usbvision
)
2555 unsigned char buffer
[1];
2557 PDEBUG(DBG_IRQ
, "");
2558 usbvision
->requestIntra
= 0;
2560 usbvision_write_reg_irq(usbvision
, USBVISION_FORCE_INTRA
, buffer
, 1);
2564 /* ----------------------------------------------------------------------- */
2566 /* ----------------------------------------------------------------------- */
2568 static void call_i2c_clients(struct usb_usbvision
*usbvision
, unsigned int cmd
,
2574 for (i
= 0; i
< USBVISION_I2C_CLIENTS_MAX
; i
++) {
2575 if (NULL
== usbvision
->i2c_clients
[i
])
2577 if (NULL
== usbvision
->i2c_clients
[i
]->driver
->command
)
2579 usbvision
->i2c_clients
[i
]->driver
->command(usbvision
->i2c_clients
[i
], cmd
, arg
);
2583 static int attach_inform(struct i2c_client
*client
)
2585 struct usb_usbvision
*usbvision
;
2586 struct tuner_setup tun_addr
;
2589 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
2590 usbvision
= (struct usb_usbvision
*)client
->adapter
->data
;
2592 usbvision
= (struct usb_usbvision
*)i2c_get_adapdata(client
->adapter
);
2595 for (i
= 0; i
< USBVISION_I2C_CLIENTS_MAX
; i
++) {
2596 if (usbvision
->i2c_clients
[i
] == NULL
||
2597 usbvision
->i2c_clients
[i
]->driver
->id
==
2598 client
->driver
->id
) {
2599 usbvision
->i2c_clients
[i
] = client
;
2603 if ((usbvision
->have_tuner
) && (usbvision
->tuner_type
!= -1)) {
2604 tun_addr
.mode_mask
= T_ANALOG_TV
;
2605 tun_addr
.type
= usbvision
->tuner_type
;
2606 tun_addr
.addr
= ADDR_UNSET
;
2607 client
->driver
->command(client
,TUNER_SET_TYPE_ADDR
, &tun_addr
);
2608 call_i2c_clients(usbvision
, VIDIOC_INT_RESET
, NULL
);
2609 call_i2c_clients(usbvision
, VIDIOC_S_INPUT
, &usbvision
->ctl_input
);
2610 call_i2c_clients(usbvision
, VIDIOC_STREAMON
, NULL
);
2612 call_i2c_clients(usbvision
, VIDIOC_S_STD
, &usbvision
->tvnorm
->id
);
2614 PDEBUG(DBG_I2C
, "usbvision[%d] attaches %s", usbvision
->nr
, client
->name
);
2619 static int detach_inform(struct i2c_client
*client
)
2621 struct usb_usbvision
*usbvision
;
2624 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
2625 usbvision
= (struct usb_usbvision
*)client
->adapter
->data
;
2627 usbvision
= (struct usb_usbvision
*)i2c_get_adapdata(client
->adapter
);
2630 PDEBUG(DBG_I2C
, "usbvision[%d] detaches %s", usbvision
->nr
, client
->name
);
2631 for (i
= 0; i
< USBVISION_I2C_CLIENTS_MAX
; i
++) {
2632 if (NULL
!= usbvision
->i2c_clients
[i
] &&
2633 usbvision
->i2c_clients
[i
]->driver
->id
==
2634 client
->driver
->id
) {
2635 usbvision
->i2c_clients
[i
] = NULL
;
2643 usbvision_i2c_read_max4(struct usb_usbvision
*usbvision
, unsigned char addr
,
2644 char *buf
, short len
)
2648 for (retries
= 5;;) {
2649 rc
= usbvision_write_reg(usbvision
, USBVISION_SER_ADRS
, addr
);
2653 /* Initiate byte read cycle */
2654 /* USBVISION_SER_CONT <- d0-d2 n. of bytes to r/w */
2656 rc
= usbvision_write_reg(usbvision
, USBVISION_SER_CONT
,
2657 (len
& 0x07) | 0x18);
2661 /* Test for Busy and ACK */
2663 /* USBVISION_SER_CONT -> d4 == 0 busy */
2664 rc
= usbvision_read_reg(usbvision
, USBVISION_SER_CONT
);
2665 } while (rc
> 0 && ((rc
& 0x10) != 0)); /* Retry while busy */
2669 /* USBVISION_SER_CONT -> d5 == 1 Not ack */
2670 if ((rc
& 0x20) == 0) /* Ack? */
2674 rc
= usbvision_write_reg(usbvision
, USBVISION_SER_CONT
, 0x00);
2684 buf
[3] = usbvision_read_reg(usbvision
, USBVISION_SER_DAT4
);
2686 buf
[2] = usbvision_read_reg(usbvision
, USBVISION_SER_DAT3
);
2688 buf
[1] = usbvision_read_reg(usbvision
, USBVISION_SER_DAT2
);
2690 buf
[0] = usbvision_read_reg(usbvision
, USBVISION_SER_DAT1
);
2694 "usbvision_i2c_read_max4: buffer length > 4\n");
2697 if (debug
& DBG_I2C
) {
2699 for (idx
= 0; idx
< len
; idx
++) {
2700 PDEBUG(DBG_I2C
, "read %x from address %x", (unsigned char)buf
[idx
], addr
);
2707 static int usbvision_i2c_write_max4(struct usb_usbvision
*usbvision
,
2708 unsigned char addr
, const char *buf
,
2713 unsigned char value
[6];
2714 unsigned char ser_cont
;
2716 ser_cont
= (len
& 0x07) | 0x10;
2719 value
[1] = ser_cont
;
2720 for (i
= 0; i
< len
; i
++)
2721 value
[i
+ 2] = buf
[i
];
2723 for (retries
= 5;;) {
2724 rc
= usb_control_msg(usbvision
->dev
,
2725 usb_sndctrlpipe(usbvision
->dev
, 1),
2727 USB_DIR_OUT
| USB_TYPE_VENDOR
|
2728 USB_RECIP_ENDPOINT
, 0,
2729 (__u16
) USBVISION_SER_ADRS
, value
,
2735 rc
= usbvision_write_reg(usbvision
, USBVISION_SER_CONT
,
2736 (len
& 0x07) | 0x10);
2740 /* Test for Busy and ACK */
2742 rc
= usbvision_read_reg(usbvision
, USBVISION_SER_CONT
);
2743 } while (rc
> 0 && ((rc
& 0x10) != 0)); /* Retry while busy */
2747 if ((rc
& 0x20) == 0) /* Ack? */
2751 usbvision_write_reg(usbvision
, USBVISION_SER_CONT
, 0x00);
2758 if (debug
& DBG_I2C
) {
2760 for (idx
= 0; idx
< len
; idx
++) {
2761 PDEBUG(DBG_I2C
, "wrote %x at address %x", (unsigned char)buf
[idx
], addr
);
2767 static int usbvision_i2c_write(void *data
, unsigned char addr
, char *buf
,
2775 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) data
;
2778 count
= (len
> maxLen
) ? maxLen
: len
;
2779 retval
= usbvision_i2c_write_max4(usbvision
, addr
, bufPtr
, count
);
2785 return (retval
< 0) ? retval
: -EFAULT
;
2790 static int usbvision_i2c_read(void *data
, unsigned char addr
, char *buf
,
2797 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) data
;
2800 count
= (len
> 3) ? 4 : len
;
2801 retval
= usbvision_i2c_read_max4(usbvision
, addr
, temp
, count
);
2803 for (i
= 0; i
< len
; i
++)
2804 buf
[rdcount
+ i
] = temp
[i
];
2808 return (retval
< 0) ? retval
: -EFAULT
;
2813 static struct i2c_algo_usb_data i2c_algo_template
= {
2815 .inb
= usbvision_i2c_read
,
2816 .outb
= usbvision_i2c_write
,
2822 static struct i2c_adapter i2c_adap_template
= {
2823 .owner
= THIS_MODULE
,
2824 .name
= "usbvision",
2825 .id
= I2C_HW_B_BT848
, /* FIXME */
2828 .client_register
= attach_inform
,
2829 .client_unregister
= detach_inform
,
2830 #if defined (I2C_ADAP_CLASS_TV_ANALOG)
2831 .class = I2C_ADAP_CLASS_TV_ANALOG
,
2832 #elif defined (I2C_CLASS_TV_ANALOG)
2833 .class = I2C_CLASS_TV_ANALOG
,
2837 static struct i2c_client i2c_client_template
= {
2838 .name
= "usbvision internal",
2845 static int usbvision_init_i2c(struct usb_usbvision
*usbvision
)
2847 memcpy(&usbvision
->i2c_adap
, &i2c_adap_template
,
2848 sizeof(struct i2c_adapter
));
2849 memcpy(&usbvision
->i2c_algo
, &i2c_algo_template
,
2850 sizeof(struct i2c_algo_usb_data
));
2851 memcpy(&usbvision
->i2c_client
, &i2c_client_template
,
2852 sizeof(struct i2c_client
));
2854 sprintf(usbvision
->i2c_adap
.name
+ strlen(usbvision
->i2c_adap
.name
),
2855 " #%d", usbvision
->vdev
->minor
& 0x1f);
2856 PDEBUG(DBG_I2C
, "Adaptername: %s", usbvision
->i2c_adap
.name
);
2858 i2c_set_adapdata(&usbvision
->i2c_adap
, usbvision
);
2859 i2c_set_clientdata(&usbvision
->i2c_client
, usbvision
);
2860 i2c_set_algo_usb_data(&usbvision
->i2c_algo
, usbvision
);
2862 usbvision
->i2c_adap
.algo_data
= &usbvision
->i2c_algo
;
2863 usbvision
->i2c_client
.adapter
= &usbvision
->i2c_adap
;
2865 if (usbvision_write_reg(usbvision
, USBVISION_SER_MODE
, USBVISION_IIC_LRNACK
) < 0) {
2866 printk(KERN_ERR
"usbvision_init_i2c: can't wirte reg\n");
2871 /* Request the load of the i2c modules we need */
2873 switch (usbvision_device_data
[usbvision
->DevModel
].Codec
) {
2875 request_module("saa7115");
2878 request_module("saa7115");
2881 if (usbvision_device_data
[usbvision
->DevModel
].Tuner
== 1) {
2882 request_module("tuner");
2887 usbvision
->i2c_ok
= usbvision_i2c_usb_add_bus(&usbvision
->i2c_adap
);
2889 return usbvision
->i2c_ok
;
2894 /****************************/
2895 /* usbvision utility functions */
2896 /****************************/
2898 static int usbvision_power_off(struct usb_usbvision
*usbvision
)
2902 PDEBUG(DBG_FUNC
, "");
2904 errCode
= usbvision_write_reg(usbvision
, USBVISION_PWR_REG
, USBVISION_SSPND_EN
);
2906 usbvision
->power
= 0;
2908 PDEBUG(DBG_FUNC
, "%s: errCode %d", (errCode
!=1)?"ERROR":"power is off", errCode
);
2913 // to call usbvision_power_off from task queue
2914 static void call_usbvision_power_off(void *_usbvision
)
2916 struct usb_usbvision
*usbvision
= _usbvision
;
2918 PDEBUG(DBG_FUNC
, "");
2919 down_interruptible(&usbvision
->lock
);
2920 if(usbvision
->user
== 0) {
2921 usbvision_i2c_usb_del_bus(&usbvision
->i2c_adap
);
2922 usbvision_power_off(usbvision
);
2923 usbvision
->initialized
= 0;
2925 up(&usbvision
->lock
);
2930 * usbvision_set_video_format()
2933 static int usbvision_set_video_format(struct usb_usbvision
*usbvision
, int format
)
2935 static const char proc
[] = "usbvision_set_video_format";
2937 unsigned char value
[2];
2939 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2942 PDEBUG(DBG_FUNC
, "isocMode %#02x", format
);
2944 if ((format
!= ISOC_MODE_YUV422
)
2945 && (format
!= ISOC_MODE_YUV420
)
2946 && (format
!= ISOC_MODE_COMPRESS
)) {
2947 printk(KERN_ERR
"usbvision: unknown video format %02x, using default YUV420",
2949 format
= ISOC_MODE_YUV420
;
2951 value
[0] = 0x0A; //TODO: See the effect of the filter
2953 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
2955 USB_DIR_OUT
| USB_TYPE_VENDOR
|
2956 USB_RECIP_ENDPOINT
, 0,
2957 (__u16
) USBVISION_FILT_CONT
, value
, 2, HZ
);
2960 printk(KERN_ERR
"%s: ERROR=%d. USBVISION stopped - "
2961 "reconnect or reload driver.\n", proc
, rc
);
2963 usbvision
->isocMode
= format
;
2968 * usbvision_set_output()
2972 static int usbvision_set_output(struct usb_usbvision
*usbvision
, int width
,
2976 int UsbWidth
, UsbHeight
;
2977 unsigned int frameRate
=0, frameDrop
=0;
2978 unsigned char value
[4];
2980 if (!USBVISION_IS_OPERATIONAL(usbvision
)) {
2984 if (width
> MAX_USB_WIDTH
) {
2985 UsbWidth
= width
/ 2;
2986 usbvision
->stretch_width
= 2;
2990 usbvision
->stretch_width
= 1;
2993 if (height
> MAX_USB_HEIGHT
) {
2994 UsbHeight
= height
/ 2;
2995 usbvision
->stretch_height
= 2;
2999 usbvision
->stretch_height
= 1;
3002 RESTRICT_TO_RANGE(UsbWidth
, MIN_FRAME_WIDTH
, MAX_USB_WIDTH
);
3003 UsbWidth
&= ~(MIN_FRAME_WIDTH
-1);
3004 RESTRICT_TO_RANGE(UsbHeight
, MIN_FRAME_HEIGHT
, MAX_USB_HEIGHT
);
3007 PDEBUG(DBG_FUNC
, "usb %dx%d; screen %dx%d; stretch %dx%d",
3008 UsbWidth
, UsbHeight
, width
, height
,
3009 usbvision
->stretch_width
, usbvision
->stretch_height
);
3011 /* I'll not rewrite the same values */
3012 if ((UsbWidth
!= usbvision
->curwidth
) || (UsbHeight
!= usbvision
->curheight
)) {
3013 value
[0] = UsbWidth
& 0xff; //LSB
3014 value
[1] = (UsbWidth
>> 8) & 0x03; //MSB
3015 value
[2] = UsbHeight
& 0xff; //LSB
3016 value
[3] = (UsbHeight
>> 8) & 0x03; //MSB
3018 errCode
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
3020 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
,
3021 0, (__u16
) USBVISION_LXSIZE_O
, value
, 4, HZ
);
3024 err("%s failed: error %d", __FUNCTION__
, errCode
);
3027 usbvision
->curwidth
= usbvision
->stretch_width
* UsbWidth
;
3028 usbvision
->curheight
= usbvision
->stretch_height
* UsbHeight
;
3031 if (usbvision
->isocMode
== ISOC_MODE_YUV422
) {
3032 frameRate
= (usbvision
->isocPacketSize
* 1000) / (UsbWidth
* UsbHeight
* 2);
3034 else if (usbvision
->isocMode
== ISOC_MODE_YUV420
) {
3035 frameRate
= (usbvision
->isocPacketSize
* 1000) / ((UsbWidth
* UsbHeight
* 12) / 8);
3038 frameRate
= FRAMERATE_MAX
;
3041 if (usbvision
->tvnorm
->id
& V4L2_STD_625_50
) {
3042 frameDrop
= frameRate
* 32 / 25 - 1;
3044 else if (usbvision
->tvnorm
->id
& V4L2_STD_525_60
) {
3045 frameDrop
= frameRate
* 32 / 30 - 1;
3048 RESTRICT_TO_RANGE(frameDrop
, FRAMERATE_MIN
, FRAMERATE_MAX
);
3050 PDEBUG(DBG_FUNC
, "frameRate %d fps, frameDrop %d", frameRate
, frameDrop
);
3052 frameDrop
= FRAMERATE_MAX
; // We can allow the maximum here, because dropping is controlled
3054 /* frameDrop = 7; => framePhase = 1, 5, 9, 13, 17, 21, 25, 0, 4, 8, ...
3056 => frameRate = (7 + 1) * 25 / 32 = 200 / 32 = 6.25;
3058 frameDrop = 9; => framePhase = 1, 5, 8, 11, 14, 17, 21, 24, 27, 1, 4, 8, ...
3059 => frameSkip = 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 4, ...
3060 => frameRate = (9 + 1) * 25 / 32 = 250 / 32 = 7.8125;
3062 errCode
= usbvision_write_reg(usbvision
, USBVISION_FRM_RATE
, frameDrop
);
3068 * usbvision_empty_framequeues()
3069 * prepare queues for incoming and outgoing frames
3071 static void usbvision_empty_framequeues(struct usb_usbvision
*usbvision
)
3075 INIT_LIST_HEAD(&(usbvision
->inqueue
));
3076 INIT_LIST_HEAD(&(usbvision
->outqueue
));
3078 for (i
= 0; i
< USBVISION_NUMFRAMES
; i
++) {
3079 usbvision
->frame
[i
].grabstate
= FrameState_Unused
;
3080 usbvision
->frame
[i
].bytes_read
= 0;
3085 * usbvision_stream_interrupt()
3088 static int usbvision_stream_interrupt(struct usb_usbvision
*usbvision
)
3092 /* stop reading from the device */
3094 usbvision
->streaming
= Stream_Interrupt
;
3095 ret
= wait_event_timeout(usbvision
->wait_stream
,
3096 (usbvision
->streaming
== Stream_Idle
),
3097 msecs_to_jiffies(USBVISION_NUMSBUF
*USBVISION_URB_FRAMES
));
3102 * usbvision_set_compress_params()
3106 static int usbvision_set_compress_params(struct usb_usbvision
*usbvision
)
3108 static const char proc
[] = "usbvision_set_compresion_params: ";
3110 unsigned char value
[6];
3112 value
[0] = 0x0F; // Intra-Compression cycle
3113 value
[1] = 0x01; // Reg.45 one line per strip
3114 value
[2] = 0x00; // Reg.46 Force intra mode on all new frames
3115 value
[3] = 0x00; // Reg.47 FORCE_UP <- 0 normal operation (not force)
3116 value
[4] = 0xA2; // Reg.48 BUF_THR I'm not sure if this does something in not compressed mode.
3117 value
[5] = 0x00; // Reg.49 DVI_YUV This has nothing to do with compression
3119 //catched values for NT1004
3120 // value[0] = 0xFF; // Never apply intra mode automatically
3121 // value[1] = 0xF1; // Use full frame height for virtual strip width; One line per strip
3122 // value[2] = 0x01; // Force intra mode on all new frames
3123 // value[3] = 0x00; // Strip size 400 Bytes; do not force up
3124 // value[4] = 0xA2; //
3125 if (!USBVISION_IS_OPERATIONAL(usbvision
))
3128 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
3130 USB_DIR_OUT
| USB_TYPE_VENDOR
|
3131 USB_RECIP_ENDPOINT
, 0,
3132 (__u16
) USBVISION_INTRA_CYC
, value
, 5, HZ
);
3135 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
3136 "reconnect or reload driver.\n", proc
, rc
);
3140 if (usbvision
->bridgeType
== BRIDGE_NT1004
) {
3141 value
[0] = 20; // PCM Threshold 1
3142 value
[1] = 12; // PCM Threshold 2
3143 value
[2] = 255; // Distorsion Threshold inter
3144 value
[3] = 255; // Distorsion Threshold intra
3145 value
[4] = 43; // Max Distorsion inter
3146 value
[5] = 43; // Max Distorsion intra
3149 value
[0] = 20; // PCM Threshold 1
3150 value
[1] = 12; // PCM Threshold 2
3151 value
[2] = 255; // Distorsion Threshold d7-d0
3152 value
[3] = 0; // Distorsion Threshold d11-d8
3153 value
[4] = 43; // Max Distorsion d7-d0
3154 value
[5] = 0; // Max Distorsion d8
3157 if (!USBVISION_IS_OPERATIONAL(usbvision
))
3160 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
3162 USB_DIR_OUT
| USB_TYPE_VENDOR
|
3163 USB_RECIP_ENDPOINT
, 0,
3164 (__u16
) USBVISION_PCM_THR1
, value
, 6, HZ
);
3167 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
3168 "reconnect or reload driver.\n", proc
, rc
);
3178 * usbvision_set_input()
3180 * Set the input (saa711x, ...) size x y and other misc input params
3181 * I've no idea if this parameters are right
3184 static int usbvision_set_input(struct usb_usbvision
*usbvision
)
3186 static const char proc
[] = "usbvision_set_input: ";
3188 unsigned char value
[8];
3189 unsigned char dvi_yuv_value
;
3191 if (!USBVISION_IS_OPERATIONAL(usbvision
))
3194 /* Set input format expected from decoder*/
3195 if (usbvision_device_data
[usbvision
->DevModel
].Vin_Reg1
>= 0) {
3196 value
[0] = usbvision_device_data
[usbvision
->DevModel
].Vin_Reg1
& 0xff;
3197 } else if(usbvision_device_data
[usbvision
->DevModel
].Codec
== CODEC_SAA7113
) {
3198 /* SAA7113 uses 8 bit output */
3199 value
[0] = USBVISION_8_422_SYNC
;
3201 /* I'm sure only about d2-d0 [010] 16 bit 4:2:2 usin sync pulses
3202 * as that is how saa7111 is configured */
3203 value
[0] = USBVISION_16_422_SYNC
;
3204 /* | USBVISION_VSNC_POL | USBVISION_VCLK_POL);*/
3207 rc
= usbvision_write_reg(usbvision
, USBVISION_VIN_REG1
, value
[0]);
3209 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
3210 "reconnect or reload driver.\n", proc
, rc
);
3215 if (usbvision
->tvnorm
->id
& V4L2_STD_PAL
) {
3217 value
[1] = 0x02; //0x02C0 -> 704 Input video line length
3219 value
[3] = 0x01; //0x0120 -> 288 Input video n. of lines
3221 value
[5] = 0x00; //0x0060 -> 96 Input video h offset
3223 value
[7] = 0x00; //0x0016 -> 22 Input video v offset
3224 } else if (usbvision
->tvnorm
->id
& V4L2_STD_SECAM
) {
3226 value
[1] = 0x02; //0x02C0 -> 704 Input video line length
3228 value
[3] = 0x01; //0x0120 -> 288 Input video n. of lines
3230 value
[5] = 0x00; //0x0001 -> 01 Input video h offset
3232 value
[7] = 0x00; //0x0001 -> 01 Input video v offset
3233 } else { /* V4L2_STD_NTSC */
3235 value
[1] = 0x02; //0x02D0 -> 720 Input video line length
3237 value
[3] = 0x00; //0x00F0 -> 240 Input video number of lines
3239 value
[5] = 0x00; //0x0050 -> 80 Input video h offset
3241 value
[7] = 0x00; //0x0010 -> 16 Input video v offset
3244 if (usbvision_device_data
[usbvision
->DevModel
].X_Offset
>= 0) {
3245 value
[4]=usbvision_device_data
[usbvision
->DevModel
].X_Offset
& 0xff;
3246 value
[5]=(usbvision_device_data
[usbvision
->DevModel
].X_Offset
& 0x0300) >> 8;
3249 if (usbvision_device_data
[usbvision
->DevModel
].Y_Offset
>= 0) {
3250 value
[6]=usbvision_device_data
[usbvision
->DevModel
].Y_Offset
& 0xff;
3251 value
[7]=(usbvision_device_data
[usbvision
->DevModel
].Y_Offset
& 0x0300) >> 8;
3254 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
3255 USBVISION_OP_CODE
, /* USBVISION specific code */
3256 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
, 0,
3257 (__u16
) USBVISION_LXSIZE_I
, value
, 8, HZ
);
3259 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
3260 "reconnect or reload driver.\n", proc
, rc
);
3265 dvi_yuv_value
= 0x00; /* U comes after V, Ya comes after U/V, Yb comes after Yb */
3267 if(usbvision_device_data
[usbvision
->DevModel
].Dvi_yuv
>= 0){
3268 dvi_yuv_value
= usbvision_device_data
[usbvision
->DevModel
].Dvi_yuv
& 0xff;
3270 else if(usbvision_device_data
[usbvision
->DevModel
].Codec
== CODEC_SAA7113
) {
3271 /* This changes as the fine sync control changes. Further investigation necessary */
3272 dvi_yuv_value
= 0x06;
3275 return (usbvision_write_reg(usbvision
, USBVISION_DVI_YUV
, dvi_yuv_value
));
3280 * usbvision_set_dram_settings()
3282 * Set the buffer address needed by the usbvision dram to operate
3283 * This values has been taken with usbsnoop.
3287 static int usbvision_set_dram_settings(struct usb_usbvision
*usbvision
)
3290 unsigned char value
[8];
3292 if (usbvision
->isocMode
== ISOC_MODE_COMPRESS
) {
3301 // UR: 0x0E200-0x3FFFF = 204288 Words (1 Word = 2 Byte)
3302 // FDL: 0x00000-0x0E099 = 57498 Words
3303 // VDW: 0x0E3FF-0x3FFFF
3315 /* These are the values of the address of the video buffer,
3316 * they have to be loaded into the USBVISION_DRM_PRM1-8
3318 * Start address of video output buffer for read: drm_prm1-2 -> 0x00000
3319 * End address of video output buffer for read: drm_prm1-3 -> 0x1ffff
3320 * Start address of video frame delay buffer: drm_prm1-4 -> 0x20000
3321 * Only used in compressed mode
3322 * End address of video frame delay buffer: drm_prm1-5-6 -> 0x3ffff
3323 * Only used in compressed mode
3324 * Start address of video output buffer for write: drm_prm1-7 -> 0x00000
3325 * End address of video output buffer for write: drm_prm1-8 -> 0x1ffff
3328 if (!USBVISION_IS_OPERATIONAL(usbvision
))
3331 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
3332 USBVISION_OP_CODE
, /* USBVISION specific code */
3333 USB_DIR_OUT
| USB_TYPE_VENDOR
|
3334 USB_RECIP_ENDPOINT
, 0,
3335 (__u16
) USBVISION_DRM_PRM1
, value
, 8, HZ
);
3338 err("%sERROR=%d", __FUNCTION__
, rc
);
3342 /* Restart the video buffer logic */
3343 if ((rc
= usbvision_write_reg(usbvision
, USBVISION_DRM_CONT
, USBVISION_RES_UR
|
3344 USBVISION_RES_FDL
| USBVISION_RES_VDW
)) < 0)
3346 rc
= usbvision_write_reg(usbvision
, USBVISION_DRM_CONT
, 0x00);
3354 * Power on the device, enables suspend-resume logic
3355 * & reset the isoc End-Point
3359 static int usbvision_power_on(struct usb_usbvision
*usbvision
)
3363 PDEBUG(DBG_FUNC
, "");
3365 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
, USBVISION_SSPND_EN
);
3366 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
3367 USBVISION_SSPND_EN
| USBVISION_RES2
);
3368 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
3369 USBVISION_SSPND_EN
| USBVISION_PWR_VID
);
3370 errCode
= usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
3371 USBVISION_SSPND_EN
| USBVISION_PWR_VID
| USBVISION_RES2
);
3373 usbvision
->power
= 1;
3375 PDEBUG(DBG_FUNC
, "%s: errCode %d", (errCode
<0)?"ERROR":"power is on", errCode
);
3380 static void usbvision_powerOffTimer(unsigned long data
)
3382 struct usb_usbvision
*usbvision
= (void *) data
;
3384 PDEBUG(DBG_FUNC
, "");
3385 del_timer(&usbvision
->powerOffTimer
);
3386 INIT_WORK(&usbvision
->powerOffWork
, call_usbvision_power_off
, usbvision
);
3387 (void) schedule_work(&usbvision
->powerOffWork
);
3393 * usbvision_begin_streaming()
3394 * Sure you have to put bit 7 to 0, if not incoming frames are droped, but no
3395 * idea about the rest
3397 static int usbvision_begin_streaming(struct usb_usbvision
*usbvision
)
3401 if (usbvision
->isocMode
== ISOC_MODE_COMPRESS
) {
3402 usbvision_init_compression(usbvision
);
3404 errCode
= usbvision_write_reg(usbvision
, USBVISION_VIN_REG2
, USBVISION_NOHVALID
|
3405 usbvision
->Vin_Reg2_Preset
);
3410 * usbvision_restart_isoc()
3411 * Not sure yet if touching here PWR_REG make loose the config
3414 static int usbvision_restart_isoc(struct usb_usbvision
*usbvision
)
3420 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
3421 USBVISION_SSPND_EN
| USBVISION_PWR_VID
)) < 0)
3425 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
3426 USBVISION_SSPND_EN
| USBVISION_PWR_VID
|
3427 USBVISION_RES2
)) < 0)
3431 usbvision_write_reg(usbvision
, USBVISION_VIN_REG2
,
3432 USBVISION_KEEP_BLANK
| USBVISION_NOHVALID
|
3433 usbvision
->Vin_Reg2_Preset
)) < 0) return ret
;
3435 /* TODO: schedule timeout */
3436 while ((usbvision_read_reg(usbvision
, USBVISION_STATUS_REG
) && 0x01) != 1);
3441 static int usbvision_audio_on(struct usb_usbvision
*usbvision
)
3443 if (usbvision_write_reg(usbvision
, USBVISION_IOPIN_REG
, usbvision
->AudioChannel
) < 0) {
3444 printk(KERN_ERR
"usbvision_audio_on: can't wirte reg\n");
3447 DEBUG(printk(KERN_DEBUG
"usbvision_audio_on: channel %d\n", usbvision
->AudioChannel
));
3448 usbvision
->AudioMute
= 0;
3452 static int usbvision_audio_mute(struct usb_usbvision
*usbvision
)
3454 if (usbvision_write_reg(usbvision
, USBVISION_IOPIN_REG
, 0x03) < 0) {
3455 printk(KERN_ERR
"usbvision_audio_mute: can't wirte reg\n");
3458 DEBUG(printk(KERN_DEBUG
"usbvision_audio_mute: audio mute\n"));
3459 usbvision
->AudioMute
= 1;
3463 static int usbvision_audio_off(struct usb_usbvision
*usbvision
)
3465 if (usbvision_write_reg(usbvision
, USBVISION_IOPIN_REG
, USBVISION_AUDIO_MUTE
) < 0) {
3466 printk(KERN_ERR
"usbvision_audio_off: can't wirte reg\n");
3469 DEBUG(printk(KERN_DEBUG
"usbvision_audio_off: audio off\n"));
3470 usbvision
->AudioMute
= 0;
3471 usbvision
->AudioChannel
= USBVISION_AUDIO_MUTE
;
3475 static int usbvision_set_audio(struct usb_usbvision
*usbvision
, int AudioChannel
)
3477 if (!usbvision
->AudioMute
) {
3478 if (usbvision_write_reg(usbvision
, USBVISION_IOPIN_REG
, AudioChannel
) < 0) {
3479 printk(KERN_ERR
"usbvision_set_audio: can't write iopin register for audio switching\n");
3483 DEBUG(printk(KERN_DEBUG
"usbvision_set_audio: channel %d\n", AudioChannel
));
3484 usbvision
->AudioChannel
= AudioChannel
;
3488 static int usbvision_setup(struct usb_usbvision
*usbvision
)
3490 usbvision_set_video_format(usbvision
, isocMode
);
3491 usbvision_set_dram_settings(usbvision
);
3492 usbvision_set_compress_params(usbvision
);
3493 usbvision_set_input(usbvision
);
3494 usbvision_set_output(usbvision
, MAX_USB_WIDTH
, MAX_USB_HEIGHT
);
3495 usbvision_restart_isoc(usbvision
);
3498 return USBVISION_IS_OPERATIONAL(usbvision
);
3503 * usbvision_init_isoc()
3506 static int usbvision_init_isoc(struct usb_usbvision
*usbvision
)
3508 struct usb_device
*dev
= usbvision
->dev
;
3509 int bufIdx
, errCode
, regValue
;
3511 if (!USBVISION_IS_OPERATIONAL(usbvision
))
3514 usbvision
->curFrame
= NULL
;
3515 scratch_reset(usbvision
);
3517 /* Alternate interface 1 is is the biggest frame size */
3518 errCode
= usb_set_interface(dev
, usbvision
->iface
, usbvision
->ifaceAltActive
);
3520 usbvision
->last_error
= errCode
;
3524 regValue
= (16 - usbvision_read_reg(usbvision
, USBVISION_ALTER_REG
)) & 0x0F;
3525 usbvision
->isocPacketSize
= (regValue
== 0) ? 0 : (regValue
* 64) - 1;
3526 PDEBUG(DBG_ISOC
, "ISO Packet Length:%d", usbvision
->isocPacketSize
);
3528 usbvision
->usb_bandwidth
= regValue
>> 1;
3529 PDEBUG(DBG_ISOC
, "USB Bandwidth Usage: %dMbit/Sec", usbvision
->usb_bandwidth
);
3533 /* We double buffer the Iso lists */
3535 for (bufIdx
= 0; bufIdx
< USBVISION_NUMSBUF
; bufIdx
++) {
3539 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3540 urb
= usb_alloc_urb(USBVISION_URB_FRAMES
);
3542 urb
= usb_alloc_urb(USBVISION_URB_FRAMES
, GFP_KERNEL
);
3545 err("%s: usb_alloc_urb() failed", __FUNCTION__
);
3548 usbvision
->sbuf
[bufIdx
].urb
= urb
;
3550 urb
->context
= usbvision
;
3551 urb
->pipe
= usb_rcvisocpipe(dev
, usbvision
->video_endp
);
3552 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3553 urb
->transfer_flags
= USB_ISO_ASAP
;
3555 urb
->transfer_flags
= URB_ISO_ASAP
;
3558 urb
->transfer_buffer
= usbvision
->sbuf
[bufIdx
].data
;
3559 urb
->complete
= usbvision_isocIrq
;
3560 urb
->number_of_packets
= USBVISION_URB_FRAMES
;
3561 urb
->transfer_buffer_length
=
3562 usbvision
->isocPacketSize
* USBVISION_URB_FRAMES
;
3563 for (j
= k
= 0; j
< USBVISION_URB_FRAMES
; j
++,
3564 k
+= usbvision
->isocPacketSize
) {
3565 urb
->iso_frame_desc
[j
].offset
= k
;
3566 urb
->iso_frame_desc
[j
].length
= usbvision
->isocPacketSize
;
3571 /* Submit all URBs */
3572 for (bufIdx
= 0; bufIdx
< USBVISION_NUMSBUF
; bufIdx
++) {
3573 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
3574 errCode
= usb_submit_urb(usbvision
->sbuf
[bufIdx
].urb
);
3576 errCode
= usb_submit_urb(usbvision
->sbuf
[bufIdx
].urb
, GFP_KERNEL
);
3579 err("%s: usb_submit_urb(%d) failed: error %d", __FUNCTION__
, bufIdx
, errCode
);
3583 usbvision
->streaming
= Stream_Idle
;
3584 PDEBUG(DBG_ISOC
, "%s: streaming=1 usbvision->video_endp=$%02x", __FUNCTION__
, usbvision
->video_endp
);
3589 * usbvision_stop_isoc()
3591 * This procedure stops streaming and deallocates URBs. Then it
3592 * activates zero-bandwidth alt. setting of the video interface.
3595 static void usbvision_stop_isoc(struct usb_usbvision
*usbvision
)
3597 int bufIdx
, errCode
, regValue
;
3599 if ((usbvision
->streaming
== Stream_Off
) || (usbvision
->dev
== NULL
))
3602 /* Unschedule all of the iso td's */
3603 for (bufIdx
= 0; bufIdx
< USBVISION_NUMSBUF
; bufIdx
++) {
3604 usb_kill_urb(usbvision
->sbuf
[bufIdx
].urb
);
3605 usb_free_urb(usbvision
->sbuf
[bufIdx
].urb
);
3606 usbvision
->sbuf
[bufIdx
].urb
= NULL
;
3610 PDEBUG(DBG_ISOC
, "%s: streaming=Stream_Off\n", __FUNCTION__
);
3611 usbvision
->streaming
= Stream_Off
;
3613 if (!usbvision
->remove_pending
) {
3615 /* Set packet size to 0 */
3616 errCode
= usb_set_interface(usbvision
->dev
, usbvision
->iface
,
3617 usbvision
->ifaceAltInactive
);
3619 err("%s: usb_set_interface() failed: error %d", __FUNCTION__
, errCode
);
3620 usbvision
->last_error
= errCode
;
3622 regValue
= (16 - usbvision_read_reg(usbvision
, USBVISION_ALTER_REG
)) & 0x0F;
3623 usbvision
->isocPacketSize
= (regValue
== 0) ? 0 : (regValue
* 64) - 1;
3624 PDEBUG(DBG_ISOC
, "ISO Packet Length:%d", usbvision
->isocPacketSize
);
3626 usbvision
->usb_bandwidth
= regValue
>> 1;
3627 PDEBUG(DBG_ISOC
, "USB Bandwidth Usage: %dMbit/Sec", usbvision
->usb_bandwidth
);
3631 static int usbvision_muxsel(struct usb_usbvision
*usbvision
, int channel
)
3634 int audio
[]= {1, 0, 0, 0};
3635 struct v4l2_routing route
;
3636 //channel 0 is TV with audiochannel 1 (tuner mono)
3637 //channel 1 is Composite with audio channel 0 (line in)
3638 //channel 2 is S-Video with audio channel 0 (line in)
3639 //channel 3 is additional video inputs to the device with audio channel 0 (line in)
3641 RESTRICT_TO_RANGE(channel
, 0, usbvision
->video_inputs
);
3642 usbvision
->ctl_input
= channel
;
3643 route
.input
= SAA7115_COMPOSITE1
;
3644 call_i2c_clients(usbvision
, VIDIOC_INT_S_VIDEO_ROUTING
,&route
);
3645 call_i2c_clients(usbvision
, VIDIOC_S_INPUT
, &usbvision
->ctl_input
);
3647 // set the new channel
3648 // Regular USB TV Tuners -> channel: 0 = Television, 1 = Composite, 2 = S-Video
3649 // Four video input devices -> channel: 0 = Chan White, 1 = Chan Green, 2 = Chan Yellow, 3 = Chan Red
3651 switch (usbvision_device_data
[usbvision
->DevModel
].Codec
) {
3653 if (SwitchSVideoInput
) { // To handle problems with S-Video Input for some devices. Use SwitchSVideoInput parameter when loading the module.
3659 if (usbvision_device_data
[usbvision
->DevModel
].VideoChannels
== 4) {
3660 mode
[0] = 0; mode
[1] = 2; mode
[3] = 3; // Special for four input devices
3663 mode
[0] = 0; mode
[1] = 2; //modes for regular saa7113 devices
3667 mode
[0] = 0; mode
[1] = 1; mode
[2] = 7; //modes for saa7111
3670 mode
[0] = 0; mode
[1] = 1; mode
[2] = 7; //default modes
3672 route
.input
= mode
[channel
];
3673 call_i2c_clients(usbvision
, VIDIOC_INT_S_VIDEO_ROUTING
,&route
);
3674 usbvision
->channel
= channel
;
3675 usbvision_set_audio(usbvision
, audio
[channel
]);
3683 * This is part of Video 4 Linux API. The driver can be opened by one
3684 * client only (checks internal counter 'usbvision->user'). The procedure
3685 * then allocates buffers needed for video processing.
3688 static int usbvision_v4l2_open(struct inode
*inode
, struct file
*file
)
3690 struct video_device
*dev
= video_devdata(file
);
3691 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
3692 const int sb_size
= USBVISION_URB_FRAMES
* USBVISION_MAX_ISOC_PACKET_SIZE
;
3695 PDEBUG(DBG_IO
, "open");
3698 if (timer_pending(&usbvision
->powerOffTimer
)) {
3699 del_timer(&usbvision
->powerOffTimer
);
3702 if (usbvision
->user
)
3705 /* Clean pointers so we know if we allocated something */
3706 for (i
= 0; i
< USBVISION_NUMSBUF
; i
++)
3707 usbvision
->sbuf
[i
].data
= NULL
;
3709 /* Allocate memory for the frame buffers */
3710 usbvision
->max_frame_size
= MAX_FRAME_SIZE
;
3711 usbvision
->fbuf_size
= USBVISION_NUMFRAMES
* usbvision
->max_frame_size
;
3712 usbvision
->fbuf
= usbvision_rvmalloc(usbvision
->fbuf_size
);
3713 usbvision
->scratch
= vmalloc(scratch_buf_size
);
3714 scratch_reset(usbvision
);
3715 if ((usbvision
->fbuf
== NULL
) || (usbvision
->scratch
== NULL
)) {
3716 err("%s: unable to allocate %d bytes for fbuf and %d bytes for scratch",
3717 __FUNCTION__
, usbvision
->fbuf_size
, scratch_buf_size
);
3721 spin_lock_init(&usbvision
->queue_lock
);
3722 init_waitqueue_head(&usbvision
->wait_frame
);
3723 init_waitqueue_head(&usbvision
->wait_stream
);
3725 /* Allocate all buffers */
3726 for (i
= 0; i
< USBVISION_NUMFRAMES
; i
++) {
3727 usbvision
->frame
[i
].index
= i
;
3728 usbvision
->frame
[i
].grabstate
= FrameState_Unused
;
3729 usbvision
->frame
[i
].data
= usbvision
->fbuf
+
3732 * Set default sizes in case IOCTL
3734 * is not used (using read() instead).
3736 usbvision
->stretch_width
= 1;
3737 usbvision
->stretch_height
= 1;
3738 usbvision
->frame
[i
].width
= usbvision
->curwidth
;
3739 usbvision
->frame
[i
].height
= usbvision
->curheight
;
3740 usbvision
->frame
[i
].bytes_read
= 0;
3742 if (dga
) { //set default for DGA
3743 usbvision
->overlay_frame
.grabstate
= FrameState_Unused
;
3744 usbvision
->overlay_frame
.scanstate
= ScanState_Scanning
;
3745 usbvision
->overlay_frame
.data
= NULL
;
3746 usbvision
->overlay_frame
.width
= usbvision
->curwidth
;
3747 usbvision
->overlay_frame
.height
= usbvision
->curheight
;
3748 usbvision
->overlay_frame
.bytes_read
= 0;
3750 for (i
= 0; i
< USBVISION_NUMSBUF
; i
++) {
3751 usbvision
->sbuf
[i
].data
= kzalloc(sb_size
, GFP_KERNEL
);
3752 if (usbvision
->sbuf
[i
].data
== NULL
) {
3753 err("%s: unable to allocate %d bytes for sbuf", __FUNCTION__
, sb_size
);
3759 if ((!errCode
) && (usbvision
->isocMode
==ISOC_MODE_COMPRESS
)) {
3760 int IFB_size
= MAX_FRAME_WIDTH
* MAX_FRAME_HEIGHT
* 3 / 2;
3761 usbvision
->IntraFrameBuffer
= vmalloc(IFB_size
);
3762 if (usbvision
->IntraFrameBuffer
== NULL
) {
3763 err("%s: unable to allocate %d for compr. frame buffer", __FUNCTION__
, IFB_size
);
3769 /* Have to free all that memory */
3770 if (usbvision
->fbuf
!= NULL
) {
3771 usbvision_rvfree(usbvision
->fbuf
, usbvision
->fbuf_size
);
3772 usbvision
->fbuf
= NULL
;
3774 if (usbvision
->scratch
!= NULL
) {
3775 vfree(usbvision
->scratch
);
3776 usbvision
->scratch
= NULL
;
3778 for (i
= 0; i
< USBVISION_NUMSBUF
; i
++) {
3779 if (usbvision
->sbuf
[i
].data
!= NULL
) {
3780 kfree(usbvision
->sbuf
[i
].data
);
3781 usbvision
->sbuf
[i
].data
= NULL
;
3784 if (usbvision
->IntraFrameBuffer
!= NULL
) {
3785 vfree(usbvision
->IntraFrameBuffer
);
3786 usbvision
->IntraFrameBuffer
= NULL
;
3791 /* If so far no errors then we shall start the camera */
3793 down(&usbvision
->lock
);
3794 if (usbvision
->power
== 0) {
3795 usbvision_power_on(usbvision
);
3796 usbvision_init_i2c(usbvision
);
3799 /* Send init sequence only once, it's large! */
3800 if (!usbvision
->initialized
) {
3802 setup_ok
= usbvision_setup(usbvision
);
3804 usbvision
->initialized
= 1;
3810 usbvision_begin_streaming(usbvision
);
3811 errCode
= usbvision_init_isoc(usbvision
);
3815 if (PowerOnAtOpen
) {
3816 usbvision_i2c_usb_del_bus(&usbvision
->i2c_adap
);
3817 usbvision_power_off(usbvision
);
3818 usbvision
->initialized
= 0;
3821 up(&usbvision
->lock
);
3827 /* prepare queues */
3828 usbvision_empty_framequeues(usbvision
);
3830 PDEBUG(DBG_IO
, "success");
3835 * usbvision_v4l2_close()
3837 * This is part of Video 4 Linux API. The procedure
3838 * stops streaming and deallocates all buffers that were earlier
3839 * allocated in usbvision_v4l2_open().
3842 static int usbvision_v4l2_close(struct inode
*inode
, struct file
*file
)
3844 struct video_device
*dev
= video_devdata(file
);
3845 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
3848 PDEBUG(DBG_IO
, "close");
3849 down(&usbvision
->lock
);
3851 usbvision_audio_off(usbvision
);
3852 usbvision_restart_isoc(usbvision
);
3853 usbvision_stop_isoc(usbvision
);
3855 if (usbvision
->IntraFrameBuffer
!= NULL
) {
3856 vfree(usbvision
->IntraFrameBuffer
);
3857 usbvision
->IntraFrameBuffer
= NULL
;
3860 usbvision_rvfree(usbvision
->fbuf
, usbvision
->fbuf_size
);
3861 vfree(usbvision
->scratch
);
3862 for (i
= 0; i
< USBVISION_NUMSBUF
; i
++)
3863 kfree(usbvision
->sbuf
[i
].data
);
3867 if (PowerOnAtOpen
) {
3868 mod_timer(&usbvision
->powerOffTimer
, jiffies
+ USBVISION_POWEROFF_TIME
);
3869 usbvision
->initialized
= 0;
3872 up(&usbvision
->lock
);
3874 if (usbvision
->remove_pending
) {
3875 info("%s: Final disconnect", __FUNCTION__
);
3876 usbvision_release(usbvision
);
3879 PDEBUG(DBG_IO
, "success");
3889 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
3892 static int usbvision_v4l2_do_ioctl(struct inode
*inode
, struct file
*file
,
3893 unsigned int cmd
, void *arg
)
3895 struct video_device
*dev
= video_devdata(file
);
3896 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
3898 if (!USBVISION_IS_OPERATIONAL(usbvision
))
3901 // if (debug & DBG_IOCTL) v4l_printk_ioctl(cmd);
3906 struct usbvision_reg
*usbvision_reg
= arg
;
3909 errCode
= usbvision_write_reg(usbvision
, usbvision_reg
->addr
, usbvision_reg
->value
);
3912 err("%s: UVIOCSREG failed: error %d", __FUNCTION__
, errCode
);
3915 PDEBUG(DBG_IOCTL
, "UVIOCSREG addr=0x%02X, value=0x%02X",
3916 usbvision_reg
->addr
, usbvision_reg
->value
);
3923 struct usbvision_reg
*usbvision_reg
= arg
;
3926 errCode
= usbvision_read_reg(usbvision
, usbvision_reg
->addr
);
3929 err("%s: UVIOCGREG failed: error %d", __FUNCTION__
, errCode
);
3932 usbvision_reg
->value
=(unsigned char)errCode
;
3933 PDEBUG(DBG_IOCTL
, "UVIOCGREG addr=0x%02X, value=0x%02X",
3934 usbvision_reg
->addr
, usbvision_reg
->value
);
3935 errCode
= 0; // No error
3939 case VIDIOC_QUERYCAP
:
3941 struct v4l2_capability
*vc
=arg
;
3943 memset(vc
, 0, sizeof(*vc
));
3944 strlcpy(vc
->driver
, "USBVision", sizeof(vc
->driver
));
3945 strlcpy(vc
->card
, usbvision_device_data
[usbvision
->DevModel
].ModelString
,
3947 strlcpy(vc
->bus_info
, usbvision
->dev
->dev
.bus_id
,
3948 sizeof(vc
->bus_info
));
3949 vc
->version
= USBVISION_DRIVER_VERSION
;
3950 vc
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
|
3952 V4L2_CAP_READWRITE
|
3953 V4L2_CAP_STREAMING
|
3954 (dga
? (V4L2_FBUF_CAP_LIST_CLIPPING
| V4L2_CAP_VIDEO_OVERLAY
) : 0) |
3955 (usbvision
->have_tuner
? V4L2_CAP_TUNER
: 0);
3956 PDEBUG(DBG_IOCTL
, "VIDIOC_QUERYCAP");
3959 case VIDIOC_ENUMINPUT
:
3961 struct v4l2_input
*vi
= arg
;
3964 if ((vi
->index
>= usbvision
->video_inputs
) || (vi
->index
< 0) )
3966 if (usbvision
->have_tuner
) {
3970 chan
= vi
->index
+ 1; //skip Television string
3974 if (usbvision_device_data
[usbvision
->DevModel
].VideoChannels
== 4) {
3975 strcpy(vi
->name
, "White Video Input");
3978 strcpy(vi
->name
, "Television");
3979 vi
->type
= V4L2_INPUT_TYPE_TUNER
;
3982 vi
->std
= V4L2_STD_PAL
| V4L2_STD_NTSC
| V4L2_STD_SECAM
;
3986 vi
->type
= V4L2_INPUT_TYPE_CAMERA
;
3987 if (usbvision_device_data
[usbvision
->DevModel
].VideoChannels
== 4) {
3988 strcpy(vi
->name
, "Green Video Input");
3991 strcpy(vi
->name
, "Composite Video Input");
3993 vi
->std
= V4L2_STD_PAL
;
3996 vi
->type
= V4L2_INPUT_TYPE_CAMERA
;
3997 if (usbvision_device_data
[usbvision
->DevModel
].VideoChannels
== 4) {
3998 strcpy(vi
->name
, "Yellow Video Input");
4001 strcpy(vi
->name
, "S-Video Input");
4003 vi
->std
= V4L2_STD_PAL
;
4006 vi
->type
= V4L2_INPUT_TYPE_CAMERA
;
4007 strcpy(vi
->name
, "Red Video Input");
4008 vi
->std
= V4L2_STD_PAL
;
4011 PDEBUG(DBG_IOCTL
, "VIDIOC_ENUMINPUT name=%s:%d tuners=%d type=%d norm=%x", vi
->name
, vi
->index
, vi
->tuner
,vi
->type
,(int)vi
->std
);
4014 case VIDIOC_ENUMSTD
:
4016 struct v4l2_standard
*e
= arg
;
4023 ret
= v4l2_video_std_construct(e
, tvnorms
[e
->index
].id
,
4024 tvnorms
[e
->index
].name
);
4030 case VIDIOC_G_INPUT
:
4033 *input
= usbvision
->ctl_input
;
4036 case VIDIOC_S_INPUT
:
4039 if ((*input
>= usbvision
->video_inputs
) || (*input
< 0) )
4041 usbvision
->ctl_input
= *input
;
4043 down(&usbvision
->lock
);
4044 usbvision_muxsel(usbvision
, usbvision
->ctl_input
);
4045 usbvision_set_input(usbvision
);
4046 usbvision_set_output(usbvision
, usbvision
->curwidth
, usbvision
->curheight
);
4047 up(&usbvision
->lock
);
4052 v4l2_std_id
*id
= arg
;
4054 *id
= usbvision
->tvnorm
->id
;
4056 PDEBUG(DBG_IOCTL
, "VIDIOC_G_STD std_id=%s", usbvision
->tvnorm
->name
);
4061 v4l2_std_id
*id
= arg
;
4064 for (i
= 0; i
< TVNORMS
; i
++)
4065 if (*id
== tvnorms
[i
].id
)
4068 for (i
= 0; i
< TVNORMS
; i
++)
4069 if (*id
& tvnorms
[i
].id
)
4074 down(&usbvision
->lock
);
4075 usbvision
->tvnorm
= &tvnorms
[i
];
4077 call_i2c_clients(usbvision
, VIDIOC_S_STD
,
4078 &usbvision
->tvnorm
->id
);
4080 up(&usbvision
->lock
);
4082 PDEBUG(DBG_IOCTL
, "VIDIOC_S_STD std_id=%s", usbvision
->tvnorm
->name
);
4085 case VIDIOC_G_TUNER
:
4087 struct v4l2_tuner
*vt
= arg
;
4089 if (!usbvision
->have_tuner
|| vt
->index
) // Only tuner 0
4091 strcpy(vt
->name
, "Television");
4092 /* Let clients fill in the remainder of this struct */
4093 call_i2c_clients(usbvision
,VIDIOC_G_TUNER
,vt
);
4095 PDEBUG(DBG_IOCTL
, "VIDIOC_G_TUNER signal=%x, afc=%x",vt
->signal
,vt
->afc
);
4098 case VIDIOC_S_TUNER
:
4100 struct v4l2_tuner
*vt
= arg
;
4102 // Only no or one tuner for now
4103 if (!usbvision
->have_tuner
|| vt
->index
)
4105 /* let clients handle this */
4106 call_i2c_clients(usbvision
,VIDIOC_S_TUNER
,vt
);
4108 PDEBUG(DBG_IOCTL
, "VIDIOC_S_TUNER");
4111 case VIDIOC_G_FREQUENCY
:
4113 struct v4l2_frequency
*freq
= arg
;
4115 freq
->tuner
= 0; // Only one tuner
4116 freq
->type
= V4L2_TUNER_ANALOG_TV
;
4117 freq
->frequency
= usbvision
->freq
;
4118 PDEBUG(DBG_IOCTL
, "VIDIOC_G_FREQUENCY freq=0x%X", (unsigned)freq
->frequency
);
4121 case VIDIOC_S_FREQUENCY
:
4123 struct v4l2_frequency
*freq
= arg
;
4125 // Only no or one tuner for now
4126 if (!usbvision
->have_tuner
|| freq
->tuner
)
4129 usbvision
->freq
= freq
->frequency
;
4130 call_i2c_clients(usbvision
, cmd
, freq
);
4131 PDEBUG(DBG_IOCTL
, "VIDIOC_S_FREQUENCY freq=0x%X", (unsigned)freq
->frequency
);
4134 case VIDIOC_G_AUDIO
:
4136 struct v4l2_audio
*v
= arg
;
4137 memset(v
,0, sizeof(v
));
4138 strcpy(v
->name
, "TV");
4139 PDEBUG(DBG_IOCTL
, "VIDIOC_G_AUDIO");
4140 // FIXME: no more processings ???
4143 case VIDIOC_S_AUDIO
:
4145 struct v4l2_audio
*v
= arg
;
4149 PDEBUG(DBG_IOCTL
, "VIDIOC_S_AUDIO");
4150 // FIXME: void function ???
4153 case VIDIOC_QUERYCTRL
:
4155 struct v4l2_queryctrl
*ctrl
= arg
;
4158 memset(ctrl
,0,sizeof(*ctrl
));
4161 i2c_clients_command(&usbvision
->i2c_adap
, cmd
, arg
);
4168 PDEBUG(DBG_IOCTL
,"VIDIOC_QUERYCTRL id=%x value=%x",ctrl
->id
,ctrl
->type
);
4172 struct v4l2_control
*ctrl
= arg
;
4174 PDEBUG(DBG_IOCTL
,"VIDIOC_G_CTRL id=%x value=%x",ctrl
->id
,ctrl
->value
);
4175 call_i2c_clients(usbvision
, VIDIOC_G_CTRL
, ctrl
);
4180 struct v4l2_control
*ctrl
= arg
;
4182 PDEBUG(DBG_IOCTL
, "VIDIOC_S_CTRL id=%x value=%x",ctrl
->id
,ctrl
->value
);
4183 call_i2c_clients(usbvision
, VIDIOC_S_CTRL
, ctrl
);
4186 case VIDIOC_REQBUFS
:
4188 struct v4l2_requestbuffers
*vr
= arg
;
4191 RESTRICT_TO_RANGE(vr
->count
,1,USBVISION_NUMFRAMES
);
4193 // Check input validity : the user must do a VIDEO CAPTURE and MMAP method.
4194 if((vr
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) ||
4195 (vr
->memory
!= V4L2_MEMORY_MMAP
))
4198 // FIXME : before this, we must control if buffers are still mapped.
4199 // Then interrupt streaming if so...
4200 if(usbvision
->streaming
== Stream_On
) {
4201 if ((ret
= usbvision_stream_interrupt(usbvision
)))
4205 usbvision_empty_framequeues(usbvision
);
4207 usbvision
->curFrame
= NULL
;
4209 PDEBUG(DBG_IOCTL
, "VIDIOC_REQBUFS count=%d",vr
->count
);
4212 case VIDIOC_QUERYBUF
:
4214 struct v4l2_buffer
*vb
= arg
;
4215 struct usbvision_frame
*frame
;
4217 // FIXME : must control that buffers are mapped (VIDIOC_REQBUFS has been called)
4219 if(vb
->type
!= V4L2_CAP_VIDEO_CAPTURE
) {
4222 if(vb
->index
>=USBVISION_NUMFRAMES
) {
4225 // Updating the corresponding frame state
4227 frame
= &usbvision
->frame
[vb
->index
];
4228 if(frame
->grabstate
>= FrameState_Ready
)
4229 vb
->flags
|= V4L2_BUF_FLAG_QUEUED
;
4230 if(frame
->grabstate
>= FrameState_Done
)
4231 vb
->flags
|= V4L2_BUF_FLAG_DONE
;
4232 if(frame
->grabstate
== FrameState_Unused
)
4233 vb
->flags
|= V4L2_BUF_FLAG_MAPPED
;
4234 vb
->memory
= V4L2_MEMORY_MMAP
;
4235 if(vb
->index
== 0) {
4239 vb
->m
.offset
= MAX_FRAME_SIZE
;
4241 vb
->memory
= V4L2_MEMORY_MMAP
;
4242 vb
->field
= V4L2_FIELD_NONE
;
4243 vb
->length
= MAX_FRAME_SIZE
;
4244 vb
->timestamp
= usbvision
->frame
[vb
->index
].timestamp
;
4245 vb
->sequence
= usbvision
->frame
[vb
->index
].sequence
;
4250 struct v4l2_buffer
*vb
= arg
;
4251 struct usbvision_frame
*frame
;
4252 unsigned long lock_flags
;
4254 // FIXME : works only on VIDEO_CAPTURE MODE, MMAP.
4255 if(vb
->type
!= V4L2_CAP_VIDEO_CAPTURE
) {
4258 if(vb
->index
>=USBVISION_NUMFRAMES
) {
4262 frame
= &usbvision
->frame
[vb
->index
];
4264 if (frame
->grabstate
!= FrameState_Unused
) {
4268 /* Mark it as ready and enqueue frame */
4269 frame
->grabstate
= FrameState_Ready
;
4270 frame
->scanstate
= ScanState_Scanning
;
4271 frame
->scanlength
= 0; /* Accumulated in usbvision_parse_data() */
4273 vb
->flags
&= ~V4L2_BUF_FLAG_DONE
;
4275 /* set v4l2_format index */
4276 frame
->v4l2_format
= usbvision
->palette
;
4278 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
4279 list_add_tail(&usbvision
->frame
[vb
->index
].frame
, &usbvision
->inqueue
);
4280 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
4282 PDEBUG(DBG_IOCTL
, "VIDIOC_QBUF frame #%d",vb
->index
);
4287 struct v4l2_buffer
*vb
= arg
;
4289 struct usbvision_frame
*f
;
4290 unsigned long lock_flags
;
4292 if (vb
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
4295 if (list_empty(&(usbvision
->outqueue
))) {
4296 if (usbvision
->streaming
== Stream_Idle
)
4298 ret
= wait_event_interruptible
4299 (usbvision
->wait_frame
,
4300 !list_empty(&(usbvision
->outqueue
)));
4305 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
4306 f
= list_entry(usbvision
->outqueue
.next
,
4307 struct usbvision_frame
, frame
);
4308 list_del(usbvision
->outqueue
.next
);
4309 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
4311 f
->grabstate
= FrameState_Unused
;
4313 vb
->memory
= V4L2_MEMORY_MMAP
;
4314 vb
->flags
= V4L2_BUF_FLAG_MAPPED
| V4L2_BUF_FLAG_QUEUED
| V4L2_BUF_FLAG_DONE
;
4315 vb
->index
= f
->index
;
4316 vb
->sequence
= f
->sequence
;
4317 vb
->timestamp
= f
->timestamp
;
4318 vb
->field
= V4L2_FIELD_NONE
;
4319 vb
->bytesused
= f
->scanlength
;
4321 if(debug
& DBG_IOCTL
) { // do not spend computing time for debug stuff if not needed !
4322 if(usbvision_counter
== 100) {
4323 PDEBUG(DBG_IOCTL
, "VIDIOC_DQBUF delta=%d",(unsigned)(jiffies
-usbvision_timestamp
));
4324 usbvision_counter
= 0;
4325 usbvision_timestamp
= jiffies
;
4328 usbvision_counter
++;
4330 PDEBUG(DBG_IOCTL
, "VIDIOC_DQBUF frame #%d",vb
->index
);
4334 case VIDIOC_STREAMON
:
4336 int b
=V4L2_BUF_TYPE_VIDEO_CAPTURE
;
4338 usbvision
->streaming
= Stream_On
;
4340 if(debug
& DBG_IOCTL
) usbvision_timestamp
= jiffies
;
4342 call_i2c_clients(usbvision
,VIDIOC_STREAMON
, &b
);
4344 PDEBUG(DBG_IOCTL
, "VIDIOC_STREAMON");
4348 case VIDIOC_STREAMOFF
:
4351 int b
=V4L2_BUF_TYPE_VIDEO_CAPTURE
;
4353 if (*type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
4356 if(usbvision
->streaming
== Stream_On
) {
4357 usbvision_stream_interrupt(usbvision
);
4358 // Stop all video streamings
4359 call_i2c_clients(usbvision
,VIDIOC_STREAMOFF
, &b
);
4361 usbvision_empty_framequeues(usbvision
);
4363 PDEBUG(DBG_IOCTL
, "VIDIOC_STREAMOFF");
4368 struct v4l2_framebuffer
*vb
= arg
;
4371 *vb
= usbvision
->vid_buf
;
4374 memset(vb
, 0, sizeof(vb
)); //dga not supported, not used
4376 PDEBUG(DBG_IOCTL
, "VIDIOC_G_FBUF base=%p, width=%d, height=%d, pixelformat=%d, bpl=%d",
4377 vb
->base
, vb
->fmt
.width
, vb
->fmt
.height
, vb
->fmt
.pixelformat
,vb
->fmt
.bytesperline
);
4382 struct v4l2_framebuffer
*vb
= arg
;
4389 if(!capable(CAP_SYS_ADMIN
) && !capable(CAP_SYS_ADMIN
)) {
4393 PDEBUG(DBG_IOCTL
, "VIDIOC_S_FBUF base=%p, width=%d, height=%d, pixelformat=%d, bpl=%d",
4394 vb
->base
, vb
->fmt
.width
, vb
->fmt
.height
, vb
->fmt
.pixelformat
,vb
->fmt
.bytesperline
);
4396 for (formatIdx
=0; formatIdx
<= USBVISION_SUPPORTED_PALETTES
; formatIdx
++) {
4397 if (formatIdx
== USBVISION_SUPPORTED_PALETTES
) {
4398 return -EINVAL
; // no matching video_format
4400 if ((vb
->fmt
.pixelformat
== usbvision_v4l2_format
[formatIdx
].format
) &&
4401 (usbvision_v4l2_format
[formatIdx
].supported
)) {
4402 break; //found matching video_format
4406 if (vb
->fmt
.bytesperline
<1) {
4409 if (usbvision
->overlay
) {
4412 down(&usbvision
->lock
);
4413 if (usbvision
->overlay_base
) {
4414 iounmap(usbvision
->overlay_base
);
4415 usbvision
->vid_buf_valid
= 0;
4417 usbvision
->overlay_base
= ioremap((ulong
)vb
->base
, vb
->fmt
.height
* vb
->fmt
.bytesperline
);
4418 if (usbvision
->overlay_base
) {
4419 usbvision
->vid_buf_valid
= 1;
4421 usbvision
->vid_buf
= *vb
;
4422 usbvision
->overlay_frame
.v4l2_format
= usbvision_v4l2_format
[formatIdx
];
4423 up(&usbvision
->lock
);
4426 case VIDIOC_ENUM_FMT
:
4428 struct v4l2_fmtdesc
*vfd
= arg
;
4430 if(vfd
->index
>=USBVISION_SUPPORTED_PALETTES
-1) {
4434 vfd
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
4435 strcpy(vfd
->description
,usbvision_v4l2_format
[vfd
->index
].desc
);
4436 vfd
->pixelformat
= usbvision_v4l2_format
[vfd
->index
].format
;
4437 memset(vfd
->reserved
, 0, sizeof(vfd
->reserved
));
4442 struct v4l2_format
*vf
= arg
;
4445 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
4447 vf
->fmt
.pix
.width
= usbvision
->curwidth
;
4448 vf
->fmt
.pix
.height
= usbvision
->curheight
;
4449 vf
->fmt
.pix
.pixelformat
= usbvision
->palette
.format
;
4450 vf
->fmt
.pix
.bytesperline
= usbvision
->curwidth
*usbvision
->palette
.bytes_per_pixel
;
4451 vf
->fmt
.pix
.sizeimage
= vf
->fmt
.pix
.bytesperline
*usbvision
->curheight
;
4452 vf
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
4453 vf
->fmt
.pix
.field
= V4L2_FIELD_NONE
; /* Always progressive image */
4457 PDEBUG(DBG_IOCTL
, "VIDIOC_G_FMT invalid type %d",vf
->type
);
4460 PDEBUG(DBG_IOCTL
, "VIDIOC_G_FMT w=%d, h=%d",vf
->fmt
.win
.w
.width
, vf
->fmt
.win
.w
.height
);
4463 case VIDIOC_TRY_FMT
:
4466 struct v4l2_format
*vf
= arg
;
4467 struct v4l2_clip
*vc
=NULL
;
4471 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
4473 if (vf
->fmt
.win
.clipcount
>256) {
4474 return -EDOM
; /* Too many clips! */
4477 vc
= vmalloc(sizeof(struct v4l2_clip
)*(vf
->fmt
.win
.clipcount
+4));
4481 if (vf
->fmt
.win
.clipcount
&& copy_from_user(vc
,vf
->fmt
.win
.clips
,sizeof(struct v4l2_clip
)*vf
->fmt
.win
.clipcount
)) {
4484 on
= usbvision
->overlay
; // Save overlay state
4486 usbvision_cap(usbvision
, 0);
4489 // strange, it seems xawtv sometimes calls us with 0
4490 // width and/or height. Ignore these values
4491 if (vf
->fmt
.win
.w
.left
== 0) {
4492 vf
->fmt
.win
.w
.left
= usbvision
->vid_win
.fmt
.win
.w
.left
;
4494 if (vf
->fmt
.win
.w
.top
== 0) {
4495 vf
->fmt
.win
.w
.top
= usbvision
->vid_win
.fmt
.win
.w
.top
;
4498 // by now we are committed to the new data...
4499 down(&usbvision
->lock
);
4500 RESTRICT_TO_RANGE(vf
->fmt
.win
.w
.width
, MIN_FRAME_WIDTH
, MAX_FRAME_WIDTH
);
4501 RESTRICT_TO_RANGE(vf
->fmt
.win
.w
.height
, MIN_FRAME_HEIGHT
, MAX_FRAME_HEIGHT
);
4502 usbvision
->vid_win
= *vf
;
4503 usbvision
->overlay_frame
.width
= vf
->fmt
.win
.w
.width
;
4504 usbvision
->overlay_frame
.height
= vf
->fmt
.win
.w
.height
;
4505 usbvision_set_output(usbvision
, vf
->fmt
.win
.w
.width
, vf
->fmt
.win
.w
.height
);
4506 up(&usbvision
->lock
);
4508 // Impose display clips
4509 if (vf
->fmt
.win
.w
.left
+vf
->fmt
.win
.w
.width
> (unsigned int)usbvision
->vid_buf
.fmt
.width
) {
4510 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);
4512 if (vf
->fmt
.win
.w
.top
+vf
->fmt
.win
.w
.height
> (unsigned int)usbvision
->vid_buf
.fmt
.height
) {
4513 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);
4516 // built the requested clipping zones
4517 usbvision_built_overlay(usbvision
, vf
->fmt
.win
.clipcount
, vc
);
4520 // restore overlay state
4522 usbvision_cap(usbvision
, 1);
4524 usbvision
->vid_win_valid
= 1;
4525 PDEBUG(DBG_IOCTL
, "VIDIOC_S_FMT overlay x=%d, y=%d, w=%d, h=%d, chroma=%x, clips=%d",
4526 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
);
4529 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
4531 /* Find requested format in available ones */
4532 for(formatIdx
=0;formatIdx
<USBVISION_SUPPORTED_PALETTES
;formatIdx
++) {
4533 if(vf
->fmt
.pix
.pixelformat
== usbvision_v4l2_format
[formatIdx
].format
) {
4534 usbvision
->palette
= usbvision_v4l2_format
[formatIdx
];
4539 if(formatIdx
== USBVISION_SUPPORTED_PALETTES
) {
4542 RESTRICT_TO_RANGE(vf
->fmt
.pix
.width
, MIN_FRAME_WIDTH
, MAX_FRAME_WIDTH
);
4543 RESTRICT_TO_RANGE(vf
->fmt
.pix
.height
, MIN_FRAME_HEIGHT
, MAX_FRAME_HEIGHT
);
4544 // by now we are committed to the new data...
4545 down(&usbvision
->lock
);
4546 usbvision_set_output(usbvision
, vf
->fmt
.pix
.width
, vf
->fmt
.pix
.height
);
4547 up(&usbvision
->lock
);
4549 PDEBUG(DBG_IOCTL
, "VIDIOC_S_FMT grabdisplay w=%d, h=%d, format=%s",
4550 vf
->fmt
.pix
.width
, vf
->fmt
.pix
.height
,usbvision
->palette
.desc
);
4557 case VIDIOC_OVERLAY
:
4562 (usbvision
->palette
.format
!= V4L2_PIX_FMT_YVU420
) &&
4563 (usbvision
->palette
.format
!= V4L2_PIX_FMT_YUV422P
) ) {
4564 PDEBUG(DBG_IOCTL
, "VIDIOC_OVERLAY DGA disabled");
4569 usbvision_cap(usbvision
, 0);
4572 // are VIDIOCSFBUF and VIDIOCSWIN done?
4573 if ((usbvision
->vid_buf_valid
== 0) || (usbvision
->vid_win_valid
== 0)) {
4574 PDEBUG(DBG_IOCTL
, "VIDIOC_OVERLAY vid_buf_valid %d; vid_win_valid %d",
4575 usbvision
->vid_buf_valid
, usbvision
->vid_win_valid
);
4578 usbvision_cap(usbvision
, 1);
4580 PDEBUG(DBG_IOCTL
, "VIDIOC_OVERLAY %s", (*v
)?"on":"off");
4584 return -ENOIOCTLCMD
;
4589 static int usbvision_v4l2_ioctl(struct inode
*inode
, struct file
*file
,
4590 unsigned int cmd
, unsigned long arg
)
4592 return video_usercopy(inode
, file
, cmd
, arg
, usbvision_v4l2_do_ioctl
);
4596 static ssize_t
usbvision_v4l2_read(struct file
*file
, char *buf
,
4597 size_t count
, loff_t
*ppos
)
4599 struct video_device
*dev
= video_devdata(file
);
4600 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
4601 int noblock
= file
->f_flags
& O_NONBLOCK
;
4602 unsigned long lock_flags
;
4606 struct usbvision_frame
*frame
;
4608 PDEBUG(DBG_IO
, "%s: %ld bytes, noblock=%d", __FUNCTION__
, (unsigned long)count
, noblock
);
4610 if (!USBVISION_IS_OPERATIONAL(usbvision
) || (buf
== NULL
))
4613 /* no stream is running, make it running ! */
4614 usbvision
->streaming
= Stream_On
;
4615 call_i2c_clients(usbvision
,VIDIOC_STREAMON
, NULL
);
4617 /* First, enqueue as many frames as possible (like a user of VIDIOC_QBUF would do) */
4618 for(i
=0;i
<USBVISION_NUMFRAMES
;i
++) {
4619 frame
= &usbvision
->frame
[i
];
4620 if(frame
->grabstate
== FrameState_Unused
) {
4621 /* Mark it as ready and enqueue frame */
4622 frame
->grabstate
= FrameState_Ready
;
4623 frame
->scanstate
= ScanState_Scanning
;
4624 frame
->scanlength
= 0; /* Accumulated in usbvision_parse_data() */
4626 /* set v4l2_format index */
4627 frame
->v4l2_format
= usbvision
->palette
;
4629 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
4630 list_add_tail(&frame
->frame
, &usbvision
->inqueue
);
4631 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
4635 /* Then try to steal a frame (like a VIDIOC_DQBUF would do) */
4636 if (list_empty(&(usbvision
->outqueue
))) {
4640 ret
= wait_event_interruptible
4641 (usbvision
->wait_frame
,
4642 !list_empty(&(usbvision
->outqueue
)));
4647 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
4648 frame
= list_entry(usbvision
->outqueue
.next
,
4649 struct usbvision_frame
, frame
);
4650 list_del(usbvision
->outqueue
.next
);
4651 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
4653 if(debug
& DBG_IOCTL
) { // do not spend computing time for debug stuff if not needed !
4654 if(usbvision_counter
== 100) {
4655 PDEBUG(DBG_IOCTL
, "VIDIOC_DQBUF delta=%d",(unsigned)(jiffies
-usbvision_timestamp
));
4656 usbvision_counter
= 0;
4657 usbvision_timestamp
= jiffies
;
4660 usbvision_counter
++;
4664 /* An error returns an empty frame */
4665 if (frame
->grabstate
== FrameState_Error
) {
4666 frame
->bytes_read
= 0;
4670 PDEBUG(DBG_IO
, "%s: frmx=%d, bytes_read=%ld, scanlength=%ld", __FUNCTION__
,
4671 frame
->index
, frame
->bytes_read
, frame
->scanlength
);
4673 /* copy bytes to user space; we allow for partials reads */
4674 if ((count
+ frame
->bytes_read
) > (unsigned long)frame
->scanlength
)
4675 count
= frame
->scanlength
- frame
->bytes_read
;
4677 if (copy_to_user(buf
, frame
->data
+ frame
->bytes_read
, count
)) {
4681 frame
->bytes_read
+= count
;
4682 PDEBUG(DBG_IO
, "%s: {copy} count used=%ld, new bytes_read=%ld", __FUNCTION__
,
4683 (unsigned long)count
, frame
->bytes_read
);
4685 // For now, forget the frame if it has not been read in one shot.
4686 /* if (frame->bytes_read >= frame->scanlength) {// All data has been read */
4687 frame
->bytes_read
= 0;
4689 /* Mark it as available to be used again. */
4690 usbvision
->frame
[frmx
].grabstate
= FrameState_Unused
;
4696 static int usbvision_v4l2_mmap(struct file
*file
, struct vm_area_struct
*vma
)
4698 struct video_device
*dev
= video_devdata(file
);
4699 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
4700 unsigned long start
= vma
->vm_start
;
4701 unsigned long size
= vma
->vm_end
-vma
->vm_start
;
4703 unsigned long page
, pos
;
4705 if (!USBVISION_IS_OPERATIONAL(usbvision
))
4708 if (size
> (((USBVISION_NUMFRAMES
* usbvision
->max_frame_size
) + PAGE_SIZE
- 1) & ~(PAGE_SIZE
- 1)))
4711 pos
= (unsigned long) usbvision
->fbuf
;
4715 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) //Compatibility for 2.6.10+ kernels
4716 page
= vmalloc_to_pfn((void *)pos
);
4717 if (remap_pfn_range(vma
, start
, page
, PAGE_SIZE
, PAGE_SHARED
)) {
4720 #else //Compatibility for 2.6.0 - 2.6.9 kernels
4721 page
= usbvision_kvirt_to_pa(pos
);
4722 if (remap_page_range(vma
, start
, page
, PAGE_SIZE
, PAGE_SHARED
)) {
4728 if (size
> PAGE_SIZE
)
4739 * Here comes the stuff for radio on usbvision based devices
4742 static int usbvision_radio_open(struct inode
*inode
, struct file
*file
)
4744 struct video_device
*dev
= video_devdata(file
);
4745 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
4746 struct v4l2_frequency freq
;
4749 PDEBUG(DBG_RIO
, "%s:", __FUNCTION__
);
4751 down(&usbvision
->lock
);
4753 if (usbvision
->user
) {
4754 err("%s: Someone tried to open an already opened USBVision Radio!", __FUNCTION__
);
4759 if (timer_pending(&usbvision
->powerOffTimer
)) {
4760 del_timer(&usbvision
->powerOffTimer
);
4762 if (usbvision
->power
== 0) {
4763 usbvision_power_on(usbvision
);
4764 usbvision_init_i2c(usbvision
);
4768 // If so far no errors then we shall start the radio
4769 usbvision
->radio
= 1;
4770 call_i2c_clients(usbvision
,AUDC_SET_RADIO
,&usbvision
->tuner_type
);
4771 freq
.frequency
= 1517; //SWR3 @ 94.8MHz
4772 call_i2c_clients(usbvision
, VIDIOC_S_FREQUENCY
, &freq
);
4773 usbvision_set_audio(usbvision
, USBVISION_AUDIO_RADIO
);
4778 if (PowerOnAtOpen
) {
4779 usbvision_i2c_usb_del_bus(&usbvision
->i2c_adap
);
4780 usbvision_power_off(usbvision
);
4781 usbvision
->initialized
= 0;
4784 up(&usbvision
->lock
);
4789 static int usbvision_radio_close(struct inode
*inode
, struct file
*file
)
4791 struct video_device
*dev
= video_devdata(file
);
4792 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
4795 PDEBUG(DBG_RIO
, "");
4797 down(&usbvision
->lock
);
4799 usbvision_audio_off(usbvision
);
4803 if (PowerOnAtOpen
) {
4804 mod_timer(&usbvision
->powerOffTimer
, jiffies
+ USBVISION_POWEROFF_TIME
);
4805 usbvision
->initialized
= 0;
4808 up(&usbvision
->lock
);
4810 if (usbvision
->remove_pending
) {
4811 info("%s: Final disconnect", __FUNCTION__
);
4812 usbvision_release(usbvision
);
4816 PDEBUG(DBG_RIO
, "success");
4821 static int usbvision_do_radio_ioctl(struct inode
*inode
, struct file
*file
,
4822 unsigned int cmd
, void *arg
)
4824 struct video_device
*dev
= video_devdata(file
);
4825 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
4827 if (!USBVISION_IS_OPERATIONAL(usbvision
))
4831 /***************************
4833 ***************************/
4834 case VIDIOC_QUERYCAP
:
4836 struct v4l2_capability
*vc
=arg
;
4837 memset(vc
, 0, sizeof(struct v4l2_capability
));
4838 strcpy(vc
->driver
,"usbvision radio");
4839 strcpy(vc
->card
,usbvision
->vcap
.card
);
4840 strcpy(vc
->bus_info
,"usb");
4841 vc
->version
= USBVISION_DRIVER_VERSION
; /* version */
4842 vc
->capabilities
= V4L2_CAP_TUNER
; /* capabilities */
4843 PDEBUG(DBG_RIO
, "%s: VIDIOC_QUERYCAP", __FUNCTION__
);
4846 case VIDIOC_QUERYCTRL
:
4848 struct v4l2_queryctrl
*qc
= arg
;
4851 case V4L2_CID_AUDIO_VOLUME
:
4852 case V4L2_CID_AUDIO_MUTE
:
4853 return v4l2_ctrl_query_fill_std(qc
);
4862 struct v4l2_control
*ctrl
= arg
;
4863 PDEBUG(DBG_IOCTL
, "VIDIOC_G_CTRL id=%x value=%x",ctrl
->id
,ctrl
->value
);
4865 case V4L2_CID_AUDIO_VOLUME
:
4866 /* ctrl->value = usbvision->volume; */
4868 case V4L2_CID_AUDIO_MUTE
:
4869 ctrl
->value
= usbvision
->AudioMute
;
4878 struct v4l2_control
*ctrl
= arg
;
4879 call_i2c_clients(usbvision
, VIDIOC_S_CTRL
, ctrl
);
4881 PDEBUG(DBG_RIO
, "%s: VIDIOC_S_CTRL id=%x value=%x", __FUNCTION__
,ctrl
->id
,ctrl
->value
);
4884 case VIDIOC_G_TUNER
:
4886 struct v4l2_tuner
*vt
= arg
;
4888 if (!usbvision
->have_tuner
|| vt
->index
) // Only tuner 0
4890 strcpy(vt
->name
, "Radio");
4891 vt
->type
= V4L2_TUNER_RADIO
;
4892 vt
->capability
= V4L2_TUNER_CAP_STEREO
;
4893 // japan: 76.0 MHz - 89.9 MHz
4894 // western europe: 87.5 MHz - 108.0 MHz
4895 // russia: 65.0 MHz - 108.0 MHz
4896 vt
->rangelow
= (int)(65*16);;
4897 vt
->rangehigh
= (int)(108*16);
4898 vt
->audmode
= V4L2_TUNER_MODE_STEREO
;
4899 vt
->rxsubchans
= V4L2_TUNER_SUB_STEREO
;
4900 call_i2c_clients(usbvision
,VIDIOC_G_TUNER
,&vt
);
4902 PDEBUG(DBG_RIO
, "%s: VIDIOC_G_TUNER signal=%d", __FUNCTION__
, vt
->signal
);
4905 case VIDIOC_S_TUNER
:
4907 struct v4l2_tuner
*vt
= arg
;
4909 // Only channel 0 has a tuner
4910 if((vt
->index
) || (usbvision
->channel
)) {
4913 PDEBUG(DBG_RIO
, "%s: VIDIOC_S_TUNER", __FUNCTION__
);
4916 case VIDIOC_G_AUDIO
:
4918 struct v4l2_audio
*va
= arg
;
4919 memset(va
,0, sizeof(va
));
4920 va
->capability
= V4L2_AUDCAP_STEREO
;
4921 strcpy(va
->name
, "Radio");
4922 PDEBUG(DBG_IOCTL
, "VIDIOC_G_AUDIO");
4925 case VIDIOC_S_AUDIO
:
4927 struct v4l2_audio
*v
= arg
;
4931 PDEBUG(DBG_IOCTL
, "VIDIOC_S_AUDIO");
4932 // FIXME: void function ???
4935 case VIDIOC_G_FREQUENCY
:
4937 struct v4l2_frequency
*freq
= arg
;
4938 freq
->tuner
= 0; // Only one tuner
4939 freq
->type
= V4L2_TUNER_RADIO
;
4940 freq
->frequency
= usbvision
->freq
;
4941 PDEBUG(DBG_RIO
, "VIDIOC_G_FREQUENCY freq=0x%X", (unsigned)freq
->frequency
);
4944 case VIDIOC_S_FREQUENCY
:
4946 struct v4l2_frequency
*freq
= arg
;
4947 usbvision
->freq
= freq
->frequency
;
4948 call_i2c_clients(usbvision
, cmd
, freq
);
4949 PDEBUG(DBG_RIO
, "VIDIOC_S_FREQUENCY freq=0x%X", (unsigned)freq
->frequency
);
4953 /***************************
4955 ***************************/
4958 struct video_capability
*vc
= arg
;
4960 memset(vc
, 0, sizeof(struct video_capability
));
4961 strcpy(vc
->name
,usbvision
->vcap
.card
);
4962 vc
->type
= VID_TYPE_TUNER
;
4965 PDEBUG(DBG_RIO
, "%s: VIDIOCGCAP", __FUNCTION__
);
4970 struct video_tuner
*vt
= arg
;
4972 if((vt
->tuner
) || (usbvision
->channel
)) { /* Only tuner 0 */
4975 strcpy(vt
->name
, "Radio");
4976 // japan: 76.0 MHz - 89.9 MHz
4977 // western europe: 87.5 MHz - 108.0 MHz
4978 // russia: 65.0 MHz - 108.0 MHz
4979 vt
->rangelow
=(int)(65*16);
4980 vt
->rangehigh
=(int)(108*16);
4983 call_i2c_clients(usbvision
,cmd
,vt
);
4984 PDEBUG(DBG_RIO
, "%s: VIDIOCGTUNER signal=%d", __FUNCTION__
, vt
->signal
);
4989 struct video_tuner
*vt
= arg
;
4991 // Only channel 0 has a tuner
4992 if((vt
->tuner
) || (usbvision
->channel
)) {
4995 PDEBUG(DBG_RIO
, "%s: VIDIOCSTUNER", __FUNCTION__
);
5000 struct video_audio
*va
= arg
;
5001 memset(va
,0, sizeof(struct video_audio
));
5002 call_i2c_clients(usbvision
, cmd
, va
);
5003 va
->flags
|=VIDEO_AUDIO_MUTABLE
;
5006 strcpy(va
->name
, "Radio");
5007 PDEBUG(DBG_RIO
, "%s: VIDIOCGAUDIO", __FUNCTION__
);
5012 struct video_audio
*va
= arg
;
5017 if(va
->flags
& VIDEO_AUDIO_MUTE
) {
5018 if (usbvision_audio_mute(usbvision
)) {
5023 if (usbvision_audio_on(usbvision
)) {
5027 PDEBUG(DBG_RIO
, "%s: VIDIOCSAUDIO flags=0x%x)", __FUNCTION__
, va
->flags
);
5032 unsigned long *freq
= arg
;
5034 *freq
= usbvision
->freq
;
5035 PDEBUG(DBG_RIO
, "%s: VIDIOCGFREQ freq = %ld00 kHz", __FUNCTION__
, (*freq
* 10)>>4);
5040 unsigned long *freq
= arg
;
5042 usbvision
->freq
= *freq
;
5043 call_i2c_clients(usbvision
, cmd
, freq
);
5044 PDEBUG(DBG_RIO
, "%s: VIDIOCSFREQ freq = %ld00 kHz", __FUNCTION__
, (*freq
* 10)>>4);
5049 PDEBUG(DBG_RIO
, "%s: Unknown command %x", __FUNCTION__
, cmd
);
5050 return -ENOIOCTLCMD
;
5057 static int usbvision_radio_ioctl(struct inode
*inode
, struct file
*file
,
5058 unsigned int cmd
, unsigned long arg
)
5060 return video_usercopy(inode
, file
, cmd
, arg
, usbvision_do_radio_ioctl
);
5065 * Here comes the stuff for vbi on usbvision based devices
5068 static int usbvision_vbi_open(struct inode
*inode
, struct file
*file
)
5070 struct video_device
*dev
= video_devdata(file
);
5071 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
5075 PDEBUG(DBG_RIO
, "%s:", __FUNCTION__
);
5077 down(&usbvision
->lock
);
5079 if (usbvision
->user
) {
5080 err("%s: Someone tried to open an already opened USBVision VBI!", __FUNCTION__
);
5085 if (timer_pending(&usbvision
->powerOffTimer
)) {
5086 del_timer(&usbvision
->powerOffTimer
);
5088 if (usbvision
->power
== 0) {
5089 usbvision_power_on(usbvision
);
5090 usbvision_init_i2c(usbvision
);
5094 // If so far no errors then we shall start the vbi device
5095 //usbvision->vbi = 1;
5096 call_i2c_clients(usbvision
,AUDC_SET_RADIO
,&usbvision
->tuner_type
);
5097 freq
= 1517; //SWR3 @ 94.8MHz
5098 call_i2c_clients(usbvision
, VIDIOCSFREQ
, &freq
);
5099 usbvision_set_audio(usbvision
, USBVISION_AUDIO_RADIO
);
5104 if (PowerOnAtOpen
) {
5105 usbvision_i2c_usb_del_bus(&usbvision
->i2c_adap
);
5106 usbvision_power_off(usbvision
);
5107 usbvision
->initialized
= 0;
5110 up(&usbvision
->lock
);
5114 static int usbvision_vbi_close(struct inode
*inode
, struct file
*file
)
5116 struct video_device
*dev
= video_devdata(file
);
5117 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
5120 PDEBUG(DBG_RIO
, "");
5122 down(&usbvision
->lock
);
5124 usbvision_audio_off(usbvision
);
5128 if (PowerOnAtOpen
) {
5129 mod_timer(&usbvision
->powerOffTimer
, jiffies
+ USBVISION_POWEROFF_TIME
);
5130 usbvision
->initialized
= 0;
5133 up(&usbvision
->lock
);
5135 if (usbvision
->remove_pending
) {
5136 info("%s: Final disconnect", __FUNCTION__
);
5137 usbvision_release(usbvision
);
5141 PDEBUG(DBG_RIO
, "success");
5146 static int usbvision_do_vbi_ioctl(struct inode
*inode
, struct file
*file
,
5147 unsigned int cmd
, void *arg
)
5149 struct video_device
*dev
= video_devdata(file
);
5150 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
5152 if (!USBVISION_IS_OPERATIONAL(usbvision
))
5156 case VIDIOC_QUERYCAP
:
5158 struct v4l2_capability
*vc
=arg
;
5159 memset(vc
, 0, sizeof(struct v4l2_capability
));
5160 strcpy(vc
->driver
,"usbvision vbi");
5161 strcpy(vc
->card
,usbvision
->vcap
.card
);
5162 strcpy(vc
->bus_info
,"usb");
5163 vc
->version
= USBVISION_DRIVER_VERSION
; /* version */
5164 vc
->capabilities
= V4L2_CAP_VBI_CAPTURE
; /* capabilities */
5165 PDEBUG(DBG_RIO
, "%s: VIDIOC_QUERYCAP", __FUNCTION__
);
5170 struct video_tuner
*vt
= arg
;
5172 if((vt
->tuner
) || (usbvision
->channel
)) { /* Only tuner 0 */
5175 strcpy(vt
->name
, "vbi");
5176 // japan: 76.0 MHz - 89.9 MHz
5177 // western europe: 87.5 MHz - 108.0 MHz
5178 // russia: 65.0 MHz - 108.0 MHz
5179 vt
->rangelow
=(int)(65*16);
5180 vt
->rangehigh
=(int)(108*16);
5183 call_i2c_clients(usbvision
,cmd
,vt
);
5184 PDEBUG(DBG_RIO
, "%s: VIDIOCGTUNER signal=%d", __FUNCTION__
, vt
->signal
);
5189 struct video_tuner
*vt
= arg
;
5191 // Only channel 0 has a tuner
5192 if((vt
->tuner
) || (usbvision
->channel
)) {
5195 PDEBUG(DBG_RIO
, "%s: VIDIOCSTUNER", __FUNCTION__
);
5200 struct video_audio
*va
= arg
;
5201 memset(va
,0, sizeof(struct video_audio
));
5202 call_i2c_clients(usbvision
, cmd
, va
);
5203 va
->flags
|=VIDEO_AUDIO_MUTABLE
;
5206 strcpy(va
->name
, "vbi");
5207 PDEBUG(DBG_RIO
, "%s: VIDIOCGAUDIO", __FUNCTION__
);
5212 struct video_audio
*va
= arg
;
5217 if(va
->flags
& VIDEO_AUDIO_MUTE
) {
5218 if (usbvision_audio_mute(usbvision
)) {
5223 if (usbvision_audio_on(usbvision
)) {
5227 PDEBUG(DBG_RIO
, "%s: VIDIOCSAUDIO flags=0x%x)", __FUNCTION__
, va
->flags
);
5232 unsigned long *freq
= arg
;
5234 *freq
= usbvision
->freq
;
5235 PDEBUG(DBG_RIO
, "%s: VIDIOCGFREQ freq = %ld00 kHz", __FUNCTION__
, (*freq
* 10)>>4);
5240 unsigned long *freq
= arg
;
5242 usbvision
->freq
= *freq
;
5243 call_i2c_clients(usbvision
, cmd
, freq
);
5244 PDEBUG(DBG_RIO
, "%s: VIDIOCSFREQ freq = %ld00 kHz", __FUNCTION__
, (*freq
* 10)>>4);
5249 PDEBUG(DBG_RIO
, "%s: Unknown command %d", __FUNCTION__
, cmd
);
5250 return -ENOIOCTLCMD
;
5256 static int usbvision_vbi_ioctl(struct inode
*inode
, struct file
*file
,
5257 unsigned int cmd
, unsigned long arg
)
5259 return video_usercopy(inode
, file
, cmd
, arg
, usbvision_do_vbi_ioctl
);
5264 static void usbvision_configure_video(struct usb_usbvision
*usbvision
)
5268 if (usbvision
== NULL
)
5271 model
= usbvision
->DevModel
;
5272 usbvision
->depth
= 24;
5273 usbvision
->palette
= usbvision_v4l2_format
[2]; // V4L2_PIX_FMT_RGB24;
5275 if (usbvision_device_data
[usbvision
->DevModel
].Vin_Reg2
>= 0) {
5276 usbvision
->Vin_Reg2_Preset
= usbvision_device_data
[usbvision
->DevModel
].Vin_Reg2
& 0xff;
5278 usbvision
->Vin_Reg2_Preset
= 0;
5281 memset(&usbvision
->vcap
, 0, sizeof(usbvision
->vcap
));
5282 strcpy(usbvision
->vcap
.driver
, "USBVision");
5283 strlcpy(usbvision
->vcap
.bus_info
, usbvision
->dev
->dev
.bus_id
,
5284 sizeof(usbvision
->vcap
.bus_info
));
5285 usbvision
->vcap
.capabilities
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_AUDIO
| V4L2_CAP_READWRITE
| V4L2_CAP_STREAMING
|
5286 (dga
? (V4L2_FBUF_CAP_LIST_CLIPPING
| V4L2_CAP_VIDEO_OVERLAY
) : 0) |
5287 (usbvision
->have_tuner
? V4L2_CAP_TUNER
: 0);
5288 usbvision
->vcap
.version
= USBVISION_DRIVER_VERSION
; /* version */
5291 for (i
= 0; i
< TVNORMS
; i
++)
5292 if (usbvision_device_data
[model
].VideoNorm
== tvnorms
[i
].mode
)
5296 usbvision
->tvnorm
= &tvnorms
[i
]; /* set default norm */
5297 call_i2c_clients(usbvision
, VIDIOC_S_STD
,
5298 &usbvision
->tvnorm
->id
);
5300 usbvision
->video_inputs
= usbvision_device_data
[model
].VideoChannels
;
5301 usbvision
->ctl_input
= 0;
5302 /* usbvision_muxsel(usbvision, usbvision->ctl_input); */
5304 /* This should be here to make i2c clients to be able to register */
5305 usbvision_audio_off(usbvision
); //first switch off audio
5306 if (!PowerOnAtOpen
) {
5307 usbvision_power_on(usbvision
); //and then power up the noisy tuner
5308 usbvision_init_i2c(usbvision
);
5313 // Video registration stuff
5317 static struct file_operations usbvision_fops
= {
5318 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5319 .owner
= THIS_MODULE
,
5321 .open
= usbvision_v4l2_open
,
5322 .release
= usbvision_v4l2_close
,
5323 .read
= usbvision_v4l2_read
,
5324 .mmap
= usbvision_v4l2_mmap
,
5325 .ioctl
= usbvision_v4l2_ioctl
,
5326 .llseek
= no_llseek
,
5328 static struct video_device usbvision_video_template
= {
5329 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5330 .owner
= THIS_MODULE
,
5332 .type
= VID_TYPE_TUNER
| VID_TYPE_CAPTURE
,
5333 .hardware
= VID_HARDWARE_USBVISION
,
5334 .fops
= &usbvision_fops
,
5335 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
5336 .name
= "usbvision-video",
5337 .release
= video_device_release
,
5344 static struct file_operations usbvision_radio_fops
= {
5345 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5346 .owner
= THIS_MODULE
,
5348 .open
= usbvision_radio_open
,
5349 .release
= usbvision_radio_close
,
5350 .ioctl
= usbvision_radio_ioctl
,
5351 .llseek
= no_llseek
,
5354 static struct video_device usbvision_radio_template
=
5356 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5357 .owner
= THIS_MODULE
,
5359 .type
= VID_TYPE_TUNER
,
5360 .hardware
= VID_HARDWARE_USBVISION
,
5361 .fops
= &usbvision_radio_fops
,
5362 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
5363 .release
= video_device_release
,
5364 .name
= "usbvision-radio",
5371 static struct file_operations usbvision_vbi_fops
= {
5372 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5373 .owner
= THIS_MODULE
,
5375 .open
= usbvision_vbi_open
,
5376 .release
= usbvision_vbi_close
,
5377 .ioctl
= usbvision_vbi_ioctl
,
5378 .llseek
= no_llseek
,
5381 static struct video_device usbvision_vbi_template
=
5383 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,31)
5384 .owner
= THIS_MODULE
,
5386 .type
= VID_TYPE_TUNER
,
5387 .hardware
= VID_HARDWARE_USBVISION
,
5388 .fops
= &usbvision_vbi_fops
,
5389 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
5390 .release
= video_device_release
,
5391 .name
= "usbvision-vbi",
5397 static struct video_device
*usbvision_vdev_init(struct usb_usbvision
*usbvision
,
5398 struct video_device
*vdev_template
,
5401 struct usb_device
*usb_dev
= usbvision
->dev
;
5402 struct video_device
*vdev
;
5404 if (usb_dev
== NULL
) {
5405 err("%s: usbvision->dev is not set", __FUNCTION__
);
5409 vdev
= video_device_alloc();
5413 *vdev
= *vdev_template
;
5414 // vdev->minor = -1;
5415 vdev
->dev
= &usb_dev
->dev
;
5416 snprintf(vdev
->name
, sizeof(vdev
->name
), "%s", name
);
5417 video_set_drvdata(vdev
, usbvision
);
5421 // unregister video4linux devices
5422 static void usbvision_unregister_video(struct usb_usbvision
*usbvision
)
5425 if (usbvision
->vbi
) {
5426 PDEBUG(DBG_PROBE
, "unregister /dev/vbi%d [v4l2]", usbvision
->vbi
->minor
& 0x1f);
5427 if (usbvision
->vbi
->minor
!= -1) {
5428 video_unregister_device(usbvision
->vbi
);
5431 video_device_release(usbvision
->vbi
);
5433 usbvision
->vbi
= NULL
;
5437 if (usbvision
->rdev
) {
5438 PDEBUG(DBG_PROBE
, "unregister /dev/radio%d [v4l2]", usbvision
->rdev
->minor
& 0x1f);
5439 if (usbvision
->rdev
->minor
!= -1) {
5440 video_unregister_device(usbvision
->rdev
);
5443 video_device_release(usbvision
->rdev
);
5445 usbvision
->rdev
= NULL
;
5449 if (usbvision
->vdev
) {
5450 PDEBUG(DBG_PROBE
, "unregister /dev/video%d [v4l2]", usbvision
->vdev
->minor
& 0x1f);
5451 if (usbvision
->vdev
->minor
!= -1) {
5452 video_unregister_device(usbvision
->vdev
);
5455 video_device_release(usbvision
->vdev
);
5457 usbvision
->vdev
= NULL
;
5461 // register video4linux devices
5462 static int __devinit
usbvision_register_video(struct usb_usbvision
*usbvision
)
5465 usbvision
->vdev
= usbvision_vdev_init(usbvision
, &usbvision_video_template
, "USBVision Video");
5466 if (usbvision
->vdev
== NULL
) {
5469 if (video_register_device(usbvision
->vdev
, VFL_TYPE_GRABBER
, video_nr
)<0) {
5472 info("USBVision[%d]: registered USBVision Video device /dev/video%d [v4l2]", usbvision
->nr
,usbvision
->vdev
->minor
& 0x1f);
5475 if (usbvision_device_data
[usbvision
->DevModel
].Radio
) {
5476 // usbvision has radio
5477 usbvision
->rdev
= usbvision_vdev_init(usbvision
, &usbvision_radio_template
, "USBVision Radio");
5478 if (usbvision
->rdev
== NULL
) {
5481 if (video_register_device(usbvision
->rdev
, VFL_TYPE_RADIO
, radio_nr
)<0) {
5484 info("USBVision[%d]: registered USBVision Radio device /dev/radio%d [v4l2]", usbvision
->nr
, usbvision
->rdev
->minor
& 0x1f);
5487 if (usbvision_device_data
[usbvision
->DevModel
].vbi
) {
5488 usbvision
->vbi
= usbvision_vdev_init(usbvision
, &usbvision_vbi_template
, "USBVision VBI");
5489 if (usbvision
->vdev
== NULL
) {
5492 if (video_register_device(usbvision
->vbi
, VFL_TYPE_VBI
, vbi_nr
)<0) {
5495 info("USBVision[%d]: registered USBVision VBI device /dev/vbi%d [v4l2] (Not Working Yet!)", usbvision
->nr
,usbvision
->vbi
->minor
& 0x1f);
5501 err("USBVision[%d]: video_register_device() failed", usbvision
->nr
);
5502 usbvision_unregister_video(usbvision
);
5509 * This code allocates the struct usb_usbvision. It is filled with default values.
5511 * Returns NULL on error, a pointer to usb_usbvision else.
5514 static struct usb_usbvision
*usbvision_alloc(struct usb_device
*dev
)
5516 struct usb_usbvision
*usbvision
;
5518 if ((usbvision
= kzalloc(sizeof(struct usb_usbvision
), GFP_KERNEL
)) == NULL
) {
5522 usbvision
->dev
= dev
;
5524 init_MUTEX(&usbvision
->lock
); /* to 1 == available */
5526 // prepare control urb for control messages during interrupts
5527 usbvision
->ctrlUrb
= usb_alloc_urb(USBVISION_URB_FRAMES
, GFP_KERNEL
);
5528 if (usbvision
->ctrlUrb
== NULL
) {
5531 init_waitqueue_head(&usbvision
->ctrlUrb_wq
);
5532 init_MUTEX(&usbvision
->ctrlUrbLock
); /* to 1 == available */
5534 init_timer(&usbvision
->powerOffTimer
);
5535 usbvision
->powerOffTimer
.data
= (long) usbvision
;
5536 usbvision
->powerOffTimer
.function
= usbvision_powerOffTimer
;
5541 if (usbvision
&& usbvision
->ctrlUrb
) {
5542 usb_free_urb(usbvision
->ctrlUrb
);
5551 * usbvision_release()
5553 * This code does final release of struct usb_usbvision. This happens
5554 * after the device is disconnected -and- all clients closed their files.
5557 static void usbvision_release(struct usb_usbvision
*usbvision
)
5559 PDEBUG(DBG_PROBE
, "");
5561 down(&usbvision
->lock
);
5563 if (timer_pending(&usbvision
->powerOffTimer
)) {
5564 del_timer(&usbvision
->powerOffTimer
);
5567 usbvision
->usbvision_used
= 0;
5568 usbvision
->initialized
= 0;
5570 up(&usbvision
->lock
);
5572 usbvision_remove_sysfs(usbvision
->vdev
);
5573 usbvision_unregister_video(usbvision
);
5575 if (usbvision
->overlay_base
) {
5576 iounmap(usbvision
->overlay_base
);
5580 if (usbvision
->ctrlUrb
) {
5581 usb_free_urb(usbvision
->ctrlUrb
);
5586 PDEBUG(DBG_PROBE
, "success");
5593 * This procedure queries device descriptor and accepts the interface
5594 * if it looks like USBVISION video device
5597 static int __devinit
usbvision_probe(struct usb_interface
*intf
, const struct usb_device_id
*devid
)
5599 struct usb_device
*dev
= interface_to_usbdev(intf
);
5600 __u8 ifnum
= intf
->altsetting
->desc
.bInterfaceNumber
;
5601 const struct usb_host_interface
*interface
;
5602 struct usb_usbvision
*usbvision
= NULL
;
5603 const struct usb_endpoint_descriptor
*endpoint
;
5606 PDEBUG(DBG_PROBE
, "VID=%#04x, PID=%#04x, ifnum=%u",
5607 dev
->descriptor
.idVendor
, dev
->descriptor
.idProduct
, ifnum
);
5608 /* Is it an USBVISION video dev? */
5610 for(model
= 0; usbvision_device_data
[model
].idVendor
; model
++) {
5611 if (le16_to_cpu(dev
->descriptor
.idVendor
) != usbvision_device_data
[model
].idVendor
) {
5614 if (le16_to_cpu(dev
->descriptor
.idProduct
) != usbvision_device_data
[model
].idProduct
) {
5618 info("%s: %s found", __FUNCTION__
, usbvision_device_data
[model
].ModelString
);
5622 if (usbvision_device_data
[model
].idVendor
== 0) {
5623 return -ENODEV
; //no matching device
5625 if (usbvision_device_data
[model
].Interface
>= 0) {
5626 interface
= &dev
->actconfig
->interface
[usbvision_device_data
[model
].Interface
]->altsetting
[0];
5629 interface
= &dev
->actconfig
->interface
[ifnum
]->altsetting
[0];
5631 endpoint
= &interface
->endpoint
[1].desc
;
5632 if ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) != USB_ENDPOINT_XFER_ISOC
) {
5633 err("%s: interface %d. has non-ISO endpoint!", __FUNCTION__
, ifnum
);
5634 err("%s: Endpoint attribures %d", __FUNCTION__
, endpoint
->bmAttributes
);
5637 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) == USB_DIR_OUT
) {
5638 err("%s: interface %d. has ISO OUT endpoint!", __FUNCTION__
, ifnum
);
5644 if ((usbvision
= usbvision_alloc(dev
)) == NULL
) {
5645 err("%s: couldn't allocate USBVision struct", __FUNCTION__
);
5648 if (dev
->descriptor
.bNumConfigurations
> 1) {
5649 usbvision
->bridgeType
= BRIDGE_NT1004
;
5651 else if (usbvision_device_data
[model
].ModelString
== "Dazzle Fusion Model DVC-90 Rev 1 (SECAM)") {
5652 usbvision
->bridgeType
= BRIDGE_NT1005
;
5655 usbvision
->bridgeType
= BRIDGE_NT1003
;
5657 PDEBUG(DBG_PROBE
, "bridgeType %d", usbvision
->bridgeType
);
5659 down(&usbvision
->lock
);
5661 usbvision
->nr
= usbvision_nr
++;
5663 usbvision
->have_tuner
= usbvision_device_data
[model
].Tuner
;
5664 if (usbvision
->have_tuner
) {
5665 usbvision
->tuner_type
= usbvision_device_data
[model
].TunerType
;
5668 usbvision
->DevModel
= model
;
5669 usbvision
->remove_pending
= 0;
5670 usbvision
->last_error
= 0;
5671 usbvision
->iface
= ifnum
;
5672 usbvision
->ifaceAltInactive
= 0;
5673 usbvision
->ifaceAltActive
= 1;
5674 usbvision
->video_endp
= endpoint
->bEndpointAddress
;
5675 usbvision
->isocPacketSize
= 0;
5676 usbvision
->usb_bandwidth
= 0;
5677 usbvision
->user
= 0;
5678 usbvision
->streaming
= Stream_Off
;
5680 usbvision_register_video(usbvision
);
5681 usbvision_configure_video(usbvision
);
5682 up(&usbvision
->lock
);
5685 usb_set_intfdata (intf
, usbvision
);
5686 usbvision_create_sysfs(usbvision
->vdev
);
5688 PDEBUG(DBG_PROBE
, "success");
5694 * usbvision_disconnect()
5696 * This procedure stops all driver activity, deallocates interface-private
5697 * structure (pointed by 'ptr') and after that driver should be removable
5698 * with no ill consequences.
5701 static void __devexit
usbvision_disconnect(struct usb_interface
*intf
)
5703 struct usb_usbvision
*usbvision
= usb_get_intfdata(intf
);
5705 PDEBUG(DBG_PROBE
, "");
5707 if (usbvision
== NULL
) {
5708 err("%s: usb_get_intfdata() failed", __FUNCTION__
);
5711 usb_set_intfdata (intf
, NULL
);
5713 down(&usbvision
->lock
);
5715 // At this time we ask to cancel outstanding URBs
5716 usbvision_stop_isoc(usbvision
);
5718 if (usbvision
->power
) {
5719 usbvision_i2c_usb_del_bus(&usbvision
->i2c_adap
);
5720 usbvision_power_off(usbvision
);
5722 usbvision
->remove_pending
= 1; // Now all ISO data will be ignored
5724 usb_put_dev(usbvision
->dev
);
5725 usbvision
->dev
= NULL
; // USB device is no more
5727 up(&usbvision
->lock
);
5729 if (usbvision
->user
) {
5730 info("%s: In use, disconnect pending", __FUNCTION__
);
5731 wake_up_interruptible(&usbvision
->wait_frame
);
5732 wake_up_interruptible(&usbvision
->wait_stream
);
5735 usbvision_release(usbvision
);
5738 PDEBUG(DBG_PROBE
, "success");
5742 static struct usb_driver usbvision_driver
= {
5743 .name
= "usbvision",
5744 .id_table
= usbvision_table
,
5745 .probe
= usbvision_probe
,
5746 .disconnect
= usbvision_disconnect
5750 * customdevice_process()
5752 * This procedure preprocesses CustomDevice parameter if any
5755 void customdevice_process(void)
5757 usbvision_device_data
[0]=usbvision_device_data
[1];
5758 usbvision_table
[0]=usbvision_table
[1];
5762 char *parse
=CustomDevice
;
5764 PDEBUG(DBG_PROBE
, "CustomDevide=%s", CustomDevice
);
5766 /*format is CustomDevice="0x0573 0x4D31 0 7113 3 PAL 1 1 1 5 -1 -1 -1 -1 -1"
5767 usbvision_device_data[0].idVendor;
5768 usbvision_device_data[0].idProduct;
5769 usbvision_device_data[0].Interface;
5770 usbvision_device_data[0].Codec;
5771 usbvision_device_data[0].VideoChannels;
5772 usbvision_device_data[0].VideoNorm;
5773 usbvision_device_data[0].AudioChannels;
5774 usbvision_device_data[0].Radio;
5775 usbvision_device_data[0].Tuner;
5776 usbvision_device_data[0].TunerType;
5777 usbvision_device_data[0].Vin_Reg1;
5778 usbvision_device_data[0].Vin_Reg2;
5779 usbvision_device_data[0].X_Offset;
5780 usbvision_device_data[0].Y_Offset;
5781 usbvision_device_data[0].Dvi_yuv;
5782 usbvision_device_data[0].ModelString;
5786 usbvision_device_data
[0].ModelString
="USBVISION Custom Device";
5789 sscanf(parse
,"%x",&usbvision_device_data
[0].idVendor
);
5791 PDEBUG(DBG_PROBE
, "idVendor=0x%.4X", usbvision_device_data
[0].idVendor
);
5793 sscanf(parse
,"%x",&usbvision_device_data
[0].idProduct
);
5795 PDEBUG(DBG_PROBE
, "idProduct=0x%.4X", usbvision_device_data
[0].idProduct
);
5796 sscanf(parse
,"%d",&usbvision_device_data
[0].Interface
);
5798 PDEBUG(DBG_PROBE
, "Interface=%d", usbvision_device_data
[0].Interface
);
5799 sscanf(parse
,"%d",&usbvision_device_data
[0].Codec
);
5801 PDEBUG(DBG_PROBE
, "Codec=%d", usbvision_device_data
[0].Codec
);
5802 sscanf(parse
,"%d",&usbvision_device_data
[0].VideoChannels
);
5804 PDEBUG(DBG_PROBE
, "VideoChannels=%d", usbvision_device_data
[0].VideoChannels
);
5809 PDEBUG(DBG_PROBE
, "VideoNorm=PAL");
5810 usbvision_device_data
[0].VideoNorm
=VIDEO_MODE_PAL
;
5814 PDEBUG(DBG_PROBE
, "VideoNorm=SECAM");
5815 usbvision_device_data
[0].VideoNorm
=VIDEO_MODE_SECAM
;
5819 PDEBUG(DBG_PROBE
, "VideoNorm=NTSC");
5820 usbvision_device_data
[0].VideoNorm
=VIDEO_MODE_NTSC
;
5824 PDEBUG(DBG_PROBE
, "VideoNorm=PAL (by default)");
5825 usbvision_device_data
[0].VideoNorm
=VIDEO_MODE_PAL
;
5830 sscanf(parse
,"%d",&usbvision_device_data
[0].AudioChannels
);
5832 PDEBUG(DBG_PROBE
, "AudioChannels=%d", usbvision_device_data
[0].AudioChannels
);
5833 sscanf(parse
,"%d",&usbvision_device_data
[0].Radio
);
5835 PDEBUG(DBG_PROBE
, "Radio=%d", usbvision_device_data
[0].Radio
);
5836 sscanf(parse
,"%d",&usbvision_device_data
[0].Tuner
);
5838 PDEBUG(DBG_PROBE
, "Tuner=%d", usbvision_device_data
[0].Tuner
);
5839 sscanf(parse
,"%d",&usbvision_device_data
[0].TunerType
);
5841 PDEBUG(DBG_PROBE
, "TunerType=%d", usbvision_device_data
[0].TunerType
);
5842 sscanf(parse
,"%d",&usbvision_device_data
[0].Vin_Reg1
);
5844 PDEBUG(DBG_PROBE
, "Vin_Reg1=%d", usbvision_device_data
[0].Vin_Reg1
);
5845 sscanf(parse
,"%d",&usbvision_device_data
[0].Vin_Reg2
);
5847 PDEBUG(DBG_PROBE
, "Vin_Reg2=%d", usbvision_device_data
[0].Vin_Reg2
);
5848 sscanf(parse
,"%d",&usbvision_device_data
[0].X_Offset
);
5850 PDEBUG(DBG_PROBE
, "X_Offset=%d", usbvision_device_data
[0].X_Offset
);
5851 sscanf(parse
,"%d",&usbvision_device_data
[0].Y_Offset
);
5853 PDEBUG(DBG_PROBE
, "Y_Offset=%d", usbvision_device_data
[0].Y_Offset
);
5854 sscanf(parse
,"%d",&usbvision_device_data
[0].Dvi_yuv
);
5855 PDEBUG(DBG_PROBE
, "Dvi_yuv=%d", usbvision_device_data
[0].Dvi_yuv
);
5857 //add to usbvision_table also
5858 usbvision_table
[0].match_flags
=USB_DEVICE_ID_MATCH_DEVICE
;
5859 usbvision_table
[0].idVendor
=usbvision_device_data
[0].idVendor
;
5860 usbvision_table
[0].idProduct
=usbvision_device_data
[0].idProduct
;
5870 * This code is run to initialize the driver.
5873 static int __init
usbvision_init(void)
5877 PDEBUG(DBG_PROBE
, "");
5879 PDEBUG(DBG_IOCTL
, "IOCTL debugging is enabled");
5880 PDEBUG(DBG_IO
, "IO debugging is enabled");
5881 PDEBUG(DBG_RIO
, "RIO debugging is enabled");
5882 PDEBUG(DBG_HEADER
, "HEADER debugging is enabled");
5883 PDEBUG(DBG_PROBE
, "PROBE debugging is enabled");
5884 PDEBUG(DBG_IRQ
, "IRQ debugging is enabled");
5885 PDEBUG(DBG_ISOC
, "ISOC debugging is enabled");
5886 PDEBUG(DBG_PARSE
, "PARSE debugging is enabled");
5887 PDEBUG(DBG_SCRATCH
, "SCRATCH debugging is enabled");
5888 PDEBUG(DBG_FUNC
, "FUNC debugging is enabled");
5889 PDEBUG(DBG_I2C
, "I2C debugging is enabled");
5891 /* disable planar mode support unless compression enabled */
5892 if (isocMode
!= ISOC_MODE_COMPRESS
) {
5893 // FIXME : not the right way to set supported flag
5894 usbvision_v4l2_format
[6].supported
= 0; // V4L2_PIX_FMT_YVU420
5895 usbvision_v4l2_format
[7].supported
= 0; // V4L2_PIX_FMT_YUV422P
5898 customdevice_process();
5900 errCode
= usb_register(&usbvision_driver
);
5903 info(DRIVER_DESC
" : " DRIVER_VERSION
);
5904 PDEBUG(DBG_PROBE
, "success");
5909 static void __exit
usbvision_exit(void)
5911 PDEBUG(DBG_PROBE
, "");
5913 usb_deregister(&usbvision_driver
);
5914 PDEBUG(DBG_PROBE
, "success");
5917 module_init(usbvision_init
);
5918 module_exit(usbvision_exit
);
5921 * Overrides for Emacs so that we follow Linus's tabbing style.
5922 * ---------------------------------------------------------------------------