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