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