1/* 2 em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB video capture devices 3 4 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it> 5 Markus Rechberger <mrechberger@gmail.com> 6 Mauro Carvalho Chehab <mchehab@infradead.org> 7 Sascha Sommer <saschasommer@freenet.de> 8 9 Some parts based on SN9C10x PC Camera Controllers GPL driver made 10 by Luca Risolia <luca.risolia@studio.unibo.it> 11 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; either version 2 of the License, or 15 (at your option) any later version. 16 17 This program is distributed in the hope that it will be useful, 18 but WITHOUT ANY WARRANTY; without even the implied warranty of 19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 GNU General Public License for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with this program; if not, write to the Free Software 24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 25 */ 26 27#include <linux/init.h> 28#include <linux/list.h> 29#include <linux/module.h> 30#include <linux/kernel.h> 31#include <linux/bitmap.h> 32#include <linux/usb.h> 33#include <linux/i2c.h> 34#include <linux/version.h> 35#include <linux/video_decoder.h> 36#include <linux/mutex.h> 37 38#include "em28xx.h" 39#include <media/tuner.h> 40#include <media/v4l2-common.h> 41#include <media/msp3400.h> 42 43#define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \ 44 "Markus Rechberger <mrechberger@gmail.com>, " \ 45 "Mauro Carvalho Chehab <mchehab@infradead.org>, " \ 46 "Sascha Sommer <saschasommer@freenet.de>" 47 48#define DRIVER_NAME "em28xx" 49#define DRIVER_DESC "Empia em28xx based USB video device driver" 50#define EM28XX_VERSION_CODE KERNEL_VERSION(0, 0, 1) 51 52#define em28xx_videodbg(fmt, arg...) do {\ 53 if (video_debug) \ 54 printk(KERN_INFO "%s %s :"fmt, \ 55 dev->name, __FUNCTION__ , ##arg); } while (0) 56 57MODULE_AUTHOR(DRIVER_AUTHOR); 58MODULE_DESCRIPTION(DRIVER_DESC); 59MODULE_LICENSE("GPL"); 60 61static LIST_HEAD(em28xx_devlist); 62 63static unsigned int card[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET }; 64static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET }; 65static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET }; 66module_param_array(card, int, NULL, 0444); 67module_param_array(video_nr, int, NULL, 0444); 68module_param_array(vbi_nr, int, NULL, 0444); 69MODULE_PARM_DESC(card,"card type"); 70MODULE_PARM_DESC(video_nr,"video device numbers"); 71MODULE_PARM_DESC(vbi_nr,"vbi device numbers"); 72 73static int tuner = -1; 74module_param(tuner, int, 0444); 75MODULE_PARM_DESC(tuner, "tuner type"); 76 77static unsigned int video_debug = 0; 78module_param(video_debug,int,0644); 79MODULE_PARM_DESC(video_debug,"enable debug messages [video]"); 80 81/* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS */ 82static unsigned long em28xx_devused; 83 84/* supported tv norms */ 85static struct em28xx_tvnorm tvnorms[] = { 86 { 87 .name = "PAL", 88 .id = V4L2_STD_PAL, 89 .mode = VIDEO_MODE_PAL, 90 }, { 91 .name = "NTSC", 92 .id = V4L2_STD_NTSC, 93 .mode = VIDEO_MODE_NTSC, 94 }, { 95 .name = "SECAM", 96 .id = V4L2_STD_SECAM, 97 .mode = VIDEO_MODE_SECAM, 98 }, { 99 .name = "PAL-M", 100 .id = V4L2_STD_PAL_M, 101 .mode = VIDEO_MODE_PAL, 102 } 103}; 104 105#define TVNORMS ARRAY_SIZE(tvnorms) 106 107/* supported controls */ 108/* Common to all boards */ 109static struct v4l2_queryctrl em28xx_qctrl[] = { 110 { 111 .id = V4L2_CID_AUDIO_VOLUME, 112 .type = V4L2_CTRL_TYPE_INTEGER, 113 .name = "Volume", 114 .minimum = 0x0, 115 .maximum = 0x1f, 116 .step = 0x1, 117 .default_value = 0x1f, 118 .flags = 0, 119 },{ 120 .id = V4L2_CID_AUDIO_MUTE, 121 .type = V4L2_CTRL_TYPE_BOOLEAN, 122 .name = "Mute", 123 .minimum = 0, 124 .maximum = 1, 125 .step = 1, 126 .default_value = 1, 127 .flags = 0, 128 } 129}; 130 131static struct usb_driver em28xx_usb_driver; 132 133static DEFINE_MUTEX(em28xx_sysfs_lock); 134static DECLARE_RWSEM(em28xx_disconnect); 135 136/********************* v4l2 interface ******************************************/ 137 138/* 139 * em28xx_config() 140 * inits registers with sane defaults 141 */ 142static int em28xx_config(struct em28xx *dev) 143{ 144 145 /* Sets I2C speed to 100 KHz */ 146 em28xx_write_regs_req(dev, 0x00, 0x06, "\x40", 1); 147 148 /* enable vbi capturing */ 149 150/* em28xx_write_regs_req(dev,0x00,0x0e,"\xC0",1); audio register */ 151/* em28xx_write_regs_req(dev,0x00,0x0f,"\x80",1); clk register */ 152 em28xx_write_regs_req(dev,0x00,0x11,"\x51",1); 153 154 em28xx_audio_usb_mute(dev, 1); 155 dev->mute = 1; /* maybe not the right place... */ 156 dev->volume = 0x1f; 157 em28xx_audio_analog_set(dev); 158 em28xx_audio_analog_setup(dev); 159 em28xx_outfmt_set_yuv422(dev); 160 em28xx_colorlevels_set_default(dev); 161 em28xx_compression_disable(dev); 162 163 return 0; 164} 165 166/* 167 * em28xx_config_i2c() 168 * configure i2c attached devices 169 */ 170static void em28xx_config_i2c(struct em28xx *dev) 171{ 172 struct v4l2_frequency f; 173 struct v4l2_routing route; 174 175 route.input = INPUT(dev->ctl_input)->vmux; 176 route.output = 0; 177 em28xx_i2c_call_clients(dev, VIDIOC_INT_RESET, NULL); 178 em28xx_i2c_call_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route); 179 em28xx_i2c_call_clients(dev, VIDIOC_STREAMON, NULL); 180 181 /* configure tuner */ 182 f.tuner = 0; 183 f.type = V4L2_TUNER_ANALOG_TV; 184 f.frequency = 9076; 185 dev->ctl_freq = f.frequency; 186 em28xx_i2c_call_clients(dev, VIDIOC_S_FREQUENCY, &f); 187 188 /* configure tda9887 */ 189 190 191/* em28xx_i2c_call_clients(dev,VIDIOC_S_STD,&dev->tvnorm->id); */ 192} 193 194/* 195 * em28xx_empty_framequeues() 196 * prepare queues for incoming and outgoing frames 197 */ 198static void em28xx_empty_framequeues(struct em28xx *dev) 199{ 200 u32 i; 201 202 INIT_LIST_HEAD(&dev->inqueue); 203 INIT_LIST_HEAD(&dev->outqueue); 204 205 for (i = 0; i < EM28XX_NUM_FRAMES; i++) { 206 dev->frame[i].state = F_UNUSED; 207 dev->frame[i].buf.bytesused = 0; 208 } 209} 210 211static void video_mux(struct em28xx *dev, int index) 212{ 213 int ainput; 214 struct v4l2_routing route; 215 216 route.input = INPUT(index)->vmux; 217 route.output = 0; 218 dev->ctl_input = index; 219 dev->ctl_ainput = INPUT(index)->amux; 220 221 em28xx_i2c_call_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route); 222 223 em28xx_videodbg("Setting input index=%d, vmux=%d, amux=%d\n",index,route.input,dev->ctl_ainput); 224 225 if (dev->has_msp34xx) { 226 if (dev->i2s_speed) 227 em28xx_i2c_call_clients(dev, VIDIOC_INT_I2S_CLOCK_FREQ, &dev->i2s_speed); 228 route.input = dev->ctl_ainput; 229 route.output = MSP_OUTPUT(MSP_SC_IN_DSP_SCART1); 230 /* Note: this is msp3400 specific */ 231 em28xx_i2c_call_clients(dev, VIDIOC_INT_S_AUDIO_ROUTING, &route); 232 ainput = EM28XX_AUDIO_SRC_TUNER; 233 em28xx_audio_source(dev, ainput); 234 } else { 235 switch (dev->ctl_ainput) { 236 case 0: 237 ainput = EM28XX_AUDIO_SRC_TUNER; 238 break; 239 default: 240 ainput = EM28XX_AUDIO_SRC_LINE; 241 } 242 em28xx_audio_source(dev, ainput); 243 } 244} 245 246/* 247 * em28xx_v4l2_open() 248 * inits the device and starts isoc transfer 249 */ 250static int em28xx_v4l2_open(struct inode *inode, struct file *filp) 251{ 252 int minor = iminor(inode); 253 int errCode = 0; 254 struct em28xx *h,*dev = NULL; 255 struct list_head *list; 256 257 list_for_each(list,&em28xx_devlist) { 258 h = list_entry(list, struct em28xx, devlist); 259 if (h->vdev->minor == minor) { 260 dev = h; 261 dev->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 262 } 263 if (h->vbi_dev->minor == minor) { 264 dev = h; 265 dev->type = V4L2_BUF_TYPE_VBI_CAPTURE; 266 } 267 } 268 if (NULL == dev) 269 return -ENODEV; 270 271 filp->private_data=dev; 272 273 em28xx_videodbg("open minor=%d type=%s users=%d\n", 274 minor,v4l2_type_names[dev->type],dev->users); 275 276 if (!down_read_trylock(&em28xx_disconnect)) 277 return -ERESTARTSYS; 278 279 if (dev->users) { 280 em28xx_warn("this driver can be opened only once\n"); 281 up_read(&em28xx_disconnect); 282 return -EBUSY; 283 } 284 285 mutex_init(&dev->fileop_lock); /* to 1 == available */ 286 spin_lock_init(&dev->queue_lock); 287 init_waitqueue_head(&dev->wait_frame); 288 init_waitqueue_head(&dev->wait_stream); 289 290 mutex_lock(&dev->lock); 291 292 if (dev->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 293 em28xx_set_alternate(dev); 294 295 dev->width = norm_maxw(dev); 296 dev->height = norm_maxh(dev); 297 dev->frame_size = dev->width * dev->height * 2; 298 dev->field_size = dev->frame_size >> 1; /*both_fileds ? dev->frame_size>>1 : dev->frame_size; */ 299 dev->bytesperline = dev->width * 2; 300 dev->hscale = 0; 301 dev->vscale = 0; 302 303 em28xx_capture_start(dev, 1); 304 em28xx_resolution_set(dev); 305 306 /* device needs to be initialized before isoc transfer */ 307 video_mux(dev, 0); 308 309 /* start the transfer */ 310 errCode = em28xx_init_isoc(dev); 311 if (errCode) 312 goto err; 313 314 } 315 316 dev->users++; 317 filp->private_data = dev; 318 dev->io = IO_NONE; 319 dev->stream = STREAM_OFF; 320 dev->num_frames = 0; 321 322 /* prepare queues */ 323 em28xx_empty_framequeues(dev); 324 325 dev->state |= DEV_INITIALIZED; 326 327err: 328 mutex_unlock(&dev->lock); 329 up_read(&em28xx_disconnect); 330 return errCode; 331} 332 333/* 334 * em28xx_realease_resources() 335 * unregisters the v4l2,i2c and usb devices 336 * called when the device gets disconected or at module unload 337*/ 338static void em28xx_release_resources(struct em28xx *dev) 339{ 340 mutex_lock(&em28xx_sysfs_lock); 341 342 343 em28xx_info("V4L2 devices /dev/video%d and /dev/vbi%d deregistered\n", 344 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN, 345 dev->vbi_dev->minor-MINOR_VFL_TYPE_VBI_MIN); 346 list_del(&dev->devlist); 347 video_unregister_device(dev->vdev); 348 video_unregister_device(dev->vbi_dev); 349 em28xx_i2c_unregister(dev); 350 usb_put_dev(dev->udev); 351 mutex_unlock(&em28xx_sysfs_lock); 352 353 354 /* Mark device as unused */ 355 em28xx_devused&=~(1<<dev->devno); 356} 357 358/* 359 * em28xx_v4l2_close() 360 * stops streaming and deallocates all resources allocated by the v4l2 calls and ioctls 361 */ 362static int em28xx_v4l2_close(struct inode *inode, struct file *filp) 363{ 364 int errCode; 365 struct em28xx *dev=filp->private_data; 366 367 em28xx_videodbg("users=%d\n", dev->users); 368 369 mutex_lock(&dev->lock); 370 371 em28xx_uninit_isoc(dev); 372 373 em28xx_release_buffers(dev); 374 375 /* the device is already disconnect, free the remaining resources */ 376 if (dev->state & DEV_DISCONNECTED) { 377 em28xx_release_resources(dev); 378 mutex_unlock(&dev->lock); 379 kfree(dev); 380 return 0; 381 } 382 383 /* set alternate 0 */ 384 dev->alt = 0; 385 em28xx_videodbg("setting alternate 0\n"); 386 errCode = usb_set_interface(dev->udev, 0, 0); 387 if (errCode < 0) { 388 em28xx_errdev ("cannot change alternate number to 0 (error=%i)\n", 389 errCode); 390 } 391 392 dev->users--; 393 wake_up_interruptible_nr(&dev->open, 1); 394 mutex_unlock(&dev->lock); 395 return 0; 396} 397 398/* 399 * em28xx_v4l2_read() 400 * will allocate buffers when called for the first time 401 */ 402static ssize_t 403em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count, 404 loff_t * f_pos) 405{ 406 struct em28xx_frame_t *f, *i; 407 unsigned long lock_flags; 408 int ret = 0; 409 struct em28xx *dev = filp->private_data; 410 411 if (dev->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 412 em28xx_videodbg("V4l2_Buf_type_videocapture is set\n"); 413 } 414 if (dev->type == V4L2_BUF_TYPE_VBI_CAPTURE) { 415 em28xx_videodbg("V4L2_BUF_TYPE_VBI_CAPTURE is set\n"); 416 em28xx_videodbg("not supported yet! ...\n"); 417 if (copy_to_user(buf, "", 1)) { 418 mutex_unlock(&dev->fileop_lock); 419 return -EFAULT; 420 } 421 return (1); 422 } 423 if (dev->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) { 424 em28xx_videodbg("V4L2_BUF_TYPE_SLICED_VBI_CAPTURE is set\n"); 425 em28xx_videodbg("not supported yet! ...\n"); 426 if (copy_to_user(buf, "", 1)) { 427 mutex_unlock(&dev->fileop_lock); 428 return -EFAULT; 429 } 430 return (1); 431 } 432 433 if (mutex_lock_interruptible(&dev->fileop_lock)) 434 return -ERESTARTSYS; 435 436 if (dev->state & DEV_DISCONNECTED) { 437 em28xx_videodbg("device not present\n"); 438 mutex_unlock(&dev->fileop_lock); 439 return -ENODEV; 440 } 441 442 if (dev->state & DEV_MISCONFIGURED) { 443 em28xx_videodbg("device misconfigured; close and open it again\n"); 444 mutex_unlock(&dev->fileop_lock); 445 return -EIO; 446 } 447 448 if (dev->io == IO_MMAP) { 449 em28xx_videodbg ("IO method is set to mmap; close and open" 450 " the device again to choose the read method\n"); 451 mutex_unlock(&dev->fileop_lock); 452 return -EINVAL; 453 } 454 455 if (dev->io == IO_NONE) { 456 if (!em28xx_request_buffers(dev, EM28XX_NUM_READ_FRAMES)) { 457 em28xx_errdev("read failed, not enough memory\n"); 458 mutex_unlock(&dev->fileop_lock); 459 return -ENOMEM; 460 } 461 dev->io = IO_READ; 462 dev->stream = STREAM_ON; 463 em28xx_queue_unusedframes(dev); 464 } 465 466 if (!count) { 467 mutex_unlock(&dev->fileop_lock); 468 return 0; 469 } 470 471 if (list_empty(&dev->outqueue)) { 472 if (filp->f_flags & O_NONBLOCK) { 473 mutex_unlock(&dev->fileop_lock); 474 return -EAGAIN; 475 } 476 ret = wait_event_interruptible 477 (dev->wait_frame, 478 (!list_empty(&dev->outqueue)) || 479 (dev->state & DEV_DISCONNECTED)); 480 if (ret) { 481 mutex_unlock(&dev->fileop_lock); 482 return ret; 483 } 484 if (dev->state & DEV_DISCONNECTED) { 485 mutex_unlock(&dev->fileop_lock); 486 return -ENODEV; 487 } 488 } 489 490 f = list_entry(dev->outqueue.prev, struct em28xx_frame_t, frame); 491 492 spin_lock_irqsave(&dev->queue_lock, lock_flags); 493 list_for_each_entry(i, &dev->outqueue, frame) 494 i->state = F_UNUSED; 495 INIT_LIST_HEAD(&dev->outqueue); 496 spin_unlock_irqrestore(&dev->queue_lock, lock_flags); 497 498 em28xx_queue_unusedframes(dev); 499 500 if (count > f->buf.length) 501 count = f->buf.length; 502 503 if (copy_to_user(buf, f->bufmem, count)) { 504 mutex_unlock(&dev->fileop_lock); 505 return -EFAULT; 506 } 507 *f_pos += count; 508 509 mutex_unlock(&dev->fileop_lock); 510 511 return count; 512} 513 514/* 515 * em28xx_v4l2_poll() 516 * will allocate buffers when called for the first time 517 */ 518static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table * wait) 519{ 520 unsigned int mask = 0; 521 struct em28xx *dev = filp->private_data; 522 523 if (mutex_lock_interruptible(&dev->fileop_lock)) 524 return POLLERR; 525 526 if (dev->state & DEV_DISCONNECTED) { 527 em28xx_videodbg("device not present\n"); 528 } else if (dev->state & DEV_MISCONFIGURED) { 529 em28xx_videodbg("device is misconfigured; close and open it again\n"); 530 } else { 531 if (dev->io == IO_NONE) { 532 if (!em28xx_request_buffers 533 (dev, EM28XX_NUM_READ_FRAMES)) { 534 em28xx_warn 535 ("poll() failed, not enough memory\n"); 536 } else { 537 dev->io = IO_READ; 538 dev->stream = STREAM_ON; 539 } 540 } 541 542 if (dev->io == IO_READ) { 543 em28xx_queue_unusedframes(dev); 544 poll_wait(filp, &dev->wait_frame, wait); 545 546 if (!list_empty(&dev->outqueue)) 547 mask |= POLLIN | POLLRDNORM; 548 549 mutex_unlock(&dev->fileop_lock); 550 551 return mask; 552 } 553 } 554 555 mutex_unlock(&dev->fileop_lock); 556 return POLLERR; 557} 558 559/* 560 * em28xx_vm_open() 561 */ 562static void em28xx_vm_open(struct vm_area_struct *vma) 563{ 564 struct em28xx_frame_t *f = vma->vm_private_data; 565 f->vma_use_count++; 566} 567 568/* 569 * em28xx_vm_close() 570 */ 571static void em28xx_vm_close(struct vm_area_struct *vma) 572{ 573 /* NOTE: buffers are not freed here */ 574 struct em28xx_frame_t *f = vma->vm_private_data; 575 f->vma_use_count--; 576} 577 578static struct vm_operations_struct em28xx_vm_ops = { 579 .open = em28xx_vm_open, 580 .close = em28xx_vm_close, 581}; 582 583/* 584 * em28xx_v4l2_mmap() 585 */ 586static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma) 587{ 588 unsigned long size = vma->vm_end - vma->vm_start, 589 start = vma->vm_start; 590 void *pos; 591 u32 i; 592 593 struct em28xx *dev = filp->private_data; 594 595 if (mutex_lock_interruptible(&dev->fileop_lock)) 596 return -ERESTARTSYS; 597 598 if (dev->state & DEV_DISCONNECTED) { 599 em28xx_videodbg("mmap: device not present\n"); 600 mutex_unlock(&dev->fileop_lock); 601 return -ENODEV; 602 } 603 604 if (dev->state & DEV_MISCONFIGURED) { 605 em28xx_videodbg ("mmap: Device is misconfigured; close and " 606 "open it again\n"); 607 mutex_unlock(&dev->fileop_lock); 608 return -EIO; 609 } 610 611 if (dev->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) || 612 size != PAGE_ALIGN(dev->frame[0].buf.length)) { 613 mutex_unlock(&dev->fileop_lock); 614 return -EINVAL; 615 } 616 617 for (i = 0; i < dev->num_frames; i++) { 618 if ((dev->frame[i].buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff) 619 break; 620 } 621 if (i == dev->num_frames) { 622 em28xx_videodbg("mmap: user supplied mapping address is out of range\n"); 623 mutex_unlock(&dev->fileop_lock); 624 return -EINVAL; 625 } 626 627 /* VM_IO is eventually going to replace PageReserved altogether */ 628 vma->vm_flags |= VM_IO; 629 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */ 630 631 pos = dev->frame[i].bufmem; 632 while (size > 0) { /* size is page-aligned */ 633 if (vm_insert_page(vma, start, vmalloc_to_page(pos))) { 634 em28xx_videodbg("mmap: vm_insert_page failed\n"); 635 mutex_unlock(&dev->fileop_lock); 636 return -EAGAIN; 637 } 638 start += PAGE_SIZE; 639 pos += PAGE_SIZE; 640 size -= PAGE_SIZE; 641 } 642 643 vma->vm_ops = &em28xx_vm_ops; 644 vma->vm_private_data = &dev->frame[i]; 645 646 em28xx_vm_open(vma); 647 mutex_unlock(&dev->fileop_lock); 648 return 0; 649} 650 651/* 652 * em28xx_get_ctrl() 653 * return the current saturation, brightness or contrast, mute state 654 */ 655static int em28xx_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl) 656{ 657 switch (ctrl->id) { 658 case V4L2_CID_AUDIO_MUTE: 659 ctrl->value = dev->mute; 660 return 0; 661 case V4L2_CID_AUDIO_VOLUME: 662 ctrl->value = dev->volume; 663 return 0; 664 default: 665 return -EINVAL; 666 } 667} 668 669/* 670 * em28xx_set_ctrl() 671 * mute or set new saturation, brightness or contrast 672 */ 673static int em28xx_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl) 674{ 675 switch (ctrl->id) { 676 case V4L2_CID_AUDIO_MUTE: 677 if (ctrl->value != dev->mute) { 678 dev->mute = ctrl->value; 679 em28xx_audio_usb_mute(dev, ctrl->value); 680 return em28xx_audio_analog_set(dev); 681 } 682 return 0; 683 case V4L2_CID_AUDIO_VOLUME: 684 dev->volume = ctrl->value; 685 return em28xx_audio_analog_set(dev); 686 default: 687 return -EINVAL; 688 } 689} 690 691/* 692 * em28xx_stream_interrupt() 693 * stops streaming 694 */ 695static int em28xx_stream_interrupt(struct em28xx *dev) 696{ 697 int ret = 0; 698 699 /* stop reading from the device */ 700 701 dev->stream = STREAM_INTERRUPT; 702 ret = wait_event_timeout(dev->wait_stream, 703 (dev->stream == STREAM_OFF) || 704 (dev->state & DEV_DISCONNECTED), 705 EM28XX_URB_TIMEOUT); 706 if (dev->state & DEV_DISCONNECTED) 707 return -ENODEV; 708 else if (ret) { 709 dev->state |= DEV_MISCONFIGURED; 710 em28xx_videodbg("device is misconfigured; close and " 711 "open /dev/video%d again\n", 712 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN); 713 return ret; 714 } 715 716 return 0; 717} 718 719static int em28xx_set_norm(struct em28xx *dev, int width, int height) 720{ 721 unsigned int hscale, vscale; 722 unsigned int maxh, maxw; 723 724 maxw = norm_maxw(dev); 725 maxh = norm_maxh(dev); 726 727 /* width must even because of the YUYV format */ 728 /* height must be even because of interlacing */ 729 height &= 0xfffe; 730 width &= 0xfffe; 731 732 if (height < 32) 733 height = 32; 734 if (height > maxh) 735 height = maxh; 736 if (width < 48) 737 width = 48; 738 if (width > maxw) 739 width = maxw; 740 741 if ((hscale = (((unsigned long)maxw) << 12) / width - 4096L) >= 0x4000) 742 hscale = 0x3fff; 743 width = (((unsigned long)maxw) << 12) / (hscale + 4096L); 744 745 if ((vscale = (((unsigned long)maxh) << 12) / height - 4096L) >= 0x4000) 746 vscale = 0x3fff; 747 height = (((unsigned long)maxh) << 12) / (vscale + 4096L); 748 749 /* set new image size */ 750 dev->width = width; 751 dev->height = height; 752 dev->frame_size = dev->width * dev->height * 2; 753 dev->field_size = dev->frame_size >> 1; /*both_fileds ? dev->frame_size>>1 : dev->frame_size; */ 754 dev->bytesperline = dev->width * 2; 755 dev->hscale = hscale; 756 dev->vscale = vscale; 757 758 em28xx_resolution_set(dev); 759 760 return 0; 761} 762 763static int em28xx_get_fmt(struct em28xx *dev, struct v4l2_format *format) 764{ 765 em28xx_videodbg("VIDIOC_G_FMT: type=%s\n", 766 (format->type ==V4L2_BUF_TYPE_VIDEO_CAPTURE) ? 767 "V4L2_BUF_TYPE_VIDEO_CAPTURE" : 768 (format->type ==V4L2_BUF_TYPE_VBI_CAPTURE) ? 769 "V4L2_BUF_TYPE_VBI_CAPTURE" : 770 (format->type ==V4L2_CAP_SLICED_VBI_CAPTURE) ? 771 "V4L2_BUF_TYPE_SLICED_VBI_CAPTURE " : 772 "not supported"); 773 774 switch (format->type) { 775 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 776 { 777 format->fmt.pix.width = dev->width; 778 format->fmt.pix.height = dev->height; 779 format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 780 format->fmt.pix.bytesperline = dev->bytesperline; 781 format->fmt.pix.sizeimage = dev->frame_size; 782 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 783 format->fmt.pix.field = dev->interlaced ? V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; 784 785 em28xx_videodbg("VIDIOC_G_FMT: %dx%d\n", dev->width, 786 dev->height); 787 break; 788 } 789 790 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: 791 { 792 format->fmt.sliced.service_set=0; 793 794 em28xx_i2c_call_clients(dev,VIDIOC_G_FMT,format); 795 796 if (format->fmt.sliced.service_set==0) 797 return -EINVAL; 798 799 break; 800 } 801 802 default: 803 return -EINVAL; 804 } 805 return (0); 806} 807 808static int em28xx_set_fmt(struct em28xx *dev, unsigned int cmd, struct v4l2_format *format) 809{ 810 u32 i; 811 int ret = 0; 812 int width = format->fmt.pix.width; 813 int height = format->fmt.pix.height; 814 unsigned int hscale, vscale; 815 unsigned int maxh, maxw; 816 817 maxw = norm_maxw(dev); 818 maxh = norm_maxh(dev); 819 820 em28xx_videodbg("%s: type=%s\n", 821 cmd == VIDIOC_TRY_FMT ? 822 "VIDIOC_TRY_FMT" : "VIDIOC_S_FMT", 823 format->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ? 824 "V4L2_BUF_TYPE_VIDEO_CAPTURE" : 825 format->type == V4L2_BUF_TYPE_VBI_CAPTURE ? 826 "V4L2_BUF_TYPE_VBI_CAPTURE " : 827 "not supported"); 828 829 if (format->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) { 830 em28xx_i2c_call_clients(dev,VIDIOC_G_FMT,format); 831 832 if (format->fmt.sliced.service_set==0) 833 return -EINVAL; 834 835 return 0; 836 } 837 838 839 if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 840 return -EINVAL; 841 842 em28xx_videodbg("%s: requested %dx%d\n", 843 cmd == VIDIOC_TRY_FMT ? 844 "VIDIOC_TRY_FMT" : "VIDIOC_S_FMT", 845 format->fmt.pix.width, format->fmt.pix.height); 846 847 /* width must even because of the YUYV format */ 848 /* height must be even because of interlacing */ 849 height &= 0xfffe; 850 width &= 0xfffe; 851 852 if (height < 32) 853 height = 32; 854 if (height > maxh) 855 height = maxh; 856 if (width < 48) 857 width = 48; 858 if (width > maxw) 859 width = maxw; 860 861 if(dev->is_em2800){ 862 /* the em2800 can only scale down to 50% */ 863 if(height % (maxh / 2)) 864 height=maxh; 865 if(width % (maxw / 2)) 866 width=maxw; 867 /* according to empiatech support */ 868 /* the MaxPacketSize is to small to support */ 869 /* framesizes larger than 640x480 @ 30 fps */ 870 /* or 640x576 @ 25 fps. As this would cut */ 871 /* of a part of the image we prefer */ 872 /* 360x576 or 360x480 for now */ 873 if(width == maxw && height == maxh) 874 width /= 2; 875 } 876 877 if ((hscale = (((unsigned long)maxw) << 12) / width - 4096L) >= 0x4000) 878 hscale = 0x3fff; 879 880 width = (((unsigned long)maxw) << 12) / (hscale + 4096L); 881 882 if ((vscale = (((unsigned long)maxh) << 12) / height - 4096L) >= 0x4000) 883 vscale = 0x3fff; 884 885 height = (((unsigned long)maxh) << 12) / (vscale + 4096L); 886 887 format->fmt.pix.width = width; 888 format->fmt.pix.height = height; 889 format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 890 format->fmt.pix.bytesperline = width * 2; 891 format->fmt.pix.sizeimage = width * 2 * height; 892 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 893 format->fmt.pix.field = V4L2_FIELD_INTERLACED; 894 895 em28xx_videodbg("%s: returned %dx%d (%d, %d)\n", 896 cmd == VIDIOC_TRY_FMT ? 897 "VIDIOC_TRY_FMT" :"VIDIOC_S_FMT", 898 format->fmt.pix.width, format->fmt.pix.height, hscale, vscale); 899 900 if (cmd == VIDIOC_TRY_FMT) 901 return 0; 902 903 for (i = 0; i < dev->num_frames; i++) 904 if (dev->frame[i].vma_use_count) { 905 em28xx_videodbg("VIDIOC_S_FMT failed. " 906 "Unmap the buffers first.\n"); 907 return -EINVAL; 908 } 909 910 /* stop io in case it is already in progress */ 911 if (dev->stream == STREAM_ON) { 912 em28xx_videodbg("VIDIOC_SET_FMT: interupting stream\n"); 913 if ((ret = em28xx_stream_interrupt(dev))) 914 return ret; 915 } 916 917 em28xx_release_buffers(dev); 918 dev->io = IO_NONE; 919 920 /* set new image size */ 921 dev->width = width; 922 dev->height = height; 923 dev->frame_size = dev->width * dev->height * 2; 924 dev->field_size = dev->frame_size >> 1; 925 dev->bytesperline = dev->width * 2; 926 dev->hscale = hscale; 927 dev->vscale = vscale; 928 em28xx_uninit_isoc(dev); 929 em28xx_set_alternate(dev); 930 em28xx_capture_start(dev, 1); 931 em28xx_resolution_set(dev); 932 em28xx_init_isoc(dev); 933 934 return 0; 935} 936 937/* 938 * em28xx_v4l2_do_ioctl() 939 * This function is _not_ called directly, but from 940 * em28xx_v4l2_ioctl. Userspace 941 * copying is done already, arg is a kernel pointer. 942 */ 943static int em28xx_do_ioctl(struct inode *inode, struct file *filp, 944 struct em28xx *dev, unsigned int cmd, void *arg, 945 v4l2_kioctl driver_ioctl) 946{ 947 int ret; 948 949 switch (cmd) { 950 /* ---------- tv norms ---------- */ 951 case VIDIOC_ENUMSTD: 952 { 953 struct v4l2_standard *e = arg; 954 unsigned int i; 955 956 i = e->index; 957 if (i >= TVNORMS) 958 return -EINVAL; 959 ret = v4l2_video_std_construct(e, tvnorms[e->index].id, 960 tvnorms[e->index].name); 961 e->index = i; 962 if (ret < 0) 963 return ret; 964 return 0; 965 } 966 case VIDIOC_G_STD: 967 { 968 v4l2_std_id *id = arg; 969 970 *id = dev->tvnorm->id; 971 return 0; 972 } 973 case VIDIOC_S_STD: 974 { 975 v4l2_std_id *id = arg; 976 unsigned int i; 977 978 for (i = 0; i < TVNORMS; i++) 979 if (*id == tvnorms[i].id) 980 break; 981 if (i == TVNORMS) 982 for (i = 0; i < TVNORMS; i++) 983 if (*id & tvnorms[i].id) 984 break; 985 if (i == TVNORMS) 986 return -EINVAL; 987 988 mutex_lock(&dev->lock); 989 dev->tvnorm = &tvnorms[i]; 990 991 em28xx_set_norm(dev, dev->width, dev->height); 992 993 em28xx_i2c_call_clients(dev, VIDIOC_S_STD, 994 &dev->tvnorm->id); 995 996 mutex_unlock(&dev->lock); 997 998 return 0; 999 } 1000 1001 /* ------ input switching ---------- */ 1002 case VIDIOC_ENUMINPUT: 1003 { 1004 struct v4l2_input *i = arg; 1005 unsigned int n; 1006 static const char *iname[] = { 1007 [EM28XX_VMUX_COMPOSITE1] = "Composite1", 1008 [EM28XX_VMUX_COMPOSITE2] = "Composite2", 1009 [EM28XX_VMUX_COMPOSITE3] = "Composite3", 1010 [EM28XX_VMUX_COMPOSITE4] = "Composite4", 1011 [EM28XX_VMUX_SVIDEO] = "S-Video", 1012 [EM28XX_VMUX_TELEVISION] = "Television", 1013 [EM28XX_VMUX_CABLE] = "Cable TV", 1014 [EM28XX_VMUX_DVB] = "DVB", 1015 [EM28XX_VMUX_DEBUG] = "for debug only", 1016 }; 1017 1018 n = i->index; 1019 if (n >= MAX_EM28XX_INPUT) 1020 return -EINVAL; 1021 if (0 == INPUT(n)->type) 1022 return -EINVAL; 1023 memset(i, 0, sizeof(*i)); 1024 i->index = n; 1025 i->type = V4L2_INPUT_TYPE_CAMERA; 1026 strcpy(i->name, iname[INPUT(n)->type]); 1027 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) || 1028 (EM28XX_VMUX_CABLE == INPUT(n)->type)) 1029 i->type = V4L2_INPUT_TYPE_TUNER; 1030 for (n = 0; n < ARRAY_SIZE(tvnorms); n++) 1031 i->std |= tvnorms[n].id; 1032 return 0; 1033 } 1034 case VIDIOC_G_INPUT: 1035 { 1036 int *i = arg; 1037 *i = dev->ctl_input; 1038 1039 return 0; 1040 } 1041 case VIDIOC_S_INPUT: 1042 { 1043 int *index = arg; 1044 1045 if (*index >= MAX_EM28XX_INPUT) 1046 return -EINVAL; 1047 if (0 == INPUT(*index)->type) 1048 return -EINVAL; 1049 1050 mutex_lock(&dev->lock); 1051 video_mux(dev, *index); 1052 mutex_unlock(&dev->lock); 1053 1054 return 0; 1055 } 1056 case VIDIOC_G_AUDIO: 1057 { 1058 struct v4l2_audio *a = arg; 1059 unsigned int index = a->index; 1060 1061 if (a->index > 1) 1062 return -EINVAL; 1063 memset(a, 0, sizeof(*a)); 1064 index = dev->ctl_ainput; 1065 1066 if (index == 0) { 1067 strcpy(a->name, "Television"); 1068 } else { 1069 strcpy(a->name, "Line In"); 1070 } 1071 a->capability = V4L2_AUDCAP_STEREO; 1072 a->index = index; 1073 return 0; 1074 } 1075 case VIDIOC_S_AUDIO: 1076 { 1077 struct v4l2_audio *a = arg; 1078 1079 if (a->index != dev->ctl_ainput) 1080 return -EINVAL; 1081 1082 return 0; 1083 } 1084 1085 /* --- controls ---------------------------------------------- */ 1086 case VIDIOC_QUERYCTRL: 1087 { 1088 struct v4l2_queryctrl *qc = arg; 1089 int i, id=qc->id; 1090 1091 memset(qc,0,sizeof(*qc)); 1092 qc->id=id; 1093 1094 if (!dev->has_msp34xx) { 1095 for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) { 1096 if (qc->id && qc->id == em28xx_qctrl[i].id) { 1097 memcpy(qc, &(em28xx_qctrl[i]), 1098 sizeof(*qc)); 1099 return 0; 1100 } 1101 } 1102 } 1103 em28xx_i2c_call_clients(dev,cmd,qc); 1104 if (qc->type) 1105 return 0; 1106 else 1107 return -EINVAL; 1108 } 1109 case VIDIOC_G_CTRL: 1110 { 1111 struct v4l2_control *ctrl = arg; 1112 int retval=-EINVAL; 1113 1114 if (!dev->has_msp34xx) 1115 retval=em28xx_get_ctrl(dev, ctrl); 1116 if (retval==-EINVAL) { 1117 em28xx_i2c_call_clients(dev,cmd,arg); 1118 return 0; 1119 } else return retval; 1120 } 1121 case VIDIOC_S_CTRL: 1122 { 1123 struct v4l2_control *ctrl = arg; 1124 u8 i; 1125 1126 if (!dev->has_msp34xx){ 1127 for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) { 1128 if (ctrl->id == em28xx_qctrl[i].id) { 1129 if (ctrl->value < 1130 em28xx_qctrl[i].minimum 1131 || ctrl->value > 1132 em28xx_qctrl[i].maximum) 1133 return -ERANGE; 1134 return em28xx_set_ctrl(dev, ctrl); 1135 } 1136 } 1137 } 1138 1139 em28xx_i2c_call_clients(dev,cmd,arg); 1140 return 0; 1141 } 1142 /* --- tuner ioctls ------------------------------------------ */ 1143 case VIDIOC_G_TUNER: 1144 { 1145 struct v4l2_tuner *t = arg; 1146 1147 if (0 != t->index) 1148 return -EINVAL; 1149 1150 memset(t, 0, sizeof(*t)); 1151 strcpy(t->name, "Tuner"); 1152 mutex_lock(&dev->lock); 1153 /* let clients fill in the remainder of this struct */ 1154 em28xx_i2c_call_clients(dev, cmd, t); 1155 mutex_unlock(&dev->lock); 1156 em28xx_videodbg("VIDIO_G_TUNER: signal=%x, afc=%x\n", t->signal, 1157 t->afc); 1158 return 0; 1159 } 1160 case VIDIOC_S_TUNER: 1161 { 1162 struct v4l2_tuner *t = arg; 1163 1164 if (0 != t->index) 1165 return -EINVAL; 1166 mutex_lock(&dev->lock); 1167 /* let clients handle this */ 1168 em28xx_i2c_call_clients(dev, cmd, t); 1169 mutex_unlock(&dev->lock); 1170 return 0; 1171 } 1172 case VIDIOC_G_FREQUENCY: 1173 { 1174 struct v4l2_frequency *f = arg; 1175 1176 memset(f, 0, sizeof(*f)); 1177 f->type = V4L2_TUNER_ANALOG_TV; 1178 f->frequency = dev->ctl_freq; 1179 1180 return 0; 1181 } 1182 case VIDIOC_S_FREQUENCY: 1183 { 1184 struct v4l2_frequency *f = arg; 1185 1186 if (0 != f->tuner) 1187 return -EINVAL; 1188 1189 if (V4L2_TUNER_ANALOG_TV != f->type) 1190 return -EINVAL; 1191 1192 mutex_lock(&dev->lock); 1193 dev->ctl_freq = f->frequency; 1194 em28xx_i2c_call_clients(dev, VIDIOC_S_FREQUENCY, f); 1195 mutex_unlock(&dev->lock); 1196 return 0; 1197 } 1198 case VIDIOC_CROPCAP: 1199 { 1200 struct v4l2_cropcap *cc = arg; 1201 1202 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1203 return -EINVAL; 1204 cc->bounds.left = 0; 1205 cc->bounds.top = 0; 1206 cc->bounds.width = dev->width; 1207 cc->bounds.height = dev->height; 1208 cc->defrect = cc->bounds; 1209 cc->pixelaspect.numerator = 54; 1210 cc->pixelaspect.denominator = 59; 1211 return 0; 1212 } 1213 case VIDIOC_STREAMON: 1214 { 1215 int *type = arg; 1216 1217 if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE 1218 || dev->io != IO_MMAP) 1219 return -EINVAL; 1220 1221 if (list_empty(&dev->inqueue)) 1222 return -EINVAL; 1223 1224 dev->stream = STREAM_ON; 1225 1226 em28xx_videodbg("VIDIOC_STREAMON: starting stream\n"); 1227 1228 return 0; 1229 } 1230 case VIDIOC_STREAMOFF: 1231 { 1232 int *type = arg; 1233 int ret; 1234 1235 if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE 1236 || dev->io != IO_MMAP) 1237 return -EINVAL; 1238 1239 if (dev->stream == STREAM_ON) { 1240 em28xx_videodbg ("VIDIOC_STREAMOFF: interrupting stream\n"); 1241 if ((ret = em28xx_stream_interrupt(dev))) 1242 return ret; 1243 } 1244 em28xx_empty_framequeues(dev); 1245 1246 return 0; 1247 } 1248 default: 1249 return v4l_compat_translate_ioctl(inode, filp, cmd, arg, 1250 driver_ioctl); 1251 } 1252 return 0; 1253} 1254 1255/* 1256 * em28xx_v4l2_do_ioctl() 1257 * This function is _not_ called directly, but from 1258 * em28xx_v4l2_ioctl. Userspace 1259 * copying is done already, arg is a kernel pointer. 1260 */ 1261static int em28xx_video_do_ioctl(struct inode *inode, struct file *filp, 1262 unsigned int cmd, void *arg) 1263{ 1264 struct em28xx *dev = filp->private_data; 1265 1266 if (!dev) 1267 return -ENODEV; 1268 1269 if (video_debug > 1) 1270 v4l_print_ioctl(dev->name,cmd); 1271 1272 switch (cmd) { 1273 1274 /* --- capabilities ------------------------------------------ */ 1275 case VIDIOC_QUERYCAP: 1276 { 1277 struct v4l2_capability *cap = arg; 1278 1279 memset(cap, 0, sizeof(*cap)); 1280 strlcpy(cap->driver, "em28xx", sizeof(cap->driver)); 1281 strlcpy(cap->card, em28xx_boards[dev->model].name, 1282 sizeof(cap->card)); 1283 strlcpy(cap->bus_info, dev->udev->dev.bus_id, 1284 sizeof(cap->bus_info)); 1285 cap->version = EM28XX_VERSION_CODE; 1286 cap->capabilities = 1287 V4L2_CAP_SLICED_VBI_CAPTURE | 1288 V4L2_CAP_VIDEO_CAPTURE | 1289 V4L2_CAP_AUDIO | 1290 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 1291 if (dev->has_tuner) 1292 cap->capabilities |= V4L2_CAP_TUNER; 1293 return 0; 1294 } 1295 /* --- capture ioctls ---------------------------------------- */ 1296 case VIDIOC_ENUM_FMT: 1297 { 1298 struct v4l2_fmtdesc *fmtd = arg; 1299 1300 if (fmtd->index != 0) 1301 return -EINVAL; 1302 memset(fmtd, 0, sizeof(*fmtd)); 1303 fmtd->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1304 strcpy(fmtd->description, "Packed YUY2"); 1305 fmtd->pixelformat = V4L2_PIX_FMT_YUYV; 1306 memset(fmtd->reserved, 0, sizeof(fmtd->reserved)); 1307 return 0; 1308 } 1309 case VIDIOC_G_FMT: 1310 return em28xx_get_fmt(dev, (struct v4l2_format *) arg); 1311 1312 case VIDIOC_TRY_FMT: 1313 case VIDIOC_S_FMT: 1314 return em28xx_set_fmt(dev, cmd, (struct v4l2_format *)arg); 1315 1316 case VIDIOC_REQBUFS: 1317 { 1318 struct v4l2_requestbuffers *rb = arg; 1319 u32 i; 1320 int ret; 1321 1322 if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 1323 rb->memory != V4L2_MEMORY_MMAP) 1324 return -EINVAL; 1325 1326 if (dev->io == IO_READ) { 1327 em28xx_videodbg ("method is set to read;" 1328 " close and open the device again to" 1329 " choose the mmap I/O method\n"); 1330 return -EINVAL; 1331 } 1332 1333 for (i = 0; i < dev->num_frames; i++) 1334 if (dev->frame[i].vma_use_count) { 1335 em28xx_videodbg ("VIDIOC_REQBUFS failed; previous buffers are still mapped\n"); 1336 return -EINVAL; 1337 } 1338 1339 if (dev->stream == STREAM_ON) { 1340 em28xx_videodbg("VIDIOC_REQBUFS: interrupting stream\n"); 1341 if ((ret = em28xx_stream_interrupt(dev))) 1342 return ret; 1343 } 1344 1345 em28xx_empty_framequeues(dev); 1346 1347 em28xx_release_buffers(dev); 1348 if (rb->count) 1349 rb->count = 1350 em28xx_request_buffers(dev, rb->count); 1351 1352 dev->frame_current = NULL; 1353 1354 em28xx_videodbg ("VIDIOC_REQBUFS: setting io method to mmap: num bufs %i\n", 1355 rb->count); 1356 dev->io = rb->count ? IO_MMAP : IO_NONE; 1357 return 0; 1358 } 1359 case VIDIOC_QUERYBUF: 1360 { 1361 struct v4l2_buffer *b = arg; 1362 1363 if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 1364 b->index >= dev->num_frames || dev->io != IO_MMAP) 1365 return -EINVAL; 1366 1367 memcpy(b, &dev->frame[b->index].buf, sizeof(*b)); 1368 1369 if (dev->frame[b->index].vma_use_count) { 1370 b->flags |= V4L2_BUF_FLAG_MAPPED; 1371 } 1372 if (dev->frame[b->index].state == F_DONE) 1373 b->flags |= V4L2_BUF_FLAG_DONE; 1374 else if (dev->frame[b->index].state != F_UNUSED) 1375 b->flags |= V4L2_BUF_FLAG_QUEUED; 1376 return 0; 1377 } 1378 case VIDIOC_QBUF: 1379 { 1380 struct v4l2_buffer *b = arg; 1381 unsigned long lock_flags; 1382 1383 if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 1384 b->index >= dev->num_frames || dev->io != IO_MMAP) { 1385 return -EINVAL; 1386 } 1387 1388 if (dev->frame[b->index].state != F_UNUSED) { 1389 return -EAGAIN; 1390 } 1391 dev->frame[b->index].state = F_QUEUED; 1392 1393 /* add frame to fifo */ 1394 spin_lock_irqsave(&dev->queue_lock, lock_flags); 1395 list_add_tail(&dev->frame[b->index].frame, 1396 &dev->inqueue); 1397 spin_unlock_irqrestore(&dev->queue_lock, lock_flags); 1398 1399 return 0; 1400 } 1401 case VIDIOC_DQBUF: 1402 { 1403 struct v4l2_buffer *b = arg; 1404 struct em28xx_frame_t *f; 1405 unsigned long lock_flags; 1406 int ret = 0; 1407 1408 if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE 1409 || dev->io != IO_MMAP) 1410 return -EINVAL; 1411 1412 if (list_empty(&dev->outqueue)) { 1413 if (dev->stream == STREAM_OFF) 1414 return -EINVAL; 1415 if (filp->f_flags & O_NONBLOCK) 1416 return -EAGAIN; 1417 ret = wait_event_interruptible 1418 (dev->wait_frame, 1419 (!list_empty(&dev->outqueue)) || 1420 (dev->state & DEV_DISCONNECTED)); 1421 if (ret) 1422 return ret; 1423 if (dev->state & DEV_DISCONNECTED) 1424 return -ENODEV; 1425 } 1426 1427 spin_lock_irqsave(&dev->queue_lock, lock_flags); 1428 f = list_entry(dev->outqueue.next, 1429 struct em28xx_frame_t, frame); 1430 list_del(dev->outqueue.next); 1431 spin_unlock_irqrestore(&dev->queue_lock, lock_flags); 1432 1433 f->state = F_UNUSED; 1434 memcpy(b, &f->buf, sizeof(*b)); 1435 1436 if (f->vma_use_count) 1437 b->flags |= V4L2_BUF_FLAG_MAPPED; 1438 1439 return 0; 1440 } 1441 default: 1442 return em28xx_do_ioctl(inode, filp, dev, cmd, arg, 1443 em28xx_video_do_ioctl); 1444 } 1445 return 0; 1446} 1447 1448/* 1449 * em28xx_v4l2_ioctl() 1450 * handle v4l2 ioctl the main action happens in em28xx_v4l2_do_ioctl() 1451 */ 1452static int em28xx_v4l2_ioctl(struct inode *inode, struct file *filp, 1453 unsigned int cmd, unsigned long arg) 1454{ 1455 int ret = 0; 1456 struct em28xx *dev = filp->private_data; 1457 1458 if (mutex_lock_interruptible(&dev->fileop_lock)) 1459 return -ERESTARTSYS; 1460 1461 if (dev->state & DEV_DISCONNECTED) { 1462 em28xx_errdev("v4l2 ioctl: device not present\n"); 1463 mutex_unlock(&dev->fileop_lock); 1464 return -ENODEV; 1465 } 1466 1467 if (dev->state & DEV_MISCONFIGURED) { 1468 em28xx_errdev 1469 ("v4l2 ioctl: device is misconfigured; close and open it again\n"); 1470 mutex_unlock(&dev->fileop_lock); 1471 return -EIO; 1472 } 1473 1474 ret = video_usercopy(inode, filp, cmd, arg, em28xx_video_do_ioctl); 1475 1476 mutex_unlock(&dev->fileop_lock); 1477 1478 return ret; 1479} 1480 1481static const struct file_operations em28xx_v4l_fops = { 1482 .owner = THIS_MODULE, 1483 .open = em28xx_v4l2_open, 1484 .release = em28xx_v4l2_close, 1485 .ioctl = em28xx_v4l2_ioctl, 1486 .read = em28xx_v4l2_read, 1487 .poll = em28xx_v4l2_poll, 1488 .mmap = em28xx_v4l2_mmap, 1489 .llseek = no_llseek, 1490 .compat_ioctl = v4l_compat_ioctl32, 1491 1492}; 1493 1494/******************************** usb interface *****************************************/ 1495 1496/* 1497 * em28xx_init_dev() 1498 * allocates and inits the device structs, registers i2c bus and v4l device 1499 */ 1500static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev, 1501 int minor, int model) 1502{ 1503 struct em28xx *dev = *devhandle; 1504 int retval = -ENOMEM; 1505 int errCode, i; 1506 unsigned int maxh, maxw; 1507 1508 dev->udev = udev; 1509 dev->model = model; 1510 mutex_init(&dev->lock); 1511 init_waitqueue_head(&dev->open); 1512 1513 dev->em28xx_write_regs = em28xx_write_regs; 1514 dev->em28xx_read_reg = em28xx_read_reg; 1515 dev->em28xx_read_reg_req_len = em28xx_read_reg_req_len; 1516 dev->em28xx_write_regs_req = em28xx_write_regs_req; 1517 dev->em28xx_read_reg_req = em28xx_read_reg_req; 1518 dev->is_em2800 = em28xx_boards[model].is_em2800; 1519 dev->has_tuner = em28xx_boards[model].has_tuner; 1520 dev->has_msp34xx = em28xx_boards[model].has_msp34xx; 1521 dev->tda9887_conf = em28xx_boards[model].tda9887_conf; 1522 dev->decoder = em28xx_boards[model].decoder; 1523 1524 if (tuner >= 0) 1525 dev->tuner_type = tuner; 1526 else 1527 dev->tuner_type = em28xx_boards[model].tuner_type; 1528 1529 dev->video_inputs = em28xx_boards[model].vchannels; 1530 1531 for (i = 0; i < TVNORMS; i++) 1532 if (em28xx_boards[model].norm == tvnorms[i].mode) 1533 break; 1534 if (i == TVNORMS) 1535 i = 0; 1536 1537 dev->tvnorm = &tvnorms[i]; /* set default norm */ 1538 1539 em28xx_videodbg("tvnorm=%s\n", dev->tvnorm->name); 1540 1541 maxw = norm_maxw(dev); 1542 maxh = norm_maxh(dev); 1543 1544 /* set default image size */ 1545 dev->width = maxw; 1546 dev->height = maxh; 1547 dev->interlaced = EM28XX_INTERLACED_DEFAULT; 1548 dev->field_size = dev->width * dev->height; 1549 dev->frame_size = 1550 dev->interlaced ? dev->field_size << 1 : dev->field_size; 1551 dev->bytesperline = dev->width * 2; 1552 dev->hscale = 0; 1553 dev->vscale = 0; 1554 dev->ctl_input = 2; 1555 1556 /* setup video picture settings for saa7113h */ 1557 memset(&dev->vpic, 0, sizeof(dev->vpic)); 1558 dev->vpic.colour = 128 << 8; 1559 dev->vpic.hue = 128 << 8; 1560 dev->vpic.brightness = 128 << 8; 1561 dev->vpic.contrast = 192 << 8; 1562 dev->vpic.whiteness = 128 << 8; /* This one isn't used */ 1563 dev->vpic.depth = 16; 1564 dev->vpic.palette = VIDEO_PALETTE_YUV422; 1565 1566 em28xx_pre_card_setup(dev); 1567#ifdef CONFIG_MODULES 1568 /* request some modules */ 1569 if (dev->decoder == EM28XX_SAA7113 || dev->decoder == EM28XX_SAA7114) 1570 request_module("saa7115"); 1571 if (dev->decoder == EM28XX_TVP5150) 1572 request_module("tvp5150"); 1573 if (dev->has_tuner) 1574 request_module("tuner"); 1575#endif 1576 errCode = em28xx_config(dev); 1577 if (errCode) { 1578 em28xx_errdev("error configuring device\n"); 1579 em28xx_devused&=~(1<<dev->devno); 1580 kfree(dev); 1581 return -ENOMEM; 1582 } 1583 1584 mutex_lock(&dev->lock); 1585 /* register i2c bus */ 1586 em28xx_i2c_register(dev); 1587 1588 /* Do board specific init and eeprom reading */ 1589 em28xx_card_setup(dev); 1590 1591 /* configure the device */ 1592 em28xx_config_i2c(dev); 1593 1594 mutex_unlock(&dev->lock); 1595 1596 errCode = em28xx_config(dev); 1597 1598#ifdef CONFIG_MODULES 1599 if (dev->has_msp34xx) 1600 request_module("msp3400"); 1601#endif 1602 /* allocate and fill v4l2 device struct */ 1603 dev->vdev = video_device_alloc(); 1604 if (NULL == dev->vdev) { 1605 em28xx_errdev("cannot allocate video_device.\n"); 1606 em28xx_devused&=~(1<<dev->devno); 1607 kfree(dev); 1608 return -ENOMEM; 1609 } 1610 1611 dev->vbi_dev = video_device_alloc(); 1612 if (NULL == dev->vbi_dev) { 1613 em28xx_errdev("cannot allocate video_device.\n"); 1614 kfree(dev->vdev); 1615 em28xx_devused&=~(1<<dev->devno); 1616 kfree(dev); 1617 return -ENOMEM; 1618 } 1619 1620 /* Fills VBI device info */ 1621 dev->vbi_dev->type = VFL_TYPE_VBI; 1622 dev->vbi_dev->hardware = 0; 1623 dev->vbi_dev->fops = &em28xx_v4l_fops; 1624 dev->vbi_dev->minor = -1; 1625 dev->vbi_dev->dev = &dev->udev->dev; 1626 dev->vbi_dev->release = video_device_release; 1627 snprintf(dev->vbi_dev->name, sizeof(dev->vbi_dev->name), "%s#%d %s", 1628 "em28xx",dev->devno,"vbi"); 1629 1630 /* Fills CAPTURE device info */ 1631 dev->vdev->type = VID_TYPE_CAPTURE; 1632 if (dev->has_tuner) 1633 dev->vdev->type |= VID_TYPE_TUNER; 1634 dev->vdev->hardware = 0; 1635 dev->vdev->fops = &em28xx_v4l_fops; 1636 dev->vdev->minor = -1; 1637 dev->vdev->dev = &dev->udev->dev; 1638 dev->vdev->release = video_device_release; 1639 snprintf(dev->vdev->name, sizeof(dev->vbi_dev->name), "%s#%d %s", 1640 "em28xx",dev->devno,"video"); 1641 1642 list_add_tail(&dev->devlist,&em28xx_devlist); 1643 1644 /* register v4l2 device */ 1645 mutex_lock(&dev->lock); 1646 if ((retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, 1647 video_nr[dev->devno]))) { 1648 em28xx_errdev("unable to register video device (error=%i).\n", 1649 retval); 1650 mutex_unlock(&dev->lock); 1651 list_del(&dev->devlist); 1652 video_device_release(dev->vdev); 1653 em28xx_devused&=~(1<<dev->devno); 1654 kfree(dev); 1655 return -ENODEV; 1656 } 1657 1658 if (video_register_device(dev->vbi_dev, VFL_TYPE_VBI, 1659 vbi_nr[dev->devno]) < 0) { 1660 printk("unable to register vbi device\n"); 1661 mutex_unlock(&dev->lock); 1662 list_del(&dev->devlist); 1663 video_device_release(dev->vbi_dev); 1664 video_device_release(dev->vdev); 1665 em28xx_devused&=~(1<<dev->devno); 1666 kfree(dev); 1667 return -ENODEV; 1668 } else { 1669 printk("registered VBI\n"); 1670 } 1671 1672 if (dev->has_msp34xx) { 1673 /* Send a reset to other chips via gpio */ 1674 em28xx_write_regs_req(dev, 0x00, 0x08, "\xf7", 1); 1675 msleep(3); 1676 em28xx_write_regs_req(dev, 0x00, 0x08, "\xff", 1); 1677 msleep(3); 1678 1679 } 1680 video_mux(dev, 0); 1681 1682 mutex_unlock(&dev->lock); 1683 1684 em28xx_info("V4L2 device registered as /dev/video%d and /dev/vbi%d\n", 1685 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN, 1686 dev->vbi_dev->minor-MINOR_VFL_TYPE_VBI_MIN); 1687 1688 return 0; 1689} 1690 1691/* 1692 * em28xx_usb_probe() 1693 * checks for supported devices 1694 */ 1695static int em28xx_usb_probe(struct usb_interface *interface, 1696 const struct usb_device_id *id) 1697{ 1698 const struct usb_endpoint_descriptor *endpoint; 1699 struct usb_device *udev; 1700 struct usb_interface *uif; 1701 struct em28xx *dev = NULL; 1702 int retval = -ENODEV; 1703 int model,i,nr,ifnum; 1704 1705 udev = usb_get_dev(interface_to_usbdev(interface)); 1706 ifnum = interface->altsetting[0].desc.bInterfaceNumber; 1707 1708 /* Check to see next free device and mark as used */ 1709 nr=find_first_zero_bit(&em28xx_devused,EM28XX_MAXBOARDS); 1710 em28xx_devused|=1<<nr; 1711 1712 /* Don't register audio interfaces */ 1713 if (interface->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) { 1714 em28xx_err(DRIVER_NAME " audio device (%04x:%04x): interface %i, class %i\n", 1715 udev->descriptor.idVendor,udev->descriptor.idProduct, 1716 ifnum, 1717 interface->altsetting[0].desc.bInterfaceClass); 1718 1719 em28xx_devused&=~(1<<nr); 1720 return -ENODEV; 1721 } 1722 1723 em28xx_err(DRIVER_NAME " new video device (%04x:%04x): interface %i, class %i\n", 1724 udev->descriptor.idVendor,udev->descriptor.idProduct, 1725 ifnum, 1726 interface->altsetting[0].desc.bInterfaceClass); 1727 1728 endpoint = &interface->cur_altsetting->endpoint[1].desc; 1729 1730 /* check if the device has the iso in endpoint at the correct place */ 1731 if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 1732 USB_ENDPOINT_XFER_ISOC) { 1733 em28xx_err(DRIVER_NAME " probing error: endpoint is non-ISO endpoint!\n"); 1734 em28xx_devused&=~(1<<nr); 1735 return -ENODEV; 1736 } 1737 if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) { 1738 em28xx_err(DRIVER_NAME " probing error: endpoint is ISO OUT endpoint!\n"); 1739 em28xx_devused&=~(1<<nr); 1740 return -ENODEV; 1741 } 1742 1743 model=id->driver_info; 1744 1745 if (nr >= EM28XX_MAXBOARDS) { 1746 printk (DRIVER_NAME ": Supports only %i em28xx boards.\n",EM28XX_MAXBOARDS); 1747 em28xx_devused&=~(1<<nr); 1748 return -ENOMEM; 1749 } 1750 1751 /* allocate memory for our device state and initialize it */ 1752 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1753 if (dev == NULL) { 1754 em28xx_err(DRIVER_NAME ": out of memory!\n"); 1755 em28xx_devused&=~(1<<nr); 1756 return -ENOMEM; 1757 } 1758 1759 snprintf(dev->name, 29, "em28xx #%d", nr); 1760 dev->devno=nr; 1761 1762 /* compute alternate max packet sizes */ 1763 uif = udev->actconfig->interface[0]; 1764 1765 dev->num_alt=uif->num_altsetting; 1766 em28xx_info("Alternate settings: %i\n",dev->num_alt); 1767// dev->alt_max_pkt_size = kmalloc(sizeof(*dev->alt_max_pkt_size)* 1768 dev->alt_max_pkt_size = kmalloc(32* 1769 dev->num_alt,GFP_KERNEL); 1770 if (dev->alt_max_pkt_size == NULL) { 1771 em28xx_errdev("out of memory!\n"); 1772 em28xx_devused&=~(1<<nr); 1773 return -ENOMEM; 1774 } 1775 1776 for (i = 0; i < dev->num_alt ; i++) { 1777 u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[1].desc. 1778 wMaxPacketSize); 1779 dev->alt_max_pkt_size[i] = 1780 (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1); 1781 em28xx_info("Alternate setting %i, max size= %i\n",i, 1782 dev->alt_max_pkt_size[i]); 1783 } 1784 1785 if ((card[nr]>=0)&&(card[nr]<em28xx_bcount)) 1786 model=card[nr]; 1787 1788 if ((model==EM2800_BOARD_UNKNOWN)||(model==EM2820_BOARD_UNKNOWN)) { 1789 em28xx_errdev( "Your board has no eeprom inside it and thus can't\n" 1790 "%s: be autodetected. Please pass card=<n> insmod option to\n" 1791 "%s: workaround that. Redirect complaints to the vendor of\n" 1792 "%s: the TV card. Generic type will be used." 1793 "%s: Best regards,\n" 1794 "%s: -- tux\n", 1795 dev->name,dev->name,dev->name,dev->name,dev->name); 1796 em28xx_errdev("%s: Here is a list of valid choices for the card=<n> insmod option:\n", 1797 dev->name); 1798 for (i = 0; i < em28xx_bcount; i++) { 1799 em28xx_errdev(" card=%d -> %s\n", i, 1800 em28xx_boards[i].name); 1801 } 1802 } 1803 1804 /* allocate device struct */ 1805 retval = em28xx_init_dev(&dev, udev, nr, model); 1806 if (retval) 1807 return retval; 1808 1809 em28xx_info("Found %s\n", em28xx_boards[model].name); 1810 1811 /* save our data pointer in this interface device */ 1812 usb_set_intfdata(interface, dev); 1813 return 0; 1814} 1815 1816/* 1817 * em28xx_usb_disconnect() 1818 * called when the device gets diconencted 1819 * video device will be unregistered on v4l2_close in case it is still open 1820 */ 1821static void em28xx_usb_disconnect(struct usb_interface *interface) 1822{ 1823 struct em28xx *dev = usb_get_intfdata(interface); 1824 usb_set_intfdata(interface, NULL); 1825 1826 if (!dev) 1827 return; 1828 1829 down_write(&em28xx_disconnect); 1830 1831 mutex_lock(&dev->lock); 1832 1833 em28xx_info("disconnecting %s\n", dev->vdev->name); 1834 1835 wake_up_interruptible_all(&dev->open); 1836 1837 if (dev->users) { 1838 em28xx_warn 1839 ("device /dev/video%d is open! Deregistration and memory " 1840 "deallocation are deferred on close.\n", 1841 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN); 1842 1843 dev->state |= DEV_MISCONFIGURED; 1844 em28xx_uninit_isoc(dev); 1845 dev->state |= DEV_DISCONNECTED; 1846 wake_up_interruptible(&dev->wait_frame); 1847 wake_up_interruptible(&dev->wait_stream); 1848 } else { 1849 dev->state |= DEV_DISCONNECTED; 1850 em28xx_release_resources(dev); 1851 } 1852 1853 mutex_unlock(&dev->lock); 1854 1855 if (!dev->users) { 1856 kfree(dev->alt_max_pkt_size); 1857 kfree(dev); 1858 } 1859 1860 up_write(&em28xx_disconnect); 1861} 1862 1863static struct usb_driver em28xx_usb_driver = { 1864 .name = "em28xx", 1865 .probe = em28xx_usb_probe, 1866 .disconnect = em28xx_usb_disconnect, 1867 .id_table = em28xx_id_table, 1868}; 1869 1870static int __init em28xx_module_init(void) 1871{ 1872 int result; 1873 1874 printk(KERN_INFO DRIVER_NAME " v4l2 driver version %d.%d.%d loaded\n", 1875 (EM28XX_VERSION_CODE >> 16) & 0xff, 1876 (EM28XX_VERSION_CODE >> 8) & 0xff, EM28XX_VERSION_CODE & 0xff); 1877#ifdef SNAPSHOT 1878 printk(KERN_INFO DRIVER_NAME " snapshot date %04d-%02d-%02d\n", 1879 SNAPSHOT / 10000, (SNAPSHOT / 100) % 100, SNAPSHOT % 100); 1880#endif 1881 1882 /* register this driver with the USB subsystem */ 1883 result = usb_register(&em28xx_usb_driver); 1884 if (result) 1885 em28xx_err(DRIVER_NAME 1886 " usb_register failed. Error number %d.\n", result); 1887 1888 return result; 1889} 1890 1891static void __exit em28xx_module_exit(void) 1892{ 1893 /* deregister this driver with the USB subsystem */ 1894 usb_deregister(&em28xx_usb_driver); 1895} 1896 1897module_init(em28xx_module_init); 1898module_exit(em28xx_module_exit); 1899