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

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