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

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