Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/media/usb/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 #ifdef CONFIG_USB_PWC_DEBUG
132         int pwc_trace = PWC_DEBUG_LEVEL;
133 #endif
134 static int power_save = -1;
135 static int leds[2] = { 100, 0 };
136 
137 /***/
138 
139 static const struct v4l2_file_operations pwc_fops = {
140         .owner =        THIS_MODULE,
141         .open =         v4l2_fh_open,
142         .release =      vb2_fop_release,
143         .read =         vb2_fop_read,
144         .poll =         vb2_fop_poll,
145         .mmap =         vb2_fop_mmap,
146         .unlocked_ioctl = video_ioctl2,
147 };
148 static struct video_device pwc_template = {
149         .name =         "Philips Webcam",       /* Filled in later */
150         .release =      video_device_release_empty,
151         .fops =         &pwc_fops,
152         .ioctl_ops =    &pwc_ioctl_ops,
153 };
154 
155 /***************************************************************************/
156 /* Private functions */
157 
158 static struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
159 {
160         unsigned long flags = 0;
161         struct pwc_frame_buf *buf = NULL;
162 
163         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
164         if (list_empty(&pdev->queued_bufs))
165                 goto leave;
166 
167         buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
168         list_del(&buf->list);
169 leave:
170         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
171         return buf;
172 }
173 
174 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
175 {
176         if (down) {
177                 PWC_TRACE("Snapshot button pressed.\n");
178         } else {
179                 PWC_TRACE("Snapshot button released.\n");
180         }
181 
182 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
183         if (pdev->button_dev) {
184                 input_report_key(pdev->button_dev, KEY_CAMERA, down);
185                 input_sync(pdev->button_dev);
186         }
187 #endif
188 }
189 
190 static void pwc_frame_complete(struct pwc_device *pdev)
191 {
192         struct pwc_frame_buf *fbuf = pdev->fill_buf;
193 
194         /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
195            frames on the USB wire after an exposure change. This conditition is
196            however detected  in the cam and a bit is set in the header.
197            */
198         if (pdev->type == 730) {
199                 unsigned char *ptr = (unsigned char *)fbuf->data;
200 
201                 if (ptr[1] == 1 && ptr[0] & 0x10) {
202                         PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
203                         pdev->drop_frames += 2;
204                 }
205                 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
206                         pwc_snapshot_button(pdev, ptr[0] & 0x01);
207                 }
208                 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
209                         if (ptr[0] & 0x02)
210                                 PWC_TRACE("Image is mirrored.\n");
211                         else
212                                 PWC_TRACE("Image is normal.\n");
213                 }
214                 pdev->vmirror = ptr[0] & 0x03;
215                 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
216                    after a short frame; this condition is filtered out specifically. A 4 byte
217                    frame doesn't make sense anyway.
218                    So we get either this sequence:
219                    drop_bit set -> 4 byte frame -> short frame -> good frame
220                    Or this one:
221                    drop_bit set -> short frame -> good frame
222                    So we drop either 3 or 2 frames in all!
223                    */
224                 if (fbuf->filled == 4)
225                         pdev->drop_frames++;
226         } else if (pdev->type == 740 || pdev->type == 720) {
227                 unsigned char *ptr = (unsigned char *)fbuf->data;
228                 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
229                         pwc_snapshot_button(pdev, ptr[0] & 0x01);
230                 }
231                 pdev->vmirror = ptr[0] & 0x03;
232         }
233 
234         /* In case we were instructed to drop the frame, do so silently. */
235         if (pdev->drop_frames > 0) {
236                 pdev->drop_frames--;
237         } else {
238                 /* Check for underflow first */
239                 if (fbuf->filled < pdev->frame_total_size) {
240                         PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
241                                        " discarded.\n", fbuf->filled);
242                 } else {
243                         fbuf->vb.v4l2_buf.field = V4L2_FIELD_NONE;
244                         fbuf->vb.v4l2_buf.sequence = pdev->vframe_count;
245                         vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
246                         pdev->fill_buf = NULL;
247                         pdev->vsync = 0;
248                 }
249         } /* !drop_frames */
250         pdev->vframe_count++;
251 }
252 
253 /* This gets called for the Isochronous pipe (video). This is done in
254  * interrupt time, so it has to be fast, not crash, and not stall. Neat.
255  */
256 static void pwc_isoc_handler(struct urb *urb)
257 {
258         struct pwc_device *pdev = (struct pwc_device *)urb->context;
259         int i, fst, flen;
260         unsigned char *iso_buf = NULL;
261 
262         if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
263             urb->status == -ESHUTDOWN) {
264                 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
265                 return;
266         }
267 
268         if (pdev->fill_buf == NULL)
269                 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
270 
271         if (urb->status != 0) {
272                 const char *errmsg;
273 
274                 errmsg = "Unknown";
275                 switch(urb->status) {
276                         case -ENOSR:            errmsg = "Buffer error (overrun)"; break;
277                         case -EPIPE:            errmsg = "Stalled (device not responding)"; break;
278                         case -EOVERFLOW:        errmsg = "Babble (bad cable?)"; break;
279                         case -EPROTO:           errmsg = "Bit-stuff error (bad cable?)"; break;
280                         case -EILSEQ:           errmsg = "CRC/Timeout (could be anything)"; break;
281                         case -ETIME:            errmsg = "Device does not respond"; break;
282                 }
283                 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
284                           urb->status, errmsg);
285                 /* Give up after a number of contiguous errors */
286                 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
287                 {
288                         PWC_ERROR("Too many ISOC errors, bailing out.\n");
289                         if (pdev->fill_buf) {
290                                 vb2_buffer_done(&pdev->fill_buf->vb,
291                                                 VB2_BUF_STATE_ERROR);
292                                 pdev->fill_buf = NULL;
293                         }
294                 }
295                 pdev->vsync = 0; /* Drop the current frame */
296                 goto handler_end;
297         }
298 
299         /* Reset ISOC error counter. We did get here, after all. */
300         pdev->visoc_errors = 0;
301 
302         /* vsync: 0 = don't copy data
303                   1 = sync-hunt
304                   2 = synched
305          */
306         /* Compact data */
307         for (i = 0; i < urb->number_of_packets; i++) {
308                 fst  = urb->iso_frame_desc[i].status;
309                 flen = urb->iso_frame_desc[i].actual_length;
310                 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
311                 if (fst != 0) {
312                         PWC_ERROR("Iso frame %d has error %d\n", i, fst);
313                         continue;
314                 }
315                 if (flen > 0 && pdev->vsync) {
316                         struct pwc_frame_buf *fbuf = pdev->fill_buf;
317 
318                         if (pdev->vsync == 1) {
319                                 v4l2_get_timestamp(
320                                         &fbuf->vb.v4l2_buf.timestamp);
321                                 pdev->vsync = 2;
322                         }
323 
324                         if (flen + fbuf->filled > pdev->frame_total_size) {
325                                 PWC_ERROR("Frame overflow (%d > %d)\n",
326                                           flen + fbuf->filled,
327                                           pdev->frame_total_size);
328                                 pdev->vsync = 0; /* Let's wait for an EOF */
329                         } else {
330                                 memcpy(fbuf->data + fbuf->filled, iso_buf,
331                                        flen);
332                                 fbuf->filled += flen;
333                         }
334                 }
335                 if (flen < pdev->vlast_packet_size) {
336                         /* Shorter packet... end of frame */
337                         if (pdev->vsync == 2)
338                                 pwc_frame_complete(pdev);
339                         if (pdev->fill_buf == NULL)
340                                 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
341                         if (pdev->fill_buf) {
342                                 pdev->fill_buf->filled = 0;
343                                 pdev->vsync = 1;
344                         }
345                 }
346                 pdev->vlast_packet_size = flen;
347         }
348 
349 handler_end:
350         i = usb_submit_urb(urb, GFP_ATOMIC);
351         if (i != 0)
352                 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
353 }
354 
355 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
356 static int pwc_isoc_init(struct pwc_device *pdev)
357 {
358         struct usb_device *udev;
359         struct urb *urb;
360         int i, j, ret;
361         struct usb_interface *intf;
362         struct usb_host_interface *idesc = NULL;
363         int compression = 0; /* 0..3 = uncompressed..high */
364 
365         pdev->vsync = 0;
366         pdev->vlast_packet_size = 0;
367         pdev->fill_buf = NULL;
368         pdev->vframe_count = 0;
369         pdev->visoc_errors = 0;
370         udev = pdev->udev;
371 
372 retry:
373         /* We first try with low compression and then retry with a higher
374            compression setting if there is not enough bandwidth. */
375         ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
376                                  pdev->vframes, &compression, 1);
377 
378         /* Get the current alternate interface, adjust packet size */
379         intf = usb_ifnum_to_if(udev, 0);
380         if (intf)
381                 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
382         if (!idesc)
383                 return -EIO;
384 
385         /* Search video endpoint */
386         pdev->vmax_packet_size = -1;
387         for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
388                 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
389                         pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
390                         break;
391                 }
392         }
393 
394         if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
395                 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
396                 return -ENFILE; /* Odd error, that should be noticeable */
397         }
398 
399         /* Set alternate interface */
400         PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
401         ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
402         if (ret == -ENOSPC && compression < 3) {
403                 compression++;
404                 goto retry;
405         }
406         if (ret < 0)
407                 return ret;
408 
409         /* Allocate and init Isochronuous urbs */
410         for (i = 0; i < MAX_ISO_BUFS; i++) {
411                 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
412                 if (urb == NULL) {
413                         PWC_ERROR("Failed to allocate urb %d\n", i);
414                         pwc_isoc_cleanup(pdev);
415                         return -ENOMEM;
416                 }
417                 pdev->urbs[i] = urb;
418                 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
419 
420                 urb->interval = 1; // devik
421                 urb->dev = udev;
422                 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
423                 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
424                 urb->transfer_buffer = usb_alloc_coherent(udev,
425                                                           ISO_BUFFER_SIZE,
426                                                           GFP_KERNEL,
427                                                           &urb->transfer_dma);
428                 if (urb->transfer_buffer == NULL) {
429                         PWC_ERROR("Failed to allocate urb buffer %d\n", i);
430                         pwc_isoc_cleanup(pdev);
431                         return -ENOMEM;
432                 }
433                 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
434                 urb->complete = pwc_isoc_handler;
435                 urb->context = pdev;
436                 urb->start_frame = 0;
437                 urb->number_of_packets = ISO_FRAMES_PER_DESC;
438                 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
439                         urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
440                         urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
441                 }
442         }
443 
444         /* link */
445         for (i = 0; i < MAX_ISO_BUFS; i++) {
446                 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
447                 if (ret == -ENOSPC && compression < 3) {
448                         compression++;
449                         pwc_isoc_cleanup(pdev);
450                         goto retry;
451                 }
452                 if (ret) {
453                         PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
454                         pwc_isoc_cleanup(pdev);
455                         return ret;
456                 }
457                 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
458         }
459 
460         /* All is done... */
461         PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
462         return 0;
463 }
464 
465 static void pwc_iso_stop(struct pwc_device *pdev)
466 {
467         int i;
468 
469         /* Unlinking ISOC buffers one by one */
470         for (i = 0; i < MAX_ISO_BUFS; i++) {
471                 if (pdev->urbs[i]) {
472                         PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
473                         usb_kill_urb(pdev->urbs[i]);
474                 }
475         }
476 }
477 
478 static void pwc_iso_free(struct pwc_device *pdev)
479 {
480         int i;
481 
482         /* Freeing ISOC buffers one by one */
483         for (i = 0; i < MAX_ISO_BUFS; i++) {
484                 if (pdev->urbs[i]) {
485                         PWC_DEBUG_MEMORY("Freeing URB\n");
486                         if (pdev->urbs[i]->transfer_buffer) {
487                                 usb_free_coherent(pdev->udev,
488                                         pdev->urbs[i]->transfer_buffer_length,
489                                         pdev->urbs[i]->transfer_buffer,
490                                         pdev->urbs[i]->transfer_dma);
491                         }
492                         usb_free_urb(pdev->urbs[i]);
493                         pdev->urbs[i] = NULL;
494                 }
495         }
496 }
497 
498 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
499 static void pwc_isoc_cleanup(struct pwc_device *pdev)
500 {
501         PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
502 
503         pwc_iso_stop(pdev);
504         pwc_iso_free(pdev);
505         usb_set_interface(pdev->udev, 0, 0);
506 
507         PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
508 }
509 
510 /* Must be called with vb_queue_lock hold */
511 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev)
512 {
513         unsigned long flags = 0;
514 
515         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
516         while (!list_empty(&pdev->queued_bufs)) {
517                 struct pwc_frame_buf *buf;
518 
519                 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
520                                  list);
521                 list_del(&buf->list);
522                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
523         }
524         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
525 }
526 
527 #ifdef CONFIG_USB_PWC_DEBUG
528 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
529 {
530         switch(sensor_type) {
531                 case 0x00:
532                         return "Hyundai CMOS sensor";
533                 case 0x20:
534                         return "Sony CCD sensor + TDA8787";
535                 case 0x2E:
536                         return "Sony CCD sensor + Exas 98L59";
537                 case 0x2F:
538                         return "Sony CCD sensor + ADI 9804";
539                 case 0x30:
540                         return "Sharp CCD sensor + TDA8787";
541                 case 0x3E:
542                         return "Sharp CCD sensor + Exas 98L59";
543                 case 0x3F:
544                         return "Sharp CCD sensor + ADI 9804";
545                 case 0x40:
546                         return "UPA 1021 sensor";
547                 case 0x100:
548                         return "VGA sensor";
549                 case 0x101:
550                         return "PAL MR sensor";
551                 default:
552                         return "unknown type of sensor";
553         }
554 }
555 #endif
556 
557 /***************************************************************************/
558 /* Video4Linux functions */
559 
560 static void pwc_video_release(struct v4l2_device *v)
561 {
562         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
563 
564         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
565         v4l2_device_unregister(&pdev->v4l2_dev);
566         kfree(pdev->ctrl_buf);
567         kfree(pdev);
568 }
569 
570 /***************************************************************************/
571 /* Videobuf2 operations */
572 
573 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
574                                 unsigned int *nbuffers, unsigned int *nplanes,
575                                 unsigned int sizes[], void *alloc_ctxs[])
576 {
577         struct pwc_device *pdev = vb2_get_drv_priv(vq);
578         int size;
579 
580         if (*nbuffers < MIN_FRAMES)
581                 *nbuffers = MIN_FRAMES;
582         else if (*nbuffers > MAX_FRAMES)
583                 *nbuffers = MAX_FRAMES;
584 
585         *nplanes = 1;
586 
587         size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
588         sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
589                               pwc_image_sizes[size][1] * 3 / 2);
590 
591         return 0;
592 }
593 
594 static int buffer_init(struct vb2_buffer *vb)
595 {
596         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
597 
598         /* need vmalloc since frame buffer > 128K */
599         buf->data = vzalloc(PWC_FRAME_SIZE);
600         if (buf->data == NULL)
601                 return -ENOMEM;
602 
603         return 0;
604 }
605 
606 static int buffer_prepare(struct vb2_buffer *vb)
607 {
608         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
609 
610         /* Don't allow queing new buffers after device disconnection */
611         if (!pdev->udev)
612                 return -ENODEV;
613 
614         return 0;
615 }
616 
617 static void buffer_finish(struct vb2_buffer *vb)
618 {
619         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
620         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
621 
622         if (vb->state == VB2_BUF_STATE_DONE) {
623                 /*
624                  * Application has called dqbuf and is getting back a buffer
625                  * we've filled, take the pwc data we've stored in buf->data
626                  * and decompress it into a usable format, storing the result
627                  * in the vb2_buffer.
628                  */
629                 pwc_decompress(pdev, buf);
630         }
631 }
632 
633 static void buffer_cleanup(struct vb2_buffer *vb)
634 {
635         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
636 
637         vfree(buf->data);
638 }
639 
640 static void buffer_queue(struct vb2_buffer *vb)
641 {
642         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
643         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
644         unsigned long flags = 0;
645 
646         /* Check the device has not disconnected between prep and queuing */
647         if (!pdev->udev) {
648                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
649                 return;
650         }
651 
652         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
653         list_add_tail(&buf->list, &pdev->queued_bufs);
654         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
655 }
656 
657 static int start_streaming(struct vb2_queue *vq, unsigned int count)
658 {
659         struct pwc_device *pdev = vb2_get_drv_priv(vq);
660         int r;
661 
662         if (!pdev->udev)
663                 return -ENODEV;
664 
665         if (mutex_lock_interruptible(&pdev->v4l2_lock))
666                 return -ERESTARTSYS;
667         /* Turn on camera and set LEDS on */
668         pwc_camera_power(pdev, 1);
669         pwc_set_leds(pdev, leds[0], leds[1]);
670 
671         r = pwc_isoc_init(pdev);
672         if (r) {
673                 /* If we failed turn camera and LEDS back off */
674                 pwc_set_leds(pdev, 0, 0);
675                 pwc_camera_power(pdev, 0);
676                 /* And cleanup any queued bufs!! */
677                 pwc_cleanup_queued_bufs(pdev);
678         }
679         mutex_unlock(&pdev->v4l2_lock);
680 
681         return r;
682 }
683 
684 static int stop_streaming(struct vb2_queue *vq)
685 {
686         struct pwc_device *pdev = vb2_get_drv_priv(vq);
687 
688         if (mutex_lock_interruptible(&pdev->v4l2_lock))
689                 return -ERESTARTSYS;
690         if (pdev->udev) {
691                 pwc_set_leds(pdev, 0, 0);
692                 pwc_camera_power(pdev, 0);
693                 pwc_isoc_cleanup(pdev);
694         }
695 
696         pwc_cleanup_queued_bufs(pdev);
697         mutex_unlock(&pdev->v4l2_lock);
698 
699         return 0;
700 }
701 
702 static struct vb2_ops pwc_vb_queue_ops = {
703         .queue_setup            = queue_setup,
704         .buf_init               = buffer_init,
705         .buf_prepare            = buffer_prepare,
706         .buf_finish             = buffer_finish,
707         .buf_cleanup            = buffer_cleanup,
708         .buf_queue              = buffer_queue,
709         .start_streaming        = start_streaming,
710         .stop_streaming         = stop_streaming,
711         .wait_prepare           = vb2_ops_wait_prepare,
712         .wait_finish            = vb2_ops_wait_finish,
713 };
714 
715 /***************************************************************************/
716 /* USB functions */
717 
718 /* This function gets called when a new device is plugged in or the usb core
719  * is loaded.
720  */
721 
722 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
723 {
724         struct usb_device *udev = interface_to_usbdev(intf);
725         struct pwc_device *pdev = NULL;
726         int vendor_id, product_id, type_id;
727         int rc;
728         int features = 0;
729         int compression = 0;
730         int my_power_save = power_save;
731         char serial_number[30], *name;
732 
733         vendor_id = le16_to_cpu(udev->descriptor.idVendor);
734         product_id = le16_to_cpu(udev->descriptor.idProduct);
735 
736         /* Check if we can handle this device */
737         PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
738                 vendor_id, product_id,
739                 intf->altsetting->desc.bInterfaceNumber);
740 
741         /* the interfaces are probed one by one. We are only interested in the
742            video interface (0) now.
743            Interface 1 is the Audio Control, and interface 2 Audio itself.
744          */
745         if (intf->altsetting->desc.bInterfaceNumber > 0)
746                 return -ENODEV;
747 
748         if (vendor_id == 0x0471) {
749                 switch (product_id) {
750                 case 0x0302:
751                         PWC_INFO("Philips PCA645VC USB webcam detected.\n");
752                         name = "Philips 645 webcam";
753                         type_id = 645;
754                         break;
755                 case 0x0303:
756                         PWC_INFO("Philips PCA646VC USB webcam detected.\n");
757                         name = "Philips 646 webcam";
758                         type_id = 646;
759                         break;
760                 case 0x0304:
761                         PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
762                         name = "Askey VC010 webcam";
763                         type_id = 646;
764                         break;
765                 case 0x0307:
766                         PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
767                         name = "Philips 675 webcam";
768                         type_id = 675;
769                         break;
770                 case 0x0308:
771                         PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
772                         name = "Philips 680 webcam";
773                         type_id = 680;
774                         break;
775                 case 0x030C:
776                         PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
777                         name = "Philips 690 webcam";
778                         type_id = 690;
779                         break;
780                 case 0x0310:
781                         PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
782                         name = "Philips 730 webcam";
783                         type_id = 730;
784                         break;
785                 case 0x0311:
786                         PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
787                         name = "Philips 740 webcam";
788                         type_id = 740;
789                         break;
790                 case 0x0312:
791                         PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
792                         name = "Philips 750 webcam";
793                         type_id = 750;
794                         break;
795                 case 0x0313:
796                         PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
797                         name = "Philips 720K/40 webcam";
798                         type_id = 720;
799                         break;
800                 case 0x0329:
801                         PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
802                         name = "Philips SPC 900NC webcam";
803                         type_id = 740;
804                         break;
805                 default:
806                         return -ENODEV;
807                         break;
808                 }
809         }
810         else if (vendor_id == 0x069A) {
811                 switch(product_id) {
812                 case 0x0001:
813                         PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
814                         name = "Askey VC010 webcam";
815                         type_id = 645;
816                         break;
817                 default:
818                         return -ENODEV;
819                         break;
820                 }
821         }
822         else if (vendor_id == 0x046d) {
823                 switch(product_id) {
824                 case 0x08b0:
825                         PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
826                         name = "Logitech QuickCam Pro 3000";
827                         type_id = 740; /* CCD sensor */
828                         break;
829                 case 0x08b1:
830                         PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
831                         name = "Logitech QuickCam Notebook Pro";
832                         type_id = 740; /* CCD sensor */
833                         break;
834                 case 0x08b2:
835                         PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
836                         name = "Logitech QuickCam Pro 4000";
837                         type_id = 740; /* CCD sensor */
838                         if (my_power_save == -1)
839                                 my_power_save = 1;
840                         break;
841                 case 0x08b3:
842                         PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
843                         name = "Logitech QuickCam Zoom";
844                         type_id = 740; /* CCD sensor */
845                         break;
846                 case 0x08B4:
847                         PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
848                         name = "Logitech QuickCam Zoom";
849                         type_id = 740; /* CCD sensor */
850                         if (my_power_save == -1)
851                                 my_power_save = 1;
852                         break;
853                 case 0x08b5:
854                         PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
855                         name = "Logitech QuickCam Orbit";
856                         type_id = 740; /* CCD sensor */
857                         if (my_power_save == -1)
858                                 my_power_save = 1;
859                         features |= FEATURE_MOTOR_PANTILT;
860                         break;
861                 case 0x08b6:
862                         PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
863                         name = "Cisco VT Camera";
864                         type_id = 740; /* CCD sensor */
865                         break;
866                 case 0x08b7:
867                         PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
868                         name = "Logitech ViewPort AV 100";
869                         type_id = 740; /* CCD sensor */
870                         break;
871                 case 0x08b8: /* Where this released? */
872                         PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
873                         name = "Logitech QuickCam (res.)";
874                         type_id = 730; /* Assuming CMOS */
875                         break;
876                 default:
877                         return -ENODEV;
878                         break;
879                 }
880         }
881         else if (vendor_id == 0x055d) {
882                 /* I don't know the difference between the C10 and the C30;
883                    I suppose the difference is the sensor, but both cameras
884                    work equally well with a type_id of 675
885                  */
886                 switch(product_id) {
887                 case 0x9000:
888                         PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
889                         name = "Samsung MPC-C10";
890                         type_id = 675;
891                         break;
892                 case 0x9001:
893                         PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
894                         name = "Samsung MPC-C30";
895                         type_id = 675;
896                         break;
897                 case 0x9002:
898                         PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
899                         name = "Samsung MPC-C30";
900                         type_id = 740;
901                         break;
902                 default:
903                         return -ENODEV;
904                         break;
905                 }
906         }
907         else if (vendor_id == 0x041e) {
908                 switch(product_id) {
909                 case 0x400c:
910                         PWC_INFO("Creative Labs Webcam 5 detected.\n");
911                         name = "Creative Labs Webcam 5";
912                         type_id = 730;
913                         if (my_power_save == -1)
914                                 my_power_save = 1;
915                         break;
916                 case 0x4011:
917                         PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
918                         name = "Creative Labs Webcam Pro Ex";
919                         type_id = 740;
920                         break;
921                 default:
922                         return -ENODEV;
923                         break;
924                 }
925         }
926         else if (vendor_id == 0x04cc) {
927                 switch(product_id) {
928                 case 0x8116:
929                         PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
930                         name = "Sotec Afina Eye";
931                         type_id = 730;
932                         break;
933                 default:
934                         return -ENODEV;
935                         break;
936                 }
937         }
938         else if (vendor_id == 0x06be) {
939                 switch(product_id) {
940                 case 0x8116:
941                         /* This is essentially the same cam as the Sotec Afina Eye */
942                         PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
943                         name = "AME Co. Afina Eye";
944                         type_id = 750;
945                         break;
946                 default:
947                         return -ENODEV;
948                         break;
949                 }
950 
951         }
952         else if (vendor_id == 0x0d81) {
953                 switch(product_id) {
954                 case 0x1900:
955                         PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
956                         name = "Visionite VCS-UC300";
957                         type_id = 740; /* CCD sensor */
958                         break;
959                 case 0x1910:
960                         PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
961                         name = "Visionite VCS-UM100";
962                         type_id = 730; /* CMOS sensor */
963                         break;
964                 default:
965                         return -ENODEV;
966                         break;
967                 }
968         }
969         else
970                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
971 
972         if (my_power_save == -1)
973                 my_power_save = 0;
974 
975         memset(serial_number, 0, 30);
976         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
977         PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
978 
979         if (udev->descriptor.bNumConfigurations > 1)
980                 PWC_WARNING("Warning: more than 1 configuration available.\n");
981 
982         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
983         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
984         if (pdev == NULL) {
985                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
986                 return -ENOMEM;
987         }
988         pdev->type = type_id;
989         pdev->features = features;
990         pwc_construct(pdev); /* set min/max sizes correct */
991 
992         mutex_init(&pdev->v4l2_lock);
993         mutex_init(&pdev->vb_queue_lock);
994         spin_lock_init(&pdev->queued_bufs_lock);
995         INIT_LIST_HEAD(&pdev->queued_bufs);
996 
997         pdev->udev = udev;
998         pdev->power_save = my_power_save;
999 
1000         /* Init videobuf2 queue structure */
1001         pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1002         pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1003         pdev->vb_queue.drv_priv = pdev;
1004         pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1005         pdev->vb_queue.ops = &pwc_vb_queue_ops;
1006         pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1007         pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1008         rc = vb2_queue_init(&pdev->vb_queue);
1009         if (rc < 0) {
1010                 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1011                 goto err_free_mem;
1012         }
1013 
1014         /* Init video_device structure */
1015         pdev->vdev = pwc_template;
1016         strcpy(pdev->vdev.name, name);
1017         pdev->vdev.queue = &pdev->vb_queue;
1018         pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1019         set_bit(V4L2_FL_USE_FH_PRIO, &pdev->vdev.flags);
1020         video_set_drvdata(&pdev->vdev, pdev);
1021 
1022         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1023         PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1024 
1025         /* Allocate USB command buffers */
1026         pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1027         if (!pdev->ctrl_buf) {
1028                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1029                 rc = -ENOMEM;
1030                 goto err_free_mem;
1031         }
1032 
1033 #ifdef CONFIG_USB_PWC_DEBUG
1034         /* Query sensor type */
1035         if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1036                 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1037                                 pdev->vdev.name,
1038                                 pwc_sensor_type_to_string(rc), rc);
1039         }
1040 #endif
1041 
1042         /* Set the leds off */
1043         pwc_set_leds(pdev, 0, 0);
1044 
1045         /* Setup initial videomode */
1046         rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1047                                 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1048         if (rc)
1049                 goto err_free_mem;
1050 
1051         /* Register controls (and read default values from camera */
1052         rc = pwc_init_controls(pdev);
1053         if (rc) {
1054                 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1055                 goto err_free_mem;
1056         }
1057 
1058         /* And powerdown the camera until streaming starts */
1059         pwc_camera_power(pdev, 0);
1060 
1061         /* Register the v4l2_device structure */
1062         pdev->v4l2_dev.release = pwc_video_release;
1063         rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1064         if (rc) {
1065                 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1066                 goto err_free_controls;
1067         }
1068 
1069         pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1070         pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1071         pdev->vdev.lock = &pdev->v4l2_lock;
1072 
1073         rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1074         if (rc < 0) {
1075                 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1076                 goto err_unregister_v4l2_dev;
1077         }
1078         PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1079 
1080 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1081         /* register webcam snapshot button input device */
1082         pdev->button_dev = input_allocate_device();
1083         if (!pdev->button_dev) {
1084                 rc = -ENOMEM;
1085                 goto err_video_unreg;
1086         }
1087 
1088         usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1089         strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1090 
1091         pdev->button_dev->name = "PWC snapshot button";
1092         pdev->button_dev->phys = pdev->button_phys;
1093         usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1094         pdev->button_dev->dev.parent = &pdev->udev->dev;
1095         pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1096         pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1097 
1098         rc = input_register_device(pdev->button_dev);
1099         if (rc) {
1100                 input_free_device(pdev->button_dev);
1101                 pdev->button_dev = NULL;
1102                 goto err_video_unreg;
1103         }
1104 #endif
1105 
1106         return 0;
1107 
1108 err_video_unreg:
1109         video_unregister_device(&pdev->vdev);
1110 err_unregister_v4l2_dev:
1111         v4l2_device_unregister(&pdev->v4l2_dev);
1112 err_free_controls:
1113         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1114 err_free_mem:
1115         kfree(pdev->ctrl_buf);
1116         kfree(pdev);
1117         return rc;
1118 }
1119 
1120 /* The user yanked out the cable... */
1121 static void usb_pwc_disconnect(struct usb_interface *intf)
1122 {
1123         struct v4l2_device *v = usb_get_intfdata(intf);
1124         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1125 
1126         mutex_lock(&pdev->vb_queue_lock);
1127         mutex_lock(&pdev->v4l2_lock);
1128         /* No need to keep the urbs around after disconnection */
1129         if (pdev->vb_queue.streaming)
1130                 pwc_isoc_cleanup(pdev);
1131         pdev->udev = NULL;
1132         pwc_cleanup_queued_bufs(pdev);
1133 
1134         v4l2_device_disconnect(&pdev->v4l2_dev);
1135         video_unregister_device(&pdev->vdev);
1136         mutex_unlock(&pdev->v4l2_lock);
1137         mutex_unlock(&pdev->vb_queue_lock);
1138 
1139 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1140         if (pdev->button_dev)
1141                 input_unregister_device(pdev->button_dev);
1142 #endif
1143 
1144         v4l2_device_put(&pdev->v4l2_dev);
1145 }
1146 
1147 
1148 /*
1149  * Initialization code & module stuff
1150  */
1151 
1152 static unsigned int leds_nargs;
1153 
1154 #ifdef CONFIG_USB_PWC_DEBUG
1155 module_param_named(trace, pwc_trace, int, 0644);
1156 #endif
1157 module_param(power_save, int, 0644);
1158 module_param_array(leds, int, &leds_nargs, 0444);
1159 
1160 #ifdef CONFIG_USB_PWC_DEBUG
1161 MODULE_PARM_DESC(trace, "For debugging purposes");
1162 #endif
1163 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1164 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1165 
1166 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1167 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1168 MODULE_LICENSE("GPL");
1169 MODULE_ALIAS("pwcx");
1170 MODULE_VERSION( PWC_VERSION );
1171 
1172 module_usb_driver(pwc_driver);
1173 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us