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

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