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)
6 NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
7 driver and thus may have bugs that are not present in the original version.
8 Please send bug reports and support requests to <luc@saillard.org>.
9 The decompression routines have been implemented by reverse-engineering the
10 Nemosoft binary pwcx module. Caveat emptor.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 This code forms the interface between the USB layers and the Philips
30 specific stuff. Some adanved stuff of the driver falls under an
31 NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
32 is thus not distributed in source form. The binary pwcx.o module
33 contains the code that falls under the NDA.
35 In case you're wondering: 'pwc' stands for "Philips WebCam", but
36 I really didn't want to type 'philips_web_cam' every time (I'm lazy as
37 any Linux kernel hacker, but I don't like uncomprehensible abbreviations
40 Oh yes, convention: to disctinguish between all the various pointers to
41 device-structures, I use these names for the pointer variables:
42 udev: struct usb_device *
43 vdev: struct video_device *
44 pdev: struct pwc_devive *
48 - Alvarado: adding whitebalance code
49 - Alistar Moire: QuickCam 3000 Pro device/product ID
50 - Tony Hoyle: Creative Labs Webcam 5 device/product ID
51 - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
52 - Jk Fang: Sotec Afina Eye ID
53 - Xavier Roche: QuickCam Pro 4000 ID
54 - Jens Knudsen: QuickCam Zoom ID
55 - J. Debert: QuickCam for Notebooks ID
58 #include <linux/errno.h>
59 #include <linux/init.h>
61 #include <linux/module.h>
62 #include <linux/poll.h>
63 #include <linux/slab.h>
64 #include <linux/vmalloc.h>
65 #include <linux/version.h>
69 #include "pwc-kiara.h"
70 #include "pwc-timon.h"
71 #include "pwc-dec23.h"
73 #include "pwc-uncompress.h"
75 /* Function prototypes and driver templates */
77 /* hotplug device table support */
78 static const struct usb_device_id pwc_device_table [] = {
79 { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */
80 { USB_DEVICE(0x0471, 0x0303) },
81 { USB_DEVICE(0x0471, 0x0304) },
82 { USB_DEVICE(0x0471, 0x0307) },
83 { USB_DEVICE(0x0471, 0x0308) },
84 { USB_DEVICE(0x0471, 0x030C) },
85 { USB_DEVICE(0x0471, 0x0310) },
86 { USB_DEVICE(0x0471, 0x0311) }, /* Philips ToUcam PRO II */
87 { USB_DEVICE(0x0471, 0x0312) },
88 { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
89 { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC PC Camera */
90 { USB_DEVICE(0x069A, 0x0001) }, /* Askey */
91 { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
92 { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
93 { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
94 { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
95 { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
96 { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
97 { USB_DEVICE(0x046D, 0x08B6) }, /* Cisco VT Camera */
98 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
99 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
100 { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
101 { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
102 { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
103 { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
104 { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
105 { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
106 { USB_DEVICE(0x06BE, 0x8116) }, /* new Afina Eye */
107 { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
108 { USB_DEVICE(0x0d81, 0x1900) },
111 MODULE_DEVICE_TABLE(usb, pwc_device_table);
113 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
114 static void usb_pwc_disconnect(struct usb_interface *intf);
116 static struct usb_driver pwc_driver = {
117 .name = "Philips webcam", /* name */
118 .id_table = pwc_device_table,
119 .probe = usb_pwc_probe, /* probe() */
120 .disconnect = usb_pwc_disconnect, /* disconnect() */
123 #define MAX_DEV_HINTS 20
124 #define MAX_ISOC_ERRORS 20
126 static int default_size = PSZ_QCIF;
127 static int default_fps = 10;
128 static int default_fbufs = 3; /* Default number of frame buffers */
129 int pwc_mbufs = 2; /* Default number of mmap() buffers */
130 #ifdef CONFIG_USB_PWC_DEBUG
131 int pwc_trace = PWC_DEBUG_LEVEL;
133 static int power_save;
134 static int led_on = 100, led_off; /* defaults to LED that is on while in use */
135 static int pwc_preferred_compression = 1; /* 0..3 = uncompressed..high */
138 char serial_number[30];
140 struct pwc_device *pdev;
141 } device_hint[MAX_DEV_HINTS];
145 static int pwc_video_open(struct inode *inode, struct file *file);
146 static int pwc_video_close(struct inode *inode, struct file *file);
147 static ssize_t pwc_video_read(struct file *file, char __user *buf,
148 size_t count, loff_t *ppos);
149 static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
150 static int pwc_video_ioctl(struct inode *inode, struct file *file,
151 unsigned int ioctlnr, unsigned long arg);
152 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
154 static const struct file_operations pwc_fops = {
155 .owner = THIS_MODULE,
156 .open = pwc_video_open,
157 .release = pwc_video_close,
158 .read = pwc_video_read,
159 .poll = pwc_video_poll,
160 .mmap = pwc_video_mmap,
161 .ioctl = pwc_video_ioctl,
163 .compat_ioctl = v4l_compat_ioctl32,
167 static struct video_device pwc_template = {
168 .name = "Philips Webcam", /* Filled in later */
169 .type = VID_TYPE_CAPTURE,
170 .release = video_device_release,
175 /***************************************************************************/
177 /* Okay, this is some magic that I worked out and the reasoning behind it...
179 The biggest problem with any USB device is of course: "what to do
180 when the user unplugs the device while it is in use by an application?"
181 We have several options:
182 1) Curse them with the 7 plagues when they do (requires divine intervention)
183 2) Tell them not to (won't work: they'll do it anyway)
184 3) Oops the kernel (this will have a negative effect on a user's uptime)
185 4) Do something sensible.
187 Of course, we go for option 4.
189 It happens that this device will be linked to two times, once from
190 usb_device and once from the video_device in their respective 'private'
191 pointers. This is done when the device is probed() and all initialization
192 succeeded. The pwc_device struct links back to both structures.
194 When a device is unplugged while in use it will be removed from the
195 list of known USB devices; I also de-register it as a V4L device, but
196 unfortunately I can't free the memory since the struct is still in use
197 by the file descriptor. This free-ing is then deferend until the first
198 opportunity. Crude, but it works.
200 A small 'advantage' is that if a user unplugs the cam and plugs it back
201 in, it should get assigned the same video device minor, but unfortunately
202 it's non-trivial to re-link the cam back to the video device... (that
203 would surely be magic! :))
206 /***************************************************************************/
207 /* Private functions */
209 /* Here we want the physical address of the memory.
210 * This is used when initializing the contents of the area.
215 static void *pwc_rvmalloc(unsigned long size)
220 mem=vmalloc_32(size);
224 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
225 adr=(unsigned long) mem;
228 SetPageReserved(vmalloc_to_page((void *)adr));
235 static void pwc_rvfree(void * mem, unsigned long size)
242 adr=(unsigned long) mem;
243 while ((long) size > 0)
245 ClearPageReserved(vmalloc_to_page((void *)adr));
255 static int pwc_allocate_buffers(struct pwc_device *pdev)
260 PWC_DEBUG_MEMORY(">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev);
265 /* Allocate Isochronuous pipe buffers */
266 for (i = 0; i < MAX_ISO_BUFS; i++) {
267 if (pdev->sbuf[i].data == NULL) {
268 kbuf = kzalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
270 PWC_ERROR("Failed to allocate iso buffer %d.\n", i);
273 PWC_DEBUG_MEMORY("Allocated iso buffer at %p.\n", kbuf);
274 pdev->sbuf[i].data = kbuf;
278 /* Allocate frame buffer structure */
279 if (pdev->fbuf == NULL) {
280 kbuf = kzalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);
282 PWC_ERROR("Failed to allocate frame buffer structure.\n");
285 PWC_DEBUG_MEMORY("Allocated frame buffer structure at %p.\n", kbuf);
289 /* create frame buffers, and make circular ring */
290 for (i = 0; i < default_fbufs; i++) {
291 if (pdev->fbuf[i].data == NULL) {
292 kbuf = vmalloc(PWC_FRAME_SIZE); /* need vmalloc since frame buffer > 128K */
294 PWC_ERROR("Failed to allocate frame buffer %d.\n", i);
297 PWC_DEBUG_MEMORY("Allocated frame buffer %d at %p.\n", i, kbuf);
298 pdev->fbuf[i].data = kbuf;
299 memset(kbuf, 0, PWC_FRAME_SIZE);
303 /* Allocate decompressor table space */
304 if (DEVICE_USE_CODEC1(pdev->type))
305 err = pwc_dec1_alloc(pdev);
307 err = pwc_dec23_alloc(pdev);
310 PWC_ERROR("Failed to allocate decompress table.\n");
314 /* Allocate image buffer; double buffer for mmap() */
315 kbuf = pwc_rvmalloc(pwc_mbufs * pdev->len_per_image);
317 PWC_ERROR("Failed to allocate image buffer(s). needed (%d)\n",
318 pwc_mbufs * pdev->len_per_image);
321 PWC_DEBUG_MEMORY("Allocated image buffer at %p.\n", kbuf);
322 pdev->image_data = kbuf;
323 for (i = 0; i < pwc_mbufs; i++) {
324 pdev->images[i].offset = i * pdev->len_per_image;
325 pdev->images[i].vma_use_count = 0;
327 for (; i < MAX_IMAGES; i++) {
328 pdev->images[i].offset = 0;
333 PWC_DEBUG_MEMORY("<< pwc_allocate_buffers()\n");
337 static void pwc_free_buffers(struct pwc_device *pdev)
341 PWC_DEBUG_MEMORY("Entering free_buffers(%p).\n", pdev);
345 /* Release Iso-pipe buffers */
346 for (i = 0; i < MAX_ISO_BUFS; i++)
347 if (pdev->sbuf[i].data != NULL) {
348 PWC_DEBUG_MEMORY("Freeing ISO buffer at %p.\n", pdev->sbuf[i].data);
349 kfree(pdev->sbuf[i].data);
350 pdev->sbuf[i].data = NULL;
353 /* The same for frame buffers */
354 if (pdev->fbuf != NULL) {
355 for (i = 0; i < default_fbufs; i++) {
356 if (pdev->fbuf[i].data != NULL) {
357 PWC_DEBUG_MEMORY("Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data);
358 vfree(pdev->fbuf[i].data);
359 pdev->fbuf[i].data = NULL;
366 /* Intermediate decompression buffer & tables */
367 if (pdev->decompress_data != NULL) {
368 PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n", pdev->decompress_data);
369 kfree(pdev->decompress_data);
370 pdev->decompress_data = NULL;
373 /* Release image buffers */
374 if (pdev->image_data != NULL) {
375 PWC_DEBUG_MEMORY("Freeing image buffer at %p.\n", pdev->image_data);
376 pwc_rvfree(pdev->image_data, pwc_mbufs * pdev->len_per_image);
378 pdev->image_data = NULL;
380 PWC_DEBUG_MEMORY("Leaving free_buffers().\n");
383 /* The frame & image buffer mess.
385 Yes, this is a mess. Well, it used to be simple, but alas... In this
386 module, 3 buffers schemes are used to get the data from the USB bus to
387 the user program. The first scheme involves the ISO buffers (called thus
388 since they transport ISO data from the USB controller), and not really
389 interesting. Suffices to say the data from this buffer is quickly
390 gathered in an interrupt handler (pwc_isoc_handler) and placed into the
393 The frame buffer is the second scheme, and is the central element here.
394 It collects the data from a single frame from the camera (hence, the
395 name). Frames are delimited by the USB camera with a short USB packet,
396 so that's easy to detect. The frame buffers form a list that is filled
397 by the camera+USB controller and drained by the user process through
398 either read() or mmap().
400 The image buffer is the third scheme, in which frames are decompressed
401 and converted into planar format. For mmap() there is more than
402 one image buffer available.
404 The frame buffers provide the image buffering. In case the user process
405 is a bit slow, this introduces lag and some undesired side-effects.
406 The problem arises when the frame buffer is full. I used to drop the last
407 frame, which makes the data in the queue stale very quickly. But dropping
408 the frame at the head of the queue proved to be a litte bit more difficult.
409 I tried a circular linked scheme, but this introduced more problems than
412 Because filling and draining are completely asynchronous processes, this
413 requires some fiddling with pointers and mutexes.
415 Eventually, I came up with a system with 2 lists: an 'empty' frame list
416 and a 'full' frame list:
417 * Initially, all frame buffers but one are on the 'empty' list; the one
418 remaining buffer is our initial fill frame.
419 * If a frame is needed for filling, we try to take it from the 'empty'
420 list, unless that list is empty, in which case we take the buffer at
421 the head of the 'full' list.
422 * When our fill buffer has been filled, it is appended to the 'full'
424 * If a frame is needed by read() or mmap(), it is taken from the head of
425 the 'full' list, handled, and then appended to the 'empty' list. If no
426 buffer is present on the 'full' list, we wait.
427 The advantage is that the buffer that is currently being decompressed/
428 converted, is on neither list, and thus not in our way (any other scheme
429 I tried had the problem of old data lingering in the queue).
431 Whatever strategy you choose, it always remains a tradeoff: with more
432 frame buffers the chances of a missed frame are reduced. On the other
433 hand, on slower machines it introduces lag because the queue will
438 \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.
440 static int pwc_next_fill_frame(struct pwc_device *pdev)
446 spin_lock_irqsave(&pdev->ptrlock, flags);
447 if (pdev->fill_frame != NULL) {
448 /* append to 'full' list */
449 if (pdev->full_frames == NULL) {
450 pdev->full_frames = pdev->fill_frame;
451 pdev->full_frames_tail = pdev->full_frames;
454 pdev->full_frames_tail->next = pdev->fill_frame;
455 pdev->full_frames_tail = pdev->fill_frame;
458 if (pdev->empty_frames != NULL) {
459 /* We have empty frames available. That's easy */
460 pdev->fill_frame = pdev->empty_frames;
461 pdev->empty_frames = pdev->empty_frames->next;
464 /* Hmm. Take it from the full list */
466 if (pdev->full_frames == NULL) {
467 PWC_ERROR("Neither empty or full frames available!\n");
468 spin_unlock_irqrestore(&pdev->ptrlock, flags);
471 pdev->fill_frame = pdev->full_frames;
472 pdev->full_frames = pdev->full_frames->next;
475 pdev->fill_frame->next = NULL;
476 spin_unlock_irqrestore(&pdev->ptrlock, flags);
482 \brief Reset all buffers, pointers and lists, except for the image_used[] buffer.
484 If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble.
486 static void pwc_reset_buffers(struct pwc_device *pdev)
491 PWC_DEBUG_MEMORY(">> %s __enter__\n", __func__);
493 spin_lock_irqsave(&pdev->ptrlock, flags);
494 pdev->full_frames = NULL;
495 pdev->full_frames_tail = NULL;
496 for (i = 0; i < default_fbufs; i++) {
497 pdev->fbuf[i].filled = 0;
499 pdev->fbuf[i].next = &pdev->fbuf[i - 1];
501 pdev->fbuf->next = NULL;
503 pdev->empty_frames = &pdev->fbuf[default_fbufs - 1];
504 pdev->empty_frames_tail = pdev->fbuf;
505 pdev->read_frame = NULL;
506 pdev->fill_frame = pdev->empty_frames;
507 pdev->empty_frames = pdev->empty_frames->next;
509 pdev->image_read_pos = 0;
510 pdev->fill_image = 0;
511 spin_unlock_irqrestore(&pdev->ptrlock, flags);
513 PWC_DEBUG_MEMORY("<< %s __leaving__\n", __func__);
518 \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.
520 int pwc_handle_frame(struct pwc_device *pdev)
525 spin_lock_irqsave(&pdev->ptrlock, flags);
526 /* First grab our read_frame; this is removed from all lists, so
527 we can release the lock after this without problems */
528 if (pdev->read_frame != NULL) {
529 /* This can't theoretically happen */
530 PWC_ERROR("Huh? Read frame still in use?\n");
531 spin_unlock_irqrestore(&pdev->ptrlock, flags);
536 if (pdev->full_frames == NULL) {
537 PWC_ERROR("Woops. No frames ready.\n");
540 pdev->read_frame = pdev->full_frames;
541 pdev->full_frames = pdev->full_frames->next;
542 pdev->read_frame->next = NULL;
545 if (pdev->read_frame != NULL) {
546 /* Decompression is a lengthy process, so it's outside of the lock.
547 This gives the isoc_handler the opportunity to fill more frames
550 spin_unlock_irqrestore(&pdev->ptrlock, flags);
551 ret = pwc_decompress(pdev);
552 spin_lock_irqsave(&pdev->ptrlock, flags);
554 /* We're done with read_buffer, tack it to the end of the empty buffer list */
555 if (pdev->empty_frames == NULL) {
556 pdev->empty_frames = pdev->read_frame;
557 pdev->empty_frames_tail = pdev->empty_frames;
560 pdev->empty_frames_tail->next = pdev->read_frame;
561 pdev->empty_frames_tail = pdev->read_frame;
563 pdev->read_frame = NULL;
565 spin_unlock_irqrestore(&pdev->ptrlock, flags);
570 \brief Advance pointers of image buffer (after each user request)
572 void pwc_next_image(struct pwc_device *pdev)
574 pdev->image_used[pdev->fill_image] = 0;
575 pdev->fill_image = (pdev->fill_image + 1) % pwc_mbufs;
579 * Print debug information when a frame is discarded because all of our buffer
582 static void pwc_frame_dumped(struct pwc_device *pdev)
584 pdev->vframes_dumped++;
585 if (pdev->vframe_count < FRAME_LOWMARK)
588 if (pdev->vframes_dumped < 20)
589 PWC_DEBUG_FLOW("Dumping frame %d\n", pdev->vframe_count);
590 else if (pdev->vframes_dumped == 20)
591 PWC_DEBUG_FLOW("Dumping frame %d (last message)\n",
595 static int pwc_rcv_short_packet(struct pwc_device *pdev, const struct pwc_frame_buf *fbuf)
599 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
600 frames on the USB wire after an exposure change. This conditition is
601 however detected in the cam and a bit is set in the header.
603 if (pdev->type == 730) {
604 unsigned char *ptr = (unsigned char *)fbuf->data;
606 if (ptr[1] == 1 && ptr[0] & 0x10) {
607 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
608 pdev->drop_frames += 2;
609 pdev->vframes_error++;
611 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
613 pdev->snapshot_button_status = 1;
614 PWC_TRACE("Snapshot button pressed.\n");
617 PWC_TRACE("Snapshot button released.\n");
620 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
622 PWC_TRACE("Image is mirrored.\n");
624 PWC_TRACE("Image is normal.\n");
626 pdev->vmirror = ptr[0] & 0x03;
627 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
628 after a short frame; this condition is filtered out specifically. A 4 byte
629 frame doesn't make sense anyway.
630 So we get either this sequence:
631 drop_bit set -> 4 byte frame -> short frame -> good frame
633 drop_bit set -> short frame -> good frame
634 So we drop either 3 or 2 frames in all!
636 if (fbuf->filled == 4)
639 else if (pdev->type == 740 || pdev->type == 720) {
640 unsigned char *ptr = (unsigned char *)fbuf->data;
641 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
643 pdev->snapshot_button_status = 1;
644 PWC_TRACE("Snapshot button pressed.\n");
647 PWC_TRACE("Snapshot button released.\n");
649 pdev->vmirror = ptr[0] & 0x03;
652 /* In case we were instructed to drop the frame, do so silently.
653 The buffer pointers are not updated either (but the counters are reset below).
655 if (pdev->drop_frames > 0)
658 /* Check for underflow first */
659 if (fbuf->filled < pdev->frame_total_size) {
660 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
661 " discarded.\n", fbuf->filled);
662 pdev->vframes_error++;
665 /* Send only once per EOF */
666 awake = 1; /* delay wake_ups */
668 /* Find our next frame to fill. This will always succeed, since we
669 * nick a frame from either empty or full list, but if we had to
670 * take it from the full list, it means a frame got dropped.
672 if (pwc_next_fill_frame(pdev))
673 pwc_frame_dumped(pdev);
677 pdev->vframe_count++;
681 /* This gets called for the Isochronous pipe (video). This is done in
682 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
684 static void pwc_isoc_handler(struct urb *urb)
686 struct pwc_device *pdev;
689 struct pwc_frame_buf *fbuf;
690 unsigned char *fillptr = NULL, *iso_buf = NULL;
693 pdev = (struct pwc_device *)urb->context;
695 PWC_ERROR("isoc_handler() called with NULL device?!\n");
699 if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
700 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
703 if (urb->status != -EINPROGRESS && urb->status != 0) {
707 switch(urb->status) {
708 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
709 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
710 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
711 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
712 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
713 case -ETIME: errmsg = "Device does not respond"; break;
715 PWC_DEBUG_FLOW("pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
716 /* Give up after a number of contiguous errors on the USB bus.
717 Appearantly something is wrong so we simulate an unplug event.
719 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
721 PWC_INFO("Too many ISOC errors, bailing out.\n");
722 pdev->error_status = EIO;
724 wake_up_interruptible(&pdev->frameq);
726 goto handler_end; // ugly, but practical
729 fbuf = pdev->fill_frame;
731 PWC_ERROR("pwc_isoc_handler without valid fill frame.\n");
736 fillptr = fbuf->data + fbuf->filled;
739 /* Reset ISOC error counter. We did get here, after all. */
740 pdev->visoc_errors = 0;
742 /* vsync: 0 = don't copy data
747 for (i = 0; i < urb->number_of_packets; i++) {
748 fst = urb->iso_frame_desc[i].status;
749 flen = urb->iso_frame_desc[i].actual_length;
750 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
752 if (flen > 0) { /* if valid data... */
753 if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */
756 /* ...copy data to frame buffer, if possible */
757 if (flen + fbuf->filled > pdev->frame_total_size) {
758 PWC_DEBUG_FLOW("Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen, pdev->frame_total_size);
759 pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */
760 pdev->vframes_error++;
763 memmove(fillptr, iso_buf, flen);
767 fbuf->filled += flen;
770 if (flen < pdev->vlast_packet_size) {
771 /* Shorter packet... We probably have the end of an image-frame;
772 wake up read() process and let select()/poll() do something.
773 Decompression is done in user time over there.
775 if (pdev->vsync == 2) {
776 if (pwc_rcv_short_packet(pdev, fbuf)) {
778 fbuf = pdev->fill_frame;
782 fillptr = fbuf->data;
786 pdev->vlast_packet_size = flen;
787 } /* ..status == 0 */
789 /* This is normally not interesting to the user, unless
790 * you are really debugging something, default = 0 */
791 static int iso_error;
794 PWC_DEBUG_FLOW("Iso frame %d of USB has error %d\n", i, fst);
800 wake_up_interruptible(&pdev->frameq);
802 urb->dev = pdev->udev;
803 i = usb_submit_urb(urb, GFP_ATOMIC);
805 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
809 int pwc_isoc_init(struct pwc_device *pdev)
811 struct usb_device *udev;
815 struct usb_interface *intf;
816 struct usb_host_interface *idesc = NULL;
825 /* Get the current alternate interface, adjust packet size */
826 if (!udev->actconfig)
828 intf = usb_ifnum_to_if(udev, 0);
830 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
835 /* Search video endpoint */
836 pdev->vmax_packet_size = -1;
837 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
838 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
839 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
844 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
845 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
846 return -ENFILE; /* Odd error, that should be noticeable */
849 /* Set alternate interface */
851 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
852 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
856 for (i = 0; i < MAX_ISO_BUFS; i++) {
857 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
859 PWC_ERROR("Failed to allocate urb %d\n", i);
863 pdev->sbuf[i].urb = urb;
864 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
867 /* De-allocate in reverse order */
869 usb_free_urb(pdev->sbuf[i].urb);
870 pdev->sbuf[i].urb = NULL;
875 /* init URB structure */
876 for (i = 0; i < MAX_ISO_BUFS; i++) {
877 urb = pdev->sbuf[i].urb;
879 urb->interval = 1; // devik
881 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
882 urb->transfer_flags = URB_ISO_ASAP;
883 urb->transfer_buffer = pdev->sbuf[i].data;
884 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
885 urb->complete = pwc_isoc_handler;
887 urb->start_frame = 0;
888 urb->number_of_packets = ISO_FRAMES_PER_DESC;
889 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
890 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
891 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
896 for (i = 0; i < MAX_ISO_BUFS; i++) {
897 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL);
899 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
901 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->sbuf[i].urb);
906 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
910 static void pwc_iso_stop(struct pwc_device *pdev)
914 /* Unlinking ISOC buffers one by one */
915 for (i = 0; i < MAX_ISO_BUFS; i++) {
918 urb = pdev->sbuf[i].urb;
920 PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb);
926 static void pwc_iso_free(struct pwc_device *pdev)
930 /* Freeing ISOC buffers one by one */
931 for (i = 0; i < MAX_ISO_BUFS; i++) {
934 urb = pdev->sbuf[i].urb;
936 PWC_DEBUG_MEMORY("Freeing URB\n");
938 pdev->sbuf[i].urb = NULL;
943 void pwc_isoc_cleanup(struct pwc_device *pdev)
945 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
948 if (pdev->iso_init == 0)
954 /* Stop camera, but only if we are sure the camera is still there (unplug
955 is signalled by EPIPE)
957 if (pdev->error_status && pdev->error_status != EPIPE) {
958 PWC_DEBUG_OPEN("Setting alternate interface 0.\n");
959 usb_set_interface(pdev->udev, 0, 0);
963 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
966 int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot)
970 /* Stop isoc stuff */
971 pwc_isoc_cleanup(pdev);
972 /* Reset parameters */
973 pwc_reset_buffers(pdev);
974 /* Try to set video mode... */
975 start = ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot);
977 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 1 failed.\n");
978 /* That failed... restore old mode (we know that worked) */
979 start = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
981 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 2 failed.\n");
986 if (pwc_isoc_init(pdev) < 0)
988 PWC_WARNING("Failed to restart ISOC transfers in pwc_try_video_mode.\n");
989 ret = -EAGAIN; /* let's try again, who knows if it works a second time */
992 pdev->drop_frames++; /* try to avoid garbage during switch */
993 return ret; /* Return original error code */
999 static struct pwc_device *cd_to_pwc(struct device *cd)
1001 struct video_device *vdev = to_video_device(cd);
1002 return video_get_drvdata(vdev);
1005 static ssize_t show_pan_tilt(struct device *class_dev,
1006 struct device_attribute *attr, char *buf)
1008 struct pwc_device *pdev = cd_to_pwc(class_dev);
1009 return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
1012 static ssize_t store_pan_tilt(struct device *class_dev,
1013 struct device_attribute *attr,
1014 const char *buf, size_t count)
1016 struct pwc_device *pdev = cd_to_pwc(class_dev);
1020 if (strncmp(buf, "reset", 5) == 0)
1021 ret = pwc_mpt_reset(pdev, 0x3);
1023 else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
1024 ret = pwc_mpt_set_angle(pdev, pan, tilt);
1030 static DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
1033 static ssize_t show_snapshot_button_status(struct device *class_dev,
1034 struct device_attribute *attr, char *buf)
1036 struct pwc_device *pdev = cd_to_pwc(class_dev);
1037 int status = pdev->snapshot_button_status;
1038 pdev->snapshot_button_status = 0;
1039 return sprintf(buf, "%d\n", status);
1042 static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
1045 static int pwc_create_sysfs_files(struct video_device *vdev)
1047 struct pwc_device *pdev = video_get_drvdata(vdev);
1050 rc = device_create_file(&vdev->dev, &dev_attr_button);
1053 if (pdev->features & FEATURE_MOTOR_PANTILT) {
1054 rc = device_create_file(&vdev->dev, &dev_attr_pan_tilt);
1055 if (rc) goto err_button;
1061 device_remove_file(&vdev->dev, &dev_attr_button);
1063 PWC_ERROR("Could not create sysfs files.\n");
1067 static void pwc_remove_sysfs_files(struct video_device *vdev)
1069 struct pwc_device *pdev = video_get_drvdata(vdev);
1070 if (pdev->features & FEATURE_MOTOR_PANTILT)
1071 device_remove_file(&vdev->dev, &dev_attr_pan_tilt);
1072 device_remove_file(&vdev->dev, &dev_attr_button);
1075 #ifdef CONFIG_USB_PWC_DEBUG
1076 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
1078 switch(sensor_type) {
1080 return "Hyundai CMOS sensor";
1082 return "Sony CCD sensor + TDA8787";
1084 return "Sony CCD sensor + Exas 98L59";
1086 return "Sony CCD sensor + ADI 9804";
1088 return "Sharp CCD sensor + TDA8787";
1090 return "Sharp CCD sensor + Exas 98L59";
1092 return "Sharp CCD sensor + ADI 9804";
1094 return "UPA 1021 sensor";
1096 return "VGA sensor";
1098 return "PAL MR sensor";
1100 return "unknown type of sensor";
1105 /***************************************************************************/
1106 /* Video4Linux functions */
1108 static int pwc_video_open(struct inode *inode, struct file *file)
1111 struct video_device *vdev = video_devdata(file);
1112 struct pwc_device *pdev;
1114 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
1116 pdev = (struct pwc_device *)vdev->priv;
1119 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1123 mutex_lock(&pdev->modlock);
1124 if (!pdev->usb_init) {
1125 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1128 /* Query sensor type */
1129 ret = pwc_get_cmos_sensor(pdev, &i);
1132 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1134 pwc_sensor_type_to_string(i), i);
1138 /* Turn on camera */
1140 i = pwc_camera_power(pdev, 1);
1142 PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
1144 /* Set LED on/off time */
1145 if (pwc_set_leds(pdev, led_on, led_off) < 0)
1146 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1148 pwc_construct(pdev); /* set min/max sizes correct */
1150 /* So far, so good. Allocate memory. */
1151 i = pwc_allocate_buffers(pdev);
1153 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1154 pwc_free_buffers(pdev);
1155 mutex_unlock(&pdev->modlock);
1159 /* Reset buffers & parameters */
1160 pwc_reset_buffers(pdev);
1161 for (i = 0; i < pwc_mbufs; i++)
1162 pdev->image_used[i] = 0;
1163 pdev->vframe_count = 0;
1164 pdev->vframes_dumped = 0;
1165 pdev->vframes_error = 0;
1166 pdev->visoc_errors = 0;
1167 pdev->error_status = 0;
1168 pwc_construct(pdev); /* set min/max sizes correct */
1170 /* Set some defaults */
1171 pdev->vsnapshot = 0;
1173 /* Start iso pipe for video; first try the last used video size
1174 (or the default one); if that fails try QCIF/10 or QSIF/10;
1175 it that fails too, give up.
1177 i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1179 unsigned int default_resolution;
1180 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1181 if (pdev->type>= 730)
1182 default_resolution = PSZ_QSIF;
1184 default_resolution = PSZ_QCIF;
1186 i = pwc_set_video_mode(pdev,
1187 pwc_image_sizes[default_resolution].x,
1188 pwc_image_sizes[default_resolution].y,
1194 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1195 pwc_free_buffers(pdev);
1196 mutex_unlock(&pdev->modlock);
1200 i = pwc_isoc_init(pdev);
1202 PWC_DEBUG_OPEN("Failed to init ISOC stuff = %d.\n", i);
1203 pwc_isoc_cleanup(pdev);
1204 pwc_free_buffers(pdev);
1205 mutex_unlock(&pdev->modlock);
1209 /* Initialize the webcam to sane value */
1210 pwc_set_brightness(pdev, 0x7fff);
1211 pwc_set_agc(pdev, 1, 0);
1214 file->private_data = vdev;
1215 mutex_unlock(&pdev->modlock);
1216 PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1221 static void pwc_cleanup(struct pwc_device *pdev)
1223 pwc_remove_sysfs_files(pdev->vdev);
1224 video_unregister_device(pdev->vdev);
1227 /* Note that all cleanup is done in the reverse order as in _open */
1228 static int pwc_video_close(struct inode *inode, struct file *file)
1230 struct video_device *vdev = file->private_data;
1231 struct pwc_device *pdev;
1234 PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
1237 pdev = (struct pwc_device *)vdev->priv;
1238 if (pdev->vopen == 0)
1239 PWC_DEBUG_MODULE("video_close() called on closed device?\n");
1241 /* Dump statistics, but only if a reasonable amount of frames were
1242 processed (to prevent endless log-entries in case of snap-shot
1245 if (pdev->vframe_count > 20)
1246 PWC_DEBUG_MODULE("Closing video device: %d frames received, dumped %d frames, %d frames with errors.\n", pdev->vframe_count, pdev->vframes_dumped, pdev->vframes_error);
1248 if (DEVICE_USE_CODEC1(pdev->type))
1253 pwc_isoc_cleanup(pdev);
1254 pwc_free_buffers(pdev);
1256 /* Turn off LEDS and power down camera, but only when not unplugged */
1257 if (!pdev->unplugged) {
1259 if (pwc_set_leds(pdev, 0, 0) < 0)
1260 PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
1262 i = pwc_camera_power(pdev, 0);
1264 PWC_ERROR("Failed to power down camera (%d)\n", i);
1267 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
1270 /* Free memory (don't set pdev to 0 just yet) */
1272 /* search device_hint[] table if we occupy a slot, by any chance */
1273 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1274 if (device_hint[hint].pdev == pdev)
1275 device_hint[hint].pdev = NULL;
1283 * FIXME: what about two parallel reads ????
1284 * ANSWER: Not supported. You can't open the device more than once,
1285 despite what the V4L1 interface says. First, I don't see
1286 the need, second there's no mechanism of alerting the
1287 2nd/3rd/... process of events like changing image size.
1288 And I don't see the point of blocking that for the
1289 2nd/3rd/... process.
1290 In multi-threaded environments reading parallel from any
1291 device is tricky anyhow.
1294 static ssize_t pwc_video_read(struct file *file, char __user *buf,
1295 size_t count, loff_t *ppos)
1297 struct video_device *vdev = file->private_data;
1298 struct pwc_device *pdev;
1299 int noblock = file->f_flags & O_NONBLOCK;
1300 DECLARE_WAITQUEUE(wait, current);
1301 int bytes_to_read, rv = 0;
1302 void *image_buffer_addr;
1304 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1312 mutex_lock(&pdev->modlock);
1313 if (pdev->error_status) {
1314 rv = -pdev->error_status; /* Something happened, report what. */
1318 /* In case we're doing partial reads, we don't have to wait for a frame */
1319 if (pdev->image_read_pos == 0) {
1320 /* Do wait queueing according to the (doc)book */
1321 add_wait_queue(&pdev->frameq, &wait);
1322 while (pdev->full_frames == NULL) {
1323 /* Check for unplugged/etc. here */
1324 if (pdev->error_status) {
1325 remove_wait_queue(&pdev->frameq, &wait);
1326 set_current_state(TASK_RUNNING);
1327 rv = -pdev->error_status ;
1331 remove_wait_queue(&pdev->frameq, &wait);
1332 set_current_state(TASK_RUNNING);
1336 if (signal_pending(current)) {
1337 remove_wait_queue(&pdev->frameq, &wait);
1338 set_current_state(TASK_RUNNING);
1343 set_current_state(TASK_INTERRUPTIBLE);
1345 remove_wait_queue(&pdev->frameq, &wait);
1346 set_current_state(TASK_RUNNING);
1348 /* Decompress and release frame */
1349 if (pwc_handle_frame(pdev)) {
1355 PWC_DEBUG_READ("Copying data to user space.\n");
1356 if (pdev->vpalette == VIDEO_PALETTE_RAW)
1357 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1359 bytes_to_read = pdev->view.size;
1361 /* copy bytes to user space; we allow for partial reads */
1362 if (count + pdev->image_read_pos > bytes_to_read)
1363 count = bytes_to_read - pdev->image_read_pos;
1364 image_buffer_addr = pdev->image_data;
1365 image_buffer_addr += pdev->images[pdev->fill_image].offset;
1366 image_buffer_addr += pdev->image_read_pos;
1367 if (copy_to_user(buf, image_buffer_addr, count)) {
1371 pdev->image_read_pos += count;
1372 if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
1373 pdev->image_read_pos = 0;
1374 pwc_next_image(pdev);
1376 mutex_unlock(&pdev->modlock);
1379 mutex_unlock(&pdev->modlock);
1383 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1385 struct video_device *vdev = file->private_data;
1386 struct pwc_device *pdev;
1394 poll_wait(file, &pdev->frameq, wait);
1395 if (pdev->error_status)
1397 if (pdev->full_frames != NULL) /* we have frames waiting */
1398 return (POLLIN | POLLRDNORM);
1403 static int pwc_video_ioctl(struct inode *inode, struct file *file,
1404 unsigned int cmd, unsigned long arg)
1406 struct video_device *vdev = file->private_data;
1407 struct pwc_device *pdev;
1414 mutex_lock(&pdev->modlock);
1415 if (!pdev->unplugged)
1416 r = video_usercopy(inode, file, cmd, arg, pwc_video_do_ioctl);
1417 mutex_unlock(&pdev->modlock);
1422 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1424 struct video_device *vdev = file->private_data;
1425 struct pwc_device *pdev;
1426 unsigned long start;
1428 unsigned long page, pos = 0;
1431 PWC_DEBUG_MEMORY(">> %s\n", __func__);
1433 size = vma->vm_end - vma->vm_start;
1434 start = vma->vm_start;
1436 /* Find the idx buffer for this mapping */
1437 for (index = 0; index < pwc_mbufs; index++) {
1438 pos = pdev->images[index].offset;
1439 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1442 if (index == MAX_IMAGES)
1446 * Special case for v4l1. In v4l1, we map only one big buffer,
1447 * but in v4l2 each buffer is mapped
1449 unsigned long total_size;
1450 total_size = pwc_mbufs * pdev->len_per_image;
1451 if (size != pdev->len_per_image && size != total_size) {
1452 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1453 size, pdev->len_per_image, total_size);
1456 } else if (size > pdev->len_per_image)
1459 vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
1461 pos += (unsigned long)pdev->image_data;
1463 page = vmalloc_to_pfn((void *)pos);
1464 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1468 if (size > PAGE_SIZE)
1476 /***************************************************************************/
1479 /* This function gets called when a new device is plugged in or the usb core
1483 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1485 struct usb_device *udev = interface_to_usbdev(intf);
1486 struct pwc_device *pdev = NULL;
1487 int vendor_id, product_id, type_id;
1490 int video_nr = -1; /* default: use next available device */
1491 char serial_number[30], *name;
1493 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1494 product_id = le16_to_cpu(udev->descriptor.idProduct);
1496 /* Check if we can handle this device */
1497 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1498 vendor_id, product_id,
1499 intf->altsetting->desc.bInterfaceNumber);
1501 /* the interfaces are probed one by one. We are only interested in the
1502 video interface (0) now.
1503 Interface 1 is the Audio Control, and interface 2 Audio itself.
1505 if (intf->altsetting->desc.bInterfaceNumber > 0)
1508 if (vendor_id == 0x0471) {
1509 switch (product_id) {
1511 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1512 name = "Philips 645 webcam";
1516 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1517 name = "Philips 646 webcam";
1521 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1522 name = "Askey VC010 webcam";
1526 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1527 name = "Philips 675 webcam";
1531 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1532 name = "Philips 680 webcam";
1536 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1537 name = "Philips 690 webcam";
1541 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1542 name = "Philips 730 webcam";
1546 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1547 name = "Philips 740 webcam";
1551 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1552 name = "Philips 750 webcam";
1556 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1557 name = "Philips 720K/40 webcam";
1561 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1562 name = "Philips SPC 900NC webcam";
1570 else if (vendor_id == 0x069A) {
1571 switch(product_id) {
1573 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1574 name = "Askey VC010 webcam";
1582 else if (vendor_id == 0x046d) {
1583 switch(product_id) {
1585 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1586 name = "Logitech QuickCam Pro 3000";
1587 type_id = 740; /* CCD sensor */
1590 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1591 name = "Logitech QuickCam Notebook Pro";
1592 type_id = 740; /* CCD sensor */
1595 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1596 name = "Logitech QuickCam Pro 4000";
1597 type_id = 740; /* CCD sensor */
1600 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1601 name = "Logitech QuickCam Zoom";
1602 type_id = 740; /* CCD sensor */
1605 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1606 name = "Logitech QuickCam Zoom";
1607 type_id = 740; /* CCD sensor */
1611 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1612 name = "Logitech QuickCam Orbit";
1613 type_id = 740; /* CCD sensor */
1614 features |= FEATURE_MOTOR_PANTILT;
1617 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1618 name = "Cisco VT Camera";
1619 type_id = 740; /* CCD sensor */
1622 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1623 name = "Logitech ViewPort AV 100";
1624 type_id = 740; /* CCD sensor */
1626 case 0x08b8: /* Where this released? */
1627 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1628 name = "Logitech QuickCam (res.)";
1629 type_id = 730; /* Assuming CMOS */
1636 else if (vendor_id == 0x055d) {
1637 /* I don't know the difference between the C10 and the C30;
1638 I suppose the difference is the sensor, but both cameras
1639 work equally well with a type_id of 675
1641 switch(product_id) {
1643 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1644 name = "Samsung MPC-C10";
1648 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1649 name = "Samsung MPC-C30";
1653 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1654 name = "Samsung MPC-C30";
1662 else if (vendor_id == 0x041e) {
1663 switch(product_id) {
1665 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1666 name = "Creative Labs Webcam 5";
1670 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1671 name = "Creative Labs Webcam Pro Ex";
1679 else if (vendor_id == 0x04cc) {
1680 switch(product_id) {
1682 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1683 name = "Sotec Afina Eye";
1691 else if (vendor_id == 0x06be) {
1692 switch(product_id) {
1694 /* This is essentially the same cam as the Sotec Afina Eye */
1695 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1696 name = "AME Co. Afina Eye";
1705 else if (vendor_id == 0x0d81) {
1706 switch(product_id) {
1708 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1709 name = "Visionite VCS-UC300";
1710 type_id = 740; /* CCD sensor */
1713 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1714 name = "Visionite VCS-UM100";
1715 type_id = 730; /* CMOS sensor */
1723 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1725 memset(serial_number, 0, 30);
1726 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1727 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1729 if (udev->descriptor.bNumConfigurations > 1)
1730 PWC_WARNING("Warning: more than 1 configuration available.\n");
1732 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1733 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1735 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1738 pdev->type = type_id;
1739 pdev->vsize = default_size;
1740 pdev->vframes = default_fps;
1741 strcpy(pdev->serial, serial_number);
1742 pdev->features = features;
1743 if (vendor_id == 0x046D && product_id == 0x08B5)
1745 /* Logitech QuickCam Orbit
1746 The ranges have been determined experimentally; they may differ from cam to cam.
1747 Also, the exact ranges left-right and up-down are different for my cam
1749 pdev->angle_range.pan_min = -7000;
1750 pdev->angle_range.pan_max = 7000;
1751 pdev->angle_range.tilt_min = -3000;
1752 pdev->angle_range.tilt_max = 2500;
1755 mutex_init(&pdev->modlock);
1756 spin_lock_init(&pdev->ptrlock);
1759 init_waitqueue_head(&pdev->frameq);
1760 pdev->vcompression = pwc_preferred_compression;
1762 /* Allocate video_device structure */
1763 pdev->vdev = video_device_alloc();
1765 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
1769 memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
1770 pdev->vdev->parent = &(udev->dev);
1771 strcpy(pdev->vdev->name, name);
1772 video_set_drvdata(pdev->vdev, pdev);
1774 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1775 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1777 /* Now search device_hint[] table for a match, so we can hint a node number. */
1778 for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1779 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1780 (device_hint[hint].pdev == NULL)) {
1781 /* so far, so good... try serial number */
1782 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1784 video_nr = device_hint[hint].device_node;
1785 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1791 pdev->vdev->release = video_device_release;
1792 i = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1794 PWC_ERROR("Failed to register as video device (%d).\n", i);
1799 PWC_INFO("Registered as /dev/video%d.\n", pdev->vdev->minor & 0x3F);
1803 if (hint < MAX_DEV_HINTS)
1804 device_hint[hint].pdev = pdev;
1806 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1807 usb_set_intfdata (intf, pdev);
1808 rc = pwc_create_sysfs_files(pdev->vdev);
1812 /* Set the leds off */
1813 pwc_set_leds(pdev, 0, 0);
1814 pwc_camera_power(pdev, 0);
1819 if (hint < MAX_DEV_HINTS)
1820 device_hint[hint].pdev = NULL;
1821 video_unregister_device(pdev->vdev);
1823 video_device_release(pdev->vdev); /* Drip... drip... drip... */
1824 kfree(pdev); /* Oops, no memory leaks please */
1828 /* The user janked out the cable... */
1829 static void usb_pwc_disconnect(struct usb_interface *intf)
1831 struct pwc_device *pdev;
1835 pdev = usb_get_intfdata (intf);
1836 usb_set_intfdata (intf, NULL);
1838 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1839 goto disconnect_out;
1841 if (pdev->udev == NULL) {
1842 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1843 goto disconnect_out;
1845 if (pdev->udev != interface_to_usbdev(intf)) {
1846 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1847 goto disconnect_out;
1850 /* We got unplugged; this is signalled by an EPIPE error code */
1852 PWC_INFO("Disconnected while webcam is in use!\n");
1853 pdev->error_status = EPIPE;
1856 /* Alert waiting processes */
1857 wake_up_interruptible(&pdev->frameq);
1858 /* Wait until device is closed */
1860 mutex_lock(&pdev->modlock);
1861 pdev->unplugged = 1;
1862 mutex_unlock(&pdev->modlock);
1865 /* Device is closed, so we can safely unregister it */
1866 PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
1868 /* Free memory (don't set pdev to 0 just yet) */
1872 /* search device_hint[] table if we occupy a slot, by any chance */
1873 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1874 if (device_hint[hint].pdev == pdev)
1875 device_hint[hint].pdev = NULL;
1881 /* *grunt* We have to do atoi ourselves :-( */
1882 static int pwc_atoi(const char *s)
1887 while (*s != '\0' && *s >= '0' && *s <= '9') {
1888 k = 10 * k + (*s - '0');
1896 * Initialization code & module stuff
1903 static int compression = -1;
1904 static int leds[2] = { -1, -1 };
1905 static unsigned int leds_nargs;
1906 static char *dev_hint[MAX_DEV_HINTS];
1907 static unsigned int dev_hint_nargs;
1909 module_param(size, charp, 0444);
1910 module_param(fps, int, 0444);
1911 module_param(fbufs, int, 0444);
1912 module_param(mbufs, int, 0444);
1913 #ifdef CONFIG_USB_PWC_DEBUG
1914 module_param_named(trace, pwc_trace, int, 0644);
1916 module_param(power_save, int, 0444);
1917 module_param(compression, int, 0444);
1918 module_param_array(leds, int, &leds_nargs, 0444);
1919 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1921 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1922 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1923 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1924 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1925 MODULE_PARM_DESC(trace, "For debugging purposes");
1926 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1927 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1928 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1929 MODULE_PARM_DESC(dev_hint, "Device node hints");
1931 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1932 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1933 MODULE_LICENSE("GPL");
1934 MODULE_ALIAS("pwcx");
1935 MODULE_VERSION( PWC_VERSION );
1937 static int __init usb_pwc_init(void)
1940 char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1942 PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1943 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1944 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1945 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1948 if (fps < 4 || fps > 30) {
1949 PWC_ERROR("Framerate out of bounds (4-30).\n");
1953 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1957 /* string; try matching with array */
1958 for (sz = 0; sz < PSZ_MAX; sz++) {
1959 if (!strcmp(sizenames[sz], size)) { /* Found! */
1964 if (sz == PSZ_MAX) {
1965 PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1968 PWC_DEBUG_MODULE("Default image size set to %s [%dx%d].\n", sizenames[default_size], pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y);
1971 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1972 PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
1976 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
1979 if (fbufs < 2 || fbufs > MAX_FRAMES) {
1980 PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
1983 default_fbufs = fbufs;
1984 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
1986 #ifdef CONFIG_USB_PWC_DEBUG
1987 if (pwc_trace >= 0) {
1988 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1991 if (compression >= 0) {
1992 if (compression > 3) {
1993 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1996 pwc_preferred_compression = compression;
1997 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
2000 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
2006 /* Big device node whoopla. Basically, it allows you to assign a
2007 device node (/dev/videoX) to a camera, based on its type
2008 & serial number. The format is [type[.serialnumber]:]node.
2010 Any camera that isn't matched by these rules gets the next
2011 available free device node.
2013 for (i = 0; i < MAX_DEV_HINTS; i++) {
2014 char *s, *colon, *dot;
2016 /* This loop also initializes the array */
2017 device_hint[i].pdev = NULL;
2019 if (s != NULL && *s != '\0') {
2020 device_hint[i].type = -1; /* wildcard */
2021 strcpy(device_hint[i].serial_number, "*");
2023 /* parse string: chop at ':' & '/' */
2025 while (*colon != '\0' && *colon != ':')
2027 while (*dot != '\0' && *dot != '.')
2029 /* Few sanity checks */
2030 if (*dot != '\0' && dot > colon) {
2031 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
2035 if (*colon == '\0') {
2038 PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
2042 /* No type or serial number specified, just a number. */
2043 device_hint[i].device_node = pwc_atoi(s);
2047 /* There's a colon, so we have at least a type and a device node */
2048 device_hint[i].type = pwc_atoi(s);
2049 device_hint[i].device_node = pwc_atoi(colon + 1);
2051 /* There's a serial number as well */
2056 while (*dot != ':' && k < 29) {
2057 device_hint[i].serial_number[k++] = *dot;
2060 device_hint[i].serial_number[k] = '\0';
2063 PWC_TRACE("device_hint[%d]:\n", i);
2064 PWC_TRACE(" type : %d\n", device_hint[i].type);
2065 PWC_TRACE(" serial# : %s\n", device_hint[i].serial_number);
2066 PWC_TRACE(" node : %d\n", device_hint[i].device_node);
2069 device_hint[i].type = 0; /* not filled */
2070 } /* ..for MAX_DEV_HINTS */
2072 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
2073 return usb_register(&pwc_driver);
2076 static void __exit usb_pwc_exit(void)
2078 PWC_DEBUG_MODULE("Deregistering driver.\n");
2079 usb_deregister(&pwc_driver);
2080 PWC_INFO("Philips webcam module removed.\n");
2083 module_init(usb_pwc_init);
2084 module_exit(usb_pwc_exit);
2086 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */