1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Linux driver for Philips webcam
3 USB and Video4Linux interface part.
4 (C) 1999-2004 Nemosoft Unv.
5 (C) 2004-2006 Luc Saillard (luc@saillard.org)
6 (C) 2011 Hans de Goede <hdegoede@redhat.com>
8 NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
9 driver and thus may have bugs that are not present in the original version.
10 Please send bug reports and support requests to <luc@saillard.org>.
11 The decompression routines have been implemented by reverse-engineering the
12 Nemosoft binary pwcx module. Caveat emptor.
18 This code forms the interface between the USB layers and the Philips
19 specific stuff. Some adanved stuff of the driver falls under an
20 NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
21 is thus not distributed in source form. The binary pwcx.o module
22 contains the code that falls under the NDA.
24 In case you're wondering: 'pwc' stands for "Philips WebCam", but
25 I really didn't want to type 'philips_web_cam' every time (I'm lazy as
26 any Linux kernel hacker, but I don't like uncomprehensible abbreviations
29 Oh yes, convention: to disctinguish between all the various pointers to
30 device-structures, I use these names for the pointer variables:
31 udev: struct usb_device *
32 vdev: struct video_device (member of pwc_dev)
33 pdev: struct pwc_devive *
37 - Alvarado: adding whitebalance code
38 - Alistar Moire: QuickCam 3000 Pro device/product ID
39 - Tony Hoyle: Creative Labs Webcam 5 device/product ID
40 - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
41 - Jk Fang: Sotec Afina Eye ID
42 - Xavier Roche: QuickCam Pro 4000 ID
43 - Jens Knudsen: QuickCam Zoom ID
44 - J. Debert: QuickCam for Notebooks ID
45 - Pham Thanh Nam: webcam snapshot button as an event input device
48 #include <linux/errno.h>
49 #include <linux/init.h>
51 #include <linux/module.h>
52 #include <linux/poll.h>
53 #include <linux/slab.h>
54 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
55 #include <linux/usb/input.h>
57 #include <linux/vmalloc.h>
59 #include <linux/kernel.h> /* simple_strtol() */
62 #include "pwc-kiara.h"
63 #include "pwc-timon.h"
64 #include "pwc-dec23.h"
67 #define CREATE_TRACE_POINTS
68 #include <trace/events/pwc.h>
70 /* Function prototypes and driver templates */
72 /* hotplug device table support */
73 static const struct usb_device_id pwc_device_table [] = {
74 { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
75 { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
77 { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam 3000 Pro */
78 { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
79 { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam 4000 Pro */
80 { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
81 { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
82 { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
83 { USB_DEVICE(0x046D, 0x08B6) }, /* Logitech/Cisco VT Camera */
84 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
85 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech QuickCam */
87 { USB_DEVICE(0x0471, 0x0302) }, /* Philips PCA645VC */
88 { USB_DEVICE(0x0471, 0x0303) }, /* Philips PCA646VC */
89 { USB_DEVICE(0x0471, 0x0304) }, /* Askey VC010 type 2 */
90 { USB_DEVICE(0x0471, 0x0307) }, /* Philips PCVC675K (Vesta) */
91 { USB_DEVICE(0x0471, 0x0308) }, /* Philips PCVC680K (Vesta Pro) */
92 { USB_DEVICE(0x0471, 0x030C) }, /* Philips PCVC690K (Vesta Pro Scan) */
93 { USB_DEVICE(0x0471, 0x0310) }, /* Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) */
94 { USB_DEVICE(0x0471, 0x0311) }, /* Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) */
95 { USB_DEVICE(0x0471, 0x0312) }, /* Philips PCVC750K (ToUCam Pro Scan) */
96 { USB_DEVICE(0x0471, 0x0313) }, /* Philips PCVC720K/40 (ToUCam XS) */
97 { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC webcam */
98 { USB_DEVICE(0x0471, 0x032C) }, /* Philips SPC 880NC webcam */
100 { USB_DEVICE(0x04CC, 0x8116) }, /* Sotec Afina Eye */
102 { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
103 { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
104 { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
106 { USB_DEVICE(0x069A, 0x0001) }, /* Askey VC010 type 1 */
108 { USB_DEVICE(0x06BE, 0x8116) }, /* AME Co. Afina Eye */
110 { USB_DEVICE(0x0d81, 0x1900) }, /* Visionite VCS-UC300 */
111 { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite VCS-UM100 */
115 MODULE_DEVICE_TABLE(usb, pwc_device_table);
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);
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() */
128 #define MAX_DEV_HINTS 20
129 #define MAX_ISOC_ERRORS 20
131 #ifdef CONFIG_USB_PWC_DEBUG
132 int pwc_trace = PWC_DEBUG_LEVEL;
134 static int power_save = -1;
135 static int leds[2] = { 100, 0 };
139 static const struct v4l2_file_operations pwc_fops = {
140 .owner = THIS_MODULE,
141 .open = v4l2_fh_open,
142 .release = vb2_fop_release,
143 .read = vb2_fop_read,
144 .poll = vb2_fop_poll,
145 .mmap = vb2_fop_mmap,
146 .unlocked_ioctl = video_ioctl2,
148 static const struct video_device pwc_template = {
149 .name = "Philips Webcam", /* Filled in later */
150 .release = video_device_release_empty,
152 .ioctl_ops = &pwc_ioctl_ops,
155 /***************************************************************************/
156 /* Private functions */
158 static void *pwc_alloc_urb_buffer(struct usb_device *dev,
159 size_t size, dma_addr_t *dma_handle)
161 struct device *dmadev = dev->bus->sysdev;
162 void *buffer = kmalloc(size, GFP_KERNEL);
167 *dma_handle = dma_map_single(dmadev, buffer, size, DMA_FROM_DEVICE);
168 if (dma_mapping_error(dmadev, *dma_handle)) {
176 static void pwc_free_urb_buffer(struct usb_device *dev,
179 dma_addr_t dma_handle)
181 struct device *dmadev = dev->bus->sysdev;
183 dma_unmap_single(dmadev, dma_handle, size, DMA_FROM_DEVICE);
187 static struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
189 unsigned long flags = 0;
190 struct pwc_frame_buf *buf = NULL;
192 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
193 if (list_empty(&pdev->queued_bufs))
196 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
197 list_del(&buf->list);
199 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
203 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
206 PWC_TRACE("Snapshot button pressed.\n");
208 PWC_TRACE("Snapshot button released.\n");
211 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
212 if (pdev->button_dev) {
213 input_report_key(pdev->button_dev, KEY_CAMERA, down);
214 input_sync(pdev->button_dev);
219 static void pwc_frame_complete(struct pwc_device *pdev)
221 struct pwc_frame_buf *fbuf = pdev->fill_buf;
223 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
224 frames on the USB wire after an exposure change. This conditition is
225 however detected in the cam and a bit is set in the header.
227 if (pdev->type == 730) {
228 unsigned char *ptr = (unsigned char *)fbuf->data;
230 if (ptr[1] == 1 && ptr[0] & 0x10) {
231 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
232 pdev->drop_frames += 2;
234 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
235 pwc_snapshot_button(pdev, ptr[0] & 0x01);
237 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
239 PWC_TRACE("Image is mirrored.\n");
241 PWC_TRACE("Image is normal.\n");
243 pdev->vmirror = ptr[0] & 0x03;
244 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
245 after a short frame; this condition is filtered out specifically. A 4 byte
246 frame doesn't make sense anyway.
247 So we get either this sequence:
248 drop_bit set -> 4 byte frame -> short frame -> good frame
250 drop_bit set -> short frame -> good frame
251 So we drop either 3 or 2 frames in all!
253 if (fbuf->filled == 4)
255 } else if (pdev->type == 740 || pdev->type == 720) {
256 unsigned char *ptr = (unsigned char *)fbuf->data;
257 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
258 pwc_snapshot_button(pdev, ptr[0] & 0x01);
260 pdev->vmirror = ptr[0] & 0x03;
263 /* In case we were instructed to drop the frame, do so silently. */
264 if (pdev->drop_frames > 0) {
267 /* Check for underflow first */
268 if (fbuf->filled < pdev->frame_total_size) {
269 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes); discarded.\n",
272 fbuf->vb.field = V4L2_FIELD_NONE;
273 fbuf->vb.sequence = pdev->vframe_count;
274 vb2_buffer_done(&fbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
275 pdev->fill_buf = NULL;
279 pdev->vframe_count++;
282 /* This gets called for the Isochronous pipe (video). This is done in
283 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
285 static void pwc_isoc_handler(struct urb *urb)
287 struct pwc_device *pdev = (struct pwc_device *)urb->context;
288 struct device *dmadev = urb->dev->bus->sysdev;
290 unsigned char *iso_buf = NULL;
292 trace_pwc_handler_enter(urb, pdev);
294 if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
295 urb->status == -ESHUTDOWN) {
296 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronously.\n",
297 urb, urb->status == -ENOENT ? "" : "a");
301 if (pdev->fill_buf == NULL)
302 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
304 if (urb->status != 0) {
308 switch(urb->status) {
309 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
310 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
311 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
312 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
313 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
314 case -ETIME: errmsg = "Device does not respond"; break;
316 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
317 urb->status, errmsg);
318 /* Give up after a number of contiguous errors */
319 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
321 PWC_ERROR("Too many ISOC errors, bailing out.\n");
322 if (pdev->fill_buf) {
323 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
324 VB2_BUF_STATE_ERROR);
325 pdev->fill_buf = NULL;
328 pdev->vsync = 0; /* Drop the current frame */
332 /* Reset ISOC error counter. We did get here, after all. */
333 pdev->visoc_errors = 0;
335 dma_sync_single_for_cpu(dmadev,
337 urb->transfer_buffer_length,
340 /* vsync: 0 = don't copy data
345 for (i = 0; i < urb->number_of_packets; i++) {
346 fst = urb->iso_frame_desc[i].status;
347 flen = urb->iso_frame_desc[i].actual_length;
348 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
350 PWC_ERROR("Iso frame %d has error %d\n", i, fst);
353 if (flen > 0 && pdev->vsync) {
354 struct pwc_frame_buf *fbuf = pdev->fill_buf;
356 if (pdev->vsync == 1) {
357 fbuf->vb.vb2_buf.timestamp = ktime_get_ns();
361 if (flen + fbuf->filled > pdev->frame_total_size) {
362 PWC_ERROR("Frame overflow (%d > %d)\n",
364 pdev->frame_total_size);
365 pdev->vsync = 0; /* Let's wait for an EOF */
367 memcpy(fbuf->data + fbuf->filled, iso_buf,
369 fbuf->filled += flen;
372 if (flen < pdev->vlast_packet_size) {
373 /* Shorter packet... end of frame */
374 if (pdev->vsync == 2)
375 pwc_frame_complete(pdev);
376 if (pdev->fill_buf == NULL)
377 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
378 if (pdev->fill_buf) {
379 pdev->fill_buf->filled = 0;
383 pdev->vlast_packet_size = flen;
386 dma_sync_single_for_device(dmadev,
388 urb->transfer_buffer_length,
392 trace_pwc_handler_exit(urb, pdev);
394 i = usb_submit_urb(urb, GFP_ATOMIC);
396 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
399 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
400 static int pwc_isoc_init(struct pwc_device *pdev)
402 struct usb_device *udev;
405 struct usb_interface *intf;
406 struct usb_host_interface *idesc = NULL;
407 int compression = 0; /* 0..3 = uncompressed..high */
410 pdev->vlast_packet_size = 0;
411 pdev->fill_buf = NULL;
412 pdev->vframe_count = 0;
413 pdev->visoc_errors = 0;
417 /* We first try with low compression and then retry with a higher
418 compression setting if there is not enough bandwidth. */
419 ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
420 pdev->vframes, &compression, 1);
422 /* Get the current alternate interface, adjust packet size */
423 intf = usb_ifnum_to_if(udev, 0);
425 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
429 /* Search video endpoint */
430 pdev->vmax_packet_size = -1;
431 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
432 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
433 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
438 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
439 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
440 return -ENFILE; /* Odd error, that should be noticeable */
443 /* Set alternate interface */
444 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
445 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
446 if (ret == -ENOSPC && compression < 3) {
453 /* Allocate and init Isochronuous urbs */
454 for (i = 0; i < MAX_ISO_BUFS; i++) {
455 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
457 pwc_isoc_cleanup(pdev);
461 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
463 urb->interval = 1; // devik
465 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
466 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
467 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
468 urb->transfer_buffer = pwc_alloc_urb_buffer(udev,
469 urb->transfer_buffer_length,
471 if (urb->transfer_buffer == NULL) {
472 PWC_ERROR("Failed to allocate urb buffer %d\n", i);
473 pwc_isoc_cleanup(pdev);
476 urb->complete = pwc_isoc_handler;
478 urb->start_frame = 0;
479 urb->number_of_packets = ISO_FRAMES_PER_DESC;
480 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
481 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
482 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
487 for (i = 0; i < MAX_ISO_BUFS; i++) {
488 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
489 if (ret == -ENOSPC && compression < 3) {
491 pwc_isoc_cleanup(pdev);
495 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
496 pwc_isoc_cleanup(pdev);
499 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
503 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
507 static void pwc_iso_stop(struct pwc_device *pdev)
511 /* Unlinking ISOC buffers one by one */
512 for (i = 0; i < MAX_ISO_BUFS; i++) {
514 PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
515 usb_kill_urb(pdev->urbs[i]);
520 static void pwc_iso_free(struct pwc_device *pdev)
524 /* Freeing ISOC buffers one by one */
525 for (i = 0; i < MAX_ISO_BUFS; i++) {
526 struct urb *urb = pdev->urbs[i];
529 PWC_DEBUG_MEMORY("Freeing URB\n");
530 if (urb->transfer_buffer)
531 pwc_free_urb_buffer(urb->dev,
532 urb->transfer_buffer_length,
533 urb->transfer_buffer,
536 pdev->urbs[i] = NULL;
541 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
542 static void pwc_isoc_cleanup(struct pwc_device *pdev)
544 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
548 usb_set_interface(pdev->udev, 0, 0);
550 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
553 /* Must be called with vb_queue_lock hold */
554 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev,
555 enum vb2_buffer_state state)
557 unsigned long flags = 0;
559 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
560 while (!list_empty(&pdev->queued_bufs)) {
561 struct pwc_frame_buf *buf;
563 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
565 list_del(&buf->list);
566 vb2_buffer_done(&buf->vb.vb2_buf, state);
568 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
571 #ifdef CONFIG_USB_PWC_DEBUG
572 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
574 switch(sensor_type) {
576 return "Hyundai CMOS sensor";
578 return "Sony CCD sensor + TDA8787";
580 return "Sony CCD sensor + Exas 98L59";
582 return "Sony CCD sensor + ADI 9804";
584 return "Sharp CCD sensor + TDA8787";
586 return "Sharp CCD sensor + Exas 98L59";
588 return "Sharp CCD sensor + ADI 9804";
590 return "UPA 1021 sensor";
594 return "PAL MR sensor";
596 return "unknown type of sensor";
601 /***************************************************************************/
602 /* Video4Linux functions */
604 static void pwc_video_release(struct v4l2_device *v)
606 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
608 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
609 v4l2_device_unregister(&pdev->v4l2_dev);
610 kfree(pdev->ctrl_buf);
614 /***************************************************************************/
615 /* Videobuf2 operations */
617 static int queue_setup(struct vb2_queue *vq,
618 unsigned int *nbuffers, unsigned int *nplanes,
619 unsigned int sizes[], struct device *alloc_devs[])
621 struct pwc_device *pdev = vb2_get_drv_priv(vq);
624 if (*nbuffers < MIN_FRAMES)
625 *nbuffers = MIN_FRAMES;
626 else if (*nbuffers > MAX_FRAMES)
627 *nbuffers = MAX_FRAMES;
631 size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
632 sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
633 pwc_image_sizes[size][1] * 3 / 2);
638 static int buffer_init(struct vb2_buffer *vb)
640 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
641 struct pwc_frame_buf *buf =
642 container_of(vbuf, struct pwc_frame_buf, vb);
644 /* need vmalloc since frame buffer > 128K */
645 buf->data = vzalloc(PWC_FRAME_SIZE);
646 if (buf->data == NULL)
652 static int buffer_prepare(struct vb2_buffer *vb)
654 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
656 /* Don't allow queueing new buffers after device disconnection */
663 static void buffer_finish(struct vb2_buffer *vb)
665 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
666 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
667 struct pwc_frame_buf *buf =
668 container_of(vbuf, struct pwc_frame_buf, vb);
670 if (vb->state == VB2_BUF_STATE_DONE) {
672 * Application has called dqbuf and is getting back a buffer
673 * we've filled, take the pwc data we've stored in buf->data
674 * and decompress it into a usable format, storing the result
677 pwc_decompress(pdev, buf);
681 static void buffer_cleanup(struct vb2_buffer *vb)
683 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
684 struct pwc_frame_buf *buf =
685 container_of(vbuf, struct pwc_frame_buf, vb);
690 static void buffer_queue(struct vb2_buffer *vb)
692 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
693 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
694 struct pwc_frame_buf *buf =
695 container_of(vbuf, struct pwc_frame_buf, vb);
696 unsigned long flags = 0;
698 /* Check the device has not disconnected between prep and queuing */
700 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
704 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
705 list_add_tail(&buf->list, &pdev->queued_bufs);
706 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
709 static int start_streaming(struct vb2_queue *vq, unsigned int count)
711 struct pwc_device *pdev = vb2_get_drv_priv(vq);
717 if (mutex_lock_interruptible(&pdev->v4l2_lock))
719 /* Turn on camera and set LEDS on */
720 pwc_camera_power(pdev, 1);
721 pwc_set_leds(pdev, leds[0], leds[1]);
723 r = pwc_isoc_init(pdev);
725 /* If we failed turn camera and LEDS back off */
726 pwc_set_leds(pdev, 0, 0);
727 pwc_camera_power(pdev, 0);
728 /* And cleanup any queued bufs!! */
729 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED);
731 mutex_unlock(&pdev->v4l2_lock);
736 static void stop_streaming(struct vb2_queue *vq)
738 struct pwc_device *pdev = vb2_get_drv_priv(vq);
740 mutex_lock(&pdev->v4l2_lock);
742 pwc_set_leds(pdev, 0, 0);
743 pwc_camera_power(pdev, 0);
744 pwc_isoc_cleanup(pdev);
747 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR);
749 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
750 VB2_BUF_STATE_ERROR);
751 mutex_unlock(&pdev->v4l2_lock);
754 static const struct vb2_ops pwc_vb_queue_ops = {
755 .queue_setup = queue_setup,
756 .buf_init = buffer_init,
757 .buf_prepare = buffer_prepare,
758 .buf_finish = buffer_finish,
759 .buf_cleanup = buffer_cleanup,
760 .buf_queue = buffer_queue,
761 .start_streaming = start_streaming,
762 .stop_streaming = stop_streaming,
763 .wait_prepare = vb2_ops_wait_prepare,
764 .wait_finish = vb2_ops_wait_finish,
767 /***************************************************************************/
770 /* This function gets called when a new device is plugged in or the usb core
774 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
776 struct usb_device *udev = interface_to_usbdev(intf);
777 struct pwc_device *pdev = NULL;
778 int vendor_id, product_id, type_id;
782 int my_power_save = power_save;
783 char serial_number[30], *name;
785 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
786 product_id = le16_to_cpu(udev->descriptor.idProduct);
788 /* Check if we can handle this device */
789 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
790 vendor_id, product_id,
791 intf->altsetting->desc.bInterfaceNumber);
793 /* the interfaces are probed one by one. We are only interested in the
794 video interface (0) now.
795 Interface 1 is the Audio Control, and interface 2 Audio itself.
797 if (intf->altsetting->desc.bInterfaceNumber > 0)
800 if (vendor_id == 0x0471) {
801 switch (product_id) {
803 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
804 name = "Philips 645 webcam";
808 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
809 name = "Philips 646 webcam";
813 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
814 name = "Askey VC010 webcam";
818 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
819 name = "Philips 675 webcam";
823 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
824 name = "Philips 680 webcam";
828 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
829 name = "Philips 690 webcam";
833 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
834 name = "Philips 730 webcam";
838 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
839 name = "Philips 740 webcam";
843 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
844 name = "Philips 750 webcam";
848 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
849 name = "Philips 720K/40 webcam";
853 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
854 name = "Philips SPC 900NC webcam";
858 PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
859 name = "Philips SPC 880NC webcam";
866 else if (vendor_id == 0x069A) {
869 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
870 name = "Askey VC010 webcam";
877 else if (vendor_id == 0x046d) {
880 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
881 name = "Logitech QuickCam Pro 3000";
882 type_id = 740; /* CCD sensor */
885 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
886 name = "Logitech QuickCam Notebook Pro";
887 type_id = 740; /* CCD sensor */
890 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
891 name = "Logitech QuickCam Pro 4000";
892 type_id = 740; /* CCD sensor */
893 if (my_power_save == -1)
897 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
898 name = "Logitech QuickCam Zoom";
899 type_id = 740; /* CCD sensor */
902 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
903 name = "Logitech QuickCam Zoom";
904 type_id = 740; /* CCD sensor */
905 if (my_power_save == -1)
909 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
910 name = "Logitech QuickCam Orbit";
911 type_id = 740; /* CCD sensor */
912 if (my_power_save == -1)
914 features |= FEATURE_MOTOR_PANTILT;
917 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
918 name = "Cisco VT Camera";
919 type_id = 740; /* CCD sensor */
922 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
923 name = "Logitech ViewPort AV 100";
924 type_id = 740; /* CCD sensor */
926 case 0x08b8: /* Where this released? */
927 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
928 name = "Logitech QuickCam (res.)";
929 type_id = 730; /* Assuming CMOS */
935 else if (vendor_id == 0x055d) {
936 /* I don't know the difference between the C10 and the C30;
937 I suppose the difference is the sensor, but both cameras
938 work equally well with a type_id of 675
942 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
943 name = "Samsung MPC-C10";
947 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
948 name = "Samsung MPC-C30";
952 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
953 name = "Samsung MPC-C30";
960 else if (vendor_id == 0x041e) {
963 PWC_INFO("Creative Labs Webcam 5 detected.\n");
964 name = "Creative Labs Webcam 5";
966 if (my_power_save == -1)
970 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
971 name = "Creative Labs Webcam Pro Ex";
978 else if (vendor_id == 0x04cc) {
981 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
982 name = "Sotec Afina Eye";
989 else if (vendor_id == 0x06be) {
992 /* This is essentially the same cam as the Sotec Afina Eye */
993 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
994 name = "AME Co. Afina Eye";
1002 else if (vendor_id == 0x0d81) {
1003 switch(product_id) {
1005 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1006 name = "Visionite VCS-UC300";
1007 type_id = 740; /* CCD sensor */
1010 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1011 name = "Visionite VCS-UM100";
1012 type_id = 730; /* CMOS sensor */
1019 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1021 if (my_power_save == -1)
1024 memset(serial_number, 0, 30);
1025 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1026 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1028 if (udev->descriptor.bNumConfigurations > 1)
1029 PWC_WARNING("Warning: more than 1 configuration available.\n");
1031 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1032 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1034 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1037 pdev->type = type_id;
1038 pdev->features = features;
1039 pwc_construct(pdev); /* set min/max sizes correct */
1041 mutex_init(&pdev->v4l2_lock);
1042 mutex_init(&pdev->vb_queue_lock);
1043 spin_lock_init(&pdev->queued_bufs_lock);
1044 INIT_LIST_HEAD(&pdev->queued_bufs);
1047 pdev->power_save = my_power_save;
1049 /* Init videobuf2 queue structure */
1050 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1051 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1052 pdev->vb_queue.drv_priv = pdev;
1053 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1054 pdev->vb_queue.ops = &pwc_vb_queue_ops;
1055 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1056 pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1057 rc = vb2_queue_init(&pdev->vb_queue);
1059 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1063 /* Init video_device structure */
1064 pdev->vdev = pwc_template;
1065 strscpy(pdev->vdev.name, name, sizeof(pdev->vdev.name));
1066 pdev->vdev.queue = &pdev->vb_queue;
1067 pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1068 video_set_drvdata(&pdev->vdev, pdev);
1070 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1071 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1073 /* Allocate USB command buffers */
1074 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1075 if (!pdev->ctrl_buf) {
1076 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1081 #ifdef CONFIG_USB_PWC_DEBUG
1082 /* Query sensor type */
1083 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1084 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1086 pwc_sensor_type_to_string(rc), rc);
1090 /* Set the leds off */
1091 pwc_set_leds(pdev, 0, 0);
1093 /* Setup initial videomode */
1094 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1095 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1099 /* Register controls (and read default values from camera */
1100 rc = pwc_init_controls(pdev);
1102 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1106 /* And powerdown the camera until streaming starts */
1107 pwc_camera_power(pdev, 0);
1109 /* Register the v4l2_device structure */
1110 pdev->v4l2_dev.release = pwc_video_release;
1111 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1113 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1114 goto err_free_controls;
1117 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1118 pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1119 pdev->vdev.lock = &pdev->v4l2_lock;
1120 pdev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
1123 rc = video_register_device(&pdev->vdev, VFL_TYPE_VIDEO, -1);
1125 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1126 goto err_unregister_v4l2_dev;
1128 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1130 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1131 /* register webcam snapshot button input device */
1132 pdev->button_dev = input_allocate_device();
1133 if (!pdev->button_dev) {
1135 goto err_video_unreg;
1138 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1139 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1141 pdev->button_dev->name = "PWC snapshot button";
1142 pdev->button_dev->phys = pdev->button_phys;
1143 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1144 pdev->button_dev->dev.parent = &pdev->udev->dev;
1145 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1146 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1148 rc = input_register_device(pdev->button_dev);
1150 input_free_device(pdev->button_dev);
1151 pdev->button_dev = NULL;
1152 goto err_video_unreg;
1158 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1160 video_unregister_device(&pdev->vdev);
1162 err_unregister_v4l2_dev:
1163 v4l2_device_unregister(&pdev->v4l2_dev);
1165 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1167 kfree(pdev->ctrl_buf);
1172 /* The user yanked out the cable... */
1173 static void usb_pwc_disconnect(struct usb_interface *intf)
1175 struct v4l2_device *v = usb_get_intfdata(intf);
1176 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1178 mutex_lock(&pdev->vb_queue_lock);
1179 mutex_lock(&pdev->v4l2_lock);
1180 /* No need to keep the urbs around after disconnection */
1181 if (pdev->vb_queue.streaming)
1182 pwc_isoc_cleanup(pdev);
1185 v4l2_device_disconnect(&pdev->v4l2_dev);
1186 video_unregister_device(&pdev->vdev);
1187 mutex_unlock(&pdev->v4l2_lock);
1188 mutex_unlock(&pdev->vb_queue_lock);
1190 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1191 if (pdev->button_dev)
1192 input_unregister_device(pdev->button_dev);
1195 v4l2_device_put(&pdev->v4l2_dev);
1200 * Initialization code & module stuff
1203 static unsigned int leds_nargs;
1205 #ifdef CONFIG_USB_PWC_DEBUG
1206 module_param_named(trace, pwc_trace, int, 0644);
1208 module_param(power_save, int, 0644);
1209 module_param_array(leds, int, &leds_nargs, 0444);
1211 #ifdef CONFIG_USB_PWC_DEBUG
1212 MODULE_PARM_DESC(trace, "For debugging purposes");
1214 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1215 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1217 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1218 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1219 MODULE_LICENSE("GPL");
1220 MODULE_ALIAS("pwcx");
1221 MODULE_VERSION( PWC_VERSION );
1223 module_usb_driver(pwc_driver);