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