2 * USB USBVISION Video device driver 0.9.9
6 * Copyright (c) 1999-2005 Joerg Heckenbach <joerg@heckenbach-aw.de>
8 * This module is part of usbvision driver project.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 * Let's call the version 0.... until compression decoding is completely
27 * This driver is written by Jose Ignacio Gijon and Joerg Heckenbach.
28 * It was based on USB CPiA driver written by Peter Pregler,
29 * Scott J. Bertin and Johannes Erdfelt
30 * Ideas are taken from bttv driver by Ralph Metzler, Marcus Metzler &
31 * Gerd Knorr and zoran 36120/36125 driver by Pauline Middelink
32 * Updates to driver completed by Dwaine P. Garden
36 * - use submit_urb for all setup packets
37 * - Fix memory settings for nt1004. It is 4 times as big as the
39 * - Add audio on endpoint 3 for nt1004 chip. Seems impossible, needs a codec interface. Which one?
40 * - Clean up the driver.
41 * - optimization for performance.
42 * - Add Videotext capability (VBI). Working on it.....
43 * - Check audio for other devices
47 #include <linux/version.h>
48 #include <linux/kernel.h>
49 #include <linux/list.h>
50 #include <linux/timer.h>
51 #include <linux/slab.h>
53 #include <linux/utsname.h>
54 #include <linux/highmem.h>
55 #include <linux/smp_lock.h>
56 #include <linux/videodev.h>
57 #include <linux/vmalloc.h>
58 #include <linux/module.h>
59 #include <linux/init.h>
60 #include <linux/spinlock.h>
62 #include <linux/videodev2.h>
63 #include <linux/video_decoder.h>
64 #include <linux/i2c.h>
66 #include <media/saa7115.h>
67 #include <media/v4l2-common.h>
68 #include <media/tuner.h>
69 #include <media/audiochip.h>
71 #include <linux/moduleparam.h>
72 #include <linux/workqueue.h>
75 #include <linux/kmod.h>
78 #include "usbvision.h"
80 #define DRIVER_AUTHOR "Joerg Heckenbach <joerg@heckenbach-aw.de>, Dwaine Garden <DwaineGarden@rogers.com>"
81 #define DRIVER_NAME "usbvision"
82 #define DRIVER_ALIAS "USBVision"
83 #define DRIVER_DESC "USBVision USB Video Device Driver for Linux"
84 #define DRIVER_LICENSE "GPL"
85 #define USBVISION_DRIVER_VERSION_MAJOR 0
86 #define USBVISION_DRIVER_VERSION_MINOR 9
87 #define USBVISION_DRIVER_VERSION_PATCHLEVEL 9
88 #define USBVISION_DRIVER_VERSION KERNEL_VERSION(USBVISION_DRIVER_VERSION_MAJOR,USBVISION_DRIVER_VERSION_MINOR,USBVISION_DRIVER_VERSION_PATCHLEVEL)
89 #define USBVISION_VERSION_STRING __stringify(USBVISION_DRIVER_VERSION_MAJOR) "." __stringify(USBVISION_DRIVER_VERSION_MINOR) "." __stringify(USBVISION_DRIVER_VERSION_PATCHLEVEL)
91 #define ENABLE_HEXDUMP 0 /* Enable if you need it */
94 #ifdef USBVISION_DEBUG
95 #define PDEBUG(level, fmt, args...) \
96 if (video_debug & (level)) info("[%s:%d] " fmt, __PRETTY_FUNCTION__, __LINE__ , ## args)
98 #define PDEBUG(level, fmt, args...) do {} while(0)
101 #define DBG_IOCTL 1<<0
103 #define DBG_PROBE 1<<2
104 #define DBG_MMAP 1<<3
107 #define rmspace(str) while(*str==' ') str++;
108 #define goto2next(str) while(*str!=' ') str++; while(*str==' ') str++;
111 static int usbvision_nr
= 0; // sequential number of usbvision device
113 static struct usbvision_v4l2_format_st usbvision_v4l2_format
[] = {
114 { 1, 1, 8, V4L2_PIX_FMT_GREY
, "GREY" },
115 { 1, 2, 16, V4L2_PIX_FMT_RGB565
, "RGB565" },
116 { 1, 3, 24, V4L2_PIX_FMT_RGB24
, "RGB24" },
117 { 1, 4, 32, V4L2_PIX_FMT_RGB32
, "RGB32" },
118 { 1, 2, 16, V4L2_PIX_FMT_RGB555
, "RGB555" },
119 { 1, 2, 16, V4L2_PIX_FMT_YUYV
, "YUV422" },
120 { 1, 2, 12, V4L2_PIX_FMT_YVU420
, "YUV420P" }, // 1.5 !
121 { 1, 2, 16, V4L2_PIX_FMT_YUV422P
, "YUV422P" }
124 /* supported tv norms */
125 static struct usbvision_tvnorm tvnorms
[] = {
134 .id
= V4L2_STD_SECAM
,
137 .id
= V4L2_STD_PAL_M
,
141 #define TVNORMS ARRAY_SIZE(tvnorms)
143 // Function prototypes
144 static void usbvision_release(struct usb_usbvision
*usbvision
);
146 // Default initalization of device driver parameters
147 static int isocMode
= ISOC_MODE_COMPRESS
; // Set the default format for ISOC endpoint
148 static int video_debug
= 0; // Set the default Debug Mode of the device driver
149 static int PowerOnAtOpen
= 1; // Set the default device to power on at startup
150 static int video_nr
= -1; // Sequential Number of Video Device
151 static int radio_nr
= -1; // Sequential Number of Radio Device
152 static int vbi_nr
= -1; // Sequential Number of VBI Device
153 static char *CustomDevice
=NULL
; // Set as nothing....
155 // Grab parameters for the device driver
157 #if defined(module_param) // Showing parameters under SYSFS
158 module_param(isocMode
, int, 0444);
159 module_param(video_debug
, int, 0444);
160 module_param(PowerOnAtOpen
, int, 0444);
161 module_param(video_nr
, int, 0444);
162 module_param(radio_nr
, int, 0444);
163 module_param(vbi_nr
, int, 0444);
164 module_param(CustomDevice
, charp
, 0444);
166 MODULE_PARAM(isocMode
, "i");
167 MODULE_PARM(video_debug
, "i"); // Grab the Debug Mode of the device driver
168 MODULE_PARM(adjustCompression
, "i"); // Grab the compression to be adaptive
169 MODULE_PARM(PowerOnAtOpen
, "i"); // Grab the device to power on at startup
170 MODULE_PARM(SwitchSVideoInput
, "i"); // To help people with Black and White output with using s-video input. Some cables and input device are wired differently.
171 MODULE_PARM(video_nr
, "i"); // video_nr option allows to specify a certain /dev/videoX device (like /dev/video0 or /dev/video1 ...)
172 MODULE_PARM(radio_nr
, "i"); // radio_nr option allows to specify a certain /dev/radioX device (like /dev/radio0 or /dev/radio1 ...)
173 MODULE_PARM(vbi_nr
, "i"); // vbi_nr option allows to specify a certain /dev/vbiX device (like /dev/vbi0 or /dev/vbi1 ...)
174 MODULE_PARM(CustomDevice
, "s"); // .... CustomDevice
177 MODULE_PARM_DESC(isocMode
, " Set the default format for ISOC endpoint. Default: 0x60 (Compression On)");
178 MODULE_PARM_DESC(video_debug
, " Set the default Debug Mode of the device driver. Default: 0 (Off)");
179 MODULE_PARM_DESC(PowerOnAtOpen
, " Set the default device to power on when device is opened. Default: 1 (On)");
180 MODULE_PARM_DESC(video_nr
, "Set video device number (/dev/videoX). Default: -1 (autodetect)");
181 MODULE_PARM_DESC(radio_nr
, "Set radio device number (/dev/radioX). Default: -1 (autodetect)");
182 MODULE_PARM_DESC(vbi_nr
, "Set vbi device number (/dev/vbiX). Default: -1 (autodetect)");
183 MODULE_PARM_DESC(CustomDevice
, " Define the fine tuning parameters for the device. Default: null");
187 MODULE_AUTHOR(DRIVER_AUTHOR
);
188 MODULE_DESCRIPTION(DRIVER_DESC
);
189 MODULE_LICENSE(DRIVER_LICENSE
);
190 MODULE_VERSION(USBVISION_VERSION_STRING
);
191 MODULE_ALIAS(DRIVER_ALIAS
);
194 /****************************************************************************************/
195 /* SYSFS Code - Copied from the stv680.c usb module. */
196 /* Device information is located at /sys/class/video4linux/video0 */
197 /* Device parameters information is located at /sys/module/usbvision */
198 /* Device USB Information is located at /sys/bus/usb/drivers/USBVision Video Grabber */
199 /****************************************************************************************/
202 #define YES_NO(x) ((x) ? "Yes" : "No")
204 static inline struct usb_usbvision
*cd_to_usbvision(struct class_device
*cd
)
206 struct video_device
*vdev
= container_of(cd
, struct video_device
, class_dev
);
207 return video_get_drvdata(vdev
);
210 static ssize_t
show_version(struct class_device
*cd
, char *buf
)
212 return sprintf(buf
, "%s\n", USBVISION_VERSION_STRING
);
214 static CLASS_DEVICE_ATTR(version
, S_IRUGO
, show_version
, NULL
);
216 static ssize_t
show_model(struct class_device
*cd
, char *buf
)
218 struct video_device
*vdev
= container_of(cd
, struct video_device
, class_dev
);
219 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
220 return sprintf(buf
, "%s\n", usbvision_device_data
[usbvision
->DevModel
].ModelString
);
222 static CLASS_DEVICE_ATTR(model
, S_IRUGO
, show_model
, NULL
);
224 static ssize_t
show_hue(struct class_device
*cd
, char *buf
)
226 struct video_device
*vdev
= container_of(cd
, struct video_device
, class_dev
);
227 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
228 struct v4l2_control ctrl
;
229 ctrl
.id
= V4L2_CID_HUE
;
232 call_i2c_clients(usbvision
, VIDIOC_G_CTRL
, &ctrl
);
233 return sprintf(buf
, "%d\n", ctrl
.value
>> 8);
235 static CLASS_DEVICE_ATTR(hue
, S_IRUGO
, show_hue
, NULL
);
237 static ssize_t
show_contrast(struct class_device
*cd
, char *buf
)
239 struct video_device
*vdev
= container_of(cd
, struct video_device
, class_dev
);
240 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
241 struct v4l2_control ctrl
;
242 ctrl
.id
= V4L2_CID_CONTRAST
;
245 call_i2c_clients(usbvision
, VIDIOC_G_CTRL
, &ctrl
);
246 return sprintf(buf
, "%d\n", ctrl
.value
>> 8);
248 static CLASS_DEVICE_ATTR(contrast
, S_IRUGO
, show_contrast
, NULL
);
250 static ssize_t
show_brightness(struct class_device
*cd
, char *buf
)
252 struct video_device
*vdev
= container_of(cd
, struct video_device
, class_dev
);
253 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
254 struct v4l2_control ctrl
;
255 ctrl
.id
= V4L2_CID_BRIGHTNESS
;
258 call_i2c_clients(usbvision
, VIDIOC_G_CTRL
, &ctrl
);
259 return sprintf(buf
, "%d\n", ctrl
.value
>> 8);
261 static CLASS_DEVICE_ATTR(brightness
, S_IRUGO
, show_brightness
, NULL
);
263 static ssize_t
show_saturation(struct class_device
*cd
, char *buf
)
265 struct video_device
*vdev
= container_of(cd
, struct video_device
, class_dev
);
266 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
267 struct v4l2_control ctrl
;
268 ctrl
.id
= V4L2_CID_SATURATION
;
271 call_i2c_clients(usbvision
, VIDIOC_G_CTRL
, &ctrl
);
272 return sprintf(buf
, "%d\n", ctrl
.value
>> 8);
274 static CLASS_DEVICE_ATTR(saturation
, S_IRUGO
, show_saturation
, NULL
);
276 static ssize_t
show_streaming(struct class_device
*cd
, char *buf
)
278 struct video_device
*vdev
= container_of(cd
, struct video_device
, class_dev
);
279 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
280 return sprintf(buf
, "%s\n", YES_NO(usbvision
->streaming
==Stream_On
?1:0));
282 static CLASS_DEVICE_ATTR(streaming
, S_IRUGO
, show_streaming
, NULL
);
284 static ssize_t
show_compression(struct class_device
*cd
, char *buf
)
286 struct video_device
*vdev
= container_of(cd
, struct video_device
, class_dev
);
287 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
288 return sprintf(buf
, "%s\n", YES_NO(usbvision
->isocMode
==ISOC_MODE_COMPRESS
));
290 static CLASS_DEVICE_ATTR(compression
, S_IRUGO
, show_compression
, NULL
);
292 static ssize_t
show_device_bridge(struct class_device
*cd
, char *buf
)
294 struct video_device
*vdev
= container_of(cd
, struct video_device
, class_dev
);
295 struct usb_usbvision
*usbvision
= video_get_drvdata(vdev
);
296 return sprintf(buf
, "%d\n", usbvision
->bridgeType
);
298 static CLASS_DEVICE_ATTR(bridge
, S_IRUGO
, show_device_bridge
, NULL
);
300 static void usbvision_create_sysfs(struct video_device
*vdev
)
306 res
=class_device_create_file(&vdev
->class_dev
,
307 &class_device_attr_version
);
310 res
=class_device_create_file(&vdev
->class_dev
,
311 &class_device_attr_model
);
314 res
=class_device_create_file(&vdev
->class_dev
,
315 &class_device_attr_hue
);
318 res
=class_device_create_file(&vdev
->class_dev
,
319 &class_device_attr_contrast
);
322 res
=class_device_create_file(&vdev
->class_dev
,
323 &class_device_attr_brightness
);
326 res
=class_device_create_file(&vdev
->class_dev
,
327 &class_device_attr_saturation
);
330 res
=class_device_create_file(&vdev
->class_dev
,
331 &class_device_attr_streaming
);
334 res
=class_device_create_file(&vdev
->class_dev
,
335 &class_device_attr_compression
);
338 res
=class_device_create_file(&vdev
->class_dev
,
339 &class_device_attr_bridge
);
344 err("%s error: %d\n", __FUNCTION__
, res
);
347 static void usbvision_remove_sysfs(struct video_device
*vdev
)
350 class_device_remove_file(&vdev
->class_dev
,
351 &class_device_attr_version
);
352 class_device_remove_file(&vdev
->class_dev
,
353 &class_device_attr_model
);
354 class_device_remove_file(&vdev
->class_dev
,
355 &class_device_attr_hue
);
356 class_device_remove_file(&vdev
->class_dev
,
357 &class_device_attr_contrast
);
358 class_device_remove_file(&vdev
->class_dev
,
359 &class_device_attr_brightness
);
360 class_device_remove_file(&vdev
->class_dev
,
361 &class_device_attr_saturation
);
362 class_device_remove_file(&vdev
->class_dev
,
363 &class_device_attr_streaming
);
364 class_device_remove_file(&vdev
->class_dev
,
365 &class_device_attr_compression
);
366 class_device_remove_file(&vdev
->class_dev
,
367 &class_device_attr_bridge
);
375 * This is part of Video 4 Linux API. The driver can be opened by one
376 * client only (checks internal counter 'usbvision->user'). The procedure
377 * then allocates buffers needed for video processing.
380 static int usbvision_v4l2_open(struct inode
*inode
, struct file
*file
)
382 struct video_device
*dev
= video_devdata(file
);
383 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
386 PDEBUG(DBG_IO
, "open");
389 usbvision_reset_powerOffTimer(usbvision
);
394 /* Allocate memory for the frame buffers */
395 errCode
= usbvision_frames_alloc(usbvision
);
397 /* Allocate memory for the scratch ring buffer */
398 errCode
= usbvision_scratch_alloc(usbvision
);
399 if ((!errCode
) && (isocMode
==ISOC_MODE_COMPRESS
)) {
400 /* Allocate intermediate decompression buffers only if needed */
401 errCode
= usbvision_decompress_alloc(usbvision
);
405 /* Deallocate all buffers if trouble */
406 usbvision_frames_free(usbvision
);
407 usbvision_scratch_free(usbvision
);
408 usbvision_decompress_free(usbvision
);
412 /* If so far no errors then we shall start the camera */
414 down(&usbvision
->lock
);
415 if (usbvision
->power
== 0) {
416 usbvision_power_on(usbvision
);
417 usbvision_init_i2c(usbvision
);
420 /* Send init sequence only once, it's large! */
421 if (!usbvision
->initialized
) {
423 setup_ok
= usbvision_setup(usbvision
,isocMode
);
425 usbvision
->initialized
= 1;
431 usbvision_begin_streaming(usbvision
);
432 errCode
= usbvision_init_isoc(usbvision
);
433 /* device needs to be initialized before isoc transfer */
434 usbvision_muxsel(usbvision
,0);
439 usbvision_i2c_usb_del_bus(&usbvision
->i2c_adap
);
440 usbvision_power_off(usbvision
);
441 usbvision
->initialized
= 0;
444 up(&usbvision
->lock
);
451 usbvision_empty_framequeues(usbvision
);
453 PDEBUG(DBG_IO
, "success");
458 * usbvision_v4l2_close()
460 * This is part of Video 4 Linux API. The procedure
461 * stops streaming and deallocates all buffers that were earlier
462 * allocated in usbvision_v4l2_open().
465 static int usbvision_v4l2_close(struct inode
*inode
, struct file
*file
)
467 struct video_device
*dev
= video_devdata(file
);
468 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
470 PDEBUG(DBG_IO
, "close");
471 down(&usbvision
->lock
);
473 usbvision_audio_off(usbvision
);
474 usbvision_restart_isoc(usbvision
);
475 usbvision_stop_isoc(usbvision
);
477 usbvision_decompress_free(usbvision
);
478 usbvision_frames_free(usbvision
);
479 usbvision_scratch_free(usbvision
);
484 /* power off in a little while to avoid off/on every close/open short sequences */
485 usbvision_set_powerOffTimer(usbvision
);
486 usbvision
->initialized
= 0;
489 up(&usbvision
->lock
);
491 if (usbvision
->remove_pending
) {
492 info("%s: Final disconnect", __FUNCTION__
);
493 usbvision_release(usbvision
);
496 PDEBUG(DBG_IO
, "success");
506 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
509 static int usbvision_v4l2_do_ioctl(struct inode
*inode
, struct file
*file
,
510 unsigned int cmd
, void *arg
)
512 struct video_device
*dev
= video_devdata(file
);
513 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
515 if (!USBVISION_IS_OPERATIONAL(usbvision
))
520 #ifdef CONFIG_VIDEO_ADV_DEBUG
521 /* ioctls to allow direct acces to the NT100x registers */
522 case VIDIOC_INT_G_REGISTER
:
524 struct v4l2_register
*reg
= arg
;
527 if (reg
->i2c_id
!= 0)
529 /* NT100x has a 8-bit register space */
530 errCode
= usbvision_read_reg(usbvision
, reg
->reg
&0xff);
532 err("%s: VIDIOC_INT_G_REGISTER failed: error %d", __FUNCTION__
, errCode
);
535 reg
->val
=(unsigned char)errCode
;
536 PDEBUG(DBG_IOCTL
, "VIDIOC_INT_G_REGISTER reg=0x%02X, value=0x%02X",
537 (unsigned int)reg
->reg
, reg
->val
);
538 errCode
= 0; // No error
542 case VIDIOC_INT_S_REGISTER
:
544 struct v4l2_register
*reg
= arg
;
547 if (reg
->i2c_id
!= 0)
549 if (!capable(CAP_SYS_ADMIN
))
551 errCode
= usbvision_write_reg(usbvision
, reg
->reg
&0xff, reg
->val
);
553 err("%s: VIDIOC_INT_S_REGISTER failed: error %d", __FUNCTION__
, errCode
);
556 PDEBUG(DBG_IOCTL
, "VIDIOC_INT_S_REGISTER reg=0x%02X, value=0x%02X",
557 (unsigned int)reg
->reg
, reg
->val
);
563 case VIDIOC_QUERYCAP
:
565 struct v4l2_capability
*vc
=arg
;
567 memset(vc
, 0, sizeof(*vc
));
568 strlcpy(vc
->driver
, "USBVision", sizeof(vc
->driver
));
569 strlcpy(vc
->card
, usbvision_device_data
[usbvision
->DevModel
].ModelString
,
571 strlcpy(vc
->bus_info
, usbvision
->dev
->dev
.bus_id
,
572 sizeof(vc
->bus_info
));
573 vc
->version
= USBVISION_DRIVER_VERSION
;
574 vc
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
|
578 (usbvision
->have_tuner
? V4L2_CAP_TUNER
: 0);
579 PDEBUG(DBG_IOCTL
, "VIDIOC_QUERYCAP");
582 case VIDIOC_ENUMINPUT
:
584 struct v4l2_input
*vi
= arg
;
587 if ((vi
->index
>= usbvision
->video_inputs
) || (vi
->index
< 0) )
589 if (usbvision
->have_tuner
) {
593 chan
= vi
->index
+ 1; //skip Television string
597 if (usbvision_device_data
[usbvision
->DevModel
].VideoChannels
== 4) {
598 strcpy(vi
->name
, "White Video Input");
601 strcpy(vi
->name
, "Television");
602 vi
->type
= V4L2_INPUT_TYPE_TUNER
;
605 vi
->std
= V4L2_STD_PAL
| V4L2_STD_NTSC
| V4L2_STD_SECAM
;
609 vi
->type
= V4L2_INPUT_TYPE_CAMERA
;
610 if (usbvision_device_data
[usbvision
->DevModel
].VideoChannels
== 4) {
611 strcpy(vi
->name
, "Green Video Input");
614 strcpy(vi
->name
, "Composite Video Input");
616 vi
->std
= V4L2_STD_PAL
;
619 vi
->type
= V4L2_INPUT_TYPE_CAMERA
;
620 if (usbvision_device_data
[usbvision
->DevModel
].VideoChannels
== 4) {
621 strcpy(vi
->name
, "Yellow Video Input");
624 strcpy(vi
->name
, "S-Video Input");
626 vi
->std
= V4L2_STD_PAL
;
629 vi
->type
= V4L2_INPUT_TYPE_CAMERA
;
630 strcpy(vi
->name
, "Red Video Input");
631 vi
->std
= V4L2_STD_PAL
;
634 PDEBUG(DBG_IOCTL
, "VIDIOC_ENUMINPUT name=%s:%d tuners=%d type=%d norm=%x",
635 vi
->name
, vi
->index
, vi
->tuner
,vi
->type
,(int)vi
->std
);
640 struct v4l2_standard
*e
= arg
;
647 ret
= v4l2_video_std_construct(e
, tvnorms
[e
->index
].id
,
648 tvnorms
[e
->index
].name
);
657 *input
= usbvision
->ctl_input
;
663 if ((*input
>= usbvision
->video_inputs
) || (*input
< 0) )
665 usbvision
->ctl_input
= *input
;
667 down(&usbvision
->lock
);
668 usbvision_muxsel(usbvision
, usbvision
->ctl_input
);
669 usbvision_set_input(usbvision
);
670 usbvision_set_output(usbvision
, usbvision
->curwidth
, usbvision
->curheight
);
671 up(&usbvision
->lock
);
676 v4l2_std_id
*id
= arg
;
678 *id
= usbvision
->tvnorm
->id
;
680 PDEBUG(DBG_IOCTL
, "VIDIOC_G_STD std_id=%s", usbvision
->tvnorm
->name
);
685 v4l2_std_id
*id
= arg
;
688 for (i
= 0; i
< TVNORMS
; i
++)
689 if (*id
== tvnorms
[i
].id
)
692 for (i
= 0; i
< TVNORMS
; i
++)
693 if (*id
& tvnorms
[i
].id
)
698 down(&usbvision
->lock
);
699 usbvision
->tvnorm
= &tvnorms
[i
];
701 call_i2c_clients(usbvision
, VIDIOC_S_STD
,
702 &usbvision
->tvnorm
->id
);
704 up(&usbvision
->lock
);
706 PDEBUG(DBG_IOCTL
, "VIDIOC_S_STD std_id=%s", usbvision
->tvnorm
->name
);
711 struct v4l2_tuner
*vt
= arg
;
713 if (!usbvision
->have_tuner
|| vt
->index
) // Only tuner 0
715 strcpy(vt
->name
, "Television");
716 /* Let clients fill in the remainder of this struct */
717 call_i2c_clients(usbvision
,VIDIOC_G_TUNER
,vt
);
719 PDEBUG(DBG_IOCTL
, "VIDIOC_G_TUNER signal=%x, afc=%x",vt
->signal
,vt
->afc
);
724 struct v4l2_tuner
*vt
= arg
;
726 // Only no or one tuner for now
727 if (!usbvision
->have_tuner
|| vt
->index
)
729 /* let clients handle this */
730 call_i2c_clients(usbvision
,VIDIOC_S_TUNER
,vt
);
732 PDEBUG(DBG_IOCTL
, "VIDIOC_S_TUNER");
735 case VIDIOC_G_FREQUENCY
:
737 struct v4l2_frequency
*freq
= arg
;
739 freq
->tuner
= 0; // Only one tuner
740 freq
->type
= V4L2_TUNER_ANALOG_TV
;
741 freq
->frequency
= usbvision
->freq
;
742 PDEBUG(DBG_IOCTL
, "VIDIOC_G_FREQUENCY freq=0x%X", (unsigned)freq
->frequency
);
745 case VIDIOC_S_FREQUENCY
:
747 struct v4l2_frequency
*freq
= arg
;
749 // Only no or one tuner for now
750 if (!usbvision
->have_tuner
|| freq
->tuner
)
753 usbvision
->freq
= freq
->frequency
;
754 call_i2c_clients(usbvision
, cmd
, freq
);
755 PDEBUG(DBG_IOCTL
, "VIDIOC_S_FREQUENCY freq=0x%X", (unsigned)freq
->frequency
);
760 struct v4l2_audio
*v
= arg
;
761 memset(v
,0, sizeof(v
));
762 strcpy(v
->name
, "TV");
763 PDEBUG(DBG_IOCTL
, "VIDIOC_G_AUDIO");
768 struct v4l2_audio
*v
= arg
;
772 PDEBUG(DBG_IOCTL
, "VIDIOC_S_AUDIO");
775 case VIDIOC_QUERYCTRL
:
777 struct v4l2_queryctrl
*ctrl
= arg
;
780 memset(ctrl
,0,sizeof(*ctrl
));
783 call_i2c_clients(usbvision
, cmd
, arg
);
790 PDEBUG(DBG_IOCTL
,"VIDIOC_QUERYCTRL id=%x value=%x",ctrl
->id
,ctrl
->type
);
794 struct v4l2_control
*ctrl
= arg
;
795 PDEBUG(DBG_IOCTL
,"VIDIOC_G_CTRL id=%x value=%x",ctrl
->id
,ctrl
->value
);
796 call_i2c_clients(usbvision
, VIDIOC_G_CTRL
, ctrl
);
801 struct v4l2_control
*ctrl
= arg
;
803 PDEBUG(DBG_IOCTL
, "VIDIOC_S_CTRL id=%x value=%x",ctrl
->id
,ctrl
->value
);
804 call_i2c_clients(usbvision
, VIDIOC_S_CTRL
, ctrl
);
809 struct v4l2_requestbuffers
*vr
= arg
;
812 RESTRICT_TO_RANGE(vr
->count
,1,USBVISION_NUMFRAMES
);
814 // Check input validity : the user must do a VIDEO CAPTURE and MMAP method.
815 if((vr
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) ||
816 (vr
->memory
!= V4L2_MEMORY_MMAP
))
819 if(usbvision
->streaming
== Stream_On
) {
820 if ((ret
= usbvision_stream_interrupt(usbvision
)))
824 usbvision_empty_framequeues(usbvision
);
826 usbvision
->curFrame
= NULL
;
828 PDEBUG(DBG_IOCTL
, "VIDIOC_REQBUFS count=%d",vr
->count
);
831 case VIDIOC_QUERYBUF
:
833 struct v4l2_buffer
*vb
= arg
;
834 struct usbvision_frame
*frame
;
836 // FIXME : must control that buffers are mapped (VIDIOC_REQBUFS has been called)
838 if(vb
->type
!= V4L2_CAP_VIDEO_CAPTURE
) {
841 if(vb
->index
>=USBVISION_NUMFRAMES
) {
844 // Updating the corresponding frame state
846 frame
= &usbvision
->frame
[vb
->index
];
847 if(frame
->grabstate
>= FrameState_Ready
)
848 vb
->flags
|= V4L2_BUF_FLAG_QUEUED
;
849 if(frame
->grabstate
>= FrameState_Done
)
850 vb
->flags
|= V4L2_BUF_FLAG_DONE
;
851 if(frame
->grabstate
== FrameState_Unused
)
852 vb
->flags
|= V4L2_BUF_FLAG_MAPPED
;
853 vb
->memory
= V4L2_MEMORY_MMAP
;
855 vb
->m
.offset
= vb
->index
*usbvision
->max_frame_size
;
857 vb
->memory
= V4L2_MEMORY_MMAP
;
858 vb
->field
= V4L2_FIELD_NONE
;
859 vb
->length
= usbvision
->curwidth
*usbvision
->curheight
*usbvision
->palette
.bytes_per_pixel
;
860 vb
->timestamp
= usbvision
->frame
[vb
->index
].timestamp
;
861 vb
->sequence
= usbvision
->frame
[vb
->index
].sequence
;
866 struct v4l2_buffer
*vb
= arg
;
867 struct usbvision_frame
*frame
;
868 unsigned long lock_flags
;
870 // FIXME : works only on VIDEO_CAPTURE MODE, MMAP.
871 if(vb
->type
!= V4L2_CAP_VIDEO_CAPTURE
) {
874 if(vb
->index
>=USBVISION_NUMFRAMES
) {
878 frame
= &usbvision
->frame
[vb
->index
];
880 if (frame
->grabstate
!= FrameState_Unused
) {
884 /* Mark it as ready and enqueue frame */
885 frame
->grabstate
= FrameState_Ready
;
886 frame
->scanstate
= ScanState_Scanning
;
887 frame
->scanlength
= 0; /* Accumulated in usbvision_parse_data() */
889 vb
->flags
&= ~V4L2_BUF_FLAG_DONE
;
891 /* set v4l2_format index */
892 frame
->v4l2_format
= usbvision
->palette
;
894 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
895 list_add_tail(&usbvision
->frame
[vb
->index
].frame
, &usbvision
->inqueue
);
896 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
898 PDEBUG(DBG_IOCTL
, "VIDIOC_QBUF frame #%d",vb
->index
);
903 struct v4l2_buffer
*vb
= arg
;
905 struct usbvision_frame
*f
;
906 unsigned long lock_flags
;
908 if (vb
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
911 if (list_empty(&(usbvision
->outqueue
))) {
912 if (usbvision
->streaming
== Stream_Idle
)
914 ret
= wait_event_interruptible
915 (usbvision
->wait_frame
,
916 !list_empty(&(usbvision
->outqueue
)));
921 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
922 f
= list_entry(usbvision
->outqueue
.next
,
923 struct usbvision_frame
, frame
);
924 list_del(usbvision
->outqueue
.next
);
925 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
927 f
->grabstate
= FrameState_Unused
;
929 vb
->memory
= V4L2_MEMORY_MMAP
;
930 vb
->flags
= V4L2_BUF_FLAG_MAPPED
| V4L2_BUF_FLAG_QUEUED
| V4L2_BUF_FLAG_DONE
;
931 vb
->index
= f
->index
;
932 vb
->sequence
= f
->sequence
;
933 vb
->timestamp
= f
->timestamp
;
934 vb
->field
= V4L2_FIELD_NONE
;
935 vb
->bytesused
= f
->scanlength
;
939 case VIDIOC_STREAMON
:
941 int b
=V4L2_BUF_TYPE_VIDEO_CAPTURE
;
943 usbvision
->streaming
= Stream_On
;
945 call_i2c_clients(usbvision
,VIDIOC_STREAMON
, &b
);
947 PDEBUG(DBG_IOCTL
, "VIDIOC_STREAMON");
951 case VIDIOC_STREAMOFF
:
954 int b
=V4L2_BUF_TYPE_VIDEO_CAPTURE
;
956 if (*type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
959 if(usbvision
->streaming
== Stream_On
) {
960 usbvision_stream_interrupt(usbvision
);
961 // Stop all video streamings
962 call_i2c_clients(usbvision
,VIDIOC_STREAMOFF
, &b
);
964 usbvision_empty_framequeues(usbvision
);
966 PDEBUG(DBG_IOCTL
, "VIDIOC_STREAMOFF");
969 case VIDIOC_ENUM_FMT
:
971 struct v4l2_fmtdesc
*vfd
= arg
;
973 if(vfd
->index
>=USBVISION_SUPPORTED_PALETTES
-1) {
977 vfd
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
978 strcpy(vfd
->description
,usbvision_v4l2_format
[vfd
->index
].desc
);
979 vfd
->pixelformat
= usbvision_v4l2_format
[vfd
->index
].format
;
980 memset(vfd
->reserved
, 0, sizeof(vfd
->reserved
));
985 struct v4l2_format
*vf
= arg
;
988 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
990 vf
->fmt
.pix
.width
= usbvision
->curwidth
;
991 vf
->fmt
.pix
.height
= usbvision
->curheight
;
992 vf
->fmt
.pix
.pixelformat
= usbvision
->palette
.format
;
993 vf
->fmt
.pix
.bytesperline
= usbvision
->curwidth
*usbvision
->palette
.bytes_per_pixel
;
994 vf
->fmt
.pix
.sizeimage
= vf
->fmt
.pix
.bytesperline
*usbvision
->curheight
;
995 vf
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
996 vf
->fmt
.pix
.field
= V4L2_FIELD_NONE
; /* Always progressive image */
997 PDEBUG(DBG_IOCTL
, "VIDIOC_G_FMT w=%d, h=%d, format=%s",
998 vf
->fmt
.pix
.width
, vf
->fmt
.pix
.height
,usbvision
->palette
.desc
);
1002 PDEBUG(DBG_IOCTL
, "VIDIOC_G_FMT invalid type %d",vf
->type
);
1007 case VIDIOC_TRY_FMT
:
1010 struct v4l2_format
*vf
= arg
;
1014 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1016 /* Find requested format in available ones */
1017 for(formatIdx
=0;formatIdx
<USBVISION_SUPPORTED_PALETTES
;formatIdx
++) {
1018 if(vf
->fmt
.pix
.pixelformat
== usbvision_v4l2_format
[formatIdx
].format
) {
1019 usbvision
->palette
= usbvision_v4l2_format
[formatIdx
];
1024 if(formatIdx
== USBVISION_SUPPORTED_PALETTES
) {
1027 RESTRICT_TO_RANGE(vf
->fmt
.pix
.width
, MIN_FRAME_WIDTH
, MAX_FRAME_WIDTH
);
1028 RESTRICT_TO_RANGE(vf
->fmt
.pix
.height
, MIN_FRAME_HEIGHT
, MAX_FRAME_HEIGHT
);
1030 vf
->fmt
.pix
.bytesperline
= vf
->fmt
.pix
.width
*usbvision
->palette
.bytes_per_pixel
;
1031 vf
->fmt
.pix
.sizeimage
= vf
->fmt
.pix
.bytesperline
*vf
->fmt
.pix
.height
;
1033 if(cmd
== VIDIOC_TRY_FMT
) {
1034 PDEBUG(DBG_IOCTL
, "VIDIOC_TRY_FMT grabdisplay w=%d, h=%d, format=%s",
1035 vf
->fmt
.pix
.width
, vf
->fmt
.pix
.height
,usbvision
->palette
.desc
);
1039 /* stop io in case it is already in progress */
1040 if(usbvision
->streaming
== Stream_On
) {
1041 if ((ret
= usbvision_stream_interrupt(usbvision
)))
1044 usbvision_empty_framequeues(usbvision
);
1046 usbvision
->curFrame
= NULL
;
1048 // by now we are committed to the new data...
1049 down(&usbvision
->lock
);
1050 usbvision_set_output(usbvision
, vf
->fmt
.pix
.width
, vf
->fmt
.pix
.height
);
1051 up(&usbvision
->lock
);
1053 PDEBUG(DBG_IOCTL
, "VIDIOC_S_FMT grabdisplay w=%d, h=%d, format=%s",
1054 vf
->fmt
.pix
.width
, vf
->fmt
.pix
.height
,usbvision
->palette
.desc
);
1062 return -ENOIOCTLCMD
;
1067 static int usbvision_v4l2_ioctl(struct inode
*inode
, struct file
*file
,
1068 unsigned int cmd
, unsigned long arg
)
1070 return video_usercopy(inode
, file
, cmd
, arg
, usbvision_v4l2_do_ioctl
);
1074 static ssize_t
usbvision_v4l2_read(struct file
*file
, char __user
*buf
,
1075 size_t count
, loff_t
*ppos
)
1077 struct video_device
*dev
= video_devdata(file
);
1078 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
1079 int noblock
= file
->f_flags
& O_NONBLOCK
;
1080 unsigned long lock_flags
;
1083 struct usbvision_frame
*frame
;
1085 PDEBUG(DBG_IO
, "%s: %ld bytes, noblock=%d", __FUNCTION__
, (unsigned long)count
, noblock
);
1087 if (!USBVISION_IS_OPERATIONAL(usbvision
) || (buf
== NULL
))
1090 /* no stream is running, make it running ! */
1091 usbvision
->streaming
= Stream_On
;
1092 call_i2c_clients(usbvision
,VIDIOC_STREAMON
, NULL
);
1094 /* First, enqueue as many frames as possible (like a user of VIDIOC_QBUF would do) */
1095 for(i
=0;i
<USBVISION_NUMFRAMES
;i
++) {
1096 frame
= &usbvision
->frame
[i
];
1097 if(frame
->grabstate
== FrameState_Unused
) {
1098 /* Mark it as ready and enqueue frame */
1099 frame
->grabstate
= FrameState_Ready
;
1100 frame
->scanstate
= ScanState_Scanning
;
1101 frame
->scanlength
= 0; /* Accumulated in usbvision_parse_data() */
1103 /* set v4l2_format index */
1104 frame
->v4l2_format
= usbvision
->palette
;
1106 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
1107 list_add_tail(&frame
->frame
, &usbvision
->inqueue
);
1108 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
1112 /* Then try to steal a frame (like a VIDIOC_DQBUF would do) */
1113 if (list_empty(&(usbvision
->outqueue
))) {
1117 ret
= wait_event_interruptible
1118 (usbvision
->wait_frame
,
1119 !list_empty(&(usbvision
->outqueue
)));
1124 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
1125 frame
= list_entry(usbvision
->outqueue
.next
,
1126 struct usbvision_frame
, frame
);
1127 list_del(usbvision
->outqueue
.next
);
1128 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
1130 /* An error returns an empty frame */
1131 if (frame
->grabstate
== FrameState_Error
) {
1132 frame
->bytes_read
= 0;
1136 PDEBUG(DBG_IO
, "%s: frmx=%d, bytes_read=%ld, scanlength=%ld", __FUNCTION__
,
1137 frame
->index
, frame
->bytes_read
, frame
->scanlength
);
1139 /* copy bytes to user space; we allow for partials reads */
1140 if ((count
+ frame
->bytes_read
) > (unsigned long)frame
->scanlength
)
1141 count
= frame
->scanlength
- frame
->bytes_read
;
1143 if (copy_to_user(buf
, frame
->data
+ frame
->bytes_read
, count
)) {
1147 frame
->bytes_read
+= count
;
1148 PDEBUG(DBG_IO
, "%s: {copy} count used=%ld, new bytes_read=%ld", __FUNCTION__
,
1149 (unsigned long)count
, frame
->bytes_read
);
1151 // For now, forget the frame if it has not been read in one shot.
1152 /* if (frame->bytes_read >= frame->scanlength) {// All data has been read */
1153 frame
->bytes_read
= 0;
1155 /* Mark it as available to be used again. */
1156 frame
->grabstate
= FrameState_Unused
;
1162 static int usbvision_v4l2_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1164 unsigned long size
= vma
->vm_end
- vma
->vm_start
,
1165 start
= vma
->vm_start
;
1169 struct video_device
*dev
= video_devdata(file
);
1170 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
1172 down(&usbvision
->lock
);
1174 if (!USBVISION_IS_OPERATIONAL(usbvision
)) {
1175 up(&usbvision
->lock
);
1179 if (!(vma
->vm_flags
& VM_WRITE
) ||
1180 size
!= PAGE_ALIGN(usbvision
->curwidth
*usbvision
->curheight
*usbvision
->palette
.bytes_per_pixel
)) {
1181 up(&usbvision
->lock
);
1185 for (i
= 0; i
< USBVISION_NUMFRAMES
; i
++) {
1186 if (((usbvision
->max_frame_size
*i
) >> PAGE_SHIFT
) == vma
->vm_pgoff
)
1189 if (i
== USBVISION_NUMFRAMES
) {
1190 PDEBUG(DBG_MMAP
, "mmap: user supplied mapping address is out of range");
1191 up(&usbvision
->lock
);
1195 /* VM_IO is eventually going to replace PageReserved altogether */
1196 vma
->vm_flags
|= VM_IO
;
1197 vma
->vm_flags
|= VM_RESERVED
; /* avoid to swap out this VMA */
1199 pos
= usbvision
->frame
[i
].data
;
1202 if (vm_insert_page(vma
, start
, vmalloc_to_page(pos
))) {
1203 PDEBUG(DBG_MMAP
, "mmap: vm_insert_page failed");
1204 up(&usbvision
->lock
);
1212 up(&usbvision
->lock
);
1218 * Here comes the stuff for radio on usbvision based devices
1221 static int usbvision_radio_open(struct inode
*inode
, struct file
*file
)
1223 struct video_device
*dev
= video_devdata(file
);
1224 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
1225 struct v4l2_frequency freq
;
1228 PDEBUG(DBG_IO
, "%s:", __FUNCTION__
);
1230 down(&usbvision
->lock
);
1232 if (usbvision
->user
) {
1233 err("%s: Someone tried to open an already opened USBVision Radio!", __FUNCTION__
);
1238 usbvision_reset_powerOffTimer(usbvision
);
1239 if (usbvision
->power
== 0) {
1240 usbvision_power_on(usbvision
);
1241 usbvision_init_i2c(usbvision
);
1245 // If so far no errors then we shall start the radio
1246 usbvision
->radio
= 1;
1247 call_i2c_clients(usbvision
,AUDC_SET_RADIO
,&usbvision
->tuner_type
);
1248 freq
.frequency
= 1517; //SWR3 @ 94.8MHz
1249 call_i2c_clients(usbvision
, VIDIOC_S_FREQUENCY
, &freq
);
1250 usbvision_set_audio(usbvision
, USBVISION_AUDIO_RADIO
);
1255 if (PowerOnAtOpen
) {
1256 usbvision_i2c_usb_del_bus(&usbvision
->i2c_adap
);
1257 usbvision_power_off(usbvision
);
1258 usbvision
->initialized
= 0;
1261 up(&usbvision
->lock
);
1266 static int usbvision_radio_close(struct inode
*inode
, struct file
*file
)
1268 struct video_device
*dev
= video_devdata(file
);
1269 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
1274 down(&usbvision
->lock
);
1276 usbvision_audio_off(usbvision
);
1280 if (PowerOnAtOpen
) {
1281 usbvision_set_powerOffTimer(usbvision
);
1282 usbvision
->initialized
= 0;
1285 up(&usbvision
->lock
);
1287 if (usbvision
->remove_pending
) {
1288 info("%s: Final disconnect", __FUNCTION__
);
1289 usbvision_release(usbvision
);
1293 PDEBUG(DBG_IO
, "success");
1298 static int usbvision_do_radio_ioctl(struct inode
*inode
, struct file
*file
,
1299 unsigned int cmd
, void *arg
)
1301 struct video_device
*dev
= video_devdata(file
);
1302 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*) video_get_drvdata(dev
);
1304 if (!USBVISION_IS_OPERATIONAL(usbvision
))
1308 case VIDIOC_QUERYCAP
:
1310 struct v4l2_capability
*vc
=arg
;
1312 memset(vc
, 0, sizeof(*vc
));
1313 strlcpy(vc
->driver
, "USBVision", sizeof(vc
->driver
));
1314 strlcpy(vc
->card
, usbvision_device_data
[usbvision
->DevModel
].ModelString
,
1316 strlcpy(vc
->bus_info
, usbvision
->dev
->dev
.bus_id
,
1317 sizeof(vc
->bus_info
));
1318 vc
->version
= USBVISION_DRIVER_VERSION
;
1319 vc
->capabilities
= (usbvision
->have_tuner
? V4L2_CAP_TUNER
: 0);
1320 PDEBUG(DBG_IO
, "VIDIOC_QUERYCAP");
1323 case VIDIOC_QUERYCTRL
:
1325 struct v4l2_queryctrl
*ctrl
= arg
;
1328 memset(ctrl
,0,sizeof(*ctrl
));
1331 call_i2c_clients(usbvision
, cmd
, arg
);
1332 PDEBUG(DBG_IO
,"VIDIOC_QUERYCTRL id=%x value=%x",ctrl
->id
,ctrl
->type
);
1342 struct v4l2_control
*ctrl
= arg
;
1344 call_i2c_clients(usbvision
, VIDIOC_G_CTRL
, ctrl
);
1345 PDEBUG(DBG_IO
,"VIDIOC_G_CTRL id=%x value=%x",ctrl
->id
,ctrl
->value
);
1350 struct v4l2_control
*ctrl
= arg
;
1352 call_i2c_clients(usbvision
, VIDIOC_S_CTRL
, ctrl
);
1353 PDEBUG(DBG_IO
, "VIDIOC_S_CTRL id=%x value=%x",ctrl
->id
,ctrl
->value
);
1356 case VIDIOC_G_TUNER
:
1358 struct v4l2_tuner
*t
= arg
;
1363 memset(t
,0,sizeof(*t
));
1364 strcpy(t
->name
, "Radio");
1365 t
->type
= V4L2_TUNER_RADIO
;
1367 /* Let clients fill in the remainder of this struct */
1368 call_i2c_clients(usbvision
,VIDIOC_G_TUNER
,t
);
1369 PDEBUG(DBG_IO
, "VIDIOC_G_TUNER signal=%x, afc=%x",t
->signal
,t
->afc
);
1372 case VIDIOC_S_TUNER
:
1374 struct v4l2_tuner
*vt
= arg
;
1376 // Only no or one tuner for now
1377 if (!usbvision
->have_tuner
|| vt
->index
)
1379 /* let clients handle this */
1380 call_i2c_clients(usbvision
,VIDIOC_S_TUNER
,vt
);
1382 PDEBUG(DBG_IO
, "VIDIOC_S_TUNER");
1385 case VIDIOC_G_AUDIO
:
1387 struct v4l2_audio
*a
= arg
;
1389 memset(a
,0,sizeof(*a
));
1390 strcpy(a
->name
,"Radio");
1391 PDEBUG(DBG_IO
, "VIDIOC_G_AUDIO");
1394 case VIDIOC_S_AUDIO
:
1395 case VIDIOC_S_INPUT
:
1399 case VIDIOC_G_FREQUENCY
:
1401 struct v4l2_frequency
*f
= arg
;
1403 memset(f
,0,sizeof(*f
));
1405 f
->type
= V4L2_TUNER_RADIO
;
1406 f
->frequency
= usbvision
->freq
;
1407 call_i2c_clients(usbvision
, cmd
, f
);
1408 PDEBUG(DBG_IO
, "VIDIOC_G_FREQUENCY freq=0x%X", (unsigned)f
->frequency
);
1412 case VIDIOC_S_FREQUENCY
:
1414 struct v4l2_frequency
*f
= arg
;
1418 usbvision
->freq
= f
->frequency
;
1419 call_i2c_clients(usbvision
, cmd
, f
);
1420 PDEBUG(DBG_IO
, "VIDIOC_S_FREQUENCY freq=0x%X", (unsigned)f
->frequency
);
1426 PDEBUG(DBG_IO
, "%s: Unknown command %x", __FUNCTION__
, cmd
);
1427 return -ENOIOCTLCMD
;
1434 static int usbvision_radio_ioctl(struct inode
*inode
, struct file
*file
,
1435 unsigned int cmd
, unsigned long arg
)
1437 return video_usercopy(inode
, file
, cmd
, arg
, usbvision_do_radio_ioctl
);
1442 * Here comes the stuff for vbi on usbvision based devices
1445 static int usbvision_vbi_open(struct inode
*inode
, struct file
*file
)
1452 static int usbvision_vbi_close(struct inode
*inode
, struct file
*file
)
1458 static int usbvision_do_vbi_ioctl(struct inode
*inode
, struct file
*file
,
1459 unsigned int cmd
, void *arg
)
1465 static int usbvision_vbi_ioctl(struct inode
*inode
, struct file
*file
,
1466 unsigned int cmd
, unsigned long arg
)
1468 return video_usercopy(inode
, file
, cmd
, arg
, usbvision_do_vbi_ioctl
);
1473 // Video registration stuff
1477 static const struct file_operations usbvision_fops
= {
1478 .owner
= THIS_MODULE
,
1479 .open
= usbvision_v4l2_open
,
1480 .release
= usbvision_v4l2_close
,
1481 .read
= usbvision_v4l2_read
,
1482 .mmap
= usbvision_v4l2_mmap
,
1483 .ioctl
= usbvision_v4l2_ioctl
,
1484 .llseek
= no_llseek
,
1486 static struct video_device usbvision_video_template
= {
1487 .owner
= THIS_MODULE
,
1488 .type
= VID_TYPE_TUNER
| VID_TYPE_CAPTURE
,
1489 .hardware
= VID_HARDWARE_USBVISION
,
1490 .fops
= &usbvision_fops
,
1491 .name
= "usbvision-video",
1492 .release
= video_device_release
,
1498 static const struct file_operations usbvision_radio_fops
= {
1499 .owner
= THIS_MODULE
,
1500 .open
= usbvision_radio_open
,
1501 .release
= usbvision_radio_close
,
1502 .ioctl
= usbvision_radio_ioctl
,
1503 .llseek
= no_llseek
,
1506 static struct video_device usbvision_radio_template
=
1508 .owner
= THIS_MODULE
,
1509 .type
= VID_TYPE_TUNER
,
1510 .hardware
= VID_HARDWARE_USBVISION
,
1511 .fops
= &usbvision_radio_fops
,
1512 .release
= video_device_release
,
1513 .name
= "usbvision-radio",
1519 static const struct file_operations usbvision_vbi_fops
= {
1520 .owner
= THIS_MODULE
,
1521 .open
= usbvision_vbi_open
,
1522 .release
= usbvision_vbi_close
,
1523 .ioctl
= usbvision_vbi_ioctl
,
1524 .llseek
= no_llseek
,
1527 static struct video_device usbvision_vbi_template
=
1529 .owner
= THIS_MODULE
,
1530 .type
= VID_TYPE_TUNER
,
1531 .hardware
= VID_HARDWARE_USBVISION
,
1532 .fops
= &usbvision_vbi_fops
,
1533 .release
= video_device_release
,
1534 .name
= "usbvision-vbi",
1539 static struct video_device
*usbvision_vdev_init(struct usb_usbvision
*usbvision
,
1540 struct video_device
*vdev_template
,
1543 struct usb_device
*usb_dev
= usbvision
->dev
;
1544 struct video_device
*vdev
;
1546 if (usb_dev
== NULL
) {
1547 err("%s: usbvision->dev is not set", __FUNCTION__
);
1551 vdev
= video_device_alloc();
1555 *vdev
= *vdev_template
;
1556 // vdev->minor = -1;
1557 vdev
->dev
= &usb_dev
->dev
;
1558 snprintf(vdev
->name
, sizeof(vdev
->name
), "%s", name
);
1559 video_set_drvdata(vdev
, usbvision
);
1563 // unregister video4linux devices
1564 static void usbvision_unregister_video(struct usb_usbvision
*usbvision
)
1567 if (usbvision
->vbi
) {
1568 PDEBUG(DBG_PROBE
, "unregister /dev/vbi%d [v4l2]", usbvision
->vbi
->minor
& 0x1f);
1569 if (usbvision
->vbi
->minor
!= -1) {
1570 video_unregister_device(usbvision
->vbi
);
1573 video_device_release(usbvision
->vbi
);
1575 usbvision
->vbi
= NULL
;
1579 if (usbvision
->rdev
) {
1580 PDEBUG(DBG_PROBE
, "unregister /dev/radio%d [v4l2]", usbvision
->rdev
->minor
& 0x1f);
1581 if (usbvision
->rdev
->minor
!= -1) {
1582 video_unregister_device(usbvision
->rdev
);
1585 video_device_release(usbvision
->rdev
);
1587 usbvision
->rdev
= NULL
;
1591 if (usbvision
->vdev
) {
1592 PDEBUG(DBG_PROBE
, "unregister /dev/video%d [v4l2]", usbvision
->vdev
->minor
& 0x1f);
1593 if (usbvision
->vdev
->minor
!= -1) {
1594 video_unregister_device(usbvision
->vdev
);
1597 video_device_release(usbvision
->vdev
);
1599 usbvision
->vdev
= NULL
;
1603 // register video4linux devices
1604 static int __devinit
usbvision_register_video(struct usb_usbvision
*usbvision
)
1607 usbvision
->vdev
= usbvision_vdev_init(usbvision
, &usbvision_video_template
, "USBVision Video");
1608 if (usbvision
->vdev
== NULL
) {
1611 if (video_register_device(usbvision
->vdev
, VFL_TYPE_GRABBER
, video_nr
)<0) {
1614 info("USBVision[%d]: registered USBVision Video device /dev/video%d [v4l2]", usbvision
->nr
,usbvision
->vdev
->minor
& 0x1f);
1617 if (usbvision_device_data
[usbvision
->DevModel
].Radio
) {
1618 // usbvision has radio
1619 usbvision
->rdev
= usbvision_vdev_init(usbvision
, &usbvision_radio_template
, "USBVision Radio");
1620 if (usbvision
->rdev
== NULL
) {
1623 if (video_register_device(usbvision
->rdev
, VFL_TYPE_RADIO
, radio_nr
)<0) {
1626 info("USBVision[%d]: registered USBVision Radio device /dev/radio%d [v4l2]", usbvision
->nr
, usbvision
->rdev
->minor
& 0x1f);
1629 if (usbvision_device_data
[usbvision
->DevModel
].vbi
) {
1630 usbvision
->vbi
= usbvision_vdev_init(usbvision
, &usbvision_vbi_template
, "USBVision VBI");
1631 if (usbvision
->vdev
== NULL
) {
1634 if (video_register_device(usbvision
->vbi
, VFL_TYPE_VBI
, vbi_nr
)<0) {
1637 info("USBVision[%d]: registered USBVision VBI device /dev/vbi%d [v4l2] (Not Working Yet!)", usbvision
->nr
,usbvision
->vbi
->minor
& 0x1f);
1643 err("USBVision[%d]: video_register_device() failed", usbvision
->nr
);
1644 usbvision_unregister_video(usbvision
);
1651 * This code allocates the struct usb_usbvision. It is filled with default values.
1653 * Returns NULL on error, a pointer to usb_usbvision else.
1656 static struct usb_usbvision
*usbvision_alloc(struct usb_device
*dev
)
1658 struct usb_usbvision
*usbvision
;
1660 if ((usbvision
= kzalloc(sizeof(struct usb_usbvision
), GFP_KERNEL
)) == NULL
) {
1664 usbvision
->dev
= dev
;
1666 init_MUTEX(&usbvision
->lock
); /* to 1 == available */
1668 // prepare control urb for control messages during interrupts
1669 usbvision
->ctrlUrb
= usb_alloc_urb(USBVISION_URB_FRAMES
, GFP_KERNEL
);
1670 if (usbvision
->ctrlUrb
== NULL
) {
1673 init_waitqueue_head(&usbvision
->ctrlUrb_wq
);
1674 init_MUTEX(&usbvision
->ctrlUrbLock
); /* to 1 == available */
1676 usbvision_init_powerOffTimer(usbvision
);
1681 if (usbvision
&& usbvision
->ctrlUrb
) {
1682 usb_free_urb(usbvision
->ctrlUrb
);
1691 * usbvision_release()
1693 * This code does final release of struct usb_usbvision. This happens
1694 * after the device is disconnected -and- all clients closed their files.
1697 static void usbvision_release(struct usb_usbvision
*usbvision
)
1699 PDEBUG(DBG_PROBE
, "");
1701 down(&usbvision
->lock
);
1703 usbvision_reset_powerOffTimer(usbvision
);
1705 usbvision
->initialized
= 0;
1707 up(&usbvision
->lock
);
1709 usbvision_remove_sysfs(usbvision
->vdev
);
1710 usbvision_unregister_video(usbvision
);
1712 if (usbvision
->ctrlUrb
) {
1713 usb_free_urb(usbvision
->ctrlUrb
);
1718 PDEBUG(DBG_PROBE
, "success");
1722 /******************************** usb interface *****************************************/
1724 static void usbvision_configure_video(struct usb_usbvision
*usbvision
)
1728 if (usbvision
== NULL
)
1731 model
= usbvision
->DevModel
;
1732 usbvision
->palette
= usbvision_v4l2_format
[2]; // V4L2_PIX_FMT_RGB24;
1734 if (usbvision_device_data
[usbvision
->DevModel
].Vin_Reg2
>= 0) {
1735 usbvision
->Vin_Reg2_Preset
= usbvision_device_data
[usbvision
->DevModel
].Vin_Reg2
& 0xff;
1737 usbvision
->Vin_Reg2_Preset
= 0;
1740 for (i
= 0; i
< TVNORMS
; i
++)
1741 if (usbvision_device_data
[model
].VideoNorm
== tvnorms
[i
].mode
)
1745 usbvision
->tvnorm
= &tvnorms
[i
]; /* set default norm */
1747 usbvision
->video_inputs
= usbvision_device_data
[model
].VideoChannels
;
1748 usbvision
->ctl_input
= 0;
1750 /* This should be here to make i2c clients to be able to register */
1751 usbvision_audio_off(usbvision
); //first switch off audio
1752 if (!PowerOnAtOpen
) {
1753 usbvision_power_on(usbvision
); //and then power up the noisy tuner
1754 usbvision_init_i2c(usbvision
);
1761 * This procedure queries device descriptor and accepts the interface
1762 * if it looks like USBVISION video device
1765 static int __devinit
usbvision_probe(struct usb_interface
*intf
, const struct usb_device_id
*devid
)
1767 struct usb_device
*dev
= interface_to_usbdev(intf
);
1768 __u8 ifnum
= intf
->altsetting
->desc
.bInterfaceNumber
;
1769 const struct usb_host_interface
*interface
;
1770 struct usb_usbvision
*usbvision
= NULL
;
1771 const struct usb_endpoint_descriptor
*endpoint
;
1774 PDEBUG(DBG_PROBE
, "VID=%#04x, PID=%#04x, ifnum=%u",
1775 dev
->descriptor
.idVendor
, dev
->descriptor
.idProduct
, ifnum
);
1776 /* Is it an USBVISION video dev? */
1778 for(model
= 0; usbvision_device_data
[model
].idVendor
; model
++) {
1779 if (le16_to_cpu(dev
->descriptor
.idVendor
) != usbvision_device_data
[model
].idVendor
) {
1782 if (le16_to_cpu(dev
->descriptor
.idProduct
) != usbvision_device_data
[model
].idProduct
) {
1786 info("%s: %s found", __FUNCTION__
, usbvision_device_data
[model
].ModelString
);
1790 if (usbvision_device_data
[model
].idVendor
== 0) {
1791 return -ENODEV
; //no matching device
1793 if (usbvision_device_data
[model
].Interface
>= 0) {
1794 interface
= &dev
->actconfig
->interface
[usbvision_device_data
[model
].Interface
]->altsetting
[0];
1797 interface
= &dev
->actconfig
->interface
[ifnum
]->altsetting
[0];
1799 endpoint
= &interface
->endpoint
[1].desc
;
1800 if ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) != USB_ENDPOINT_XFER_ISOC
) {
1801 err("%s: interface %d. has non-ISO endpoint!", __FUNCTION__
, ifnum
);
1802 err("%s: Endpoint attribures %d", __FUNCTION__
, endpoint
->bmAttributes
);
1805 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) == USB_DIR_OUT
) {
1806 err("%s: interface %d. has ISO OUT endpoint!", __FUNCTION__
, ifnum
);
1812 if ((usbvision
= usbvision_alloc(dev
)) == NULL
) {
1813 err("%s: couldn't allocate USBVision struct", __FUNCTION__
);
1816 if (dev
->descriptor
.bNumConfigurations
> 1) {
1817 usbvision
->bridgeType
= BRIDGE_NT1004
;
1819 else if (usbvision_device_data
[model
].ModelString
== "Dazzle Fusion Model DVC-90 Rev 1 (SECAM)") {
1820 usbvision
->bridgeType
= BRIDGE_NT1005
;
1823 usbvision
->bridgeType
= BRIDGE_NT1003
;
1825 PDEBUG(DBG_PROBE
, "bridgeType %d", usbvision
->bridgeType
);
1827 down(&usbvision
->lock
);
1829 usbvision
->nr
= usbvision_nr
++;
1831 usbvision
->have_tuner
= usbvision_device_data
[model
].Tuner
;
1832 if (usbvision
->have_tuner
) {
1833 usbvision
->tuner_type
= usbvision_device_data
[model
].TunerType
;
1836 usbvision
->tuner_addr
= ADDR_UNSET
;
1838 usbvision
->DevModel
= model
;
1839 usbvision
->remove_pending
= 0;
1840 usbvision
->iface
= ifnum
;
1841 usbvision
->ifaceAltInactive
= 0;
1842 usbvision
->ifaceAltActive
= 1;
1843 usbvision
->video_endp
= endpoint
->bEndpointAddress
;
1844 usbvision
->isocPacketSize
= 0;
1845 usbvision
->usb_bandwidth
= 0;
1846 usbvision
->user
= 0;
1847 usbvision
->streaming
= Stream_Off
;
1848 usbvision_register_video(usbvision
);
1849 usbvision_configure_video(usbvision
);
1850 up(&usbvision
->lock
);
1853 usb_set_intfdata (intf
, usbvision
);
1854 usbvision_create_sysfs(usbvision
->vdev
);
1856 PDEBUG(DBG_PROBE
, "success");
1862 * usbvision_disconnect()
1864 * This procedure stops all driver activity, deallocates interface-private
1865 * structure (pointed by 'ptr') and after that driver should be removable
1866 * with no ill consequences.
1869 static void __devexit
usbvision_disconnect(struct usb_interface
*intf
)
1871 struct usb_usbvision
*usbvision
= usb_get_intfdata(intf
);
1873 PDEBUG(DBG_PROBE
, "");
1875 if (usbvision
== NULL
) {
1876 err("%s: usb_get_intfdata() failed", __FUNCTION__
);
1879 usb_set_intfdata (intf
, NULL
);
1881 down(&usbvision
->lock
);
1883 // At this time we ask to cancel outstanding URBs
1884 usbvision_stop_isoc(usbvision
);
1886 if (usbvision
->power
) {
1887 usbvision_i2c_usb_del_bus(&usbvision
->i2c_adap
);
1888 usbvision_power_off(usbvision
);
1890 usbvision
->remove_pending
= 1; // Now all ISO data will be ignored
1892 usb_put_dev(usbvision
->dev
);
1893 usbvision
->dev
= NULL
; // USB device is no more
1895 up(&usbvision
->lock
);
1897 if (usbvision
->user
) {
1898 info("%s: In use, disconnect pending", __FUNCTION__
);
1899 wake_up_interruptible(&usbvision
->wait_frame
);
1900 wake_up_interruptible(&usbvision
->wait_stream
);
1903 usbvision_release(usbvision
);
1906 PDEBUG(DBG_PROBE
, "success");
1910 static struct usb_driver usbvision_driver
= {
1911 .name
= "usbvision",
1912 .id_table
= usbvision_table
,
1913 .probe
= usbvision_probe
,
1914 .disconnect
= usbvision_disconnect
1918 * customdevice_process()
1920 * This procedure preprocesses CustomDevice parameter if any
1923 static void customdevice_process(void)
1925 usbvision_device_data
[0]=usbvision_device_data
[1];
1926 usbvision_table
[0]=usbvision_table
[1];
1930 char *parse
=CustomDevice
;
1932 PDEBUG(DBG_PROBE
, "CustomDevide=%s", CustomDevice
);
1934 /*format is CustomDevice="0x0573 0x4D31 0 7113 3 PAL 1 1 1 5 -1 -1 -1 -1 -1"
1935 usbvision_device_data[0].idVendor;
1936 usbvision_device_data[0].idProduct;
1937 usbvision_device_data[0].Interface;
1938 usbvision_device_data[0].Codec;
1939 usbvision_device_data[0].VideoChannels;
1940 usbvision_device_data[0].VideoNorm;
1941 usbvision_device_data[0].AudioChannels;
1942 usbvision_device_data[0].Radio;
1943 usbvision_device_data[0].Tuner;
1944 usbvision_device_data[0].TunerType;
1945 usbvision_device_data[0].Vin_Reg1;
1946 usbvision_device_data[0].Vin_Reg2;
1947 usbvision_device_data[0].X_Offset;
1948 usbvision_device_data[0].Y_Offset;
1949 usbvision_device_data[0].Dvi_yuv;
1950 usbvision_device_data[0].ModelString;
1954 usbvision_device_data
[0].ModelString
="USBVISION Custom Device";
1957 sscanf(parse
,"%x",&usbvision_device_data
[0].idVendor
);
1959 PDEBUG(DBG_PROBE
, "idVendor=0x%.4X", usbvision_device_data
[0].idVendor
);
1961 sscanf(parse
,"%x",&usbvision_device_data
[0].idProduct
);
1963 PDEBUG(DBG_PROBE
, "idProduct=0x%.4X", usbvision_device_data
[0].idProduct
);
1964 sscanf(parse
,"%d",&usbvision_device_data
[0].Interface
);
1966 PDEBUG(DBG_PROBE
, "Interface=%d", usbvision_device_data
[0].Interface
);
1967 sscanf(parse
,"%d",&usbvision_device_data
[0].Codec
);
1969 PDEBUG(DBG_PROBE
, "Codec=%d", usbvision_device_data
[0].Codec
);
1970 sscanf(parse
,"%d",&usbvision_device_data
[0].VideoChannels
);
1972 PDEBUG(DBG_PROBE
, "VideoChannels=%d", usbvision_device_data
[0].VideoChannels
);
1977 PDEBUG(DBG_PROBE
, "VideoNorm=PAL");
1978 usbvision_device_data
[0].VideoNorm
=V4L2_STD_PAL
;
1982 PDEBUG(DBG_PROBE
, "VideoNorm=SECAM");
1983 usbvision_device_data
[0].VideoNorm
=V4L2_STD_SECAM
;
1987 PDEBUG(DBG_PROBE
, "VideoNorm=NTSC");
1988 usbvision_device_data
[0].VideoNorm
=V4L2_STD_NTSC
;
1992 PDEBUG(DBG_PROBE
, "VideoNorm=PAL (by default)");
1993 usbvision_device_data
[0].VideoNorm
=V4L2_STD_PAL
;
1998 sscanf(parse
,"%d",&usbvision_device_data
[0].AudioChannels
);
2000 PDEBUG(DBG_PROBE
, "AudioChannels=%d", usbvision_device_data
[0].AudioChannels
);
2001 sscanf(parse
,"%d",&usbvision_device_data
[0].Radio
);
2003 PDEBUG(DBG_PROBE
, "Radio=%d", usbvision_device_data
[0].Radio
);
2004 sscanf(parse
,"%d",&usbvision_device_data
[0].Tuner
);
2006 PDEBUG(DBG_PROBE
, "Tuner=%d", usbvision_device_data
[0].Tuner
);
2007 sscanf(parse
,"%d",&usbvision_device_data
[0].TunerType
);
2009 PDEBUG(DBG_PROBE
, "TunerType=%d", usbvision_device_data
[0].TunerType
);
2010 sscanf(parse
,"%d",&usbvision_device_data
[0].Vin_Reg1
);
2012 PDEBUG(DBG_PROBE
, "Vin_Reg1=%d", usbvision_device_data
[0].Vin_Reg1
);
2013 sscanf(parse
,"%d",&usbvision_device_data
[0].Vin_Reg2
);
2015 PDEBUG(DBG_PROBE
, "Vin_Reg2=%d", usbvision_device_data
[0].Vin_Reg2
);
2016 sscanf(parse
,"%d",&usbvision_device_data
[0].X_Offset
);
2018 PDEBUG(DBG_PROBE
, "X_Offset=%d", usbvision_device_data
[0].X_Offset
);
2019 sscanf(parse
,"%d",&usbvision_device_data
[0].Y_Offset
);
2021 PDEBUG(DBG_PROBE
, "Y_Offset=%d", usbvision_device_data
[0].Y_Offset
);
2022 sscanf(parse
,"%d",&usbvision_device_data
[0].Dvi_yuv
);
2023 PDEBUG(DBG_PROBE
, "Dvi_yuv=%d", usbvision_device_data
[0].Dvi_yuv
);
2025 //add to usbvision_table also
2026 usbvision_table
[0].match_flags
=USB_DEVICE_ID_MATCH_DEVICE
;
2027 usbvision_table
[0].idVendor
=usbvision_device_data
[0].idVendor
;
2028 usbvision_table
[0].idProduct
=usbvision_device_data
[0].idProduct
;
2038 * This code is run to initialize the driver.
2041 static int __init
usbvision_init(void)
2045 PDEBUG(DBG_PROBE
, "");
2047 PDEBUG(DBG_IOCTL
, "IOCTL debugging is enabled [video]");
2048 PDEBUG(DBG_IO
, "IO debugging is enabled [video]");
2049 PDEBUG(DBG_PROBE
, "PROBE debugging is enabled [video]");
2050 PDEBUG(DBG_MMAP
, "MMAP debugging is enabled [video]");
2052 /* disable planar mode support unless compression enabled */
2053 if (isocMode
!= ISOC_MODE_COMPRESS
) {
2054 // FIXME : not the right way to set supported flag
2055 usbvision_v4l2_format
[6].supported
= 0; // V4L2_PIX_FMT_YVU420
2056 usbvision_v4l2_format
[7].supported
= 0; // V4L2_PIX_FMT_YUV422P
2059 customdevice_process();
2061 errCode
= usb_register(&usbvision_driver
);
2064 info(DRIVER_DESC
" : " USBVISION_VERSION_STRING
);
2065 PDEBUG(DBG_PROBE
, "success");
2070 static void __exit
usbvision_exit(void)
2072 PDEBUG(DBG_PROBE
, "");
2074 usb_deregister(&usbvision_driver
);
2075 PDEBUG(DBG_PROBE
, "success");
2078 module_init(usbvision_init
);
2079 module_exit(usbvision_exit
);
2082 * Overrides for Emacs so that we follow Linus's tabbing style.
2083 * ---------------------------------------------------------------------------