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>
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.
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.
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.
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
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.
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
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 *
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
60 #include <linux/errno.h>
61 #include <linux/init.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>
69 #include <linux/vmalloc.h>
71 #include <linux/kernel.h> /* simple_strtol() */
74 #include "pwc-kiara.h"
75 #include "pwc-timon.h"
76 #include "pwc-dec23.h"
79 /* Function prototypes and driver templates */
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) },
116 MODULE_DEVICE_TABLE(usb, pwc_device_table);
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);
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() */
129 #define MAX_DEV_HINTS 20
130 #define MAX_ISOC_ERRORS 20
132 #ifdef CONFIG_USB_PWC_DEBUG
133 int pwc_trace = PWC_DEBUG_LEVEL;
135 static int power_save = -1;
136 static int leds[2] = { 100, 0 };
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,
149 static struct video_device pwc_template = {
150 .name = "Philips Webcam", /* Filled in later */
151 .release = video_device_release_empty,
153 .ioctl_ops = &pwc_ioctl_ops,
156 /***************************************************************************/
157 /* Private functions */
159 static struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
161 unsigned long flags = 0;
162 struct pwc_frame_buf *buf = NULL;
164 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
165 if (list_empty(&pdev->queued_bufs))
168 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
169 list_del(&buf->list);
171 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
175 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
178 PWC_TRACE("Snapshot button pressed.\n");
180 PWC_TRACE("Snapshot button released.\n");
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);
191 static void pwc_frame_complete(struct pwc_device *pdev)
193 struct pwc_frame_buf *fbuf = pdev->fill_buf;
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.
199 if (pdev->type == 730) {
200 unsigned char *ptr = (unsigned char *)fbuf->data;
202 if (ptr[1] == 1 && ptr[0] & 0x10) {
203 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
204 pdev->drop_frames += 2;
206 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
207 pwc_snapshot_button(pdev, ptr[0] & 0x01);
209 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
211 PWC_TRACE("Image is mirrored.\n");
213 PWC_TRACE("Image is normal.\n");
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
222 drop_bit set -> short frame -> good frame
223 So we drop either 3 or 2 frames in all!
225 if (fbuf->filled == 4)
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);
232 pdev->vmirror = ptr[0] & 0x03;
235 /* In case we were instructed to drop the frame, do so silently. */
236 if (pdev->drop_frames > 0) {
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);
244 fbuf->vb.field = V4L2_FIELD_NONE;
245 fbuf->vb.sequence = pdev->vframe_count;
246 vb2_buffer_done(&fbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
247 pdev->fill_buf = NULL;
251 pdev->vframe_count++;
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.
257 static void pwc_isoc_handler(struct urb *urb)
259 struct pwc_device *pdev = (struct pwc_device *)urb->context;
261 unsigned char *iso_buf = NULL;
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");
269 if (pdev->fill_buf == NULL)
270 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
272 if (urb->status != 0) {
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;
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)
289 PWC_ERROR("Too many ISOC errors, bailing out.\n");
290 if (pdev->fill_buf) {
291 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
292 VB2_BUF_STATE_ERROR);
293 pdev->fill_buf = NULL;
296 pdev->vsync = 0; /* Drop the current frame */
300 /* Reset ISOC error counter. We did get here, after all. */
301 pdev->visoc_errors = 0;
303 /* vsync: 0 = don't copy 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;
313 PWC_ERROR("Iso frame %d has error %d\n", i, fst);
316 if (flen > 0 && pdev->vsync) {
317 struct pwc_frame_buf *fbuf = pdev->fill_buf;
319 if (pdev->vsync == 1) {
321 &fbuf->vb.timestamp);
325 if (flen + fbuf->filled > pdev->frame_total_size) {
326 PWC_ERROR("Frame overflow (%d > %d)\n",
328 pdev->frame_total_size);
329 pdev->vsync = 0; /* Let's wait for an EOF */
331 memcpy(fbuf->data + fbuf->filled, iso_buf,
333 fbuf->filled += flen;
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;
347 pdev->vlast_packet_size = flen;
351 i = usb_submit_urb(urb, GFP_ATOMIC);
353 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
356 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
357 static int pwc_isoc_init(struct pwc_device *pdev)
359 struct usb_device *udev;
362 struct usb_interface *intf;
363 struct usb_host_interface *idesc = NULL;
364 int compression = 0; /* 0..3 = uncompressed..high */
367 pdev->vlast_packet_size = 0;
368 pdev->fill_buf = NULL;
369 pdev->vframe_count = 0;
370 pdev->visoc_errors = 0;
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);
379 /* Get the current alternate interface, adjust packet size */
380 intf = usb_ifnum_to_if(udev, 0);
382 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
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);
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 */
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) {
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);
414 PWC_ERROR("Failed to allocate urb %d\n", i);
415 pwc_isoc_cleanup(pdev);
419 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
421 urb->interval = 1; // devik
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,
429 if (urb->transfer_buffer == NULL) {
430 PWC_ERROR("Failed to allocate urb buffer %d\n", i);
431 pwc_isoc_cleanup(pdev);
434 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
435 urb->complete = pwc_isoc_handler;
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;
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) {
450 pwc_isoc_cleanup(pdev);
454 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
455 pwc_isoc_cleanup(pdev);
458 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
462 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
466 static void pwc_iso_stop(struct pwc_device *pdev)
470 /* Unlinking ISOC buffers one by one */
471 for (i = 0; i < MAX_ISO_BUFS; i++) {
473 PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
474 usb_kill_urb(pdev->urbs[i]);
479 static void pwc_iso_free(struct pwc_device *pdev)
483 /* Freeing ISOC buffers one by one */
484 for (i = 0; i < MAX_ISO_BUFS; 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);
493 usb_free_urb(pdev->urbs[i]);
494 pdev->urbs[i] = NULL;
499 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
500 static void pwc_isoc_cleanup(struct pwc_device *pdev)
502 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
506 usb_set_interface(pdev->udev, 0, 0);
508 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
511 /* Must be called with vb_queue_lock hold */
512 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev,
513 enum vb2_buffer_state state)
515 unsigned long flags = 0;
517 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
518 while (!list_empty(&pdev->queued_bufs)) {
519 struct pwc_frame_buf *buf;
521 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
523 list_del(&buf->list);
524 vb2_buffer_done(&buf->vb.vb2_buf, state);
526 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
529 #ifdef CONFIG_USB_PWC_DEBUG
530 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
532 switch(sensor_type) {
534 return "Hyundai CMOS sensor";
536 return "Sony CCD sensor + TDA8787";
538 return "Sony CCD sensor + Exas 98L59";
540 return "Sony CCD sensor + ADI 9804";
542 return "Sharp CCD sensor + TDA8787";
544 return "Sharp CCD sensor + Exas 98L59";
546 return "Sharp CCD sensor + ADI 9804";
548 return "UPA 1021 sensor";
552 return "PAL MR sensor";
554 return "unknown type of sensor";
559 /***************************************************************************/
560 /* Video4Linux functions */
562 static void pwc_video_release(struct v4l2_device *v)
564 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
566 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
567 v4l2_device_unregister(&pdev->v4l2_dev);
568 kfree(pdev->ctrl_buf);
572 /***************************************************************************/
573 /* Videobuf2 operations */
575 static int queue_setup(struct vb2_queue *vq, const void *parg,
576 unsigned int *nbuffers, unsigned int *nplanes,
577 unsigned int sizes[], void *alloc_ctxs[])
579 struct pwc_device *pdev = vb2_get_drv_priv(vq);
582 if (*nbuffers < MIN_FRAMES)
583 *nbuffers = MIN_FRAMES;
584 else if (*nbuffers > MAX_FRAMES)
585 *nbuffers = MAX_FRAMES;
589 size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
590 sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
591 pwc_image_sizes[size][1] * 3 / 2);
596 static int buffer_init(struct vb2_buffer *vb)
598 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
599 struct pwc_frame_buf *buf =
600 container_of(vbuf, struct pwc_frame_buf, vb);
602 /* need vmalloc since frame buffer > 128K */
603 buf->data = vzalloc(PWC_FRAME_SIZE);
604 if (buf->data == NULL)
610 static int buffer_prepare(struct vb2_buffer *vb)
612 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
614 /* Don't allow queing new buffers after device disconnection */
621 static void buffer_finish(struct vb2_buffer *vb)
623 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
624 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
625 struct pwc_frame_buf *buf =
626 container_of(vbuf, struct pwc_frame_buf, vb);
628 if (vb->state == VB2_BUF_STATE_DONE) {
630 * Application has called dqbuf and is getting back a buffer
631 * we've filled, take the pwc data we've stored in buf->data
632 * and decompress it into a usable format, storing the result
635 pwc_decompress(pdev, buf);
639 static void buffer_cleanup(struct vb2_buffer *vb)
641 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
642 struct pwc_frame_buf *buf =
643 container_of(vbuf, struct pwc_frame_buf, vb);
648 static void buffer_queue(struct vb2_buffer *vb)
650 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
651 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
652 struct pwc_frame_buf *buf =
653 container_of(vbuf, struct pwc_frame_buf, vb);
654 unsigned long flags = 0;
656 /* Check the device has not disconnected between prep and queuing */
658 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
662 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
663 list_add_tail(&buf->list, &pdev->queued_bufs);
664 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
667 static int start_streaming(struct vb2_queue *vq, unsigned int count)
669 struct pwc_device *pdev = vb2_get_drv_priv(vq);
675 if (mutex_lock_interruptible(&pdev->v4l2_lock))
677 /* Turn on camera and set LEDS on */
678 pwc_camera_power(pdev, 1);
679 pwc_set_leds(pdev, leds[0], leds[1]);
681 r = pwc_isoc_init(pdev);
683 /* If we failed turn camera and LEDS back off */
684 pwc_set_leds(pdev, 0, 0);
685 pwc_camera_power(pdev, 0);
686 /* And cleanup any queued bufs!! */
687 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED);
689 mutex_unlock(&pdev->v4l2_lock);
694 static void stop_streaming(struct vb2_queue *vq)
696 struct pwc_device *pdev = vb2_get_drv_priv(vq);
698 mutex_lock(&pdev->v4l2_lock);
700 pwc_set_leds(pdev, 0, 0);
701 pwc_camera_power(pdev, 0);
702 pwc_isoc_cleanup(pdev);
705 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR);
707 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
708 VB2_BUF_STATE_ERROR);
709 mutex_unlock(&pdev->v4l2_lock);
712 static struct vb2_ops pwc_vb_queue_ops = {
713 .queue_setup = queue_setup,
714 .buf_init = buffer_init,
715 .buf_prepare = buffer_prepare,
716 .buf_finish = buffer_finish,
717 .buf_cleanup = buffer_cleanup,
718 .buf_queue = buffer_queue,
719 .start_streaming = start_streaming,
720 .stop_streaming = stop_streaming,
721 .wait_prepare = vb2_ops_wait_prepare,
722 .wait_finish = vb2_ops_wait_finish,
725 /***************************************************************************/
728 /* This function gets called when a new device is plugged in or the usb core
732 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
734 struct usb_device *udev = interface_to_usbdev(intf);
735 struct pwc_device *pdev = NULL;
736 int vendor_id, product_id, type_id;
740 int my_power_save = power_save;
741 char serial_number[30], *name;
743 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
744 product_id = le16_to_cpu(udev->descriptor.idProduct);
746 /* Check if we can handle this device */
747 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
748 vendor_id, product_id,
749 intf->altsetting->desc.bInterfaceNumber);
751 /* the interfaces are probed one by one. We are only interested in the
752 video interface (0) now.
753 Interface 1 is the Audio Control, and interface 2 Audio itself.
755 if (intf->altsetting->desc.bInterfaceNumber > 0)
758 if (vendor_id == 0x0471) {
759 switch (product_id) {
761 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
762 name = "Philips 645 webcam";
766 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
767 name = "Philips 646 webcam";
771 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
772 name = "Askey VC010 webcam";
776 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
777 name = "Philips 675 webcam";
781 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
782 name = "Philips 680 webcam";
786 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
787 name = "Philips 690 webcam";
791 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
792 name = "Philips 730 webcam";
796 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
797 name = "Philips 740 webcam";
801 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
802 name = "Philips 750 webcam";
806 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
807 name = "Philips 720K/40 webcam";
811 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
812 name = "Philips SPC 900NC webcam";
816 PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
817 name = "Philips SPC 880NC webcam";
825 else if (vendor_id == 0x069A) {
828 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
829 name = "Askey VC010 webcam";
837 else if (vendor_id == 0x046d) {
840 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
841 name = "Logitech QuickCam Pro 3000";
842 type_id = 740; /* CCD sensor */
845 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
846 name = "Logitech QuickCam Notebook Pro";
847 type_id = 740; /* CCD sensor */
850 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
851 name = "Logitech QuickCam Pro 4000";
852 type_id = 740; /* CCD sensor */
853 if (my_power_save == -1)
857 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
858 name = "Logitech QuickCam Zoom";
859 type_id = 740; /* CCD sensor */
862 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
863 name = "Logitech QuickCam Zoom";
864 type_id = 740; /* CCD sensor */
865 if (my_power_save == -1)
869 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
870 name = "Logitech QuickCam Orbit";
871 type_id = 740; /* CCD sensor */
872 if (my_power_save == -1)
874 features |= FEATURE_MOTOR_PANTILT;
877 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
878 name = "Cisco VT Camera";
879 type_id = 740; /* CCD sensor */
882 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
883 name = "Logitech ViewPort AV 100";
884 type_id = 740; /* CCD sensor */
886 case 0x08b8: /* Where this released? */
887 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
888 name = "Logitech QuickCam (res.)";
889 type_id = 730; /* Assuming CMOS */
896 else if (vendor_id == 0x055d) {
897 /* I don't know the difference between the C10 and the C30;
898 I suppose the difference is the sensor, but both cameras
899 work equally well with a type_id of 675
903 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
904 name = "Samsung MPC-C10";
908 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
909 name = "Samsung MPC-C30";
913 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
914 name = "Samsung MPC-C30";
922 else if (vendor_id == 0x041e) {
925 PWC_INFO("Creative Labs Webcam 5 detected.\n");
926 name = "Creative Labs Webcam 5";
928 if (my_power_save == -1)
932 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
933 name = "Creative Labs Webcam Pro Ex";
941 else if (vendor_id == 0x04cc) {
944 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
945 name = "Sotec Afina Eye";
953 else if (vendor_id == 0x06be) {
956 /* This is essentially the same cam as the Sotec Afina Eye */
957 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
958 name = "AME Co. Afina Eye";
967 else if (vendor_id == 0x0d81) {
970 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
971 name = "Visionite VCS-UC300";
972 type_id = 740; /* CCD sensor */
975 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
976 name = "Visionite VCS-UM100";
977 type_id = 730; /* CMOS sensor */
985 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
987 if (my_power_save == -1)
990 memset(serial_number, 0, 30);
991 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
992 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
994 if (udev->descriptor.bNumConfigurations > 1)
995 PWC_WARNING("Warning: more than 1 configuration available.\n");
997 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
998 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1000 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1003 pdev->type = type_id;
1004 pdev->features = features;
1005 pwc_construct(pdev); /* set min/max sizes correct */
1007 mutex_init(&pdev->v4l2_lock);
1008 mutex_init(&pdev->vb_queue_lock);
1009 spin_lock_init(&pdev->queued_bufs_lock);
1010 INIT_LIST_HEAD(&pdev->queued_bufs);
1013 pdev->power_save = my_power_save;
1015 /* Init videobuf2 queue structure */
1016 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1017 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1018 pdev->vb_queue.drv_priv = pdev;
1019 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1020 pdev->vb_queue.ops = &pwc_vb_queue_ops;
1021 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1022 pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1023 rc = vb2_queue_init(&pdev->vb_queue);
1025 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1029 /* Init video_device structure */
1030 pdev->vdev = pwc_template;
1031 strcpy(pdev->vdev.name, name);
1032 pdev->vdev.queue = &pdev->vb_queue;
1033 pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1034 video_set_drvdata(&pdev->vdev, pdev);
1036 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1037 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1039 /* Allocate USB command buffers */
1040 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1041 if (!pdev->ctrl_buf) {
1042 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1047 #ifdef CONFIG_USB_PWC_DEBUG
1048 /* Query sensor type */
1049 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1050 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1052 pwc_sensor_type_to_string(rc), rc);
1056 /* Set the leds off */
1057 pwc_set_leds(pdev, 0, 0);
1059 /* Setup initial videomode */
1060 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1061 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1065 /* Register controls (and read default values from camera */
1066 rc = pwc_init_controls(pdev);
1068 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1072 /* And powerdown the camera until streaming starts */
1073 pwc_camera_power(pdev, 0);
1075 /* Register the v4l2_device structure */
1076 pdev->v4l2_dev.release = pwc_video_release;
1077 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1079 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1080 goto err_free_controls;
1083 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1084 pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1085 pdev->vdev.lock = &pdev->v4l2_lock;
1087 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1089 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1090 goto err_unregister_v4l2_dev;
1092 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1094 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1095 /* register webcam snapshot button input device */
1096 pdev->button_dev = input_allocate_device();
1097 if (!pdev->button_dev) {
1099 goto err_video_unreg;
1102 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1103 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1105 pdev->button_dev->name = "PWC snapshot button";
1106 pdev->button_dev->phys = pdev->button_phys;
1107 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1108 pdev->button_dev->dev.parent = &pdev->udev->dev;
1109 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1110 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1112 rc = input_register_device(pdev->button_dev);
1114 input_free_device(pdev->button_dev);
1115 pdev->button_dev = NULL;
1116 goto err_video_unreg;
1122 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1124 video_unregister_device(&pdev->vdev);
1126 err_unregister_v4l2_dev:
1127 v4l2_device_unregister(&pdev->v4l2_dev);
1129 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1131 kfree(pdev->ctrl_buf);
1136 /* The user yanked out the cable... */
1137 static void usb_pwc_disconnect(struct usb_interface *intf)
1139 struct v4l2_device *v = usb_get_intfdata(intf);
1140 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1142 mutex_lock(&pdev->vb_queue_lock);
1143 mutex_lock(&pdev->v4l2_lock);
1144 /* No need to keep the urbs around after disconnection */
1145 if (pdev->vb_queue.streaming)
1146 pwc_isoc_cleanup(pdev);
1149 v4l2_device_disconnect(&pdev->v4l2_dev);
1150 video_unregister_device(&pdev->vdev);
1151 mutex_unlock(&pdev->v4l2_lock);
1152 mutex_unlock(&pdev->vb_queue_lock);
1154 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1155 if (pdev->button_dev)
1156 input_unregister_device(pdev->button_dev);
1159 v4l2_device_put(&pdev->v4l2_dev);
1164 * Initialization code & module stuff
1167 static unsigned int leds_nargs;
1169 #ifdef CONFIG_USB_PWC_DEBUG
1170 module_param_named(trace, pwc_trace, int, 0644);
1172 module_param(power_save, int, 0644);
1173 module_param_array(leds, int, &leds_nargs, 0444);
1175 #ifdef CONFIG_USB_PWC_DEBUG
1176 MODULE_PARM_DESC(trace, "For debugging purposes");
1178 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1179 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1181 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1182 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1183 MODULE_LICENSE("GPL");
1184 MODULE_ALIAS("pwcx");
1185 MODULE_VERSION( PWC_VERSION );
1187 module_usb_driver(pwc_driver);