Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/agpgart
[linux-2.6] / drivers / media / video / pwc / pwc-if.c
1 /* Linux driver for Philips webcam
2    USB and Video4Linux interface part.
3    (C) 1999-2004 Nemosoft Unv.
4    (C) 2004-2006 Luc Saillard (luc@saillard.org)
5
6    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
7    driver and thus may have bugs that are not present in the original version.
8    Please send bug reports and support requests to <luc@saillard.org>.
9    The decompression routines have been implemented by reverse-engineering the
10    Nemosoft binary pwcx module. Caveat emptor.
11
12    This program is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 2 of the License, or
15    (at your option) any later version.
16
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21
22    You should have received a copy of the GNU General Public License
23    along with this program; if not, write to the Free Software
24    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25
26 */
27
28 /*
29    This code forms the interface between the USB layers and the Philips
30    specific stuff. Some adanved stuff of the driver falls under an
31    NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
32    is thus not distributed in source form. The binary pwcx.o module
33    contains the code that falls under the NDA.
34
35    In case you're wondering: 'pwc' stands for "Philips WebCam", but
36    I really didn't want to type 'philips_web_cam' every time (I'm lazy as
37    any Linux kernel hacker, but I don't like uncomprehensible abbreviations
38    without explanation).
39
40    Oh yes, convention: to disctinguish between all the various pointers to
41    device-structures, I use these names for the pointer variables:
42    udev: struct usb_device *
43    vdev: struct video_device *
44    pdev: struct pwc_devive *
45 */
46
47 /* Contributors:
48    - Alvarado: adding whitebalance code
49    - Alistar Moire: QuickCam 3000 Pro device/product ID
50    - Tony Hoyle: Creative Labs Webcam 5 device/product ID
51    - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
52    - Jk Fang: Sotec Afina Eye ID
53    - Xavier Roche: QuickCam Pro 4000 ID
54    - Jens Knudsen: QuickCam Zoom ID
55    - J. Debert: QuickCam for Notebooks ID
56 */
57
58 #include <linux/errno.h>
59 #include <linux/init.h>
60 #include <linux/mm.h>
61 #include <linux/module.h>
62 #include <linux/poll.h>
63 #include <linux/slab.h>
64 #include <linux/vmalloc.h>
65 #include <linux/version.h>
66 #include <asm/io.h>
67 #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 #if CONFIG_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 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 >= 0) {
870                         if (pdev->sbuf[i].urb != NULL)
871                                 usb_free_urb(pdev->sbuf[i].urb);
872                         pdev->sbuf[i].urb = NULL;
873                         i--;
874                 }
875                 return ret;
876         }
877
878         /* init URB structure */
879         for (i = 0; i < MAX_ISO_BUFS; i++) {
880                 urb = pdev->sbuf[i].urb;
881
882                 urb->interval = 1; // devik
883                 urb->dev = udev;
884                 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
885                 urb->transfer_flags = URB_ISO_ASAP;
886                 urb->transfer_buffer = pdev->sbuf[i].data;
887                 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
888                 urb->complete = pwc_isoc_handler;
889                 urb->context = pdev;
890                 urb->start_frame = 0;
891                 urb->number_of_packets = ISO_FRAMES_PER_DESC;
892                 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
893                         urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
894                         urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
895                 }
896         }
897
898         /* link */
899         for (i = 0; i < MAX_ISO_BUFS; i++) {
900                 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL);
901                 if (ret)
902                         PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
903                 else
904                         PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->sbuf[i].urb);
905         }
906
907         /* All is done... */
908         pdev->iso_init = 1;
909         PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
910         return 0;
911 }
912
913 void pwc_isoc_cleanup(struct pwc_device *pdev)
914 {
915         int i;
916
917         PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
918         if (pdev == NULL)
919                 return;
920         if (pdev->iso_init == 0)
921                 return;
922
923         /* Unlinking ISOC buffers one by one */
924         for (i = 0; i < MAX_ISO_BUFS; i++) {
925                 struct urb *urb;
926
927                 urb = pdev->sbuf[i].urb;
928                 if (urb != 0) {
929                         if (pdev->iso_init) {
930                                 PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb);
931                                 usb_kill_urb(urb);
932                         }
933                         PWC_DEBUG_MEMORY("Freeing URB\n");
934                         usb_free_urb(urb);
935                         pdev->sbuf[i].urb = NULL;
936                 }
937         }
938
939         /* Stop camera, but only if we are sure the camera is still there (unplug
940            is signalled by EPIPE)
941          */
942         if (pdev->error_status && pdev->error_status != EPIPE) {
943                 PWC_DEBUG_OPEN("Setting alternate interface 0.\n");
944                 usb_set_interface(pdev->udev, 0, 0);
945         }
946
947         pdev->iso_init = 0;
948         PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
949 }
950
951 int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot)
952 {
953         int ret, start;
954
955         /* Stop isoc stuff */
956         pwc_isoc_cleanup(pdev);
957         /* Reset parameters */
958         pwc_reset_buffers(pdev);
959         /* Try to set video mode... */
960         start = ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot);
961         if (ret) {
962                 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 1 failed.\n");
963                 /* That failed... restore old mode (we know that worked) */
964                 start = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
965                 if (start) {
966                         PWC_DEBUG_FLOW("pwc_set_video_mode attempt 2 failed.\n");
967                 }
968         }
969         if (start == 0)
970         {
971                 if (pwc_isoc_init(pdev) < 0)
972                 {
973                         PWC_WARNING("Failed to restart ISOC transfers in pwc_try_video_mode.\n");
974                         ret = -EAGAIN; /* let's try again, who knows if it works a second time */
975                 }
976         }
977         pdev->drop_frames++; /* try to avoid garbage during switch */
978         return ret; /* Return original error code */
979 }
980
981 /*********
982  * sysfs
983  *********/
984 static struct pwc_device *cd_to_pwc(struct class_device *cd)
985 {
986         struct video_device *vdev = to_video_device(cd);
987         return video_get_drvdata(vdev);
988 }
989
990 static ssize_t show_pan_tilt(struct class_device *class_dev, char *buf)
991 {
992         struct pwc_device *pdev = cd_to_pwc(class_dev);
993         return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
994 }
995
996 static ssize_t store_pan_tilt(struct class_device *class_dev, const char *buf,
997                          size_t count)
998 {
999         struct pwc_device *pdev = cd_to_pwc(class_dev);
1000         int pan, tilt;
1001         int ret = -EINVAL;
1002
1003         if (strncmp(buf, "reset", 5) == 0)
1004                 ret = pwc_mpt_reset(pdev, 0x3);
1005
1006         else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
1007                 ret = pwc_mpt_set_angle(pdev, pan, tilt);
1008
1009         if (ret < 0)
1010                 return ret;
1011         return strlen(buf);
1012 }
1013 static CLASS_DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
1014                          store_pan_tilt);
1015
1016 static ssize_t show_snapshot_button_status(struct class_device *class_dev, char *buf)
1017 {
1018         struct pwc_device *pdev = cd_to_pwc(class_dev);
1019         int status = pdev->snapshot_button_status;
1020         pdev->snapshot_button_status = 0;
1021         return sprintf(buf, "%d\n", status);
1022 }
1023
1024 static CLASS_DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
1025                          NULL);
1026
1027 static int pwc_create_sysfs_files(struct video_device *vdev)
1028 {
1029         struct pwc_device *pdev = video_get_drvdata(vdev);
1030         int rc;
1031
1032         rc = video_device_create_file(vdev, &class_device_attr_button);
1033         if (rc)
1034                 goto err;
1035         if (pdev->features & FEATURE_MOTOR_PANTILT) {
1036                 rc = video_device_create_file(vdev,&class_device_attr_pan_tilt);
1037                 if (rc) goto err_button;
1038         }
1039
1040         return 0;
1041
1042 err_button:
1043         video_device_remove_file(vdev, &class_device_attr_button);
1044 err:
1045         return rc;
1046 }
1047
1048 static void pwc_remove_sysfs_files(struct video_device *vdev)
1049 {
1050         struct pwc_device *pdev = video_get_drvdata(vdev);
1051         if (pdev->features & FEATURE_MOTOR_PANTILT)
1052                 video_device_remove_file(vdev, &class_device_attr_pan_tilt);
1053         video_device_remove_file(vdev, &class_device_attr_button);
1054 }
1055
1056 #if CONFIG_PWC_DEBUG
1057 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
1058 {
1059         switch(sensor_type) {
1060                 case 0x00:
1061                         return "Hyundai CMOS sensor";
1062                 case 0x20:
1063                         return "Sony CCD sensor + TDA8787";
1064                 case 0x2E:
1065                         return "Sony CCD sensor + Exas 98L59";
1066                 case 0x2F:
1067                         return "Sony CCD sensor + ADI 9804";
1068                 case 0x30:
1069                         return "Sharp CCD sensor + TDA8787";
1070                 case 0x3E:
1071                         return "Sharp CCD sensor + Exas 98L59";
1072                 case 0x3F:
1073                         return "Sharp CCD sensor + ADI 9804";
1074                 case 0x40:
1075                         return "UPA 1021 sensor";
1076                 case 0x100:
1077                         return "VGA sensor";
1078                 case 0x101:
1079                         return "PAL MR sensor";
1080                 default:
1081                         return "unknown type of sensor";
1082         }
1083 }
1084 #endif
1085
1086 /***************************************************************************/
1087 /* Video4Linux functions */
1088
1089 static int pwc_video_open(struct inode *inode, struct file *file)
1090 {
1091         int i, ret;
1092         struct video_device *vdev = video_devdata(file);
1093         struct pwc_device *pdev;
1094
1095         PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
1096
1097         pdev = (struct pwc_device *)vdev->priv;
1098         if (pdev == NULL)
1099                 BUG();
1100         if (pdev->vopen) {
1101                 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1102                 return -EBUSY;
1103         }
1104
1105         down(&pdev->modlock);
1106         if (!pdev->usb_init) {
1107                 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1108                 pdev->usb_init = 1;
1109
1110                 /* Query sensor type */
1111                 ret = pwc_get_cmos_sensor(pdev, &i);
1112                 if (ret >= 0)
1113                 {
1114                         PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1115                                         pdev->vdev->name,
1116                                         pwc_sensor_type_to_string(i), i);
1117                 }
1118         }
1119
1120         /* Turn on camera */
1121         if (power_save) {
1122                 i = pwc_camera_power(pdev, 1);
1123                 if (i < 0)
1124                         PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
1125         }
1126         /* Set LED on/off time */
1127         if (pwc_set_leds(pdev, led_on, led_off) < 0)
1128                 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1129
1130         pwc_construct(pdev); /* set min/max sizes correct */
1131
1132         /* So far, so good. Allocate memory. */
1133         i = pwc_allocate_buffers(pdev);
1134         if (i < 0) {
1135                 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1136                 pwc_free_buffers(pdev);
1137                 up(&pdev->modlock);
1138                 return i;
1139         }
1140
1141         /* Reset buffers & parameters */
1142         pwc_reset_buffers(pdev);
1143         for (i = 0; i < pwc_mbufs; i++)
1144                 pdev->image_used[i] = 0;
1145         pdev->vframe_count = 0;
1146         pdev->vframes_dumped = 0;
1147         pdev->vframes_error = 0;
1148         pdev->visoc_errors = 0;
1149         pdev->error_status = 0;
1150         pwc_construct(pdev); /* set min/max sizes correct */
1151
1152         /* Set some defaults */
1153         pdev->vsnapshot = 0;
1154
1155         /* Start iso pipe for video; first try the last used video size
1156            (or the default one); if that fails try QCIF/10 or QSIF/10;
1157            it that fails too, give up.
1158          */
1159         i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1160         if (i)  {
1161                 unsigned int default_resolution;
1162                 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1163                 if (pdev->type>= 730)
1164                         default_resolution = PSZ_QSIF;
1165                 else
1166                         default_resolution = PSZ_QCIF;
1167
1168                 i = pwc_set_video_mode(pdev,
1169                                        pwc_image_sizes[default_resolution].x,
1170                                        pwc_image_sizes[default_resolution].y,
1171                                        10,
1172                                        pdev->vcompression,
1173                                        0);
1174         }
1175         if (i) {
1176                 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1177                 pwc_free_buffers(pdev);
1178                 up(&pdev->modlock);
1179                 return i;
1180         }
1181
1182         i = pwc_isoc_init(pdev);
1183         if (i) {
1184                 PWC_DEBUG_OPEN("Failed to init ISOC stuff = %d.\n", i);
1185                 pwc_isoc_cleanup(pdev);
1186                 pwc_free_buffers(pdev);
1187                 up(&pdev->modlock);
1188                 return i;
1189         }
1190
1191         /* Initialize the webcam to sane value */
1192         pwc_set_brightness(pdev, 0x7fff);
1193         pwc_set_agc(pdev, 1, 0);
1194
1195         pdev->vopen++;
1196         file->private_data = vdev;
1197         up(&pdev->modlock);
1198         PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1199         return 0;
1200 }
1201
1202 /* Note that all cleanup is done in the reverse order as in _open */
1203 static int pwc_video_close(struct inode *inode, struct file *file)
1204 {
1205         struct video_device *vdev = file->private_data;
1206         struct pwc_device *pdev;
1207         int i;
1208
1209         PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
1210
1211         pdev = (struct pwc_device *)vdev->priv;
1212         if (pdev->vopen == 0)
1213                 PWC_DEBUG_MODULE("video_close() called on closed device?\n");
1214
1215         /* Dump statistics, but only if a reasonable amount of frames were
1216            processed (to prevent endless log-entries in case of snap-shot
1217            programs)
1218          */
1219         if (pdev->vframe_count > 20)
1220                 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);
1221
1222         if (DEVICE_USE_CODEC1(pdev->type))
1223             pwc_dec1_exit();
1224         else
1225             pwc_dec23_exit();
1226
1227         pwc_isoc_cleanup(pdev);
1228         pwc_free_buffers(pdev);
1229
1230         /* Turn off LEDS and power down camera, but only when not unplugged */
1231         if (pdev->error_status != EPIPE) {
1232                 /* Turn LEDs off */
1233                 if (pwc_set_leds(pdev, 0, 0) < 0)
1234                         PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
1235                 if (power_save) {
1236                         i = pwc_camera_power(pdev, 0);
1237                         if (i < 0)
1238                                 PWC_ERROR("Failed to power down camera (%d)\n", i);
1239                 }
1240         }
1241         pdev->vopen--;
1242         PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
1243         return 0;
1244 }
1245
1246 /*
1247  *      FIXME: what about two parallel reads ????
1248  *      ANSWER: Not supported. You can't open the device more than once,
1249                 despite what the V4L1 interface says. First, I don't see
1250                 the need, second there's no mechanism of alerting the
1251                 2nd/3rd/... process of events like changing image size.
1252                 And I don't see the point of blocking that for the
1253                 2nd/3rd/... process.
1254                 In multi-threaded environments reading parallel from any
1255                 device is tricky anyhow.
1256  */
1257
1258 static ssize_t pwc_video_read(struct file *file, char __user *buf,
1259                           size_t count, loff_t *ppos)
1260 {
1261         struct video_device *vdev = file->private_data;
1262         struct pwc_device *pdev;
1263         int noblock = file->f_flags & O_NONBLOCK;
1264         DECLARE_WAITQUEUE(wait, current);
1265         int bytes_to_read;
1266         void *image_buffer_addr;
1267
1268         PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1269                         vdev, buf, count);
1270         if (vdev == NULL)
1271                 return -EFAULT;
1272         pdev = vdev->priv;
1273         if (pdev == NULL)
1274                 return -EFAULT;
1275         if (pdev->error_status)
1276                 return -pdev->error_status; /* Something happened, report what. */
1277
1278         /* In case we're doing partial reads, we don't have to wait for a frame */
1279         if (pdev->image_read_pos == 0) {
1280                 /* Do wait queueing according to the (doc)book */
1281                 add_wait_queue(&pdev->frameq, &wait);
1282                 while (pdev->full_frames == NULL) {
1283                         /* Check for unplugged/etc. here */
1284                         if (pdev->error_status) {
1285                                 remove_wait_queue(&pdev->frameq, &wait);
1286                                 set_current_state(TASK_RUNNING);
1287                                 return -pdev->error_status ;
1288                         }
1289                         if (noblock) {
1290                                 remove_wait_queue(&pdev->frameq, &wait);
1291                                 set_current_state(TASK_RUNNING);
1292                                 return -EWOULDBLOCK;
1293                         }
1294                         if (signal_pending(current)) {
1295                                 remove_wait_queue(&pdev->frameq, &wait);
1296                                 set_current_state(TASK_RUNNING);
1297                                 return -ERESTARTSYS;
1298                         }
1299                         schedule();
1300                         set_current_state(TASK_INTERRUPTIBLE);
1301                 }
1302                 remove_wait_queue(&pdev->frameq, &wait);
1303                 set_current_state(TASK_RUNNING);
1304
1305                 /* Decompress and release frame */
1306                 if (pwc_handle_frame(pdev))
1307                         return -EFAULT;
1308         }
1309
1310         PWC_DEBUG_READ("Copying data to user space.\n");
1311         if (pdev->vpalette == VIDEO_PALETTE_RAW)
1312                 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1313         else
1314                 bytes_to_read = pdev->view.size;
1315
1316         /* copy bytes to user space; we allow for partial reads */
1317         if (count + pdev->image_read_pos > bytes_to_read)
1318                 count = bytes_to_read - pdev->image_read_pos;
1319         image_buffer_addr = pdev->image_data;
1320         image_buffer_addr += pdev->images[pdev->fill_image].offset;
1321         image_buffer_addr += pdev->image_read_pos;
1322         if (copy_to_user(buf, image_buffer_addr, count))
1323                 return -EFAULT;
1324         pdev->image_read_pos += count;
1325         if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
1326                 pdev->image_read_pos = 0;
1327                 pwc_next_image(pdev);
1328         }
1329         return count;
1330 }
1331
1332 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1333 {
1334         struct video_device *vdev = file->private_data;
1335         struct pwc_device *pdev;
1336
1337         if (vdev == NULL)
1338                 return -EFAULT;
1339         pdev = vdev->priv;
1340         if (pdev == NULL)
1341                 return -EFAULT;
1342
1343         poll_wait(file, &pdev->frameq, wait);
1344         if (pdev->error_status)
1345                 return POLLERR;
1346         if (pdev->full_frames != NULL) /* we have frames waiting */
1347                 return (POLLIN | POLLRDNORM);
1348
1349         return 0;
1350 }
1351
1352 static int pwc_video_ioctl(struct inode *inode, struct file *file,
1353                            unsigned int cmd, unsigned long arg)
1354 {
1355         return video_usercopy(inode, file, cmd, arg, pwc_video_do_ioctl);
1356 }
1357
1358 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1359 {
1360         struct video_device *vdev = file->private_data;
1361         struct pwc_device *pdev;
1362         unsigned long start;
1363         unsigned long size;
1364         unsigned long page, pos = 0;
1365         int index;
1366
1367         PWC_DEBUG_MEMORY(">> %s\n", __FUNCTION__);
1368         pdev = vdev->priv;
1369         size = vma->vm_end - vma->vm_start;
1370         start = vma->vm_start;
1371
1372         /* Find the idx buffer for this mapping */
1373         for (index = 0; index < pwc_mbufs; index++) {
1374                 pos = pdev->images[index].offset;
1375                 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1376                         break;
1377         }
1378         if (index == MAX_IMAGES)
1379                 return -EINVAL;
1380         if (index == 0) {
1381                 /*
1382                  * Special case for v4l1. In v4l1, we map only one big buffer,
1383                  * but in v4l2 each buffer is mapped
1384                  */
1385                 unsigned long total_size;
1386                 total_size = pwc_mbufs * pdev->len_per_image;
1387                 if (size != pdev->len_per_image && size != total_size) {
1388                         PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1389                                    size, pdev->len_per_image, total_size);
1390                         return -EINVAL;
1391                 }
1392         } else if (size > pdev->len_per_image)
1393                 return -EINVAL;
1394
1395         vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
1396
1397         pos += (unsigned long)pdev->image_data;
1398         while (size > 0) {
1399                 page = vmalloc_to_pfn((void *)pos);
1400                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1401                         return -EAGAIN;
1402                 start += PAGE_SIZE;
1403                 pos += PAGE_SIZE;
1404                 if (size > PAGE_SIZE)
1405                         size -= PAGE_SIZE;
1406                 else
1407                         size = 0;
1408         }
1409         return 0;
1410 }
1411
1412 /***************************************************************************/
1413 /* USB functions */
1414
1415 /* This function gets called when a new device is plugged in or the usb core
1416  * is loaded.
1417  */
1418
1419 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1420 {
1421         struct usb_device *udev = interface_to_usbdev(intf);
1422         struct pwc_device *pdev = NULL;
1423         int vendor_id, product_id, type_id;
1424         int i, hint, rc;
1425         int features = 0;
1426         int video_nr = -1; /* default: use next available device */
1427         char serial_number[30], *name;
1428
1429         vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1430         product_id = le16_to_cpu(udev->descriptor.idProduct);
1431
1432         /* Check if we can handle this device */
1433         PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1434                 vendor_id, product_id,
1435                 intf->altsetting->desc.bInterfaceNumber);
1436
1437         /* the interfaces are probed one by one. We are only interested in the
1438            video interface (0) now.
1439            Interface 1 is the Audio Control, and interface 2 Audio itself.
1440          */
1441         if (intf->altsetting->desc.bInterfaceNumber > 0)
1442                 return -ENODEV;
1443
1444         if (vendor_id == 0x0471) {
1445                 switch (product_id) {
1446                 case 0x0302:
1447                         PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1448                         name = "Philips 645 webcam";
1449                         type_id = 645;
1450                         break;
1451                 case 0x0303:
1452                         PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1453                         name = "Philips 646 webcam";
1454                         type_id = 646;
1455                         break;
1456                 case 0x0304:
1457                         PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1458                         name = "Askey VC010 webcam";
1459                         type_id = 646;
1460                         break;
1461                 case 0x0307:
1462                         PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1463                         name = "Philips 675 webcam";
1464                         type_id = 675;
1465                         break;
1466                 case 0x0308:
1467                         PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1468                         name = "Philips 680 webcam";
1469                         type_id = 680;
1470                         break;
1471                 case 0x030C:
1472                         PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1473                         name = "Philips 690 webcam";
1474                         type_id = 690;
1475                         break;
1476                 case 0x0310:
1477                         PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1478                         name = "Philips 730 webcam";
1479                         type_id = 730;
1480                         break;
1481                 case 0x0311:
1482                         PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1483                         name = "Philips 740 webcam";
1484                         type_id = 740;
1485                         break;
1486                 case 0x0312:
1487                         PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1488                         name = "Philips 750 webcam";
1489                         type_id = 750;
1490                         break;
1491                 case 0x0313:
1492                         PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1493                         name = "Philips 720K/40 webcam";
1494                         type_id = 720;
1495                         break;
1496                 case 0x0329:
1497                         PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1498                         name = "Philips SPC 900NC webcam";
1499                         type_id = 720;
1500                         break;
1501                 default:
1502                         return -ENODEV;
1503                         break;
1504                 }
1505         }
1506         else if (vendor_id == 0x069A) {
1507                 switch(product_id) {
1508                 case 0x0001:
1509                         PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1510                         name = "Askey VC010 webcam";
1511                         type_id = 645;
1512                         break;
1513                 default:
1514                         return -ENODEV;
1515                         break;
1516                 }
1517         }
1518         else if (vendor_id == 0x046d) {
1519                 switch(product_id) {
1520                 case 0x08b0:
1521                         PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1522                         name = "Logitech QuickCam Pro 3000";
1523                         type_id = 740; /* CCD sensor */
1524                         break;
1525                 case 0x08b1:
1526                         PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1527                         name = "Logitech QuickCam Notebook Pro";
1528                         type_id = 740; /* CCD sensor */
1529                         break;
1530                 case 0x08b2:
1531                         PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1532                         name = "Logitech QuickCam Pro 4000";
1533                         type_id = 740; /* CCD sensor */
1534                         break;
1535                 case 0x08b3:
1536                         PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1537                         name = "Logitech QuickCam Zoom";
1538                         type_id = 740; /* CCD sensor */
1539                         break;
1540                 case 0x08B4:
1541                         PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1542                         name = "Logitech QuickCam Zoom";
1543                         type_id = 740; /* CCD sensor */
1544                         power_save = 1;
1545                         break;
1546                 case 0x08b5:
1547                         PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1548                         name = "Logitech QuickCam Orbit";
1549                         type_id = 740; /* CCD sensor */
1550                         features |= FEATURE_MOTOR_PANTILT;
1551                         break;
1552                 case 0x08b6:
1553                 case 0x08b7:
1554                 case 0x08b8:
1555                         PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1556                         name = "Logitech QuickCam (res.)";
1557                         type_id = 730; /* Assuming CMOS */
1558                         break;
1559                 default:
1560                         return -ENODEV;
1561                         break;
1562                 }
1563         }
1564         else if (vendor_id == 0x055d) {
1565                 /* I don't know the difference between the C10 and the C30;
1566                    I suppose the difference is the sensor, but both cameras
1567                    work equally well with a type_id of 675
1568                  */
1569                 switch(product_id) {
1570                 case 0x9000:
1571                         PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1572                         name = "Samsung MPC-C10";
1573                         type_id = 675;
1574                         break;
1575                 case 0x9001:
1576                         PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1577                         name = "Samsung MPC-C30";
1578                         type_id = 675;
1579                         break;
1580                 case 0x9002:
1581                         PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1582                         name = "Samsung MPC-C30";
1583                         type_id = 740;
1584                         break;
1585                 default:
1586                         return -ENODEV;
1587                         break;
1588                 }
1589         }
1590         else if (vendor_id == 0x041e) {
1591                 switch(product_id) {
1592                 case 0x400c:
1593                         PWC_INFO("Creative Labs Webcam 5 detected.\n");
1594                         name = "Creative Labs Webcam 5";
1595                         type_id = 730;
1596                         break;
1597                 case 0x4011:
1598                         PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1599                         name = "Creative Labs Webcam Pro Ex";
1600                         type_id = 740;
1601                         break;
1602                 default:
1603                         return -ENODEV;
1604                         break;
1605                 }
1606         }
1607         else if (vendor_id == 0x04cc) {
1608                 switch(product_id) {
1609                 case 0x8116:
1610                         PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1611                         name = "Sotec Afina Eye";
1612                         type_id = 730;
1613                         break;
1614                 default:
1615                         return -ENODEV;
1616                         break;
1617                 }
1618         }
1619         else if (vendor_id == 0x06be) {
1620                 switch(product_id) {
1621                 case 0x8116:
1622                         /* This is essentially the same cam as the Sotec Afina Eye */
1623                         PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1624                         name = "AME Co. Afina Eye";
1625                         type_id = 750;
1626                         break;
1627                 default:
1628                         return -ENODEV;
1629                         break;
1630                 }
1631
1632         }
1633         else if (vendor_id == 0x0d81) {
1634                 switch(product_id) {
1635                 case 0x1900:
1636                         PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1637                         name = "Visionite VCS-UC300";
1638                         type_id = 740; /* CCD sensor */
1639                         break;
1640                 case 0x1910:
1641                         PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1642                         name = "Visionite VCS-UM100";
1643                         type_id = 730; /* CMOS sensor */
1644                         break;
1645                 default:
1646                         return -ENODEV;
1647                         break;
1648                 }
1649         }
1650         else
1651                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1652
1653         memset(serial_number, 0, 30);
1654         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1655         PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1656
1657         if (udev->descriptor.bNumConfigurations > 1)
1658                 PWC_WARNING("Warning: more than 1 configuration available.\n");
1659
1660         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1661         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1662         if (pdev == NULL) {
1663                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1664                 return -ENOMEM;
1665         }
1666         pdev->type = type_id;
1667         pdev->vsize = default_size;
1668         pdev->vframes = default_fps;
1669         strcpy(pdev->serial, serial_number);
1670         pdev->features = features;
1671         if (vendor_id == 0x046D && product_id == 0x08B5)
1672         {
1673                 /* Logitech QuickCam Orbit
1674                    The ranges have been determined experimentally; they may differ from cam to cam.
1675                    Also, the exact ranges left-right and up-down are different for my cam
1676                   */
1677                 pdev->angle_range.pan_min  = -7000;
1678                 pdev->angle_range.pan_max  =  7000;
1679                 pdev->angle_range.tilt_min = -3000;
1680                 pdev->angle_range.tilt_max =  2500;
1681         }
1682
1683         init_MUTEX(&pdev->modlock);
1684         spin_lock_init(&pdev->ptrlock);
1685
1686         pdev->udev = udev;
1687         init_waitqueue_head(&pdev->frameq);
1688         pdev->vcompression = pwc_preferred_compression;
1689
1690         /* Allocate video_device structure */
1691         pdev->vdev = video_device_alloc();
1692         if (pdev->vdev == 0)
1693         {
1694                 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
1695                 kfree(pdev);
1696                 return -ENOMEM;
1697         }
1698         memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
1699         pdev->vdev->dev = &(udev->dev);
1700         strcpy(pdev->vdev->name, name);
1701         pdev->vdev->owner = THIS_MODULE;
1702         video_set_drvdata(pdev->vdev, pdev);
1703
1704         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1705         PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1706
1707         /* Now search device_hint[] table for a match, so we can hint a node number. */
1708         for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1709                 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1710                      (device_hint[hint].pdev == NULL)) {
1711                         /* so far, so good... try serial number */
1712                         if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1713                                 /* match! */
1714                                 video_nr = device_hint[hint].device_node;
1715                                 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1716                                 break;
1717                         }
1718                 }
1719         }
1720
1721         pdev->vdev->release = video_device_release;
1722         i = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1723         if (i < 0) {
1724                 PWC_ERROR("Failed to register as video device (%d).\n", i);
1725                 rc = i;
1726                 goto err;
1727         }
1728         else {
1729                 PWC_INFO("Registered as /dev/video%d.\n", pdev->vdev->minor & 0x3F);
1730         }
1731
1732         /* occupy slot */
1733         if (hint < MAX_DEV_HINTS)
1734                 device_hint[hint].pdev = pdev;
1735
1736         PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1737         usb_set_intfdata (intf, pdev);
1738         rc = pwc_create_sysfs_files(pdev->vdev);
1739         if (rc)
1740                 goto err_unreg;
1741
1742         /* Set the leds off */
1743         pwc_set_leds(pdev, 0, 0);
1744         pwc_camera_power(pdev, 0);
1745
1746         return 0;
1747
1748 err_unreg:
1749         if (hint < MAX_DEV_HINTS)
1750                 device_hint[hint].pdev = NULL;
1751         video_unregister_device(pdev->vdev);
1752 err:
1753         video_device_release(pdev->vdev); /* Drip... drip... drip... */
1754         kfree(pdev); /* Oops, no memory leaks please */
1755         return rc;
1756 }
1757
1758 /* The user janked out the cable... */
1759 static void usb_pwc_disconnect(struct usb_interface *intf)
1760 {
1761         struct pwc_device *pdev;
1762         int hint;
1763
1764         lock_kernel();
1765         pdev = usb_get_intfdata (intf);
1766         usb_set_intfdata (intf, NULL);
1767         if (pdev == NULL) {
1768                 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1769                 goto disconnect_out;
1770         }
1771         if (pdev->udev == NULL) {
1772                 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1773                 goto disconnect_out;
1774         }
1775         if (pdev->udev != interface_to_usbdev(intf)) {
1776                 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1777                 goto disconnect_out;
1778         }
1779
1780         /* We got unplugged; this is signalled by an EPIPE error code */
1781         if (pdev->vopen) {
1782                 PWC_INFO("Disconnected while webcam is in use!\n");
1783                 pdev->error_status = EPIPE;
1784         }
1785
1786         /* Alert waiting processes */
1787         wake_up_interruptible(&pdev->frameq);
1788         /* Wait until device is closed */
1789         while (pdev->vopen)
1790                 schedule();
1791         /* Device is now closed, so we can safely unregister it */
1792         PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
1793         pwc_remove_sysfs_files(pdev->vdev);
1794         video_unregister_device(pdev->vdev);
1795
1796         /* Free memory (don't set pdev to 0 just yet) */
1797         kfree(pdev);
1798
1799 disconnect_out:
1800         /* search device_hint[] table if we occupy a slot, by any chance */
1801         for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1802                 if (device_hint[hint].pdev == pdev)
1803                         device_hint[hint].pdev = NULL;
1804
1805         unlock_kernel();
1806 }
1807
1808
1809 /* *grunt* We have to do atoi ourselves :-( */
1810 static int pwc_atoi(const char *s)
1811 {
1812         int k = 0;
1813
1814         k = 0;
1815         while (*s != '\0' && *s >= '0' && *s <= '9') {
1816                 k = 10 * k + (*s - '0');
1817                 s++;
1818         }
1819         return k;
1820 }
1821
1822
1823 /*
1824  * Initialization code & module stuff
1825  */
1826
1827 static char *size;
1828 static int fps;
1829 static int fbufs;
1830 static int mbufs;
1831 static int compression = -1;
1832 static int leds[2] = { -1, -1 };
1833 static int leds_nargs;
1834 static char *dev_hint[MAX_DEV_HINTS];
1835 static int dev_hint_nargs;
1836
1837 module_param(size, charp, 0444);
1838 module_param(fps, int, 0444);
1839 module_param(fbufs, int, 0444);
1840 module_param(mbufs, int, 0444);
1841 #if CONFIG_PWC_DEBUG
1842 module_param_named(trace, pwc_trace, int, 0644);
1843 #endif
1844 module_param(power_save, int, 0444);
1845 module_param(compression, int, 0444);
1846 module_param_array(leds, int, &leds_nargs, 0444);
1847 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1848
1849 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1850 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1851 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1852 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1853 MODULE_PARM_DESC(trace, "For debugging purposes");
1854 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1855 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1856 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1857 MODULE_PARM_DESC(dev_hint, "Device node hints");
1858
1859 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1860 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1861 MODULE_LICENSE("GPL");
1862 MODULE_ALIAS("pwcx");
1863 MODULE_VERSION( PWC_VERSION );
1864
1865 static int __init usb_pwc_init(void)
1866 {
1867         int i, sz;
1868         char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1869
1870         PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1871         PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1872         PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1873         PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1874
1875         if (fps) {
1876                 if (fps < 4 || fps > 30) {
1877                         PWC_ERROR("Framerate out of bounds (4-30).\n");
1878                         return -EINVAL;
1879                 }
1880                 default_fps = fps;
1881                 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1882         }
1883
1884         if (size) {
1885                 /* string; try matching with array */
1886                 for (sz = 0; sz < PSZ_MAX; sz++) {
1887                         if (!strcmp(sizenames[sz], size)) { /* Found! */
1888                                 default_size = sz;
1889                                 break;
1890                         }
1891                 }
1892                 if (sz == PSZ_MAX) {
1893                         PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1894                         return -EINVAL;
1895                 }
1896                 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);
1897         }
1898         if (mbufs) {
1899                 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1900                         PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
1901                         return -EINVAL;
1902                 }
1903                 pwc_mbufs = mbufs;
1904                 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
1905         }
1906         if (fbufs) {
1907                 if (fbufs < 2 || fbufs > MAX_FRAMES) {
1908                         PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
1909                         return -EINVAL;
1910                 }
1911                 default_fbufs = fbufs;
1912                 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
1913         }
1914 #if CONFIG_PWC_DEBUG
1915         if (pwc_trace >= 0) {
1916                 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1917         }
1918 #endif
1919         if (compression >= 0) {
1920                 if (compression > 3) {
1921                         PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1922                         return -EINVAL;
1923                 }
1924                 pwc_preferred_compression = compression;
1925                 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
1926         }
1927         if (power_save)
1928                 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
1929         if (leds[0] >= 0)
1930                 led_on = leds[0];
1931         if (leds[1] >= 0)
1932                 led_off = leds[1];
1933
1934         /* Big device node whoopla. Basically, it allows you to assign a
1935            device node (/dev/videoX) to a camera, based on its type
1936            & serial number. The format is [type[.serialnumber]:]node.
1937
1938            Any camera that isn't matched by these rules gets the next
1939            available free device node.
1940          */
1941         for (i = 0; i < MAX_DEV_HINTS; i++) {
1942                 char *s, *colon, *dot;
1943
1944                 /* This loop also initializes the array */
1945                 device_hint[i].pdev = NULL;
1946                 s = dev_hint[i];
1947                 if (s != NULL && *s != '\0') {
1948                         device_hint[i].type = -1; /* wildcard */
1949                         strcpy(device_hint[i].serial_number, "*");
1950
1951                         /* parse string: chop at ':' & '/' */
1952                         colon = dot = s;
1953                         while (*colon != '\0' && *colon != ':')
1954                                 colon++;
1955                         while (*dot != '\0' && *dot != '.')
1956                                 dot++;
1957                         /* Few sanity checks */
1958                         if (*dot != '\0' && dot > colon) {
1959                                 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
1960                                 return -EINVAL;
1961                         }
1962
1963                         if (*colon == '\0') {
1964                                 /* No colon */
1965                                 if (*dot != '\0') {
1966                                         PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
1967                                         return -EINVAL;
1968                                 }
1969                                 else {
1970                                         /* No type or serial number specified, just a number. */
1971                                         device_hint[i].device_node = pwc_atoi(s);
1972                                 }
1973                         }
1974                         else {
1975                                 /* There's a colon, so we have at least a type and a device node */
1976                                 device_hint[i].type = pwc_atoi(s);
1977                                 device_hint[i].device_node = pwc_atoi(colon + 1);
1978                                 if (*dot != '\0') {
1979                                         /* There's a serial number as well */
1980                                         int k;
1981
1982                                         dot++;
1983                                         k = 0;
1984                                         while (*dot != ':' && k < 29) {
1985                                                 device_hint[i].serial_number[k++] = *dot;
1986                                                 dot++;
1987                                         }
1988                                         device_hint[i].serial_number[k] = '\0';
1989                                 }
1990                         }
1991                         PWC_TRACE("device_hint[%d]:\n", i);
1992                         PWC_TRACE("  type    : %d\n", device_hint[i].type);
1993                         PWC_TRACE("  serial# : %s\n", device_hint[i].serial_number);
1994                         PWC_TRACE("  node    : %d\n", device_hint[i].device_node);
1995                 }
1996                 else
1997                         device_hint[i].type = 0; /* not filled */
1998         } /* ..for MAX_DEV_HINTS */
1999
2000         PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
2001         return usb_register(&pwc_driver);
2002 }
2003
2004 static void __exit usb_pwc_exit(void)
2005 {
2006         PWC_DEBUG_MODULE("Deregistering driver.\n");
2007         usb_deregister(&pwc_driver);
2008         PWC_INFO("Philips webcam module removed.\n");
2009 }
2010
2011 module_init(usb_pwc_init);
2012 module_exit(usb_pwc_exit);
2013
2014 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */