V4L/DVB (5166): Remove obsolete alias defines of CONFIG_* settings
[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) }, /* Logitech (reserved) */
99         { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech (reserved) */
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 = 720;
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                 case 0x08b7:
1551                 case 0x08b8:
1552                         PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1553                         name = "Logitech QuickCam (res.)";
1554                         type_id = 730; /* Assuming CMOS */
1555                         break;
1556                 default:
1557                         return -ENODEV;
1558                         break;
1559                 }
1560         }
1561         else if (vendor_id == 0x055d) {
1562                 /* I don't know the difference between the C10 and the C30;
1563                    I suppose the difference is the sensor, but both cameras
1564                    work equally well with a type_id of 675
1565                  */
1566                 switch(product_id) {
1567                 case 0x9000:
1568                         PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1569                         name = "Samsung MPC-C10";
1570                         type_id = 675;
1571                         break;
1572                 case 0x9001:
1573                         PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1574                         name = "Samsung MPC-C30";
1575                         type_id = 675;
1576                         break;
1577                 case 0x9002:
1578                         PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1579                         name = "Samsung MPC-C30";
1580                         type_id = 740;
1581                         break;
1582                 default:
1583                         return -ENODEV;
1584                         break;
1585                 }
1586         }
1587         else if (vendor_id == 0x041e) {
1588                 switch(product_id) {
1589                 case 0x400c:
1590                         PWC_INFO("Creative Labs Webcam 5 detected.\n");
1591                         name = "Creative Labs Webcam 5";
1592                         type_id = 730;
1593                         break;
1594                 case 0x4011:
1595                         PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1596                         name = "Creative Labs Webcam Pro Ex";
1597                         type_id = 740;
1598                         break;
1599                 default:
1600                         return -ENODEV;
1601                         break;
1602                 }
1603         }
1604         else if (vendor_id == 0x04cc) {
1605                 switch(product_id) {
1606                 case 0x8116:
1607                         PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1608                         name = "Sotec Afina Eye";
1609                         type_id = 730;
1610                         break;
1611                 default:
1612                         return -ENODEV;
1613                         break;
1614                 }
1615         }
1616         else if (vendor_id == 0x06be) {
1617                 switch(product_id) {
1618                 case 0x8116:
1619                         /* This is essentially the same cam as the Sotec Afina Eye */
1620                         PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1621                         name = "AME Co. Afina Eye";
1622                         type_id = 750;
1623                         break;
1624                 default:
1625                         return -ENODEV;
1626                         break;
1627                 }
1628
1629         }
1630         else if (vendor_id == 0x0d81) {
1631                 switch(product_id) {
1632                 case 0x1900:
1633                         PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1634                         name = "Visionite VCS-UC300";
1635                         type_id = 740; /* CCD sensor */
1636                         break;
1637                 case 0x1910:
1638                         PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1639                         name = "Visionite VCS-UM100";
1640                         type_id = 730; /* CMOS sensor */
1641                         break;
1642                 default:
1643                         return -ENODEV;
1644                         break;
1645                 }
1646         }
1647         else
1648                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1649
1650         memset(serial_number, 0, 30);
1651         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1652         PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1653
1654         if (udev->descriptor.bNumConfigurations > 1)
1655                 PWC_WARNING("Warning: more than 1 configuration available.\n");
1656
1657         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1658         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1659         if (pdev == NULL) {
1660                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1661                 return -ENOMEM;
1662         }
1663         pdev->type = type_id;
1664         pdev->vsize = default_size;
1665         pdev->vframes = default_fps;
1666         strcpy(pdev->serial, serial_number);
1667         pdev->features = features;
1668         if (vendor_id == 0x046D && product_id == 0x08B5)
1669         {
1670                 /* Logitech QuickCam Orbit
1671                    The ranges have been determined experimentally; they may differ from cam to cam.
1672                    Also, the exact ranges left-right and up-down are different for my cam
1673                   */
1674                 pdev->angle_range.pan_min  = -7000;
1675                 pdev->angle_range.pan_max  =  7000;
1676                 pdev->angle_range.tilt_min = -3000;
1677                 pdev->angle_range.tilt_max =  2500;
1678         }
1679
1680         init_MUTEX(&pdev->modlock);
1681         spin_lock_init(&pdev->ptrlock);
1682
1683         pdev->udev = udev;
1684         init_waitqueue_head(&pdev->frameq);
1685         pdev->vcompression = pwc_preferred_compression;
1686
1687         /* Allocate video_device structure */
1688         pdev->vdev = video_device_alloc();
1689         if (pdev->vdev == 0)
1690         {
1691                 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
1692                 kfree(pdev);
1693                 return -ENOMEM;
1694         }
1695         memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
1696         pdev->vdev->dev = &(udev->dev);
1697         strcpy(pdev->vdev->name, name);
1698         pdev->vdev->owner = THIS_MODULE;
1699         video_set_drvdata(pdev->vdev, pdev);
1700
1701         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1702         PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1703
1704         /* Now search device_hint[] table for a match, so we can hint a node number. */
1705         for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1706                 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1707                      (device_hint[hint].pdev == NULL)) {
1708                         /* so far, so good... try serial number */
1709                         if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1710                                 /* match! */
1711                                 video_nr = device_hint[hint].device_node;
1712                                 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1713                                 break;
1714                         }
1715                 }
1716         }
1717
1718         pdev->vdev->release = video_device_release;
1719         i = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1720         if (i < 0) {
1721                 PWC_ERROR("Failed to register as video device (%d).\n", i);
1722                 rc = i;
1723                 goto err;
1724         }
1725         else {
1726                 PWC_INFO("Registered as /dev/video%d.\n", pdev->vdev->minor & 0x3F);
1727         }
1728
1729         /* occupy slot */
1730         if (hint < MAX_DEV_HINTS)
1731                 device_hint[hint].pdev = pdev;
1732
1733         PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1734         usb_set_intfdata (intf, pdev);
1735         rc = pwc_create_sysfs_files(pdev->vdev);
1736         if (rc)
1737                 goto err_unreg;
1738
1739         /* Set the leds off */
1740         pwc_set_leds(pdev, 0, 0);
1741         pwc_camera_power(pdev, 0);
1742
1743         return 0;
1744
1745 err_unreg:
1746         if (hint < MAX_DEV_HINTS)
1747                 device_hint[hint].pdev = NULL;
1748         video_unregister_device(pdev->vdev);
1749 err:
1750         video_device_release(pdev->vdev); /* Drip... drip... drip... */
1751         kfree(pdev); /* Oops, no memory leaks please */
1752         return rc;
1753 }
1754
1755 /* The user janked out the cable... */
1756 static void usb_pwc_disconnect(struct usb_interface *intf)
1757 {
1758         struct pwc_device *pdev;
1759         int hint;
1760
1761         lock_kernel();
1762         pdev = usb_get_intfdata (intf);
1763         usb_set_intfdata (intf, NULL);
1764         if (pdev == NULL) {
1765                 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1766                 goto disconnect_out;
1767         }
1768         if (pdev->udev == NULL) {
1769                 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1770                 goto disconnect_out;
1771         }
1772         if (pdev->udev != interface_to_usbdev(intf)) {
1773                 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1774                 goto disconnect_out;
1775         }
1776
1777         /* We got unplugged; this is signalled by an EPIPE error code */
1778         if (pdev->vopen) {
1779                 PWC_INFO("Disconnected while webcam is in use!\n");
1780                 pdev->error_status = EPIPE;
1781         }
1782
1783         /* Alert waiting processes */
1784         wake_up_interruptible(&pdev->frameq);
1785         /* Wait until device is closed */
1786         while (pdev->vopen)
1787                 schedule();
1788         /* Device is now closed, so we can safely unregister it */
1789         PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
1790         pwc_remove_sysfs_files(pdev->vdev);
1791         video_unregister_device(pdev->vdev);
1792
1793         /* Free memory (don't set pdev to 0 just yet) */
1794         kfree(pdev);
1795
1796 disconnect_out:
1797         /* search device_hint[] table if we occupy a slot, by any chance */
1798         for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1799                 if (device_hint[hint].pdev == pdev)
1800                         device_hint[hint].pdev = NULL;
1801
1802         unlock_kernel();
1803 }
1804
1805
1806 /* *grunt* We have to do atoi ourselves :-( */
1807 static int pwc_atoi(const char *s)
1808 {
1809         int k = 0;
1810
1811         k = 0;
1812         while (*s != '\0' && *s >= '0' && *s <= '9') {
1813                 k = 10 * k + (*s - '0');
1814                 s++;
1815         }
1816         return k;
1817 }
1818
1819
1820 /*
1821  * Initialization code & module stuff
1822  */
1823
1824 static char *size;
1825 static int fps;
1826 static int fbufs;
1827 static int mbufs;
1828 static int compression = -1;
1829 static int leds[2] = { -1, -1 };
1830 static int leds_nargs;
1831 static char *dev_hint[MAX_DEV_HINTS];
1832 static int dev_hint_nargs;
1833
1834 module_param(size, charp, 0444);
1835 module_param(fps, int, 0444);
1836 module_param(fbufs, int, 0444);
1837 module_param(mbufs, int, 0444);
1838 #ifdef CONFIG_USB_PWC_DEBUG
1839 module_param_named(trace, pwc_trace, int, 0644);
1840 #endif
1841 module_param(power_save, int, 0444);
1842 module_param(compression, int, 0444);
1843 module_param_array(leds, int, &leds_nargs, 0444);
1844 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1845
1846 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1847 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1848 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1849 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1850 MODULE_PARM_DESC(trace, "For debugging purposes");
1851 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1852 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1853 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1854 MODULE_PARM_DESC(dev_hint, "Device node hints");
1855
1856 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1857 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1858 MODULE_LICENSE("GPL");
1859 MODULE_ALIAS("pwcx");
1860 MODULE_VERSION( PWC_VERSION );
1861
1862 static int __init usb_pwc_init(void)
1863 {
1864         int i, sz;
1865         char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1866
1867         PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1868         PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1869         PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1870         PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1871
1872         if (fps) {
1873                 if (fps < 4 || fps > 30) {
1874                         PWC_ERROR("Framerate out of bounds (4-30).\n");
1875                         return -EINVAL;
1876                 }
1877                 default_fps = fps;
1878                 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1879         }
1880
1881         if (size) {
1882                 /* string; try matching with array */
1883                 for (sz = 0; sz < PSZ_MAX; sz++) {
1884                         if (!strcmp(sizenames[sz], size)) { /* Found! */
1885                                 default_size = sz;
1886                                 break;
1887                         }
1888                 }
1889                 if (sz == PSZ_MAX) {
1890                         PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1891                         return -EINVAL;
1892                 }
1893                 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);
1894         }
1895         if (mbufs) {
1896                 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1897                         PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
1898                         return -EINVAL;
1899                 }
1900                 pwc_mbufs = mbufs;
1901                 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
1902         }
1903         if (fbufs) {
1904                 if (fbufs < 2 || fbufs > MAX_FRAMES) {
1905                         PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
1906                         return -EINVAL;
1907                 }
1908                 default_fbufs = fbufs;
1909                 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
1910         }
1911 #ifdef CONFIG_USB_PWC_DEBUG
1912         if (pwc_trace >= 0) {
1913                 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1914         }
1915 #endif
1916         if (compression >= 0) {
1917                 if (compression > 3) {
1918                         PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1919                         return -EINVAL;
1920                 }
1921                 pwc_preferred_compression = compression;
1922                 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
1923         }
1924         if (power_save)
1925                 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
1926         if (leds[0] >= 0)
1927                 led_on = leds[0];
1928         if (leds[1] >= 0)
1929                 led_off = leds[1];
1930
1931         /* Big device node whoopla. Basically, it allows you to assign a
1932            device node (/dev/videoX) to a camera, based on its type
1933            & serial number. The format is [type[.serialnumber]:]node.
1934
1935            Any camera that isn't matched by these rules gets the next
1936            available free device node.
1937          */
1938         for (i = 0; i < MAX_DEV_HINTS; i++) {
1939                 char *s, *colon, *dot;
1940
1941                 /* This loop also initializes the array */
1942                 device_hint[i].pdev = NULL;
1943                 s = dev_hint[i];
1944                 if (s != NULL && *s != '\0') {
1945                         device_hint[i].type = -1; /* wildcard */
1946                         strcpy(device_hint[i].serial_number, "*");
1947
1948                         /* parse string: chop at ':' & '/' */
1949                         colon = dot = s;
1950                         while (*colon != '\0' && *colon != ':')
1951                                 colon++;
1952                         while (*dot != '\0' && *dot != '.')
1953                                 dot++;
1954                         /* Few sanity checks */
1955                         if (*dot != '\0' && dot > colon) {
1956                                 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
1957                                 return -EINVAL;
1958                         }
1959
1960                         if (*colon == '\0') {
1961                                 /* No colon */
1962                                 if (*dot != '\0') {
1963                                         PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
1964                                         return -EINVAL;
1965                                 }
1966                                 else {
1967                                         /* No type or serial number specified, just a number. */
1968                                         device_hint[i].device_node = pwc_atoi(s);
1969                                 }
1970                         }
1971                         else {
1972                                 /* There's a colon, so we have at least a type and a device node */
1973                                 device_hint[i].type = pwc_atoi(s);
1974                                 device_hint[i].device_node = pwc_atoi(colon + 1);
1975                                 if (*dot != '\0') {
1976                                         /* There's a serial number as well */
1977                                         int k;
1978
1979                                         dot++;
1980                                         k = 0;
1981                                         while (*dot != ':' && k < 29) {
1982                                                 device_hint[i].serial_number[k++] = *dot;
1983                                                 dot++;
1984                                         }
1985                                         device_hint[i].serial_number[k] = '\0';
1986                                 }
1987                         }
1988                         PWC_TRACE("device_hint[%d]:\n", i);
1989                         PWC_TRACE("  type    : %d\n", device_hint[i].type);
1990                         PWC_TRACE("  serial# : %s\n", device_hint[i].serial_number);
1991                         PWC_TRACE("  node    : %d\n", device_hint[i].device_node);
1992                 }
1993                 else
1994                         device_hint[i].type = 0; /* not filled */
1995         } /* ..for MAX_DEV_HINTS */
1996
1997         PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
1998         return usb_register(&pwc_driver);
1999 }
2000
2001 static void __exit usb_pwc_exit(void)
2002 {
2003         PWC_DEBUG_MODULE("Deregistering driver.\n");
2004         usb_deregister(&pwc_driver);
2005         PWC_INFO("Philips webcam module removed.\n");
2006 }
2007
2008 module_init(usb_pwc_init);
2009 module_exit(usb_pwc_exit);
2010
2011 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */