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(0x069A, 0x0001) }, /* Askey */
95 { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
96 { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
97 { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
98 { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
99 { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
100 { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
101 { USB_DEVICE(0x046D, 0x08B6) }, /* Cisco VT Camera */
102 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
103 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
104 { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
105 { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
106 { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
107 { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
108 { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
109 { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
110 { USB_DEVICE(0x06BE, 0x8116) }, /* new Afina Eye */
111 { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
112 { USB_DEVICE(0x0d81, 0x1900) },
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 int pwc_video_close(struct file *file);
140 static ssize_t pwc_video_read(struct file *file, char __user *buf,
141 size_t count, loff_t *ppos);
142 static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
143 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
145 static const struct v4l2_file_operations pwc_fops = {
146 .owner = THIS_MODULE,
147 .open = v4l2_fh_open,
148 .release = pwc_video_close,
149 .read = pwc_video_read,
150 .poll = pwc_video_poll,
151 .mmap = pwc_video_mmap,
152 .unlocked_ioctl = video_ioctl2,
154 static struct video_device pwc_template = {
155 .name = "Philips Webcam", /* Filled in later */
156 .release = video_device_release_empty,
158 .ioctl_ops = &pwc_ioctl_ops,
161 /***************************************************************************/
162 /* Private functions */
164 struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
166 unsigned long flags = 0;
167 struct pwc_frame_buf *buf = NULL;
169 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
170 if (list_empty(&pdev->queued_bufs))
173 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
174 list_del(&buf->list);
176 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
180 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
183 PWC_TRACE("Snapshot button pressed.\n");
185 PWC_TRACE("Snapshot button released.\n");
188 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
189 if (pdev->button_dev) {
190 input_report_key(pdev->button_dev, KEY_CAMERA, down);
191 input_sync(pdev->button_dev);
196 static void pwc_frame_complete(struct pwc_device *pdev)
198 struct pwc_frame_buf *fbuf = pdev->fill_buf;
200 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
201 frames on the USB wire after an exposure change. This conditition is
202 however detected in the cam and a bit is set in the header.
204 if (pdev->type == 730) {
205 unsigned char *ptr = (unsigned char *)fbuf->data;
207 if (ptr[1] == 1 && ptr[0] & 0x10) {
208 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
209 pdev->drop_frames += 2;
211 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
212 pwc_snapshot_button(pdev, ptr[0] & 0x01);
214 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
216 PWC_TRACE("Image is mirrored.\n");
218 PWC_TRACE("Image is normal.\n");
220 pdev->vmirror = ptr[0] & 0x03;
221 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
222 after a short frame; this condition is filtered out specifically. A 4 byte
223 frame doesn't make sense anyway.
224 So we get either this sequence:
225 drop_bit set -> 4 byte frame -> short frame -> good frame
227 drop_bit set -> short frame -> good frame
228 So we drop either 3 or 2 frames in all!
230 if (fbuf->filled == 4)
232 } else if (pdev->type == 740 || pdev->type == 720) {
233 unsigned char *ptr = (unsigned char *)fbuf->data;
234 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
235 pwc_snapshot_button(pdev, ptr[0] & 0x01);
237 pdev->vmirror = ptr[0] & 0x03;
240 /* In case we were instructed to drop the frame, do so silently. */
241 if (pdev->drop_frames > 0) {
244 /* Check for underflow first */
245 if (fbuf->filled < pdev->frame_total_size) {
246 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
247 " discarded.\n", fbuf->filled);
249 fbuf->vb.v4l2_buf.field = V4L2_FIELD_NONE;
250 fbuf->vb.v4l2_buf.sequence = pdev->vframe_count;
251 vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
252 pdev->fill_buf = NULL;
256 pdev->vframe_count++;
259 /* This gets called for the Isochronous pipe (video). This is done in
260 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
262 static void pwc_isoc_handler(struct urb *urb)
264 struct pwc_device *pdev = (struct pwc_device *)urb->context;
266 unsigned char *iso_buf = NULL;
268 if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
269 urb->status == -ESHUTDOWN) {
270 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
274 if (pdev->fill_buf == NULL)
275 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
277 if (urb->status != 0) {
281 switch(urb->status) {
282 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
283 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
284 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
285 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
286 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
287 case -ETIME: errmsg = "Device does not respond"; break;
289 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
290 urb->status, errmsg);
291 /* Give up after a number of contiguous errors */
292 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
294 PWC_ERROR("Too many ISOC errors, bailing out.\n");
295 if (pdev->fill_buf) {
296 vb2_buffer_done(&pdev->fill_buf->vb,
297 VB2_BUF_STATE_ERROR);
298 pdev->fill_buf = NULL;
301 pdev->vsync = 0; /* Drop the current frame */
305 /* Reset ISOC error counter. We did get here, after all. */
306 pdev->visoc_errors = 0;
308 /* vsync: 0 = don't copy data
313 for (i = 0; i < urb->number_of_packets; i++) {
314 fst = urb->iso_frame_desc[i].status;
315 flen = urb->iso_frame_desc[i].actual_length;
316 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
318 PWC_ERROR("Iso frame %d has error %d\n", i, fst);
321 if (flen > 0 && pdev->vsync) {
322 struct pwc_frame_buf *fbuf = pdev->fill_buf;
324 if (pdev->vsync == 1) {
325 do_gettimeofday(&fbuf->vb.v4l2_buf.timestamp);
329 if (flen + fbuf->filled > pdev->frame_total_size) {
330 PWC_ERROR("Frame overflow (%d > %d)\n",
332 pdev->frame_total_size);
333 pdev->vsync = 0; /* Let's wait for an EOF */
335 memcpy(fbuf->data + fbuf->filled, iso_buf,
337 fbuf->filled += flen;
340 if (flen < pdev->vlast_packet_size) {
341 /* Shorter packet... end of frame */
342 if (pdev->vsync == 2)
343 pwc_frame_complete(pdev);
344 if (pdev->fill_buf == NULL)
345 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
346 if (pdev->fill_buf) {
347 pdev->fill_buf->filled = 0;
351 pdev->vlast_packet_size = flen;
355 i = usb_submit_urb(urb, GFP_ATOMIC);
357 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
360 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
361 static int pwc_isoc_init(struct pwc_device *pdev)
363 struct usb_device *udev;
366 struct usb_interface *intf;
367 struct usb_host_interface *idesc = NULL;
368 int compression = 0; /* 0..3 = uncompressed..high */
371 pdev->vlast_packet_size = 0;
372 pdev->fill_buf = NULL;
373 pdev->vframe_count = 0;
374 pdev->visoc_errors = 0;
378 /* We first try with low compression and then retry with a higher
379 compression setting if there is not enough bandwidth. */
380 ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
381 pdev->vframes, &compression, 1);
383 /* Get the current alternate interface, adjust packet size */
384 intf = usb_ifnum_to_if(udev, 0);
386 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
390 /* Search video endpoint */
391 pdev->vmax_packet_size = -1;
392 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
393 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
394 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
399 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
400 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
401 return -ENFILE; /* Odd error, that should be noticeable */
404 /* Set alternate interface */
405 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
406 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
407 if (ret == -ENOSPC && compression < 3) {
414 /* Allocate and init Isochronuous urbs */
415 for (i = 0; i < MAX_ISO_BUFS; i++) {
416 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
418 PWC_ERROR("Failed to allocate urb %d\n", i);
419 pwc_isoc_cleanup(pdev);
423 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
425 urb->interval = 1; // devik
427 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
428 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
429 urb->transfer_buffer = usb_alloc_coherent(udev,
433 if (urb->transfer_buffer == NULL) {
434 PWC_ERROR("Failed to allocate urb buffer %d\n", i);
435 pwc_isoc_cleanup(pdev);
438 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
439 urb->complete = pwc_isoc_handler;
441 urb->start_frame = 0;
442 urb->number_of_packets = ISO_FRAMES_PER_DESC;
443 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
444 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
445 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
450 for (i = 0; i < MAX_ISO_BUFS; i++) {
451 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
452 if (ret == -ENOSPC && compression < 3) {
454 pwc_isoc_cleanup(pdev);
458 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
459 pwc_isoc_cleanup(pdev);
462 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
466 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
470 static void pwc_iso_stop(struct pwc_device *pdev)
474 /* Unlinking ISOC buffers one by one */
475 for (i = 0; i < MAX_ISO_BUFS; i++) {
477 PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
478 usb_kill_urb(pdev->urbs[i]);
483 static void pwc_iso_free(struct pwc_device *pdev)
487 /* Freeing ISOC buffers one by one */
488 for (i = 0; i < MAX_ISO_BUFS; i++) {
490 PWC_DEBUG_MEMORY("Freeing URB\n");
491 if (pdev->urbs[i]->transfer_buffer) {
492 usb_free_coherent(pdev->udev,
493 pdev->urbs[i]->transfer_buffer_length,
494 pdev->urbs[i]->transfer_buffer,
495 pdev->urbs[i]->transfer_dma);
497 usb_free_urb(pdev->urbs[i]);
498 pdev->urbs[i] = NULL;
503 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
504 static void pwc_isoc_cleanup(struct pwc_device *pdev)
506 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
510 usb_set_interface(pdev->udev, 0, 0);
512 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
515 /* Must be called with vb_queue_lock hold */
516 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev)
518 unsigned long flags = 0;
520 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
521 while (!list_empty(&pdev->queued_bufs)) {
522 struct pwc_frame_buf *buf;
524 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
526 list_del(&buf->list);
527 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
529 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
532 #ifdef CONFIG_USB_PWC_DEBUG
533 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
535 switch(sensor_type) {
537 return "Hyundai CMOS sensor";
539 return "Sony CCD sensor + TDA8787";
541 return "Sony CCD sensor + Exas 98L59";
543 return "Sony CCD sensor + ADI 9804";
545 return "Sharp CCD sensor + TDA8787";
547 return "Sharp CCD sensor + Exas 98L59";
549 return "Sharp CCD sensor + ADI 9804";
551 return "UPA 1021 sensor";
555 return "PAL MR sensor";
557 return "unknown type of sensor";
562 /***************************************************************************/
563 /* Video4Linux functions */
565 int pwc_test_n_set_capt_file(struct pwc_device *pdev, struct file *file)
567 if (pdev->capt_file != NULL &&
568 pdev->capt_file != file)
571 pdev->capt_file = file;
576 static void pwc_video_release(struct v4l2_device *v)
578 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
580 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
581 v4l2_device_unregister(&pdev->v4l2_dev);
582 kfree(pdev->ctrl_buf);
586 static int pwc_video_close(struct file *file)
588 struct pwc_device *pdev = video_drvdata(file);
591 * If we're still streaming vb2_queue_release will call stream_stop
592 * so we must take both the v4l2_lock and the vb_queue_lock.
594 if (mutex_lock_interruptible(&pdev->v4l2_lock))
596 if (mutex_lock_interruptible(&pdev->vb_queue_lock)) {
597 mutex_unlock(&pdev->v4l2_lock);
601 if (pdev->capt_file == file) {
602 vb2_queue_release(&pdev->vb_queue);
603 pdev->capt_file = NULL;
606 mutex_unlock(&pdev->vb_queue_lock);
607 mutex_unlock(&pdev->v4l2_lock);
609 return v4l2_fh_release(file);
612 static ssize_t pwc_video_read(struct file *file, char __user *buf,
613 size_t count, loff_t *ppos)
615 struct pwc_device *pdev = video_drvdata(file);
619 if (mutex_lock_interruptible(&pdev->vb_queue_lock))
622 ret = pwc_test_n_set_capt_file(pdev, file);
626 /* stream_start will get called so we must take the v4l2_lock */
627 if (pdev->vb_queue.fileio == NULL)
630 /* Use try_lock, since we're taking the locks in the *wrong* order! */
631 if (lock_v4l2 && !mutex_trylock(&pdev->v4l2_lock)) {
635 ret = vb2_read(&pdev->vb_queue, buf, count, ppos,
636 file->f_flags & O_NONBLOCK);
638 mutex_unlock(&pdev->v4l2_lock);
640 mutex_unlock(&pdev->vb_queue_lock);
644 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
646 struct pwc_device *pdev = video_drvdata(file);
647 struct vb2_queue *q = &pdev->vb_queue;
648 unsigned long req_events = poll_requested_events(wait);
649 unsigned int ret = POLL_ERR;
652 if (mutex_lock_interruptible(&pdev->vb_queue_lock))
655 /* Will this start fileio and thus call start_stream? */
656 if ((req_events & (POLLIN | POLLRDNORM)) &&
657 q->num_buffers == 0 && !q->streaming && q->fileio == NULL) {
658 if (pwc_test_n_set_capt_file(pdev, file))
663 /* Use try_lock, since we're taking the locks in the *wrong* order! */
664 if (lock_v4l2 && !mutex_trylock(&pdev->v4l2_lock))
666 ret = vb2_poll(&pdev->vb_queue, file, wait);
668 mutex_unlock(&pdev->v4l2_lock);
673 mutex_unlock(&pdev->vb_queue_lock);
677 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
679 struct pwc_device *pdev = video_drvdata(file);
682 if (mutex_lock_interruptible(&pdev->vb_queue_lock))
685 ret = pwc_test_n_set_capt_file(pdev, file);
687 ret = vb2_mmap(&pdev->vb_queue, vma);
689 mutex_unlock(&pdev->vb_queue_lock);
693 /***************************************************************************/
694 /* Videobuf2 operations */
696 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
697 unsigned int *nbuffers, unsigned int *nplanes,
698 unsigned int sizes[], void *alloc_ctxs[])
700 struct pwc_device *pdev = vb2_get_drv_priv(vq);
703 if (*nbuffers < MIN_FRAMES)
704 *nbuffers = MIN_FRAMES;
705 else if (*nbuffers > MAX_FRAMES)
706 *nbuffers = MAX_FRAMES;
710 size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
711 sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
712 pwc_image_sizes[size][1] * 3 / 2);
717 static int buffer_init(struct vb2_buffer *vb)
719 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
721 /* need vmalloc since frame buffer > 128K */
722 buf->data = vzalloc(PWC_FRAME_SIZE);
723 if (buf->data == NULL)
729 static int buffer_prepare(struct vb2_buffer *vb)
731 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
733 /* Don't allow queing new buffers after device disconnection */
740 static int buffer_finish(struct vb2_buffer *vb)
742 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
743 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
746 * Application has called dqbuf and is getting back a buffer we've
747 * filled, take the pwc data we've stored in buf->data and decompress
748 * it into a usable format, storing the result in the vb2_buffer
750 return pwc_decompress(pdev, buf);
753 static void buffer_cleanup(struct vb2_buffer *vb)
755 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
760 static void buffer_queue(struct vb2_buffer *vb)
762 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
763 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
764 unsigned long flags = 0;
766 /* Check the device has not disconnected between prep and queuing */
768 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
772 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
773 list_add_tail(&buf->list, &pdev->queued_bufs);
774 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
777 static int start_streaming(struct vb2_queue *vq, unsigned int count)
779 struct pwc_device *pdev = vb2_get_drv_priv(vq);
785 /* Turn on camera and set LEDS on */
786 pwc_camera_power(pdev, 1);
787 pwc_set_leds(pdev, leds[0], leds[1]);
789 r = pwc_isoc_init(pdev);
791 /* If we failed turn camera and LEDS back off */
792 pwc_set_leds(pdev, 0, 0);
793 pwc_camera_power(pdev, 0);
794 /* And cleanup any queued bufs!! */
795 pwc_cleanup_queued_bufs(pdev);
801 static int stop_streaming(struct vb2_queue *vq)
803 struct pwc_device *pdev = vb2_get_drv_priv(vq);
806 pwc_set_leds(pdev, 0, 0);
807 pwc_camera_power(pdev, 0);
808 pwc_isoc_cleanup(pdev);
811 pwc_cleanup_queued_bufs(pdev);
816 static void wait_prepare(struct vb2_queue *vq)
818 struct pwc_device *pdev = vb2_get_drv_priv(vq);
819 mutex_unlock(&pdev->vb_queue_lock);
822 static void wait_finish(struct vb2_queue *vq)
824 struct pwc_device *pdev = vb2_get_drv_priv(vq);
825 mutex_lock(&pdev->vb_queue_lock);
828 static struct vb2_ops pwc_vb_queue_ops = {
829 .queue_setup = queue_setup,
830 .buf_init = buffer_init,
831 .buf_prepare = buffer_prepare,
832 .buf_finish = buffer_finish,
833 .buf_cleanup = buffer_cleanup,
834 .buf_queue = buffer_queue,
835 .start_streaming = start_streaming,
836 .stop_streaming = stop_streaming,
837 .wait_prepare = wait_prepare,
838 .wait_finish = wait_finish,
841 /***************************************************************************/
844 /* This function gets called when a new device is plugged in or the usb core
848 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
850 struct usb_device *udev = interface_to_usbdev(intf);
851 struct pwc_device *pdev = NULL;
852 int vendor_id, product_id, type_id;
856 int my_power_save = power_save;
857 char serial_number[30], *name;
859 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
860 product_id = le16_to_cpu(udev->descriptor.idProduct);
862 /* Check if we can handle this device */
863 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
864 vendor_id, product_id,
865 intf->altsetting->desc.bInterfaceNumber);
867 /* the interfaces are probed one by one. We are only interested in the
868 video interface (0) now.
869 Interface 1 is the Audio Control, and interface 2 Audio itself.
871 if (intf->altsetting->desc.bInterfaceNumber > 0)
874 if (vendor_id == 0x0471) {
875 switch (product_id) {
877 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
878 name = "Philips 645 webcam";
882 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
883 name = "Philips 646 webcam";
887 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
888 name = "Askey VC010 webcam";
892 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
893 name = "Philips 675 webcam";
897 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
898 name = "Philips 680 webcam";
902 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
903 name = "Philips 690 webcam";
907 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
908 name = "Philips 730 webcam";
912 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
913 name = "Philips 740 webcam";
917 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
918 name = "Philips 750 webcam";
922 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
923 name = "Philips 720K/40 webcam";
927 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
928 name = "Philips SPC 900NC webcam";
936 else if (vendor_id == 0x069A) {
939 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
940 name = "Askey VC010 webcam";
948 else if (vendor_id == 0x046d) {
951 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
952 name = "Logitech QuickCam Pro 3000";
953 type_id = 740; /* CCD sensor */
956 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
957 name = "Logitech QuickCam Notebook Pro";
958 type_id = 740; /* CCD sensor */
961 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
962 name = "Logitech QuickCam Pro 4000";
963 type_id = 740; /* CCD sensor */
964 if (my_power_save == -1)
968 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
969 name = "Logitech QuickCam Zoom";
970 type_id = 740; /* CCD sensor */
973 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
974 name = "Logitech QuickCam Zoom";
975 type_id = 740; /* CCD sensor */
976 if (my_power_save == -1)
980 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
981 name = "Logitech QuickCam Orbit";
982 type_id = 740; /* CCD sensor */
983 if (my_power_save == -1)
985 features |= FEATURE_MOTOR_PANTILT;
988 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
989 name = "Cisco VT Camera";
990 type_id = 740; /* CCD sensor */
993 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
994 name = "Logitech ViewPort AV 100";
995 type_id = 740; /* CCD sensor */
997 case 0x08b8: /* Where this released? */
998 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
999 name = "Logitech QuickCam (res.)";
1000 type_id = 730; /* Assuming CMOS */
1007 else if (vendor_id == 0x055d) {
1008 /* I don't know the difference between the C10 and the C30;
1009 I suppose the difference is the sensor, but both cameras
1010 work equally well with a type_id of 675
1012 switch(product_id) {
1014 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1015 name = "Samsung MPC-C10";
1019 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1020 name = "Samsung MPC-C30";
1024 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1025 name = "Samsung MPC-C30";
1033 else if (vendor_id == 0x041e) {
1034 switch(product_id) {
1036 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1037 name = "Creative Labs Webcam 5";
1039 if (my_power_save == -1)
1043 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1044 name = "Creative Labs Webcam Pro Ex";
1052 else if (vendor_id == 0x04cc) {
1053 switch(product_id) {
1055 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1056 name = "Sotec Afina Eye";
1064 else if (vendor_id == 0x06be) {
1065 switch(product_id) {
1067 /* This is essentially the same cam as the Sotec Afina Eye */
1068 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1069 name = "AME Co. Afina Eye";
1078 else if (vendor_id == 0x0d81) {
1079 switch(product_id) {
1081 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1082 name = "Visionite VCS-UC300";
1083 type_id = 740; /* CCD sensor */
1086 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1087 name = "Visionite VCS-UM100";
1088 type_id = 730; /* CMOS sensor */
1096 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1098 if (my_power_save == -1)
1101 memset(serial_number, 0, 30);
1102 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1103 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1105 if (udev->descriptor.bNumConfigurations > 1)
1106 PWC_WARNING("Warning: more than 1 configuration available.\n");
1108 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1109 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1111 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1114 pdev->type = type_id;
1115 pdev->features = features;
1116 pwc_construct(pdev); /* set min/max sizes correct */
1118 mutex_init(&pdev->v4l2_lock);
1119 mutex_init(&pdev->vb_queue_lock);
1120 spin_lock_init(&pdev->queued_bufs_lock);
1121 INIT_LIST_HEAD(&pdev->queued_bufs);
1124 pdev->power_save = my_power_save;
1126 /* Init videobuf2 queue structure */
1127 memset(&pdev->vb_queue, 0, sizeof(pdev->vb_queue));
1128 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1129 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1130 pdev->vb_queue.drv_priv = pdev;
1131 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1132 pdev->vb_queue.ops = &pwc_vb_queue_ops;
1133 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1134 vb2_queue_init(&pdev->vb_queue);
1136 /* Init video_device structure */
1137 memcpy(&pdev->vdev, &pwc_template, sizeof(pwc_template));
1138 strcpy(pdev->vdev.name, name);
1139 set_bit(V4L2_FL_USE_FH_PRIO, &pdev->vdev.flags);
1140 video_set_drvdata(&pdev->vdev, pdev);
1142 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1143 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1145 /* Allocate USB command buffers */
1146 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1147 if (!pdev->ctrl_buf) {
1148 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1153 #ifdef CONFIG_USB_PWC_DEBUG
1154 /* Query sensor type */
1155 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1156 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1158 pwc_sensor_type_to_string(rc), rc);
1162 /* Set the leds off */
1163 pwc_set_leds(pdev, 0, 0);
1165 /* Setup intial videomode */
1166 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1167 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1171 /* Register controls (and read default values from camera */
1172 rc = pwc_init_controls(pdev);
1174 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1178 /* And powerdown the camera until streaming starts */
1179 pwc_camera_power(pdev, 0);
1181 /* Register the v4l2_device structure */
1182 pdev->v4l2_dev.release = pwc_video_release;
1183 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1185 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1186 goto err_free_controls;
1189 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1190 pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1191 pdev->vdev.lock = &pdev->v4l2_lock;
1194 * Don't take v4l2_lock for these ioctls. This improves latency if
1195 * v4l2_lock is taken for a long time, e.g. when changing a control
1196 * value, and a new frame is ready to be dequeued.
1198 v4l2_disable_ioctl_locking(&pdev->vdev, VIDIOC_DQBUF);
1199 v4l2_disable_ioctl_locking(&pdev->vdev, VIDIOC_QBUF);
1200 v4l2_disable_ioctl_locking(&pdev->vdev, VIDIOC_QUERYBUF);
1202 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1204 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1205 goto err_unregister_v4l2_dev;
1207 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1209 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1210 /* register webcam snapshot button input device */
1211 pdev->button_dev = input_allocate_device();
1212 if (!pdev->button_dev) {
1213 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1215 goto err_video_unreg;
1218 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1219 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1221 pdev->button_dev->name = "PWC snapshot button";
1222 pdev->button_dev->phys = pdev->button_phys;
1223 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1224 pdev->button_dev->dev.parent = &pdev->udev->dev;
1225 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1226 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1228 rc = input_register_device(pdev->button_dev);
1230 input_free_device(pdev->button_dev);
1231 pdev->button_dev = NULL;
1232 goto err_video_unreg;
1239 video_unregister_device(&pdev->vdev);
1240 err_unregister_v4l2_dev:
1241 v4l2_device_unregister(&pdev->v4l2_dev);
1243 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1245 kfree(pdev->ctrl_buf);
1250 /* The user yanked out the cable... */
1251 static void usb_pwc_disconnect(struct usb_interface *intf)
1253 struct v4l2_device *v = usb_get_intfdata(intf);
1254 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1256 mutex_lock(&pdev->v4l2_lock);
1258 mutex_lock(&pdev->vb_queue_lock);
1259 /* No need to keep the urbs around after disconnection */
1260 if (pdev->vb_queue.streaming)
1261 pwc_isoc_cleanup(pdev);
1263 pwc_cleanup_queued_bufs(pdev);
1264 mutex_unlock(&pdev->vb_queue_lock);
1266 v4l2_device_disconnect(&pdev->v4l2_dev);
1267 video_unregister_device(&pdev->vdev);
1269 mutex_unlock(&pdev->v4l2_lock);
1271 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1272 if (pdev->button_dev)
1273 input_unregister_device(pdev->button_dev);
1276 v4l2_device_put(&pdev->v4l2_dev);
1281 * Initialization code & module stuff
1284 static unsigned int leds_nargs;
1286 #ifdef CONFIG_USB_PWC_DEBUG
1287 module_param_named(trace, pwc_trace, int, 0644);
1289 module_param(power_save, int, 0644);
1290 module_param_array(leds, int, &leds_nargs, 0444);
1292 #ifdef CONFIG_USB_PWC_DEBUG
1293 MODULE_PARM_DESC(trace, "For debugging purposes");
1295 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1296 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1298 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1299 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1300 MODULE_LICENSE("GPL");
1301 MODULE_ALIAS("pwcx");
1302 MODULE_VERSION( PWC_VERSION );
1304 module_usb_driver(pwc_driver);