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