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