Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[linux-2.6.git] / drivers / media / video / pwc / pwc-if.c
1 /* Linux driver for Philips webcam
2    USB and Video4Linux interface part.
3    (C) 1999-2004 Nemosoft Unv.
4    (C) 2004-2006 Luc Saillard (luc@saillard.org)
5    (C) 2011 Hans de Goede <hdegoede@redhat.com>
6
7    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
8    driver and thus may have bugs that are not present in the original version.
9    Please send bug reports and support requests to <luc@saillard.org>.
10    The decompression routines have been implemented by reverse-engineering the
11    Nemosoft binary pwcx module. Caveat emptor.
12
13    This program is free software; you can redistribute it and/or modify
14    it under the terms of the GNU General Public License as published by
15    the Free Software Foundation; either version 2 of the License, or
16    (at your option) any later version.
17
18    This program is distributed in the hope that it will be useful,
19    but WITHOUT ANY WARRANTY; without even the implied warranty of
20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21    GNU General Public License for more details.
22
23    You should have received a copy of the GNU General Public License
24    along with this program; if not, write to the Free Software
25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26
27 */
28
29 /*
30    This code forms the interface between the USB layers and the Philips
31    specific stuff. Some adanved stuff of the driver falls under an
32    NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
33    is thus not distributed in source form. The binary pwcx.o module
34    contains the code that falls under the NDA.
35
36    In case you're wondering: 'pwc' stands for "Philips WebCam", but
37    I really didn't want to type 'philips_web_cam' every time (I'm lazy as
38    any Linux kernel hacker, but I don't like uncomprehensible abbreviations
39    without explanation).
40
41    Oh yes, convention: to disctinguish between all the various pointers to
42    device-structures, I use these names for the pointer variables:
43    udev: struct usb_device *
44    vdev: struct video_device (member of pwc_dev)
45    pdev: struct pwc_devive *
46 */
47
48 /* Contributors:
49    - Alvarado: adding whitebalance code
50    - Alistar Moire: QuickCam 3000 Pro device/product ID
51    - Tony Hoyle: Creative Labs Webcam 5 device/product ID
52    - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
53    - Jk Fang: Sotec Afina Eye ID
54    - Xavier Roche: QuickCam Pro 4000 ID
55    - Jens Knudsen: QuickCam Zoom ID
56    - J. Debert: QuickCam for Notebooks ID
57    - Pham Thanh Nam: webcam snapshot button as an event input device
58 */
59
60 #include <linux/errno.h>
61 #include <linux/init.h>
62 #include <linux/mm.h>
63 #include <linux/module.h>
64 #include <linux/poll.h>
65 #include <linux/slab.h>
66 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
67 #include <linux/usb/input.h>
68 #endif
69 #include <linux/vmalloc.h>
70 #include <asm/io.h>
71 #include <linux/kernel.h>               /* simple_strtol() */
72
73 #include "pwc.h"
74 #include "pwc-kiara.h"
75 #include "pwc-timon.h"
76 #include "pwc-dec23.h"
77 #include "pwc-dec1.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 static void pwc_isoc_cleanup(struct pwc_device *pdev);
120
121 static struct usb_driver pwc_driver = {
122         .name =                 "Philips webcam",       /* name */
123         .id_table =             pwc_device_table,
124         .probe =                usb_pwc_probe,          /* probe() */
125         .disconnect =           usb_pwc_disconnect,     /* disconnect() */
126 };
127
128 #define MAX_DEV_HINTS   20
129 #define MAX_ISOC_ERRORS 20
130
131 static int default_fps = 10;
132 #ifdef CONFIG_USB_PWC_DEBUG
133         int pwc_trace = PWC_DEBUG_LEVEL;
134 #endif
135 static int power_save = -1;
136 static int led_on = 100, led_off; /* defaults to LED that is on while in use */
137 static struct {
138         int type;
139         char serial_number[30];
140         int device_node;
141         struct pwc_device *pdev;
142 } device_hint[MAX_DEV_HINTS];
143
144 /***/
145
146 static int pwc_video_close(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_mmap(struct file *file, struct vm_area_struct *vma);
151
152 static const struct v4l2_file_operations pwc_fops = {
153         .owner =        THIS_MODULE,
154         .open =         v4l2_fh_open,
155         .release =      pwc_video_close,
156         .read =         pwc_video_read,
157         .poll =         pwc_video_poll,
158         .mmap =         pwc_video_mmap,
159         .unlocked_ioctl = video_ioctl2,
160 };
161 static struct video_device pwc_template = {
162         .name =         "Philips Webcam",       /* Filled in later */
163         .release =      video_device_release_empty,
164         .fops =         &pwc_fops,
165         .ioctl_ops =    &pwc_ioctl_ops,
166 };
167
168 /***************************************************************************/
169 /* Private functions */
170
171 struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
172 {
173         unsigned long flags = 0;
174         struct pwc_frame_buf *buf = NULL;
175
176         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
177         if (list_empty(&pdev->queued_bufs))
178                 goto leave;
179
180         buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
181         list_del(&buf->list);
182 leave:
183         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
184         return buf;
185 }
186
187 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
188 {
189         if (down) {
190                 PWC_TRACE("Snapshot button pressed.\n");
191         } else {
192                 PWC_TRACE("Snapshot button released.\n");
193         }
194
195 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
196         if (pdev->button_dev) {
197                 input_report_key(pdev->button_dev, KEY_CAMERA, down);
198                 input_sync(pdev->button_dev);
199         }
200 #endif
201 }
202
203 static void pwc_frame_complete(struct pwc_device *pdev)
204 {
205         struct pwc_frame_buf *fbuf = pdev->fill_buf;
206
207         /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
208            frames on the USB wire after an exposure change. This conditition is
209            however detected  in the cam and a bit is set in the header.
210            */
211         if (pdev->type == 730) {
212                 unsigned char *ptr = (unsigned char *)fbuf->data;
213
214                 if (ptr[1] == 1 && ptr[0] & 0x10) {
215                         PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
216                         pdev->drop_frames += 2;
217                 }
218                 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
219                         pwc_snapshot_button(pdev, ptr[0] & 0x01);
220                 }
221                 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
222                         if (ptr[0] & 0x02)
223                                 PWC_TRACE("Image is mirrored.\n");
224                         else
225                                 PWC_TRACE("Image is normal.\n");
226                 }
227                 pdev->vmirror = ptr[0] & 0x03;
228                 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
229                    after a short frame; this condition is filtered out specifically. A 4 byte
230                    frame doesn't make sense anyway.
231                    So we get either this sequence:
232                    drop_bit set -> 4 byte frame -> short frame -> good frame
233                    Or this one:
234                    drop_bit set -> short frame -> good frame
235                    So we drop either 3 or 2 frames in all!
236                    */
237                 if (fbuf->filled == 4)
238                         pdev->drop_frames++;
239         } else if (pdev->type == 740 || pdev->type == 720) {
240                 unsigned char *ptr = (unsigned char *)fbuf->data;
241                 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
242                         pwc_snapshot_button(pdev, ptr[0] & 0x01);
243                 }
244                 pdev->vmirror = ptr[0] & 0x03;
245         }
246
247         /* In case we were instructed to drop the frame, do so silently. */
248         if (pdev->drop_frames > 0) {
249                 pdev->drop_frames--;
250         } else {
251                 /* Check for underflow first */
252                 if (fbuf->filled < pdev->frame_total_size) {
253                         PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
254                                        " discarded.\n", fbuf->filled);
255                 } else {
256                         fbuf->vb.v4l2_buf.field = V4L2_FIELD_NONE;
257                         fbuf->vb.v4l2_buf.sequence = pdev->vframe_count;
258                         vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
259                         pdev->fill_buf = NULL;
260                         pdev->vsync = 0;
261                 }
262         } /* !drop_frames */
263         pdev->vframe_count++;
264 }
265
266 /* This gets called for the Isochronous pipe (video). This is done in
267  * interrupt time, so it has to be fast, not crash, and not stall. Neat.
268  */
269 static void pwc_isoc_handler(struct urb *urb)
270 {
271         struct pwc_device *pdev = (struct pwc_device *)urb->context;
272         int i, fst, flen;
273         unsigned char *iso_buf = NULL;
274
275         if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
276             urb->status == -ESHUTDOWN) {
277                 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
278                 return;
279         }
280
281         if (pdev->fill_buf == NULL)
282                 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
283
284         if (urb->status != 0) {
285                 const char *errmsg;
286
287                 errmsg = "Unknown";
288                 switch(urb->status) {
289                         case -ENOSR:            errmsg = "Buffer error (overrun)"; break;
290                         case -EPIPE:            errmsg = "Stalled (device not responding)"; break;
291                         case -EOVERFLOW:        errmsg = "Babble (bad cable?)"; break;
292                         case -EPROTO:           errmsg = "Bit-stuff error (bad cable?)"; break;
293                         case -EILSEQ:           errmsg = "CRC/Timeout (could be anything)"; break;
294                         case -ETIME:            errmsg = "Device does not respond"; break;
295                 }
296                 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
297                           urb->status, errmsg);
298                 /* Give up after a number of contiguous errors */
299                 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
300                 {
301                         PWC_ERROR("Too many ISOC errors, bailing out.\n");
302                         if (pdev->fill_buf) {
303                                 vb2_buffer_done(&pdev->fill_buf->vb,
304                                                 VB2_BUF_STATE_ERROR);
305                                 pdev->fill_buf = NULL;
306                         }
307                 }
308                 pdev->vsync = 0; /* Drop the current frame */
309                 goto handler_end;
310         }
311
312         /* Reset ISOC error counter. We did get here, after all. */
313         pdev->visoc_errors = 0;
314
315         /* vsync: 0 = don't copy data
316                   1 = sync-hunt
317                   2 = synched
318          */
319         /* Compact data */
320         for (i = 0; i < urb->number_of_packets; i++) {
321                 fst  = urb->iso_frame_desc[i].status;
322                 flen = urb->iso_frame_desc[i].actual_length;
323                 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
324                 if (fst != 0) {
325                         PWC_ERROR("Iso frame %d has error %d\n", i, fst);
326                         continue;
327                 }
328                 if (flen > 0 && pdev->vsync) {
329                         struct pwc_frame_buf *fbuf = pdev->fill_buf;
330
331                         if (pdev->vsync == 1) {
332                                 do_gettimeofday(&fbuf->vb.v4l2_buf.timestamp);
333                                 pdev->vsync = 2;
334                         }
335
336                         if (flen + fbuf->filled > pdev->frame_total_size) {
337                                 PWC_ERROR("Frame overflow (%d > %d)\n",
338                                           flen + fbuf->filled,
339                                           pdev->frame_total_size);
340                                 pdev->vsync = 0; /* Let's wait for an EOF */
341                         } else {
342                                 memcpy(fbuf->data + fbuf->filled, iso_buf,
343                                        flen);
344                                 fbuf->filled += flen;
345                         }
346                 }
347                 if (flen < pdev->vlast_packet_size) {
348                         /* Shorter packet... end of frame */
349                         if (pdev->vsync == 2)
350                                 pwc_frame_complete(pdev);
351                         if (pdev->fill_buf == NULL)
352                                 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
353                         if (pdev->fill_buf) {
354                                 pdev->fill_buf->filled = 0;
355                                 pdev->vsync = 1;
356                         }
357                 }
358                 pdev->vlast_packet_size = flen;
359         }
360
361 handler_end:
362         i = usb_submit_urb(urb, GFP_ATOMIC);
363         if (i != 0)
364                 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
365 }
366
367 static int pwc_isoc_init(struct pwc_device *pdev)
368 {
369         struct usb_device *udev;
370         struct urb *urb;
371         int i, j, ret;
372         struct usb_interface *intf;
373         struct usb_host_interface *idesc = NULL;
374         int compression = 0; /* 0..3 = uncompressed..high */
375
376         if (pdev->iso_init)
377                 return 0;
378
379         pdev->vsync = 0;
380         pdev->vlast_packet_size = 0;
381         pdev->fill_buf = NULL;
382         pdev->vframe_count = 0;
383         pdev->visoc_errors = 0;
384         udev = pdev->udev;
385
386 retry:
387         /* We first try with low compression and then retry with a higher
388            compression setting if there is not enough bandwidth. */
389         ret = pwc_set_video_mode(pdev, pdev->width, pdev->height,
390                                  pdev->vframes, &compression);
391
392         /* Get the current alternate interface, adjust packet size */
393         intf = usb_ifnum_to_if(udev, 0);
394         if (intf)
395                 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
396         if (!idesc)
397                 return -EIO;
398
399         /* Search video endpoint */
400         pdev->vmax_packet_size = -1;
401         for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
402                 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
403                         pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
404                         break;
405                 }
406         }
407
408         if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
409                 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
410                 return -ENFILE; /* Odd error, that should be noticeable */
411         }
412
413         /* Set alternate interface */
414         PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
415         ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
416         if (ret == -ENOSPC && compression < 3) {
417                 compression++;
418                 goto retry;
419         }
420         if (ret < 0)
421                 return ret;
422
423         /* Allocate and init Isochronuous urbs */
424         for (i = 0; i < MAX_ISO_BUFS; i++) {
425                 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
426                 if (urb == NULL) {
427                         PWC_ERROR("Failed to allocate urb %d\n", i);
428                         pdev->iso_init = 1;
429                         pwc_isoc_cleanup(pdev);
430                         return -ENOMEM;
431                 }
432                 pdev->urbs[i] = urb;
433                 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
434
435                 urb->interval = 1; // devik
436                 urb->dev = udev;
437                 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
438                 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
439                 urb->transfer_buffer = usb_alloc_coherent(udev,
440                                                           ISO_BUFFER_SIZE,
441                                                           GFP_KERNEL,
442                                                           &urb->transfer_dma);
443                 if (urb->transfer_buffer == NULL) {
444                         PWC_ERROR("Failed to allocate urb buffer %d\n", i);
445                         pdev->iso_init = 1;
446                         pwc_isoc_cleanup(pdev);
447                         return -ENOMEM;
448                 }
449                 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
450                 urb->complete = pwc_isoc_handler;
451                 urb->context = pdev;
452                 urb->start_frame = 0;
453                 urb->number_of_packets = ISO_FRAMES_PER_DESC;
454                 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
455                         urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
456                         urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
457                 }
458         }
459
460         /* link */
461         for (i = 0; i < MAX_ISO_BUFS; i++) {
462                 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
463                 if (ret == -ENOSPC && compression < 3) {
464                         compression++;
465                         pdev->iso_init = 1;
466                         pwc_isoc_cleanup(pdev);
467                         goto retry;
468                 }
469                 if (ret) {
470                         PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
471                         pdev->iso_init = 1;
472                         pwc_isoc_cleanup(pdev);
473                         return ret;
474                 }
475                 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
476         }
477
478         /* All is done... */
479         pdev->iso_init = 1;
480         PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
481         return 0;
482 }
483
484 static void pwc_iso_stop(struct pwc_device *pdev)
485 {
486         int i;
487
488         /* Unlinking ISOC buffers one by one */
489         for (i = 0; i < MAX_ISO_BUFS; i++) {
490                 if (pdev->urbs[i]) {
491                         PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
492                         usb_kill_urb(pdev->urbs[i]);
493                 }
494         }
495 }
496
497 static void pwc_iso_free(struct pwc_device *pdev)
498 {
499         int i;
500
501         /* Freeing ISOC buffers one by one */
502         for (i = 0; i < MAX_ISO_BUFS; i++) {
503                 if (pdev->urbs[i]) {
504                         PWC_DEBUG_MEMORY("Freeing URB\n");
505                         if (pdev->urbs[i]->transfer_buffer) {
506                                 usb_free_coherent(pdev->udev,
507                                         pdev->urbs[i]->transfer_buffer_length,
508                                         pdev->urbs[i]->transfer_buffer,
509                                         pdev->urbs[i]->transfer_dma);
510                         }
511                         usb_free_urb(pdev->urbs[i]);
512                         pdev->urbs[i] = NULL;
513                 }
514         }
515 }
516
517 static void pwc_isoc_cleanup(struct pwc_device *pdev)
518 {
519         PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
520
521         if (pdev->iso_init == 0)
522                 return;
523
524         pwc_iso_stop(pdev);
525         pwc_iso_free(pdev);
526         usb_set_interface(pdev->udev, 0, 0);
527
528         pdev->iso_init = 0;
529         PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
530 }
531
532 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev)
533 {
534         unsigned long flags = 0;
535
536         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
537         while (!list_empty(&pdev->queued_bufs)) {
538                 struct pwc_frame_buf *buf;
539
540                 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
541                                  list);
542                 list_del(&buf->list);
543                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
544         }
545         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
546 }
547
548 #ifdef CONFIG_USB_PWC_DEBUG
549 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
550 {
551         switch(sensor_type) {
552                 case 0x00:
553                         return "Hyundai CMOS sensor";
554                 case 0x20:
555                         return "Sony CCD sensor + TDA8787";
556                 case 0x2E:
557                         return "Sony CCD sensor + Exas 98L59";
558                 case 0x2F:
559                         return "Sony CCD sensor + ADI 9804";
560                 case 0x30:
561                         return "Sharp CCD sensor + TDA8787";
562                 case 0x3E:
563                         return "Sharp CCD sensor + Exas 98L59";
564                 case 0x3F:
565                         return "Sharp CCD sensor + ADI 9804";
566                 case 0x40:
567                         return "UPA 1021 sensor";
568                 case 0x100:
569                         return "VGA sensor";
570                 case 0x101:
571                         return "PAL MR sensor";
572                 default:
573                         return "unknown type of sensor";
574         }
575 }
576 #endif
577
578 /***************************************************************************/
579 /* Video4Linux functions */
580
581 int pwc_test_n_set_capt_file(struct pwc_device *pdev, struct file *file)
582 {
583         int r = 0;
584
585         mutex_lock(&pdev->capt_file_lock);
586         if (pdev->capt_file != NULL &&
587             pdev->capt_file != file) {
588                 r = -EBUSY;
589                 goto leave;
590         }
591         pdev->capt_file = file;
592 leave:
593         mutex_unlock(&pdev->capt_file_lock);
594         return r;
595 }
596
597 static void pwc_video_release(struct v4l2_device *v)
598 {
599         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
600         int hint;
601
602         /* search device_hint[] table if we occupy a slot, by any chance */
603         for (hint = 0; hint < MAX_DEV_HINTS; hint++)
604                 if (device_hint[hint].pdev == pdev)
605                         device_hint[hint].pdev = NULL;
606
607         /* Free intermediate decompression buffer & tables */
608         if (pdev->decompress_data != NULL) {
609                 PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n",
610                                  pdev->decompress_data);
611                 kfree(pdev->decompress_data);
612                 pdev->decompress_data = NULL;
613         }
614
615         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
616
617         kfree(pdev);
618 }
619
620 static int pwc_video_close(struct file *file)
621 {
622         struct pwc_device *pdev = video_drvdata(file);
623
624         if (pdev->capt_file == file) {
625                 vb2_queue_release(&pdev->vb_queue);
626                 pdev->capt_file = NULL;
627         }
628         return v4l2_fh_release(file);
629 }
630
631 static ssize_t pwc_video_read(struct file *file, char __user *buf,
632                               size_t count, loff_t *ppos)
633 {
634         struct pwc_device *pdev = video_drvdata(file);
635
636         if (!pdev->udev)
637                 return -ENODEV;
638
639         if (pwc_test_n_set_capt_file(pdev, file))
640                 return -EBUSY;
641
642         return vb2_read(&pdev->vb_queue, buf, count, ppos,
643                         file->f_flags & O_NONBLOCK);
644 }
645
646 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
647 {
648         struct pwc_device *pdev = video_drvdata(file);
649
650         if (!pdev->udev)
651                 return POLL_ERR;
652
653         return vb2_poll(&pdev->vb_queue, file, wait);
654 }
655
656 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
657 {
658         struct pwc_device *pdev = video_drvdata(file);
659
660         if (pdev->capt_file != file)
661                 return -EBUSY;
662
663         return vb2_mmap(&pdev->vb_queue, vma);
664 }
665
666 /***************************************************************************/
667 /* Videobuf2 operations */
668
669 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
670                                 unsigned int *nbuffers, unsigned int *nplanes,
671                                 unsigned int sizes[], void *alloc_ctxs[])
672 {
673         struct pwc_device *pdev = vb2_get_drv_priv(vq);
674         int size;
675
676         if (*nbuffers < MIN_FRAMES)
677                 *nbuffers = MIN_FRAMES;
678         else if (*nbuffers > MAX_FRAMES)
679                 *nbuffers = MAX_FRAMES;
680
681         *nplanes = 1;
682
683         size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
684         sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
685                               pwc_image_sizes[size][1] * 3 / 2);
686
687         return 0;
688 }
689
690 static int buffer_init(struct vb2_buffer *vb)
691 {
692         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
693
694         /* need vmalloc since frame buffer > 128K */
695         buf->data = vzalloc(PWC_FRAME_SIZE);
696         if (buf->data == NULL)
697                 return -ENOMEM;
698
699         return 0;
700 }
701
702 static int buffer_prepare(struct vb2_buffer *vb)
703 {
704         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
705
706         /* Don't allow queing new buffers after device disconnection */
707         if (!pdev->udev)
708                 return -ENODEV;
709
710         return 0;
711 }
712
713 static int buffer_finish(struct vb2_buffer *vb)
714 {
715         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
716         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
717
718         /*
719          * Application has called dqbuf and is getting back a buffer we've
720          * filled, take the pwc data we've stored in buf->data and decompress
721          * it into a usable format, storing the result in the vb2_buffer
722          */
723         return pwc_decompress(pdev, buf);
724 }
725
726 static void buffer_cleanup(struct vb2_buffer *vb)
727 {
728         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
729
730         vfree(buf->data);
731 }
732
733 static void buffer_queue(struct vb2_buffer *vb)
734 {
735         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
736         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
737         unsigned long flags = 0;
738
739         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
740         /* Check the device has not disconnected between prep and queuing */
741         if (pdev->udev)
742                 list_add_tail(&buf->list, &pdev->queued_bufs);
743         else
744                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
745         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
746 }
747
748 static int start_streaming(struct vb2_queue *vq, unsigned int count)
749 {
750         struct pwc_device *pdev = vb2_get_drv_priv(vq);
751         int r;
752
753         mutex_lock(&pdev->udevlock);
754         if (!pdev->udev) {
755                 r = -ENODEV;
756                 goto leave;
757         }
758
759         /* Turn on camera and set LEDS on */
760         pwc_camera_power(pdev, 1);
761         pwc_set_leds(pdev, led_on, led_off);
762
763         r = pwc_isoc_init(pdev);
764         if (r) {
765                 /* If we failed turn camera and LEDS back off */
766                 pwc_set_leds(pdev, 0, 0);
767                 pwc_camera_power(pdev, 0);
768                 /* And cleanup any queued bufs!! */
769                 pwc_cleanup_queued_bufs(pdev);
770         }
771 leave:
772         mutex_unlock(&pdev->udevlock);
773         return r;
774 }
775
776 static int stop_streaming(struct vb2_queue *vq)
777 {
778         struct pwc_device *pdev = vb2_get_drv_priv(vq);
779
780         mutex_lock(&pdev->udevlock);
781         if (pdev->udev) {
782                 pwc_set_leds(pdev, 0, 0);
783                 pwc_camera_power(pdev, 0);
784                 pwc_isoc_cleanup(pdev);
785         }
786         mutex_unlock(&pdev->udevlock);
787
788         pwc_cleanup_queued_bufs(pdev);
789
790         return 0;
791 }
792
793 static struct vb2_ops pwc_vb_queue_ops = {
794         .queue_setup            = queue_setup,
795         .buf_init               = buffer_init,
796         .buf_prepare            = buffer_prepare,
797         .buf_finish             = buffer_finish,
798         .buf_cleanup            = buffer_cleanup,
799         .buf_queue              = buffer_queue,
800         .start_streaming        = start_streaming,
801         .stop_streaming         = stop_streaming,
802 };
803
804 /***************************************************************************/
805 /* USB functions */
806
807 /* This function gets called when a new device is plugged in or the usb core
808  * is loaded.
809  */
810
811 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
812 {
813         struct usb_device *udev = interface_to_usbdev(intf);
814         struct pwc_device *pdev = NULL;
815         int vendor_id, product_id, type_id;
816         int hint, rc;
817         int features = 0;
818         int compression = 0;
819         int video_nr = -1; /* default: use next available device */
820         int my_power_save = power_save;
821         char serial_number[30], *name;
822
823         vendor_id = le16_to_cpu(udev->descriptor.idVendor);
824         product_id = le16_to_cpu(udev->descriptor.idProduct);
825
826         /* Check if we can handle this device */
827         PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
828                 vendor_id, product_id,
829                 intf->altsetting->desc.bInterfaceNumber);
830
831         /* the interfaces are probed one by one. We are only interested in the
832            video interface (0) now.
833            Interface 1 is the Audio Control, and interface 2 Audio itself.
834          */
835         if (intf->altsetting->desc.bInterfaceNumber > 0)
836                 return -ENODEV;
837
838         if (vendor_id == 0x0471) {
839                 switch (product_id) {
840                 case 0x0302:
841                         PWC_INFO("Philips PCA645VC USB webcam detected.\n");
842                         name = "Philips 645 webcam";
843                         type_id = 645;
844                         break;
845                 case 0x0303:
846                         PWC_INFO("Philips PCA646VC USB webcam detected.\n");
847                         name = "Philips 646 webcam";
848                         type_id = 646;
849                         break;
850                 case 0x0304:
851                         PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
852                         name = "Askey VC010 webcam";
853                         type_id = 646;
854                         break;
855                 case 0x0307:
856                         PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
857                         name = "Philips 675 webcam";
858                         type_id = 675;
859                         break;
860                 case 0x0308:
861                         PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
862                         name = "Philips 680 webcam";
863                         type_id = 680;
864                         break;
865                 case 0x030C:
866                         PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
867                         name = "Philips 690 webcam";
868                         type_id = 690;
869                         break;
870                 case 0x0310:
871                         PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
872                         name = "Philips 730 webcam";
873                         type_id = 730;
874                         break;
875                 case 0x0311:
876                         PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
877                         name = "Philips 740 webcam";
878                         type_id = 740;
879                         break;
880                 case 0x0312:
881                         PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
882                         name = "Philips 750 webcam";
883                         type_id = 750;
884                         break;
885                 case 0x0313:
886                         PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
887                         name = "Philips 720K/40 webcam";
888                         type_id = 720;
889                         break;
890                 case 0x0329:
891                         PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
892                         name = "Philips SPC 900NC webcam";
893                         type_id = 740;
894                         break;
895                 default:
896                         return -ENODEV;
897                         break;
898                 }
899         }
900         else if (vendor_id == 0x069A) {
901                 switch(product_id) {
902                 case 0x0001:
903                         PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
904                         name = "Askey VC010 webcam";
905                         type_id = 645;
906                         break;
907                 default:
908                         return -ENODEV;
909                         break;
910                 }
911         }
912         else if (vendor_id == 0x046d) {
913                 switch(product_id) {
914                 case 0x08b0:
915                         PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
916                         name = "Logitech QuickCam Pro 3000";
917                         type_id = 740; /* CCD sensor */
918                         break;
919                 case 0x08b1:
920                         PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
921                         name = "Logitech QuickCam Notebook Pro";
922                         type_id = 740; /* CCD sensor */
923                         break;
924                 case 0x08b2:
925                         PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
926                         name = "Logitech QuickCam Pro 4000";
927                         type_id = 740; /* CCD sensor */
928                         if (my_power_save == -1)
929                                 my_power_save = 1;
930                         break;
931                 case 0x08b3:
932                         PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
933                         name = "Logitech QuickCam Zoom";
934                         type_id = 740; /* CCD sensor */
935                         break;
936                 case 0x08B4:
937                         PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
938                         name = "Logitech QuickCam Zoom";
939                         type_id = 740; /* CCD sensor */
940                         if (my_power_save == -1)
941                                 my_power_save = 1;
942                         break;
943                 case 0x08b5:
944                         PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
945                         name = "Logitech QuickCam Orbit";
946                         type_id = 740; /* CCD sensor */
947                         if (my_power_save == -1)
948                                 my_power_save = 1;
949                         features |= FEATURE_MOTOR_PANTILT;
950                         break;
951                 case 0x08b6:
952                         PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
953                         name = "Cisco VT Camera";
954                         type_id = 740; /* CCD sensor */
955                         break;
956                 case 0x08b7:
957                         PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
958                         name = "Logitech ViewPort AV 100";
959                         type_id = 740; /* CCD sensor */
960                         break;
961                 case 0x08b8: /* Where this released? */
962                         PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
963                         name = "Logitech QuickCam (res.)";
964                         type_id = 730; /* Assuming CMOS */
965                         break;
966                 default:
967                         return -ENODEV;
968                         break;
969                 }
970         }
971         else if (vendor_id == 0x055d) {
972                 /* I don't know the difference between the C10 and the C30;
973                    I suppose the difference is the sensor, but both cameras
974                    work equally well with a type_id of 675
975                  */
976                 switch(product_id) {
977                 case 0x9000:
978                         PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
979                         name = "Samsung MPC-C10";
980                         type_id = 675;
981                         break;
982                 case 0x9001:
983                         PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
984                         name = "Samsung MPC-C30";
985                         type_id = 675;
986                         break;
987                 case 0x9002:
988                         PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
989                         name = "Samsung MPC-C30";
990                         type_id = 740;
991                         break;
992                 default:
993                         return -ENODEV;
994                         break;
995                 }
996         }
997         else if (vendor_id == 0x041e) {
998                 switch(product_id) {
999                 case 0x400c:
1000                         PWC_INFO("Creative Labs Webcam 5 detected.\n");
1001                         name = "Creative Labs Webcam 5";
1002                         type_id = 730;
1003                         if (my_power_save == -1)
1004                                 my_power_save = 1;
1005                         break;
1006                 case 0x4011:
1007                         PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1008                         name = "Creative Labs Webcam Pro Ex";
1009                         type_id = 740;
1010                         break;
1011                 default:
1012                         return -ENODEV;
1013                         break;
1014                 }
1015         }
1016         else if (vendor_id == 0x04cc) {
1017                 switch(product_id) {
1018                 case 0x8116:
1019                         PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1020                         name = "Sotec Afina Eye";
1021                         type_id = 730;
1022                         break;
1023                 default:
1024                         return -ENODEV;
1025                         break;
1026                 }
1027         }
1028         else if (vendor_id == 0x06be) {
1029                 switch(product_id) {
1030                 case 0x8116:
1031                         /* This is essentially the same cam as the Sotec Afina Eye */
1032                         PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1033                         name = "AME Co. Afina Eye";
1034                         type_id = 750;
1035                         break;
1036                 default:
1037                         return -ENODEV;
1038                         break;
1039                 }
1040
1041         }
1042         else if (vendor_id == 0x0d81) {
1043                 switch(product_id) {
1044                 case 0x1900:
1045                         PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1046                         name = "Visionite VCS-UC300";
1047                         type_id = 740; /* CCD sensor */
1048                         break;
1049                 case 0x1910:
1050                         PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1051                         name = "Visionite VCS-UM100";
1052                         type_id = 730; /* CMOS sensor */
1053                         break;
1054                 default:
1055                         return -ENODEV;
1056                         break;
1057                 }
1058         }
1059         else
1060                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1061
1062         if (my_power_save == -1)
1063                 my_power_save = 0;
1064
1065         memset(serial_number, 0, 30);
1066         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1067         PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1068
1069         if (udev->descriptor.bNumConfigurations > 1)
1070                 PWC_WARNING("Warning: more than 1 configuration available.\n");
1071
1072         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1073         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1074         if (pdev == NULL) {
1075                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1076                 return -ENOMEM;
1077         }
1078         pdev->type = type_id;
1079         pdev->vframes = default_fps;
1080         pdev->features = features;
1081         pwc_construct(pdev); /* set min/max sizes correct */
1082
1083         mutex_init(&pdev->capt_file_lock);
1084         mutex_init(&pdev->udevlock);
1085         spin_lock_init(&pdev->queued_bufs_lock);
1086         INIT_LIST_HEAD(&pdev->queued_bufs);
1087
1088         pdev->udev = udev;
1089         pdev->power_save = my_power_save;
1090
1091         /* Init videobuf2 queue structure */
1092         memset(&pdev->vb_queue, 0, sizeof(pdev->vb_queue));
1093         pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1094         pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1095         pdev->vb_queue.drv_priv = pdev;
1096         pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1097         pdev->vb_queue.ops = &pwc_vb_queue_ops;
1098         pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1099         vb2_queue_init(&pdev->vb_queue);
1100
1101         /* Init video_device structure */
1102         memcpy(&pdev->vdev, &pwc_template, sizeof(pwc_template));
1103         strcpy(pdev->vdev.name, name);
1104         set_bit(V4L2_FL_USE_FH_PRIO, &pdev->vdev.flags);
1105         video_set_drvdata(&pdev->vdev, pdev);
1106
1107         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1108         PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1109
1110         /* Now search device_hint[] table for a match, so we can hint a node number. */
1111         for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1112                 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1113                      (device_hint[hint].pdev == NULL)) {
1114                         /* so far, so good... try serial number */
1115                         if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1116                                 /* match! */
1117                                 video_nr = device_hint[hint].device_node;
1118                                 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1119                                 break;
1120                         }
1121                 }
1122         }
1123
1124         /* occupy slot */
1125         if (hint < MAX_DEV_HINTS)
1126                 device_hint[hint].pdev = pdev;
1127
1128 #ifdef CONFIG_USB_PWC_DEBUG
1129         /* Query sensor type */
1130         if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1131                 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1132                                 pdev->vdev.name,
1133                                 pwc_sensor_type_to_string(rc), rc);
1134         }
1135 #endif
1136
1137         /* Set the leds off */
1138         pwc_set_leds(pdev, 0, 0);
1139
1140         /* Setup intial videomode */
1141         rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT, pdev->vframes,
1142                                 &compression);
1143         if (rc)
1144                 goto err_free_mem;
1145
1146         /* Register controls (and read default values from camera */
1147         rc = pwc_init_controls(pdev);
1148         if (rc) {
1149                 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1150                 goto err_free_mem;
1151         }
1152
1153         /* And powerdown the camera until streaming starts */
1154         pwc_camera_power(pdev, 0);
1155
1156         /* Register the v4l2_device structure */
1157         pdev->v4l2_dev.release = pwc_video_release;
1158         rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1159         if (rc) {
1160                 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1161                 goto err_free_controls;
1162         }
1163
1164         pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1165         pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1166
1167         rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1168         if (rc < 0) {
1169                 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1170                 goto err_unregister_v4l2_dev;
1171         }
1172         PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1173
1174 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1175         /* register webcam snapshot button input device */
1176         pdev->button_dev = input_allocate_device();
1177         if (!pdev->button_dev) {
1178                 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1179                 rc = -ENOMEM;
1180                 goto err_video_unreg;
1181         }
1182
1183         usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1184         strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1185
1186         pdev->button_dev->name = "PWC snapshot button";
1187         pdev->button_dev->phys = pdev->button_phys;
1188         usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1189         pdev->button_dev->dev.parent = &pdev->udev->dev;
1190         pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1191         pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1192
1193         rc = input_register_device(pdev->button_dev);
1194         if (rc) {
1195                 input_free_device(pdev->button_dev);
1196                 pdev->button_dev = NULL;
1197                 goto err_video_unreg;
1198         }
1199 #endif
1200
1201         return 0;
1202
1203 err_video_unreg:
1204         video_unregister_device(&pdev->vdev);
1205 err_unregister_v4l2_dev:
1206         v4l2_device_unregister(&pdev->v4l2_dev);
1207 err_free_controls:
1208         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1209 err_free_mem:
1210         if (hint < MAX_DEV_HINTS)
1211                 device_hint[hint].pdev = NULL;
1212         kfree(pdev);
1213         return rc;
1214 }
1215
1216 /* The user yanked out the cable... */
1217 static void usb_pwc_disconnect(struct usb_interface *intf)
1218 {
1219         struct v4l2_device *v = usb_get_intfdata(intf);
1220         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1221
1222         mutex_lock(&pdev->udevlock);
1223         /* No need to keep the urbs around after disconnection */
1224         pwc_isoc_cleanup(pdev);
1225         pdev->udev = NULL;
1226         mutex_unlock(&pdev->udevlock);
1227
1228         pwc_cleanup_queued_bufs(pdev);
1229
1230         video_unregister_device(&pdev->vdev);
1231         v4l2_device_unregister(&pdev->v4l2_dev);
1232
1233 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1234         if (pdev->button_dev)
1235                 input_unregister_device(pdev->button_dev);
1236 #endif
1237
1238         v4l2_device_put(&pdev->v4l2_dev);
1239 }
1240
1241
1242 /*
1243  * Initialization code & module stuff
1244  */
1245
1246 static int fps;
1247 static int leds[2] = { -1, -1 };
1248 static unsigned int leds_nargs;
1249 static char *dev_hint[MAX_DEV_HINTS];
1250 static unsigned int dev_hint_nargs;
1251
1252 module_param(fps, int, 0444);
1253 #ifdef CONFIG_USB_PWC_DEBUG
1254 module_param_named(trace, pwc_trace, int, 0644);
1255 #endif
1256 module_param(power_save, int, 0644);
1257 module_param_array(leds, int, &leds_nargs, 0444);
1258 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1259
1260 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1261 #ifdef CONFIG_USB_PWC_DEBUG
1262 MODULE_PARM_DESC(trace, "For debugging purposes");
1263 #endif
1264 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1265 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1266 MODULE_PARM_DESC(dev_hint, "Device node hints");
1267
1268 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1269 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1270 MODULE_LICENSE("GPL");
1271 MODULE_ALIAS("pwcx");
1272 MODULE_VERSION( PWC_VERSION );
1273
1274 static int __init usb_pwc_init(void)
1275 {
1276         int i;
1277
1278 #ifdef CONFIG_USB_PWC_DEBUG
1279         PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1280         PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1281         PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1282         PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1283
1284         if (pwc_trace >= 0) {
1285                 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1286         }
1287 #endif
1288
1289         if (fps) {
1290                 if (fps < 4 || fps > 30) {
1291                         PWC_ERROR("Framerate out of bounds (4-30).\n");
1292                         return -EINVAL;
1293                 }
1294                 default_fps = fps;
1295                 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1296         }
1297
1298         if (leds[0] >= 0)
1299                 led_on = leds[0];
1300         if (leds[1] >= 0)
1301                 led_off = leds[1];
1302
1303         /* Big device node whoopla. Basically, it allows you to assign a
1304            device node (/dev/videoX) to a camera, based on its type
1305            & serial number. The format is [type[.serialnumber]:]node.
1306
1307            Any camera that isn't matched by these rules gets the next
1308            available free device node.
1309          */
1310         for (i = 0; i < MAX_DEV_HINTS; i++) {
1311                 char *s, *colon, *dot;
1312
1313                 /* This loop also initializes the array */
1314                 device_hint[i].pdev = NULL;
1315                 s = dev_hint[i];
1316                 if (s != NULL && *s != '\0') {
1317                         device_hint[i].type = -1; /* wildcard */
1318                         strcpy(device_hint[i].serial_number, "*");
1319
1320                         /* parse string: chop at ':' & '/' */
1321                         colon = dot = s;
1322                         while (*colon != '\0' && *colon != ':')
1323                                 colon++;
1324                         while (*dot != '\0' && *dot != '.')
1325                                 dot++;
1326                         /* Few sanity checks */
1327                         if (*dot != '\0' && dot > colon) {
1328                                 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
1329                                 return -EINVAL;
1330                         }
1331
1332                         if (*colon == '\0') {
1333                                 /* No colon */
1334                                 if (*dot != '\0') {
1335                                         PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
1336                                         return -EINVAL;
1337                                 }
1338                                 else {
1339                                         /* No type or serial number specified, just a number. */
1340                                         device_hint[i].device_node =
1341                                                 simple_strtol(s, NULL, 10);
1342                                 }
1343                         }
1344                         else {
1345                                 /* There's a colon, so we have at least a type and a device node */
1346                                 device_hint[i].type =
1347                                         simple_strtol(s, NULL, 10);
1348                                 device_hint[i].device_node =
1349                                         simple_strtol(colon + 1, NULL, 10);
1350                                 if (*dot != '\0') {
1351                                         /* There's a serial number as well */
1352                                         int k;
1353
1354                                         dot++;
1355                                         k = 0;
1356                                         while (*dot != ':' && k < 29) {
1357                                                 device_hint[i].serial_number[k++] = *dot;
1358                                                 dot++;
1359                                         }
1360                                         device_hint[i].serial_number[k] = '\0';
1361                                 }
1362                         }
1363                         PWC_TRACE("device_hint[%d]:\n", i);
1364                         PWC_TRACE("  type    : %d\n", device_hint[i].type);
1365                         PWC_TRACE("  serial# : %s\n", device_hint[i].serial_number);
1366                         PWC_TRACE("  node    : %d\n", device_hint[i].device_node);
1367                 }
1368                 else
1369                         device_hint[i].type = 0; /* not filled */
1370         } /* ..for MAX_DEV_HINTS */
1371
1372         PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
1373         return usb_register(&pwc_driver);
1374 }
1375
1376 static void __exit usb_pwc_exit(void)
1377 {
1378         PWC_DEBUG_MODULE("Deregistering driver.\n");
1379         usb_deregister(&pwc_driver);
1380         PWC_INFO("Philips webcam module removed.\n");
1381 }
1382
1383 module_init(usb_pwc_init);
1384 module_exit(usb_pwc_exit);
1385
1386 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */