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