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