err.no Git - linux-2.6/blob - drivers/media/video/em28xx/em28xx-video.c

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