[PATCH] remove many unneeded #includes of sched.h
[linux-2.6.git] / drivers / media / video / usbvision / usbvision-video.c
1 /*
2  * USB USBVISION Video device driver 0.9.9
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  *
35  * TODO:
36  *     - use submit_urb for all setup packets
37  *     - Fix memory settings for nt1004. It is 4 times as big as the
38  *       nt1003 memory.
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
44  *
45  */
46
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>
52 #include <linux/mm.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>
61 #include <asm/io.h>
62 #include <linux/videodev2.h>
63 #include <linux/video_decoder.h>
64 #include <linux/i2c.h>
65
66 #include <media/saa7115.h>
67 #include <media/v4l2-common.h>
68 #include <media/tuner.h>
69 #include <media/audiochip.h>
70
71 #include <linux/moduleparam.h>
72 #include <linux/workqueue.h>
73
74 #ifdef CONFIG_KMOD
75 #include <linux/kmod.h>
76 #endif
77
78 #include "usbvision.h"
79
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)
90
91 #define ENABLE_HEXDUMP  0       /* Enable if you need it */
92
93
94 #ifdef USBVISION_DEBUG
95         #define PDEBUG(level, fmt, args...) \
96                 if (video_debug & (level)) info("[%s:%d] " fmt, __PRETTY_FUNCTION__, __LINE__ , ## args)
97 #else
98         #define PDEBUG(level, fmt, args...) do {} while(0)
99 #endif
100
101 #define DBG_IOCTL       1<<0
102 #define DBG_IO          1<<1
103 #define DBG_PROBE       1<<2
104 #define DBG_MMAP        1<<3
105
106 //String operations
107 #define rmspace(str)    while(*str==' ') str++;
108 #define goto2next(str)  while(*str!=' ') str++; while(*str==' ') str++;
109
110
111 static int usbvision_nr = 0;                    // sequential number of usbvision device
112
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" }
122 };
123
124 /* supported tv norms */
125 static struct usbvision_tvnorm tvnorms[] = {
126         {
127                 .name = "PAL",
128                 .id = V4L2_STD_PAL,
129         }, {
130                 .name = "NTSC",
131                 .id = V4L2_STD_NTSC,
132         }, {
133                  .name = "SECAM",
134                  .id = V4L2_STD_SECAM,
135         }, {
136                 .name = "PAL-M",
137                 .id = V4L2_STD_PAL_M,
138         }
139 };
140
141 #define TVNORMS ARRAY_SIZE(tvnorms)
142
143 // Function prototypes
144 static void usbvision_release(struct usb_usbvision *usbvision);
145
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....
154
155 // Grab parameters for the device driver
156
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);
165 #else                                                   // Old Style
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
175 #endif
176
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");
184
185
186 // Misc stuff
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);
192
193
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 /****************************************************************************************/
200
201
202 #define YES_NO(x) ((x) ? "Yes" : "No")
203
204 static inline struct usb_usbvision *cd_to_usbvision(struct class_device *cd)
205 {
206         struct video_device *vdev = container_of(cd, struct video_device, class_dev);
207         return video_get_drvdata(vdev);
208 }
209
210 static ssize_t show_version(struct class_device *cd, char *buf)
211 {
212         return sprintf(buf, "%s\n", USBVISION_VERSION_STRING);
213 }
214 static CLASS_DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
215
216 static ssize_t show_model(struct class_device *cd, char *buf)
217 {
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);
221 }
222 static CLASS_DEVICE_ATTR(model, S_IRUGO, show_model, NULL);
223
224 static ssize_t show_hue(struct class_device *cd, char *buf)
225 {
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;
230         ctrl.value = 0;
231         if(usbvision->user)
232                 call_i2c_clients(usbvision, VIDIOC_G_CTRL, &ctrl);
233         return sprintf(buf, "%d\n", ctrl.value >> 8);
234 }
235 static CLASS_DEVICE_ATTR(hue, S_IRUGO, show_hue, NULL);
236
237 static ssize_t show_contrast(struct class_device *cd, char *buf)
238 {
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;
243         ctrl.value = 0;
244         if(usbvision->user)
245                 call_i2c_clients(usbvision, VIDIOC_G_CTRL, &ctrl);
246         return sprintf(buf, "%d\n", ctrl.value >> 8);
247 }
248 static CLASS_DEVICE_ATTR(contrast, S_IRUGO, show_contrast, NULL);
249
250 static ssize_t show_brightness(struct class_device *cd, char *buf)
251 {
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;
256         ctrl.value = 0;
257         if(usbvision->user)
258                 call_i2c_clients(usbvision, VIDIOC_G_CTRL, &ctrl);
259         return sprintf(buf, "%d\n", ctrl.value >> 8);
260 }
261 static CLASS_DEVICE_ATTR(brightness, S_IRUGO, show_brightness, NULL);
262
263 static ssize_t show_saturation(struct class_device *cd, char *buf)
264 {
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;
269         ctrl.value = 0;
270         if(usbvision->user)
271                 call_i2c_clients(usbvision, VIDIOC_G_CTRL, &ctrl);
272         return sprintf(buf, "%d\n", ctrl.value >> 8);
273 }
274 static CLASS_DEVICE_ATTR(saturation, S_IRUGO, show_saturation, NULL);
275
276 static ssize_t show_streaming(struct class_device *cd, char *buf)
277 {
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));
281 }
282 static CLASS_DEVICE_ATTR(streaming, S_IRUGO, show_streaming, NULL);
283
284 static ssize_t show_compression(struct class_device *cd, char *buf)
285 {
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));
289 }
290 static CLASS_DEVICE_ATTR(compression, S_IRUGO, show_compression, NULL);
291
292 static ssize_t show_device_bridge(struct class_device *cd, char *buf)
293 {
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);
297 }
298 static CLASS_DEVICE_ATTR(bridge, S_IRUGO, show_device_bridge, NULL);
299
300 static void usbvision_create_sysfs(struct video_device *vdev)
301 {
302         int res;
303         if (!vdev)
304                 return;
305         do {
306                 res=class_device_create_file(&vdev->class_dev,
307                                              &class_device_attr_version);
308                 if (res<0)
309                         break;
310                 res=class_device_create_file(&vdev->class_dev,
311                                              &class_device_attr_model);
312                 if (res<0)
313                         break;
314                 res=class_device_create_file(&vdev->class_dev,
315                                              &class_device_attr_hue);
316                 if (res<0)
317                         break;
318                 res=class_device_create_file(&vdev->class_dev,
319                                              &class_device_attr_contrast);
320                 if (res<0)
321                         break;
322                 res=class_device_create_file(&vdev->class_dev,
323                                              &class_device_attr_brightness);
324                 if (res<0)
325                         break;
326                 res=class_device_create_file(&vdev->class_dev,
327                                              &class_device_attr_saturation);
328                 if (res<0)
329                         break;
330                 res=class_device_create_file(&vdev->class_dev,
331                                              &class_device_attr_streaming);
332                 if (res<0)
333                         break;
334                 res=class_device_create_file(&vdev->class_dev,
335                                              &class_device_attr_compression);
336                 if (res<0)
337                         break;
338                 res=class_device_create_file(&vdev->class_dev,
339                                              &class_device_attr_bridge);
340                 if (res>=0)
341                         return;
342         } while (0);
343
344         err("%s error: %d\n", __FUNCTION__, res);
345 }
346
347 static void usbvision_remove_sysfs(struct video_device *vdev)
348 {
349         if (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);
368         }
369 }
370
371
372 /*
373  * usbvision_open()
374  *
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.
378  *
379  */
380 static int usbvision_v4l2_open(struct inode *inode, struct file *file)
381 {
382         struct video_device *dev = video_devdata(file);
383         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
384         int errCode = 0;
385
386         PDEBUG(DBG_IO, "open");
387
388
389         usbvision_reset_powerOffTimer(usbvision);
390
391         if (usbvision->user)
392                 errCode = -EBUSY;
393         else {
394                 /* Allocate memory for the frame buffers */
395                 errCode = usbvision_frames_alloc(usbvision);
396                 if(!errCode) {
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);
402                         }
403                 }
404                 if (errCode) {
405                         /* Deallocate all buffers if trouble */
406                         usbvision_frames_free(usbvision);
407                         usbvision_scratch_free(usbvision);
408                         usbvision_decompress_free(usbvision);
409                 }
410         }
411
412         /* If so far no errors then we shall start the camera */
413         if (!errCode) {
414                 down(&usbvision->lock);
415                 if (usbvision->power == 0) {
416                         usbvision_power_on(usbvision);
417                         usbvision_init_i2c(usbvision);
418                 }
419
420                 /* Send init sequence only once, it's large! */
421                 if (!usbvision->initialized) {
422                         int setup_ok = 0;
423                         setup_ok = usbvision_setup(usbvision,isocMode);
424                         if (setup_ok)
425                                 usbvision->initialized = 1;
426                         else
427                                 errCode = -EBUSY;
428                 }
429
430                 if (!errCode) {
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);
435                         usbvision->user++;
436                 }
437                 else {
438                         if (PowerOnAtOpen) {
439                                 usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
440                                 usbvision_power_off(usbvision);
441                                 usbvision->initialized = 0;
442                         }
443                 }
444                 up(&usbvision->lock);
445         }
446
447         if (errCode) {
448         }
449
450         /* prepare queues */
451         usbvision_empty_framequeues(usbvision);
452
453         PDEBUG(DBG_IO, "success");
454         return errCode;
455 }
456
457 /*
458  * usbvision_v4l2_close()
459  *
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().
463  *
464  */
465 static int usbvision_v4l2_close(struct inode *inode, struct file *file)
466 {
467         struct video_device *dev = video_devdata(file);
468         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
469
470         PDEBUG(DBG_IO, "close");
471         down(&usbvision->lock);
472
473         usbvision_audio_off(usbvision);
474         usbvision_restart_isoc(usbvision);
475         usbvision_stop_isoc(usbvision);
476
477         usbvision_decompress_free(usbvision);
478         usbvision_frames_free(usbvision);
479         usbvision_scratch_free(usbvision);
480
481         usbvision->user--;
482
483         if (PowerOnAtOpen) {
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;
487         }
488
489         up(&usbvision->lock);
490
491         if (usbvision->remove_pending) {
492                 info("%s: Final disconnect", __FUNCTION__);
493                 usbvision_release(usbvision);
494         }
495
496         PDEBUG(DBG_IO, "success");
497
498
499         return 0;
500 }
501
502
503 /*
504  * usbvision_ioctl()
505  *
506  * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
507  *
508  */
509 static int usbvision_v4l2_do_ioctl(struct inode *inode, struct file *file,
510                                  unsigned int cmd, void *arg)
511 {
512         struct video_device *dev = video_devdata(file);
513         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
514
515         if (!USBVISION_IS_OPERATIONAL(usbvision))
516                 return -EFAULT;
517
518         switch (cmd) {
519
520 #ifdef CONFIG_VIDEO_ADV_DEBUG
521                 /* ioctls to allow direct acces to the NT100x registers */
522                 case VIDIOC_INT_G_REGISTER:
523                 {
524                         struct v4l2_register *reg = arg;
525                         int errCode;
526
527                         if (reg->i2c_id != 0)
528                                 return -EINVAL;
529                         /* NT100x has a 8-bit register space */
530                         errCode = usbvision_read_reg(usbvision, reg->reg&0xff);
531                         if (errCode < 0) {
532                                 err("%s: VIDIOC_INT_G_REGISTER failed: error %d", __FUNCTION__, errCode);
533                         }
534                         else {
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
539                         }
540                         return errCode;
541                 }
542                 case VIDIOC_INT_S_REGISTER:
543                 {
544                         struct v4l2_register *reg = arg;
545                         int errCode;
546
547                         if (reg->i2c_id != 0)
548                                 return -EINVAL;
549                         if (!capable(CAP_SYS_ADMIN))
550                                 return -EPERM;
551                         errCode = usbvision_write_reg(usbvision, reg->reg&0xff, reg->val);
552                         if (errCode < 0) {
553                                 err("%s: VIDIOC_INT_S_REGISTER failed: error %d", __FUNCTION__, errCode);
554                         }
555                         else {
556                                 PDEBUG(DBG_IOCTL, "VIDIOC_INT_S_REGISTER reg=0x%02X, value=0x%02X",
557                                                         (unsigned int)reg->reg, reg->val);
558                                 errCode = 0;
559                         }
560                         return 0;
561                 }
562 #endif
563                 case VIDIOC_QUERYCAP:
564                 {
565                         struct v4l2_capability *vc=arg;
566
567                         memset(vc, 0, sizeof(*vc));
568                         strlcpy(vc->driver, "USBVision", sizeof(vc->driver));
569                         strlcpy(vc->card, usbvision_device_data[usbvision->DevModel].ModelString,
570                                 sizeof(vc->card));
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 |
575                                 V4L2_CAP_AUDIO |
576                                 V4L2_CAP_READWRITE |
577                                 V4L2_CAP_STREAMING |
578                                 (usbvision->have_tuner ? V4L2_CAP_TUNER : 0);
579                         PDEBUG(DBG_IOCTL, "VIDIOC_QUERYCAP");
580                         return 0;
581                 }
582                 case VIDIOC_ENUMINPUT:
583                 {
584                         struct v4l2_input *vi = arg;
585                         int chan;
586
587                         if ((vi->index >= usbvision->video_inputs) || (vi->index < 0) )
588                                 return -EINVAL;
589                         if (usbvision->have_tuner) {
590                                 chan = vi->index;
591                         }
592                         else {
593                                 chan = vi->index + 1; //skip Television string
594                         }
595                         switch(chan) {
596                                 case 0:
597                                         if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) {
598                                                 strcpy(vi->name, "White Video Input");
599                                         }
600                                         else {
601                                                 strcpy(vi->name, "Television");
602                                                 vi->type = V4L2_INPUT_TYPE_TUNER;
603                                                 vi->audioset = 1;
604                                                 vi->tuner = chan;
605                                                 vi->std = V4L2_STD_PAL | V4L2_STD_NTSC | V4L2_STD_SECAM;
606                                         }
607                                         break;
608                                 case 1:
609                                         vi->type = V4L2_INPUT_TYPE_CAMERA;
610                                         if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) {
611                                                 strcpy(vi->name, "Green Video Input");
612                                         }
613                                         else {
614                                                 strcpy(vi->name, "Composite Video Input");
615                                         }
616                                         vi->std = V4L2_STD_PAL;
617                                         break;
618                                 case 2:
619                                         vi->type = V4L2_INPUT_TYPE_CAMERA;
620                                         if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) {
621                                                 strcpy(vi->name, "Yellow Video Input");
622                                         }
623                                         else {
624                                         strcpy(vi->name, "S-Video Input");
625                                         }
626                                         vi->std = V4L2_STD_PAL;
627                                         break;
628                                 case 3:
629                                         vi->type = V4L2_INPUT_TYPE_CAMERA;
630                                         strcpy(vi->name, "Red Video Input");
631                                         vi->std = V4L2_STD_PAL;
632                                         break;
633                         }
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);
636                         return 0;
637                 }
638                 case VIDIOC_ENUMSTD:
639                 {
640                         struct v4l2_standard *e = arg;
641                         unsigned int i;
642                         int ret;
643
644                         i = e->index;
645                         if (i >= TVNORMS)
646                                 return -EINVAL;
647                         ret = v4l2_video_std_construct(e, tvnorms[e->index].id,
648                                                        tvnorms[e->index].name);
649                         e->index = i;
650                         if (ret < 0)
651                                 return ret;
652                         return 0;
653                 }
654                 case VIDIOC_G_INPUT:
655                 {
656                         int *input = arg;
657                         *input = usbvision->ctl_input;
658                         return 0;
659                 }
660                 case VIDIOC_S_INPUT:
661                 {
662                         int *input = arg;
663                         if ((*input >= usbvision->video_inputs) || (*input < 0) )
664                                 return -EINVAL;
665                         usbvision->ctl_input = *input;
666
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);
672                         return 0;
673                 }
674                 case VIDIOC_G_STD:
675                 {
676                         v4l2_std_id *id = arg;
677
678                         *id = usbvision->tvnorm->id;
679
680                         PDEBUG(DBG_IOCTL, "VIDIOC_G_STD std_id=%s", usbvision->tvnorm->name);
681                         return 0;
682                 }
683                 case VIDIOC_S_STD:
684                 {
685                         v4l2_std_id *id = arg;
686                         unsigned int i;
687
688                         for (i = 0; i < TVNORMS; i++)
689                                 if (*id == tvnorms[i].id)
690                                         break;
691                         if (i == TVNORMS)
692                                 for (i = 0; i < TVNORMS; i++)
693                                         if (*id & tvnorms[i].id)
694                                                 break;
695                         if (i == TVNORMS)
696                                 return -EINVAL;
697
698                         down(&usbvision->lock);
699                         usbvision->tvnorm = &tvnorms[i];
700
701                         call_i2c_clients(usbvision, VIDIOC_S_STD,
702                                          &usbvision->tvnorm->id);
703
704                         up(&usbvision->lock);
705
706                         PDEBUG(DBG_IOCTL, "VIDIOC_S_STD std_id=%s", usbvision->tvnorm->name);
707                         return 0;
708                 }
709                 case VIDIOC_G_TUNER:
710                 {
711                         struct v4l2_tuner *vt = arg;
712
713                         if (!usbvision->have_tuner || vt->index)        // Only tuner 0
714                                 return -EINVAL;
715                         strcpy(vt->name, "Television");
716                         /* Let clients fill in the remainder of this struct */
717                         call_i2c_clients(usbvision,VIDIOC_G_TUNER,vt);
718
719                         PDEBUG(DBG_IOCTL, "VIDIOC_G_TUNER signal=%x, afc=%x",vt->signal,vt->afc);
720                         return 0;
721                 }
722                 case VIDIOC_S_TUNER:
723                 {
724                         struct v4l2_tuner *vt = arg;
725
726                         // Only no or one tuner for now
727                         if (!usbvision->have_tuner || vt->index)
728                                 return -EINVAL;
729                         /* let clients handle this */
730                         call_i2c_clients(usbvision,VIDIOC_S_TUNER,vt);
731
732                         PDEBUG(DBG_IOCTL, "VIDIOC_S_TUNER");
733                         return 0;
734                 }
735                 case VIDIOC_G_FREQUENCY:
736                 {
737                         struct v4l2_frequency *freq = arg;
738
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);
743                         return 0;
744                 }
745                 case VIDIOC_S_FREQUENCY:
746                 {
747                         struct v4l2_frequency *freq = arg;
748
749                         // Only no or one tuner for now
750                         if (!usbvision->have_tuner || freq->tuner)
751                                 return -EINVAL;
752
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);
756                         return 0;
757                 }
758                 case VIDIOC_G_AUDIO:
759                 {
760                         struct v4l2_audio *v = arg;
761                         memset(v,0, sizeof(v));
762                         strcpy(v->name, "TV");
763                         PDEBUG(DBG_IOCTL, "VIDIOC_G_AUDIO");
764                         return 0;
765                 }
766                 case VIDIOC_S_AUDIO:
767                 {
768                         struct v4l2_audio *v = arg;
769                         if(v->index) {
770                                 return -EINVAL;
771                         }
772                         PDEBUG(DBG_IOCTL, "VIDIOC_S_AUDIO");
773                         return 0;
774                 }
775                 case VIDIOC_QUERYCTRL:
776                 {
777                         struct v4l2_queryctrl *ctrl = arg;
778                         int id=ctrl->id;
779
780                         memset(ctrl,0,sizeof(*ctrl));
781                         ctrl->id=id;
782
783                         call_i2c_clients(usbvision, cmd, arg);
784
785                         if (ctrl->type)
786                                 return 0;
787                         else
788                                 return -EINVAL;
789
790                         PDEBUG(DBG_IOCTL,"VIDIOC_QUERYCTRL id=%x value=%x",ctrl->id,ctrl->type);
791                 }
792                 case VIDIOC_G_CTRL:
793                 {
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);
797                         return 0;
798                 }
799                 case VIDIOC_S_CTRL:
800                 {
801                         struct v4l2_control *ctrl = arg;
802
803                         PDEBUG(DBG_IOCTL, "VIDIOC_S_CTRL id=%x value=%x",ctrl->id,ctrl->value);
804                         call_i2c_clients(usbvision, VIDIOC_S_CTRL, ctrl);
805                         return 0;
806                 }
807                 case VIDIOC_REQBUFS:
808                 {
809                         struct v4l2_requestbuffers *vr = arg;
810                         int ret;
811
812                         RESTRICT_TO_RANGE(vr->count,1,USBVISION_NUMFRAMES);
813
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))
817                                 return -EINVAL;
818
819                         if(usbvision->streaming == Stream_On) {
820                                 if ((ret = usbvision_stream_interrupt(usbvision)))
821                                     return ret;
822                         }
823
824                         usbvision_empty_framequeues(usbvision);
825
826                         usbvision->curFrame = NULL;
827
828                         PDEBUG(DBG_IOCTL, "VIDIOC_REQBUFS count=%d",vr->count);
829                         return 0;
830                 }
831                 case VIDIOC_QUERYBUF:
832                 {
833                         struct v4l2_buffer *vb = arg;
834                         struct usbvision_frame *frame;
835
836                         // FIXME : must control that buffers are mapped (VIDIOC_REQBUFS has been called)
837
838                         if(vb->type != V4L2_CAP_VIDEO_CAPTURE) {
839                                 return -EINVAL;
840                         }
841                         if(vb->index>=USBVISION_NUMFRAMES)  {
842                                 return -EINVAL;
843                         }
844                         // Updating the corresponding frame state
845                         vb->flags = 0;
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;
854
855                         vb->m.offset = vb->index*usbvision->max_frame_size;
856
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;
862                         return 0;
863                 }
864                 case VIDIOC_QBUF:
865                 {
866                         struct v4l2_buffer *vb = arg;
867                         struct usbvision_frame *frame;
868                         unsigned long lock_flags;
869
870                         // FIXME : works only on VIDEO_CAPTURE MODE, MMAP.
871                         if(vb->type != V4L2_CAP_VIDEO_CAPTURE) {
872                                 return -EINVAL;
873                         }
874                         if(vb->index>=USBVISION_NUMFRAMES)  {
875                                 return -EINVAL;
876                         }
877
878                         frame = &usbvision->frame[vb->index];
879
880                         if (frame->grabstate != FrameState_Unused) {
881                                 return -EAGAIN;
882                         }
883
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() */
888
889                         vb->flags &= ~V4L2_BUF_FLAG_DONE;
890
891                         /* set v4l2_format index */
892                         frame->v4l2_format = usbvision->palette;
893
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);
897
898                         PDEBUG(DBG_IOCTL, "VIDIOC_QBUF frame #%d",vb->index);
899                         return 0;
900                 }
901                 case VIDIOC_DQBUF:
902                 {
903                         struct v4l2_buffer *vb = arg;
904                         int ret;
905                         struct usbvision_frame *f;
906                         unsigned long lock_flags;
907
908                         if (vb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
909                                 return -EINVAL;
910
911                         if (list_empty(&(usbvision->outqueue))) {
912                                 if (usbvision->streaming == Stream_Idle)
913                                         return -EINVAL;
914                                 ret = wait_event_interruptible
915                                         (usbvision->wait_frame,
916                                          !list_empty(&(usbvision->outqueue)));
917                                 if (ret)
918                                         return ret;
919                         }
920
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);
926
927                         f->grabstate = FrameState_Unused;
928
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;
936
937                         return 0;
938                 }
939                 case VIDIOC_STREAMON:
940                 {
941                         int b=V4L2_BUF_TYPE_VIDEO_CAPTURE;
942
943                         usbvision->streaming = Stream_On;
944
945                         call_i2c_clients(usbvision,VIDIOC_STREAMON , &b);
946
947                         PDEBUG(DBG_IOCTL, "VIDIOC_STREAMON");
948
949                         return 0;
950                 }
951                 case VIDIOC_STREAMOFF:
952                 {
953                         int *type = arg;
954                         int b=V4L2_BUF_TYPE_VIDEO_CAPTURE;
955
956                         if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
957                                 return -EINVAL;
958
959                         if(usbvision->streaming == Stream_On) {
960                                 usbvision_stream_interrupt(usbvision);
961                                 // Stop all video streamings
962                                 call_i2c_clients(usbvision,VIDIOC_STREAMOFF , &b);
963                         }
964                         usbvision_empty_framequeues(usbvision);
965
966                         PDEBUG(DBG_IOCTL, "VIDIOC_STREAMOFF");
967                         return 0;
968                 }
969                 case VIDIOC_ENUM_FMT:
970                 {
971                         struct v4l2_fmtdesc *vfd = arg;
972
973                         if(vfd->index>=USBVISION_SUPPORTED_PALETTES-1) {
974                                 return -EINVAL;
975                         }
976                         vfd->flags = 0;
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));
981                         return 0;
982                 }
983                 case VIDIOC_G_FMT:
984                 {
985                         struct v4l2_format *vf = arg;
986
987                         switch (vf->type) {
988                                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
989                                 {
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);
999                                         return 0;
1000                                 }
1001                                 default:
1002                                         PDEBUG(DBG_IOCTL, "VIDIOC_G_FMT invalid type %d",vf->type);
1003                                         return -EINVAL;
1004                         }
1005                         return 0;
1006                 }
1007                 case VIDIOC_TRY_FMT:
1008                 case VIDIOC_S_FMT:
1009                 {
1010                         struct v4l2_format *vf = arg;
1011                         int formatIdx,ret;
1012
1013                         switch(vf->type) {
1014                                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1015                                 {
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];
1020                                                         break;
1021                                                 }
1022                                         }
1023                                         /* robustness */
1024                                         if(formatIdx == USBVISION_SUPPORTED_PALETTES) {
1025                                                 return -EINVAL;
1026                                         }
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);
1029
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;
1032
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);
1036                                                 return 0;
1037                                         }
1038
1039                                         /* stop io in case it is already in progress */
1040                                         if(usbvision->streaming == Stream_On) {
1041                                                 if ((ret = usbvision_stream_interrupt(usbvision)))
1042                                                         return ret;
1043                                         }
1044                                         usbvision_empty_framequeues(usbvision);
1045
1046                                         usbvision->curFrame = NULL;
1047
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);
1052
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);
1055                                         return 0;
1056                                 }
1057                                 default:
1058                                         return -EINVAL;
1059                         }
1060                 }
1061                 default:
1062                         return -ENOIOCTLCMD;
1063         }
1064         return 0;
1065 }
1066
1067 static int usbvision_v4l2_ioctl(struct inode *inode, struct file *file,
1068                        unsigned int cmd, unsigned long arg)
1069 {
1070         return video_usercopy(inode, file, cmd, arg, usbvision_v4l2_do_ioctl);
1071 }
1072
1073
1074 static ssize_t usbvision_v4l2_read(struct file *file, char __user *buf,
1075                       size_t count, loff_t *ppos)
1076 {
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;
1081
1082         int ret,i;
1083         struct usbvision_frame *frame;
1084
1085         PDEBUG(DBG_IO, "%s: %ld bytes, noblock=%d", __FUNCTION__, (unsigned long)count, noblock);
1086
1087         if (!USBVISION_IS_OPERATIONAL(usbvision) || (buf == NULL))
1088                 return -EFAULT;
1089
1090         /* no stream is running, make it running ! */
1091         usbvision->streaming = Stream_On;
1092         call_i2c_clients(usbvision,VIDIOC_STREAMON , NULL);
1093
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() */
1102
1103                         /* set v4l2_format index */
1104                         frame->v4l2_format = usbvision->palette;
1105
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);
1109                 }
1110         }
1111
1112         /* Then try to steal a frame (like a VIDIOC_DQBUF would do) */
1113         if (list_empty(&(usbvision->outqueue))) {
1114                 if(noblock)
1115                         return -EAGAIN;
1116
1117                 ret = wait_event_interruptible
1118                         (usbvision->wait_frame,
1119                          !list_empty(&(usbvision->outqueue)));
1120                 if (ret)
1121                         return ret;
1122         }
1123
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);
1129
1130         /* An error returns an empty frame */
1131         if (frame->grabstate == FrameState_Error) {
1132                 frame->bytes_read = 0;
1133                 return 0;
1134         }
1135
1136         PDEBUG(DBG_IO, "%s: frmx=%d, bytes_read=%ld, scanlength=%ld", __FUNCTION__,
1137                        frame->index, frame->bytes_read, frame->scanlength);
1138
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;
1142
1143         if (copy_to_user(buf, frame->data + frame->bytes_read, count)) {
1144                 return -EFAULT;
1145         }
1146
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);
1150
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;
1154
1155                 /* Mark it as available to be used again. */
1156                 frame->grabstate = FrameState_Unused;
1157 /*      } */
1158
1159         return count;
1160 }
1161
1162 static int usbvision_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
1163 {
1164         unsigned long size = vma->vm_end - vma->vm_start,
1165                 start = vma->vm_start;
1166         void *pos;
1167         u32 i;
1168
1169         struct video_device *dev = video_devdata(file);
1170         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
1171
1172         down(&usbvision->lock);
1173
1174         if (!USBVISION_IS_OPERATIONAL(usbvision)) {
1175                 up(&usbvision->lock);
1176                 return -EFAULT;
1177         }
1178
1179         if (!(vma->vm_flags & VM_WRITE) ||
1180             size != PAGE_ALIGN(usbvision->curwidth*usbvision->curheight*usbvision->palette.bytes_per_pixel)) {
1181                 up(&usbvision->lock);
1182                 return -EINVAL;
1183         }
1184
1185         for (i = 0; i < USBVISION_NUMFRAMES; i++) {
1186                 if (((usbvision->max_frame_size*i) >> PAGE_SHIFT) == vma->vm_pgoff)
1187                         break;
1188         }
1189         if (i == USBVISION_NUMFRAMES) {
1190                 PDEBUG(DBG_MMAP, "mmap: user supplied mapping address is out of range");
1191                 up(&usbvision->lock);
1192                 return -EINVAL;
1193         }
1194
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 */
1198
1199         pos = usbvision->frame[i].data;
1200         while (size > 0) {
1201
1202                 if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
1203                         PDEBUG(DBG_MMAP, "mmap: vm_insert_page failed");
1204                         up(&usbvision->lock);
1205                         return -EAGAIN;
1206                 }
1207                 start += PAGE_SIZE;
1208                 pos += PAGE_SIZE;
1209                 size -= PAGE_SIZE;
1210         }
1211
1212         up(&usbvision->lock);
1213         return 0;
1214 }
1215
1216
1217 /*
1218  * Here comes the stuff for radio on usbvision based devices
1219  *
1220  */
1221 static int usbvision_radio_open(struct inode *inode, struct file *file)
1222 {
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;
1226         int errCode = 0;
1227
1228         PDEBUG(DBG_IO, "%s:", __FUNCTION__);
1229
1230         down(&usbvision->lock);
1231
1232         if (usbvision->user) {
1233                 err("%s: Someone tried to open an already opened USBVision Radio!", __FUNCTION__);
1234                 errCode = -EBUSY;
1235         }
1236         else {
1237                 if(PowerOnAtOpen) {
1238                         usbvision_reset_powerOffTimer(usbvision);
1239                         if (usbvision->power == 0) {
1240                                 usbvision_power_on(usbvision);
1241                                 usbvision_init_i2c(usbvision);
1242                         }
1243                 }
1244
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);
1251                 usbvision->user++;
1252         }
1253
1254         if (errCode) {
1255                 if (PowerOnAtOpen) {
1256                         usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
1257                         usbvision_power_off(usbvision);
1258                         usbvision->initialized = 0;
1259                 }
1260         }
1261         up(&usbvision->lock);
1262         return errCode;
1263 }
1264
1265
1266 static int usbvision_radio_close(struct inode *inode, struct file *file)
1267 {
1268         struct video_device *dev = video_devdata(file);
1269         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
1270         int errCode = 0;
1271
1272         PDEBUG(DBG_IO, "");
1273
1274         down(&usbvision->lock);
1275
1276         usbvision_audio_off(usbvision);
1277         usbvision->radio=0;
1278         usbvision->user--;
1279
1280         if (PowerOnAtOpen) {
1281                 usbvision_set_powerOffTimer(usbvision);
1282                 usbvision->initialized = 0;
1283         }
1284
1285         up(&usbvision->lock);
1286
1287         if (usbvision->remove_pending) {
1288                 info("%s: Final disconnect", __FUNCTION__);
1289                 usbvision_release(usbvision);
1290         }
1291
1292
1293         PDEBUG(DBG_IO, "success");
1294
1295         return errCode;
1296 }
1297
1298 static int usbvision_do_radio_ioctl(struct inode *inode, struct file *file,
1299                                  unsigned int cmd, void *arg)
1300 {
1301         struct video_device *dev = video_devdata(file);
1302         struct usb_usbvision *usbvision = (struct usb_usbvision *) video_get_drvdata(dev);
1303
1304         if (!USBVISION_IS_OPERATIONAL(usbvision))
1305                 return -EIO;
1306
1307         switch (cmd) {
1308                 case VIDIOC_QUERYCAP:
1309                 {
1310                         struct v4l2_capability *vc=arg;
1311
1312                         memset(vc, 0, sizeof(*vc));
1313                         strlcpy(vc->driver, "USBVision", sizeof(vc->driver));
1314                         strlcpy(vc->card, usbvision_device_data[usbvision->DevModel].ModelString,
1315                                 sizeof(vc->card));
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");
1321                         return 0;
1322                 }
1323                 case VIDIOC_QUERYCTRL:
1324                 {
1325                         struct v4l2_queryctrl *ctrl = arg;
1326                         int id=ctrl->id;
1327
1328                         memset(ctrl,0,sizeof(*ctrl));
1329                         ctrl->id=id;
1330
1331                         call_i2c_clients(usbvision, cmd, arg);
1332                         PDEBUG(DBG_IO,"VIDIOC_QUERYCTRL id=%x value=%x",ctrl->id,ctrl->type);
1333
1334                         if (ctrl->type)
1335                                 return 0;
1336                         else
1337                                 return -EINVAL;
1338
1339                 }
1340                 case VIDIOC_G_CTRL:
1341                 {
1342                         struct v4l2_control *ctrl = arg;
1343
1344                         call_i2c_clients(usbvision, VIDIOC_G_CTRL, ctrl);
1345                         PDEBUG(DBG_IO,"VIDIOC_G_CTRL id=%x value=%x",ctrl->id,ctrl->value);
1346                         return 0;
1347                 }
1348                 case VIDIOC_S_CTRL:
1349                 {
1350                         struct v4l2_control *ctrl = arg;
1351
1352                         call_i2c_clients(usbvision, VIDIOC_S_CTRL, ctrl);
1353                         PDEBUG(DBG_IO, "VIDIOC_S_CTRL id=%x value=%x",ctrl->id,ctrl->value);
1354                         return 0;
1355                 }
1356                 case VIDIOC_G_TUNER:
1357                 {
1358                         struct v4l2_tuner *t = arg;
1359
1360                         if (t->index > 0)
1361                                 return -EINVAL;
1362
1363                         memset(t,0,sizeof(*t));
1364                         strcpy(t->name, "Radio");
1365                         t->type = V4L2_TUNER_RADIO;
1366
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);
1370                         return 0;
1371                 }
1372                 case VIDIOC_S_TUNER:
1373                 {
1374                         struct v4l2_tuner *vt = arg;
1375
1376                         // Only no or one tuner for now
1377                         if (!usbvision->have_tuner || vt->index)
1378                                 return -EINVAL;
1379                         /* let clients handle this */
1380                         call_i2c_clients(usbvision,VIDIOC_S_TUNER,vt);
1381
1382                         PDEBUG(DBG_IO, "VIDIOC_S_TUNER");
1383                         return 0;
1384                 }
1385                 case VIDIOC_G_AUDIO:
1386                 {
1387                         struct v4l2_audio *a = arg;
1388
1389                         memset(a,0,sizeof(*a));
1390                         strcpy(a->name,"Radio");
1391                         PDEBUG(DBG_IO, "VIDIOC_G_AUDIO");
1392                         return 0;
1393                 }
1394                 case VIDIOC_S_AUDIO:
1395                 case VIDIOC_S_INPUT:
1396                 case VIDIOC_S_STD:
1397                 return 0;
1398
1399                 case VIDIOC_G_FREQUENCY:
1400                 {
1401                         struct v4l2_frequency *f = arg;
1402
1403                         memset(f,0,sizeof(*f));
1404
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);
1409
1410                         return 0;
1411                 }
1412                 case VIDIOC_S_FREQUENCY:
1413                 {
1414                         struct v4l2_frequency *f = arg;
1415
1416                         if (f->tuner != 0)
1417                                 return -EINVAL;
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);
1421
1422                         return 0;
1423                 }
1424                 default:
1425                 {
1426                         PDEBUG(DBG_IO, "%s: Unknown command %x", __FUNCTION__, cmd);
1427                         return -ENOIOCTLCMD;
1428                 }
1429         }
1430         return 0;
1431 }
1432
1433
1434 static int usbvision_radio_ioctl(struct inode *inode, struct file *file,
1435                        unsigned int cmd, unsigned long arg)
1436 {
1437         return video_usercopy(inode, file, cmd, arg, usbvision_do_radio_ioctl);
1438 }
1439
1440
1441 /*
1442  * Here comes the stuff for vbi on usbvision based devices
1443  *
1444  */
1445 static int usbvision_vbi_open(struct inode *inode, struct file *file)
1446 {
1447         /* TODO */
1448         return -EINVAL;
1449
1450 }
1451
1452 static int usbvision_vbi_close(struct inode *inode, struct file *file)
1453 {
1454         /* TODO */
1455         return -EINVAL;
1456 }
1457
1458 static int usbvision_do_vbi_ioctl(struct inode *inode, struct file *file,
1459                                  unsigned int cmd, void *arg)
1460 {
1461         /* TODO */
1462         return -EINVAL;
1463 }
1464
1465 static int usbvision_vbi_ioctl(struct inode *inode, struct file *file,
1466                        unsigned int cmd, unsigned long arg)
1467 {
1468         return video_usercopy(inode, file, cmd, arg, usbvision_do_vbi_ioctl);
1469 }
1470
1471
1472 //
1473 // Video registration stuff
1474 //
1475
1476 // Video template
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,
1485 };
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,
1493         .minor          = -1,
1494 };
1495
1496
1497 // Radio template
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,
1504 };
1505
1506 static struct video_device usbvision_radio_template=
1507 {
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",
1514         .minor          = -1,
1515 };
1516
1517
1518 // vbi template
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,
1525 };
1526
1527 static struct video_device usbvision_vbi_template=
1528 {
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",
1535         .minor          = -1,
1536 };
1537
1538
1539 static struct video_device *usbvision_vdev_init(struct usb_usbvision *usbvision,
1540                                         struct video_device *vdev_template,
1541                                         char *name)
1542 {
1543         struct usb_device *usb_dev = usbvision->dev;
1544         struct video_device *vdev;
1545
1546         if (usb_dev == NULL) {
1547                 err("%s: usbvision->dev is not set", __FUNCTION__);
1548                 return NULL;
1549         }
1550
1551         vdev = video_device_alloc();
1552         if (NULL == vdev) {
1553                 return NULL;
1554         }
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);
1560         return vdev;
1561 }
1562
1563 // unregister video4linux devices
1564 static void usbvision_unregister_video(struct usb_usbvision *usbvision)
1565 {
1566         // vbi Device:
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);
1571                 }
1572                 else {
1573                         video_device_release(usbvision->vbi);
1574                 }
1575                 usbvision->vbi = NULL;
1576         }
1577
1578         // Radio Device:
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);
1583                 }
1584                 else {
1585                         video_device_release(usbvision->rdev);
1586                 }
1587                 usbvision->rdev = NULL;
1588         }
1589
1590         // Video Device:
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);
1595                 }
1596                 else {
1597                         video_device_release(usbvision->vdev);
1598                 }
1599                 usbvision->vdev = NULL;
1600         }
1601 }
1602
1603 // register video4linux devices
1604 static int __devinit usbvision_register_video(struct usb_usbvision *usbvision)
1605 {
1606         // Video Device:
1607         usbvision->vdev = usbvision_vdev_init(usbvision, &usbvision_video_template, "USBVision Video");
1608         if (usbvision->vdev == NULL) {
1609                 goto err_exit;
1610         }
1611         if (video_register_device(usbvision->vdev, VFL_TYPE_GRABBER, video_nr)<0) {
1612                 goto err_exit;
1613         }
1614         info("USBVision[%d]: registered USBVision Video device /dev/video%d [v4l2]", usbvision->nr,usbvision->vdev->minor & 0x1f);
1615
1616         // Radio Device:
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) {
1621                         goto err_exit;
1622                 }
1623                 if (video_register_device(usbvision->rdev, VFL_TYPE_RADIO, radio_nr)<0) {
1624                         goto err_exit;
1625                 }
1626                 info("USBVision[%d]: registered USBVision Radio device /dev/radio%d [v4l2]", usbvision->nr, usbvision->rdev->minor & 0x1f);
1627         }
1628         // vbi Device:
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) {
1632                         goto err_exit;
1633                 }
1634                 if (video_register_device(usbvision->vbi, VFL_TYPE_VBI, vbi_nr)<0) {
1635                         goto err_exit;
1636                 }
1637                 info("USBVision[%d]: registered USBVision VBI device /dev/vbi%d [v4l2] (Not Working Yet!)", usbvision->nr,usbvision->vbi->minor & 0x1f);
1638         }
1639         // all done
1640         return 0;
1641
1642  err_exit:
1643         err("USBVision[%d]: video_register_device() failed", usbvision->nr);
1644         usbvision_unregister_video(usbvision);
1645         return -1;
1646 }
1647
1648 /*
1649  * usbvision_alloc()
1650  *
1651  * This code allocates the struct usb_usbvision. It is filled with default values.
1652  *
1653  * Returns NULL on error, a pointer to usb_usbvision else.
1654  *
1655  */
1656 static struct usb_usbvision *usbvision_alloc(struct usb_device *dev)
1657 {
1658         struct usb_usbvision *usbvision;
1659
1660         if ((usbvision = kzalloc(sizeof(struct usb_usbvision), GFP_KERNEL)) == NULL) {
1661                 goto err_exit;
1662         }
1663
1664         usbvision->dev = dev;
1665
1666         init_MUTEX(&usbvision->lock);   /* to 1 == available */
1667
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) {
1671                 goto err_exit;
1672         }
1673         init_waitqueue_head(&usbvision->ctrlUrb_wq);
1674         init_MUTEX(&usbvision->ctrlUrbLock);    /* to 1 == available */
1675
1676         usbvision_init_powerOffTimer(usbvision);
1677
1678         return usbvision;
1679
1680 err_exit:
1681         if (usbvision && usbvision->ctrlUrb) {
1682                 usb_free_urb(usbvision->ctrlUrb);
1683         }
1684         if (usbvision) {
1685                 kfree(usbvision);
1686         }
1687         return NULL;
1688 }
1689
1690 /*
1691  * usbvision_release()
1692  *
1693  * This code does final release of struct usb_usbvision. This happens
1694  * after the device is disconnected -and- all clients closed their files.
1695  *
1696  */
1697 static void usbvision_release(struct usb_usbvision *usbvision)
1698 {
1699         PDEBUG(DBG_PROBE, "");
1700
1701         down(&usbvision->lock);
1702
1703         usbvision_reset_powerOffTimer(usbvision);
1704
1705         usbvision->initialized = 0;
1706
1707         up(&usbvision->lock);
1708
1709         usbvision_remove_sysfs(usbvision->vdev);
1710         usbvision_unregister_video(usbvision);
1711
1712         if (usbvision->ctrlUrb) {
1713                 usb_free_urb(usbvision->ctrlUrb);
1714         }
1715
1716         kfree(usbvision);
1717
1718         PDEBUG(DBG_PROBE, "success");
1719 }
1720
1721
1722 /******************************** usb interface *****************************************/
1723
1724 static void usbvision_configure_video(struct usb_usbvision *usbvision)
1725 {
1726         int model,i;
1727
1728         if (usbvision == NULL)
1729                 return;
1730
1731         model = usbvision->DevModel;
1732         usbvision->palette = usbvision_v4l2_format[2]; // V4L2_PIX_FMT_RGB24;
1733
1734         if (usbvision_device_data[usbvision->DevModel].Vin_Reg2 >= 0) {
1735                 usbvision->Vin_Reg2_Preset = usbvision_device_data[usbvision->DevModel].Vin_Reg2 & 0xff;
1736         } else {
1737                 usbvision->Vin_Reg2_Preset = 0;
1738         }
1739
1740         for (i = 0; i < TVNORMS; i++)
1741                 if (usbvision_device_data[model].VideoNorm == tvnorms[i].mode)
1742                         break;
1743         if (i == TVNORMS)
1744                 i = 0;
1745         usbvision->tvnorm = &tvnorms[i];        /* set default norm */
1746
1747         usbvision->video_inputs = usbvision_device_data[model].VideoChannels;
1748         usbvision->ctl_input = 0;
1749
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);
1755         }
1756 }
1757
1758 /*
1759  * usbvision_probe()
1760  *
1761  * This procedure queries device descriptor and accepts the interface
1762  * if it looks like USBVISION video device
1763  *
1764  */
1765 static int __devinit usbvision_probe(struct usb_interface *intf, const struct usb_device_id *devid)
1766 {
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;
1772         int model;
1773
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? */
1777         model = 0;
1778         for(model = 0; usbvision_device_data[model].idVendor; model++) {
1779                 if (le16_to_cpu(dev->descriptor.idVendor) != usbvision_device_data[model].idVendor) {
1780                         continue;
1781                 }
1782                 if (le16_to_cpu(dev->descriptor.idProduct) != usbvision_device_data[model].idProduct) {
1783                         continue;
1784                 }
1785
1786                 info("%s: %s found", __FUNCTION__, usbvision_device_data[model].ModelString);
1787                 break;
1788         }
1789
1790         if (usbvision_device_data[model].idVendor == 0) {
1791                 return -ENODEV; //no matching device
1792         }
1793         if (usbvision_device_data[model].Interface >= 0) {
1794                 interface = &dev->actconfig->interface[usbvision_device_data[model].Interface]->altsetting[0];
1795         }
1796         else {
1797                 interface = &dev->actconfig->interface[ifnum]->altsetting[0];
1798         }
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);
1803                 return -ENODEV;
1804         }
1805         if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) {
1806                 err("%s: interface %d. has ISO OUT endpoint!", __FUNCTION__, ifnum);
1807                 return -ENODEV;
1808         }
1809
1810         usb_get_dev(dev);
1811
1812         if ((usbvision = usbvision_alloc(dev)) == NULL) {
1813                 err("%s: couldn't allocate USBVision struct", __FUNCTION__);
1814                 return -ENOMEM;
1815         }
1816         if (dev->descriptor.bNumConfigurations > 1) {
1817                 usbvision->bridgeType = BRIDGE_NT1004;
1818         }
1819         else if (usbvision_device_data[model].ModelString == "Dazzle Fusion Model DVC-90 Rev 1 (SECAM)") {
1820                 usbvision->bridgeType = BRIDGE_NT1005;
1821         }
1822         else {
1823                 usbvision->bridgeType = BRIDGE_NT1003;
1824         }
1825         PDEBUG(DBG_PROBE, "bridgeType %d", usbvision->bridgeType);
1826
1827         down(&usbvision->lock);
1828
1829         usbvision->nr = usbvision_nr++;
1830
1831         usbvision->have_tuner = usbvision_device_data[model].Tuner;
1832         if (usbvision->have_tuner) {
1833                 usbvision->tuner_type = usbvision_device_data[model].TunerType;
1834         }
1835
1836         usbvision->tuner_addr = ADDR_UNSET;
1837
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);
1851
1852
1853         usb_set_intfdata (intf, usbvision);
1854         usbvision_create_sysfs(usbvision->vdev);
1855
1856         PDEBUG(DBG_PROBE, "success");
1857         return 0;
1858 }
1859
1860
1861 /*
1862  * usbvision_disconnect()
1863  *
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.
1867  *
1868  */
1869 static void __devexit usbvision_disconnect(struct usb_interface *intf)
1870 {
1871         struct usb_usbvision *usbvision = usb_get_intfdata(intf);
1872
1873         PDEBUG(DBG_PROBE, "");
1874
1875         if (usbvision == NULL) {
1876                 err("%s: usb_get_intfdata() failed", __FUNCTION__);
1877                 return;
1878         }
1879         usb_set_intfdata (intf, NULL);
1880
1881         down(&usbvision->lock);
1882
1883         // At this time we ask to cancel outstanding URBs
1884         usbvision_stop_isoc(usbvision);
1885
1886         if (usbvision->power) {
1887                 usbvision_i2c_usb_del_bus(&usbvision->i2c_adap);
1888                 usbvision_power_off(usbvision);
1889         }
1890         usbvision->remove_pending = 1;  // Now all ISO data will be ignored
1891
1892         usb_put_dev(usbvision->dev);
1893         usbvision->dev = NULL;  // USB device is no more
1894
1895         up(&usbvision->lock);
1896
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);
1901         }
1902         else {
1903                 usbvision_release(usbvision);
1904         }
1905
1906         PDEBUG(DBG_PROBE, "success");
1907
1908 }
1909
1910 static struct usb_driver usbvision_driver = {
1911         .name           = "usbvision",
1912         .id_table       = usbvision_table,
1913         .probe          = usbvision_probe,
1914         .disconnect     = usbvision_disconnect
1915 };
1916
1917 /*
1918  * customdevice_process()
1919  *
1920  * This procedure preprocesses CustomDevice parameter if any
1921  *
1922  */
1923 static void customdevice_process(void)
1924 {
1925         usbvision_device_data[0]=usbvision_device_data[1];
1926         usbvision_table[0]=usbvision_table[1];
1927
1928         if(CustomDevice)
1929         {
1930                 char *parse=CustomDevice;
1931
1932                 PDEBUG(DBG_PROBE, "CustomDevide=%s", CustomDevice);
1933
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;
1951                 */
1952
1953                 rmspace(parse);
1954                 usbvision_device_data[0].ModelString="USBVISION Custom Device";
1955
1956                 parse+=2;
1957                 sscanf(parse,"%x",&usbvision_device_data[0].idVendor);
1958                 goto2next(parse);
1959                 PDEBUG(DBG_PROBE, "idVendor=0x%.4X", usbvision_device_data[0].idVendor);
1960                 parse+=2;
1961                 sscanf(parse,"%x",&usbvision_device_data[0].idProduct);
1962                 goto2next(parse);
1963                 PDEBUG(DBG_PROBE, "idProduct=0x%.4X", usbvision_device_data[0].idProduct);
1964                 sscanf(parse,"%d",&usbvision_device_data[0].Interface);
1965                 goto2next(parse);
1966                 PDEBUG(DBG_PROBE, "Interface=%d", usbvision_device_data[0].Interface);
1967                 sscanf(parse,"%d",&usbvision_device_data[0].Codec);
1968                 goto2next(parse);
1969                 PDEBUG(DBG_PROBE, "Codec=%d", usbvision_device_data[0].Codec);
1970                 sscanf(parse,"%d",&usbvision_device_data[0].VideoChannels);
1971                 goto2next(parse);
1972                 PDEBUG(DBG_PROBE, "VideoChannels=%d", usbvision_device_data[0].VideoChannels);
1973
1974                 switch(*parse)
1975                 {
1976                         case 'P':
1977                                 PDEBUG(DBG_PROBE, "VideoNorm=PAL");
1978                                 usbvision_device_data[0].VideoNorm=V4L2_STD_PAL;
1979                                 break;
1980
1981                         case 'S':
1982                                 PDEBUG(DBG_PROBE, "VideoNorm=SECAM");
1983                                 usbvision_device_data[0].VideoNorm=V4L2_STD_SECAM;
1984                                 break;
1985
1986                         case 'N':
1987                                 PDEBUG(DBG_PROBE, "VideoNorm=NTSC");
1988                                 usbvision_device_data[0].VideoNorm=V4L2_STD_NTSC;
1989                                 break;
1990
1991                         default:
1992                                 PDEBUG(DBG_PROBE, "VideoNorm=PAL (by default)");
1993                                 usbvision_device_data[0].VideoNorm=V4L2_STD_PAL;
1994                                 break;
1995                 }
1996                 goto2next(parse);
1997
1998                 sscanf(parse,"%d",&usbvision_device_data[0].AudioChannels);
1999                 goto2next(parse);
2000                 PDEBUG(DBG_PROBE, "AudioChannels=%d", usbvision_device_data[0].AudioChannels);
2001                 sscanf(parse,"%d",&usbvision_device_data[0].Radio);
2002                 goto2next(parse);
2003                 PDEBUG(DBG_PROBE, "Radio=%d", usbvision_device_data[0].Radio);
2004                 sscanf(parse,"%d",&usbvision_device_data[0].Tuner);
2005                 goto2next(parse);
2006                 PDEBUG(DBG_PROBE, "Tuner=%d", usbvision_device_data[0].Tuner);
2007                 sscanf(parse,"%d",&usbvision_device_data[0].TunerType);
2008                 goto2next(parse);
2009                 PDEBUG(DBG_PROBE, "TunerType=%d", usbvision_device_data[0].TunerType);
2010                 sscanf(parse,"%d",&usbvision_device_data[0].Vin_Reg1);
2011                 goto2next(parse);
2012                 PDEBUG(DBG_PROBE, "Vin_Reg1=%d", usbvision_device_data[0].Vin_Reg1);
2013                 sscanf(parse,"%d",&usbvision_device_data[0].Vin_Reg2);
2014                 goto2next(parse);
2015                 PDEBUG(DBG_PROBE, "Vin_Reg2=%d", usbvision_device_data[0].Vin_Reg2);
2016                 sscanf(parse,"%d",&usbvision_device_data[0].X_Offset);
2017                 goto2next(parse);
2018                 PDEBUG(DBG_PROBE, "X_Offset=%d", usbvision_device_data[0].X_Offset);
2019                 sscanf(parse,"%d",&usbvision_device_data[0].Y_Offset);
2020                 goto2next(parse);
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);
2024
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;
2029
2030         }
2031 }
2032
2033
2034
2035 /*
2036  * usbvision_init()
2037  *
2038  * This code is run to initialize the driver.
2039  *
2040  */
2041 static int __init usbvision_init(void)
2042 {
2043         int errCode;
2044
2045         PDEBUG(DBG_PROBE, "");
2046
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]");
2051
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
2057         }
2058
2059         customdevice_process();
2060
2061         errCode = usb_register(&usbvision_driver);
2062
2063         if (errCode == 0) {
2064                 info(DRIVER_DESC " : " USBVISION_VERSION_STRING);
2065                 PDEBUG(DBG_PROBE, "success");
2066         }
2067         return errCode;
2068 }
2069
2070 static void __exit usbvision_exit(void)
2071 {
2072  PDEBUG(DBG_PROBE, "");
2073
2074  usb_deregister(&usbvision_driver);
2075  PDEBUG(DBG_PROBE, "success");
2076 }
2077
2078 module_init(usbvision_init);
2079 module_exit(usbvision_exit);
2080
2081 /*
2082  * Overrides for Emacs so that we follow Linus's tabbing style.
2083  * ---------------------------------------------------------------------------
2084  * Local variables:
2085  * c-basic-offset: 8
2086  * End:
2087  */