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 void pwc_isoc_cleanup(struct pwc_device *pdev)
 911 {
 912         int i;
 913
 914         PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
 915         if (pdev == NULL)
 916                 return;
 917         if (pdev->iso_init == 0)
 918                 return;
 919
 920         /* Unlinking ISOC buffers one by one */
 921         for (i = 0; i < MAX_ISO_BUFS; i++) {
 922                 struct urb *urb;
 923
 924                 urb = pdev->sbuf[i].urb;
 925                 if (urb != 0) {
 926                         if (pdev->iso_init) {
 927                                 PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb);
 928                                 usb_kill_urb(urb);
 929                         }
 930                         PWC_DEBUG_MEMORY("Freeing URB\n");
 931                         usb_free_urb(urb);
 932                         pdev->sbuf[i].urb = NULL;
 933                 }
 934         }
 935
 936         /* Stop camera, but only if we are sure the camera is still there (unplug
 937            is signalled by EPIPE)
 938          */
 939         if (pdev->error_status && pdev->error_status != EPIPE) {
 940                 PWC_DEBUG_OPEN("Setting alternate interface 0.\n");
 941                 usb_set_interface(pdev->udev, 0, 0);
 942         }
 943
 944         pdev->iso_init = 0;
 945         PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
 946 }
 947
 948 int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot)
 949 {
 950         int ret, start;
 951
 952         /* Stop isoc stuff */
 953         pwc_isoc_cleanup(pdev);
 954         /* Reset parameters */
 955         pwc_reset_buffers(pdev);
 956         /* Try to set video mode... */
 957         start = ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot);
 958         if (ret) {
 959                 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 1 failed.\n");
 960                 /* That failed... restore old mode (we know that worked) */
 961                 start = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
 962                 if (start) {
 963                         PWC_DEBUG_FLOW("pwc_set_video_mode attempt 2 failed.\n");
 964                 }
 965         }
 966         if (start == 0)
 967         {
 968                 if (pwc_isoc_init(pdev) < 0)
 969                 {
 970                         PWC_WARNING("Failed to restart ISOC transfers in pwc_try_video_mode.\n");
 971                         ret = -EAGAIN; /* let's try again, who knows if it works a second time */
 972                 }
 973         }
 974         pdev->drop_frames++; /* try to avoid garbage during switch */
 975         return ret; /* Return original error code */
 976 }
 977
 978 /*********
 979  * sysfs
 980  *********/
 981 static struct pwc_device *cd_to_pwc(struct class_device *cd)
 982 {
 983         struct video_device *vdev = to_video_device(cd);
 984         return video_get_drvdata(vdev);
 985 }
 986
 987 static ssize_t show_pan_tilt(struct class_device *class_dev, char *buf)
 988 {
 989         struct pwc_device *pdev = cd_to_pwc(class_dev);
 990         return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
 991 }
 992
 993 static ssize_t store_pan_tilt(struct class_device *class_dev, const char *buf,
 994                          size_t count)
 995 {
 996         struct pwc_device *pdev = cd_to_pwc(class_dev);
 997         int pan, tilt;
 998         int ret = -EINVAL;
 999
1000         if (strncmp(buf, "reset", 5) == 0)
1001                 ret = pwc_mpt_reset(pdev, 0x3);
1002
1003         else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
1004                 ret = pwc_mpt_set_angle(pdev, pan, tilt);
1005
1006         if (ret < 0)
1007                 return ret;
1008         return strlen(buf);
1009 }
1010 static CLASS_DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
1011                          store_pan_tilt);
1012
1013 static ssize_t show_snapshot_button_status(struct class_device *class_dev, char *buf)
1014 {
1015         struct pwc_device *pdev = cd_to_pwc(class_dev);
1016         int status = pdev->snapshot_button_status;
1017         pdev->snapshot_button_status = 0;
1018         return sprintf(buf, "%d\n", status);
1019 }
1020
1021 static CLASS_DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
1022                          NULL);
1023
1024 static int pwc_create_sysfs_files(struct video_device *vdev)
1025 {
1026         struct pwc_device *pdev = video_get_drvdata(vdev);
1027         int rc;
1028
1029         rc = video_device_create_file(vdev, &class_device_attr_button);
1030         if (rc)
1031                 goto err;
1032         if (pdev->features & FEATURE_MOTOR_PANTILT) {
1033                 rc = video_device_create_file(vdev,&class_device_attr_pan_tilt);
1034                 if (rc) goto err_button;
1035         }
1036
1037         return 0;
1038
1039 err_button:
1040         video_device_remove_file(vdev, &class_device_attr_button);
1041 err:
1042         return rc;
1043 }
1044
1045 static void pwc_remove_sysfs_files(struct video_device *vdev)
1046 {
1047         struct pwc_device *pdev = video_get_drvdata(vdev);
1048         if (pdev->features & FEATURE_MOTOR_PANTILT)
1049                 video_device_remove_file(vdev, &class_device_attr_pan_tilt);
1050         video_device_remove_file(vdev, &class_device_attr_button);
1051 }
1052
1053 #ifdef CONFIG_USB_PWC_DEBUG
1054 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
1055 {
1056         switch(sensor_type) {
1057                 case 0x00:
1058                         return "Hyundai CMOS sensor";
1059                 case 0x20:
1060                         return "Sony CCD sensor + TDA8787";
1061                 case 0x2E:
1062                         return "Sony CCD sensor + Exas 98L59";
1063                 case 0x2F:
1064                         return "Sony CCD sensor + ADI 9804";
1065                 case 0x30:
1066                         return "Sharp CCD sensor + TDA8787";
1067                 case 0x3E:
1068                         return "Sharp CCD sensor + Exas 98L59";
1069                 case 0x3F:
1070                         return "Sharp CCD sensor + ADI 9804";
1071                 case 0x40:
1072                         return "UPA 1021 sensor";
1073                 case 0x100:
1074                         return "VGA sensor";
1075                 case 0x101:
1076                         return "PAL MR sensor";
1077                 default:
1078                         return "unknown type of sensor";
1079         }
1080 }
1081 #endif
1082
1083 /***************************************************************************/
1084 /* Video4Linux functions */
1085
1086 static int pwc_video_open(struct inode *inode, struct file *file)
1087 {
1088         int i, ret;
1089         struct video_device *vdev = video_devdata(file);
1090         struct pwc_device *pdev;
1091
1092         PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
1093
1094         pdev = (struct pwc_device *)vdev->priv;
1095         BUG_ON(!pdev);
1096         if (pdev->vopen) {
1097                 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1098                 return -EBUSY;
1099         }
1100
1101         mutex_lock(&pdev->modlock);
1102         if (!pdev->usb_init) {
1103                 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1104                 pdev->usb_init = 1;
1105
1106                 /* Query sensor type */
1107                 ret = pwc_get_cmos_sensor(pdev, &i);
1108                 if (ret >= 0)
1109                 {
1110                         PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1111                                         pdev->vdev->name,
1112                                         pwc_sensor_type_to_string(i), i);
1113                 }
1114         }
1115
1116         /* Turn on camera */
1117         if (power_save) {
1118                 i = pwc_camera_power(pdev, 1);
1119                 if (i < 0)
1120                         PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
1121         }
1122         /* Set LED on/off time */
1123         if (pwc_set_leds(pdev, led_on, led_off) < 0)
1124                 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1125
1126         pwc_construct(pdev); /* set min/max sizes correct */
1127
1128         /* So far, so good. Allocate memory. */
1129         i = pwc_allocate_buffers(pdev);
1130         if (i < 0) {
1131                 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1132                 pwc_free_buffers(pdev);
1133                 mutex_unlock(&pdev->modlock);
1134                 return i;
1135         }
1136
1137         /* Reset buffers & parameters */
1138         pwc_reset_buffers(pdev);
1139         for (i = 0; i < pwc_mbufs; i++)
1140                 pdev->image_used[i] = 0;
1141         pdev->vframe_count = 0;
1142         pdev->vframes_dumped = 0;
1143         pdev->vframes_error = 0;
1144         pdev->visoc_errors = 0;
1145         pdev->error_status = 0;
1146         pwc_construct(pdev); /* set min/max sizes correct */
1147
1148         /* Set some defaults */
1149         pdev->vsnapshot = 0;
1150
1151         /* Start iso pipe for video; first try the last used video size
1152            (or the default one); if that fails try QCIF/10 or QSIF/10;
1153            it that fails too, give up.
1154          */
1155         i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1156         if (i)  {
1157                 unsigned int default_resolution;
1158                 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1159                 if (pdev->type>= 730)
1160                         default_resolution = PSZ_QSIF;
1161                 else
1162                         default_resolution = PSZ_QCIF;
1163
1164                 i = pwc_set_video_mode(pdev,
1165                                        pwc_image_sizes[default_resolution].x,
1166                                        pwc_image_sizes[default_resolution].y,
1167                                        10,
1168                                        pdev->vcompression,
1169                                        0);
1170         }
1171         if (i) {
1172                 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1173                 pwc_free_buffers(pdev);
1174                 mutex_unlock(&pdev->modlock);
1175                 return i;
1176         }
1177
1178         i = pwc_isoc_init(pdev);
1179         if (i) {
1180                 PWC_DEBUG_OPEN("Failed to init ISOC stuff = %d.\n", i);
1181                 pwc_isoc_cleanup(pdev);
1182                 pwc_free_buffers(pdev);
1183                 mutex_unlock(&pdev->modlock);
1184                 return i;
1185         }
1186
1187         /* Initialize the webcam to sane value */
1188         pwc_set_brightness(pdev, 0x7fff);
1189         pwc_set_agc(pdev, 1, 0);
1190
1191         pdev->vopen++;
1192         file->private_data = vdev;
1193         mutex_unlock(&pdev->modlock);
1194         PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1195         return 0;
1196 }
1197
1198
1199 static void pwc_cleanup(struct pwc_device *pdev)
1200 {
1201         pwc_remove_sysfs_files(pdev->vdev);
1202         video_unregister_device(pdev->vdev);
1203 }
1204
1205 /* Note that all cleanup is done in the reverse order as in _open */
1206 static int pwc_video_close(struct inode *inode, struct file *file)
1207 {
1208         struct video_device *vdev = file->private_data;
1209         struct pwc_device *pdev;
1210         int i, hint;
1211
1212         PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
1213
1214         pdev = (struct pwc_device *)vdev->priv;
1215         if (pdev->vopen == 0)
1216                 PWC_DEBUG_MODULE("video_close() called on closed device?\n");
1217
1218         /* Dump statistics, but only if a reasonable amount of frames were
1219            processed (to prevent endless log-entries in case of snap-shot
1220            programs)
1221          */
1222         if (pdev->vframe_count > 20)
1223                 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);
1224
1225         if (DEVICE_USE_CODEC1(pdev->type))
1226             pwc_dec1_exit();
1227         else
1228             pwc_dec23_exit();
1229
1230         pwc_isoc_cleanup(pdev);
1231         pwc_free_buffers(pdev);
1232
1233         lock_kernel();
1234         /* Turn off LEDS and power down camera, but only when not unplugged */
1235         if (!pdev->unplugged) {
1236                 /* Turn LEDs off */
1237                 if (pwc_set_leds(pdev, 0, 0) < 0)
1238                         PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
1239                 if (power_save) {
1240                         i = pwc_camera_power(pdev, 0);
1241                         if (i < 0)
1242                                 PWC_ERROR("Failed to power down camera (%d)\n", i);
1243                 }
1244                 pdev->vopen--;
1245                 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
1246         } else {
1247                 pwc_cleanup(pdev);
1248                 /* Free memory (don't set pdev to 0 just yet) */
1249                 kfree(pdev);
1250                 /* search device_hint[] table if we occupy a slot, by any chance */
1251                 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1252                         if (device_hint[hint].pdev == pdev)
1253                                 device_hint[hint].pdev = NULL;
1254         }
1255         unlock_kernel();
1256
1257         return 0;
1258 }
1259
1260 /*
1261  *      FIXME: what about two parallel reads ????
1262  *      ANSWER: Not supported. You can't open the device more than once,
1263                 despite what the V4L1 interface says. First, I don't see
1264                 the need, second there's no mechanism of alerting the
1265                 2nd/3rd/... process of events like changing image size.
1266                 And I don't see the point of blocking that for the
1267                 2nd/3rd/... process.
1268                 In multi-threaded environments reading parallel from any
1269                 device is tricky anyhow.
1270  */
1271
1272 static ssize_t pwc_video_read(struct file *file, char __user *buf,
1273                           size_t count, loff_t *ppos)
1274 {
1275         struct video_device *vdev = file->private_data;
1276         struct pwc_device *pdev;
1277         int noblock = file->f_flags & O_NONBLOCK;
1278         DECLARE_WAITQUEUE(wait, current);
1279         int bytes_to_read;
1280         void *image_buffer_addr;
1281
1282         PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1283                         vdev, buf, count);
1284         if (vdev == NULL)
1285                 return -EFAULT;
1286         pdev = vdev->priv;
1287         if (pdev == NULL)
1288                 return -EFAULT;
1289         if (pdev->error_status)
1290                 return -pdev->error_status; /* Something happened, report what. */
1291
1292         /* In case we're doing partial reads, we don't have to wait for a frame */
1293         if (pdev->image_read_pos == 0) {
1294                 /* Do wait queueing according to the (doc)book */
1295                 add_wait_queue(&pdev->frameq, &wait);
1296                 while (pdev->full_frames == NULL) {
1297                         /* Check for unplugged/etc. here */
1298                         if (pdev->error_status) {
1299                                 remove_wait_queue(&pdev->frameq, &wait);
1300                                 set_current_state(TASK_RUNNING);
1301                                 return -pdev->error_status ;
1302                         }
1303                         if (noblock) {
1304                                 remove_wait_queue(&pdev->frameq, &wait);
1305                                 set_current_state(TASK_RUNNING);
1306                                 return -EWOULDBLOCK;
1307                         }
1308                         if (signal_pending(current)) {
1309                                 remove_wait_queue(&pdev->frameq, &wait);
1310                                 set_current_state(TASK_RUNNING);
1311                                 return -ERESTARTSYS;
1312                         }
1313                         schedule();
1314                         set_current_state(TASK_INTERRUPTIBLE);
1315                 }
1316                 remove_wait_queue(&pdev->frameq, &wait);
1317                 set_current_state(TASK_RUNNING);
1318
1319                 /* Decompress and release frame */
1320                 if (pwc_handle_frame(pdev))
1321                         return -EFAULT;
1322         }
1323
1324         PWC_DEBUG_READ("Copying data to user space.\n");
1325         if (pdev->vpalette == VIDEO_PALETTE_RAW)
1326                 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1327         else
1328                 bytes_to_read = pdev->view.size;
1329
1330         /* copy bytes to user space; we allow for partial reads */
1331         if (count + pdev->image_read_pos > bytes_to_read)
1332                 count = bytes_to_read - pdev->image_read_pos;
1333         image_buffer_addr = pdev->image_data;
1334         image_buffer_addr += pdev->images[pdev->fill_image].offset;
1335         image_buffer_addr += pdev->image_read_pos;
1336         if (copy_to_user(buf, image_buffer_addr, count))
1337                 return -EFAULT;
1338         pdev->image_read_pos += count;
1339         if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
1340                 pdev->image_read_pos = 0;
1341                 pwc_next_image(pdev);
1342         }
1343         return count;
1344 }
1345
1346 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1347 {
1348         struct video_device *vdev = file->private_data;
1349         struct pwc_device *pdev;
1350
1351         if (vdev == NULL)
1352                 return -EFAULT;
1353         pdev = vdev->priv;
1354         if (pdev == NULL)
1355                 return -EFAULT;
1356
1357         poll_wait(file, &pdev->frameq, wait);
1358         if (pdev->error_status)
1359                 return POLLERR;
1360         if (pdev->full_frames != NULL) /* we have frames waiting */
1361                 return (POLLIN | POLLRDNORM);
1362
1363         return 0;
1364 }
1365
1366 static int pwc_video_ioctl(struct inode *inode, struct file *file,
1367                            unsigned int cmd, unsigned long arg)
1368 {
1369         return video_usercopy(inode, file, cmd, arg, pwc_video_do_ioctl);
1370 }
1371
1372 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1373 {
1374         struct video_device *vdev = file->private_data;
1375         struct pwc_device *pdev;
1376         unsigned long start;
1377         unsigned long size;
1378         unsigned long page, pos = 0;
1379         int index;
1380
1381         PWC_DEBUG_MEMORY(">> %s\n", __FUNCTION__);
1382         pdev = vdev->priv;
1383         size = vma->vm_end - vma->vm_start;
1384         start = vma->vm_start;
1385
1386         /* Find the idx buffer for this mapping */
1387         for (index = 0; index < pwc_mbufs; index++) {
1388                 pos = pdev->images[index].offset;
1389                 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1390                         break;
1391         }
1392         if (index == MAX_IMAGES)
1393                 return -EINVAL;
1394         if (index == 0) {
1395                 /*
1396                  * Special case for v4l1. In v4l1, we map only one big buffer,
1397                  * but in v4l2 each buffer is mapped
1398                  */
1399                 unsigned long total_size;
1400                 total_size = pwc_mbufs * pdev->len_per_image;
1401                 if (size != pdev->len_per_image && size != total_size) {
1402                         PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1403                                    size, pdev->len_per_image, total_size);
1404                         return -EINVAL;
1405                 }
1406         } else if (size > pdev->len_per_image)
1407                 return -EINVAL;
1408
1409         vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
1410
1411         pos += (unsigned long)pdev->image_data;
1412         while (size > 0) {
1413                 page = vmalloc_to_pfn((void *)pos);
1414                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1415                         return -EAGAIN;
1416                 start += PAGE_SIZE;
1417                 pos += PAGE_SIZE;
1418                 if (size > PAGE_SIZE)
1419                         size -= PAGE_SIZE;
1420                 else
1421                         size = 0;
1422         }
1423         return 0;
1424 }
1425
1426 /***************************************************************************/
1427 /* USB functions */
1428
1429 /* This function gets called when a new device is plugged in or the usb core
1430  * is loaded.
1431  */
1432
1433 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1434 {
1435         struct usb_device *udev = interface_to_usbdev(intf);
1436         struct pwc_device *pdev = NULL;
1437         int vendor_id, product_id, type_id;
1438         int i, hint, rc;
1439         int features = 0;
1440         int video_nr = -1; /* default: use next available device */
1441         char serial_number[30], *name;
1442
1443         vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1444         product_id = le16_to_cpu(udev->descriptor.idProduct);
1445
1446         /* Check if we can handle this device */
1447         PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1448                 vendor_id, product_id,
1449                 intf->altsetting->desc.bInterfaceNumber);
1450
1451         /* the interfaces are probed one by one. We are only interested in the
1452            video interface (0) now.
1453            Interface 1 is the Audio Control, and interface 2 Audio itself.
1454          */
1455         if (intf->altsetting->desc.bInterfaceNumber > 0)
1456                 return -ENODEV;
1457
1458         if (vendor_id == 0x0471) {
1459                 switch (product_id) {
1460                 case 0x0302:
1461                         PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1462                         name = "Philips 645 webcam";
1463                         type_id = 645;
1464                         break;
1465                 case 0x0303:
1466                         PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1467                         name = "Philips 646 webcam";
1468                         type_id = 646;
1469                         break;
1470                 case 0x0304:
1471                         PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1472                         name = "Askey VC010 webcam";
1473                         type_id = 646;
1474                         break;
1475                 case 0x0307:
1476                         PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1477                         name = "Philips 675 webcam";
1478                         type_id = 675;
1479                         break;
1480                 case 0x0308:
1481                         PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1482                         name = "Philips 680 webcam";
1483                         type_id = 680;
1484                         break;
1485                 case 0x030C:
1486                         PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1487                         name = "Philips 690 webcam";
1488                         type_id = 690;
1489                         break;
1490                 case 0x0310:
1491                         PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1492                         name = "Philips 730 webcam";
1493                         type_id = 730;
1494                         break;
1495                 case 0x0311:
1496                         PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1497                         name = "Philips 740 webcam";
1498                         type_id = 740;
1499                         break;
1500                 case 0x0312:
1501                         PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1502                         name = "Philips 750 webcam";
1503                         type_id = 750;
1504                         break;
1505                 case 0x0313:
1506                         PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1507                         name = "Philips 720K/40 webcam";
1508                         type_id = 720;
1509                         break;
1510                 case 0x0329:
1511                         PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1512                         name = "Philips SPC 900NC webcam";
1513                         type_id = 740;
1514                         break;
1515                 default:
1516                         return -ENODEV;
1517                         break;
1518                 }
1519         }
1520         else if (vendor_id == 0x069A) {
1521                 switch(product_id) {
1522                 case 0x0001:
1523                         PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1524                         name = "Askey VC010 webcam";
1525                         type_id = 645;
1526                         break;
1527                 default:
1528                         return -ENODEV;
1529                         break;
1530                 }
1531         }
1532         else if (vendor_id == 0x046d) {
1533                 switch(product_id) {
1534                 case 0x08b0:
1535                         PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1536                         name = "Logitech QuickCam Pro 3000";
1537                         type_id = 740; /* CCD sensor */
1538                         break;
1539                 case 0x08b1:
1540                         PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1541                         name = "Logitech QuickCam Notebook Pro";
1542                         type_id = 740; /* CCD sensor */
1543                         break;
1544                 case 0x08b2:
1545                         PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1546                         name = "Logitech QuickCam Pro 4000";
1547                         type_id = 740; /* CCD sensor */
1548                         break;
1549                 case 0x08b3:
1550                         PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1551                         name = "Logitech QuickCam Zoom";
1552                         type_id = 740; /* CCD sensor */
1553                         break;
1554                 case 0x08B4:
1555                         PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1556                         name = "Logitech QuickCam Zoom";
1557                         type_id = 740; /* CCD sensor */
1558                         power_save = 1;
1559                         break;
1560                 case 0x08b5:
1561                         PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1562                         name = "Logitech QuickCam Orbit";
1563                         type_id = 740; /* CCD sensor */
1564                         features |= FEATURE_MOTOR_PANTILT;
1565                         break;
1566                 case 0x08b6:
1567                         PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1568                         name = "Cisco VT Camera";
1569                         type_id = 740; /* CCD sensor */
1570                         break;
1571                 case 0x08b7:
1572                         PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1573                         name = "Logitech ViewPort AV 100";
1574                         type_id = 740; /* CCD sensor */
1575                         break;
1576                 case 0x08b8: /* Where this released? */
1577                         PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1578                         name = "Logitech QuickCam (res.)";
1579                         type_id = 730; /* Assuming CMOS */
1580                         break;
1581                 default:
1582                         return -ENODEV;
1583                         break;
1584                 }
1585         }
1586         else if (vendor_id == 0x055d) {
1587                 /* I don't know the difference between the C10 and the C30;
1588                    I suppose the difference is the sensor, but both cameras
1589                    work equally well with a type_id of 675
1590                  */
1591                 switch(product_id) {
1592                 case 0x9000:
1593                         PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1594                         name = "Samsung MPC-C10";
1595                         type_id = 675;
1596                         break;
1597                 case 0x9001:
1598                         PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1599                         name = "Samsung MPC-C30";
1600                         type_id = 675;
1601                         break;
1602                 case 0x9002:
1603                         PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1604                         name = "Samsung MPC-C30";
1605                         type_id = 740;
1606                         break;
1607                 default:
1608                         return -ENODEV;
1609                         break;
1610                 }
1611         }
1612         else if (vendor_id == 0x041e) {
1613                 switch(product_id) {
1614                 case 0x400c:
1615                         PWC_INFO("Creative Labs Webcam 5 detected.\n");
1616                         name = "Creative Labs Webcam 5";
1617                         type_id = 730;
1618                         break;
1619                 case 0x4011:
1620                         PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1621                         name = "Creative Labs Webcam Pro Ex";
1622                         type_id = 740;
1623                         break;
1624                 default:
1625                         return -ENODEV;
1626                         break;
1627                 }
1628         }
1629         else if (vendor_id == 0x04cc) {
1630                 switch(product_id) {
1631                 case 0x8116:
1632                         PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1633                         name = "Sotec Afina Eye";
1634                         type_id = 730;
1635                         break;
1636                 default:
1637                         return -ENODEV;
1638                         break;
1639                 }
1640         }
1641         else if (vendor_id == 0x06be) {
1642                 switch(product_id) {
1643                 case 0x8116:
1644                         /* This is essentially the same cam as the Sotec Afina Eye */
1645                         PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1646                         name = "AME Co. Afina Eye";
1647                         type_id = 750;
1648                         break;
1649                 default:
1650                         return -ENODEV;
1651                         break;
1652                 }
1653
1654         }
1655         else if (vendor_id == 0x0d81) {
1656                 switch(product_id) {
1657                 case 0x1900:
1658                         PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1659                         name = "Visionite VCS-UC300";
1660                         type_id = 740; /* CCD sensor */
1661                         break;
1662                 case 0x1910:
1663                         PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1664                         name = "Visionite VCS-UM100";
1665                         type_id = 730; /* CMOS sensor */
1666                         break;
1667                 default:
1668                         return -ENODEV;
1669                         break;
1670                 }
1671         }
1672         else
1673                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1674
1675         memset(serial_number, 0, 30);
1676         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1677         PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1678
1679         if (udev->descriptor.bNumConfigurations > 1)
1680                 PWC_WARNING("Warning: more than 1 configuration available.\n");
1681
1682         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1683         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1684         if (pdev == NULL) {
1685                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1686                 return -ENOMEM;
1687         }
1688         pdev->type = type_id;
1689         pdev->vsize = default_size;
1690         pdev->vframes = default_fps;
1691         strcpy(pdev->serial, serial_number);
1692         pdev->features = features;
1693         if (vendor_id == 0x046D && product_id == 0x08B5)
1694         {
1695                 /* Logitech QuickCam Orbit
1696                    The ranges have been determined experimentally; they may differ from cam to cam.
1697                    Also, the exact ranges left-right and up-down are different for my cam
1698                   */
1699                 pdev->angle_range.pan_min  = -7000;
1700                 pdev->angle_range.pan_max  =  7000;
1701                 pdev->angle_range.tilt_min = -3000;
1702                 pdev->angle_range.tilt_max =  2500;
1703         }
1704
1705         mutex_init(&pdev->modlock);
1706         spin_lock_init(&pdev->ptrlock);
1707
1708         pdev->udev = udev;
1709         init_waitqueue_head(&pdev->frameq);
1710         pdev->vcompression = pwc_preferred_compression;
1711
1712         /* Allocate video_device structure */
1713         pdev->vdev = video_device_alloc();
1714         if (pdev->vdev == 0)
1715         {
1716                 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
1717                 kfree(pdev);
1718                 return -ENOMEM;
1719         }
1720         memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
1721         pdev->vdev->dev = &(udev->dev);
1722         strcpy(pdev->vdev->name, name);
1723         pdev->vdev->owner = THIS_MODULE;
1724         video_set_drvdata(pdev->vdev, pdev);
1725
1726         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1727         PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1728
1729         /* Now search device_hint[] table for a match, so we can hint a node number. */
1730         for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1731                 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1732                      (device_hint[hint].pdev == NULL)) {
1733                         /* so far, so good... try serial number */
1734                         if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1735                                 /* match! */
1736                                 video_nr = device_hint[hint].device_node;
1737                                 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1738                                 break;
1739                         }
1740                 }
1741         }
1742
1743         pdev->vdev->release = video_device_release;
1744         i = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1745         if (i < 0) {
1746                 PWC_ERROR("Failed to register as video device (%d).\n", i);
1747                 rc = i;
1748                 goto err;
1749         }
1750         else {
1751                 PWC_INFO("Registered as /dev/video%d.\n", pdev->vdev->minor & 0x3F);
1752         }
1753
1754         /* occupy slot */
1755         if (hint < MAX_DEV_HINTS)
1756                 device_hint[hint].pdev = pdev;
1757
1758         PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1759         usb_set_intfdata (intf, pdev);
1760         rc = pwc_create_sysfs_files(pdev->vdev);
1761         if (rc)
1762                 goto err_unreg;
1763
1764         /* Set the leds off */
1765         pwc_set_leds(pdev, 0, 0);
1766         pwc_camera_power(pdev, 0);
1767
1768         return 0;
1769
1770 err_unreg:
1771         if (hint < MAX_DEV_HINTS)
1772                 device_hint[hint].pdev = NULL;
1773         video_unregister_device(pdev->vdev);
1774 err:
1775         video_device_release(pdev->vdev); /* Drip... drip... drip... */
1776         kfree(pdev); /* Oops, no memory leaks please */
1777         return rc;
1778 }
1779
1780 /* The user janked out the cable... */
1781 static void usb_pwc_disconnect(struct usb_interface *intf)
1782 {
1783         struct pwc_device *pdev;
1784         int hint;
1785
1786         lock_kernel();
1787         pdev = usb_get_intfdata (intf);
1788         usb_set_intfdata (intf, NULL);
1789         if (pdev == NULL) {
1790                 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1791                 goto disconnect_out;
1792         }
1793         if (pdev->udev == NULL) {
1794                 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1795                 goto disconnect_out;
1796         }
1797         if (pdev->udev != interface_to_usbdev(intf)) {
1798                 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1799                 goto disconnect_out;
1800         }
1801
1802         /* We got unplugged; this is signalled by an EPIPE error code */
1803         if (pdev->vopen) {
1804                 PWC_INFO("Disconnected while webcam is in use!\n");
1805                 pdev->error_status = EPIPE;
1806         }
1807
1808         /* Alert waiting processes */
1809         wake_up_interruptible(&pdev->frameq);
1810         /* Wait until device is closed */
1811         if(pdev->vopen) {
1812                 pdev->unplugged = 1;
1813         } else {
1814                 /* Device is closed, so we can safely unregister it */
1815                 PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
1816                 pwc_cleanup(pdev);
1817                 /* Free memory (don't set pdev to 0 just yet) */
1818                 kfree(pdev);
1819
1820 disconnect_out:
1821                 /* search device_hint[] table if we occupy a slot, by any chance */
1822                 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1823                         if (device_hint[hint].pdev == pdev)
1824                                 device_hint[hint].pdev = NULL;
1825         }
1826
1827         unlock_kernel();
1828 }
1829
1830
1831 /* *grunt* We have to do atoi ourselves :-( */
1832 static int pwc_atoi(const char *s)
1833 {
1834         int k = 0;
1835
1836         k = 0;
1837         while (*s != '\0' && *s >= '0' && *s <= '9') {
1838                 k = 10 * k + (*s - '0');
1839                 s++;
1840         }
1841         return k;
1842 }
1843
1844
1845 /*
1846  * Initialization code & module stuff
1847  */
1848
1849 static char *size;
1850 static int fps;
1851 static int fbufs;
1852 static int mbufs;
1853 static int compression = -1;
1854 static int leds[2] = { -1, -1 };
1855 static int leds_nargs;
1856 static char *dev_hint[MAX_DEV_HINTS];
1857 static int dev_hint_nargs;
1858
1859 module_param(size, charp, 0444);
1860 module_param(fps, int, 0444);
1861 module_param(fbufs, int, 0444);
1862 module_param(mbufs, int, 0444);
1863 #ifdef CONFIG_USB_PWC_DEBUG
1864 module_param_named(trace, pwc_trace, int, 0644);
1865 #endif
1866 module_param(power_save, int, 0444);
1867 module_param(compression, int, 0444);
1868 module_param_array(leds, int, &leds_nargs, 0444);
1869 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1870
1871 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1872 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1873 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1874 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1875 MODULE_PARM_DESC(trace, "For debugging purposes");
1876 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1877 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1878 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1879 MODULE_PARM_DESC(dev_hint, "Device node hints");
1880
1881 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1882 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1883 MODULE_LICENSE("GPL");
1884 MODULE_ALIAS("pwcx");
1885 MODULE_VERSION( PWC_VERSION );
1886
1887 static int __init usb_pwc_init(void)
1888 {
1889         int i, sz;
1890         char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1891
1892         PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1893         PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1894         PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1895         PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1896
1897         if (fps) {
1898                 if (fps < 4 || fps > 30) {
1899                         PWC_ERROR("Framerate out of bounds (4-30).\n");
1900                         return -EINVAL;
1901                 }
1902                 default_fps = fps;
1903                 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1904         }
1905
1906         if (size) {
1907                 /* string; try matching with array */
1908                 for (sz = 0; sz < PSZ_MAX; sz++) {
1909                         if (!strcmp(sizenames[sz], size)) { /* Found! */
1910                                 default_size = sz;
1911                                 break;
1912                         }
1913                 }
1914                 if (sz == PSZ_MAX) {
1915                         PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1916                         return -EINVAL;
1917                 }
1918                 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);
1919         }
1920         if (mbufs) {
1921                 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1922                         PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
1923                         return -EINVAL;
1924                 }
1925                 pwc_mbufs = mbufs;
1926                 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
1927         }
1928         if (fbufs) {
1929                 if (fbufs < 2 || fbufs > MAX_FRAMES) {
1930                         PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
1931                         return -EINVAL;
1932                 }
1933                 default_fbufs = fbufs;
1934                 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
1935         }
1936 #ifdef CONFIG_USB_PWC_DEBUG
1937         if (pwc_trace >= 0) {
1938                 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1939         }
1940 #endif
1941         if (compression >= 0) {
1942                 if (compression > 3) {
1943                         PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1944                         return -EINVAL;
1945                 }
1946                 pwc_preferred_compression = compression;
1947                 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
1948         }
1949         if (power_save)
1950                 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
1951         if (leds[0] >= 0)
1952                 led_on = leds[0];
1953         if (leds[1] >= 0)
1954                 led_off = leds[1];
1955
1956         /* Big device node whoopla. Basically, it allows you to assign a
1957            device node (/dev/videoX) to a camera, based on its type
1958            & serial number. The format is [type[.serialnumber]:]node.
1959
1960            Any camera that isn't matched by these rules gets the next
1961            available free device node.
1962          */
1963         for (i = 0; i < MAX_DEV_HINTS; i++) {
1964                 char *s, *colon, *dot;
1965
1966                 /* This loop also initializes the array */
1967                 device_hint[i].pdev = NULL;
1968                 s = dev_hint[i];
1969                 if (s != NULL && *s != '\0') {
1970                         device_hint[i].type = -1; /* wildcard */
1971                         strcpy(device_hint[i].serial_number, "*");
1972
1973                         /* parse string: chop at ':' & '/' */
1974                         colon = dot = s;
1975                         while (*colon != '\0' && *colon != ':')
1976                                 colon++;
1977                         while (*dot != '\0' && *dot != '.')
1978                                 dot++;
1979                         /* Few sanity checks */
1980                         if (*dot != '\0' && dot > colon) {
1981                                 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
1982                                 return -EINVAL;
1983                         }
1984
1985                         if (*colon == '\0') {
1986                                 /* No colon */
1987                                 if (*dot != '\0') {
1988                                         PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
1989                                         return -EINVAL;
1990                                 }
1991                                 else {
1992                                         /* No type or serial number specified, just a number. */
1993                                         device_hint[i].device_node = pwc_atoi(s);
1994                                 }
1995                         }
1996                         else {
1997                                 /* There's a colon, so we have at least a type and a device node */
1998                                 device_hint[i].type = pwc_atoi(s);
1999                                 device_hint[i].device_node = pwc_atoi(colon + 1);
2000                                 if (*dot != '\0') {
2001                                         /* There's a serial number as well */
2002                                         int k;
2003
2004                                         dot++;
2005                                         k = 0;
2006                                         while (*dot != ':' && k < 29) {
2007                                                 device_hint[i].serial_number[k++] = *dot;
2008                                                 dot++;
2009                                         }
2010                                         device_hint[i].serial_number[k] = '\0';
2011                                 }
2012                         }
2013                         PWC_TRACE("device_hint[%d]:\n", i);
2014                         PWC_TRACE("  type    : %d\n", device_hint[i].type);
2015                         PWC_TRACE("  serial# : %s\n", device_hint[i].serial_number);
2016                         PWC_TRACE("  node    : %d\n", device_hint[i].device_node);
2017                 }
2018                 else
2019                         device_hint[i].type = 0; /* not filled */
2020         } /* ..for MAX_DEV_HINTS */
2021
2022         PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
2023         return usb_register(&pwc_driver);
2024 }
2025
2026 static void __exit usb_pwc_exit(void)
2027 {
2028         PWC_DEBUG_MODULE("Deregistering driver.\n");
2029         usb_deregister(&pwc_driver);
2030         PWC_INFO("Philips webcam module removed.\n");
2031 }
2032
2033 module_init(usb_pwc_init);
2034 module_exit(usb_pwc_exit);
2035
2036 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */