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