usbvision-video.c revision 975f5766be048fb65eae6dbf423db129cd641124
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. 40 * Seems impossible, needs a codec interface. Which one? 41 * - Clean up the driver. 42 * - optimization for performance. 43 * - Add Videotext capability (VBI). Working on it..... 44 * - Check audio for other devices 45 * 46 */ 47 48#include <linux/version.h> 49#include <linux/kernel.h> 50#include <linux/list.h> 51#include <linux/timer.h> 52#include <linux/slab.h> 53#include <linux/mm.h> 54#include <linux/utsname.h> 55#include <linux/highmem.h> 56#include <linux/vmalloc.h> 57#include <linux/module.h> 58#include <linux/init.h> 59#include <linux/spinlock.h> 60#include <asm/io.h> 61#include <linux/videodev2.h> 62#include <linux/i2c.h> 63 64#include <media/saa7115.h> 65#include <media/v4l2-common.h> 66#include <media/v4l2-ioctl.h> 67#include <media/tuner.h> 68 69#include <linux/workqueue.h> 70 71#include "usbvision.h" 72#include "usbvision-cards.h" 73 74#define DRIVER_AUTHOR "Joerg Heckenbach <joerg@heckenbach-aw.de>,\ 75 Dwaine Garden <DwaineGarden@rogers.com>" 76#define DRIVER_NAME "usbvision" 77#define DRIVER_ALIAS "USBVision" 78#define DRIVER_DESC "USBVision USB Video Device Driver for Linux" 79#define DRIVER_LICENSE "GPL" 80#define USBVISION_DRIVER_VERSION_MAJOR 0 81#define USBVISION_DRIVER_VERSION_MINOR 9 82#define USBVISION_DRIVER_VERSION_PATCHLEVEL 9 83#define USBVISION_DRIVER_VERSION KERNEL_VERSION(USBVISION_DRIVER_VERSION_MAJOR,\ 84USBVISION_DRIVER_VERSION_MINOR,\ 85USBVISION_DRIVER_VERSION_PATCHLEVEL) 86#define USBVISION_VERSION_STRING __stringify(USBVISION_DRIVER_VERSION_MAJOR)\ 87 "." __stringify(USBVISION_DRIVER_VERSION_MINOR)\ 88 "." __stringify(USBVISION_DRIVER_VERSION_PATCHLEVEL) 89 90#define ENABLE_HEXDUMP 0 /* Enable if you need it */ 91 92 93#ifdef USBVISION_DEBUG 94 #define PDEBUG(level, fmt, args...) { \ 95 if (video_debug & (level)) \ 96 printk(KERN_INFO KBUILD_MODNAME ":[%s:%d] " fmt, \ 97 __func__, __LINE__ , ## args); \ 98 } 99#else 100 #define PDEBUG(level, fmt, args...) do {} while(0) 101#endif 102 103#define DBG_IO 1<<1 104#define DBG_PROBE 1<<2 105#define DBG_MMAP 1<<3 106 107//String operations 108#define rmspace(str) while(*str==' ') str++; 109#define goto2next(str) while(*str!=' ') str++; while(*str==' ') str++; 110 111 112/* sequential number of usbvision device */ 113static int usbvision_nr; 114 115static struct usbvision_v4l2_format_st usbvision_v4l2_format[] = { 116 { 1, 1, 8, V4L2_PIX_FMT_GREY , "GREY" }, 117 { 1, 2, 16, V4L2_PIX_FMT_RGB565 , "RGB565" }, 118 { 1, 3, 24, V4L2_PIX_FMT_RGB24 , "RGB24" }, 119 { 1, 4, 32, V4L2_PIX_FMT_RGB32 , "RGB32" }, 120 { 1, 2, 16, V4L2_PIX_FMT_RGB555 , "RGB555" }, 121 { 1, 2, 16, V4L2_PIX_FMT_YUYV , "YUV422" }, 122 { 1, 2, 12, V4L2_PIX_FMT_YVU420 , "YUV420P" }, // 1.5 ! 123 { 1, 2, 16, V4L2_PIX_FMT_YUV422P , "YUV422P" } 124}; 125 126/* Function prototypes */ 127static void usbvision_release(struct usb_usbvision *usbvision); 128 129/* Default initialization of device driver parameters */ 130/* Set the default format for ISOC endpoint */ 131static int isocMode = ISOC_MODE_COMPRESS; 132/* Set the default Debug Mode of the device driver */ 133static int video_debug; 134/* Set the default device to power on at startup */ 135static int PowerOnAtOpen = 1; 136/* Sequential Number of Video Device */ 137static int video_nr = -1; 138/* Sequential Number of Radio Device */ 139static int radio_nr = -1; 140/* Sequential Number of VBI Device */ 141static int vbi_nr = -1; 142 143/* Grab parameters for the device driver */ 144 145/* Showing parameters under SYSFS */ 146module_param(isocMode, int, 0444); 147module_param(video_debug, int, 0444); 148module_param(PowerOnAtOpen, int, 0444); 149module_param(video_nr, int, 0444); 150module_param(radio_nr, int, 0444); 151module_param(vbi_nr, int, 0444); 152 153MODULE_PARM_DESC(isocMode, " Set the default format for ISOC endpoint. Default: 0x60 (Compression On)"); 154MODULE_PARM_DESC(video_debug, " Set the default Debug Mode of the device driver. Default: 0 (Off)"); 155MODULE_PARM_DESC(PowerOnAtOpen, " Set the default device to power on when device is opened. Default: 1 (On)"); 156MODULE_PARM_DESC(video_nr, "Set video device number (/dev/videoX). Default: -1 (autodetect)"); 157MODULE_PARM_DESC(radio_nr, "Set radio device number (/dev/radioX). Default: -1 (autodetect)"); 158MODULE_PARM_DESC(vbi_nr, "Set vbi device number (/dev/vbiX). Default: -1 (autodetect)"); 159 160 161// Misc stuff 162MODULE_AUTHOR(DRIVER_AUTHOR); 163MODULE_DESCRIPTION(DRIVER_DESC); 164MODULE_LICENSE(DRIVER_LICENSE); 165MODULE_VERSION(USBVISION_VERSION_STRING); 166MODULE_ALIAS(DRIVER_ALIAS); 167 168 169/*****************************************************************************/ 170/* SYSFS Code - Copied from the stv680.c usb module. */ 171/* Device information is located at /sys/class/video4linux/video0 */ 172/* Device parameters information is located at /sys/module/usbvision */ 173/* Device USB Information is located at */ 174/* /sys/bus/usb/drivers/USBVision Video Grabber */ 175/*****************************************************************************/ 176 177#define YES_NO(x) ((x) ? "Yes" : "No") 178 179static inline struct usb_usbvision *cd_to_usbvision(struct device *cd) 180{ 181 struct video_device *vdev = 182 container_of(cd, struct video_device, dev); 183 return video_get_drvdata(vdev); 184} 185 186static ssize_t show_version(struct device *cd, 187 struct device_attribute *attr, char *buf) 188{ 189 return sprintf(buf, "%s\n", USBVISION_VERSION_STRING); 190} 191static DEVICE_ATTR(version, S_IRUGO, show_version, NULL); 192 193static ssize_t show_model(struct device *cd, 194 struct device_attribute *attr, char *buf) 195{ 196 struct video_device *vdev = 197 container_of(cd, struct video_device, dev); 198 struct usb_usbvision *usbvision = video_get_drvdata(vdev); 199 return sprintf(buf, "%s\n", 200 usbvision_device_data[usbvision->DevModel].ModelString); 201} 202static DEVICE_ATTR(model, S_IRUGO, show_model, NULL); 203 204static ssize_t show_hue(struct device *cd, 205 struct device_attribute *attr, char *buf) 206{ 207 struct video_device *vdev = 208 container_of(cd, struct video_device, dev); 209 struct usb_usbvision *usbvision = video_get_drvdata(vdev); 210 struct v4l2_control ctrl; 211 ctrl.id = V4L2_CID_HUE; 212 ctrl.value = 0; 213 if(usbvision->user) 214 call_all(usbvision, core, g_ctrl, &ctrl); 215 return sprintf(buf, "%d\n", ctrl.value); 216} 217static DEVICE_ATTR(hue, S_IRUGO, show_hue, NULL); 218 219static ssize_t show_contrast(struct device *cd, 220 struct device_attribute *attr, char *buf) 221{ 222 struct video_device *vdev = 223 container_of(cd, struct video_device, dev); 224 struct usb_usbvision *usbvision = video_get_drvdata(vdev); 225 struct v4l2_control ctrl; 226 ctrl.id = V4L2_CID_CONTRAST; 227 ctrl.value = 0; 228 if(usbvision->user) 229 call_all(usbvision, core, g_ctrl, &ctrl); 230 return sprintf(buf, "%d\n", ctrl.value); 231} 232static DEVICE_ATTR(contrast, S_IRUGO, show_contrast, NULL); 233 234static ssize_t show_brightness(struct device *cd, 235 struct device_attribute *attr, char *buf) 236{ 237 struct video_device *vdev = 238 container_of(cd, struct video_device, dev); 239 struct usb_usbvision *usbvision = video_get_drvdata(vdev); 240 struct v4l2_control ctrl; 241 ctrl.id = V4L2_CID_BRIGHTNESS; 242 ctrl.value = 0; 243 if(usbvision->user) 244 call_all(usbvision, core, g_ctrl, &ctrl); 245 return sprintf(buf, "%d\n", ctrl.value); 246} 247static DEVICE_ATTR(brightness, S_IRUGO, show_brightness, NULL); 248 249static ssize_t show_saturation(struct device *cd, 250 struct device_attribute *attr, char *buf) 251{ 252 struct video_device *vdev = 253 container_of(cd, struct video_device, dev); 254 struct usb_usbvision *usbvision = video_get_drvdata(vdev); 255 struct v4l2_control ctrl; 256 ctrl.id = V4L2_CID_SATURATION; 257 ctrl.value = 0; 258 if(usbvision->user) 259 call_all(usbvision, core, g_ctrl, &ctrl); 260 return sprintf(buf, "%d\n", ctrl.value); 261} 262static DEVICE_ATTR(saturation, S_IRUGO, show_saturation, NULL); 263 264static ssize_t show_streaming(struct device *cd, 265 struct device_attribute *attr, char *buf) 266{ 267 struct video_device *vdev = 268 container_of(cd, struct video_device, dev); 269 struct usb_usbvision *usbvision = video_get_drvdata(vdev); 270 return sprintf(buf, "%s\n", 271 YES_NO(usbvision->streaming==Stream_On?1:0)); 272} 273static DEVICE_ATTR(streaming, S_IRUGO, show_streaming, NULL); 274 275static ssize_t show_compression(struct device *cd, 276 struct device_attribute *attr, char *buf) 277{ 278 struct video_device *vdev = 279 container_of(cd, struct video_device, dev); 280 struct usb_usbvision *usbvision = video_get_drvdata(vdev); 281 return sprintf(buf, "%s\n", 282 YES_NO(usbvision->isocMode==ISOC_MODE_COMPRESS)); 283} 284static DEVICE_ATTR(compression, S_IRUGO, show_compression, NULL); 285 286static ssize_t show_device_bridge(struct device *cd, 287 struct device_attribute *attr, char *buf) 288{ 289 struct video_device *vdev = 290 container_of(cd, struct video_device, dev); 291 struct usb_usbvision *usbvision = video_get_drvdata(vdev); 292 return sprintf(buf, "%d\n", usbvision->bridgeType); 293} 294static DEVICE_ATTR(bridge, S_IRUGO, show_device_bridge, NULL); 295 296static void usbvision_create_sysfs(struct video_device *vdev) 297{ 298 int res; 299 if (!vdev) 300 return; 301 do { 302 res = device_create_file(&vdev->dev, &dev_attr_version); 303 if (res<0) 304 break; 305 res = device_create_file(&vdev->dev, &dev_attr_model); 306 if (res<0) 307 break; 308 res = device_create_file(&vdev->dev, &dev_attr_hue); 309 if (res<0) 310 break; 311 res = device_create_file(&vdev->dev, &dev_attr_contrast); 312 if (res<0) 313 break; 314 res = device_create_file(&vdev->dev, &dev_attr_brightness); 315 if (res<0) 316 break; 317 res = device_create_file(&vdev->dev, &dev_attr_saturation); 318 if (res<0) 319 break; 320 res = device_create_file(&vdev->dev, &dev_attr_streaming); 321 if (res<0) 322 break; 323 res = device_create_file(&vdev->dev, &dev_attr_compression); 324 if (res<0) 325 break; 326 res = device_create_file(&vdev->dev, &dev_attr_bridge); 327 if (res>=0) 328 return; 329 } while (0); 330 331 dev_err(&vdev->dev, "%s error: %d\n", __func__, res); 332} 333 334static void usbvision_remove_sysfs(struct video_device *vdev) 335{ 336 if (vdev) { 337 device_remove_file(&vdev->dev, &dev_attr_version); 338 device_remove_file(&vdev->dev, &dev_attr_model); 339 device_remove_file(&vdev->dev, &dev_attr_hue); 340 device_remove_file(&vdev->dev, &dev_attr_contrast); 341 device_remove_file(&vdev->dev, &dev_attr_brightness); 342 device_remove_file(&vdev->dev, &dev_attr_saturation); 343 device_remove_file(&vdev->dev, &dev_attr_streaming); 344 device_remove_file(&vdev->dev, &dev_attr_compression); 345 device_remove_file(&vdev->dev, &dev_attr_bridge); 346 } 347} 348 349/* 350 * usbvision_open() 351 * 352 * This is part of Video 4 Linux API. The driver can be opened by one 353 * client only (checks internal counter 'usbvision->user'). The procedure 354 * then allocates buffers needed for video processing. 355 * 356 */ 357static int usbvision_v4l2_open(struct file *file) 358{ 359 struct usb_usbvision *usbvision = video_drvdata(file); 360 int errCode = 0; 361 362 PDEBUG(DBG_IO, "open"); 363 364 lock_kernel(); 365 usbvision_reset_powerOffTimer(usbvision); 366 367 if (usbvision->user) 368 errCode = -EBUSY; 369 else { 370 /* Allocate memory for the scratch ring buffer */ 371 errCode = usbvision_scratch_alloc(usbvision); 372 if (isocMode==ISOC_MODE_COMPRESS) { 373 /* Allocate intermediate decompression buffers 374 only if needed */ 375 errCode = usbvision_decompress_alloc(usbvision); 376 } 377 if (errCode) { 378 /* Deallocate all buffers if trouble */ 379 usbvision_scratch_free(usbvision); 380 usbvision_decompress_free(usbvision); 381 } 382 } 383 384 /* If so far no errors then we shall start the camera */ 385 if (!errCode) { 386 mutex_lock(&usbvision->lock); 387 if (usbvision->power == 0) { 388 usbvision_power_on(usbvision); 389 usbvision_i2c_register(usbvision); 390 } 391 392 /* Send init sequence only once, it's large! */ 393 if (!usbvision->initialized) { 394 int setup_ok = 0; 395 setup_ok = usbvision_setup(usbvision,isocMode); 396 if (setup_ok) 397 usbvision->initialized = 1; 398 else 399 errCode = -EBUSY; 400 } 401 402 if (!errCode) { 403 usbvision_begin_streaming(usbvision); 404 errCode = usbvision_init_isoc(usbvision); 405 /* device must be initialized before isoc transfer */ 406 usbvision_muxsel(usbvision,0); 407 usbvision->user++; 408 } else { 409 if (PowerOnAtOpen) { 410 usbvision_i2c_unregister(usbvision); 411 usbvision_power_off(usbvision); 412 usbvision->initialized = 0; 413 } 414 } 415 mutex_unlock(&usbvision->lock); 416 } 417 418 /* prepare queues */ 419 usbvision_empty_framequeues(usbvision); 420 421 PDEBUG(DBG_IO, "success"); 422 unlock_kernel(); 423 return errCode; 424} 425 426/* 427 * usbvision_v4l2_close() 428 * 429 * This is part of Video 4 Linux API. The procedure 430 * stops streaming and deallocates all buffers that were earlier 431 * allocated in usbvision_v4l2_open(). 432 * 433 */ 434static int usbvision_v4l2_close(struct file *file) 435{ 436 struct usb_usbvision *usbvision = video_drvdata(file); 437 438 PDEBUG(DBG_IO, "close"); 439 mutex_lock(&usbvision->lock); 440 441 usbvision_audio_off(usbvision); 442 usbvision_restart_isoc(usbvision); 443 usbvision_stop_isoc(usbvision); 444 445 usbvision_decompress_free(usbvision); 446 usbvision_frames_free(usbvision); 447 usbvision_empty_framequeues(usbvision); 448 usbvision_scratch_free(usbvision); 449 450 usbvision->user--; 451 452 if (PowerOnAtOpen) { 453 /* power off in a little while 454 to avoid off/on every close/open short sequences */ 455 usbvision_set_powerOffTimer(usbvision); 456 usbvision->initialized = 0; 457 } 458 459 mutex_unlock(&usbvision->lock); 460 461 if (usbvision->remove_pending) { 462 printk(KERN_INFO "%s: Final disconnect\n", __func__); 463 usbvision_release(usbvision); 464 } 465 466 PDEBUG(DBG_IO, "success"); 467 return 0; 468} 469 470 471/* 472 * usbvision_ioctl() 473 * 474 * This is part of Video 4 Linux API. The procedure handles ioctl() calls. 475 * 476 */ 477#ifdef CONFIG_VIDEO_ADV_DEBUG 478static int vidioc_g_register (struct file *file, void *priv, 479 struct v4l2_dbg_register *reg) 480{ 481 struct usb_usbvision *usbvision = video_drvdata(file); 482 int errCode; 483 484 if (!v4l2_chip_match_host(®->match)) 485 return -EINVAL; 486 /* NT100x has a 8-bit register space */ 487 errCode = usbvision_read_reg(usbvision, reg->reg&0xff); 488 if (errCode < 0) { 489 dev_err(&usbvision->vdev->dev, 490 "%s: VIDIOC_DBG_G_REGISTER failed: error %d\n", 491 __func__, errCode); 492 return errCode; 493 } 494 reg->val = errCode; 495 reg->size = 1; 496 return 0; 497} 498 499static int vidioc_s_register (struct file *file, void *priv, 500 struct v4l2_dbg_register *reg) 501{ 502 struct usb_usbvision *usbvision = video_drvdata(file); 503 int errCode; 504 505 if (!v4l2_chip_match_host(®->match)) 506 return -EINVAL; 507 /* NT100x has a 8-bit register space */ 508 errCode = usbvision_write_reg(usbvision, reg->reg&0xff, reg->val); 509 if (errCode < 0) { 510 dev_err(&usbvision->vdev->dev, 511 "%s: VIDIOC_DBG_S_REGISTER failed: error %d\n", 512 __func__, errCode); 513 return errCode; 514 } 515 return 0; 516} 517#endif 518 519static int vidioc_querycap (struct file *file, void *priv, 520 struct v4l2_capability *vc) 521{ 522 struct usb_usbvision *usbvision = video_drvdata(file); 523 524 strlcpy(vc->driver, "USBVision", sizeof(vc->driver)); 525 strlcpy(vc->card, 526 usbvision_device_data[usbvision->DevModel].ModelString, 527 sizeof(vc->card)); 528 usb_make_path(usbvision->dev, vc->bus_info, sizeof(vc->bus_info)); 529 vc->version = USBVISION_DRIVER_VERSION; 530 vc->capabilities = V4L2_CAP_VIDEO_CAPTURE | 531 V4L2_CAP_AUDIO | 532 V4L2_CAP_READWRITE | 533 V4L2_CAP_STREAMING | 534 (usbvision->have_tuner ? V4L2_CAP_TUNER : 0); 535 return 0; 536} 537 538static int vidioc_enum_input (struct file *file, void *priv, 539 struct v4l2_input *vi) 540{ 541 struct usb_usbvision *usbvision = video_drvdata(file); 542 int chan; 543 544 if ((vi->index >= usbvision->video_inputs) || (vi->index < 0) ) 545 return -EINVAL; 546 if (usbvision->have_tuner) { 547 chan = vi->index; 548 } else { 549 chan = vi->index + 1; /*skip Television string*/ 550 } 551 /* Determine the requested input characteristics 552 specific for each usbvision card model */ 553 switch(chan) { 554 case 0: 555 if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) { 556 strcpy(vi->name, "White Video Input"); 557 } else { 558 strcpy(vi->name, "Television"); 559 vi->type = V4L2_INPUT_TYPE_TUNER; 560 vi->audioset = 1; 561 vi->tuner = chan; 562 vi->std = USBVISION_NORMS; 563 } 564 break; 565 case 1: 566 vi->type = V4L2_INPUT_TYPE_CAMERA; 567 if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) { 568 strcpy(vi->name, "Green Video Input"); 569 } else { 570 strcpy(vi->name, "Composite Video Input"); 571 } 572 vi->std = V4L2_STD_PAL; 573 break; 574 case 2: 575 vi->type = V4L2_INPUT_TYPE_CAMERA; 576 if (usbvision_device_data[usbvision->DevModel].VideoChannels == 4) { 577 strcpy(vi->name, "Yellow Video Input"); 578 } else { 579 strcpy(vi->name, "S-Video Input"); 580 } 581 vi->std = V4L2_STD_PAL; 582 break; 583 case 3: 584 vi->type = V4L2_INPUT_TYPE_CAMERA; 585 strcpy(vi->name, "Red Video Input"); 586 vi->std = V4L2_STD_PAL; 587 break; 588 } 589 return 0; 590} 591 592static int vidioc_g_input (struct file *file, void *priv, unsigned int *input) 593{ 594 struct usb_usbvision *usbvision = video_drvdata(file); 595 596 *input = usbvision->ctl_input; 597 return 0; 598} 599 600static int vidioc_s_input (struct file *file, void *priv, unsigned int input) 601{ 602 struct usb_usbvision *usbvision = video_drvdata(file); 603 604 if ((input >= usbvision->video_inputs) || (input < 0) ) 605 return -EINVAL; 606 607 mutex_lock(&usbvision->lock); 608 usbvision_muxsel(usbvision, input); 609 usbvision_set_input(usbvision); 610 usbvision_set_output(usbvision, 611 usbvision->curwidth, 612 usbvision->curheight); 613 mutex_unlock(&usbvision->lock); 614 return 0; 615} 616 617static int vidioc_s_std (struct file *file, void *priv, v4l2_std_id *id) 618{ 619 struct usb_usbvision *usbvision = video_drvdata(file); 620 621 usbvision->tvnormId=*id; 622 623 mutex_lock(&usbvision->lock); 624 call_all(usbvision, tuner, s_std, usbvision->tvnormId); 625 mutex_unlock(&usbvision->lock); 626 /* propagate the change to the decoder */ 627 usbvision_muxsel(usbvision, usbvision->ctl_input); 628 629 return 0; 630} 631 632static int vidioc_g_tuner (struct file *file, void *priv, 633 struct v4l2_tuner *vt) 634{ 635 struct usb_usbvision *usbvision = video_drvdata(file); 636 637 if (!usbvision->have_tuner || vt->index) // Only tuner 0 638 return -EINVAL; 639 if(usbvision->radio) { 640 strcpy(vt->name, "Radio"); 641 vt->type = V4L2_TUNER_RADIO; 642 } else { 643 strcpy(vt->name, "Television"); 644 } 645 /* Let clients fill in the remainder of this struct */ 646 call_all(usbvision, tuner, g_tuner, vt); 647 648 return 0; 649} 650 651static int vidioc_s_tuner (struct file *file, void *priv, 652 struct v4l2_tuner *vt) 653{ 654 struct usb_usbvision *usbvision = video_drvdata(file); 655 656 // Only no or one tuner for now 657 if (!usbvision->have_tuner || vt->index) 658 return -EINVAL; 659 /* let clients handle this */ 660 call_all(usbvision, tuner, s_tuner, vt); 661 662 return 0; 663} 664 665static int vidioc_g_frequency (struct file *file, void *priv, 666 struct v4l2_frequency *freq) 667{ 668 struct usb_usbvision *usbvision = video_drvdata(file); 669 670 freq->tuner = 0; // Only one tuner 671 if(usbvision->radio) { 672 freq->type = V4L2_TUNER_RADIO; 673 } else { 674 freq->type = V4L2_TUNER_ANALOG_TV; 675 } 676 freq->frequency = usbvision->freq; 677 678 return 0; 679} 680 681static int vidioc_s_frequency (struct file *file, void *priv, 682 struct v4l2_frequency *freq) 683{ 684 struct usb_usbvision *usbvision = video_drvdata(file); 685 686 // Only no or one tuner for now 687 if (!usbvision->have_tuner || freq->tuner) 688 return -EINVAL; 689 690 usbvision->freq = freq->frequency; 691 call_all(usbvision, tuner, s_frequency, freq); 692 693 return 0; 694} 695 696static int vidioc_g_audio (struct file *file, void *priv, struct v4l2_audio *a) 697{ 698 struct usb_usbvision *usbvision = video_drvdata(file); 699 700 if(usbvision->radio) { 701 strcpy(a->name,"Radio"); 702 } else { 703 strcpy(a->name, "TV"); 704 } 705 706 return 0; 707} 708 709static int vidioc_s_audio (struct file *file, void *fh, 710 struct v4l2_audio *a) 711{ 712 if(a->index) { 713 return -EINVAL; 714 } 715 716 return 0; 717} 718 719static int vidioc_queryctrl (struct file *file, void *priv, 720 struct v4l2_queryctrl *ctrl) 721{ 722 struct usb_usbvision *usbvision = video_drvdata(file); 723 724 call_all(usbvision, core, queryctrl, ctrl); 725 726 if (!ctrl->type) 727 return -EINVAL; 728 729 return 0; 730} 731 732static int vidioc_g_ctrl (struct file *file, void *priv, 733 struct v4l2_control *ctrl) 734{ 735 struct usb_usbvision *usbvision = video_drvdata(file); 736 call_all(usbvision, core, g_ctrl, ctrl); 737 738 return 0; 739} 740 741static int vidioc_s_ctrl (struct file *file, void *priv, 742 struct v4l2_control *ctrl) 743{ 744 struct usb_usbvision *usbvision = video_drvdata(file); 745 call_all(usbvision, core, s_ctrl, ctrl); 746 747 return 0; 748} 749 750static int vidioc_reqbufs (struct file *file, 751 void *priv, struct v4l2_requestbuffers *vr) 752{ 753 struct usb_usbvision *usbvision = video_drvdata(file); 754 int ret; 755 756 RESTRICT_TO_RANGE(vr->count,1,USBVISION_NUMFRAMES); 757 758 /* Check input validity: 759 the user must do a VIDEO CAPTURE and MMAP method. */ 760 if (vr->memory != V4L2_MEMORY_MMAP) 761 return -EINVAL; 762 763 if(usbvision->streaming == Stream_On) { 764 if ((ret = usbvision_stream_interrupt(usbvision))) 765 return ret; 766 } 767 768 usbvision_frames_free(usbvision); 769 usbvision_empty_framequeues(usbvision); 770 vr->count = usbvision_frames_alloc(usbvision,vr->count); 771 772 usbvision->curFrame = NULL; 773 774 return 0; 775} 776 777static int vidioc_querybuf (struct file *file, 778 void *priv, struct v4l2_buffer *vb) 779{ 780 struct usb_usbvision *usbvision = video_drvdata(file); 781 struct usbvision_frame *frame; 782 783 /* FIXME : must control 784 that buffers are mapped (VIDIOC_REQBUFS has been called) */ 785 if(vb->index>=usbvision->num_frames) { 786 return -EINVAL; 787 } 788 /* Updating the corresponding frame state */ 789 vb->flags = 0; 790 frame = &usbvision->frame[vb->index]; 791 if(frame->grabstate >= FrameState_Ready) 792 vb->flags |= V4L2_BUF_FLAG_QUEUED; 793 if(frame->grabstate >= FrameState_Done) 794 vb->flags |= V4L2_BUF_FLAG_DONE; 795 if(frame->grabstate == FrameState_Unused) 796 vb->flags |= V4L2_BUF_FLAG_MAPPED; 797 vb->memory = V4L2_MEMORY_MMAP; 798 799 vb->m.offset = vb->index*PAGE_ALIGN(usbvision->max_frame_size); 800 801 vb->memory = V4L2_MEMORY_MMAP; 802 vb->field = V4L2_FIELD_NONE; 803 vb->length = usbvision->curwidth* 804 usbvision->curheight* 805 usbvision->palette.bytes_per_pixel; 806 vb->timestamp = usbvision->frame[vb->index].timestamp; 807 vb->sequence = usbvision->frame[vb->index].sequence; 808 return 0; 809} 810 811static int vidioc_qbuf (struct file *file, void *priv, struct v4l2_buffer *vb) 812{ 813 struct usb_usbvision *usbvision = video_drvdata(file); 814 struct usbvision_frame *frame; 815 unsigned long lock_flags; 816 817 /* FIXME : works only on VIDEO_CAPTURE MODE, MMAP. */ 818 if(vb->index>=usbvision->num_frames) { 819 return -EINVAL; 820 } 821 822 frame = &usbvision->frame[vb->index]; 823 824 if (frame->grabstate != FrameState_Unused) { 825 return -EAGAIN; 826 } 827 828 /* Mark it as ready and enqueue frame */ 829 frame->grabstate = FrameState_Ready; 830 frame->scanstate = ScanState_Scanning; 831 frame->scanlength = 0; /* Accumulated in usbvision_parse_data() */ 832 833 vb->flags &= ~V4L2_BUF_FLAG_DONE; 834 835 /* set v4l2_format index */ 836 frame->v4l2_format = usbvision->palette; 837 838 spin_lock_irqsave(&usbvision->queue_lock, lock_flags); 839 list_add_tail(&usbvision->frame[vb->index].frame, &usbvision->inqueue); 840 spin_unlock_irqrestore(&usbvision->queue_lock, lock_flags); 841 842 return 0; 843} 844 845static int vidioc_dqbuf (struct file *file, void *priv, struct v4l2_buffer *vb) 846{ 847 struct usb_usbvision *usbvision = video_drvdata(file); 848 int ret; 849 struct usbvision_frame *f; 850 unsigned long lock_flags; 851 852 if (list_empty(&(usbvision->outqueue))) { 853 if (usbvision->streaming == Stream_Idle) 854 return -EINVAL; 855 ret = wait_event_interruptible 856 (usbvision->wait_frame, 857 !list_empty(&(usbvision->outqueue))); 858 if (ret) 859 return ret; 860 } 861 862 spin_lock_irqsave(&usbvision->queue_lock, lock_flags); 863 f = list_entry(usbvision->outqueue.next, 864 struct usbvision_frame, frame); 865 list_del(usbvision->outqueue.next); 866 spin_unlock_irqrestore(&usbvision->queue_lock, lock_flags); 867 868 f->grabstate = FrameState_Unused; 869 870 vb->memory = V4L2_MEMORY_MMAP; 871 vb->flags = V4L2_BUF_FLAG_MAPPED | 872 V4L2_BUF_FLAG_QUEUED | 873 V4L2_BUF_FLAG_DONE; 874 vb->index = f->index; 875 vb->sequence = f->sequence; 876 vb->timestamp = f->timestamp; 877 vb->field = V4L2_FIELD_NONE; 878 vb->bytesused = f->scanlength; 879 880 return 0; 881} 882 883static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i) 884{ 885 struct usb_usbvision *usbvision = video_drvdata(file); 886 887 usbvision->streaming = Stream_On; 888 call_all(usbvision, video, s_stream, 1); 889 890 return 0; 891} 892 893static int vidioc_streamoff(struct file *file, 894 void *priv, enum v4l2_buf_type type) 895{ 896 struct usb_usbvision *usbvision = video_drvdata(file); 897 898 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 899 return -EINVAL; 900 901 if(usbvision->streaming == Stream_On) { 902 usbvision_stream_interrupt(usbvision); 903 /* Stop all video streamings */ 904 call_all(usbvision, video, s_stream, 0); 905 } 906 usbvision_empty_framequeues(usbvision); 907 908 return 0; 909} 910 911static int vidioc_enum_fmt_vid_cap (struct file *file, void *priv, 912 struct v4l2_fmtdesc *vfd) 913{ 914 if(vfd->index>=USBVISION_SUPPORTED_PALETTES-1) { 915 return -EINVAL; 916 } 917 strcpy(vfd->description,usbvision_v4l2_format[vfd->index].desc); 918 vfd->pixelformat = usbvision_v4l2_format[vfd->index].format; 919 return 0; 920} 921 922static int vidioc_g_fmt_vid_cap (struct file *file, void *priv, 923 struct v4l2_format *vf) 924{ 925 struct usb_usbvision *usbvision = video_drvdata(file); 926 vf->fmt.pix.width = usbvision->curwidth; 927 vf->fmt.pix.height = usbvision->curheight; 928 vf->fmt.pix.pixelformat = usbvision->palette.format; 929 vf->fmt.pix.bytesperline = 930 usbvision->curwidth*usbvision->palette.bytes_per_pixel; 931 vf->fmt.pix.sizeimage = vf->fmt.pix.bytesperline*usbvision->curheight; 932 vf->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 933 vf->fmt.pix.field = V4L2_FIELD_NONE; /* Always progressive image */ 934 935 return 0; 936} 937 938static int vidioc_try_fmt_vid_cap (struct file *file, void *priv, 939 struct v4l2_format *vf) 940{ 941 struct usb_usbvision *usbvision = video_drvdata(file); 942 int formatIdx; 943 944 /* Find requested format in available ones */ 945 for(formatIdx=0;formatIdx<USBVISION_SUPPORTED_PALETTES;formatIdx++) { 946 if(vf->fmt.pix.pixelformat == 947 usbvision_v4l2_format[formatIdx].format) { 948 usbvision->palette = usbvision_v4l2_format[formatIdx]; 949 break; 950 } 951 } 952 /* robustness */ 953 if(formatIdx == USBVISION_SUPPORTED_PALETTES) { 954 return -EINVAL; 955 } 956 RESTRICT_TO_RANGE(vf->fmt.pix.width, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH); 957 RESTRICT_TO_RANGE(vf->fmt.pix.height, MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT); 958 959 vf->fmt.pix.bytesperline = vf->fmt.pix.width* 960 usbvision->palette.bytes_per_pixel; 961 vf->fmt.pix.sizeimage = vf->fmt.pix.bytesperline*vf->fmt.pix.height; 962 963 return 0; 964} 965 966static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 967 struct v4l2_format *vf) 968{ 969 struct usb_usbvision *usbvision = video_drvdata(file); 970 int ret; 971 972 if( 0 != (ret=vidioc_try_fmt_vid_cap (file, priv, vf)) ) { 973 return ret; 974 } 975 976 /* stop io in case it is already in progress */ 977 if(usbvision->streaming == Stream_On) { 978 if ((ret = usbvision_stream_interrupt(usbvision))) 979 return ret; 980 } 981 usbvision_frames_free(usbvision); 982 usbvision_empty_framequeues(usbvision); 983 984 usbvision->curFrame = NULL; 985 986 /* by now we are committed to the new data... */ 987 mutex_lock(&usbvision->lock); 988 usbvision_set_output(usbvision, vf->fmt.pix.width, vf->fmt.pix.height); 989 mutex_unlock(&usbvision->lock); 990 991 return 0; 992} 993 994static ssize_t usbvision_v4l2_read(struct file *file, char __user *buf, 995 size_t count, loff_t *ppos) 996{ 997 struct usb_usbvision *usbvision = video_drvdata(file); 998 int noblock = file->f_flags & O_NONBLOCK; 999 unsigned long lock_flags; 1000 1001 int ret,i; 1002 struct usbvision_frame *frame; 1003 1004 PDEBUG(DBG_IO, "%s: %ld bytes, noblock=%d", __func__, 1005 (unsigned long)count, noblock); 1006 1007 if (!USBVISION_IS_OPERATIONAL(usbvision) || (buf == NULL)) 1008 return -EFAULT; 1009 1010 /* This entry point is compatible with the mmap routines 1011 so that a user can do either VIDIOC_QBUF/VIDIOC_DQBUF 1012 to get frames or call read on the device. */ 1013 if(!usbvision->num_frames) { 1014 /* First, allocate some frames to work with 1015 if this has not been done with VIDIOC_REQBUF */ 1016 usbvision_frames_free(usbvision); 1017 usbvision_empty_framequeues(usbvision); 1018 usbvision_frames_alloc(usbvision,USBVISION_NUMFRAMES); 1019 } 1020 1021 if(usbvision->streaming != Stream_On) { 1022 /* no stream is running, make it running ! */ 1023 usbvision->streaming = Stream_On; 1024 call_all(usbvision, video, s_stream, 1); 1025 } 1026 1027 /* Then, enqueue as many frames as possible 1028 (like a user of VIDIOC_QBUF would do) */ 1029 for(i=0;i<usbvision->num_frames;i++) { 1030 frame = &usbvision->frame[i]; 1031 if(frame->grabstate == FrameState_Unused) { 1032 /* Mark it as ready and enqueue frame */ 1033 frame->grabstate = FrameState_Ready; 1034 frame->scanstate = ScanState_Scanning; 1035 /* Accumulated in usbvision_parse_data() */ 1036 frame->scanlength = 0; 1037 1038 /* set v4l2_format index */ 1039 frame->v4l2_format = usbvision->palette; 1040 1041 spin_lock_irqsave(&usbvision->queue_lock, lock_flags); 1042 list_add_tail(&frame->frame, &usbvision->inqueue); 1043 spin_unlock_irqrestore(&usbvision->queue_lock, 1044 lock_flags); 1045 } 1046 } 1047 1048 /* Then try to steal a frame (like a VIDIOC_DQBUF would do) */ 1049 if (list_empty(&(usbvision->outqueue))) { 1050 if(noblock) 1051 return -EAGAIN; 1052 1053 ret = wait_event_interruptible 1054 (usbvision->wait_frame, 1055 !list_empty(&(usbvision->outqueue))); 1056 if (ret) 1057 return ret; 1058 } 1059 1060 spin_lock_irqsave(&usbvision->queue_lock, lock_flags); 1061 frame = list_entry(usbvision->outqueue.next, 1062 struct usbvision_frame, frame); 1063 list_del(usbvision->outqueue.next); 1064 spin_unlock_irqrestore(&usbvision->queue_lock, lock_flags); 1065 1066 /* An error returns an empty frame */ 1067 if (frame->grabstate == FrameState_Error) { 1068 frame->bytes_read = 0; 1069 return 0; 1070 } 1071 1072 PDEBUG(DBG_IO, "%s: frmx=%d, bytes_read=%ld, scanlength=%ld", 1073 __func__, 1074 frame->index, frame->bytes_read, frame->scanlength); 1075 1076 /* copy bytes to user space; we allow for partials reads */ 1077 if ((count + frame->bytes_read) > (unsigned long)frame->scanlength) 1078 count = frame->scanlength - frame->bytes_read; 1079 1080 if (copy_to_user(buf, frame->data + frame->bytes_read, count)) { 1081 return -EFAULT; 1082 } 1083 1084 frame->bytes_read += count; 1085 PDEBUG(DBG_IO, "%s: {copy} count used=%ld, new bytes_read=%ld", 1086 __func__, 1087 (unsigned long)count, frame->bytes_read); 1088 1089 /* For now, forget the frame if it has not been read in one shot. */ 1090/* if (frame->bytes_read >= frame->scanlength) {// All data has been read */ 1091 frame->bytes_read = 0; 1092 1093 /* Mark it as available to be used again. */ 1094 frame->grabstate = FrameState_Unused; 1095/* } */ 1096 1097 return count; 1098} 1099 1100static int usbvision_v4l2_mmap(struct file *file, struct vm_area_struct *vma) 1101{ 1102 unsigned long size = vma->vm_end - vma->vm_start, 1103 start = vma->vm_start; 1104 void *pos; 1105 u32 i; 1106 struct usb_usbvision *usbvision = video_drvdata(file); 1107 1108 PDEBUG(DBG_MMAP, "mmap"); 1109 1110 mutex_lock(&usbvision->lock); 1111 1112 if (!USBVISION_IS_OPERATIONAL(usbvision)) { 1113 mutex_unlock(&usbvision->lock); 1114 return -EFAULT; 1115 } 1116 1117 if (!(vma->vm_flags & VM_WRITE) || 1118 size != PAGE_ALIGN(usbvision->max_frame_size)) { 1119 mutex_unlock(&usbvision->lock); 1120 return -EINVAL; 1121 } 1122 1123 for (i = 0; i < usbvision->num_frames; i++) { 1124 if (((PAGE_ALIGN(usbvision->max_frame_size)*i) >> PAGE_SHIFT) == 1125 vma->vm_pgoff) 1126 break; 1127 } 1128 if (i == usbvision->num_frames) { 1129 PDEBUG(DBG_MMAP, 1130 "mmap: user supplied mapping address is out of range"); 1131 mutex_unlock(&usbvision->lock); 1132 return -EINVAL; 1133 } 1134 1135 /* VM_IO is eventually going to replace PageReserved altogether */ 1136 vma->vm_flags |= VM_IO; 1137 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */ 1138 1139 pos = usbvision->frame[i].data; 1140 while (size > 0) { 1141 1142 if (vm_insert_page(vma, start, vmalloc_to_page(pos))) { 1143 PDEBUG(DBG_MMAP, "mmap: vm_insert_page failed"); 1144 mutex_unlock(&usbvision->lock); 1145 return -EAGAIN; 1146 } 1147 start += PAGE_SIZE; 1148 pos += PAGE_SIZE; 1149 size -= PAGE_SIZE; 1150 } 1151 1152 mutex_unlock(&usbvision->lock); 1153 return 0; 1154} 1155 1156 1157/* 1158 * Here comes the stuff for radio on usbvision based devices 1159 * 1160 */ 1161static int usbvision_radio_open(struct file *file) 1162{ 1163 struct usb_usbvision *usbvision = video_drvdata(file); 1164 int errCode = 0; 1165 1166 PDEBUG(DBG_IO, "%s:", __func__); 1167 1168 mutex_lock(&usbvision->lock); 1169 1170 if (usbvision->user) { 1171 dev_err(&usbvision->rdev->dev, 1172 "%s: Someone tried to open an already opened USBVision Radio!\n", 1173 __func__); 1174 errCode = -EBUSY; 1175 } 1176 else { 1177 if(PowerOnAtOpen) { 1178 usbvision_reset_powerOffTimer(usbvision); 1179 if (usbvision->power == 0) { 1180 usbvision_power_on(usbvision); 1181 usbvision_i2c_register(usbvision); 1182 } 1183 } 1184 1185 /* Alternate interface 1 is is the biggest frame size */ 1186 errCode = usbvision_set_alternate(usbvision); 1187 if (errCode < 0) { 1188 usbvision->last_error = errCode; 1189 errCode = -EBUSY; 1190 goto out; 1191 } 1192 1193 // If so far no errors then we shall start the radio 1194 usbvision->radio = 1; 1195 call_all(usbvision, tuner, s_radio); 1196 usbvision_set_audio(usbvision, USBVISION_AUDIO_RADIO); 1197 usbvision->user++; 1198 } 1199 1200 if (errCode) { 1201 if (PowerOnAtOpen) { 1202 usbvision_i2c_unregister(usbvision); 1203 usbvision_power_off(usbvision); 1204 usbvision->initialized = 0; 1205 } 1206 } 1207out: 1208 mutex_unlock(&usbvision->lock); 1209 return errCode; 1210} 1211 1212 1213static int usbvision_radio_close(struct file *file) 1214{ 1215 struct usb_usbvision *usbvision = video_drvdata(file); 1216 int errCode = 0; 1217 1218 PDEBUG(DBG_IO, ""); 1219 1220 mutex_lock(&usbvision->lock); 1221 1222 /* Set packet size to 0 */ 1223 usbvision->ifaceAlt=0; 1224 errCode = usb_set_interface(usbvision->dev, usbvision->iface, 1225 usbvision->ifaceAlt); 1226 1227 usbvision_audio_off(usbvision); 1228 usbvision->radio=0; 1229 usbvision->user--; 1230 1231 if (PowerOnAtOpen) { 1232 usbvision_set_powerOffTimer(usbvision); 1233 usbvision->initialized = 0; 1234 } 1235 1236 mutex_unlock(&usbvision->lock); 1237 1238 if (usbvision->remove_pending) { 1239 printk(KERN_INFO "%s: Final disconnect\n", __func__); 1240 usbvision_release(usbvision); 1241 } 1242 1243 PDEBUG(DBG_IO, "success"); 1244 return errCode; 1245} 1246 1247/* 1248 * Here comes the stuff for vbi on usbvision based devices 1249 * 1250 */ 1251static int usbvision_vbi_open(struct file *file) 1252{ 1253 /* TODO */ 1254 return -ENODEV; 1255} 1256 1257static int usbvision_vbi_close(struct file *file) 1258{ 1259 /* TODO */ 1260 return -ENODEV; 1261} 1262 1263static long usbvision_do_vbi_ioctl(struct file *file, 1264 unsigned int cmd, void *arg) 1265{ 1266 /* TODO */ 1267 return -ENOIOCTLCMD; 1268} 1269 1270static long usbvision_vbi_ioctl(struct file *file, 1271 unsigned int cmd, unsigned long arg) 1272{ 1273 return video_usercopy(file, cmd, arg, usbvision_do_vbi_ioctl); 1274} 1275 1276 1277// 1278// Video registration stuff 1279// 1280 1281// Video template 1282static const struct v4l2_file_operations usbvision_fops = { 1283 .owner = THIS_MODULE, 1284 .open = usbvision_v4l2_open, 1285 .release = usbvision_v4l2_close, 1286 .read = usbvision_v4l2_read, 1287 .mmap = usbvision_v4l2_mmap, 1288 .ioctl = video_ioctl2, 1289/* .poll = video_poll, */ 1290}; 1291 1292static const struct v4l2_ioctl_ops usbvision_ioctl_ops = { 1293 .vidioc_querycap = vidioc_querycap, 1294 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 1295 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 1296 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 1297 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 1298 .vidioc_reqbufs = vidioc_reqbufs, 1299 .vidioc_querybuf = vidioc_querybuf, 1300 .vidioc_qbuf = vidioc_qbuf, 1301 .vidioc_dqbuf = vidioc_dqbuf, 1302 .vidioc_s_std = vidioc_s_std, 1303 .vidioc_enum_input = vidioc_enum_input, 1304 .vidioc_g_input = vidioc_g_input, 1305 .vidioc_s_input = vidioc_s_input, 1306 .vidioc_queryctrl = vidioc_queryctrl, 1307 .vidioc_g_audio = vidioc_g_audio, 1308 .vidioc_s_audio = vidioc_s_audio, 1309 .vidioc_g_ctrl = vidioc_g_ctrl, 1310 .vidioc_s_ctrl = vidioc_s_ctrl, 1311 .vidioc_streamon = vidioc_streamon, 1312 .vidioc_streamoff = vidioc_streamoff, 1313#ifdef CONFIG_VIDEO_V4L1_COMPAT 1314/* .vidiocgmbuf = vidiocgmbuf, */ 1315#endif 1316 .vidioc_g_tuner = vidioc_g_tuner, 1317 .vidioc_s_tuner = vidioc_s_tuner, 1318 .vidioc_g_frequency = vidioc_g_frequency, 1319 .vidioc_s_frequency = vidioc_s_frequency, 1320#ifdef CONFIG_VIDEO_ADV_DEBUG 1321 .vidioc_g_register = vidioc_g_register, 1322 .vidioc_s_register = vidioc_s_register, 1323#endif 1324}; 1325 1326static struct video_device usbvision_video_template = { 1327 .fops = &usbvision_fops, 1328 .ioctl_ops = &usbvision_ioctl_ops, 1329 .name = "usbvision-video", 1330 .release = video_device_release, 1331 .minor = -1, 1332 .tvnorms = USBVISION_NORMS, 1333 .current_norm = V4L2_STD_PAL 1334}; 1335 1336 1337// Radio template 1338static const struct v4l2_file_operations usbvision_radio_fops = { 1339 .owner = THIS_MODULE, 1340 .open = usbvision_radio_open, 1341 .release = usbvision_radio_close, 1342 .ioctl = video_ioctl2, 1343}; 1344 1345static const struct v4l2_ioctl_ops usbvision_radio_ioctl_ops = { 1346 .vidioc_querycap = vidioc_querycap, 1347 .vidioc_enum_input = vidioc_enum_input, 1348 .vidioc_g_input = vidioc_g_input, 1349 .vidioc_s_input = vidioc_s_input, 1350 .vidioc_queryctrl = vidioc_queryctrl, 1351 .vidioc_g_audio = vidioc_g_audio, 1352 .vidioc_s_audio = vidioc_s_audio, 1353 .vidioc_g_ctrl = vidioc_g_ctrl, 1354 .vidioc_s_ctrl = vidioc_s_ctrl, 1355 .vidioc_g_tuner = vidioc_g_tuner, 1356 .vidioc_s_tuner = vidioc_s_tuner, 1357 .vidioc_g_frequency = vidioc_g_frequency, 1358 .vidioc_s_frequency = vidioc_s_frequency, 1359}; 1360 1361static struct video_device usbvision_radio_template = { 1362 .fops = &usbvision_radio_fops, 1363 .name = "usbvision-radio", 1364 .release = video_device_release, 1365 .minor = -1, 1366 .ioctl_ops = &usbvision_radio_ioctl_ops, 1367 1368 .tvnorms = USBVISION_NORMS, 1369 .current_norm = V4L2_STD_PAL 1370}; 1371 1372// vbi template 1373static const struct v4l2_file_operations usbvision_vbi_fops = { 1374 .owner = THIS_MODULE, 1375 .open = usbvision_vbi_open, 1376 .release = usbvision_vbi_close, 1377 .ioctl = usbvision_vbi_ioctl, 1378}; 1379 1380static struct video_device usbvision_vbi_template= 1381{ 1382 .fops = &usbvision_vbi_fops, 1383 .release = video_device_release, 1384 .name = "usbvision-vbi", 1385 .minor = -1, 1386}; 1387 1388 1389static struct video_device *usbvision_vdev_init(struct usb_usbvision *usbvision, 1390 struct video_device *vdev_template, 1391 char *name) 1392{ 1393 struct usb_device *usb_dev = usbvision->dev; 1394 struct video_device *vdev; 1395 1396 if (usb_dev == NULL) { 1397 dev_err(&usbvision->dev->dev, 1398 "%s: usbvision->dev is not set\n", __func__); 1399 return NULL; 1400 } 1401 1402 vdev = video_device_alloc(); 1403 if (NULL == vdev) { 1404 return NULL; 1405 } 1406 *vdev = *vdev_template; 1407// vdev->minor = -1; 1408 vdev->v4l2_dev = &usbvision->v4l2_dev; 1409 snprintf(vdev->name, sizeof(vdev->name), "%s", name); 1410 video_set_drvdata(vdev, usbvision); 1411 return vdev; 1412} 1413 1414// unregister video4linux devices 1415static void usbvision_unregister_video(struct usb_usbvision *usbvision) 1416{ 1417 // vbi Device: 1418 if (usbvision->vbi) { 1419 PDEBUG(DBG_PROBE, "unregister /dev/vbi%d [v4l2]", 1420 usbvision->vbi->num); 1421 if (usbvision->vbi->minor != -1) { 1422 video_unregister_device(usbvision->vbi); 1423 } else { 1424 video_device_release(usbvision->vbi); 1425 } 1426 usbvision->vbi = NULL; 1427 } 1428 1429 // Radio Device: 1430 if (usbvision->rdev) { 1431 PDEBUG(DBG_PROBE, "unregister /dev/radio%d [v4l2]", 1432 usbvision->rdev->num); 1433 if (usbvision->rdev->minor != -1) { 1434 video_unregister_device(usbvision->rdev); 1435 } else { 1436 video_device_release(usbvision->rdev); 1437 } 1438 usbvision->rdev = NULL; 1439 } 1440 1441 // Video Device: 1442 if (usbvision->vdev) { 1443 PDEBUG(DBG_PROBE, "unregister /dev/video%d [v4l2]", 1444 usbvision->vdev->num); 1445 if (usbvision->vdev->minor != -1) { 1446 video_unregister_device(usbvision->vdev); 1447 } else { 1448 video_device_release(usbvision->vdev); 1449 } 1450 usbvision->vdev = NULL; 1451 } 1452} 1453 1454// register video4linux devices 1455static int __devinit usbvision_register_video(struct usb_usbvision *usbvision) 1456{ 1457 // Video Device: 1458 usbvision->vdev = usbvision_vdev_init(usbvision, 1459 &usbvision_video_template, 1460 "USBVision Video"); 1461 if (usbvision->vdev == NULL) { 1462 goto err_exit; 1463 } 1464 if (video_register_device(usbvision->vdev, 1465 VFL_TYPE_GRABBER, 1466 video_nr)<0) { 1467 goto err_exit; 1468 } 1469 printk(KERN_INFO "USBVision[%d]: registered USBVision Video device /dev/video%d [v4l2]\n", 1470 usbvision->nr, usbvision->vdev->num); 1471 1472 // Radio Device: 1473 if (usbvision_device_data[usbvision->DevModel].Radio) { 1474 // usbvision has radio 1475 usbvision->rdev = usbvision_vdev_init(usbvision, 1476 &usbvision_radio_template, 1477 "USBVision Radio"); 1478 if (usbvision->rdev == NULL) { 1479 goto err_exit; 1480 } 1481 if (video_register_device(usbvision->rdev, 1482 VFL_TYPE_RADIO, 1483 radio_nr)<0) { 1484 goto err_exit; 1485 } 1486 printk(KERN_INFO "USBVision[%d]: registered USBVision Radio device /dev/radio%d [v4l2]\n", 1487 usbvision->nr, usbvision->rdev->num); 1488 } 1489 // vbi Device: 1490 if (usbvision_device_data[usbvision->DevModel].vbi) { 1491 usbvision->vbi = usbvision_vdev_init(usbvision, 1492 &usbvision_vbi_template, 1493 "USBVision VBI"); 1494 if (usbvision->vdev == NULL) { 1495 goto err_exit; 1496 } 1497 if (video_register_device(usbvision->vbi, 1498 VFL_TYPE_VBI, 1499 vbi_nr)<0) { 1500 goto err_exit; 1501 } 1502 printk(KERN_INFO "USBVision[%d]: registered USBVision VBI device /dev/vbi%d [v4l2] (Not Working Yet!)\n", 1503 usbvision->nr, usbvision->vbi->num); 1504 } 1505 // all done 1506 return 0; 1507 1508 err_exit: 1509 dev_err(&usbvision->dev->dev, 1510 "USBVision[%d]: video_register_device() failed\n", 1511 usbvision->nr); 1512 usbvision_unregister_video(usbvision); 1513 return -1; 1514} 1515 1516/* 1517 * usbvision_alloc() 1518 * 1519 * This code allocates the struct usb_usbvision. 1520 * It is filled with default values. 1521 * 1522 * Returns NULL on error, a pointer to usb_usbvision else. 1523 * 1524 */ 1525static struct usb_usbvision *usbvision_alloc(struct usb_device *dev) 1526{ 1527 struct usb_usbvision *usbvision; 1528 1529 usbvision = kzalloc(sizeof(struct usb_usbvision), GFP_KERNEL); 1530 if (usbvision == NULL) 1531 return NULL; 1532 1533 usbvision->dev = dev; 1534 if (v4l2_device_register(&dev->dev, &usbvision->v4l2_dev)) 1535 goto err_free; 1536 1537 mutex_init(&usbvision->lock); /* available */ 1538 1539 // prepare control urb for control messages during interrupts 1540 usbvision->ctrlUrb = usb_alloc_urb(USBVISION_URB_FRAMES, GFP_KERNEL); 1541 if (usbvision->ctrlUrb == NULL) 1542 goto err_unreg; 1543 init_waitqueue_head(&usbvision->ctrlUrb_wq); 1544 1545 usbvision_init_powerOffTimer(usbvision); 1546 1547 return usbvision; 1548 1549err_unreg: 1550 v4l2_device_unregister(&usbvision->v4l2_dev); 1551err_free: 1552 kfree(usbvision); 1553 return NULL; 1554} 1555 1556/* 1557 * usbvision_release() 1558 * 1559 * This code does final release of struct usb_usbvision. This happens 1560 * after the device is disconnected -and- all clients closed their files. 1561 * 1562 */ 1563static void usbvision_release(struct usb_usbvision *usbvision) 1564{ 1565 PDEBUG(DBG_PROBE, ""); 1566 1567 mutex_lock(&usbvision->lock); 1568 1569 usbvision_reset_powerOffTimer(usbvision); 1570 1571 usbvision->initialized = 0; 1572 1573 mutex_unlock(&usbvision->lock); 1574 1575 usbvision_remove_sysfs(usbvision->vdev); 1576 usbvision_unregister_video(usbvision); 1577 1578 if (usbvision->ctrlUrb) { 1579 usb_free_urb(usbvision->ctrlUrb); 1580 } 1581 1582 v4l2_device_unregister(&usbvision->v4l2_dev); 1583 kfree(usbvision); 1584 1585 PDEBUG(DBG_PROBE, "success"); 1586} 1587 1588 1589/*********************** usb interface **********************************/ 1590 1591static void usbvision_configure_video(struct usb_usbvision *usbvision) 1592{ 1593 int model; 1594 1595 if (usbvision == NULL) 1596 return; 1597 1598 model = usbvision->DevModel; 1599 usbvision->palette = usbvision_v4l2_format[2]; // V4L2_PIX_FMT_RGB24; 1600 1601 if (usbvision_device_data[usbvision->DevModel].Vin_Reg2_override) { 1602 usbvision->Vin_Reg2_Preset = 1603 usbvision_device_data[usbvision->DevModel].Vin_Reg2; 1604 } else { 1605 usbvision->Vin_Reg2_Preset = 0; 1606 } 1607 1608 usbvision->tvnormId = usbvision_device_data[model].VideoNorm; 1609 1610 usbvision->video_inputs = usbvision_device_data[model].VideoChannels; 1611 usbvision->ctl_input = 0; 1612 1613 /* This should be here to make i2c clients to be able to register */ 1614 /* first switch off audio */ 1615 usbvision_audio_off(usbvision); 1616 if (!PowerOnAtOpen) { 1617 /* and then power up the noisy tuner */ 1618 usbvision_power_on(usbvision); 1619 usbvision_i2c_register(usbvision); 1620 } 1621} 1622 1623/* 1624 * usbvision_probe() 1625 * 1626 * This procedure queries device descriptor and accepts the interface 1627 * if it looks like USBVISION video device 1628 * 1629 */ 1630static int __devinit usbvision_probe(struct usb_interface *intf, 1631 const struct usb_device_id *devid) 1632{ 1633 struct usb_device *dev = usb_get_dev(interface_to_usbdev(intf)); 1634 struct usb_interface *uif; 1635 __u8 ifnum = intf->altsetting->desc.bInterfaceNumber; 1636 const struct usb_host_interface *interface; 1637 struct usb_usbvision *usbvision = NULL; 1638 const struct usb_endpoint_descriptor *endpoint; 1639 int model,i; 1640 1641 PDEBUG(DBG_PROBE, "VID=%#04x, PID=%#04x, ifnum=%u", 1642 dev->descriptor.idVendor, 1643 dev->descriptor.idProduct, ifnum); 1644 1645 model = devid->driver_info; 1646 if ( (model<0) || (model>=usbvision_device_data_size) ) { 1647 PDEBUG(DBG_PROBE, "model out of bounds %d",model); 1648 return -ENODEV; 1649 } 1650 printk(KERN_INFO "%s: %s found\n", __func__, 1651 usbvision_device_data[model].ModelString); 1652 1653 if (usbvision_device_data[model].Interface >= 0) { 1654 interface = &dev->actconfig->interface[usbvision_device_data[model].Interface]->altsetting[0]; 1655 } else { 1656 interface = &dev->actconfig->interface[ifnum]->altsetting[0]; 1657 } 1658 endpoint = &interface->endpoint[1].desc; 1659 if (!usb_endpoint_xfer_isoc(endpoint)) { 1660 dev_err(&intf->dev, "%s: interface %d. has non-ISO endpoint!\n", 1661 __func__, ifnum); 1662 dev_err(&intf->dev, "%s: Endpoint attributes %d", 1663 __func__, endpoint->bmAttributes); 1664 return -ENODEV; 1665 } 1666 if (usb_endpoint_dir_out(endpoint)) { 1667 dev_err(&intf->dev, "%s: interface %d. has ISO OUT endpoint!\n", 1668 __func__, ifnum); 1669 return -ENODEV; 1670 } 1671 1672 if ((usbvision = usbvision_alloc(dev)) == NULL) { 1673 dev_err(&intf->dev, "%s: couldn't allocate USBVision struct\n", __func__); 1674 return -ENOMEM; 1675 } 1676 1677 if (dev->descriptor.bNumConfigurations > 1) { 1678 usbvision->bridgeType = BRIDGE_NT1004; 1679 } else if (model == DAZZLE_DVC_90_REV_1_SECAM) { 1680 usbvision->bridgeType = BRIDGE_NT1005; 1681 } else { 1682 usbvision->bridgeType = BRIDGE_NT1003; 1683 } 1684 PDEBUG(DBG_PROBE, "bridgeType %d", usbvision->bridgeType); 1685 1686 mutex_lock(&usbvision->lock); 1687 1688 /* compute alternate max packet sizes */ 1689 uif = dev->actconfig->interface[0]; 1690 1691 usbvision->num_alt=uif->num_altsetting; 1692 PDEBUG(DBG_PROBE, "Alternate settings: %i",usbvision->num_alt); 1693 usbvision->alt_max_pkt_size = kmalloc(32* 1694 usbvision->num_alt,GFP_KERNEL); 1695 if (usbvision->alt_max_pkt_size == NULL) { 1696 dev_err(&intf->dev, "usbvision: out of memory!\n"); 1697 mutex_unlock(&usbvision->lock); 1698 return -ENOMEM; 1699 } 1700 1701 for (i = 0; i < usbvision->num_alt ; i++) { 1702 u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[1].desc. 1703 wMaxPacketSize); 1704 usbvision->alt_max_pkt_size[i] = 1705 (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1); 1706 PDEBUG(DBG_PROBE, "Alternate setting %i, max size= %i",i, 1707 usbvision->alt_max_pkt_size[i]); 1708 } 1709 1710 1711 usbvision->nr = usbvision_nr++; 1712 1713 usbvision->have_tuner = usbvision_device_data[model].Tuner; 1714 if (usbvision->have_tuner) { 1715 usbvision->tuner_type = usbvision_device_data[model].TunerType; 1716 } 1717 1718 usbvision->DevModel = model; 1719 usbvision->remove_pending = 0; 1720 usbvision->iface = ifnum; 1721 usbvision->ifaceAlt = 0; 1722 usbvision->video_endp = endpoint->bEndpointAddress; 1723 usbvision->isocPacketSize = 0; 1724 usbvision->usb_bandwidth = 0; 1725 usbvision->user = 0; 1726 usbvision->streaming = Stream_Off; 1727 usbvision_register_video(usbvision); 1728 usbvision_configure_video(usbvision); 1729 mutex_unlock(&usbvision->lock); 1730 1731 1732 usb_set_intfdata (intf, usbvision); 1733 usbvision_create_sysfs(usbvision->vdev); 1734 1735 PDEBUG(DBG_PROBE, "success"); 1736 return 0; 1737} 1738 1739 1740/* 1741 * usbvision_disconnect() 1742 * 1743 * This procedure stops all driver activity, deallocates interface-private 1744 * structure (pointed by 'ptr') and after that driver should be removable 1745 * with no ill consequences. 1746 * 1747 */ 1748static void __devexit usbvision_disconnect(struct usb_interface *intf) 1749{ 1750 struct usb_usbvision *usbvision = usb_get_intfdata(intf); 1751 1752 PDEBUG(DBG_PROBE, ""); 1753 1754 if (usbvision == NULL) { 1755 dev_err(&usbvision->dev->dev, 1756 "%s: usb_get_intfdata() failed\n", __func__); 1757 return; 1758 } 1759 usb_set_intfdata (intf, NULL); 1760 1761 mutex_lock(&usbvision->lock); 1762 1763 // At this time we ask to cancel outstanding URBs 1764 usbvision_stop_isoc(usbvision); 1765 1766 v4l2_device_disconnect(&usbvision->v4l2_dev); 1767 1768 if (usbvision->power) { 1769 usbvision_i2c_unregister(usbvision); 1770 usbvision_power_off(usbvision); 1771 } 1772 usbvision->remove_pending = 1; // Now all ISO data will be ignored 1773 1774 usb_put_dev(usbvision->dev); 1775 usbvision->dev = NULL; // USB device is no more 1776 1777 mutex_unlock(&usbvision->lock); 1778 1779 if (usbvision->user) { 1780 printk(KERN_INFO "%s: In use, disconnect pending\n", 1781 __func__); 1782 wake_up_interruptible(&usbvision->wait_frame); 1783 wake_up_interruptible(&usbvision->wait_stream); 1784 } else { 1785 usbvision_release(usbvision); 1786 } 1787 1788 PDEBUG(DBG_PROBE, "success"); 1789} 1790 1791static struct usb_driver usbvision_driver = { 1792 .name = "usbvision", 1793 .id_table = usbvision_table, 1794 .probe = usbvision_probe, 1795 .disconnect = usbvision_disconnect 1796}; 1797 1798/* 1799 * usbvision_init() 1800 * 1801 * This code is run to initialize the driver. 1802 * 1803 */ 1804static int __init usbvision_init(void) 1805{ 1806 int errCode; 1807 1808 PDEBUG(DBG_PROBE, ""); 1809 1810 PDEBUG(DBG_IO, "IO debugging is enabled [video]"); 1811 PDEBUG(DBG_PROBE, "PROBE debugging is enabled [video]"); 1812 PDEBUG(DBG_MMAP, "MMAP debugging is enabled [video]"); 1813 1814 /* disable planar mode support unless compression enabled */ 1815 if (isocMode != ISOC_MODE_COMPRESS ) { 1816 // FIXME : not the right way to set supported flag 1817 usbvision_v4l2_format[6].supported = 0; // V4L2_PIX_FMT_YVU420 1818 usbvision_v4l2_format[7].supported = 0; // V4L2_PIX_FMT_YUV422P 1819 } 1820 1821 errCode = usb_register(&usbvision_driver); 1822 1823 if (errCode == 0) { 1824 printk(KERN_INFO DRIVER_DESC " : " USBVISION_VERSION_STRING "\n"); 1825 PDEBUG(DBG_PROBE, "success"); 1826 } 1827 return errCode; 1828} 1829 1830static void __exit usbvision_exit(void) 1831{ 1832 PDEBUG(DBG_PROBE, ""); 1833 1834 usb_deregister(&usbvision_driver); 1835 PDEBUG(DBG_PROBE, "success"); 1836} 1837 1838module_init(usbvision_init); 1839module_exit(usbvision_exit); 1840 1841/* 1842 * Overrides for Emacs so that we follow Linus's tabbing style. 1843 * --------------------------------------------------------------------------- 1844 * Local variables: 1845 * c-basic-offset: 8 1846 * End: 1847 */ 1848