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