SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/em28xx/em28xx-video.c

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