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