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