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