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 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 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 struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
160 unsigned long flags = 0;
161 struct pwc_frame_buf *buf = NULL;
163 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
164 if (list_empty(&pdev->queued_bufs))
167 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
168 list_del(&buf->list);
170 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
174 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
177 PWC_TRACE("Snapshot button pressed.\n");
179 PWC_TRACE("Snapshot button released.\n");
182 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
183 if (pdev->button_dev) {
184 input_report_key(pdev->button_dev, KEY_CAMERA, down);
185 input_sync(pdev->button_dev);
190 static void pwc_frame_complete(struct pwc_device *pdev)
192 struct pwc_frame_buf *fbuf = pdev->fill_buf;
194 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
195 frames on the USB wire after an exposure change. This conditition is
196 however detected in the cam and a bit is set in the header.
198 if (pdev->type == 730) {
199 unsigned char *ptr = (unsigned char *)fbuf->data;
201 if (ptr[1] == 1 && ptr[0] & 0x10) {
202 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
203 pdev->drop_frames += 2;
205 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
206 pwc_snapshot_button(pdev, ptr[0] & 0x01);
208 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
210 PWC_TRACE("Image is mirrored.\n");
212 PWC_TRACE("Image is normal.\n");
214 pdev->vmirror = ptr[0] & 0x03;
215 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
216 after a short frame; this condition is filtered out specifically. A 4 byte
217 frame doesn't make sense anyway.
218 So we get either this sequence:
219 drop_bit set -> 4 byte frame -> short frame -> good frame
221 drop_bit set -> short frame -> good frame
222 So we drop either 3 or 2 frames in all!
224 if (fbuf->filled == 4)
226 } else if (pdev->type == 740 || pdev->type == 720) {
227 unsigned char *ptr = (unsigned char *)fbuf->data;
228 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
229 pwc_snapshot_button(pdev, ptr[0] & 0x01);
231 pdev->vmirror = ptr[0] & 0x03;
234 /* In case we were instructed to drop the frame, do so silently. */
235 if (pdev->drop_frames > 0) {
238 /* Check for underflow first */
239 if (fbuf->filled < pdev->frame_total_size) {
240 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
241 " discarded.\n", fbuf->filled);
243 fbuf->vb.field = V4L2_FIELD_NONE;
244 fbuf->vb.sequence = pdev->vframe_count;
245 vb2_buffer_done(&fbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
246 pdev->fill_buf = NULL;
250 pdev->vframe_count++;
253 /* This gets called for the Isochronous pipe (video). This is done in
254 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
256 static void pwc_isoc_handler(struct urb *urb)
258 struct pwc_device *pdev = (struct pwc_device *)urb->context;
260 unsigned char *iso_buf = NULL;
262 if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
263 urb->status == -ESHUTDOWN) {
264 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
268 if (pdev->fill_buf == NULL)
269 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
271 if (urb->status != 0) {
275 switch(urb->status) {
276 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
277 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
278 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
279 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
280 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
281 case -ETIME: errmsg = "Device does not respond"; break;
283 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
284 urb->status, errmsg);
285 /* Give up after a number of contiguous errors */
286 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
288 PWC_ERROR("Too many ISOC errors, bailing out.\n");
289 if (pdev->fill_buf) {
290 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
291 VB2_BUF_STATE_ERROR);
292 pdev->fill_buf = NULL;
295 pdev->vsync = 0; /* Drop the current frame */
299 /* Reset ISOC error counter. We did get here, after all. */
300 pdev->visoc_errors = 0;
302 /* vsync: 0 = don't copy data
307 for (i = 0; i < urb->number_of_packets; i++) {
308 fst = urb->iso_frame_desc[i].status;
309 flen = urb->iso_frame_desc[i].actual_length;
310 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
312 PWC_ERROR("Iso frame %d has error %d\n", i, fst);
315 if (flen > 0 && pdev->vsync) {
316 struct pwc_frame_buf *fbuf = pdev->fill_buf;
318 if (pdev->vsync == 1) {
319 fbuf->vb.vb2_buf.timestamp = ktime_get_ns();
323 if (flen + fbuf->filled > pdev->frame_total_size) {
324 PWC_ERROR("Frame overflow (%d > %d)\n",
326 pdev->frame_total_size);
327 pdev->vsync = 0; /* Let's wait for an EOF */
329 memcpy(fbuf->data + fbuf->filled, iso_buf,
331 fbuf->filled += flen;
334 if (flen < pdev->vlast_packet_size) {
335 /* Shorter packet... end of frame */
336 if (pdev->vsync == 2)
337 pwc_frame_complete(pdev);
338 if (pdev->fill_buf == NULL)
339 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
340 if (pdev->fill_buf) {
341 pdev->fill_buf->filled = 0;
345 pdev->vlast_packet_size = flen;
349 i = usb_submit_urb(urb, GFP_ATOMIC);
351 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
354 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
355 static int pwc_isoc_init(struct pwc_device *pdev)
357 struct usb_device *udev;
360 struct usb_interface *intf;
361 struct usb_host_interface *idesc = NULL;
362 int compression = 0; /* 0..3 = uncompressed..high */
365 pdev->vlast_packet_size = 0;
366 pdev->fill_buf = NULL;
367 pdev->vframe_count = 0;
368 pdev->visoc_errors = 0;
372 /* We first try with low compression and then retry with a higher
373 compression setting if there is not enough bandwidth. */
374 ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
375 pdev->vframes, &compression, 1);
377 /* Get the current alternate interface, adjust packet size */
378 intf = usb_ifnum_to_if(udev, 0);
380 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
384 /* Search video endpoint */
385 pdev->vmax_packet_size = -1;
386 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
387 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
388 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
393 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
394 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
395 return -ENFILE; /* Odd error, that should be noticeable */
398 /* Set alternate interface */
399 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
400 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
401 if (ret == -ENOSPC && compression < 3) {
408 /* Allocate and init Isochronuous urbs */
409 for (i = 0; i < MAX_ISO_BUFS; i++) {
410 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
412 PWC_ERROR("Failed to allocate urb %d\n", i);
413 pwc_isoc_cleanup(pdev);
417 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
419 urb->interval = 1; // devik
421 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
422 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
423 urb->transfer_buffer = usb_alloc_coherent(udev,
427 if (urb->transfer_buffer == NULL) {
428 PWC_ERROR("Failed to allocate urb buffer %d\n", i);
429 pwc_isoc_cleanup(pdev);
432 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
433 urb->complete = pwc_isoc_handler;
435 urb->start_frame = 0;
436 urb->number_of_packets = ISO_FRAMES_PER_DESC;
437 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
438 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
439 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
444 for (i = 0; i < MAX_ISO_BUFS; i++) {
445 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
446 if (ret == -ENOSPC && compression < 3) {
448 pwc_isoc_cleanup(pdev);
452 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
453 pwc_isoc_cleanup(pdev);
456 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
460 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
464 static void pwc_iso_stop(struct pwc_device *pdev)
468 /* Unlinking ISOC buffers one by one */
469 for (i = 0; i < MAX_ISO_BUFS; i++) {
471 PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
472 usb_kill_urb(pdev->urbs[i]);
477 static void pwc_iso_free(struct pwc_device *pdev)
481 /* Freeing ISOC buffers one by one */
482 for (i = 0; i < MAX_ISO_BUFS; i++) {
484 PWC_DEBUG_MEMORY("Freeing URB\n");
485 if (pdev->urbs[i]->transfer_buffer) {
486 usb_free_coherent(pdev->udev,
487 pdev->urbs[i]->transfer_buffer_length,
488 pdev->urbs[i]->transfer_buffer,
489 pdev->urbs[i]->transfer_dma);
491 usb_free_urb(pdev->urbs[i]);
492 pdev->urbs[i] = NULL;
497 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
498 static void pwc_isoc_cleanup(struct pwc_device *pdev)
500 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
504 usb_set_interface(pdev->udev, 0, 0);
506 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
509 /* Must be called with vb_queue_lock hold */
510 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev,
511 enum vb2_buffer_state state)
513 unsigned long flags = 0;
515 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
516 while (!list_empty(&pdev->queued_bufs)) {
517 struct pwc_frame_buf *buf;
519 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
521 list_del(&buf->list);
522 vb2_buffer_done(&buf->vb.vb2_buf, state);
524 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
527 #ifdef CONFIG_USB_PWC_DEBUG
528 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
530 switch(sensor_type) {
532 return "Hyundai CMOS sensor";
534 return "Sony CCD sensor + TDA8787";
536 return "Sony CCD sensor + Exas 98L59";
538 return "Sony CCD sensor + ADI 9804";
540 return "Sharp CCD sensor + TDA8787";
542 return "Sharp CCD sensor + Exas 98L59";
544 return "Sharp CCD sensor + ADI 9804";
546 return "UPA 1021 sensor";
550 return "PAL MR sensor";
552 return "unknown type of sensor";
557 /***************************************************************************/
558 /* Video4Linux functions */
560 static void pwc_video_release(struct v4l2_device *v)
562 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
564 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
565 v4l2_device_unregister(&pdev->v4l2_dev);
566 kfree(pdev->ctrl_buf);
570 /***************************************************************************/
571 /* Videobuf2 operations */
573 static int queue_setup(struct vb2_queue *vq,
574 unsigned int *nbuffers, unsigned int *nplanes,
575 unsigned int sizes[], void *alloc_ctxs[])
577 struct pwc_device *pdev = vb2_get_drv_priv(vq);
580 if (*nbuffers < MIN_FRAMES)
581 *nbuffers = MIN_FRAMES;
582 else if (*nbuffers > MAX_FRAMES)
583 *nbuffers = MAX_FRAMES;
587 size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
588 sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
589 pwc_image_sizes[size][1] * 3 / 2);
594 static int buffer_init(struct vb2_buffer *vb)
596 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
597 struct pwc_frame_buf *buf =
598 container_of(vbuf, struct pwc_frame_buf, vb);
600 /* need vmalloc since frame buffer > 128K */
601 buf->data = vzalloc(PWC_FRAME_SIZE);
602 if (buf->data == NULL)
608 static int buffer_prepare(struct vb2_buffer *vb)
610 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
612 /* Don't allow queing new buffers after device disconnection */
619 static void buffer_finish(struct vb2_buffer *vb)
621 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
622 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
623 struct pwc_frame_buf *buf =
624 container_of(vbuf, struct pwc_frame_buf, vb);
626 if (vb->state == VB2_BUF_STATE_DONE) {
628 * Application has called dqbuf and is getting back a buffer
629 * we've filled, take the pwc data we've stored in buf->data
630 * and decompress it into a usable format, storing the result
633 pwc_decompress(pdev, buf);
637 static void buffer_cleanup(struct vb2_buffer *vb)
639 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
640 struct pwc_frame_buf *buf =
641 container_of(vbuf, struct pwc_frame_buf, vb);
646 static void buffer_queue(struct vb2_buffer *vb)
648 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
649 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
650 struct pwc_frame_buf *buf =
651 container_of(vbuf, struct pwc_frame_buf, vb);
652 unsigned long flags = 0;
654 /* Check the device has not disconnected between prep and queuing */
656 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
660 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
661 list_add_tail(&buf->list, &pdev->queued_bufs);
662 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
665 static int start_streaming(struct vb2_queue *vq, unsigned int count)
667 struct pwc_device *pdev = vb2_get_drv_priv(vq);
673 if (mutex_lock_interruptible(&pdev->v4l2_lock))
675 /* Turn on camera and set LEDS on */
676 pwc_camera_power(pdev, 1);
677 pwc_set_leds(pdev, leds[0], leds[1]);
679 r = pwc_isoc_init(pdev);
681 /* If we failed turn camera and LEDS back off */
682 pwc_set_leds(pdev, 0, 0);
683 pwc_camera_power(pdev, 0);
684 /* And cleanup any queued bufs!! */
685 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED);
687 mutex_unlock(&pdev->v4l2_lock);
692 static void stop_streaming(struct vb2_queue *vq)
694 struct pwc_device *pdev = vb2_get_drv_priv(vq);
696 mutex_lock(&pdev->v4l2_lock);
698 pwc_set_leds(pdev, 0, 0);
699 pwc_camera_power(pdev, 0);
700 pwc_isoc_cleanup(pdev);
703 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR);
705 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
706 VB2_BUF_STATE_ERROR);
707 mutex_unlock(&pdev->v4l2_lock);
710 static struct vb2_ops pwc_vb_queue_ops = {
711 .queue_setup = queue_setup,
712 .buf_init = buffer_init,
713 .buf_prepare = buffer_prepare,
714 .buf_finish = buffer_finish,
715 .buf_cleanup = buffer_cleanup,
716 .buf_queue = buffer_queue,
717 .start_streaming = start_streaming,
718 .stop_streaming = stop_streaming,
719 .wait_prepare = vb2_ops_wait_prepare,
720 .wait_finish = vb2_ops_wait_finish,
723 /***************************************************************************/
726 /* This function gets called when a new device is plugged in or the usb core
730 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
732 struct usb_device *udev = interface_to_usbdev(intf);
733 struct pwc_device *pdev = NULL;
734 int vendor_id, product_id, type_id;
738 int my_power_save = power_save;
739 char serial_number[30], *name;
741 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
742 product_id = le16_to_cpu(udev->descriptor.idProduct);
744 /* Check if we can handle this device */
745 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
746 vendor_id, product_id,
747 intf->altsetting->desc.bInterfaceNumber);
749 /* the interfaces are probed one by one. We are only interested in the
750 video interface (0) now.
751 Interface 1 is the Audio Control, and interface 2 Audio itself.
753 if (intf->altsetting->desc.bInterfaceNumber > 0)
756 if (vendor_id == 0x0471) {
757 switch (product_id) {
759 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
760 name = "Philips 645 webcam";
764 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
765 name = "Philips 646 webcam";
769 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
770 name = "Askey VC010 webcam";
774 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
775 name = "Philips 675 webcam";
779 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
780 name = "Philips 680 webcam";
784 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
785 name = "Philips 690 webcam";
789 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
790 name = "Philips 730 webcam";
794 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
795 name = "Philips 740 webcam";
799 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
800 name = "Philips 750 webcam";
804 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
805 name = "Philips 720K/40 webcam";
809 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
810 name = "Philips SPC 900NC webcam";
818 else if (vendor_id == 0x069A) {
821 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
822 name = "Askey VC010 webcam";
830 else if (vendor_id == 0x046d) {
833 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
834 name = "Logitech QuickCam Pro 3000";
835 type_id = 740; /* CCD sensor */
838 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
839 name = "Logitech QuickCam Notebook Pro";
840 type_id = 740; /* CCD sensor */
843 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
844 name = "Logitech QuickCam Pro 4000";
845 type_id = 740; /* CCD sensor */
846 if (my_power_save == -1)
850 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
851 name = "Logitech QuickCam Zoom";
852 type_id = 740; /* CCD sensor */
855 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
856 name = "Logitech QuickCam Zoom";
857 type_id = 740; /* CCD sensor */
858 if (my_power_save == -1)
862 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
863 name = "Logitech QuickCam Orbit";
864 type_id = 740; /* CCD sensor */
865 if (my_power_save == -1)
867 features |= FEATURE_MOTOR_PANTILT;
870 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
871 name = "Cisco VT Camera";
872 type_id = 740; /* CCD sensor */
875 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
876 name = "Logitech ViewPort AV 100";
877 type_id = 740; /* CCD sensor */
879 case 0x08b8: /* Where this released? */
880 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
881 name = "Logitech QuickCam (res.)";
882 type_id = 730; /* Assuming CMOS */
889 else if (vendor_id == 0x055d) {
890 /* I don't know the difference between the C10 and the C30;
891 I suppose the difference is the sensor, but both cameras
892 work equally well with a type_id of 675
896 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
897 name = "Samsung MPC-C10";
901 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
902 name = "Samsung MPC-C30";
906 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
907 name = "Samsung MPC-C30";
915 else if (vendor_id == 0x041e) {
918 PWC_INFO("Creative Labs Webcam 5 detected.\n");
919 name = "Creative Labs Webcam 5";
921 if (my_power_save == -1)
925 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
926 name = "Creative Labs Webcam Pro Ex";
934 else if (vendor_id == 0x04cc) {
937 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
938 name = "Sotec Afina Eye";
946 else if (vendor_id == 0x06be) {
949 /* This is essentially the same cam as the Sotec Afina Eye */
950 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
951 name = "AME Co. Afina Eye";
960 else if (vendor_id == 0x0d81) {
963 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
964 name = "Visionite VCS-UC300";
965 type_id = 740; /* CCD sensor */
968 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
969 name = "Visionite VCS-UM100";
970 type_id = 730; /* CMOS sensor */
978 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
980 if (my_power_save == -1)
983 memset(serial_number, 0, 30);
984 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
985 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
987 if (udev->descriptor.bNumConfigurations > 1)
988 PWC_WARNING("Warning: more than 1 configuration available.\n");
990 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
991 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
993 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
996 pdev->type = type_id;
997 pdev->features = features;
998 pwc_construct(pdev); /* set min/max sizes correct */
1000 mutex_init(&pdev->v4l2_lock);
1001 mutex_init(&pdev->vb_queue_lock);
1002 spin_lock_init(&pdev->queued_bufs_lock);
1003 INIT_LIST_HEAD(&pdev->queued_bufs);
1006 pdev->power_save = my_power_save;
1008 /* Init videobuf2 queue structure */
1009 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1010 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1011 pdev->vb_queue.drv_priv = pdev;
1012 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1013 pdev->vb_queue.ops = &pwc_vb_queue_ops;
1014 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1015 pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1016 rc = vb2_queue_init(&pdev->vb_queue);
1018 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1022 /* Init video_device structure */
1023 pdev->vdev = pwc_template;
1024 strcpy(pdev->vdev.name, name);
1025 pdev->vdev.queue = &pdev->vb_queue;
1026 pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1027 video_set_drvdata(&pdev->vdev, pdev);
1029 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1030 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1032 /* Allocate USB command buffers */
1033 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1034 if (!pdev->ctrl_buf) {
1035 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1040 #ifdef CONFIG_USB_PWC_DEBUG
1041 /* Query sensor type */
1042 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1043 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1045 pwc_sensor_type_to_string(rc), rc);
1049 /* Set the leds off */
1050 pwc_set_leds(pdev, 0, 0);
1052 /* Setup initial videomode */
1053 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1054 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1058 /* Register controls (and read default values from camera */
1059 rc = pwc_init_controls(pdev);
1061 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1065 /* And powerdown the camera until streaming starts */
1066 pwc_camera_power(pdev, 0);
1068 /* Register the v4l2_device structure */
1069 pdev->v4l2_dev.release = pwc_video_release;
1070 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1072 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1073 goto err_free_controls;
1076 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1077 pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1078 pdev->vdev.lock = &pdev->v4l2_lock;
1080 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1082 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1083 goto err_unregister_v4l2_dev;
1085 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1087 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1088 /* register webcam snapshot button input device */
1089 pdev->button_dev = input_allocate_device();
1090 if (!pdev->button_dev) {
1092 goto err_video_unreg;
1095 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1096 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1098 pdev->button_dev->name = "PWC snapshot button";
1099 pdev->button_dev->phys = pdev->button_phys;
1100 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1101 pdev->button_dev->dev.parent = &pdev->udev->dev;
1102 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1103 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1105 rc = input_register_device(pdev->button_dev);
1107 input_free_device(pdev->button_dev);
1108 pdev->button_dev = NULL;
1109 goto err_video_unreg;
1116 video_unregister_device(&pdev->vdev);
1117 err_unregister_v4l2_dev:
1118 v4l2_device_unregister(&pdev->v4l2_dev);
1120 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1122 kfree(pdev->ctrl_buf);
1127 /* The user yanked out the cable... */
1128 static void usb_pwc_disconnect(struct usb_interface *intf)
1130 struct v4l2_device *v = usb_get_intfdata(intf);
1131 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1133 mutex_lock(&pdev->vb_queue_lock);
1134 mutex_lock(&pdev->v4l2_lock);
1135 /* No need to keep the urbs around after disconnection */
1136 if (pdev->vb_queue.streaming)
1137 pwc_isoc_cleanup(pdev);
1140 v4l2_device_disconnect(&pdev->v4l2_dev);
1141 video_unregister_device(&pdev->vdev);
1142 mutex_unlock(&pdev->v4l2_lock);
1143 mutex_unlock(&pdev->vb_queue_lock);
1145 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1146 if (pdev->button_dev)
1147 input_unregister_device(pdev->button_dev);
1150 v4l2_device_put(&pdev->v4l2_dev);
1155 * Initialization code & module stuff
1158 static unsigned int leds_nargs;
1160 #ifdef CONFIG_USB_PWC_DEBUG
1161 module_param_named(trace, pwc_trace, int, 0644);
1163 module_param(power_save, int, 0644);
1164 module_param_array(leds, int, &leds_nargs, 0444);
1166 #ifdef CONFIG_USB_PWC_DEBUG
1167 MODULE_PARM_DESC(trace, "For debugging purposes");
1169 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1170 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1172 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1173 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1174 MODULE_LICENSE("GPL");
1175 MODULE_ALIAS("pwcx");
1176 MODULE_VERSION( PWC_VERSION );
1178 module_usb_driver(pwc_driver);