drivers/usb/media/pwc-if.c

   1 /* Linux driver for Philips webcam
   2    USB and Video4Linux interface part.
   3    (C) 1999-2003 Nemosoft Unv.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19 */
  20
  21 /*
  22    This code forms the interface between the USB layers and the Philips
  23    specific stuff. Some adanved stuff of the driver falls under an
  24    NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
  25    is thus not distributed in source form. The binary pwcx.o module
  26    contains the code that falls under the NDA.
  27
  28    In case you're wondering: 'pwc' stands for "Philips WebCam", but
  29    I really didn't want to type 'philips_web_cam' every time (I'm lazy as
  30    any Linux kernel hacker, but I don't like uncomprehensible abbreviations
  31    without explanation).
  32
  33    Oh yes, convention: to disctinguish between all the various pointers to
  34    device-structures, I use these names for the pointer variables:
  35    udev: struct usb_device *
  36    vdev: struct video_device *
  37    pdev: struct pwc_devive *
  38 */
  39
  40 /* Contributors:
  41    - Alvarado: adding whitebalance code
  42    - Alistar Moire: QuickCam 3000 Pro device/product ID
  43    - Tony Hoyle: Creative Labs Webcam 5 device/product ID
  44    - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
  45    - Jk Fang: SOTEC Afina Eye ID
  46    - Xavier Roche: QuickCam Pro 4000 ID
  47    - Jens Knudsen: QuickCam Zoom ID
  48    - J. Debert: QuickCam for Notebooks ID
  49 */
  50
  51 #include <linux/errno.h>
  52 #include <linux/init.h>
  53 #include <linux/mm.h>
  54 #include <linux/module.h>
  55 #include <linux/poll.h>
  56 #include <linux/slab.h>
  57 #include <linux/vmalloc.h>
  58 #include <asm/io.h>
  59
  60 #include "pwc.h"
  61 #include "pwc-ioctl.h"
  62 #include "pwc-uncompress.h"
  63
  64 /* Function prototypes and driver templates */
  65
  66 /* hotplug device table support */
  67 static struct usb_device_id pwc_device_table [] = {
  68         { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */
  69         { USB_DEVICE(0x0471, 0x0303) },
  70         { USB_DEVICE(0x0471, 0x0304) },
  71         { USB_DEVICE(0x0471, 0x0307) },
  72         { USB_DEVICE(0x0471, 0x0308) },
  73         { USB_DEVICE(0x0471, 0x030C) },
  74         { USB_DEVICE(0x0471, 0x0310) },
  75         { USB_DEVICE(0x0471, 0x0311) },
  76         { USB_DEVICE(0x0471, 0x0312) },
  77         { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
  78         { USB_DEVICE(0x069A, 0x0001) }, /* Askey */
  79         { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
  80         { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
  81         { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
  82         { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
  83         { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
  84         { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
  85         { USB_DEVICE(0x046D, 0x08B6) }, /* Logitech (reserved) */
  86         { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech (reserved) */
  87         { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
  88         { USB_DEVICE(0x055D, 0x9000) }, /* Samsung */
  89         { USB_DEVICE(0x055D, 0x9001) },
  90         { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
  91         { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
  92         { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
  93         { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
  94         { USB_DEVICE(0x0d81, 0x1900) },
  95         { }
  96 };
  97 MODULE_DEVICE_TABLE(usb, pwc_device_table);
  98
  99 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
 100 static void usb_pwc_disconnect(struct usb_interface *intf);
 101
 102 static struct usb_driver pwc_driver = {
 103         .owner =                THIS_MODULE,
 104         .name =                 "Philips webcam",       /* name */
 105         .id_table =             pwc_device_table,
 106         .probe =                usb_pwc_probe,          /* probe() */
 107         .disconnect =           usb_pwc_disconnect,     /* disconnect() */
 108 };
 109
 110 #define MAX_DEV_HINTS   20
 111 #define MAX_ISOC_ERRORS 20
 112
 113 static int default_size = PSZ_QCIF;
 114 static int default_fps = 10;
 115 static int default_fbufs = 3;   /* Default number of frame buffers */
 116 static int default_mbufs = 2;   /* Default number of mmap() buffers */
 117        int pwc_trace = TRACE_MODULE | TRACE_FLOW | TRACE_PWCX;
 118 static int power_save = 0;
 119 static int led_on = 100, led_off = 0; /* defaults to LED that is on while in use */
 120        int pwc_preferred_compression = 2; /* 0..3 = uncompressed..high */
 121 static struct {
 122         int type;
 123         char serial_number[30];
 124         int device_node;
 125         struct pwc_device *pdev;
 126 } device_hint[MAX_DEV_HINTS];
 127
 128 /***/
 129
 130 static int pwc_video_open(struct inode *inode, struct file *file);
 131 static int pwc_video_close(struct inode *inode, struct file *file);
 132 static int pwc_video_release(struct video_device *);
 133 static ssize_t pwc_video_read(struct file *file, char *buf,
 134                           size_t count, loff_t *ppos);
 135 static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
 136 static int  pwc_video_ioctl(struct inode *inode, struct file *file,
 137                             unsigned int ioctlnr, unsigned long arg);
 138 static int  pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
 139
 140 static struct file_operations pwc_fops = {
 141         .owner =        THIS_MODULE,
 142         .open =         pwc_video_open,
 143         .release =      pwc_video_close,
 144         .read =         pwc_video_read,
 145         .poll =         pwc_video_poll,
 146         .mmap =         pwc_video_mmap,
 147         .ioctl =        pwc_video_ioctl,
 148         .llseek =       no_llseek,
 149 };
 150 static struct video_device pwc_template = {
 151         .owner =        THIS_MODULE,
 152         .name =         "Philips Webcam",       /* Filled in later */
 153         .type =         VID_TYPE_CAPTURE,
 154         .hardware =     VID_HARDWARE_PWC,
 155         .fops =         &pwc_fops,
 156 };
 157
 158 /***************************************************************************/
 159
 160 /* Okay, this is some magic that I worked out and the reasoning behind it...
 161
 162    The biggest problem with any USB device is of course: "what to do
 163    when the user unplugs the device while it is in use by an application?"
 164    We have several options:
 165    1) Curse them with the 7 plagues when they do (requires divine intervention)
 166    2) Tell them not to (won't work: they'll do it anyway)
 167    3) Oops the kernel (this will have a negative effect on a user's uptime)
 168    4) Do something sensible.
 169
 170    Of course, we go for option 4.
 171
 172    It happens that this device will be linked to two times, once from
 173    usb_device and once from the video_device in their respective 'private'
 174    pointers. This is done when the device is probed() and all initialization
 175    succeeded. The pwc_device struct links back to both structures.
 176
 177    When a device is unplugged while in use it will be removed from the
 178    list of known USB devices; I also de-register it as a V4L device, but
 179    unfortunately I can't free the memory since the struct is still in use
 180    by the file descriptor. This free-ing is then deferend until the first
 181    opportunity. Crude, but it works.
 182
 183    A small 'advantage' is that if a user unplugs the cam and plugs it back
 184    in, it should get assigned the same video device minor, but unfortunately
 185    it's non-trivial to re-link the cam back to the video device... (that
 186    would surely be magic! :))
 187 */
 188
 189 /***************************************************************************/
 190 /* Private functions */
 191
 192 /* Here we want the physical address of the memory.
 193  * This is used when initializing the contents of the area.
 194  */
 195 static inline unsigned long kvirt_to_pa(unsigned long adr)
 196 {
 197         unsigned long kva, ret;
 198
 199         kva = (unsigned long) page_address(vmalloc_to_page((void *)adr));
 200         kva |= adr & (PAGE_SIZE-1); /* restore the offset */
 201         ret = __pa(kva);
 202         return ret;
 203 }
 204
 205 static void * rvmalloc(unsigned long size)
 206 {
 207         void * mem;
 208         unsigned long adr;
 209
 210         size=PAGE_ALIGN(size);
 211         mem=vmalloc_32(size);
 212         if (mem)
 213         {
 214                 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
 215                 adr=(unsigned long) mem;
 216                 while (size > 0)
 217                 {
 218                         SetPageReserved(vmalloc_to_page((void *)adr));
 219                         adr+=PAGE_SIZE;
 220                         size-=PAGE_SIZE;
 221                 }
 222         }
 223         return mem;
 224 }
 225
 226 static void rvfree(void * mem, unsigned long size)
 227 {
 228         unsigned long adr;
 229
 230         if (mem)
 231         {
 232                 adr=(unsigned long) mem;
 233                 while ((long) size > 0)
 234                 {
 235                         ClearPageReserved(vmalloc_to_page((void *)adr));
 236                         adr+=PAGE_SIZE;
 237                         size-=PAGE_SIZE;
 238                 }
 239                 vfree(mem);
 240         }
 241 }
 242
 243
 244
 245
 246 static int pwc_allocate_buffers(struct pwc_device *pdev)
 247 {
 248         int i;
 249         void *kbuf;
 250
 251         Trace(TRACE_MEMORY, ">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev);
 252
 253         if (pdev == NULL)
 254                 return -ENXIO;
 255
 256 #ifdef PWC_MAGIC
 257         if (pdev->magic != PWC_MAGIC) {
 258                 Err("allocate_buffers(): magic failed.\n");
 259                 return -ENXIO;
 260         }
 261 #endif
 262         /* Allocate Isochronous pipe buffers */
 263         for (i = 0; i < MAX_ISO_BUFS; i++) {
 264                 if (pdev->sbuf[i].data == NULL) {
 265                         kbuf = kmalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
 266                         if (kbuf == NULL) {
 267                                 Err("Failed to allocate iso buffer %d.\n", i);
 268                                 return -ENOMEM;
 269                         }
 270                         Trace(TRACE_MEMORY, "Allocated iso buffer at %p.\n", kbuf);
 271                         pdev->sbuf[i].data = kbuf;
 272                         memset(kbuf, 0, ISO_BUFFER_SIZE);
 273                 }
 274         }
 275
 276         /* Allocate frame buffer structure */
 277         if (pdev->fbuf == NULL) {
 278                 kbuf = kmalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);
 279                 if (kbuf == NULL) {
 280                         Err("Failed to allocate frame buffer structure.\n");
 281                         return -ENOMEM;
 282                 }
 283                 Trace(TRACE_MEMORY, "Allocated frame buffer structure at %p.\n", kbuf);
 284                 pdev->fbuf = kbuf;
 285                 memset(kbuf, 0, default_fbufs * sizeof(struct pwc_frame_buf));
 286         }
 287         /* create frame buffers, and make circular ring */
 288         for (i = 0; i < default_fbufs; i++) {
 289                 if (pdev->fbuf[i].data == NULL) {
 290                         kbuf = vmalloc(PWC_FRAME_SIZE); /* need vmalloc since frame buffer > 128K */
 291                         if (kbuf == NULL) {
 292                                 Err("Failed to allocate frame buffer %d.\n", i);
 293                                 return -ENOMEM;
 294                         }
 295                         Trace(TRACE_MEMORY, "Allocated frame buffer %d at %p.\n", i, kbuf);
 296                         pdev->fbuf[i].data = kbuf;
 297                         memset(kbuf, 128, PWC_FRAME_SIZE);
 298                 }
 299         }
 300
 301         /* Allocate decompressor table space */
 302         kbuf = NULL;
 303         if (pdev->decompressor != NULL) {
 304                 kbuf = kmalloc(pdev->decompressor->table_size, GFP_KERNEL);
 305                 if (kbuf == NULL) {
 306                         Err("Failed to allocate decompress table.\n");
 307                         return -ENOMEM;
 308                 }
 309                 Trace(TRACE_MEMORY, "Allocated decompress table %p.\n", kbuf);
 310         }
 311         pdev->decompress_data = kbuf;
 312
 313         /* Allocate image buffer; double buffer for mmap() */
 314         kbuf = rvmalloc(default_mbufs * pdev->len_per_image);
 315         if (kbuf == NULL) {
 316                 Err("Failed to allocate image buffer(s).\n");
 317                 return -ENOMEM;
 318         }
 319         Trace(TRACE_MEMORY, "Allocated image buffer at %p.\n", kbuf);
 320         pdev->image_data = kbuf;
 321         for (i = 0; i < default_mbufs; i++)
 322                 pdev->image_ptr[i] = kbuf + i * pdev->len_per_image;
 323         for (; i < MAX_IMAGES; i++)
 324                 pdev->image_ptr[i] = NULL;
 325
 326         kbuf = NULL;
 327
 328         Trace(TRACE_MEMORY, "<< pwc_allocate_buffers()\n");
 329         return 0;
 330 }
 331
 332 static void pwc_free_buffers(struct pwc_device *pdev)
 333 {
 334         int i;
 335
 336         Trace(TRACE_MEMORY, "Entering free_buffers(%p).\n", pdev);
 337
 338         if (pdev == NULL)
 339                 return;
 340 #ifdef PWC_MAGIC
 341         if (pdev->magic != PWC_MAGIC) {
 342                 Err("free_buffers(): magic failed.\n");
 343                 return;
 344         }
 345 #endif
 346
 347         /* Release Iso-pipe buffers */
 348         for (i = 0; i < MAX_ISO_BUFS; i++)
 349                 if (pdev->sbuf[i].data != NULL) {
 350                         Trace(TRACE_MEMORY, "Freeing ISO buffer at %p.\n", pdev->sbuf[i].data);
 351                         kfree(pdev->sbuf[i].data);
 352                         pdev->sbuf[i].data = NULL;
 353                 }
 354
 355         /* The same for frame buffers */
 356         if (pdev->fbuf != NULL) {
 357                 for (i = 0; i < default_fbufs; i++) {
 358                         if (pdev->fbuf[i].data != NULL) {
 359                                 Trace(TRACE_MEMORY, "Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data);
 360                                 vfree(pdev->fbuf[i].data);
 361                                 pdev->fbuf[i].data = NULL;
 362                         }
 363                 }
 364                 kfree(pdev->fbuf);
 365                 pdev->fbuf = NULL;
 366         }
 367
 368         /* Intermediate decompression buffer & tables */
 369         if (pdev->decompress_data != NULL) {
 370                 Trace(TRACE_MEMORY, "Freeing decompression buffer at %p.\n", pdev->decompress_data);
 371                 kfree(pdev->decompress_data);
 372                 pdev->decompress_data = NULL;
 373         }
 374         pdev->decompressor = NULL;
 375
 376         /* Release image buffers */
 377         if (pdev->image_data != NULL) {
 378                 Trace(TRACE_MEMORY, "Freeing image buffer at %p.\n", pdev->image_data);
 379                 rvfree(pdev->image_data, default_mbufs * pdev->len_per_image);
 380         }
 381         pdev->image_data = NULL;
 382
 383         Trace(TRACE_MEMORY, "Leaving free_buffers().\n");
 384 }
 385
 386 /* The frame & image buffer mess.
 387
 388    Yes, this is a mess. Well, it used to be simple, but alas...  In this
 389    module, 3 buffers schemes are used to get the data from the USB bus to
 390    the user program. The first scheme involves the ISO buffers (called thus
 391    since they transport ISO data from the USB controller), and not really
 392    interesting. Suffices to say the data from this buffer is quickly
 393    gathered in an interrupt handler (pwc_isoc_handler) and placed into the
 394    frame buffer.
 395
 396    The frame buffer is the second scheme, and is the central element here.
 397    It collects the data from a single frame from the camera (hence, the
 398    name). Frames are delimited by the USB camera with a short USB packet,
 399    so that's easy to detect. The frame buffers form a list that is filled
 400    by the camera+USB controller and drained by the user process through
 401    either read() or mmap().
 402
 403    The image buffer is the third scheme, in which frames are decompressed
 404    and converted into planar format. For mmap() there is more than
 405    one image buffer available.
 406
 407    The frame buffers provide the image buffering. In case the user process
 408    is a bit slow, this introduces lag and some undesired side-effects.
 409    The problem arises when the frame buffer is full. I used to drop the last
 410    frame, which makes the data in the queue stale very quickly. But dropping
 411    the frame at the head of the queue proved to be a litte bit more difficult.
 412    I tried a circular linked scheme, but this introduced more problems than
 413    it solved.
 414
 415    Because filling and draining are completely asynchronous processes, this
 416    requires some fiddling with pointers and mutexes.
 417
 418    Eventually, I came up with a system with 2 lists: an 'empty' frame list
 419    and a 'full' frame list:
 420      * Initially, all frame buffers but one are on the 'empty' list; the one
 421        remaining buffer is our initial fill frame.
 422      * If a frame is needed for filling, we try to take it from the 'empty'
 423        list, unless that list is empty, in which case we take the buffer at
 424        the head of the 'full' list.
 425      * When our fill buffer has been filled, it is appended to the 'full'
 426        list.
 427      * If a frame is needed by read() or mmap(), it is taken from the head of
 428        the 'full' list, handled, and then appended to the 'empty' list. If no
 429        buffer is present on the 'full' list, we wait.
 430    The advantage is that the buffer that is currently being decompressed/
 431    converted, is on neither list, and thus not in our way (any other scheme
 432    I tried had the problem of old data lingering in the queue).
 433
 434    Whatever strategy you choose, it always remains a tradeoff: with more
 435    frame buffers the chances of a missed frame are reduced. On the other
 436    hand, on slower machines it introduces lag because the queue will
 437    always be full.
 438  */
 439
 440 /**
 441   \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.
 442  */
 443 static inline int pwc_next_fill_frame(struct pwc_device *pdev)
 444 {
 445         int ret;
 446         unsigned long flags;
 447
 448         ret = 0;
 449         spin_lock_irqsave(&pdev->ptrlock, flags);
 450         if (pdev->fill_frame != NULL) {
 451                 /* append to 'full' list */
 452                 if (pdev->full_frames == NULL) {
 453                         pdev->full_frames = pdev->fill_frame;
 454                         pdev->full_frames_tail = pdev->full_frames;
 455                 }
 456                 else {
 457                         pdev->full_frames_tail->next = pdev->fill_frame;
 458                         pdev->full_frames_tail = pdev->fill_frame;
 459                 }
 460         }
 461         if (pdev->empty_frames != NULL) {
 462                 /* We have empty frames available. That's easy */
 463                 pdev->fill_frame = pdev->empty_frames;
 464                 pdev->empty_frames = pdev->empty_frames->next;
 465         }
 466         else {
 467                 /* Hmm. Take it from the full list */
 468 #if PWC_DEBUG
 469                 /* sanity check */
 470                 if (pdev->full_frames == NULL) {
 471                         Err("Neither empty or full frames available!\n");
 472                         spin_unlock_irqrestore(&pdev->ptrlock, flags);
 473                         return -EINVAL;
 474                 }
 475 #endif
 476                 pdev->fill_frame = pdev->full_frames;
 477                 pdev->full_frames = pdev->full_frames->next;
 478                 ret = 1;
 479         }
 480         pdev->fill_frame->next = NULL;
 481 #if PWC_DEBUG
 482         Trace(TRACE_SEQUENCE, "Assigning sequence number %d.\n", pdev->sequence);
 483         pdev->fill_frame->sequence = pdev->sequence++;
 484 #endif
 485         spin_unlock_irqrestore(&pdev->ptrlock, flags);
 486         return ret;
 487 }
 488
 489
 490 /**
 491   \brief Reset all buffers, pointers and lists, except for the image_used[] buffer.
 492
 493   If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble.
 494  */
 495 static void pwc_reset_buffers(struct pwc_device *pdev)
 496 {
 497         int i;
 498         unsigned long flags;
 499
 500         spin_lock_irqsave(&pdev->ptrlock, flags);
 501         pdev->full_frames = NULL;
 502         pdev->full_frames_tail = NULL;
 503         for (i = 0; i < default_fbufs; i++) {
 504                 pdev->fbuf[i].filled = 0;
 505                 if (i > 0)
 506                         pdev->fbuf[i].next = &pdev->fbuf[i - 1];
 507                 else
 508                         pdev->fbuf->next = NULL;
 509         }
 510         pdev->empty_frames = &pdev->fbuf[default_fbufs - 1];
 511         pdev->empty_frames_tail = pdev->fbuf;
 512         pdev->read_frame = NULL;
 513         pdev->fill_frame = pdev->empty_frames;
 514         pdev->empty_frames = pdev->empty_frames->next;
 515
 516         pdev->image_read_pos = 0;
 517         pdev->fill_image = 0;
 518         spin_unlock_irqrestore(&pdev->ptrlock, flags);
 519 }
 520
 521
 522 /**
 523   \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.
 524  */
 525 static int pwc_handle_frame(struct pwc_device *pdev)
 526 {
 527         int ret = 0;
 528         unsigned long flags;
 529
 530         spin_lock_irqsave(&pdev->ptrlock, flags);
 531         /* First grab our read_frame; this is removed from all lists, so
 532            we can release the lock after this without problems */
 533         if (pdev->read_frame != NULL) {
 534                 /* This can't theoretically happen */
 535                 Err("Huh? Read frame still in use?\n");
 536         }
 537         else {
 538                 if (pdev->full_frames == NULL) {
 539                         Err("Woops. No frames ready.\n");
 540                 }
 541                 else {
 542                         pdev->read_frame = pdev->full_frames;
 543                         pdev->full_frames = pdev->full_frames->next;
 544                         pdev->read_frame->next = NULL;
 545                 }
 546
 547                 if (pdev->read_frame != NULL) {
 548 #if PWC_DEBUG
 549                         Trace(TRACE_SEQUENCE, "Decompressing frame %d\n", pdev->read_frame->sequence);
 550 #endif
 551                         /* Decompression is a lenghty process, so it's outside of the lock.
 552                            This gives the isoc_handler the opportunity to fill more frames
 553                            in the mean time.
 554                         */
 555                         spin_unlock_irqrestore(&pdev->ptrlock, flags);
 556                         ret = pwc_decompress(pdev);
 557                         spin_lock_irqsave(&pdev->ptrlock, flags);
 558
 559                         /* We're done with read_buffer, tack it to the end of the empty buffer list */
 560                         if (pdev->empty_frames == NULL) {
 561                                 pdev->empty_frames = pdev->read_frame;
 562                                 pdev->empty_frames_tail = pdev->empty_frames;
 563                         }
 564                         else {
 565                                 pdev->empty_frames_tail->next = pdev->read_frame;
 566                                 pdev->empty_frames_tail = pdev->read_frame;
 567                         }
 568                         pdev->read_frame = NULL;
 569                 }
 570         }
 571         spin_unlock_irqrestore(&pdev->ptrlock, flags);
 572         return ret;
 573 }
 574
 575 /**
 576   \brief Advance pointers of image buffer (after each user request)
 577 */
 578 static inline void pwc_next_image(struct pwc_device *pdev)
 579 {
 580         pdev->image_used[pdev->fill_image] = 0;
 581         pdev->fill_image = (pdev->fill_image + 1) % default_mbufs;
 582 }
 583
 584
 585 /* This gets called for the Isochronous pipe (video). This is done in
 586  * interrupt time, so it has to be fast, not crash, and not stall. Neat.
 587  */
 588 static void pwc_isoc_handler(struct urb *urb, struct pt_regs *regs)
 589 {
 590         struct pwc_device *pdev;
 591         int i, fst, flen;
 592         int awake;
 593         struct pwc_frame_buf *fbuf;
 594         unsigned char *fillptr = 0, *iso_buf = 0;
 595
 596         awake = 0;
 597         pdev = (struct pwc_device *)urb->context;
 598         if (pdev == NULL) {
 599                 Err("isoc_handler() called with NULL device?!\n");
 600                 return;
 601         }
 602 #ifdef PWC_MAGIC
 603         if (pdev->magic != PWC_MAGIC) {
 604                 Err("isoc_handler() called with bad magic!\n");
 605                 return;
 606         }
 607 #endif
 608         if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
 609                 Trace(TRACE_OPEN, "pwc_isoc_handler(): URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
 610                 return;
 611         }
 612         if (urb->status != -EINPROGRESS && urb->status != 0) {
 613                 const char *errmsg;
 614
 615                 errmsg = "Unknown";
 616                 switch(urb->status) {
 617                         case -ENOSR:            errmsg = "Buffer error (overrun)"; break;
 618                         case -EPIPE:            errmsg = "Stalled (device not responding)"; break;
 619                         case -EOVERFLOW:        errmsg = "Babble (bad cable?)"; break;
 620                         case -EPROTO:           errmsg = "Bit-stuff error (bad cable?)"; break;
 621                         case -EILSEQ:           errmsg = "CRC/Timeout (could be anything)"; break;
 622                         case -ETIMEDOUT:        errmsg = "NAK (device does not respond)"; break;
 623                 }
 624                 Trace(TRACE_FLOW, "pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
 625                 /* Give up after a number of contiguous errors on the USB bus.
 626                    Appearantly something is wrong so we simulate an unplug event.
 627                  */
 628                 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
 629                 {
 630                         Info("Too many ISOC errors, bailing out.\n");
 631                         pdev->error_status = EIO;
 632                         awake = 1;
 633                         wake_up_interruptible(&pdev->frameq);
 634                 }
 635                 goto handler_end; // ugly, but practical
 636         }
 637
 638         fbuf = pdev->fill_frame;
 639         if (fbuf == NULL) {
 640                 Err("pwc_isoc_handler without valid fill frame.\n");
 641                 awake = 1;
 642                 goto handler_end;
 643         }
 644         else {
 645                 fillptr = fbuf->data + fbuf->filled;
 646         }
 647
 648         /* Reset ISOC error counter. We did get here, after all. */
 649         pdev->visoc_errors = 0;
 650
 651         /* vsync: 0 = don't copy data
 652                   1 = sync-hunt
 653                   2 = synched
 654          */
 655         /* Compact data */
 656         for (i = 0; i < urb->number_of_packets; i++) {
 657                 fst  = urb->iso_frame_desc[i].status;
 658                 flen = urb->iso_frame_desc[i].actual_length;
 659                 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
 660                 if (fst == 0) {
 661                         if (flen > 0) { /* if valid data... */
 662                                 if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */
 663                                         pdev->vsync = 2;
 664
 665                                         /* ...copy data to frame buffer, if possible */
 666                                         if (flen + fbuf->filled > pdev->frame_size) {
 667                                                 Trace(TRACE_FLOW, "Frame buffer overflow (flen = %d, frame_size = %d).\n", flen, pdev->frame_size);
 668                                                 pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */
 669                                                 pdev->vframes_error++;
 670                                         }
 671                                         else {
 672                                                 memmove(fillptr, iso_buf, flen);
 673                                                 fillptr += flen;
 674                                         }
 675                                 }
 676                                 fbuf->filled += flen;
 677                         } /* ..flen > 0 */
 678
 679                         if (flen < pdev->vlast_packet_size) {
 680                                 /* Shorter packet... We probably have the end of an image-frame;
 681                                    wake up read() process and let select()/poll() do something.
 682                                    Decompression is done in user time over there.
 683                                  */
 684                                 if (pdev->vsync == 2) {
 685                                         /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
 686                                            frames on the USB wire after an exposure change. This conditition is
 687                                            however detected  in the cam and a bit is set in the header.
 688                                          */
 689                                         if (pdev->type == 730) {
 690                                                 unsigned char *ptr = (unsigned char *)fbuf->data;
 691
 692                                                 if (ptr[1] == 1 && ptr[0] & 0x10) {
 693 #if PWC_DEBUG
 694                                                         Debug("Hyundai CMOS sensor bug. Dropping frame %d.\n", fbuf->sequence);
 695 #endif
 696                                                         pdev->drop_frames += 2;
 697                                                         pdev->vframes_error++;
 698                                                 }
 699                                                 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
 700                                                         if (ptr[0] & 0x01)
 701                                                                 Info("Snapshot button pressed.\n");
 702                                                         else
 703                                                                 Info("Snapshot button released.\n");
 704                                                 }
 705                                                 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
 706                                                         if (ptr[0] & 0x02)
 707                                                                 Info("Image is mirrored.\n");
 708                                                         else
 709                                                                 Info("Image is normal.\n");
 710                                                 }
 711                                                 pdev->vmirror = ptr[0] & 0x03;
 712                                                 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
 713                                                    after a short frame; this condition is filtered out specifically. A 4 byte
 714                                                    frame doesn't make sense anyway.
 715                                                    So we get either this sequence:
 716                                                         drop_bit set -> 4 byte frame -> short frame -> good frame
 717                                                    Or this one:
 718                                                         drop_bit set -> short frame -> good frame
 719                                                    So we drop either 3 or 2 frames in all!
 720                                                  */
 721                                                 if (fbuf->filled == 4)
 722                                                         pdev->drop_frames++;
 723                                         }
 724
 725                                         /* In case we were instructed to drop the frame, do so silently.
 726                                            The buffer pointers are not updated either (but the counters are reset below).
 727                                          */
 728                                         if (pdev->drop_frames > 0)
 729                                                 pdev->drop_frames--;
 730                                         else {
 731                                                 /* Check for underflow first */
 732                                                 if (fbuf->filled < pdev->frame_size) {
 733                                                         Trace(TRACE_FLOW, "Frame buffer underflow (%d bytes); discarded.\n", fbuf->filled);
 734                                                         pdev->vframes_error++;
 735                                                 }
 736                                                 else {
 737                                                         /* Send only once per EOF */
 738                                                         awake = 1; /* delay wake_ups */
 739
 740                                                         /* Find our next frame to fill. This will always succeed, since we
 741                                                          * nick a frame from either empty or full list, but if we had to
 742                                                          * take it from the full list, it means a frame got dropped.
 743                                                          */
 744                                                         if (pwc_next_fill_frame(pdev)) {
 745                                                                 pdev->vframes_dumped++;
 746                                                                 if ((pdev->vframe_count > FRAME_LOWMARK) && (pwc_trace & TRACE_FLOW)) {
 747                                                                         if (pdev->vframes_dumped < 20)
 748                                                                                 Trace(TRACE_FLOW, "Dumping frame %d.\n", pdev->vframe_count);
 749                                                                         if (pdev->vframes_dumped == 20)
 750                                                                                 Trace(TRACE_FLOW, "Dumping frame %d (last message).\n", pdev->vframe_count);
 751                                                                 }
 752                                                         }
 753                                                         fbuf = pdev->fill_frame;
 754                                                 }
 755                                         } /* !drop_frames */
 756                                         pdev->vframe_count++;
 757                                 }
 758                                 fbuf->filled = 0;
 759                                 fillptr = fbuf->data;
 760                                 pdev->vsync = 1;
 761                         } /* .. flen < last_packet_size */
 762                         pdev->vlast_packet_size = flen;
 763                 } /* ..status == 0 */
 764 #if PWC_DEBUG
 765                 /* This is normally not interesting to the user, unless you are really debugging something */
 766                 else {
 767                         static int iso_error = 0;
 768                         iso_error++;
 769                         if (iso_error < 20)
 770                                 Trace(TRACE_FLOW, "Iso frame %d of USB has error %d\n", i, fst);
 771                 }
 772 #endif
 773         }
 774
 775 handler_end:
 776         if (awake)
 777                 wake_up_interruptible(&pdev->frameq);
 778
 779         urb->dev = pdev->udev;
 780         i = usb_submit_urb(urb, GFP_ATOMIC);
 781         if (i != 0)
 782                 Err("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
 783 }
 784
 785
 786 static int pwc_isoc_init(struct pwc_device *pdev)
 787 {
 788         struct usb_device *udev;
 789         struct urb *urb;
 790         int i, j, ret;
 791
 792         struct usb_host_interface *idesc;
 793
 794         if (pdev == NULL)
 795                 return -EFAULT;
 796         if (pdev->iso_init)
 797                 return 0;
 798         pdev->vsync = 0;
 799         udev = pdev->udev;
 800
 801         /* Get the current alternate interface, adjust packet size */
 802         if (!udev->actconfig)
 803                 return -EFAULT;
 804         idesc = &udev->actconfig->interface[0]->altsetting[pdev->valternate];
 805         if (!idesc)
 806                 return -EFAULT;
 807
 808         /* Search video endpoint */
 809         pdev->vmax_packet_size = -1;
 810         for (i = 0; i < idesc->desc.bNumEndpoints; i++)
 811                 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
 812                         pdev->vmax_packet_size = idesc->endpoint[i].desc.wMaxPacketSize;
 813                         break;
 814                 }
 815
 816         if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
 817                 Err("Failed to find packet size for video endpoint in current alternate setting.\n");
 818                 return -ENFILE; /* Odd error, that should be noticeable */
 819         }
 820
 821         /* Set alternate interface */
 822         ret = 0;
 823         Trace(TRACE_OPEN, "Setting alternate interface %d\n", pdev->valternate);
 824         ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
 825         if (ret < 0)
 826                 return ret;
 827
 828         for (i = 0; i < MAX_ISO_BUFS; i++) {
 829                 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
 830                 if (urb == NULL) {
 831                         Err("Failed to allocate urb %d\n", i);
 832                         ret = -ENOMEM;
 833                         break;
 834                 }
 835                 pdev->sbuf[i].urb = urb;
 836                 Trace(TRACE_MEMORY, "Allocated URB at 0x%p\n", urb);
 837         }
 838         if (ret) {
 839                 /* De-allocate in reverse order */
 840                 while (i >= 0) {
 841                         if (pdev->sbuf[i].urb != NULL)
 842                                 usb_free_urb(pdev->sbuf[i].urb);
 843                         pdev->sbuf[i].urb = NULL;
 844                         i--;
 845                 }
 846                 return ret;
 847         }
 848
 849         /* init URB structure */
 850         for (i = 0; i < MAX_ISO_BUFS; i++) {
 851                 urb = pdev->sbuf[i].urb;
 852
 853                 urb->interval = 1; // devik
 854                 urb->dev = udev;
 855                 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
 856                 urb->transfer_flags = URB_ISO_ASAP;
 857                 urb->transfer_buffer = pdev->sbuf[i].data;
 858                 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
 859                 urb->complete = pwc_isoc_handler;
 860                 urb->context = pdev;
 861                 urb->start_frame = 0;
 862                 urb->number_of_packets = ISO_FRAMES_PER_DESC;
 863                 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
 864                         urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
 865                         urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
 866                 }
 867         }
 868
 869         /* link */
 870         for (i = 0; i < MAX_ISO_BUFS; i++) {
 871                 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL);
 872                 if (ret)
 873                         Err("isoc_init() submit_urb %d failed with error %d\n", i, ret);
 874                 else
 875                         Trace(TRACE_OPEN, "URB 0x%p submitted.\n", pdev->sbuf[i].urb);
 876         }
 877
 878         /* All is done... */
 879         pdev->iso_init = 1;
 880         Trace(TRACE_OPEN, "<< pwc_isoc_init()\n");
 881         return 0;
 882 }
 883
 884 static void pwc_isoc_cleanup(struct pwc_device *pdev)
 885 {
 886         int i;
 887
 888         Trace(TRACE_OPEN, ">> pwc_isoc_cleanup()\n");
 889         if (pdev == NULL)
 890                 return;
 891
 892         /* Unlinking ISOC buffers one by one */
 893         for (i = 0; i < MAX_ISO_BUFS; i++) {
 894                 struct urb *urb;
 895
 896                 urb = pdev->sbuf[i].urb;
 897                 if (urb != 0) {
 898                         if (pdev->iso_init) {
 899                                 Trace(TRACE_MEMORY, "Unlinking URB %p\n", urb);
 900                                 usb_unlink_urb(urb);
 901                         }
 902                         Trace(TRACE_MEMORY, "Freeing URB\n");
 903                         usb_free_urb(urb);
 904                         pdev->sbuf[i].urb = NULL;
 905                 }
 906         }
 907
 908         /* Stop camera, but only if we are sure the camera is still there (unplug
 909            is signalled by EPIPE)
 910          */
 911         if (pdev->error_status && pdev->error_status != EPIPE) {
 912                 Trace(TRACE_OPEN, "Setting alternate interface 0.\n");
 913                 usb_set_interface(pdev->udev, 0, 0);
 914         }
 915
 916         pdev->iso_init = 0;
 917         Trace(TRACE_OPEN, "<< pwc_isoc_cleanup()\n");
 918 }
 919
 920 int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot)
 921 {
 922         int ret, start;
 923
 924         /* Stop isoc stuff */
 925         pwc_isoc_cleanup(pdev);
 926         /* Reset parameters */
 927         pwc_reset_buffers(pdev);
 928         /* Try to set video mode... */
 929         start = ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot);
 930         if (ret) {
 931                 Trace(TRACE_FLOW, "pwc_set_video_mode attempt 1 failed.\n");
 932                 /* That failed... restore old mode (we know that worked) */
 933                 start = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
 934                 if (start) {
 935                         Trace(TRACE_FLOW, "pwc_set_video_mode attempt 2 failed.\n");
 936                 }
 937         }
 938         if (start == 0)
 939         {
 940                 if (pwc_isoc_init(pdev) < 0)
 941                 {
 942                         Info("Failed to restart ISOC transfers in pwc_try_video_mode.\n");
 943                         ret = -EAGAIN; /* let's try again, who knows if it works a second time */
 944                 }
 945         }
 946         pdev->drop_frames++; /* try to avoid garbage during switch */
 947         return ret; /* Return original error code */
 948 }
 949
 950
 951 /***************************************************************************/
 952 /* Video4Linux functions */
 953
 954 static int pwc_video_open(struct inode *inode, struct file *file)
 955 {
 956         int i;
 957         struct video_device *vdev = video_devdata(file);
 958         struct pwc_device *pdev;
 959
 960         Trace(TRACE_OPEN, ">> video_open called(vdev = 0x%p).\n", vdev);
 961
 962         pdev = (struct pwc_device *)vdev->priv;
 963         if (pdev == NULL)
 964                 BUG();
 965         if (pdev->vopen)
 966                 return -EBUSY;
 967
 968         down(&pdev->modlock);
 969         if (!pdev->usb_init) {
 970                 Trace(TRACE_OPEN, "Doing first time initialization.\n");
 971                 pdev->usb_init = 1;
 972
 973                 if (pwc_trace & TRACE_OPEN) {
 974                         /* Query sensor type */
 975                         const char *sensor_type = NULL;
 976
 977                         i = pwc_get_cmos_sensor(pdev);
 978                         switch(i) {
 979                         case -1: /* Unknown, show nothing */; break;
 980                         case 0x00:  sensor_type = "Hyundai CMOS sensor"; break;
 981                         case 0x20:  sensor_type = "Sony CCD sensor + TDA8787"; break;
 982                         case 0x2E:  sensor_type = "Sony CCD sensor + Exas 98L59"; break;
 983                         case 0x2F:  sensor_type = "Sony CCD sensor + ADI 9804"; break;
 984                         case 0x30:  sensor_type = "Sharp CCD sensor + TDA8787"; break;
 985                         case 0x3E:  sensor_type = "Sharp CCD sensor + Exas 98L59"; break;
 986                         case 0x3F:  sensor_type = "Sharp CCD sensor + ADI 9804"; break;
 987                         case 0x40:  sensor_type = "UPA 1021 sensor"; break;
 988                         case 0x100: sensor_type = "VGA sensor"; break;
 989                         case 0x101: sensor_type = "PAL MR sensor"; break;
 990                         default:    sensor_type = "unknown type of sensor"; break;
 991                         }
 992                         if (sensor_type != NULL)
 993                                 Info("This %s camera is equipped with a %s (%d).\n", pdev->vdev.name, sensor_type, i);
 994                 }
 995         }
 996
 997         /* Turn on camera */
 998         if (power_save) {
 999                 i = pwc_camera_power(pdev, 1);
1000                 if (i < 0)
1001                         Info("Failed to restore power to the camera! (%d)\n", i);
1002         }
1003         /* Set LED on/off time */
1004         if (pwc_set_leds(pdev, led_on, led_off) < 0)
1005                 Info("Failed to set LED on/off time.\n");
1006
1007         /* Find our decompressor, if any */
1008         pdev->decompressor = pwc_find_decompressor(pdev->type);
1009 #if PWC_DEBUG
1010         Debug("Found decompressor for %d at 0x%p\n", pdev->type, pdev->decompressor);
1011 #endif
1012         pwc_construct(pdev); /* set min/max sizes correct */
1013
1014         /* So far, so good. Allocate memory. */
1015         i = pwc_allocate_buffers(pdev);
1016         if (i < 0) {
1017                 Trace(TRACE_OPEN, "Failed to allocate buffer memory.\n");
1018                 up(&pdev->modlock);
1019                 return i;
1020         }
1021
1022         /* Reset buffers & parameters */
1023         pwc_reset_buffers(pdev);
1024         for (i = 0; i < default_mbufs; i++)
1025                 pdev->image_used[i] = 0;
1026         pdev->vframe_count = 0;
1027         pdev->vframes_dumped = 0;
1028         pdev->vframes_error = 0;
1029         pdev->visoc_errors = 0;
1030         pdev->error_status = 0;
1031 #if PWC_DEBUG
1032         pdev->sequence = 0;
1033 #endif
1034         pwc_construct(pdev); /* set min/max sizes correct */
1035
1036         /* Set some defaults */
1037         pdev->vsnapshot = 0;
1038         /* Start iso pipe for video; first try the last used video size
1039            (or the default one); if that fails try QCIF/10 or QSIF/10;
1040            it that fails too, give up.
1041          */
1042         i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1043         if (i)  {
1044                 Trace(TRACE_OPEN, "First attempt at set_video_mode failed.\n");
1045                 if (pdev->type == 730 || pdev->type == 740 || pdev->type == 750)
1046                         i = pwc_set_video_mode(pdev, pwc_image_sizes[PSZ_QSIF].x, pwc_image_sizes[PSZ_QSIF].y, 10, pdev->vcompression, 0);
1047                 else
1048                         i = pwc_set_video_mode(pdev, pwc_image_sizes[PSZ_QCIF].x, pwc_image_sizes[PSZ_QCIF].y, 10, pdev->vcompression, 0);
1049         }
1050         if (i) {
1051                 Trace(TRACE_OPEN, "Second attempt at set_video_mode failed.\n");
1052                 up(&pdev->modlock);
1053                 return i;
1054         }
1055
1056         i = pwc_isoc_init(pdev);
1057         if (i) {
1058                 Trace(TRACE_OPEN, "Failed to init ISOC stuff = %d.\n", i);
1059                 up(&pdev->modlock);
1060                 return i;
1061         }
1062
1063         pdev->vopen++;
1064         file->private_data = vdev;
1065         /* lock decompressor; this has a small race condition, since we
1066            could in theory unload pwcx.o between pwc_find_decompressor()
1067            above and this call. I doubt it's ever going to be a problem.
1068          */
1069         if (pdev->decompressor != NULL)
1070                 pdev->decompressor->lock();
1071         up(&pdev->modlock);
1072         Trace(TRACE_OPEN, "<< video_open() returns 0.\n");
1073         return 0;
1074 }
1075
1076 /* Note that all cleanup is done in the reverse order as in _open */
1077 static int pwc_video_close(struct inode *inode, struct file *file)
1078 {
1079         struct video_device *vdev = file->private_data;
1080         struct pwc_device *pdev;
1081         int i;
1082
1083         Trace(TRACE_OPEN, ">> video_close called(vdev = 0x%p).\n", vdev);
1084
1085         pdev = (struct pwc_device *)vdev->priv;
1086         if (pdev->vopen == 0)
1087                 Info("video_close() called on closed device?\n");
1088
1089         /* Dump statistics, but only if a reasonable amount of frames were
1090            processed (to prevent endless log-entries in case of snap-shot
1091            programs)
1092          */
1093         if (pdev->vframe_count > 20)
1094                 Info("Closing video device: %d frames received, dumped %d frames, %d frames with errors.\n", pdev->vframe_count, pdev->vframes_dumped, pdev->vframes_error);
1095
1096         if (pdev->decompressor != NULL) {
1097                 pdev->decompressor->exit();
1098                 pdev->decompressor->unlock();
1099                 pdev->decompressor = NULL;
1100         }
1101
1102         pwc_isoc_cleanup(pdev);
1103         pwc_free_buffers(pdev);
1104
1105         /* Turn off LEDS and power down camera, but only when not unplugged */
1106         if (pdev->error_status != EPIPE) {
1107                 /* Turn LEDs off */
1108                 if (pwc_set_leds(pdev, 0, 0) < 0)
1109                         Info("Failed to set LED on/off time.\n");
1110                 if (power_save) {
1111                         i = pwc_camera_power(pdev, 0);
1112                         if (i < 0)
1113                                 Err("Failed to power down camera (%d)\n", i);
1114                 }
1115         }
1116         pdev->vopen = 0;
1117         Trace(TRACE_OPEN, "<< video_close()\n");
1118         return 0;
1119 }
1120
1121 static int pwc_video_release(struct video_device *vfd)
1122 {
1123         Trace(TRACE_OPEN, "pwc_video_release() called. Now what?\n");
1124 }
1125
1126
1127 /*
1128  *      FIXME: what about two parallel reads ????
1129  *      ANSWER: Not supported. You can't open the device more than once,
1130                 despite what the V4L1 interface says. First, I don't see
1131                 the need, second there's no mechanism of alerting the
1132                 2nd/3rd/... process of events like changing image size.
1133                 And I don't see the point of blocking that for the
1134                 2nd/3rd/... process.
1135                 In multi-threaded environments reading parallel from any
1136                 device is tricky anyhow.
1137  */
1138
1139 static ssize_t pwc_video_read(struct file *file, char *buf,
1140                           size_t count, loff_t *ppos)
1141 {
1142         struct video_device *vdev = file->private_data;
1143         struct pwc_device *pdev;
1144         int noblock = file->f_flags & O_NONBLOCK;
1145         DECLARE_WAITQUEUE(wait, current);
1146
1147         Trace(TRACE_READ, "video_read(0x%p, %p, %d) called.\n", vdev, buf, count);
1148         if (vdev == NULL)
1149                 return -EFAULT;
1150         pdev = vdev->priv;
1151         if (pdev == NULL)
1152                 return -EFAULT;
1153         if (pdev->error_status)
1154                 return -pdev->error_status; /* Something happened, report what. */
1155
1156         /* In case we're doing partial reads, we don't have to wait for a frame */
1157         if (pdev->image_read_pos == 0) {
1158                 /* Do wait queueing according to the (doc)book */
1159                 add_wait_queue(&pdev->frameq, &wait);
1160                 while (pdev->full_frames == NULL) {
1161                         /* Check for unplugged/etc. here */
1162                         if (pdev->error_status) {
1163                                 remove_wait_queue(&pdev->frameq, &wait);
1164                                 set_current_state(TASK_RUNNING);
1165                                 return -pdev->error_status ;
1166                         }
1167                         if (noblock) {
1168                                 remove_wait_queue(&pdev->frameq, &wait);
1169                                 set_current_state(TASK_RUNNING);
1170                                 return -EWOULDBLOCK;
1171                         }
1172                         if (signal_pending(current)) {
1173                                 remove_wait_queue(&pdev->frameq, &wait);
1174                                 set_current_state(TASK_RUNNING);
1175                                 return -ERESTARTSYS;
1176                         }
1177                         schedule();
1178                         set_current_state(TASK_INTERRUPTIBLE);
1179                 }
1180                 remove_wait_queue(&pdev->frameq, &wait);
1181                 set_current_state(TASK_RUNNING);
1182
1183                 /* Decompress and release frame */
1184                 if (pwc_handle_frame(pdev))
1185                         return -EFAULT;
1186         }
1187
1188         Trace(TRACE_READ, "Copying data to user space.\n");
1189         /* copy bytes to user space; we allow for partial reads */
1190         if (count + pdev->image_read_pos > pdev->view.size)
1191                 count = pdev->view.size - pdev->image_read_pos;
1192         if (copy_to_user(buf, pdev->image_ptr[pdev->fill_image] + pdev->image_read_pos, count))
1193                 return -EFAULT;
1194         pdev->image_read_pos += count;
1195         if (pdev->image_read_pos >= pdev->view.size) { /* All data has been read */
1196                 pdev->image_read_pos = 0;
1197                 pwc_next_image(pdev);
1198         }
1199         return count;
1200 }
1201
1202 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1203 {
1204         struct video_device *vdev = file->private_data;
1205         struct pwc_device *pdev;
1206
1207         if (vdev == NULL)
1208                 return -EFAULT;
1209         pdev = vdev->priv;
1210         if (pdev == NULL)
1211                 return -EFAULT;
1212
1213         poll_wait(file, &pdev->frameq, wait);
1214         if (pdev->error_status)
1215                 return POLLERR;
1216         if (pdev->full_frames != NULL) /* we have frames waiting */
1217                 return (POLLIN | POLLRDNORM);
1218
1219         return 0;
1220 }
1221
1222 static int pwc_video_do_ioctl(struct inode *inode, struct file *file,
1223                               unsigned int cmd, void *arg)
1224 {
1225         struct video_device *vdev = file->private_data;
1226         struct pwc_device *pdev;
1227         DECLARE_WAITQUEUE(wait, current);
1228
1229         if (vdev == NULL)
1230                 return -EFAULT;
1231         pdev = vdev->priv;
1232         if (pdev == NULL)
1233                 return -EFAULT;
1234
1235         switch (cmd) {
1236                 /* Query cabapilities */
1237                 case VIDIOCGCAP:
1238                 {
1239                         struct video_capability *caps = arg;
1240
1241                         strcpy(caps->name, vdev->name);
1242                         caps->type = VID_TYPE_CAPTURE;
1243                         caps->channels = 1;
1244                         caps->audios = 1;
1245                         caps->minwidth  = pdev->view_min.x;
1246                         caps->minheight = pdev->view_min.y;
1247                         caps->maxwidth  = pdev->view_max.x;
1248                         caps->maxheight = pdev->view_max.y;
1249                         break;
1250                 }
1251
1252                 /* Channel functions (simulate 1 channel) */
1253                 case VIDIOCGCHAN:
1254                 {
1255                         struct video_channel *v = arg;
1256
1257                         if (v->channel != 0)
1258                                 return -EINVAL;
1259                         v->flags = 0;
1260                         v->tuners = 0;
1261                         v->type = VIDEO_TYPE_CAMERA;
1262                         strcpy(v->name, "Webcam");
1263                         return 0;
1264                 }
1265
1266                 case VIDIOCSCHAN:
1267                 {
1268                         /* The spec says the argument is an integer, but
1269                            the bttv driver uses a video_channel arg, which
1270                            makes sense becasue it also has the norm flag.
1271                          */
1272                         struct video_channel *v = arg;
1273                         if (v->channel != 0)
1274                                 return -EINVAL;
1275                         return 0;
1276                 }
1277
1278
1279                 /* Picture functions; contrast etc. */
1280                 case VIDIOCGPICT:
1281                 {
1282                         struct video_picture *p = arg;
1283                         int val;
1284
1285                         p->colour = 0x8000;
1286                         p->hue = 0x8000;
1287                         val = pwc_get_brightness(pdev);
1288                         if (val >= 0)
1289                                 p->brightness = val;
1290                         else
1291                                 p->brightness = 0xffff;
1292                         val = pwc_get_contrast(pdev);
1293                         if (val >= 0)
1294                                 p->contrast = val;
1295                         else
1296                                 p->contrast = 0xffff;
1297                         /* Gamma, Whiteness, what's the difference? :) */
1298                         val = pwc_get_gamma(pdev);
1299                         if (val >= 0)
1300                                 p->whiteness = val;
1301                         else
1302                                 p->whiteness = 0xffff;
1303                         val = pwc_get_saturation(pdev);
1304                         if (val >= 0)
1305                                 p->colour = val;
1306                         else
1307                                 p->colour = 0xffff;
1308                         p->depth = 24;
1309                         p->palette = VIDEO_PALETTE_YUV420P;
1310                         p->hue = 0xFFFF; /* N/A */
1311                         break;
1312                 }
1313
1314                 case VIDIOCSPICT:
1315                 {
1316                         struct video_picture *p = arg;
1317                         /*
1318                          *      FIXME:  Suppose we are mid read
1319                                 ANSWER: No problem: the firmware of the camera
1320                                         can handle brightness/contrast/etc
1321                                         changes at _any_ time, and the palette
1322                                         is used exactly once in the uncompress
1323                                         routine.
1324                          */
1325                         if (p->palette && p->palette != VIDEO_PALETTE_YUV420P) {
1326                                 return -EINVAL;
1327                         }
1328                         pwc_set_brightness(pdev, p->brightness);
1329                         pwc_set_contrast(pdev, p->contrast);
1330                         pwc_set_gamma(pdev, p->whiteness);
1331                         pwc_set_saturation(pdev, p->colour);
1332                         break;
1333                 }
1334
1335                 /* Window/size parameters */
1336                 case VIDIOCGWIN:
1337                 {
1338                         struct video_window *vw = arg;
1339
1340                         vw->x = 0;
1341                         vw->y = 0;
1342                         vw->width = pdev->view.x;
1343                         vw->height = pdev->view.y;
1344                         vw->chromakey = 0;
1345                         vw->flags = (pdev->vframes << PWC_FPS_SHIFT) |
1346                                    (pdev->vsnapshot ? PWC_FPS_SNAPSHOT : 0);
1347                         break;
1348                 }
1349
1350                 case VIDIOCSWIN:
1351                 {
1352                         struct video_window *vw = arg;
1353                         int fps, snapshot, ret;
1354
1355                         fps = (vw->flags & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
1356                         snapshot = vw->flags & PWC_FPS_SNAPSHOT;
1357                         if (fps == 0)
1358                                 fps = pdev->vframes;
1359                         if (pdev->view.x == vw->width && pdev->view.y && fps == pdev->vframes && snapshot == pdev->vsnapshot)
1360                                 return 0;
1361                         ret = pwc_try_video_mode(pdev, vw->width, vw->height, fps, pdev->vcompression, snapshot);
1362                         if (ret)
1363                                 return ret;
1364                         break;
1365                 }
1366
1367                 /* We don't have overlay support (yet) */
1368                 case VIDIOCGFBUF:
1369                 {
1370                         struct video_buffer *vb = arg;
1371
1372                         memset(vb,0,sizeof(*vb));
1373                         break;
1374                 }
1375
1376                 /* mmap() functions */
1377                 case VIDIOCGMBUF:
1378                 {
1379                         /* Tell the user program how much memory is needed for a mmap() */
1380                         struct video_mbuf *vm = arg;
1381                         int i;
1382
1383                         memset(vm, 0, sizeof(*vm));
1384                         vm->size = default_mbufs * pdev->len_per_image;
1385                         vm->frames = default_mbufs; /* double buffering should be enough for most applications */
1386                         for (i = 0; i < default_mbufs; i++)
1387                                 vm->offsets[i] = i * pdev->len_per_image;
1388                         break;
1389                 }
1390
1391                 case VIDIOCMCAPTURE:
1392                 {
1393                         /* Start capture into a given image buffer (called 'frame' in video_mmap structure) */
1394                         struct video_mmap *vm = arg;
1395
1396                         Trace(TRACE_READ, "VIDIOCMCAPTURE: %dx%d, frame %d, format %d\n", vm->width, vm->height, vm->frame, vm->format);
1397                         if (vm->frame < 0 || vm->frame >= default_mbufs)
1398                                 return -EINVAL;
1399
1400                         /* xawtv is nasty. It probes the available palettes
1401                            by setting a very small image size and trying
1402                            various palettes... The driver doesn't support
1403                            such small images, so I'm working around it.
1404                          */
1405                         if (vm->format && vm->format != VIDEO_PALETTE_YUV420P)
1406                                 return -EINVAL;
1407
1408                         if ((vm->width != pdev->view.x || vm->height != pdev->view.y) &&
1409                             (vm->width >= pdev->view_min.x && vm->height >= pdev->view_min.y)) {
1410                                 int ret;
1411
1412                                 Trace(TRACE_OPEN, "VIDIOCMCAPTURE: changing size to please xawtv :-(.\n");
1413                                 ret = pwc_try_video_mode(pdev, vm->width, vm->height, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
1414                                 if (ret)
1415                                         return ret;
1416                         } /* ... size mismatch */
1417
1418                         /* FIXME: should we lock here? */
1419                         if (pdev->image_used[vm->frame])
1420                                 return -EBUSY;  /* buffer wasn't available. Bummer */
1421                         pdev->image_used[vm->frame] = 1;
1422
1423                         /* Okay, we're done here. In the SYNC call we wait until a
1424                            frame comes available, then expand image into the given
1425                            buffer.
1426                            In contrast to the CPiA cam the Philips cams deliver a
1427                            constant stream, almost like a grabber card. Also,
1428                            we have separate buffers for the rawdata and the image,
1429                            meaning we can nearly always expand into the requested buffer.
1430                          */
1431                         Trace(TRACE_READ, "VIDIOCMCAPTURE done.\n");
1432                         break;
1433                 }
1434
1435                 case VIDIOCSYNC:
1436                 {
1437                         /* The doc says: "Whenever a buffer is used it should
1438                            call VIDIOCSYNC to free this frame up and continue."
1439
1440                            The only odd thing about this whole procedure is
1441                            that MCAPTURE flags the buffer as "in use", and
1442                            SYNC immediately unmarks it, while it isn't
1443                            after SYNC that you know that the buffer actually
1444                            got filled! So you better not start a CAPTURE in
1445                            the same frame immediately (use double buffering).
1446                            This is not a problem for this cam, since it has
1447                            extra intermediate buffers, but a hardware
1448                            grabber card will then overwrite the buffer
1449                            you're working on.
1450                          */
1451                         int *mbuf = arg;
1452                         int ret;
1453
1454                         Trace(TRACE_READ, "VIDIOCSYNC called (%d).\n", *mbuf);
1455
1456                         /* bounds check */
1457                         if (*mbuf < 0 || *mbuf >= default_mbufs)
1458                                 return -EINVAL;
1459                         /* check if this buffer was requested anyway */
1460                         if (pdev->image_used[*mbuf] == 0)
1461                                 return -EINVAL;
1462
1463                         /* Add ourselves to the frame wait-queue.
1464
1465                            FIXME: needs auditing for safety.
1466                            QUESTION: In what respect? I think that using the
1467                                      frameq is safe now.
1468                          */
1469                         add_wait_queue(&pdev->frameq, &wait);
1470                         while (pdev->full_frames == NULL) {
1471                                 if (pdev->error_status) {
1472                                         remove_wait_queue(&pdev->frameq, &wait);
1473                                         set_current_state(TASK_RUNNING);
1474                                         return -pdev->error_status;
1475                                 }
1476
1477                                 if (signal_pending(current)) {
1478                                         remove_wait_queue(&pdev->frameq, &wait);
1479                                         set_current_state(TASK_RUNNING);
1480                                         return -ERESTARTSYS;
1481                                 }
1482                                 schedule();
1483                                 set_current_state(TASK_INTERRUPTIBLE);
1484                         }
1485                         remove_wait_queue(&pdev->frameq, &wait);
1486                         set_current_state(TASK_RUNNING);
1487
1488                         /* The frame is ready. Expand in the image buffer
1489                            requested by the user. I don't care if you
1490                            mmap() 5 buffers and request data in this order:
1491                            buffer 4 2 3 0 1 2 3 0 4 3 1 . . .
1492                            Grabber hardware may not be so forgiving.
1493                          */
1494                         Trace(TRACE_READ, "VIDIOCSYNC: frame ready.\n");
1495                         pdev->fill_image = *mbuf; /* tell in which buffer we want the image to be expanded */
1496                         /* Decompress, etc */
1497                         ret = pwc_handle_frame(pdev);
1498                         pdev->image_used[*mbuf] = 0;
1499                         if (ret)
1500                                 return -EFAULT;
1501                         break;
1502                 }
1503
1504                 case VIDIOCGAUDIO:
1505                 {
1506                         struct video_audio *v = arg;
1507
1508                         strcpy(v->name, "Microphone");
1509                         v->audio = -1; /* unknown audio minor */
1510                         v->flags = 0;
1511                         v->mode = VIDEO_SOUND_MONO;
1512                         v->volume = 0;
1513                         v->bass = 0;
1514                         v->treble = 0;
1515                         v->balance = 0x8000;
1516                         v->step = 1;
1517                         break;
1518                 }
1519
1520                 case VIDIOCSAUDIO:
1521                 {
1522                         /* Dummy: nothing can be set */
1523                         break;
1524                 }
1525
1526                 case VIDIOCGUNIT:
1527                 {
1528                         struct video_unit *vu = arg;
1529
1530                         vu->video = pdev->vdev.minor & 0x3F;
1531                         vu->audio = -1; /* not known yet */
1532                         vu->vbi = -1;
1533                         vu->radio = -1;
1534                         vu->teletext = -1;
1535                         break;
1536                 }
1537                 default:
1538                         return pwc_ioctl(pdev, cmd, arg);
1539         } /* ..switch */
1540         return 0;
1541 }
1542
1543 static int pwc_video_ioctl(struct inode *inode, struct file *file,
1544                            unsigned int cmd, unsigned long arg)
1545 {
1546         return video_usercopy(inode, file, cmd, arg, pwc_video_do_ioctl);
1547 }
1548
1549
1550 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1551 {
1552         struct video_device *vdev = file->private_data;
1553         struct pwc_device *pdev;
1554         unsigned long start = vma->vm_start;
1555         unsigned long size  = vma->vm_end-vma->vm_start;
1556         unsigned long page, pos;
1557
1558         Trace(TRACE_MEMORY, "mmap(0x%p, 0x%lx, %lu) called.\n", vdev, start, size);
1559         pdev = vdev->priv;
1560
1561         pos = (unsigned long)pdev->image_data;
1562         while (size > 0) {
1563                 page = kvirt_to_pa(pos);
1564                 if (remap_page_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1565                         return -EAGAIN;
1566
1567                 start += PAGE_SIZE;
1568                 pos += PAGE_SIZE;
1569                 if (size > PAGE_SIZE)
1570                         size -= PAGE_SIZE;
1571                 else
1572                         size = 0;
1573         }
1574
1575         return 0;
1576 }
1577
1578 /***************************************************************************/
1579 /* USB functions */
1580
1581 /* This function gets called when a new device is plugged in or the usb core
1582  * is loaded.
1583  */
1584
1585 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1586 {
1587         struct usb_device *udev = interface_to_usbdev(intf);
1588         struct pwc_device *pdev = NULL;
1589         int vendor_id, product_id, type_id;
1590         int i, hint;
1591         int features = 0;
1592         int video_nr = -1; /* default: use next available device */
1593         char serial_number[30], *name;
1594
1595         /* Check if we can handle this device */
1596         Trace(TRACE_PROBE, "probe() called [%04X %04X], if %d\n",
1597                 udev->descriptor.idVendor, udev->descriptor.idProduct,
1598                 intf->altsetting->desc.bInterfaceNumber);
1599
1600         /* the interfaces are probed one by one. We are only interested in the
1601            video interface (0) now.
1602            Interface 1 is the Audio Control, and interface 2 Audio itself.
1603          */
1604         if (intf->altsetting->desc.bInterfaceNumber > 0)
1605                 return -ENODEV;
1606
1607         vendor_id = udev->descriptor.idVendor;
1608         product_id = udev->descriptor.idProduct;
1609
1610         if (vendor_id == 0x0471) {
1611                 switch (product_id) {
1612                 case 0x0302:
1613                         Info("Philips PCA645VC USB webcam detected.\n");
1614                         name = "Philips 645 webcam";
1615                         type_id = 645;
1616                         break;
1617                 case 0x0303:
1618                         Info("Philips PCA646VC USB webcam detected.\n");
1619                         name = "Philips 646 webcam";
1620                         type_id = 646;
1621                         break;
1622                 case 0x0304:
1623                         Info("Askey VC010 type 2 USB webcam detected.\n");
1624                         name = "Askey VC010 webcam";
1625                         type_id = 646;
1626                         break;
1627                 case 0x0307:
1628                         Info("Philips PCVC675K (Vesta) USB webcam detected.\n");
1629                         name = "Philips 675 webcam";
1630                         type_id = 675;
1631                         break;
1632                 case 0x0308:
1633                         Info("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1634                         name = "Philips 680 webcam";
1635                         type_id = 680;
1636                         break;
1637                 case 0x030C:
1638                         Info("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1639                         name = "Philips 690 webcam";
1640                         type_id = 690;
1641                         break;
1642                 case 0x0310:
1643                         Info("Philips PCVC730K (ToUCam Fun) USB webcam detected.\n");
1644                         name = "Philips 730 webcam";
1645                         type_id = 730;
1646                         break;
1647                 case 0x0311:
1648                         Info("Philips PCVC740K (ToUCam Pro) USB webcam detected.\n");
1649                         name = "Philips 740 webcam";
1650                         type_id = 740;
1651                         break;
1652                 case 0x0312:
1653                         Info("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1654                         name = "Philips 750 webcam";
1655                         type_id = 750;
1656                         break;
1657                 case 0x0313:
1658                         Info("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1659                         name = "Philips 720K/40 webcam";
1660                         type_id = 720;
1661                         break;
1662                 default:
1663                         return -ENODEV;
1664                         break;
1665                 }
1666         }
1667         else if (vendor_id == 0x069A) {
1668                 switch(product_id) {
1669                 case 0x0001:
1670                         Info("Askey VC010 type 1 USB webcam detected.\n");
1671                         name = "Askey VC010 webcam";
1672                         type_id = 645;
1673                         break;
1674                 default:
1675                         return -ENODEV;
1676                         break;
1677                 }
1678         }
1679         else if (vendor_id == 0x046d) {
1680                 switch(product_id) {
1681                 case 0x08b0:
1682                         Info("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1683                         name = "Logitech QuickCam Pro 3000";
1684                         type_id = 740; /* CCD sensor */
1685                         break;
1686                 case 0x08b1:
1687                         Info("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1688                         name = "Logitech QuickCam Notebook Pro";
1689                         type_id = 740; /* CCD sensor */
1690                         break;
1691                 case 0x08b2:
1692                         Info("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1693                         name = "Logitech QuickCam Pro 4000";
1694                         type_id = 740; /* CCD sensor */
1695                         break;
1696                 case 0x08b3:
1697                         Info("Logitech QuickCam Zoom USB webcam detected.\n");
1698                         name = "Logitech QuickCam Zoom";
1699                         type_id = 740; /* CCD sensor */
1700                         break;
1701                 case 0x08B4:
1702                         Info("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1703                         name = "Logitech QuickCam Zoom";
1704                         type_id = 740; /* CCD sensor */
1705                         break;
1706                 case 0x08b5:
1707                         Info("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1708                         name = "Logitech QuickCam Orbit";
1709                         type_id = 740; /* CCD sensor */
1710                         features |= FEATURE_MOTOR_PANTILT;
1711                         break;
1712                 case 0x08b6:
1713                 case 0x08b7:
1714                 case 0x08b8:
1715                         Info("Logitech QuickCam detected (reserved ID).\n");
1716                         name = "Logitech QuickCam (res.)";
1717                         type_id = 730; /* Assuming CMOS */
1718                         break;
1719                 default:
1720                         return -ENODEV;
1721                         break;
1722                 }
1723         }
1724         else if (vendor_id == 0x055d) {
1725                 /* I don't know the difference between the C10 and the C30;
1726                    I suppose the difference is the sensor, but both cameras
1727                    work equally well with a type_id of 675
1728                  */
1729                 switch(product_id) {
1730                 case 0x9000:
1731                         Info("Samsung MPC-C10 USB webcam detected.\n");
1732                         name = "Samsung MPC-C10";
1733                         type_id = 675;
1734                         break;
1735                 case 0x9001:
1736                         Info("Samsung MPC-C30 USB webcam detected.\n");
1737                         name = "Samsung MPC-C30";
1738                         type_id = 675;
1739                         break;
1740                 default:
1741                         return -ENODEV;
1742                         break;
1743                 }
1744         }
1745         else if (vendor_id == 0x041e) {
1746                 switch(product_id) {
1747                 case 0x400c:
1748                         Info("Creative Labs Webcam 5 detected.\n");
1749                         name = "Creative Labs Webcam 5";
1750                         type_id = 730;
1751                         break;
1752                 case 0x4011:
1753                         Info("Creative Labs Webcam Pro Ex detected.\n");
1754                         name = "Creative Labs Webcam Pro Ex";
1755                         type_id = 740;
1756                         break;
1757                 default:
1758                         return -ENODEV;
1759                         break;
1760                 }
1761         }
1762         else if (vendor_id == 0x04cc) {
1763                 switch(product_id) {
1764                 case 0x8116:
1765                         Info("Sotec Afina Eye USB webcam detected.\n");
1766                         name = "Sotec Afina Eye";
1767                         type_id = 730;
1768                         break;
1769                 default:
1770                         return -ENODEV;
1771                         break;
1772                 }
1773         }
1774         else if (vendor_id == 0x0d81) {
1775                 switch(product_id) {
1776                 case 0x1900:
1777                         Info("Visionite VCS-UC300 USB webcam detected.\n");
1778                         name = "Visionite VCS-UC300";
1779                         type_id = 740; /* CCD sensor */
1780                         break;
1781                 case 0x1910:
1782                         Info("Visionite VCS-UM100 USB webcam detected.\n");
1783                         name = "Visionite VCS-UM100";
1784                         type_id = 730; /* CMOS sensor */
1785                         break;
1786                 default:
1787                         return -ENODEV;
1788                         break;
1789                 }
1790         }
1791         else
1792                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1793
1794         memset(serial_number, 0, 30);
1795         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1796         Trace(TRACE_PROBE, "Device serial number is %s\n", serial_number);
1797
1798         if (udev->descriptor.bNumConfigurations > 1)
1799                 Info("Warning: more than 1 configuration available.\n");
1800
1801         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1802         pdev = kmalloc(sizeof(struct pwc_device), GFP_KERNEL);
1803         if (pdev == NULL) {
1804                 Err("Oops, could not allocate memory for pwc_device.\n");
1805                 return -ENOMEM;
1806         }
1807         memset(pdev, 0, sizeof(struct pwc_device));
1808         pdev->type = type_id;
1809         pdev->vsize = default_size;
1810         pdev->vframes = default_fps;
1811         pdev->features = features;
1812         if (vendor_id == 0x046D && product_id == 0x08B5)
1813         {
1814                 /* Logitech QuickCam Orbit
1815                    The ranges have been determined experimentally; they may differ from cam to cam.
1816                    Also, the exact ranges left-right and up-down are different for my cam
1817                   */
1818                 pdev->angle_range.pan_min  = -7000;
1819                 pdev->angle_range.pan_max  =  7000;
1820                 pdev->angle_range.tilt_min = -3000;
1821                 pdev->angle_range.tilt_max =  2500;
1822                 pdev->angle_range.zoom_min = -1;
1823                 pdev->angle_range.zoom_max = -1;
1824         }
1825
1826         init_MUTEX(&pdev->modlock);
1827         pdev->ptrlock = SPIN_LOCK_UNLOCKED;
1828
1829         pdev->udev = udev;
1830         init_waitqueue_head(&pdev->frameq);
1831         pdev->vcompression = pwc_preferred_compression;
1832
1833         memcpy(&pdev->vdev, &pwc_template, sizeof(pwc_template));
1834         strcpy(pdev->vdev.name, name);
1835         pdev->vdev.owner = THIS_MODULE;
1836         pdev->vdev.priv = pdev;
1837
1838         pdev->release = udev->descriptor.bcdDevice;
1839         Trace(TRACE_PROBE, "Release: %04x\n", pdev->release);
1840
1841         /* Now search device_hint[] table for a match, so we can hint a node number. */
1842         for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1843                 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1844                      (device_hint[hint].pdev == NULL)) {
1845                         /* so far, so good... try serial number */
1846                         if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1847                                 /* match! */
1848                                 video_nr = device_hint[hint].device_node;
1849                                 Trace(TRACE_PROBE, "Found hint, will try to register as /dev/video%d\n", video_nr);
1850                                 break;
1851                         }
1852                 }
1853         }
1854
1855         pdev->vdev.release = pwc_video_release;
1856         i = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1857         if (i < 0) {
1858                 Err("Failed to register as video device (%d).\n", i);
1859                 kfree(pdev); /* Oops, no memory leaks please */
1860                 return -EIO;
1861         }
1862         else {
1863                 Info("Registered as /dev/video%d.\n", pdev->vdev.minor & 0x3F);
1864         }
1865
1866         /* occupy slot */
1867         if (hint < MAX_DEV_HINTS)
1868                 device_hint[hint].pdev = pdev;
1869
1870         Trace(TRACE_PROBE, "probe() function returning struct at 0x%p.\n", pdev);
1871         usb_set_intfdata (intf, pdev);
1872         return 0;
1873 }
1874
1875 /* The user janked out the cable... */
1876 static void usb_pwc_disconnect(struct usb_interface *intf)
1877 {
1878         struct pwc_device *pdev;
1879         int hint;
1880
1881         lock_kernel();
1882         pdev = usb_get_intfdata (intf);
1883         usb_set_intfdata (intf, NULL);
1884         if (pdev == NULL) {
1885                 Err("pwc_disconnect() Called without private pointer.\n");
1886                 goto disconnect_out;
1887         }
1888         if (pdev->udev == NULL) {
1889                 Err("pwc_disconnect() already called for %p\n", pdev);
1890                 goto disconnect_out;
1891         }
1892         if (pdev->udev != interface_to_usbdev(intf)) {
1893                 Err("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1894                 goto disconnect_out;
1895         }
1896 #ifdef PWC_MAGIC
1897         if (pdev->magic != PWC_MAGIC) {
1898                 Err("pwc_disconnect() Magic number failed. Consult your scrolls and try again.\n");
1899                 goto disconnect_out;
1900         }
1901 #endif
1902
1903         /* We got unplugged; this is signalled by an EPIPE error code */
1904         if (pdev->vopen) {
1905                 Info("Disconnected while webcam is in use!\n");
1906                 pdev->error_status = EPIPE;
1907         }
1908
1909         /* Alert waiting processes */
1910         wake_up_interruptible(&pdev->frameq);
1911         /* Wait until device is closed */
1912         while (pdev->vopen)
1913                 schedule();
1914         /* Device is now closed, so we can safely unregister it */
1915         Trace(TRACE_PROBE, "Unregistering video device in disconnect().\n");
1916         video_unregister_device(&pdev->vdev);
1917
1918         /* Free memory (don't set pdev to 0 just yet) */
1919         kfree(pdev);
1920
1921 disconnect_out:
1922         /* search device_hint[] table if we occupy a slot, by any chance */
1923         for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1924                 if (device_hint[hint].pdev == pdev)
1925                         device_hint[hint].pdev = NULL;
1926
1927         unlock_kernel();
1928 }
1929
1930
1931 /* *grunt* We have to do atoi ourselves :-( */
1932 static int pwc_atoi(const char *s)
1933 {
1934         int k = 0;
1935
1936         k = 0;
1937         while (*s != '\0' && *s >= '0' && *s <= '9') {
1938                 k = 10 * k + (*s - '0');
1939                 s++;
1940         }
1941         return k;
1942 }
1943
1944
1945 /*
1946  * Initialization code & module stuff
1947  */
1948
1949 static char *size = NULL;
1950 static int fps = 0;
1951 static int fbufs = 0;
1952 static int mbufs = 0;
1953 static int trace = -1;
1954 static int compression = -1;
1955 static int leds[2] = { -1, -1 };
1956 static char *dev_hint[MAX_DEV_HINTS] = { };
1957
1958 MODULE_PARM(size, "s");
1959 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1960 MODULE_PARM(fps, "i");
1961 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1962 MODULE_PARM(fbufs, "i");
1963 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1964 MODULE_PARM(mbufs, "i");
1965 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1966 MODULE_PARM(trace, "i");
1967 MODULE_PARM_DESC(trace, "For debugging purposes");
1968 MODULE_PARM(power_save, "i");
1969 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1970 MODULE_PARM(compression, "i");
1971 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1972 MODULE_PARM(leds, "2i");
1973 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1974 MODULE_PARM(dev_hint, "0-20s");
1975 MODULE_PARM_DESC(dev_hint, "Device node hints");
1976
1977 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1978 MODULE_AUTHOR("Nemosoft Unv. <nemosoft@smcc.demon.nl>");
1979 MODULE_LICENSE("GPL");
1980
1981 static int __init usb_pwc_init(void)
1982 {
1983         int i, sz;
1984         char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1985
1986         Info("Philips PCA645/646 + PCVC675/680/690 + PCVC730/740/750 webcam module version " PWC_VERSION " loaded.\n");
1987         Info("Also supports the Askey VC010, various Logitech QuickCams, Samsung MPC-C10 and MPC-C30,\n");
1988         Info("the Creative WebCam 5, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1989
1990         if (fps) {
1991                 if (fps < 4 || fps > 30) {
1992                         Err("Framerate out of bounds (4-30).\n");
1993                         return -EINVAL;
1994                 }
1995                 default_fps = fps;
1996                 Info("Default framerate set to %d.\n", default_fps);
1997         }
1998
1999         if (size) {
2000                 /* string; try matching with array */
2001                 for (sz = 0; sz < PSZ_MAX; sz++) {
2002                         if (!strcmp(sizenames[sz], size)) { /* Found! */
2003                                 default_size = sz;
2004                                 break;
2005                         }
2006                 }
2007                 if (sz == PSZ_MAX) {
2008                         Err("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
2009                         return -EINVAL;
2010                 }
2011                 Info("Default image size set to %s [%dx%d].\n", sizenames[default_size], pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y);
2012         }
2013         if (mbufs) {
2014                 if (mbufs < 1 || mbufs > MAX_IMAGES) {
2015                         Err("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
2016                         return -EINVAL;
2017                 }
2018                 default_mbufs = mbufs;
2019                 Info("Number of image buffers set to %d.\n", default_mbufs);
2020         }
2021         if (fbufs) {
2022                 if (fbufs < 2 || fbufs > MAX_FRAMES) {
2023                         Err("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
2024                         return -EINVAL;
2025                 }
2026                 default_fbufs = fbufs;
2027                 Info("Number of frame buffers set to %d.\n", default_fbufs);
2028         }
2029         if (trace >= 0) {
2030                 Info("Trace options: 0x%04x\n", trace);
2031                 pwc_trace = trace;
2032         }
2033         if (compression >= 0) {
2034                 if (compression > 3) {
2035                         Err("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
2036                         return -EINVAL;
2037                 }
2038                 pwc_preferred_compression = compression;
2039                 Info("Preferred compression set to %d.\n", pwc_preferred_compression);
2040         }
2041         if (power_save)
2042                 Info("Enabling power save on open/close.\n");
2043         if (leds[0] >= 0)
2044                 led_on = leds[0];
2045         if (leds[1] >= 0)
2046                 led_off = leds[1];
2047
2048         /* Big device node whoopla. Basically, it allows you to assign a
2049            device node (/dev/videoX) to a camera, based on its type
2050            & serial number. The format is [type[.serialnumber]:]node.
2051
2052            Any camera that isn't matched by these rules gets the next
2053            available free device node.
2054          */
2055         for (i = 0; i < MAX_DEV_HINTS; i++) {
2056                 char *s, *colon, *dot;
2057
2058                 /* This loop also initializes the array */
2059                 device_hint[i].pdev = NULL;
2060                 s = dev_hint[i];
2061                 if (s != NULL && *s != '\0') {
2062                         device_hint[i].type = -1; /* wildcard */
2063                         strcpy(device_hint[i].serial_number, "*");
2064
2065                         /* parse string: chop at ':' & '/' */
2066                         colon = dot = s;
2067                         while (*colon != '\0' && *colon != ':')
2068                                 colon++;
2069                         while (*dot != '\0' && *dot != '.')
2070                                 dot++;
2071                         /* Few sanity checks */
2072                         if (*dot != '\0' && dot > colon) {
2073                                 Err("Malformed camera hint: the colon must be after the dot.\n");
2074                                 return -EINVAL;
2075                         }
2076
2077                         if (*colon == '\0') {
2078                                 /* No colon */
2079                                 if (*dot != '\0') {
2080                                         Err("Malformed camera hint: no colon + device node given.\n");
2081                                         return -EINVAL;
2082                                 }
2083                                 else {
2084                                         /* No type or serial number specified, just a number. */
2085                                         device_hint[i].device_node = pwc_atoi(s);
2086                                 }
2087                         }
2088                         else {
2089                                 /* There's a colon, so we have at least a type and a device node */
2090                                 device_hint[i].type = pwc_atoi(s);
2091                                 device_hint[i].device_node = pwc_atoi(colon + 1);
2092                                 if (*dot != '\0') {
2093                                         /* There's a serial number as well */
2094                                         int k;
2095
2096                                         dot++;
2097                                         k = 0;
2098                                         while (*dot != ':' && k < 29) {
2099                                                 device_hint[i].serial_number[k++] = *dot;
2100                                                 dot++;
2101                                         }
2102                                         device_hint[i].serial_number[k] = '\0';
2103                                 }
2104                         }
2105 #if PWC_DEBUG
2106                         Debug("device_hint[%d]:\n", i);
2107                         Debug("  type    : %d\n", device_hint[i].type);
2108                         Debug("  serial# : %s\n", device_hint[i].serial_number);
2109                         Debug("  node    : %d\n", device_hint[i].device_node);
2110 #endif
2111                 }
2112                 else
2113                         device_hint[i].type = 0; /* not filled */
2114         } /* ..for MAX_DEV_HINTS */
2115
2116         Trace(TRACE_PROBE, "Registering driver at address 0x%p.\n", &pwc_driver);
2117         return usb_register(&pwc_driver);
2118 }
2119
2120 static void __exit usb_pwc_exit(void)
2121 {
2122         Trace(TRACE_MODULE, "Deregistering driver.\n");
2123         usb_deregister(&pwc_driver);
2124         Info("Philips webcam module removed.\n");
2125 }
2126
2127 module_init(usb_pwc_init);
2128 module_exit(usb_pwc_exit);
2129