v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / drivers / usb / pwc-if.c
1 /* Linux driver for Philips webcam 
2    USB and Video4Linux interface part.
3    (C) 1999-2001 Nemosoft Unv.
4
5    This program is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 2 of the License, or
8    (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
19 */
20
21 /*  
22    This code forms the interface between the USB layers and the Philips
23    specific stuff. Some adanved stuff of the driver falls under an
24    NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
25    is thus not distributed in source form. The binary pwcx.o module 
26    contains the code that falls under the NDA.
27    
28    In case you're wondering: 'pwc' stands for "Philips WebCam", but 
29    I really didn't want to type 'philips_web_cam' every time (I'm lazy as
30    any Linux kernel hacker, but I don't like uncomprehensible abbreviations
31    without explanation).
32    
33    Oh yes, convention: to disctinguish between all the various pointers to
34    device-structures, I use these names for the pointer variables:
35    udev: struct usb_device *
36    vdev: struct video_device *
37    pdev: struct pwc_devive *
38 */   
39
40 #include <linux/errno.h>
41 #include <linux/init.h>
42 #include <linux/module.h>
43 #include <linux/poll.h>
44 #include <linux/slab.h>
45 #include <linux/vmalloc.h>
46 #include <linux/wrapper.h>
47 #include <asm/io.h>
48
49 #include "pwc.h"
50 #include "pwc-ioctl.h"
51 #include "pwc-uncompress.h"
52
53 #if !defined(MAP_NR)
54 #define MAP_NR(a) virt_to_page(a)
55 #endif
56
57 /* Function prototypes and driver templates */
58
59 /* hotplug device table support */
60 static __devinitdata struct usb_device_id pwc_device_table [] = {
61         { USB_DEVICE(0x0471, 0x0302) },
62         { USB_DEVICE(0x0471, 0x0303) },
63         { USB_DEVICE(0x0471, 0x0304) },
64         { USB_DEVICE(0x0471, 0x0307) },
65         { USB_DEVICE(0x0471, 0x0308) },
66         { USB_DEVICE(0x0471, 0x030C) },
67         { USB_DEVICE(0x0471, 0x0310) },
68         { USB_DEVICE(0x0471, 0x0311) },
69         { USB_DEVICE(0x0471, 0x0312) },
70         { USB_DEVICE(0x069A, 0x0001) },
71         { }
72 };
73 MODULE_DEVICE_TABLE(usb, pwc_device_table);
74
75 static void *usb_pwc_probe(struct usb_device *udev, unsigned int ifnum, const struct usb_device_id *id);
76 static void usb_pwc_disconnect(struct usb_device *udev, void *ptr);
77
78 static struct usb_driver pwc_driver =
79 {
80         name:                   "Philips webcam",       /* name */
81         id_table:               pwc_device_table,
82         probe:                  usb_pwc_probe,          /* probe() */
83         disconnect:             usb_pwc_disconnect,     /* disconnect() */
84 };
85
86 static int default_size = PSZ_QCIF;
87 static int default_fps = 10;
88 static int default_palette = VIDEO_PALETTE_YUV420P; /* This is normal for webcams */
89 static int default_fbufs = 3;   /* Default number of frame buffers */
90 static int default_mbufs = 2;   /* Default number of mmap() buffers */
91        int pwc_trace = TRACE_MODULE | TRACE_FLOW;
92 static int power_save = 0;
93 int pwc_preferred_compression = 2; /* 0..3 = uncompressed..high */
94
95 static struct semaphore mem_lock;
96 static void *mem_leak = NULL; /* For delayed kfree()s. See below */
97
98 static int video_nr = -1;
99
100 /***/
101
102 static int  pwc_video_open(struct video_device *vdev, int mode);
103 static void pwc_video_close(struct video_device *vdev);
104 static long pwc_video_read(struct video_device *vdev, char *buf, unsigned long count, int noblock);
105 static long pwc_video_write(struct video_device *vdev, const char *buf, unsigned long count, int noblock);
106 static unsigned int pwc_video_poll(struct video_device *vdev, struct file *file, poll_table *wait);
107 static int  pwc_video_ioctl(struct video_device *vdev, unsigned int cmd, void *arg);
108 static int  pwc_video_mmap(struct video_device *dev, const char *adr, unsigned long size);
109
110 static struct video_device pwc_template = {
111         owner:          THIS_MODULE,
112         name:           "Philips Webcam",       /* Filled in later */
113         type:           VID_TYPE_CAPTURE,
114         hardware:       VID_HARDWARE_PWC,
115         open:           pwc_video_open,
116         close:          pwc_video_close,
117         read:           pwc_video_read,
118         write:          pwc_video_write,
119         poll:           pwc_video_poll,
120         ioctl:          pwc_video_ioctl,
121         mmap:           pwc_video_mmap,
122         initialize:     NULL,                   /* initialize */
123         minor:          0                       /* minor */
124 };
125
126 /***************************************************************************/
127
128 /* Okay, this is some magic that I worked out and the reasoning behind it...
129
130    The biggest problem with any USB device is of course: "what to do 
131    when the user unplugs the device while it is in use by an application?"
132    We have several options:
133    1) Curse them with the 7 plagues when they do (requires divine intervention)
134    2) Tell them not to (won't work: they'll do it anyway)
135    3) Oops the kernel (this will have a negative effect on a user's uptime)
136    4) Do something sensible.
137    
138    Of course, we go for option 4.
139
140    It happens that this device will be linked to two times, once from
141    usb_device and once from the video_device in their respective 'private'
142    pointers. This is done when the device is probed() and all initialization
143    succeeded. The pwc_device struct links back to both structures.
144
145    When a device is unplugged while in use it will be removed from the 
146    list of known USB devices; I also de-register as a V4L device, but 
147    unfortunately I can't free the memory since the struct is still in use
148    by the file descriptor. This free-ing is then deferend until the first
149    opportunity. Crude, but it works.
150    
151    A small 'advantage' is that if a user unplugs the cam and plugs it back
152    in, it should get assigned the same video device minor, but unfortunately
153    it's non-trivial to re-link the cam back to the video device... (that 
154    would surely be magic! :))
155 */
156
157 /***************************************************************************/
158 /* Private functions */
159
160 /* Memory management functions, nicked from cpia.c, which nicked them from
161    bttv.c. So far, I've counted duplication of this code 6 times 
162    (bttv, cpia, ibmcam, ov511, pwc, ieee1394).
163  */
164
165 /* Given PGD from the address space's page table, return the kernel
166  * virtual mapping of the physical memory mapped at ADR.
167  */
168 static inline unsigned long uvirt_to_kva(pgd_t *pgd, unsigned long adr)
169 {
170         unsigned long ret = 0UL;
171         pmd_t *pmd;
172         pte_t *ptep, pte;
173
174         if (!pgd_none(*pgd)) {
175                 pmd = pmd_offset(pgd, adr);
176                 if (!pmd_none(*pmd)) {
177                         ptep = pte_offset(pmd, adr);
178                         pte = *ptep;
179                         if (pte_present(pte)) {
180                                 ret = (unsigned long) page_address(pte_page(pte));
181                                 ret |= (adr & (PAGE_SIZE-1));
182                         }
183                 }
184         }
185         return ret;
186 }
187
188 static inline unsigned long uvirt_to_bus(unsigned long adr)
189 {
190         unsigned long kva, ret;
191
192         kva = uvirt_to_kva(pgd_offset(current->mm, adr), adr);
193         ret = virt_to_bus((void *)kva);
194         return ret;
195 }
196
197 static inline unsigned long kvirt_to_bus(unsigned long adr)
198 {
199         unsigned long va, kva, ret;
200
201         va = VMALLOC_VMADDR(adr);
202         kva = uvirt_to_kva(pgd_offset_k(va), va);
203         ret = virt_to_bus((void *)kva);
204         return ret;
205 }
206
207 /* Here we want the physical address of the memory.
208  * This is used when initializing the contents of the
209  * area and marking the pages as reserved.
210  */
211 static inline unsigned long kvirt_to_pa(unsigned long adr)
212 {
213         unsigned long va, kva, ret;
214
215         va = VMALLOC_VMADDR(adr);
216         kva = uvirt_to_kva(pgd_offset_k(va), va);
217         ret = __pa(kva);
218         return ret;
219 }
220
221 static void *rvmalloc(unsigned long size)
222 {
223         void *mem;
224         unsigned long adr, page;
225
226         /* Round it off to PAGE_SIZE */
227         size += (PAGE_SIZE - 1);
228         size &= ~(PAGE_SIZE - 1);
229
230         mem = vmalloc(size);
231         if (!mem)
232                 return NULL;
233
234         memset(mem, 0, size); /* Clear the ram out, no junk to the user */
235         adr = (unsigned long) mem;
236         while (size > 0) {
237                 page = kvirt_to_pa(adr);
238                 mem_map_reserve(MAP_NR(__va(page)));
239                 adr += PAGE_SIZE;
240                 if (size > PAGE_SIZE)
241                         size -= PAGE_SIZE;
242                 else
243                         size = 0;
244         }
245         return mem;
246 }
247
248 static void rvfree(void *mem, unsigned long size)
249 {
250         unsigned long adr, page;
251
252         if (!mem)
253                 return;
254
255         size += (PAGE_SIZE - 1);
256         size &= ~(PAGE_SIZE - 1);
257
258         adr=(unsigned long) mem;
259         while (size > 0) {
260                 page = kvirt_to_pa(adr);
261                 mem_map_unreserve(MAP_NR(__va(page)));
262                 adr += PAGE_SIZE;
263                 if (size > PAGE_SIZE)
264                         size -= PAGE_SIZE;
265                 else
266                         size = 0;
267         }
268         vfree(mem);
269 }
270
271
272
273 static int pwc_allocate_buffers(struct pwc_device *pdev)
274 {
275         int i;
276         void *kbuf;
277
278         Trace(TRACE_MEMORY, "Entering allocate_buffers(%p).\n", pdev);
279
280         if (pdev == NULL)
281                 return -ENXIO;
282                 
283 #ifdef PWC_MAGIC
284         if (pdev->magic != PWC_MAGIC) {
285                 Err("allocate_buffers(): magic failed.\n");
286                 return -ENXIO;
287         }
288 #endif  
289         /* Allocate Isochronuous pipe buffers */
290         for (i = 0; i < MAX_ISO_BUFS; i++) {
291                 if (pdev->sbuf[i].data == NULL) {
292                         kbuf = kmalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
293                         if (kbuf == NULL) {
294                                 Err("Failed to allocate iso buffer %d.\n", i);
295                                 return -ENOMEM;
296                         }
297                         pdev->sbuf[i].data = kbuf;
298                         memset(kbuf, 0, ISO_BUFFER_SIZE);
299                 }
300         }
301
302         /* Allocate frame buffer structure */
303         if (pdev->fbuf == NULL) {
304                 kbuf = kmalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);
305                 if (kbuf == NULL) {
306                         Err("Failed to allocate frame buffer structure.\n");
307                         return -ENOMEM;
308                 }
309                 pdev->fbuf = kbuf;
310                 memset(kbuf, 0, default_fbufs * sizeof(struct pwc_frame_buf));
311         }
312         /* create frame buffers, and make circular ring */
313         for (i = 0; i < default_fbufs; i++) {
314                 if (pdev->fbuf[i].data == NULL) {
315                         kbuf = vmalloc(FRAME_SIZE); /* need vmalloc since frame buffer > 128K */
316                         if (kbuf == NULL) {
317                                 Err("Failed to allocate frame buffer %d.\n", i);
318                                 return -ENOMEM;
319                         }
320                         pdev->fbuf[i].data = kbuf;
321                         memset(kbuf, 0, FRAME_SIZE);
322                 }
323         }
324         
325         /* Allocate decompressor table space */
326         kbuf = NULL;
327         if (pdev->decompressor != NULL) {
328                 kbuf = kmalloc(pdev->decompressor->table_size, GFP_KERNEL);
329                 if (kbuf == NULL) {
330                         Err("Failed to allocate decompress table.\n");
331                         return -ENOMEM;
332                 }
333         }
334         pdev->decompress_data = kbuf;
335         
336         /* Allocate image buffer; double buffer for mmap() */
337         kbuf = rvmalloc(default_mbufs * pdev->view_max.size * 4);
338         if (kbuf == NULL) {
339                 Err("Failed to allocate image buffer(s).\n");
340                 return -ENOMEM;
341         }
342         pdev->image_data = kbuf;
343         for (i = 0; i < default_mbufs; i++)
344                 pdev->image_ptr[i] = kbuf + (i * pdev->view_max.size * 4);
345         for (; i < MAX_IMAGES; i++)
346                 pdev->image_ptr[i] = NULL;
347
348         Trace(TRACE_MEMORY, "Leaving pwc_allocate_buffers().\n");
349
350         return 0;
351 }
352
353 static void pwc_free_buffers(struct pwc_device *pdev)
354 {
355         int i;
356
357         Trace(TRACE_MEMORY, "Entering free_buffers(%p).\n", pdev);
358
359         if (pdev == NULL)
360                 return;
361 #ifdef PWC_MAGIC
362         if (pdev->magic != PWC_MAGIC) {
363                 Err("free_buffers(): magic failed.\n");
364                 return;
365         }
366 #endif  
367
368         /* Release Iso-pipe buffers */
369         Trace(TRACE_MEMORY, "Freeing ISO buffers.\n");
370         for (i = 0; i < MAX_ISO_BUFS; i++)
371                 if (pdev->sbuf[i].data != NULL) {
372                         kfree(pdev->sbuf[i].data);
373                         pdev->sbuf[i].data = NULL;
374                 }
375
376         /* The same for frame buffers */
377         Trace(TRACE_MEMORY, "Freeing frame buffers.\n");
378         if (pdev->fbuf != NULL) {
379                 for (i = 0; i < default_fbufs; i++) {
380                         if (pdev->fbuf[i].data != NULL) {
381                                 vfree(pdev->fbuf[i].data);
382                                 pdev->fbuf[i].data = NULL;
383                         }
384                 }
385                 kfree(pdev->fbuf);
386                 pdev->fbuf = NULL;
387         }
388
389         /* Intermediate decompression buffer & tables */
390         Trace(TRACE_MEMORY, "Freeing decompression buffer\n");
391         if (pdev->decompress_data != NULL) {
392                 kfree(pdev->decompress_data);
393                 pdev->decompress_data = NULL;
394         }
395         pdev->decompressor = NULL;
396
397         /* Release image buffers */
398         Trace(TRACE_MEMORY, "Freeing image buffers\n");
399         if (pdev->image_data != NULL)
400                 rvfree(pdev->image_data, default_mbufs * pdev->view_max.size * 4);
401         pdev->image_data = NULL;
402         Trace(TRACE_MEMORY, "Leaving free_buffers().\n");
403 }
404
405 /* The frame & image buffer mess. 
406
407    Yes, this is a mess. Well, it used to be simple, but alas...  In this
408    module, 3 buffers schemes are used to get the data from the USB bus to
409    the user program. The first scheme involves the ISO buffers (called thus
410    since they transport ISO data from the USB controller), and not really
411    interesting. Suffices to say the data from this buffer is quickly 
412    gathered in an interrupt handler (pwc_isoc_handler) and placed into the 
413    frame buffer.
414    
415    The frame buffer is the second scheme, and is the central element here.
416    It collects the data from a single frame from the camera (hence, the
417    name). Frames are delimited by the USB camera with a short USB packet,
418    so that's easy to detect. The frame buffers form a list that is filled
419    by the camera+USB controller and drained by the user process through 
420    either read() or mmap().
421    
422    The image buffer is the third scheme, in which frames are decompressed
423    and possibly converted into planar format. For mmap() there is more than
424    one image buffer available.
425
426    The frame buffers provide the image buffering, in case the user process
427    is a bit slow. This introduces lag and some undesired side-effects.
428    The problem arises when the frame buffer is full. I used to drop the last 
429    frame, which makes the data in the queue stale very quickly. But dropping 
430    the frame at the head of the queue proved to be a litte bit more difficult.
431    I tried a circular linked scheme, but this introduced more problems than
432    it solved.
433
434    Because filling and draining are completely asynchronous processes, this
435    requires some fiddling with pointers and mutexes.
436    
437    Eventually, I came up with a system with 2 lists: an 'empty' frame list
438    and a 'full' frame list:
439      * Initially, all frame buffers but one are on the 'empty' list; the one
440        remaining buffer is our initial fill frame.
441      * If a frame is needed for filling, we take it from the 'empty' list, 
442        unless that list is empty, in which case we take the buffer at the 
443        head of the 'full' list.
444      * When our fill buffer has been filled, it is appended to the 'full' 
445        list.
446      * If a frame is needed by read() or mmap(), it is taken from the head of 
447        the 'full' list, handled, and then appended to the 'empty' list. If no
448        buffer is present on the 'full' list, we wait.
449    The advantage is that the buffer that is currently being decompressed/
450    converted, is on neither list, and thus not in our way (any other scheme 
451    I tried had the problem of old data lingering in the queue).
452
453    Whatever strategy you choose, it always remains a tradeoff: with more
454    frame buffers the chances of a missed frame are reduced. On the other
455    hand, on slower machines it introduces lag because the queue will 
456    always be full.
457  */
458
459 /**
460   \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.
461  */
462 static inline int pwc_next_fill_frame(struct pwc_device *pdev)
463 {
464         int ret, flags;
465         
466         ret = 0;
467         spin_lock_irqsave(&pdev->ptrlock, flags);
468         if (pdev->fill_frame != NULL) {
469                 /* append to 'full' list */
470                 if (pdev->full_frames == NULL) {
471                         pdev->full_frames = pdev->fill_frame;
472                         pdev->full_frames_tail = pdev->full_frames;
473                 }
474                 else {
475                         pdev->full_frames_tail->next = pdev->fill_frame;
476                         pdev->full_frames_tail = pdev->fill_frame;
477                 }
478         }
479         if (pdev->empty_frames != NULL) {
480                 /* We have empty frames available. That's easy */
481                 pdev->fill_frame = pdev->empty_frames;
482                 pdev->empty_frames = pdev->empty_frames->next;  
483         }
484         else {
485                 /* Hmm. Take it from the full list */
486 #if PWC_DEBUG           
487                 /* sanity check */
488                 if (pdev->full_frames == NULL) {
489                         Err("Neither empty or full frames available!\n");
490                         spin_unlock_irqrestore(&pdev->ptrlock, flags);
491                         return -EINVAL;
492                 }
493 #endif
494                 pdev->fill_frame = pdev->full_frames;
495                 pdev->full_frames = pdev->full_frames->next;
496                 ret = 1;
497         }
498         pdev->fill_frame->next = NULL;
499 #if PWC_DEBUG
500         Trace(TRACE_SEQUENCE, "Assigning sequence number %d.\n", pdev->sequence);
501         pdev->fill_frame->sequence = pdev->sequence++;
502 #endif
503         spin_unlock_irqrestore(&pdev->ptrlock, flags);
504         return ret;
505 }
506  
507
508 /**
509   \brief Reset all buffers, pointers and lists, except for the image_used[] buffer. 
510   
511   If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble.
512  */
513 static void pwc_reset_buffers(struct pwc_device *pdev)
514 {
515         int i, flags;
516
517         spin_lock_irqsave(&pdev->ptrlock, flags);
518         pdev->full_frames = NULL;
519         pdev->full_frames_tail = NULL;
520         for (i = 0; i < default_fbufs; i++) {
521                 pdev->fbuf[i].filled = 0;
522                 if (i > 0)
523                         pdev->fbuf[i].next = &pdev->fbuf[i - 1];
524                 else
525                         pdev->fbuf->next = NULL;
526         }
527         pdev->empty_frames = &pdev->fbuf[default_fbufs - 1];
528         pdev->empty_frames_tail = pdev->fbuf;
529         pdev->read_frame = NULL;
530         pdev->fill_frame = pdev->empty_frames;
531         pdev->empty_frames = pdev->empty_frames->next;
532
533         pdev->image_read_pos = 0;
534         pdev->fill_image = 0;
535         spin_unlock_irqrestore(&pdev->ptrlock, flags);
536 }
537
538
539 /**
540   \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.
541  */
542 static int pwc_handle_frame(struct pwc_device *pdev)
543 {
544         int ret = 0, flags;
545         
546         spin_lock_irqsave(&pdev->ptrlock, flags);
547         /* First grab our read_frame; this is removed from all lists, so
548            we can release the lock after this without problems */
549         if (pdev->read_frame != NULL) {
550                 /* This can't theoretically happen */
551                 Err("Huh? Read frame still in use?\n");
552         }
553         else {
554                 if (pdev->full_frames == NULL) {
555                         Err("Woops. No frames ready.\n");
556                 }
557                 else {
558                         pdev->read_frame = pdev->full_frames;
559                         pdev->full_frames = pdev->full_frames->next;
560                         pdev->read_frame->next = NULL;
561                 }
562
563                 if (pdev->read_frame != NULL) {
564 #if PWC_DEBUG
565                         Trace(TRACE_SEQUENCE, "Decompressing frame %d\n", pdev->read_frame->sequence);
566 #endif
567                         /* Decompression is a lenghty process, so it's outside of the lock.
568                            This gives the isoc_handler the opportunity to fill more frames 
569                            in the mean time.
570                         */
571                         spin_unlock_irqrestore(&pdev->ptrlock, flags);
572                         ret = pwc_decompress(pdev);
573                         spin_lock_irqsave(&pdev->ptrlock, flags);
574
575                         /* We're done with read_buffer, tack it to the end of the empty buffer list */
576                         if (pdev->empty_frames == NULL) {
577                                 pdev->empty_frames = pdev->read_frame;
578                                 pdev->empty_frames_tail = pdev->empty_frames;
579                         }
580                         else {
581                                 pdev->empty_frames_tail->next = pdev->read_frame;
582                                 pdev->empty_frames_tail = pdev->read_frame;
583                         }
584                         pdev->read_frame = NULL;
585                 }
586         }
587         spin_unlock_irqrestore(&pdev->ptrlock, flags);
588         return ret;
589 }
590
591 /**
592   \brief Advance pointers of image buffer (after each user request) 
593 */
594 static inline void pwc_next_image(struct pwc_device *pdev)
595 {
596         pdev->image_used[pdev->fill_image] = 0;
597         pdev->fill_image = (pdev->fill_image + 1) % default_mbufs;
598 }
599
600 /* XXX: 2001-06-17: The YUV420 palette will be phased out soon */
601 static int pwc_set_palette(struct pwc_device *pdev, int pal)
602 {
603         if (   pal == VIDEO_PALETTE_YUV420
604             || pal == VIDEO_PALETTE_YUV420P
605 #if PWC_DEBUG
606             || pal == VIDEO_PALETTE_RAW
607 #endif
608         ) {
609                 pdev->vpalette = pal;
610                 pwc_set_image_buffer_size(pdev);
611                 return 0;
612         }
613         return -1;
614 }
615
616
617
618 /* This gets called for the Isochronous pipe (video). This is done in
619  * interrupt time, so it has to be fast, not crash, and not stall. Neat.
620  */
621 static void pwc_isoc_handler(purb_t urb)
622 {
623         struct pwc_device *pdev;
624         int i, fst, flen;
625         int awake;
626         struct pwc_frame_buf *fbuf;
627         unsigned char *fillptr, *iso_buf;
628
629         pdev = (struct pwc_device *)urb->context;
630         if (pdev == NULL) {
631                 Err("isoc_handler() called with NULL device?!\n");
632                 return;
633         }
634 #ifdef PWC_MAGIC        
635         if (pdev->magic != PWC_MAGIC) {
636                 Err("isoc_handler() called with bad magic!\n");
637                 return;
638         }
639 #endif
640         if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
641                 Trace(TRACE_OPEN, "pwc_isoc_handler(): URB unlinked.\n");
642                 return;
643         }
644         if (urb->status != -EINPROGRESS && urb->status != 0) {
645                 Trace(TRACE_FLOW, "pwc_isoc_handler() called with status %d.\n", urb->status);
646                 return;
647         }
648
649         fbuf = pdev->fill_frame;
650         if (fbuf == NULL) {
651                 Err("pwc_isoc_handler without valid fill frame.\n");
652                 wake_up_interruptible(&pdev->frameq);
653                 return;
654         }
655         fillptr = fbuf->data + fbuf->filled;
656         awake = 0;
657
658         /* vsync: 0 = don't copy data
659                   1 = sync-hunt
660                   2 = synched 
661          */
662         /* Compact data */
663         for (i = 0; i < urb->number_of_packets; i++) {
664                 fst  = urb->iso_frame_desc[i].status;
665                 flen = urb->iso_frame_desc[i].actual_length;
666                 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
667                 if (fst == 0) {
668                         if (flen > 0) { /* if valid data... */
669                                 if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */
670                                         pdev->vsync = 2;
671
672                                         /* ...copy data to frame buffer, if possible */
673                                         if (flen + fbuf->filled > pdev->frame_size) {
674                                                 Trace(TRACE_FLOW, "Frame buffer overflow (flen = %d, frame_size = %d).\n", flen, pdev->frame_size);
675                                                 pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */
676                                                 pdev->vframes_error++;
677                                         }
678                                         else {
679                                                 memmove(fillptr, iso_buf, flen);
680                                                 fillptr += flen;
681                                         }
682                                 }
683                                 fbuf->filled += flen;
684                         } /* ..flen > 0 */
685
686                         if (flen < pdev->vlast_packet_size) {
687                                 /* Shorter packet... We probably have the end of an image-frame; 
688                                    wake up read() process and let select()/poll() do something.
689                                    Decompression is done in user time over there. 
690                                  */
691                                 if (pdev->vsync == 2) {
692                                         /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus 
693                                            frames on the USB wire after an exposure change. This conditition is 
694                                            however detected  in the cam and a bit is set in the header.
695                                          */
696                                         if (pdev->type == 730) {
697                                                 unsigned char *ptr = (unsigned char *)fbuf->data;
698                                                 
699                                                 if (ptr[1] == 1 && ptr[0] & 0x10) {
700 #if PWC_DEBUG
701                                                         Debug("Hyundai CMOS sensor bug. Dropping frame %d.\n", fbuf->sequence);
702 #endif
703                                                         pdev->drop_frames = 2;
704                                                         pdev->vframes_error++;
705                                                 }
706                                                 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet 
707                                                    after a short frame; this condition is filtered out specifically. A 4 byte
708                                                    frame doesn't make sense anyway.
709                                                    So we get either this sequence: 
710                                                         drop_bit set -> 4 byte frame -> short frame -> good frame
711                                                    Or this one:
712                                                         drop_bit set -> short frame -> good frame
713                                                    So we drop either 3 or 2 frames in all!
714                                                  */
715                                                 if (fbuf->filled == 4)
716                                                         pdev->drop_frames++;
717                                         }
718
719                                         /* In case we were instructed to drop the frame, do so silently.
720                                            The buffer pointers are not updated either (but the counters are reset below).
721                                          */
722                                         if (pdev->drop_frames)
723                                                 pdev->drop_frames--;
724                                         else {
725                                                 /* Check for underflow first */
726                                                 if (fbuf->filled < pdev->frame_size) {
727                                                         Trace(TRACE_FLOW, "Frame buffer underflow (%d bytes); discarded.\n", fbuf->filled);
728                                                         pdev->vframes_error++;
729                                                 }
730                                                 else {
731                                                         /* Send only once per EOF */
732                                                         awake = 1; /* delay wake_ups */
733                                                         
734                                                         /* Find our next frame to fill. This will always succeed, since we
735                                                          * nick a frame from either empty or full list, but if we had to
736                                                          * take it from the full list, it means a frame got dropped.
737                                                          */
738                                                         if (pwc_next_fill_frame(pdev)) {
739                                                                 pdev->vframes_dumped++;
740                                                                 if ((pdev->vframe_count > FRAME_LOWMARK) && (pwc_trace & TRACE_FLOW)) {
741                                                                         if (pdev->vframes_dumped < 20)
742                                                                                 Info("Dumping frame %d.\n", pdev->vframe_count);
743                                                                         if (pdev->vframes_dumped == 20)
744                                                                                 Info("Dumping frame %d (last message).\n", pdev->vframe_count);
745                                                                 }
746                                                         }
747                                                         fbuf = pdev->fill_frame;
748                                                 }
749                                         } /* !drop_frames */
750                                         pdev->vframe_count++;
751                                 }
752                                 fbuf->filled = 0;
753                                 fillptr = fbuf->data;
754                                 pdev->vsync = 1;
755                         } /* .. flen < last_packet_size */
756                         pdev->vlast_packet_size = flen;
757                 } /* ..status == 0 */
758         }
759         if (awake)
760                 wake_up_interruptible(&pdev->frameq);
761 }
762
763
764 static int pwc_isoc_init(struct pwc_device *pdev)
765 {
766         struct usb_device *udev;
767         purb_t urb;
768         int i, j, ret;
769
770         struct usb_interface_descriptor *idesc;
771         int cur_alt;
772
773         if (pdev == NULL)
774                 return -EFAULT;
775         if (pdev->iso_init)
776                 return 0;
777         pdev->vsync = 0;
778         udev = pdev->udev;
779         
780         /* Get the current alternate interface, adjust packet size */
781         if (!udev->actconfig)
782                 return -EFAULT;
783         cur_alt = udev->actconfig->interface[0].act_altsetting;
784         idesc = &udev->actconfig->interface[0].altsetting[cur_alt];
785         if (!idesc)
786                 return -EFAULT;
787
788         /* Search video endpoint */
789         pdev->vmax_packet_size = -1;
790         for (i = 0; i < idesc->bNumEndpoints; i++)
791                 if ((idesc->endpoint[i].bEndpointAddress & 0xF) == pdev->vendpoint) {
792                         pdev->vmax_packet_size = idesc->endpoint[i].wMaxPacketSize;
793                         break;
794                 }
795         
796         if (pdev->vmax_packet_size < 0) {
797                 Err("Failed to find packet size for video endpoint in current alternate setting.\n");
798                 return -ENFILE; /* Odd error, that should be noticable */
799         }
800
801         ret = 0;
802         for (i = 0; i < MAX_ISO_BUFS; i++) {
803                 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC);
804                 if (urb == NULL) {
805                         Err("Failed to allocate urb %d\n", i);
806                         ret = -ENOMEM;
807                         break;
808                 }
809                 pdev->sbuf[i].urb = urb;
810         }
811         if (ret) {
812                 /* De-allocate in reverse order */
813                 while (i >= 0) {
814                         if (pdev->sbuf[i].urb != NULL)
815                                 usb_free_urb(pdev->sbuf[i].urb);
816                         pdev->sbuf[i].urb = NULL;
817                         i--;
818                 }
819                 return ret;
820         }
821         
822         
823         /* init URB structure */        
824         for (i = 0; i < MAX_ISO_BUFS; i++) {
825                 urb = pdev->sbuf[i].urb;
826
827                 urb->next = pdev->sbuf[(i + 1) % MAX_ISO_BUFS].urb;
828                 urb->dev = udev;
829                 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
830                 urb->transfer_flags = USB_ISO_ASAP;
831                 urb->transfer_buffer = pdev->sbuf[i].data;
832                 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
833                 urb->complete = pwc_isoc_handler;
834                 urb->context = pdev;
835                 urb->start_frame = 0;
836                 urb->number_of_packets = ISO_FRAMES_PER_DESC;
837                 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
838                         urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
839                         urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE;
840                 }
841         }
842
843         /* link */
844         for (i = 0; i < MAX_ISO_BUFS; i++) {
845                 ret = usb_submit_urb(pdev->sbuf[i].urb);
846                 if (ret)
847                         Err("isoc_init() submit_urb %d failed with error %d\n", i, ret);
848                 else
849                         Trace(TRACE_OPEN, "pwc_isoc_init(): URB submitted.\n");
850         }
851
852         /* data should stream in now */
853         pdev->iso_init = 1;
854         return 0;
855 }
856
857 static void pwc_isoc_cleanup(struct pwc_device *pdev)
858 {
859         int i;
860         
861         if (pdev == NULL)
862                 return;
863         if (!pdev->iso_init)
864                 return;
865         /* Stop camera, but only if we are sure the camera is still there */
866         if (!pdev->unplugged)
867                 usb_set_interface(pdev->udev, 0, 0);
868         for (i = MAX_ISO_BUFS - 1; i >= 0; i--) {
869                 pdev->sbuf[i].urb->next = NULL;
870                 usb_unlink_urb(pdev->sbuf[i].urb);
871                 usb_free_urb(pdev->sbuf[i].urb);
872                 pdev->sbuf[i].urb = NULL;
873         }
874         pdev->iso_init = 0;
875 }
876
877 int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot)
878 {
879         int ret;
880
881         /* Stop isoc stuff */
882         pwc_isoc_cleanup(pdev);
883         /* Reset parameters */
884         pwc_reset_buffers(pdev);
885         /* Try to set video mode... */
886         ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot);
887         if (ret) /* That failed... restore old mode (we know that worked) */
888                 ret = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
889         else /* Set (new) alternate interface */
890                 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
891         if (!ret)
892                 ret = pwc_isoc_init(pdev);
893         pdev->drop_frames = 1; /* try to avoid garbage during switch */
894         return ret;
895 }
896
897
898 static inline void set_mem_leak(void *ptr)
899 {
900         down(&mem_lock);
901         if (mem_leak != NULL)
902                 Err("Memleak: overwriting mem_leak pointer!\n");
903         Trace(TRACE_MEMORY, "Setting mem_leak to 0x%p.\n", ptr);
904         mem_leak = ptr;
905         up(&mem_lock);
906 }
907
908 static inline void free_mem_leak(void)
909 {
910         down(&mem_lock);
911         if (mem_leak != NULL) {
912                 Trace(TRACE_MEMORY, "Freeing mem_leak ptr 0x%p.\n", mem_leak);
913                 kfree(mem_leak);
914                 mem_leak = NULL;
915         }
916         up(&mem_lock);
917 }
918
919
920 /***************************************************************************/
921 /* Video4Linux functions */
922
923 static int pwc_video_open(struct video_device *vdev, int mode)
924 {
925         int i;
926         struct pwc_device *pdev;
927
928         Trace(TRACE_OPEN, "video_open called(0x%p, 0%o).\n", vdev, mode);
929         
930         if (vdev == NULL)
931                 BUG();
932         pdev = (struct pwc_device *)vdev->priv;
933         if (pdev == NULL)
934                 BUG();
935         
936         down(&pdev->modlock);
937         if (!pdev->usb_init) {
938                 Trace(TRACE_OPEN, "Doing first time initialization.\n");
939                 /* Reset camera */
940                 if (usb_set_interface(pdev->udev, 0, 0))
941                         Info("Failed to set alternate interface to 0.\n");
942                 pdev->usb_init = 1;
943         }
944         else {
945                 /* Turn on camera */
946                 if (power_save) {
947                         i = pwc_camera_power(pdev, 1);
948                         if (i < 0)
949                                 Info("Failed to restore power to the camera! (%d)\n", i);
950                 }
951         }
952
953         /* Find our decompressor, if any */
954         pdev->decompressor = pwc_find_decompressor(pdev->type);
955 #if PWC_DEBUG   
956         Debug("Found decompressor for %d at 0x%p\n", pdev->type, pdev->decompressor);
957 #endif
958
959         /* So far, so good. Allocate memory. */
960         i = pwc_allocate_buffers(pdev);
961         if (i < 0) {
962                 Trace(TRACE_OPEN, "Failed to allocate buffer memory.\n");
963                 up(&pdev->modlock);
964                 return i;
965         }
966         
967         /* Reset buffers & parameters */
968         pwc_reset_buffers(pdev);
969         for (i = 0; i < default_mbufs; i++)
970                 pdev->image_used[i] = 0;
971         pdev->vframe_count = 0;
972         pdev->vframes_dumped = 0;
973         pdev->vframes_error = 0;
974         pdev->vpalette = default_palette;
975 #if PWC_DEBUG   
976         pdev->sequence = 0;
977 #endif
978
979         /* Set some defaults */
980         pdev->vsnapshot = 0;
981         if (pdev->type == 730 || pdev->type == 740 || pdev->type == 750)
982                 pdev->vsize = PSZ_QSIF;
983         else
984                 pdev->vsize = PSZ_QCIF;
985         pdev->vframes = 10;
986
987         /* Start iso pipe for video; first try user-supplied size/fps, if
988            that fails try QCIF/10 or QSIF/10 (a reasonable default), 
989            then give up 
990          */
991         i = pwc_set_video_mode(pdev, pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y, default_fps, pdev->vcompression, 0);
992         if (i)  {
993                 Trace(TRACE_OPEN, "First attempt at set_video_mode failed.\n");
994                 if (pdev->type == 730 || pdev->type == 740 || pdev->type == 750)
995                         i = pwc_set_video_mode(pdev, pwc_image_sizes[PSZ_QSIF].x, pwc_image_sizes[PSZ_QSIF].y, 10, pdev->vcompression, 0);
996                 else
997                         i = pwc_set_video_mode(pdev, pwc_image_sizes[PSZ_QCIF].x, pwc_image_sizes[PSZ_QCIF].y, 10, pdev->vcompression, 0);
998         }
999         if (i) {
1000                 Trace(TRACE_OPEN, "Second attempt at set_video_mode failed.\n");
1001                 up(&pdev->modlock);
1002                 return i;
1003         }
1004         i = usb_set_interface(pdev->udev, 0, pdev->valternate);
1005         if (i) {
1006                 Trace(TRACE_OPEN, "Failed to set alternate interface = %d.\n", i);
1007                 up(&pdev->modlock);
1008                 return -EINVAL;
1009         }
1010         i = pwc_isoc_init(pdev);
1011         if (i) {
1012                 Trace(TRACE_OPEN, "Failed to init ISOC stuff = %d.\n", i);
1013                 MOD_DEC_USE_COUNT;
1014                 up(&pdev->modlock);
1015                 return i;
1016         }
1017
1018         pdev->vopen++;
1019         /* lock decompressor; this has a small race condition, since we 
1020            could in theory unload pwcx.o between pwc_find_decompressor()
1021            above and this call. I doubt it's ever going to be a problem.
1022          */
1023         if (pdev->decompressor != NULL)
1024                 pdev->decompressor->lock();
1025         up(&pdev->modlock);
1026         Trace(TRACE_OPEN, "video_open() returning 0.\n");
1027         return 0;
1028 }
1029
1030 /* Note that all cleanup is done in the reverse order as in _open */
1031 static void pwc_video_close(struct video_device *vdev)
1032 {
1033         struct pwc_device *pdev;
1034         int i;
1035
1036         Trace(TRACE_OPEN, "video_close called(0x%p).\n", vdev);
1037
1038         pdev = (struct pwc_device *)vdev->priv;
1039         if (pdev->vopen == 0)
1040                 Info("video_close() called on closed device?\n");
1041
1042         /* Free isoc URBs */
1043         pwc_isoc_cleanup(pdev);
1044
1045         /* Dump statistics, but only if a reasonable amount of frames were
1046            processed (to prevent endless log-entries in case of snap-shot
1047            programs) 
1048          */
1049         if (pdev->vframe_count > 20)
1050                 Info("Closing video device: %d frames received, dumped %d frames, %d frames with errors.\n", pdev->vframe_count, pdev->vframes_dumped, pdev->vframes_error);
1051
1052         if (pdev->unplugged) {
1053                 /* The device was unplugged or some other error occured */
1054                 /* We unregister the video_device */
1055                 Trace(TRACE_OPEN, "Delayed video device unregistered.\n");
1056                 video_unregister_device(pdev->vdev);
1057         }
1058         else {
1059                 /* Normal close: stop isochronuous and interrupt endpoint */
1060                 Trace(TRACE_OPEN, "Normal close(): setting interface to 0.\n");
1061                 usb_set_interface(pdev->udev, 0, 0);
1062
1063                 /* Turn off LED by powering down camera */
1064                 if (power_save) {
1065                         i = pwc_camera_power(pdev, 0);
1066                         if (i < 0) 
1067                                 Err("Failed to power down camera (%d)\n", i);
1068                 }
1069         }
1070
1071         pdev->vopen = 0;
1072         if (pdev->decompressor != NULL) {
1073                 pdev->decompressor->exit();
1074                 pdev->decompressor->unlock();
1075         }
1076         pwc_free_buffers(pdev);
1077
1078         /* wake up _disconnect() routine */
1079         if (pdev->unplugged)
1080                 wake_up(&pdev->remove_ok);
1081 }
1082
1083 /*
1084  *      FIXME: what about two parallel reads ????
1085  *      ANSWER: Not supported. You can't open the device more than once,
1086                 despite what the V4L1 interface says. First, I don't see 
1087                 the need, second there's no mechanism of alerting the 
1088                 2nd/3rd/... process of events like changing image size.
1089                 And I don't see the point of blocking that for the 
1090                 2nd/3rd/... process.
1091                 In multi-threaded environments reading parallel from any
1092                 device is tricky anyhow.
1093  */
1094  
1095 static long pwc_video_read(struct video_device *vdev, char *buf, unsigned long count, int noblock)
1096 {
1097         struct pwc_device *pdev;
1098         DECLARE_WAITQUEUE(wait, current);
1099
1100         Trace(TRACE_READ, "video_read(0x%p, %p, %ld, %d) called.\n", vdev, buf, count, noblock);
1101         if (vdev == NULL)
1102                 return -EFAULT;
1103         pdev = vdev->priv;
1104         if (pdev == NULL)
1105                 return -EFAULT;
1106         if (pdev->unplugged) {
1107                 Debug("pwc_video_read: Device got unplugged (1).\n");
1108                 return -EPIPE; /* unplugged device! */
1109         }
1110
1111         /* In case we're doing partial reads, we don't have to wait for a frame */
1112         if (pdev->image_read_pos == 0) {
1113                 /* Do wait queueing according to the (doc)book */
1114                 add_wait_queue(&pdev->frameq, &wait);
1115                 while (pdev->full_frames == NULL) {
1116                         if (noblock) {
1117                                 remove_wait_queue(&pdev->frameq, &wait);
1118                                 current->state = TASK_RUNNING;
1119                                 return -EWOULDBLOCK;
1120                         }
1121                         if (signal_pending(current)) {
1122                                 remove_wait_queue(&pdev->frameq, &wait);
1123                                 current->state = TASK_RUNNING;
1124                                 return -ERESTARTSYS;
1125                         }
1126                         schedule();
1127                         current->state = TASK_INTERRUPTIBLE;
1128                 }
1129                 remove_wait_queue(&pdev->frameq, &wait);
1130                 current->state = TASK_RUNNING;
1131                                                                                                                                                                                         
1132                 /* Decompress [, convert] and release frame */
1133                 if (pwc_handle_frame(pdev))
1134                         return -EFAULT;
1135         }
1136
1137         Trace(TRACE_READ, "Copying data to user space.\n");
1138         /* copy bytes to user space; we allow for partial reads */
1139         if (count + pdev->image_read_pos > pdev->view.size)
1140                 count = pdev->view.size - pdev->image_read_pos;
1141         if (copy_to_user(buf, pdev->image_ptr[pdev->fill_image] + pdev->image_read_pos, count))
1142                 return -EFAULT;
1143         pdev->image_read_pos += count;
1144         if (pdev->image_read_pos >= pdev->view.size) { /* All data has been read */
1145                 pdev->image_read_pos = 0;
1146                 pwc_next_image(pdev);
1147         }
1148         return count;
1149 }
1150
1151
1152 static long pwc_video_write(struct video_device *vdev, const char *buf, unsigned long count, int noblock)
1153 {
1154         return -EINVAL;   
1155 }
1156
1157 static unsigned int pwc_video_poll(struct video_device *vdev, struct file *file, poll_table *wait)
1158 {
1159         struct pwc_device *pdev;
1160         
1161         if (vdev == NULL)
1162                 return -EFAULT;
1163         pdev = vdev->priv;
1164         if (pdev == NULL)
1165                 return -EFAULT;
1166         
1167         poll_wait(file, &pdev->frameq, wait);
1168         if (pdev->unplugged) {
1169                 Debug("pwc_video_poll: Device got unplugged.\n");
1170                 return POLLERR;
1171         }               
1172         if (pdev->full_frames != NULL) /* we have frames waiting */
1173                 return (POLLIN | POLLRDNORM);
1174
1175         return 0;
1176 }
1177         
1178 static int pwc_video_ioctl(struct video_device *vdev, unsigned int cmd, void *arg)
1179 {
1180         struct pwc_device *pdev;
1181         DECLARE_WAITQUEUE(wait, current);
1182         
1183         if (vdev == NULL)
1184                 return -EFAULT;
1185         pdev = vdev->priv;
1186         if (pdev == NULL)
1187                 return -EFAULT;
1188
1189         switch (cmd) {
1190                 /* Query cabapilities */
1191                 case VIDIOCGCAP: 
1192                 {
1193                         struct video_capability caps;
1194
1195                         strcpy(caps.name, vdev->name);
1196                         caps.type = VID_TYPE_CAPTURE;
1197                         caps.channels = 1;
1198                         caps.audios = 1;
1199                         caps.minwidth  = pdev->view_min.x;
1200                         caps.minheight = pdev->view_min.y;
1201                         caps.maxwidth  = pdev->view_max.x;
1202                         caps.maxheight = pdev->view_max.y;
1203                         if (copy_to_user(arg, &caps, sizeof(caps)))
1204                                 return -EFAULT;
1205                         break;
1206                 }
1207
1208                 /* Channel functions (simulate 1 channel) */
1209                 case VIDIOCGCHAN:
1210                 {
1211                         struct video_channel v;
1212
1213                         if (copy_from_user(&v, arg, sizeof(v)))
1214                                 return -EFAULT;
1215                         if (v.channel != 0)
1216                                 return -EINVAL;
1217
1218                         v.flags = 0;
1219                         v.tuners = 0;
1220                         v.type = VIDEO_TYPE_CAMERA;
1221                         strcpy(v.name, "Webcam");
1222
1223                         if (copy_to_user(arg, &v, sizeof(v)))
1224                                 return -EFAULT;
1225
1226                         return 0;
1227                 }
1228
1229                 case VIDIOCSCHAN:
1230                 {       
1231                         /* The spec says the argument is an integer, but
1232                            the bttv driver uses a video_channel arg, which
1233                            makes sense becasue it also has the norm flag.
1234                          */
1235                         struct video_channel v;
1236
1237                         if (copy_from_user(&v, arg, sizeof(v)))
1238                                 return -EFAULT;
1239
1240                         if (v.channel != 0)
1241                                 return -EINVAL;
1242
1243                         return 0;
1244                 }
1245
1246
1247                 /* Picture functions; contrast etc. */
1248                 case VIDIOCGPICT:
1249                 {
1250                         struct video_picture p;
1251                         int val;
1252
1253                         p.colour = 0x8000;
1254                         p.hue = 0x8000;
1255                         val = pwc_get_brightness(pdev);
1256                         if (val >= 0)
1257                                 p.brightness = val;
1258                         else
1259                                 p.brightness = 0xffff;
1260                         val = pwc_get_contrast(pdev);
1261                         if (val >= 0)
1262                                 p.contrast = val;
1263                         else
1264                                 p.contrast = 0xffff;
1265                         /* Gamma, Whiteness, what's the difference? :) */
1266                         val = pwc_get_gamma(pdev);
1267                         if (val >= 0)
1268                                 p.whiteness = val;
1269                         else
1270                                 p.whiteness = 0xffff;
1271                         val = pwc_get_saturation(pdev);
1272                         if (val >= 0)
1273                                 p.colour = val;
1274                         else
1275                                 p.colour = 0xffff;
1276                         p.depth = 24;
1277                         p.palette = pdev->vpalette;
1278                         p.hue = 0xFFFF; /* N/A */
1279
1280                         if (copy_to_user(arg, &p, sizeof(p)))
1281                                 return -EFAULT;
1282                         break;
1283                 }
1284                 
1285                 case VIDIOCSPICT:
1286                 {
1287                         struct video_picture p;
1288
1289                         if (copy_from_user(&p, arg, sizeof(p)))
1290                                 return -EFAULT;
1291
1292                         /*
1293                          *      FIXME:  Suppose we are mid read
1294                                 ANSWER: No problem: the firmware of the camera
1295                                         can handle brightness/contrast/etc
1296                                         changes at _any_ time, and the palette
1297                                         is used exactly once in the uncompress
1298                                         routine.
1299                          */
1300                         pwc_set_brightness(pdev, p.brightness);
1301                         pwc_set_contrast(pdev, p.contrast);
1302                         pwc_set_gamma(pdev, p.whiteness);
1303                         pwc_set_saturation(pdev, p.colour);
1304                         if (p.palette && p.palette != pdev->vpalette) {
1305                                 if (pwc_set_palette(pdev, p.palette) < 0)
1306                                         return -EINVAL;
1307                         }
1308                         break;
1309                 }
1310
1311                 /* Window/size parameters */            
1312                 case VIDIOCGWIN:
1313                 {
1314                         struct video_window vw;
1315                         
1316                         vw.x = 0;
1317                         vw.y = 0;
1318                         vw.width = pdev->view.x;
1319                         vw.height = pdev->view.y;
1320                         vw.chromakey = 0;
1321                         vw.flags = (pdev->vframes << PWC_FPS_SHIFT) | 
1322                                    (pdev->vsnapshot ? PWC_FPS_SNAPSHOT : 0);
1323                         
1324                         if (copy_to_user(arg, &vw, sizeof(vw)))
1325                                 return -EFAULT;                 
1326                         break;
1327                 }
1328                 
1329                 case VIDIOCSWIN:
1330                 {
1331                         struct video_window vw;
1332                         int fps, snapshot, ret;
1333                 
1334                         if (copy_from_user(&vw, arg, sizeof(vw)))
1335                                 return -EFAULT;
1336
1337                         fps = (vw.flags & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
1338                         snapshot = vw.flags & PWC_FPS_SNAPSHOT;
1339                         if (fps == 0)
1340                                 fps = pdev->vframes;
1341                         if (pdev->view.x == vw.width && pdev->view.y && fps == pdev->vframes && snapshot == pdev->vsnapshot)
1342                                 return 0;
1343                         ret = pwc_try_video_mode(pdev, vw.width, vw.height, fps, pdev->vcompression, snapshot);
1344                         if (ret)
1345                                 return ret;
1346                         break;          
1347                 }
1348                 
1349                 /* We don't have overlay support (yet) */
1350                 case VIDIOCGFBUF:
1351                 {
1352                         struct video_buffer vb;
1353                         
1354                         vb.base = NULL;
1355                         vb.height = 0;
1356                         vb.width = 0;
1357                         vb.depth = 0;
1358                         vb.bytesperline = 0;
1359                         
1360                         if (copy_to_user((void *)arg, (void *)&vb, sizeof(vb)))
1361                                 return -EFAULT;
1362                         break;
1363                 }
1364
1365                 /* mmap() functions */
1366                 case VIDIOCGMBUF:
1367                 {
1368                         /* Tell the user program how much memory is needed for a mmap() */
1369                         struct video_mbuf vm;
1370                         int i;
1371
1372                         memset(&vm, 0, sizeof(vm));
1373                         vm.size = default_mbufs * pdev->view_max.size * 4;
1374                         vm.frames = default_mbufs; /* double buffering should be enough */
1375                         for (i = 0; i < default_mbufs; i++)
1376                                 vm.offsets[i] = i * pdev->view_max.size * 4;
1377
1378                         if (copy_to_user((void *)arg, (void *)&vm, sizeof(vm)))
1379                                 return -EFAULT;
1380                         break;
1381                 }
1382
1383                 case VIDIOCMCAPTURE:
1384                 {
1385                         /* Start capture into a given image buffer (called 'frame' in video_mmap structure) */
1386                         struct video_mmap vm;
1387
1388                         if (copy_from_user((void *)&vm, (void *)arg, sizeof(vm)))
1389                                 return -EFAULT;
1390                         Trace(TRACE_READ, "VIDIOCMCAPTURE: %dx%d, frame %d, format %d\n", vm.width, vm.height, vm.frame, vm.format);
1391                         if (vm.frame < 0 || vm.frame >= default_mbufs)
1392                                 return -EINVAL;
1393
1394                         /* xawtv is nasty. It probes the available palettes
1395                            by setting a very small image size and trying
1396                            various palettes... The driver doesn't support
1397                            such small images, so I'm working around it.
1398                          */
1399                         if (vm.format && vm.format != pdev->vpalette)
1400                                 if (pwc_set_palette(pdev, vm.format) < 0)
1401                                         return -EINVAL;
1402                          
1403                         if ((vm.width != pdev->view.x || vm.height != pdev->view.y) &&
1404                             (vm.width >= pdev->view_min.x && vm.height >= pdev->view_min.y)) {
1405                                 int ret;
1406                                 
1407                                 Trace(TRACE_OPEN, "VIDIOCMCAPTURE: changing size to please xawtv :-(.\n");
1408                                 ret = pwc_try_video_mode(pdev, vm.width, vm.height, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
1409                                 if (ret)
1410                                         return ret;
1411                         } /* ... size mismatch */
1412
1413                         /* FIXME: should we lock here? */
1414                         if (pdev->image_used[vm.frame])
1415                                 return -EBUSY;  /* buffer wasn't available. Bummer */
1416                         pdev->image_used[vm.frame] = 1;
1417
1418                         /* Okay, we're done here. In the SYNC call we wait until a 
1419                            frame comes available, then expand image into the given 
1420                            buffer.
1421                            In contrast to the CPiA cam the Philips cams deliver a 
1422                            constant stream, almost like a grabber card. Also,
1423                            we have separate buffers for the rawdata and the image,
1424                            meaning we can nearly always expand into the requested buffer.
1425                          */
1426                         Trace(TRACE_READ, "VIDIOCMCAPTURE done.\n");
1427                         break;
1428                 }
1429
1430                 case VIDIOCSYNC:
1431                 {
1432                         /* The doc says: "Whenever a buffer is used it should
1433                            call VIDIOCSYNC to free this frame up and continue."
1434                            
1435                            The only odd thing about this whole procedure is 
1436                            that MCAPTURE flags the buffer as "in use", and
1437                            SYNC immediately unmarks it, while it isn't 
1438                            after SYNC that you know that the buffer actually
1439                            got filled! So you better not start a CAPTURE in
1440                            the same frame immediately (use double buffering). 
1441                            This is not a problem for this cam, since it has 
1442                            extra intermediate buffers, but a hardware 
1443                            grabber card will then overwrite the buffer 
1444                            you're working on.
1445                          */
1446                         int mbuf, ret;
1447
1448                         if (copy_from_user((void *)&mbuf, arg, sizeof(int)))
1449                                 return -EFAULT;
1450
1451                         Trace(TRACE_READ, "VIDIOCSYNC called (%d).\n", mbuf);
1452
1453                         /* bounds check */
1454                         if (mbuf < 0 || mbuf >= default_mbufs)
1455                                 return -EINVAL;
1456                         /* check if this buffer was requested anyway */
1457                         if (pdev->image_used[mbuf] == 0)
1458                                 return -EINVAL;
1459
1460                         /* Add ourselves to the frame wait-queue.
1461                            
1462                            FIXME: needs auditing for safety.
1463                            QUSTION: In what respect? I think that using the
1464                                     frameq is safe now.
1465                          */
1466                         add_wait_queue(&pdev->frameq, &wait);
1467                         while (pdev->full_frames == NULL) {
1468                                 if (signal_pending(current)) {
1469                                         remove_wait_queue(&pdev->frameq, &wait);
1470                                         current->state = TASK_RUNNING;
1471                                         return -ERESTARTSYS;
1472                                 }
1473                                 schedule();
1474                                 current->state = TASK_INTERRUPTIBLE;
1475                         }
1476                         remove_wait_queue(&pdev->frameq, &wait);
1477                         current->state = TASK_RUNNING;
1478                                 
1479                         /* The frame is ready. Expand in the image buffer 
1480                            requested by the user. I don't care if you 
1481                            mmap() 5 buffers and request data in this order: 
1482                            buffer 4 2 3 0 1 2 3 0 4 3 1 . . .
1483                            Grabber hardware may not be so forgiving.
1484                          */
1485                         Trace(TRACE_READ, "VIDIOCSYNC: frame ready.\n");
1486                         pdev->fill_image = mbuf; /* tell in which buffer we want the image to be expanded */
1487                         /* Decompress, etc */
1488                         ret = pwc_handle_frame(pdev);
1489                         pdev->image_used[mbuf] = 0;
1490                         if (ret)
1491                                 return -EFAULT;
1492                         break;
1493                 }
1494                 
1495                 case VIDIOCGAUDIO:
1496                 {
1497                         struct video_audio v;
1498                         
1499                         strcpy(v.name, "Microphone");
1500                         v.audio = -1; /* unknown audio minor */
1501                         v.flags = 0;
1502                         v.mode = VIDEO_SOUND_MONO;
1503                         v.volume = 0;
1504                         v.bass = 0;
1505                         v.treble = 0;
1506                         v.balance = 0x8000;
1507                         v.step = 1;
1508                         
1509                         if (copy_to_user(arg, &v, sizeof(v)))
1510                                 return -EFAULT;
1511                         break;  
1512                 }
1513                 
1514                 case VIDIOCSAUDIO:
1515                 {
1516                         struct video_audio v;
1517                         
1518                         if (copy_from_user(&v, arg, sizeof(v)))
1519                                 return -EFAULT;
1520                         /* Dummy: nothing can be set */
1521                         break;
1522                 }
1523                 
1524                 case VIDIOCGUNIT:
1525                 {
1526                         struct video_unit vu;
1527                         
1528                         vu.video = pdev->vdev->minor & 0x3F;
1529                         vu.audio = -1; /* not known yet */
1530                         vu.vbi = -1;
1531                         vu.radio = -1;
1532                         vu.teletext = -1;
1533                         if (copy_to_user(arg, &vu, sizeof(vu)))
1534                                 return -EFAULT;
1535                         break;
1536                 }
1537                 default:
1538                         return pwc_ioctl(pdev, cmd, arg);
1539         } /* ..switch */
1540         return 0;
1541 }       
1542
1543 static int pwc_video_mmap(struct video_device *vdev, const char *adr, unsigned long size)
1544 {
1545         struct pwc_device *pdev;
1546         unsigned long start = (unsigned long)adr;
1547         unsigned long page, pos;
1548         
1549         Trace(TRACE_READ, "mmap(0x%p, 0x%p, %lu) called.\n", vdev, adr, size);
1550         pdev = vdev->priv;
1551
1552         /* FIXME - audit mmap during a read */          
1553
1554         pos = (unsigned long)pdev->image_data;
1555         while (size > 0) {
1556                 page = kvirt_to_pa(pos);
1557                 if (remap_page_range(start, page, PAGE_SIZE, PAGE_SHARED))
1558                         return -EAGAIN;
1559
1560                 start += PAGE_SIZE;
1561                 pos += PAGE_SIZE;
1562                 if (size > PAGE_SIZE)
1563                         size -= PAGE_SIZE;
1564                 else
1565                         size = 0;
1566         }
1567
1568         return 0;
1569 }
1570
1571 /***************************************************************************/
1572 /* USB functions */
1573
1574 /* This function gets called when a new device is plugged in or the usb core
1575  * is loaded.
1576  */
1577
1578 static void *usb_pwc_probe(struct usb_device *udev, unsigned int ifnum, const struct usb_device_id *id)
1579 {
1580         struct pwc_device *pdev = NULL;
1581         struct video_device *vdev;
1582         int vendor_id, product_id, type_id;
1583         int i;
1584
1585         free_mem_leak();
1586         
1587         /* Check if we can handle this device */
1588         Trace(TRACE_PROBE, "probe() called [%04X %04X], if %d\n", udev->descriptor.idVendor, udev->descriptor.idProduct, ifnum);
1589
1590         /* the interfaces are probed one by one. We are only interested in the
1591            video interface (0) now.
1592            Interface 1 is the Audio Control, and interface 2 Audio itself.
1593          */
1594         if (ifnum > 0) 
1595                 return NULL;
1596
1597         vendor_id = udev->descriptor.idVendor;
1598         product_id = udev->descriptor.idProduct;
1599
1600         if (vendor_id == 0x0471) {
1601                 switch (product_id) {
1602                 case 0x0302:
1603                         Info("Philips PCA645VC USB webcam detected.\n");
1604                         type_id = 645;
1605                         break;
1606                 case 0x0303:
1607                         Info("Philips PCA646VC USB webcam detected.\n");
1608                         type_id = 646;
1609                         break;
1610                 case 0x0304:
1611                         Info("Askey VC010 type 2 USB webcam detected.\n");
1612                         type_id = 646;
1613                         break;
1614                 case 0x0307:
1615                         Info("Philips PCVC675K (Vesta) USB webcam detected.\n");
1616                         type_id = 675;
1617                         break;
1618                 case 0x0308:
1619                         Info("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1620                         type_id = 680;
1621                         break;
1622                 case 0x030C:
1623                         Info("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1624                         type_id = 690;
1625                         break;
1626                 case 0x0310:
1627                         Info("Philips PCVC730K (ToUCam Fun) USB webcam detected.\n");
1628                         type_id = 730;
1629                         break;
1630                 case 0x0311:
1631                         Info("Philips PCVC740K (ToUCam Pro) USB webcam detected.\n");
1632                         type_id = 740;
1633                         break;
1634                 case 0x0312:
1635                         Info("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1636                         type_id = 750;
1637                         break;
1638                 default:
1639                         return NULL;
1640                         break;
1641                 }
1642         }
1643         else if (vendor_id == 0x069A) {
1644                 switch(product_id) {
1645                 case 0x0001:
1646                         Info("Askey VC010 type 1 USB webcam detected.\n");
1647                         type_id = 645;
1648                         break;
1649                 default:
1650                         return NULL;
1651                         break;
1652                 }
1653         }
1654         else return NULL; /* Not Philips or Askey, for sure. */
1655
1656         if (udev->descriptor.bNumConfigurations > 1)
1657                 Info("Warning: more than 1 configuration available.\n");
1658
1659         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1660         pdev = kmalloc(sizeof(struct pwc_device), GFP_KERNEL);
1661         if (pdev == NULL) {
1662                 Err("Oops, could not allocate memory for pwc_device.\n");
1663                 return NULL;
1664         }
1665         memset(pdev, 0, sizeof(struct pwc_device));
1666         pdev->type = type_id;
1667         pwc_construct(pdev);
1668
1669         init_MUTEX(&pdev->modlock);
1670         pdev->ptrlock = SPIN_LOCK_UNLOCKED;
1671
1672         pdev->udev = udev;
1673         init_waitqueue_head(&pdev->frameq);
1674         init_waitqueue_head(&pdev->remove_ok);
1675         pdev->vcompression = pwc_preferred_compression;
1676
1677         /* Now hook it up to the video subsystem */
1678         vdev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1679         if (vdev == NULL) {
1680                 Err("Oops, could not allocate memory for video_device.\n");
1681                 return NULL;
1682         }
1683         memcpy(vdev, &pwc_template, sizeof(pwc_template));
1684         sprintf(vdev->name, "Philips %d webcam", pdev->type);
1685         SET_MODULE_OWNER(vdev);
1686         pdev->vdev = vdev;
1687         vdev->priv = pdev;
1688
1689         pdev->release = udev->descriptor.bcdDevice;
1690         Trace(TRACE_PROBE, "Release: %04x\n", pdev->release);
1691
1692         i = video_register_device(vdev, VFL_TYPE_GRABBER, video_nr);
1693         if (i < 0) {
1694                 Err("Failed to register as video device (%d).\n", i);
1695                 return NULL;
1696         }
1697         else {
1698                 Trace(TRACE_PROBE, "Registered video struct at 0x%p.\n", vdev);
1699                 Info("Registered as /dev/video%d.\n", vdev->minor & 0x3F);
1700         }
1701
1702 #if 0
1703         /* Shut down camera now (some people like the LED off) */
1704         if (power_save) {
1705                 Trace(TRACE_PROBE, "Powering down camera");
1706                 i = pwc_camera_power(pdev, 0);
1707                 if (i < 0)
1708                         Info("Failed to power-down the camera (%d)\n", i);
1709         }
1710 #endif
1711
1712         Trace(TRACE_PROBE, "probe() function returning struct at 0x%p.\n", pdev);
1713         return pdev;
1714 }
1715
1716 /* The user janked out the cable... */
1717 static void usb_pwc_disconnect(struct usb_device *udev, void *ptr)
1718 {
1719         struct pwc_device *pdev;
1720
1721         free_mem_leak();
1722
1723         pdev = (struct pwc_device *)ptr;
1724         if (pdev == NULL) {
1725                 Err("pwc_disconnect() Called without private pointer.\n");
1726                 return;
1727         }
1728         if (pdev->udev == NULL) {
1729                 Err("pwc_disconnect() already called for %p\n", pdev);
1730                 return;
1731         }
1732         if (pdev->udev != udev) {
1733                 Err("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1734                 return;
1735         }
1736 #ifdef PWC_MAGIC        
1737         if (pdev->magic != PWC_MAGIC) {
1738                 Err("pwc_disconnect() Magic number failed. Consult your scrolls and try again.\n");
1739                 return;
1740         }
1741 #endif  
1742         
1743         pdev->unplugged = 1;
1744         if (pdev->vdev != NULL) {
1745                 if (pdev->vopen) {
1746                         Info("Disconnected while device/video is open!\n");
1747                         
1748                         /* Wake up any processes that might be waiting for
1749                            a frame, let them return an error condition
1750                          */
1751                         wake_up(&pdev->frameq);
1752                         
1753                         /* Wait until we get a 'go' from _close(). This
1754                            had a gigantic race condition, since we kfree()
1755                            stuff here, but we have to wait until close() 
1756                            is finished. */
1757                            
1758                         Trace(TRACE_PROBE, "Sleeping on remove_ok.\n");
1759                         sleep_on(&pdev->remove_ok);
1760                         Trace(TRACE_PROBE, "Done sleeping.\n");
1761                         set_mem_leak(pdev->vdev);
1762                         pdev->vdev = NULL;
1763                 }
1764                 else {
1765                         /* Normal disconnect; remove from available devices */
1766                         Trace(TRACE_PROBE, "Unregistering video device normally.\n");
1767                         video_unregister_device(pdev->vdev); 
1768                         kfree(pdev->vdev);
1769                         pdev->vdev = NULL;
1770                 }
1771         }
1772         pdev->udev = NULL;
1773         kfree(pdev);
1774 }
1775
1776
1777
1778 /* 
1779  * Initialization code & module stuff 
1780  */
1781
1782 static char *size = NULL;
1783 static int fps = 0;
1784 static char *palette = NULL;
1785 static int fbufs = 0;
1786 static int mbufs = 0;
1787 static int trace = -1;
1788 static int compression = -1;
1789
1790 MODULE_PARM(video_nr, "i");
1791 MODULE_PARM(size, "s");
1792 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1793 MODULE_PARM(fps, "i");
1794 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1795 MODULE_PARM(palette, "s");
1796 MODULE_PARM_DESC(palette, "Initial colour format of images. One of yuv420, yuv420p");
1797 MODULE_PARM(fbufs, "i");
1798 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1799 MODULE_PARM(mbufs, "i");
1800 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1801 MODULE_PARM(trace, "i");
1802 MODULE_PARM_DESC(trace, "For debugging purposes");
1803 MODULE_PARM(power_save, "i");
1804 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1805 MODULE_PARM(compression, "i");
1806 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1807
1808 MODULE_DESCRIPTION("Philips USB webcam driver");
1809 MODULE_AUTHOR("Nemosoft Unv. <nemosoft@smcc.demon.nl>");
1810
1811 static int __init usb_pwc_init(void)
1812 {
1813         int s;
1814         char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1815
1816         Info("Philips PCA645/646 + PCVC675/680/690 + PCVC730/740/750 webcam module version " PWC_VERSION " loaded.\n");
1817         Info("Also supports Askey VC010 cam.\n");
1818
1819         if (fps) {
1820                 if (fps < 5 || fps > 30) {
1821                         Err("Framerate out of bounds (5-30).\n");
1822                         return -EINVAL;
1823                 }
1824                 default_fps = fps;
1825                 Info("Default framerate set to %d.\n", default_fps);
1826         }
1827         
1828         if (size) {
1829                 /* string; try matching with array */
1830                 for (s = 0; s < PSZ_MAX; s++) {
1831                         if (!strcmp(sizenames[s], size)) { /* Found! */
1832                                 default_size = s;
1833                                 break;
1834                         }
1835                 }
1836                 if (s == PSZ_MAX) {
1837                         Err("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1838                         return -EINVAL;
1839                 }
1840                 Info("Default image size set to %s [%dx%d].\n", sizenames[default_size], pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y);
1841         }
1842         if (palette) {
1843                 /* Determine default palette */
1844                 if (!strcmp(palette, "yuv420"))
1845                         default_palette = VIDEO_PALETTE_YUV420;
1846                 else if (!strcmp(palette, "yuv420p"))
1847                         default_palette = VIDEO_PALETTE_YUV420P;
1848                 else {
1849                         Err("Palette not recognized: try palette=yuv420 or yuv420p.\n");
1850                         Info("Download the driver from http://www.smcc.demon.nl/webcam/ for in kernel\n");
1851                         Info("format conversion support.\n");
1852                         return -EINVAL;
1853                 }
1854                 Info("Default palette set to %d.\n", default_palette);
1855         }
1856         if (mbufs) {
1857                 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1858                         Err("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
1859                         return -EINVAL;
1860                 }
1861                 default_mbufs = mbufs;
1862                 Info("Number of image buffers set to %d.\n", default_mbufs);
1863         }
1864         if (fbufs) {
1865                 if (fbufs < 2 || fbufs > MAX_FRAMES) {
1866                         Err("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
1867                         return -EINVAL;
1868                 }
1869                 default_fbufs = fbufs;
1870                 Info("Number of frame buffers set to %d.\n", default_fbufs);
1871         }
1872         if (trace >= 0) {
1873                 Info("Trace options: 0x%04x\n", trace);
1874                 pwc_trace = trace;
1875         }
1876         if (compression >= 0) {
1877                 if (compression > 3) {
1878                         Err("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1879                         return -EINVAL;
1880                 }
1881                 pwc_preferred_compression = compression;
1882                 Info("Preferred compression set to %d.\n", pwc_preferred_compression);
1883         }
1884         if (power_save)
1885                 Info("Enabling power save on open/close.\n");
1886
1887         init_MUTEX(&mem_lock);
1888         Trace(TRACE_PROBE, "Registering driver at address 0x%p.\n", &pwc_driver);
1889         return usb_register(&pwc_driver);
1890 }
1891
1892 static void __exit usb_pwc_exit(void)
1893 {
1894         free_mem_leak();
1895         Trace(TRACE_MODULE, "Deregistering driver.\n");
1896         usb_deregister(&pwc_driver);
1897         Info("Philips webcam module removed.\n");
1898 }
1899
1900 module_init(usb_pwc_init);
1901 module_exit(usb_pwc_exit);
1902