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