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