Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5

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.field = V4L2_FIELD_NONE;
244                         fbuf->vb.sequence = pdev->vframe_count;
245                         vb2_buffer_done(&fbuf->vb.vb2_buf, 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.vb2_buf,
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                                 fbuf->vb.vb2_buf.timestamp = ktime_get_ns();
320                                 pdev->vsync = 2;
321                         }
322 
323                         if (flen + fbuf->filled > pdev->frame_total_size) {
324                                 PWC_ERROR("Frame overflow (%d > %d)\n",
325                                           flen + fbuf->filled,
326                                           pdev->frame_total_size);
327                                 pdev->vsync = 0; /* Let's wait for an EOF */
328                         } else {
329                                 memcpy(fbuf->data + fbuf->filled, iso_buf,
330                                        flen);
331                                 fbuf->filled += flen;
332                         }
333                 }
334                 if (flen < pdev->vlast_packet_size) {
335                         /* Shorter packet... end of frame */
336                         if (pdev->vsync == 2)
337                                 pwc_frame_complete(pdev);
338                         if (pdev->fill_buf == NULL)
339                                 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
340                         if (pdev->fill_buf) {
341                                 pdev->fill_buf->filled = 0;
342                                 pdev->vsync = 1;
343                         }
344                 }
345                 pdev->vlast_packet_size = flen;
346         }
347 
348 handler_end:
349         i = usb_submit_urb(urb, GFP_ATOMIC);
350         if (i != 0)
351                 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
352 }
353 
354 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
355 static int pwc_isoc_init(struct pwc_device *pdev)
356 {
357         struct usb_device *udev;
358         struct urb *urb;
359         int i, j, ret;
360         struct usb_interface *intf;
361         struct usb_host_interface *idesc = NULL;
362         int compression = 0; /* 0..3 = uncompressed..high */
363 
364         pdev->vsync = 0;
365         pdev->vlast_packet_size = 0;
366         pdev->fill_buf = NULL;
367         pdev->vframe_count = 0;
368         pdev->visoc_errors = 0;
369         udev = pdev->udev;
370 
371 retry:
372         /* We first try with low compression and then retry with a higher
373            compression setting if there is not enough bandwidth. */
374         ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
375                                  pdev->vframes, &compression, 1);
376 
377         /* Get the current alternate interface, adjust packet size */
378         intf = usb_ifnum_to_if(udev, 0);
379         if (intf)
380                 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
381         if (!idesc)
382                 return -EIO;
383 
384         /* Search video endpoint */
385         pdev->vmax_packet_size = -1;
386         for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
387                 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
388                         pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
389                         break;
390                 }
391         }
392 
393         if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
394                 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
395                 return -ENFILE; /* Odd error, that should be noticeable */
396         }
397 
398         /* Set alternate interface */
399         PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
400         ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
401         if (ret == -ENOSPC && compression < 3) {
402                 compression++;
403                 goto retry;
404         }
405         if (ret < 0)
406                 return ret;
407 
408         /* Allocate and init Isochronuous urbs */
409         for (i = 0; i < MAX_ISO_BUFS; i++) {
410                 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
411                 if (urb == NULL) {
412                         PWC_ERROR("Failed to allocate urb %d\n", i);
413                         pwc_isoc_cleanup(pdev);
414                         return -ENOMEM;
415                 }
416                 pdev->urbs[i] = urb;
417                 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
418 
419                 urb->interval = 1; // devik
420                 urb->dev = udev;
421                 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
422                 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
423                 urb->transfer_buffer = usb_alloc_coherent(udev,
424                                                           ISO_BUFFER_SIZE,
425                                                           GFP_KERNEL,
426                                                           &urb->transfer_dma);
427                 if (urb->transfer_buffer == NULL) {
428                         PWC_ERROR("Failed to allocate urb buffer %d\n", i);
429                         pwc_isoc_cleanup(pdev);
430                         return -ENOMEM;
431                 }
432                 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
433                 urb->complete = pwc_isoc_handler;
434                 urb->context = pdev;
435                 urb->start_frame = 0;
436                 urb->number_of_packets = ISO_FRAMES_PER_DESC;
437                 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
438                         urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
439                         urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
440                 }
441         }
442 
443         /* link */
444         for (i = 0; i < MAX_ISO_BUFS; i++) {
445                 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
446                 if (ret == -ENOSPC && compression < 3) {
447                         compression++;
448                         pwc_isoc_cleanup(pdev);
449                         goto retry;
450                 }
451                 if (ret) {
452                         PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
453                         pwc_isoc_cleanup(pdev);
454                         return ret;
455                 }
456                 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
457         }
458 
459         /* All is done... */
460         PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
461         return 0;
462 }
463 
464 static void pwc_iso_stop(struct pwc_device *pdev)
465 {
466         int i;
467 
468         /* Unlinking ISOC buffers one by one */
469         for (i = 0; i < MAX_ISO_BUFS; i++) {
470                 if (pdev->urbs[i]) {
471                         PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
472                         usb_kill_urb(pdev->urbs[i]);
473                 }
474         }
475 }
476 
477 static void pwc_iso_free(struct pwc_device *pdev)
478 {
479         int i;
480 
481         /* Freeing ISOC buffers one by one */
482         for (i = 0; i < MAX_ISO_BUFS; i++) {
483                 if (pdev->urbs[i]) {
484                         PWC_DEBUG_MEMORY("Freeing URB\n");
485                         if (pdev->urbs[i]->transfer_buffer) {
486                                 usb_free_coherent(pdev->udev,
487                                         pdev->urbs[i]->transfer_buffer_length,
488                                         pdev->urbs[i]->transfer_buffer,
489                                         pdev->urbs[i]->transfer_dma);
490                         }
491                         usb_free_urb(pdev->urbs[i]);
492                         pdev->urbs[i] = NULL;
493                 }
494         }
495 }
496 
497 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
498 static void pwc_isoc_cleanup(struct pwc_device *pdev)
499 {
500         PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
501 
502         pwc_iso_stop(pdev);
503         pwc_iso_free(pdev);
504         usb_set_interface(pdev->udev, 0, 0);
505 
506         PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
507 }
508 
509 /* Must be called with vb_queue_lock hold */
510 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev,
511                                     enum vb2_buffer_state state)
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);
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,
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 vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
597         struct pwc_frame_buf *buf =
598                 container_of(vbuf, struct pwc_frame_buf, vb);
599 
600         /* need vmalloc since frame buffer > 128K */
601         buf->data = vzalloc(PWC_FRAME_SIZE);
602         if (buf->data == NULL)
603                 return -ENOMEM;
604 
605         return 0;
606 }
607 
608 static int buffer_prepare(struct vb2_buffer *vb)
609 {
610         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
611 
612         /* Don't allow queing new buffers after device disconnection */
613         if (!pdev->udev)
614                 return -ENODEV;
615 
616         return 0;
617 }
618 
619 static void buffer_finish(struct vb2_buffer *vb)
620 {
621         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
622         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
623         struct pwc_frame_buf *buf =
624                 container_of(vbuf, struct pwc_frame_buf, vb);
625 
626         if (vb->state == VB2_BUF_STATE_DONE) {
627                 /*
628                  * Application has called dqbuf and is getting back a buffer
629                  * we've filled, take the pwc data we've stored in buf->data
630                  * and decompress it into a usable format, storing the result
631                  * in the vb2_buffer.
632                  */
633                 pwc_decompress(pdev, buf);
634         }
635 }
636 
637 static void buffer_cleanup(struct vb2_buffer *vb)
638 {
639         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
640         struct pwc_frame_buf *buf =
641                 container_of(vbuf, struct pwc_frame_buf, vb);
642 
643         vfree(buf->data);
644 }
645 
646 static void buffer_queue(struct vb2_buffer *vb)
647 {
648         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
649         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
650         struct pwc_frame_buf *buf =
651                 container_of(vbuf, struct pwc_frame_buf, vb);
652         unsigned long flags = 0;
653 
654         /* Check the device has not disconnected between prep and queuing */
655         if (!pdev->udev) {
656                 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
657                 return;
658         }
659 
660         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
661         list_add_tail(&buf->list, &pdev->queued_bufs);
662         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
663 }
664 
665 static int start_streaming(struct vb2_queue *vq, unsigned int count)
666 {
667         struct pwc_device *pdev = vb2_get_drv_priv(vq);
668         int r;
669 
670         if (!pdev->udev)
671                 return -ENODEV;
672 
673         if (mutex_lock_interruptible(&pdev->v4l2_lock))
674                 return -ERESTARTSYS;
675         /* Turn on camera and set LEDS on */
676         pwc_camera_power(pdev, 1);
677         pwc_set_leds(pdev, leds[0], leds[1]);
678 
679         r = pwc_isoc_init(pdev);
680         if (r) {
681                 /* If we failed turn camera and LEDS back off */
682                 pwc_set_leds(pdev, 0, 0);
683                 pwc_camera_power(pdev, 0);
684                 /* And cleanup any queued bufs!! */
685                 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED);
686         }
687         mutex_unlock(&pdev->v4l2_lock);
688 
689         return r;
690 }
691 
692 static void stop_streaming(struct vb2_queue *vq)
693 {
694         struct pwc_device *pdev = vb2_get_drv_priv(vq);
695 
696         mutex_lock(&pdev->v4l2_lock);
697         if (pdev->udev) {
698                 pwc_set_leds(pdev, 0, 0);
699                 pwc_camera_power(pdev, 0);
700                 pwc_isoc_cleanup(pdev);
701         }
702 
703         pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR);
704         if (pdev->fill_buf)
705                 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
706                                 VB2_BUF_STATE_ERROR);
707         mutex_unlock(&pdev->v4l2_lock);
708 }
709 
710 static struct vb2_ops pwc_vb_queue_ops = {
711         .queue_setup            = queue_setup,
712         .buf_init               = buffer_init,
713         .buf_prepare            = buffer_prepare,
714         .buf_finish             = buffer_finish,
715         .buf_cleanup            = buffer_cleanup,
716         .buf_queue              = buffer_queue,
717         .start_streaming        = start_streaming,
718         .stop_streaming         = stop_streaming,
719         .wait_prepare           = vb2_ops_wait_prepare,
720         .wait_finish            = vb2_ops_wait_finish,
721 };
722 
723 /***************************************************************************/
724 /* USB functions */
725 
726 /* This function gets called when a new device is plugged in or the usb core
727  * is loaded.
728  */
729 
730 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
731 {
732         struct usb_device *udev = interface_to_usbdev(intf);
733         struct pwc_device *pdev = NULL;
734         int vendor_id, product_id, type_id;
735         int rc;
736         int features = 0;
737         int compression = 0;
738         int my_power_save = power_save;
739         char serial_number[30], *name;
740 
741         vendor_id = le16_to_cpu(udev->descriptor.idVendor);
742         product_id = le16_to_cpu(udev->descriptor.idProduct);
743 
744         /* Check if we can handle this device */
745         PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
746                 vendor_id, product_id,
747                 intf->altsetting->desc.bInterfaceNumber);
748 
749         /* the interfaces are probed one by one. We are only interested in the
750            video interface (0) now.
751            Interface 1 is the Audio Control, and interface 2 Audio itself.
752          */
753         if (intf->altsetting->desc.bInterfaceNumber > 0)
754                 return -ENODEV;
755 
756         if (vendor_id == 0x0471) {
757                 switch (product_id) {
758                 case 0x0302:
759                         PWC_INFO("Philips PCA645VC USB webcam detected.\n");
760                         name = "Philips 645 webcam";
761                         type_id = 645;
762                         break;
763                 case 0x0303:
764                         PWC_INFO("Philips PCA646VC USB webcam detected.\n");
765                         name = "Philips 646 webcam";
766                         type_id = 646;
767                         break;
768                 case 0x0304:
769                         PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
770                         name = "Askey VC010 webcam";
771                         type_id = 646;
772                         break;
773                 case 0x0307:
774                         PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
775                         name = "Philips 675 webcam";
776                         type_id = 675;
777                         break;
778                 case 0x0308:
779                         PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
780                         name = "Philips 680 webcam";
781                         type_id = 680;
782                         break;
783                 case 0x030C:
784                         PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
785                         name = "Philips 690 webcam";
786                         type_id = 690;
787                         break;
788                 case 0x0310:
789                         PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
790                         name = "Philips 730 webcam";
791                         type_id = 730;
792                         break;
793                 case 0x0311:
794                         PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
795                         name = "Philips 740 webcam";
796                         type_id = 740;
797                         break;
798                 case 0x0312:
799                         PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
800                         name = "Philips 750 webcam";
801                         type_id = 750;
802                         break;
803                 case 0x0313:
804                         PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
805                         name = "Philips 720K/40 webcam";
806                         type_id = 720;
807                         break;
808                 case 0x0329:
809                         PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
810                         name = "Philips SPC 900NC webcam";
811                         type_id = 740;
812                         break;
813                 default:
814                         return -ENODEV;
815                         break;
816                 }
817         }
818         else if (vendor_id == 0x069A) {
819                 switch(product_id) {
820                 case 0x0001:
821                         PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
822                         name = "Askey VC010 webcam";
823                         type_id = 645;
824                         break;
825                 default:
826                         return -ENODEV;
827                         break;
828                 }
829         }
830         else if (vendor_id == 0x046d) {
831                 switch(product_id) {
832                 case 0x08b0:
833                         PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
834                         name = "Logitech QuickCam Pro 3000";
835                         type_id = 740; /* CCD sensor */
836                         break;
837                 case 0x08b1:
838                         PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
839                         name = "Logitech QuickCam Notebook Pro";
840                         type_id = 740; /* CCD sensor */
841                         break;
842                 case 0x08b2:
843                         PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
844                         name = "Logitech QuickCam Pro 4000";
845                         type_id = 740; /* CCD sensor */
846                         if (my_power_save == -1)
847                                 my_power_save = 1;
848                         break;
849                 case 0x08b3:
850                         PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
851                         name = "Logitech QuickCam Zoom";
852                         type_id = 740; /* CCD sensor */
853                         break;
854                 case 0x08B4:
855                         PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
856                         name = "Logitech QuickCam Zoom";
857                         type_id = 740; /* CCD sensor */
858                         if (my_power_save == -1)
859                                 my_power_save = 1;
860                         break;
861                 case 0x08b5:
862                         PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
863                         name = "Logitech QuickCam Orbit";
864                         type_id = 740; /* CCD sensor */
865                         if (my_power_save == -1)
866                                 my_power_save = 1;
867                         features |= FEATURE_MOTOR_PANTILT;
868                         break;
869                 case 0x08b6:
870                         PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
871                         name = "Cisco VT Camera";
872                         type_id = 740; /* CCD sensor */
873                         break;
874                 case 0x08b7:
875                         PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
876                         name = "Logitech ViewPort AV 100";
877                         type_id = 740; /* CCD sensor */
878                         break;
879                 case 0x08b8: /* Where this released? */
880                         PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
881                         name = "Logitech QuickCam (res.)";
882                         type_id = 730; /* Assuming CMOS */
883                         break;
884                 default:
885                         return -ENODEV;
886                         break;
887                 }
888         }
889         else if (vendor_id == 0x055d) {
890                 /* I don't know the difference between the C10 and the C30;
891                    I suppose the difference is the sensor, but both cameras
892                    work equally well with a type_id of 675
893                  */
894                 switch(product_id) {
895                 case 0x9000:
896                         PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
897                         name = "Samsung MPC-C10";
898                         type_id = 675;
899                         break;
900                 case 0x9001:
901                         PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
902                         name = "Samsung MPC-C30";
903                         type_id = 675;
904                         break;
905                 case 0x9002:
906                         PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
907                         name = "Samsung MPC-C30";
908                         type_id = 740;
909                         break;
910                 default:
911                         return -ENODEV;
912                         break;
913                 }
914         }
915         else if (vendor_id == 0x041e) {
916                 switch(product_id) {
917                 case 0x400c:
918                         PWC_INFO("Creative Labs Webcam 5 detected.\n");
919                         name = "Creative Labs Webcam 5";
920                         type_id = 730;
921                         if (my_power_save == -1)
922                                 my_power_save = 1;
923                         break;
924                 case 0x4011:
925                         PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
926                         name = "Creative Labs Webcam Pro Ex";
927                         type_id = 740;
928                         break;
929                 default:
930                         return -ENODEV;
931                         break;
932                 }
933         }
934         else if (vendor_id == 0x04cc) {
935                 switch(product_id) {
936                 case 0x8116:
937                         PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
938                         name = "Sotec Afina Eye";
939                         type_id = 730;
940                         break;
941                 default:
942                         return -ENODEV;
943                         break;
944                 }
945         }
946         else if (vendor_id == 0x06be) {
947                 switch(product_id) {
948                 case 0x8116:
949                         /* This is essentially the same cam as the Sotec Afina Eye */
950                         PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
951                         name = "AME Co. Afina Eye";
952                         type_id = 750;
953                         break;
954                 default:
955                         return -ENODEV;
956                         break;
957                 }
958 
959         }
960         else if (vendor_id == 0x0d81) {
961                 switch(product_id) {
962                 case 0x1900:
963                         PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
964                         name = "Visionite VCS-UC300";
965                         type_id = 740; /* CCD sensor */
966                         break;
967                 case 0x1910:
968                         PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
969                         name = "Visionite VCS-UM100";
970                         type_id = 730; /* CMOS sensor */
971                         break;
972                 default:
973                         return -ENODEV;
974                         break;
975                 }
976         }
977         else
978                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
979 
980         if (my_power_save == -1)
981                 my_power_save = 0;
982 
983         memset(serial_number, 0, 30);
984         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
985         PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
986 
987         if (udev->descriptor.bNumConfigurations > 1)
988                 PWC_WARNING("Warning: more than 1 configuration available.\n");
989 
990         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
991         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
992         if (pdev == NULL) {
993                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
994                 return -ENOMEM;
995         }
996         pdev->type = type_id;
997         pdev->features = features;
998         pwc_construct(pdev); /* set min/max sizes correct */
999 
1000         mutex_init(&pdev->v4l2_lock);
1001         mutex_init(&pdev->vb_queue_lock);
1002         spin_lock_init(&pdev->queued_bufs_lock);
1003         INIT_LIST_HEAD(&pdev->queued_bufs);
1004 
1005         pdev->udev = udev;
1006         pdev->power_save = my_power_save;
1007 
1008         /* Init videobuf2 queue structure */
1009         pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1010         pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1011         pdev->vb_queue.drv_priv = pdev;
1012         pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1013         pdev->vb_queue.ops = &pwc_vb_queue_ops;
1014         pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1015         pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1016         rc = vb2_queue_init(&pdev->vb_queue);
1017         if (rc < 0) {
1018                 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1019                 goto err_free_mem;
1020         }
1021 
1022         /* Init video_device structure */
1023         pdev->vdev = pwc_template;
1024         strcpy(pdev->vdev.name, name);
1025         pdev->vdev.queue = &pdev->vb_queue;
1026         pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1027         video_set_drvdata(&pdev->vdev, pdev);
1028 
1029         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1030         PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1031 
1032         /* Allocate USB command buffers */
1033         pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1034         if (!pdev->ctrl_buf) {
1035                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1036                 rc = -ENOMEM;
1037                 goto err_free_mem;
1038         }
1039 
1040 #ifdef CONFIG_USB_PWC_DEBUG
1041         /* Query sensor type */
1042         if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1043                 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1044                                 pdev->vdev.name,
1045                                 pwc_sensor_type_to_string(rc), rc);
1046         }
1047 #endif
1048 
1049         /* Set the leds off */
1050         pwc_set_leds(pdev, 0, 0);
1051 
1052         /* Setup initial videomode */
1053         rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1054                                 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1055         if (rc)
1056                 goto err_free_mem;
1057 
1058         /* Register controls (and read default values from camera */
1059         rc = pwc_init_controls(pdev);
1060         if (rc) {
1061                 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1062                 goto err_free_mem;
1063         }
1064 
1065         /* And powerdown the camera until streaming starts */
1066         pwc_camera_power(pdev, 0);
1067 
1068         /* Register the v4l2_device structure */
1069         pdev->v4l2_dev.release = pwc_video_release;
1070         rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1071         if (rc) {
1072                 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1073                 goto err_free_controls;
1074         }
1075 
1076         pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1077         pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1078         pdev->vdev.lock = &pdev->v4l2_lock;
1079 
1080         rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1081         if (rc < 0) {
1082                 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1083                 goto err_unregister_v4l2_dev;
1084         }
1085         PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1086 
1087 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1088         /* register webcam snapshot button input device */
1089         pdev->button_dev = input_allocate_device();
1090         if (!pdev->button_dev) {
1091                 rc = -ENOMEM;
1092                 goto err_video_unreg;
1093         }
1094 
1095         usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1096         strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1097 
1098         pdev->button_dev->name = "PWC snapshot button";
1099         pdev->button_dev->phys = pdev->button_phys;
1100         usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1101         pdev->button_dev->dev.parent = &pdev->udev->dev;
1102         pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1103         pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1104 
1105         rc = input_register_device(pdev->button_dev);
1106         if (rc) {
1107                 input_free_device(pdev->button_dev);
1108                 pdev->button_dev = NULL;
1109                 goto err_video_unreg;
1110         }
1111 #endif
1112 
1113         return 0;
1114 
1115 err_video_unreg:
1116         video_unregister_device(&pdev->vdev);
1117 err_unregister_v4l2_dev:
1118         v4l2_device_unregister(&pdev->v4l2_dev);
1119 err_free_controls:
1120         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1121 err_free_mem:
1122         kfree(pdev->ctrl_buf);
1123         kfree(pdev);
1124         return rc;
1125 }
1126 
1127 /* The user yanked out the cable... */
1128 static void usb_pwc_disconnect(struct usb_interface *intf)
1129 {
1130         struct v4l2_device *v = usb_get_intfdata(intf);
1131         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1132 
1133         mutex_lock(&pdev->vb_queue_lock);
1134         mutex_lock(&pdev->v4l2_lock);
1135         /* No need to keep the urbs around after disconnection */
1136         if (pdev->vb_queue.streaming)
1137                 pwc_isoc_cleanup(pdev);
1138         pdev->udev = NULL;
1139 
1140         v4l2_device_disconnect(&pdev->v4l2_dev);
1141         video_unregister_device(&pdev->vdev);
1142         mutex_unlock(&pdev->v4l2_lock);
1143         mutex_unlock(&pdev->vb_queue_lock);
1144 
1145 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1146         if (pdev->button_dev)
1147                 input_unregister_device(pdev->button_dev);
1148 #endif
1149 
1150         v4l2_device_put(&pdev->v4l2_dev);
1151 }
1152 
1153 
1154 /*
1155  * Initialization code & module stuff
1156  */
1157 
1158 static unsigned int leds_nargs;
1159 
1160 #ifdef CONFIG_USB_PWC_DEBUG
1161 module_param_named(trace, pwc_trace, int, 0644);
1162 #endif
1163 module_param(power_save, int, 0644);
1164 module_param_array(leds, int, &leds_nargs, 0444);
1165 
1166 #ifdef CONFIG_USB_PWC_DEBUG
1167 MODULE_PARM_DESC(trace, "For debugging purposes");
1168 #endif
1169 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1170 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1171 
1172 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1173 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1174 MODULE_LICENSE("GPL");
1175 MODULE_ALIAS("pwcx");
1176 MODULE_VERSION( PWC_VERSION );
1177 
1178 module_usb_driver(pwc_driver);
1179 

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