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