drivers/media/video/pwc/pwc-if.c

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