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.v4l2_buf.field = V4L2_FIELD_NONE;
245 fbuf->vb.v4l2_buf.sequence = pdev->vframe_count;
246 vb2_buffer_done(&fbuf->vb, 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,
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.v4l2_buf.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)512 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev)
513 {
514 unsigned long flags = 0;
515
516 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
517 while (!list_empty(&pdev->queued_bufs)) {
518 struct pwc_frame_buf *buf;
519
520 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
521 list);
522 list_del(&buf->list);
523 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
524 }
525 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
526 }
527
528 #ifdef CONFIG_USB_PWC_DEBUG
pwc_sensor_type_to_string(unsigned int sensor_type)529 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
530 {
531 switch(sensor_type) {
532 case 0x00:
533 return "Hyundai CMOS sensor";
534 case 0x20:
535 return "Sony CCD sensor + TDA8787";
536 case 0x2E:
537 return "Sony CCD sensor + Exas 98L59";
538 case 0x2F:
539 return "Sony CCD sensor + ADI 9804";
540 case 0x30:
541 return "Sharp CCD sensor + TDA8787";
542 case 0x3E:
543 return "Sharp CCD sensor + Exas 98L59";
544 case 0x3F:
545 return "Sharp CCD sensor + ADI 9804";
546 case 0x40:
547 return "UPA 1021 sensor";
548 case 0x100:
549 return "VGA sensor";
550 case 0x101:
551 return "PAL MR sensor";
552 default:
553 return "unknown type of sensor";
554 }
555 }
556 #endif
557
558 /***************************************************************************/
559 /* Video4Linux functions */
560
pwc_video_release(struct v4l2_device * v)561 static void pwc_video_release(struct v4l2_device *v)
562 {
563 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
564
565 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
566 v4l2_device_unregister(&pdev->v4l2_dev);
567 kfree(pdev->ctrl_buf);
568 kfree(pdev);
569 }
570
571 /***************************************************************************/
572 /* Videobuf2 operations */
573
queue_setup(struct vb2_queue * vq,const struct v4l2_format * fmt,unsigned int * nbuffers,unsigned int * nplanes,unsigned int sizes[],void * alloc_ctxs[])574 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
575 unsigned int *nbuffers, unsigned int *nplanes,
576 unsigned int sizes[], void *alloc_ctxs[])
577 {
578 struct pwc_device *pdev = vb2_get_drv_priv(vq);
579 int size;
580
581 if (*nbuffers < MIN_FRAMES)
582 *nbuffers = MIN_FRAMES;
583 else if (*nbuffers > MAX_FRAMES)
584 *nbuffers = MAX_FRAMES;
585
586 *nplanes = 1;
587
588 size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
589 sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
590 pwc_image_sizes[size][1] * 3 / 2);
591
592 return 0;
593 }
594
buffer_init(struct vb2_buffer * vb)595 static int buffer_init(struct vb2_buffer *vb)
596 {
597 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
598
599 /* need vmalloc since frame buffer > 128K */
600 buf->data = vzalloc(PWC_FRAME_SIZE);
601 if (buf->data == NULL)
602 return -ENOMEM;
603
604 return 0;
605 }
606
buffer_prepare(struct vb2_buffer * vb)607 static int buffer_prepare(struct vb2_buffer *vb)
608 {
609 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
610
611 /* Don't allow queing new buffers after device disconnection */
612 if (!pdev->udev)
613 return -ENODEV;
614
615 return 0;
616 }
617
buffer_finish(struct vb2_buffer * vb)618 static void buffer_finish(struct vb2_buffer *vb)
619 {
620 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
621 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
622
623 if (vb->state == VB2_BUF_STATE_DONE) {
624 /*
625 * Application has called dqbuf and is getting back a buffer
626 * we've filled, take the pwc data we've stored in buf->data
627 * and decompress it into a usable format, storing the result
628 * in the vb2_buffer.
629 */
630 pwc_decompress(pdev, buf);
631 }
632 }
633
buffer_cleanup(struct vb2_buffer * vb)634 static void buffer_cleanup(struct vb2_buffer *vb)
635 {
636 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
637
638 vfree(buf->data);
639 }
640
buffer_queue(struct vb2_buffer * vb)641 static void buffer_queue(struct vb2_buffer *vb)
642 {
643 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
644 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
645 unsigned long flags = 0;
646
647 /* Check the device has not disconnected between prep and queuing */
648 if (!pdev->udev) {
649 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
650 return;
651 }
652
653 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
654 list_add_tail(&buf->list, &pdev->queued_bufs);
655 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
656 }
657
start_streaming(struct vb2_queue * vq,unsigned int count)658 static int start_streaming(struct vb2_queue *vq, unsigned int count)
659 {
660 struct pwc_device *pdev = vb2_get_drv_priv(vq);
661 int r;
662
663 if (!pdev->udev)
664 return -ENODEV;
665
666 if (mutex_lock_interruptible(&pdev->v4l2_lock))
667 return -ERESTARTSYS;
668 /* Turn on camera and set LEDS on */
669 pwc_camera_power(pdev, 1);
670 pwc_set_leds(pdev, leds[0], leds[1]);
671
672 r = pwc_isoc_init(pdev);
673 if (r) {
674 /* If we failed turn camera and LEDS back off */
675 pwc_set_leds(pdev, 0, 0);
676 pwc_camera_power(pdev, 0);
677 /* And cleanup any queued bufs!! */
678 pwc_cleanup_queued_bufs(pdev);
679 }
680 mutex_unlock(&pdev->v4l2_lock);
681
682 return r;
683 }
684
stop_streaming(struct vb2_queue * vq)685 static void stop_streaming(struct vb2_queue *vq)
686 {
687 struct pwc_device *pdev = vb2_get_drv_priv(vq);
688
689 mutex_lock(&pdev->v4l2_lock);
690 if (pdev->udev) {
691 pwc_set_leds(pdev, 0, 0);
692 pwc_camera_power(pdev, 0);
693 pwc_isoc_cleanup(pdev);
694 }
695
696 pwc_cleanup_queued_bufs(pdev);
697 mutex_unlock(&pdev->v4l2_lock);
698 }
699
700 static struct vb2_ops pwc_vb_queue_ops = {
701 .queue_setup = queue_setup,
702 .buf_init = buffer_init,
703 .buf_prepare = buffer_prepare,
704 .buf_finish = buffer_finish,
705 .buf_cleanup = buffer_cleanup,
706 .buf_queue = buffer_queue,
707 .start_streaming = start_streaming,
708 .stop_streaming = stop_streaming,
709 .wait_prepare = vb2_ops_wait_prepare,
710 .wait_finish = vb2_ops_wait_finish,
711 };
712
713 /***************************************************************************/
714 /* USB functions */
715
716 /* This function gets called when a new device is plugged in or the usb core
717 * is loaded.
718 */
719
usb_pwc_probe(struct usb_interface * intf,const struct usb_device_id * id)720 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
721 {
722 struct usb_device *udev = interface_to_usbdev(intf);
723 struct pwc_device *pdev = NULL;
724 int vendor_id, product_id, type_id;
725 int rc;
726 int features = 0;
727 int compression = 0;
728 int my_power_save = power_save;
729 char serial_number[30], *name;
730
731 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
732 product_id = le16_to_cpu(udev->descriptor.idProduct);
733
734 /* Check if we can handle this device */
735 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
736 vendor_id, product_id,
737 intf->altsetting->desc.bInterfaceNumber);
738
739 /* the interfaces are probed one by one. We are only interested in the
740 video interface (0) now.
741 Interface 1 is the Audio Control, and interface 2 Audio itself.
742 */
743 if (intf->altsetting->desc.bInterfaceNumber > 0)
744 return -ENODEV;
745
746 if (vendor_id == 0x0471) {
747 switch (product_id) {
748 case 0x0302:
749 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
750 name = "Philips 645 webcam";
751 type_id = 645;
752 break;
753 case 0x0303:
754 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
755 name = "Philips 646 webcam";
756 type_id = 646;
757 break;
758 case 0x0304:
759 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
760 name = "Askey VC010 webcam";
761 type_id = 646;
762 break;
763 case 0x0307:
764 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
765 name = "Philips 675 webcam";
766 type_id = 675;
767 break;
768 case 0x0308:
769 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
770 name = "Philips 680 webcam";
771 type_id = 680;
772 break;
773 case 0x030C:
774 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
775 name = "Philips 690 webcam";
776 type_id = 690;
777 break;
778 case 0x0310:
779 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
780 name = "Philips 730 webcam";
781 type_id = 730;
782 break;
783 case 0x0311:
784 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
785 name = "Philips 740 webcam";
786 type_id = 740;
787 break;
788 case 0x0312:
789 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
790 name = "Philips 750 webcam";
791 type_id = 750;
792 break;
793 case 0x0313:
794 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
795 name = "Philips 720K/40 webcam";
796 type_id = 720;
797 break;
798 case 0x0329:
799 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
800 name = "Philips SPC 900NC webcam";
801 type_id = 740;
802 break;
803 case 0x032C:
804 PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
805 name = "Philips SPC 880NC webcam";
806 type_id = 740;
807 break;
808 default:
809 return -ENODEV;
810 break;
811 }
812 }
813 else if (vendor_id == 0x069A) {
814 switch(product_id) {
815 case 0x0001:
816 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
817 name = "Askey VC010 webcam";
818 type_id = 645;
819 break;
820 default:
821 return -ENODEV;
822 break;
823 }
824 }
825 else if (vendor_id == 0x046d) {
826 switch(product_id) {
827 case 0x08b0:
828 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
829 name = "Logitech QuickCam Pro 3000";
830 type_id = 740; /* CCD sensor */
831 break;
832 case 0x08b1:
833 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
834 name = "Logitech QuickCam Notebook Pro";
835 type_id = 740; /* CCD sensor */
836 break;
837 case 0x08b2:
838 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
839 name = "Logitech QuickCam Pro 4000";
840 type_id = 740; /* CCD sensor */
841 if (my_power_save == -1)
842 my_power_save = 1;
843 break;
844 case 0x08b3:
845 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
846 name = "Logitech QuickCam Zoom";
847 type_id = 740; /* CCD sensor */
848 break;
849 case 0x08B4:
850 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
851 name = "Logitech QuickCam Zoom";
852 type_id = 740; /* CCD sensor */
853 if (my_power_save == -1)
854 my_power_save = 1;
855 break;
856 case 0x08b5:
857 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
858 name = "Logitech QuickCam Orbit";
859 type_id = 740; /* CCD sensor */
860 if (my_power_save == -1)
861 my_power_save = 1;
862 features |= FEATURE_MOTOR_PANTILT;
863 break;
864 case 0x08b6:
865 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
866 name = "Cisco VT Camera";
867 type_id = 740; /* CCD sensor */
868 break;
869 case 0x08b7:
870 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
871 name = "Logitech ViewPort AV 100";
872 type_id = 740; /* CCD sensor */
873 break;
874 case 0x08b8: /* Where this released? */
875 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
876 name = "Logitech QuickCam (res.)";
877 type_id = 730; /* Assuming CMOS */
878 break;
879 default:
880 return -ENODEV;
881 break;
882 }
883 }
884 else if (vendor_id == 0x055d) {
885 /* I don't know the difference between the C10 and the C30;
886 I suppose the difference is the sensor, but both cameras
887 work equally well with a type_id of 675
888 */
889 switch(product_id) {
890 case 0x9000:
891 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
892 name = "Samsung MPC-C10";
893 type_id = 675;
894 break;
895 case 0x9001:
896 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
897 name = "Samsung MPC-C30";
898 type_id = 675;
899 break;
900 case 0x9002:
901 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
902 name = "Samsung MPC-C30";
903 type_id = 740;
904 break;
905 default:
906 return -ENODEV;
907 break;
908 }
909 }
910 else if (vendor_id == 0x041e) {
911 switch(product_id) {
912 case 0x400c:
913 PWC_INFO("Creative Labs Webcam 5 detected.\n");
914 name = "Creative Labs Webcam 5";
915 type_id = 730;
916 if (my_power_save == -1)
917 my_power_save = 1;
918 break;
919 case 0x4011:
920 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
921 name = "Creative Labs Webcam Pro Ex";
922 type_id = 740;
923 break;
924 default:
925 return -ENODEV;
926 break;
927 }
928 }
929 else if (vendor_id == 0x04cc) {
930 switch(product_id) {
931 case 0x8116:
932 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
933 name = "Sotec Afina Eye";
934 type_id = 730;
935 break;
936 default:
937 return -ENODEV;
938 break;
939 }
940 }
941 else if (vendor_id == 0x06be) {
942 switch(product_id) {
943 case 0x8116:
944 /* This is essentially the same cam as the Sotec Afina Eye */
945 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
946 name = "AME Co. Afina Eye";
947 type_id = 750;
948 break;
949 default:
950 return -ENODEV;
951 break;
952 }
953
954 }
955 else if (vendor_id == 0x0d81) {
956 switch(product_id) {
957 case 0x1900:
958 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
959 name = "Visionite VCS-UC300";
960 type_id = 740; /* CCD sensor */
961 break;
962 case 0x1910:
963 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
964 name = "Visionite VCS-UM100";
965 type_id = 730; /* CMOS sensor */
966 break;
967 default:
968 return -ENODEV;
969 break;
970 }
971 }
972 else
973 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
974
975 if (my_power_save == -1)
976 my_power_save = 0;
977
978 memset(serial_number, 0, 30);
979 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
980 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
981
982 if (udev->descriptor.bNumConfigurations > 1)
983 PWC_WARNING("Warning: more than 1 configuration available.\n");
984
985 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
986 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
987 if (pdev == NULL) {
988 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
989 return -ENOMEM;
990 }
991 pdev->type = type_id;
992 pdev->features = features;
993 pwc_construct(pdev); /* set min/max sizes correct */
994
995 mutex_init(&pdev->v4l2_lock);
996 mutex_init(&pdev->vb_queue_lock);
997 spin_lock_init(&pdev->queued_bufs_lock);
998 INIT_LIST_HEAD(&pdev->queued_bufs);
999
1000 pdev->udev = udev;
1001 pdev->power_save = my_power_save;
1002
1003 /* Init videobuf2 queue structure */
1004 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1005 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1006 pdev->vb_queue.drv_priv = pdev;
1007 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1008 pdev->vb_queue.ops = &pwc_vb_queue_ops;
1009 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1010 pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1011 rc = vb2_queue_init(&pdev->vb_queue);
1012 if (rc < 0) {
1013 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1014 goto err_free_mem;
1015 }
1016
1017 /* Init video_device structure */
1018 pdev->vdev = pwc_template;
1019 strcpy(pdev->vdev.name, name);
1020 pdev->vdev.queue = &pdev->vb_queue;
1021 pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1022 video_set_drvdata(&pdev->vdev, pdev);
1023
1024 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1025 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1026
1027 /* Allocate USB command buffers */
1028 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1029 if (!pdev->ctrl_buf) {
1030 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1031 rc = -ENOMEM;
1032 goto err_free_mem;
1033 }
1034
1035 #ifdef CONFIG_USB_PWC_DEBUG
1036 /* Query sensor type */
1037 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1038 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1039 pdev->vdev.name,
1040 pwc_sensor_type_to_string(rc), rc);
1041 }
1042 #endif
1043
1044 /* Set the leds off */
1045 pwc_set_leds(pdev, 0, 0);
1046
1047 /* Setup initial videomode */
1048 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1049 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1050 if (rc)
1051 goto err_free_mem;
1052
1053 /* Register controls (and read default values from camera */
1054 rc = pwc_init_controls(pdev);
1055 if (rc) {
1056 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1057 goto err_free_mem;
1058 }
1059
1060 /* And powerdown the camera until streaming starts */
1061 pwc_camera_power(pdev, 0);
1062
1063 /* Register the v4l2_device structure */
1064 pdev->v4l2_dev.release = pwc_video_release;
1065 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1066 if (rc) {
1067 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1068 goto err_free_controls;
1069 }
1070
1071 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1072 pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1073 pdev->vdev.lock = &pdev->v4l2_lock;
1074
1075 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1076 if (rc < 0) {
1077 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1078 goto err_unregister_v4l2_dev;
1079 }
1080 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1081
1082 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1083 /* register webcam snapshot button input device */
1084 pdev->button_dev = input_allocate_device();
1085 if (!pdev->button_dev) {
1086 rc = -ENOMEM;
1087 goto err_video_unreg;
1088 }
1089
1090 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1091 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1092
1093 pdev->button_dev->name = "PWC snapshot button";
1094 pdev->button_dev->phys = pdev->button_phys;
1095 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1096 pdev->button_dev->dev.parent = &pdev->udev->dev;
1097 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1098 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1099
1100 rc = input_register_device(pdev->button_dev);
1101 if (rc) {
1102 input_free_device(pdev->button_dev);
1103 pdev->button_dev = NULL;
1104 goto err_video_unreg;
1105 }
1106 #endif
1107
1108 return 0;
1109
1110 err_video_unreg:
1111 video_unregister_device(&pdev->vdev);
1112 err_unregister_v4l2_dev:
1113 v4l2_device_unregister(&pdev->v4l2_dev);
1114 err_free_controls:
1115 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1116 err_free_mem:
1117 kfree(pdev->ctrl_buf);
1118 kfree(pdev);
1119 return rc;
1120 }
1121
1122 /* The user yanked out the cable... */
usb_pwc_disconnect(struct usb_interface * intf)1123 static void usb_pwc_disconnect(struct usb_interface *intf)
1124 {
1125 struct v4l2_device *v = usb_get_intfdata(intf);
1126 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1127
1128 mutex_lock(&pdev->vb_queue_lock);
1129 mutex_lock(&pdev->v4l2_lock);
1130 /* No need to keep the urbs around after disconnection */
1131 if (pdev->vb_queue.streaming)
1132 pwc_isoc_cleanup(pdev);
1133 pdev->udev = NULL;
1134 pwc_cleanup_queued_bufs(pdev);
1135
1136 v4l2_device_disconnect(&pdev->v4l2_dev);
1137 video_unregister_device(&pdev->vdev);
1138 mutex_unlock(&pdev->v4l2_lock);
1139 mutex_unlock(&pdev->vb_queue_lock);
1140
1141 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1142 if (pdev->button_dev)
1143 input_unregister_device(pdev->button_dev);
1144 #endif
1145
1146 v4l2_device_put(&pdev->v4l2_dev);
1147 }
1148
1149
1150 /*
1151 * Initialization code & module stuff
1152 */
1153
1154 static unsigned int leds_nargs;
1155
1156 #ifdef CONFIG_USB_PWC_DEBUG
1157 module_param_named(trace, pwc_trace, int, 0644);
1158 #endif
1159 module_param(power_save, int, 0644);
1160 module_param_array(leds, int, &leds_nargs, 0444);
1161
1162 #ifdef CONFIG_USB_PWC_DEBUG
1163 MODULE_PARM_DESC(trace, "For debugging purposes");
1164 #endif
1165 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1166 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1167
1168 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1169 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1170 MODULE_LICENSE("GPL");
1171 MODULE_ALIAS("pwcx");
1172 MODULE_VERSION( PWC_VERSION );
1173
1174 module_usb_driver(pwc_driver);
1175