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 = 0;
134 static int led_on = 100, led_off = 0; /* 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,
162 .compat_ioctl = v4l_compat_ioctl32,
165 static struct video_device pwc_template = {
166 .owner = THIS_MODULE,
167 .name = "Philips Webcam", /* Filled in later */
168 .type = VID_TYPE_CAPTURE,
169 .hardware = VID_HARDWARE_PWC,
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", __FUNCTION__);
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", __FUNCTION__);
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 lenghty 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 */
791 static int iso_error = 0;
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 class_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 class_device *class_dev, char *buf)
1007 struct pwc_device *pdev = cd_to_pwc(class_dev);
1008 return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
1011 static ssize_t store_pan_tilt(struct class_device *class_dev, const char *buf,
1014 struct pwc_device *pdev = cd_to_pwc(class_dev);
1018 if (strncmp(buf, "reset", 5) == 0)
1019 ret = pwc_mpt_reset(pdev, 0x3);
1021 else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
1022 ret = pwc_mpt_set_angle(pdev, pan, tilt);
1028 static CLASS_DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
1031 static ssize_t show_snapshot_button_status(struct class_device *class_dev, char *buf)
1033 struct pwc_device *pdev = cd_to_pwc(class_dev);
1034 int status = pdev->snapshot_button_status;
1035 pdev->snapshot_button_status = 0;
1036 return sprintf(buf, "%d\n", status);
1039 static CLASS_DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
1042 static int pwc_create_sysfs_files(struct video_device *vdev)
1044 struct pwc_device *pdev = video_get_drvdata(vdev);
1047 rc = video_device_create_file(vdev, &class_device_attr_button);
1050 if (pdev->features & FEATURE_MOTOR_PANTILT) {
1051 rc = video_device_create_file(vdev,&class_device_attr_pan_tilt);
1052 if (rc) goto err_button;
1058 video_device_remove_file(vdev, &class_device_attr_button);
1063 static void pwc_remove_sysfs_files(struct video_device *vdev)
1065 struct pwc_device *pdev = video_get_drvdata(vdev);
1066 if (pdev->features & FEATURE_MOTOR_PANTILT)
1067 video_device_remove_file(vdev, &class_device_attr_pan_tilt);
1068 video_device_remove_file(vdev, &class_device_attr_button);
1071 #ifdef CONFIG_USB_PWC_DEBUG
1072 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
1074 switch(sensor_type) {
1076 return "Hyundai CMOS sensor";
1078 return "Sony CCD sensor + TDA8787";
1080 return "Sony CCD sensor + Exas 98L59";
1082 return "Sony CCD sensor + ADI 9804";
1084 return "Sharp CCD sensor + TDA8787";
1086 return "Sharp CCD sensor + Exas 98L59";
1088 return "Sharp CCD sensor + ADI 9804";
1090 return "UPA 1021 sensor";
1092 return "VGA sensor";
1094 return "PAL MR sensor";
1096 return "unknown type of sensor";
1101 /***************************************************************************/
1102 /* Video4Linux functions */
1104 static int pwc_video_open(struct inode *inode, struct file *file)
1107 struct video_device *vdev = video_devdata(file);
1108 struct pwc_device *pdev;
1110 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
1112 pdev = (struct pwc_device *)vdev->priv;
1115 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1119 mutex_lock(&pdev->modlock);
1120 if (!pdev->usb_init) {
1121 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1124 /* Query sensor type */
1125 ret = pwc_get_cmos_sensor(pdev, &i);
1128 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1130 pwc_sensor_type_to_string(i), i);
1134 /* Turn on camera */
1136 i = pwc_camera_power(pdev, 1);
1138 PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
1140 /* Set LED on/off time */
1141 if (pwc_set_leds(pdev, led_on, led_off) < 0)
1142 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1144 pwc_construct(pdev); /* set min/max sizes correct */
1146 /* So far, so good. Allocate memory. */
1147 i = pwc_allocate_buffers(pdev);
1149 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1150 pwc_free_buffers(pdev);
1151 mutex_unlock(&pdev->modlock);
1155 /* Reset buffers & parameters */
1156 pwc_reset_buffers(pdev);
1157 for (i = 0; i < pwc_mbufs; i++)
1158 pdev->image_used[i] = 0;
1159 pdev->vframe_count = 0;
1160 pdev->vframes_dumped = 0;
1161 pdev->vframes_error = 0;
1162 pdev->visoc_errors = 0;
1163 pdev->error_status = 0;
1164 pwc_construct(pdev); /* set min/max sizes correct */
1166 /* Set some defaults */
1167 pdev->vsnapshot = 0;
1169 /* Start iso pipe for video; first try the last used video size
1170 (or the default one); if that fails try QCIF/10 or QSIF/10;
1171 it that fails too, give up.
1173 i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1175 unsigned int default_resolution;
1176 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1177 if (pdev->type>= 730)
1178 default_resolution = PSZ_QSIF;
1180 default_resolution = PSZ_QCIF;
1182 i = pwc_set_video_mode(pdev,
1183 pwc_image_sizes[default_resolution].x,
1184 pwc_image_sizes[default_resolution].y,
1190 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1191 pwc_free_buffers(pdev);
1192 mutex_unlock(&pdev->modlock);
1196 i = pwc_isoc_init(pdev);
1198 PWC_DEBUG_OPEN("Failed to init ISOC stuff = %d.\n", i);
1199 pwc_isoc_cleanup(pdev);
1200 pwc_free_buffers(pdev);
1201 mutex_unlock(&pdev->modlock);
1205 /* Initialize the webcam to sane value */
1206 pwc_set_brightness(pdev, 0x7fff);
1207 pwc_set_agc(pdev, 1, 0);
1210 file->private_data = vdev;
1211 mutex_unlock(&pdev->modlock);
1212 PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1217 static void pwc_cleanup(struct pwc_device *pdev)
1219 pwc_remove_sysfs_files(pdev->vdev);
1220 video_unregister_device(pdev->vdev);
1223 /* Note that all cleanup is done in the reverse order as in _open */
1224 static int pwc_video_close(struct inode *inode, struct file *file)
1226 struct video_device *vdev = file->private_data;
1227 struct pwc_device *pdev;
1230 PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
1233 pdev = (struct pwc_device *)vdev->priv;
1234 if (pdev->vopen == 0)
1235 PWC_DEBUG_MODULE("video_close() called on closed device?\n");
1237 /* Dump statistics, but only if a reasonable amount of frames were
1238 processed (to prevent endless log-entries in case of snap-shot
1241 if (pdev->vframe_count > 20)
1242 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);
1244 if (DEVICE_USE_CODEC1(pdev->type))
1249 pwc_isoc_cleanup(pdev);
1250 pwc_free_buffers(pdev);
1252 /* Turn off LEDS and power down camera, but only when not unplugged */
1253 if (!pdev->unplugged) {
1255 if (pwc_set_leds(pdev, 0, 0) < 0)
1256 PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
1258 i = pwc_camera_power(pdev, 0);
1260 PWC_ERROR("Failed to power down camera (%d)\n", i);
1263 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
1266 /* Free memory (don't set pdev to 0 just yet) */
1268 /* search device_hint[] table if we occupy a slot, by any chance */
1269 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1270 if (device_hint[hint].pdev == pdev)
1271 device_hint[hint].pdev = NULL;
1279 * FIXME: what about two parallel reads ????
1280 * ANSWER: Not supported. You can't open the device more than once,
1281 despite what the V4L1 interface says. First, I don't see
1282 the need, second there's no mechanism of alerting the
1283 2nd/3rd/... process of events like changing image size.
1284 And I don't see the point of blocking that for the
1285 2nd/3rd/... process.
1286 In multi-threaded environments reading parallel from any
1287 device is tricky anyhow.
1290 static ssize_t pwc_video_read(struct file *file, char __user *buf,
1291 size_t count, loff_t *ppos)
1293 struct video_device *vdev = file->private_data;
1294 struct pwc_device *pdev;
1295 int noblock = file->f_flags & O_NONBLOCK;
1296 DECLARE_WAITQUEUE(wait, current);
1297 int bytes_to_read, rv = 0;
1298 void *image_buffer_addr;
1300 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1308 mutex_lock(&pdev->modlock);
1309 if (pdev->error_status) {
1310 rv = -pdev->error_status; /* Something happened, report what. */
1314 /* In case we're doing partial reads, we don't have to wait for a frame */
1315 if (pdev->image_read_pos == 0) {
1316 /* Do wait queueing according to the (doc)book */
1317 add_wait_queue(&pdev->frameq, &wait);
1318 while (pdev->full_frames == NULL) {
1319 /* Check for unplugged/etc. here */
1320 if (pdev->error_status) {
1321 remove_wait_queue(&pdev->frameq, &wait);
1322 set_current_state(TASK_RUNNING);
1323 rv = -pdev->error_status ;
1327 remove_wait_queue(&pdev->frameq, &wait);
1328 set_current_state(TASK_RUNNING);
1332 if (signal_pending(current)) {
1333 remove_wait_queue(&pdev->frameq, &wait);
1334 set_current_state(TASK_RUNNING);
1339 set_current_state(TASK_INTERRUPTIBLE);
1341 remove_wait_queue(&pdev->frameq, &wait);
1342 set_current_state(TASK_RUNNING);
1344 /* Decompress and release frame */
1345 if (pwc_handle_frame(pdev)) {
1351 PWC_DEBUG_READ("Copying data to user space.\n");
1352 if (pdev->vpalette == VIDEO_PALETTE_RAW)
1353 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1355 bytes_to_read = pdev->view.size;
1357 /* copy bytes to user space; we allow for partial reads */
1358 if (count + pdev->image_read_pos > bytes_to_read)
1359 count = bytes_to_read - pdev->image_read_pos;
1360 image_buffer_addr = pdev->image_data;
1361 image_buffer_addr += pdev->images[pdev->fill_image].offset;
1362 image_buffer_addr += pdev->image_read_pos;
1363 if (copy_to_user(buf, image_buffer_addr, count)) {
1367 pdev->image_read_pos += count;
1368 if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
1369 pdev->image_read_pos = 0;
1370 pwc_next_image(pdev);
1372 mutex_unlock(&pdev->modlock);
1375 mutex_unlock(&pdev->modlock);
1379 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1381 struct video_device *vdev = file->private_data;
1382 struct pwc_device *pdev;
1390 poll_wait(file, &pdev->frameq, wait);
1391 if (pdev->error_status)
1393 if (pdev->full_frames != NULL) /* we have frames waiting */
1394 return (POLLIN | POLLRDNORM);
1399 static int pwc_video_ioctl(struct inode *inode, struct file *file,
1400 unsigned int cmd, unsigned long arg)
1402 struct video_device *vdev = file->private_data;
1403 struct pwc_device *pdev;
1410 mutex_lock(&pdev->modlock);
1411 if (!pdev->unplugged)
1412 r = video_usercopy(inode, file, cmd, arg, pwc_video_do_ioctl);
1413 mutex_unlock(&pdev->modlock);
1418 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1420 struct video_device *vdev = file->private_data;
1421 struct pwc_device *pdev;
1422 unsigned long start;
1424 unsigned long page, pos = 0;
1427 PWC_DEBUG_MEMORY(">> %s\n", __FUNCTION__);
1429 size = vma->vm_end - vma->vm_start;
1430 start = vma->vm_start;
1432 /* Find the idx buffer for this mapping */
1433 for (index = 0; index < pwc_mbufs; index++) {
1434 pos = pdev->images[index].offset;
1435 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1438 if (index == MAX_IMAGES)
1442 * Special case for v4l1. In v4l1, we map only one big buffer,
1443 * but in v4l2 each buffer is mapped
1445 unsigned long total_size;
1446 total_size = pwc_mbufs * pdev->len_per_image;
1447 if (size != pdev->len_per_image && size != total_size) {
1448 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1449 size, pdev->len_per_image, total_size);
1452 } else if (size > pdev->len_per_image)
1455 vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
1457 pos += (unsigned long)pdev->image_data;
1459 page = vmalloc_to_pfn((void *)pos);
1460 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1464 if (size > PAGE_SIZE)
1472 /***************************************************************************/
1475 /* This function gets called when a new device is plugged in or the usb core
1479 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1481 struct usb_device *udev = interface_to_usbdev(intf);
1482 struct pwc_device *pdev = NULL;
1483 int vendor_id, product_id, type_id;
1486 int video_nr = -1; /* default: use next available device */
1487 char serial_number[30], *name;
1489 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1490 product_id = le16_to_cpu(udev->descriptor.idProduct);
1492 /* Check if we can handle this device */
1493 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1494 vendor_id, product_id,
1495 intf->altsetting->desc.bInterfaceNumber);
1497 /* the interfaces are probed one by one. We are only interested in the
1498 video interface (0) now.
1499 Interface 1 is the Audio Control, and interface 2 Audio itself.
1501 if (intf->altsetting->desc.bInterfaceNumber > 0)
1504 if (vendor_id == 0x0471) {
1505 switch (product_id) {
1507 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1508 name = "Philips 645 webcam";
1512 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1513 name = "Philips 646 webcam";
1517 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1518 name = "Askey VC010 webcam";
1522 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1523 name = "Philips 675 webcam";
1527 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1528 name = "Philips 680 webcam";
1532 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1533 name = "Philips 690 webcam";
1537 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1538 name = "Philips 730 webcam";
1542 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1543 name = "Philips 740 webcam";
1547 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1548 name = "Philips 750 webcam";
1552 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1553 name = "Philips 720K/40 webcam";
1557 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1558 name = "Philips SPC 900NC webcam";
1566 else if (vendor_id == 0x069A) {
1567 switch(product_id) {
1569 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1570 name = "Askey VC010 webcam";
1578 else if (vendor_id == 0x046d) {
1579 switch(product_id) {
1581 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1582 name = "Logitech QuickCam Pro 3000";
1583 type_id = 740; /* CCD sensor */
1586 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1587 name = "Logitech QuickCam Notebook Pro";
1588 type_id = 740; /* CCD sensor */
1591 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1592 name = "Logitech QuickCam Pro 4000";
1593 type_id = 740; /* CCD sensor */
1596 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1597 name = "Logitech QuickCam Zoom";
1598 type_id = 740; /* CCD sensor */
1601 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1602 name = "Logitech QuickCam Zoom";
1603 type_id = 740; /* CCD sensor */
1607 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1608 name = "Logitech QuickCam Orbit";
1609 type_id = 740; /* CCD sensor */
1610 features |= FEATURE_MOTOR_PANTILT;
1613 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1614 name = "Cisco VT Camera";
1615 type_id = 740; /* CCD sensor */
1618 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1619 name = "Logitech ViewPort AV 100";
1620 type_id = 740; /* CCD sensor */
1622 case 0x08b8: /* Where this released? */
1623 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1624 name = "Logitech QuickCam (res.)";
1625 type_id = 730; /* Assuming CMOS */
1632 else if (vendor_id == 0x055d) {
1633 /* I don't know the difference between the C10 and the C30;
1634 I suppose the difference is the sensor, but both cameras
1635 work equally well with a type_id of 675
1637 switch(product_id) {
1639 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1640 name = "Samsung MPC-C10";
1644 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1645 name = "Samsung MPC-C30";
1649 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1650 name = "Samsung MPC-C30";
1658 else if (vendor_id == 0x041e) {
1659 switch(product_id) {
1661 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1662 name = "Creative Labs Webcam 5";
1666 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1667 name = "Creative Labs Webcam Pro Ex";
1675 else if (vendor_id == 0x04cc) {
1676 switch(product_id) {
1678 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1679 name = "Sotec Afina Eye";
1687 else if (vendor_id == 0x06be) {
1688 switch(product_id) {
1690 /* This is essentially the same cam as the Sotec Afina Eye */
1691 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1692 name = "AME Co. Afina Eye";
1701 else if (vendor_id == 0x0d81) {
1702 switch(product_id) {
1704 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1705 name = "Visionite VCS-UC300";
1706 type_id = 740; /* CCD sensor */
1709 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1710 name = "Visionite VCS-UM100";
1711 type_id = 730; /* CMOS sensor */
1719 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1721 memset(serial_number, 0, 30);
1722 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1723 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1725 if (udev->descriptor.bNumConfigurations > 1)
1726 PWC_WARNING("Warning: more than 1 configuration available.\n");
1728 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1729 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1731 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1734 pdev->type = type_id;
1735 pdev->vsize = default_size;
1736 pdev->vframes = default_fps;
1737 strcpy(pdev->serial, serial_number);
1738 pdev->features = features;
1739 if (vendor_id == 0x046D && product_id == 0x08B5)
1741 /* Logitech QuickCam Orbit
1742 The ranges have been determined experimentally; they may differ from cam to cam.
1743 Also, the exact ranges left-right and up-down are different for my cam
1745 pdev->angle_range.pan_min = -7000;
1746 pdev->angle_range.pan_max = 7000;
1747 pdev->angle_range.tilt_min = -3000;
1748 pdev->angle_range.tilt_max = 2500;
1751 mutex_init(&pdev->modlock);
1752 spin_lock_init(&pdev->ptrlock);
1755 init_waitqueue_head(&pdev->frameq);
1756 pdev->vcompression = pwc_preferred_compression;
1758 /* Allocate video_device structure */
1759 pdev->vdev = video_device_alloc();
1760 if (pdev->vdev == 0)
1762 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
1766 memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
1767 pdev->vdev->dev = &(udev->dev);
1768 strcpy(pdev->vdev->name, name);
1769 pdev->vdev->owner = THIS_MODULE;
1770 video_set_drvdata(pdev->vdev, pdev);
1772 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1773 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1775 /* Now search device_hint[] table for a match, so we can hint a node number. */
1776 for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1777 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1778 (device_hint[hint].pdev == NULL)) {
1779 /* so far, so good... try serial number */
1780 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1782 video_nr = device_hint[hint].device_node;
1783 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1789 pdev->vdev->release = video_device_release;
1790 i = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1792 PWC_ERROR("Failed to register as video device (%d).\n", i);
1797 PWC_INFO("Registered as /dev/video%d.\n", pdev->vdev->minor & 0x3F);
1801 if (hint < MAX_DEV_HINTS)
1802 device_hint[hint].pdev = pdev;
1804 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1805 usb_set_intfdata (intf, pdev);
1806 rc = pwc_create_sysfs_files(pdev->vdev);
1810 /* Set the leds off */
1811 pwc_set_leds(pdev, 0, 0);
1812 pwc_camera_power(pdev, 0);
1817 if (hint < MAX_DEV_HINTS)
1818 device_hint[hint].pdev = NULL;
1819 video_unregister_device(pdev->vdev);
1821 video_device_release(pdev->vdev); /* Drip... drip... drip... */
1822 kfree(pdev); /* Oops, no memory leaks please */
1826 /* The user janked out the cable... */
1827 static void usb_pwc_disconnect(struct usb_interface *intf)
1829 struct pwc_device *pdev;
1833 pdev = usb_get_intfdata (intf);
1834 usb_set_intfdata (intf, NULL);
1836 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1837 goto disconnect_out;
1839 if (pdev->udev == NULL) {
1840 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1841 goto disconnect_out;
1843 if (pdev->udev != interface_to_usbdev(intf)) {
1844 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1845 goto disconnect_out;
1848 /* We got unplugged; this is signalled by an EPIPE error code */
1850 PWC_INFO("Disconnected while webcam is in use!\n");
1851 pdev->error_status = EPIPE;
1854 /* Alert waiting processes */
1855 wake_up_interruptible(&pdev->frameq);
1856 /* Wait until device is closed */
1858 mutex_lock(&pdev->modlock);
1859 pdev->unplugged = 1;
1860 mutex_unlock(&pdev->modlock);
1863 /* Device is closed, so we can safely unregister it */
1864 PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
1866 /* Free memory (don't set pdev to 0 just yet) */
1870 /* search device_hint[] table if we occupy a slot, by any chance */
1871 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1872 if (device_hint[hint].pdev == pdev)
1873 device_hint[hint].pdev = NULL;
1879 /* *grunt* We have to do atoi ourselves :-( */
1880 static int pwc_atoi(const char *s)
1885 while (*s != '\0' && *s >= '0' && *s <= '9') {
1886 k = 10 * k + (*s - '0');
1894 * Initialization code & module stuff
1901 static int compression = -1;
1902 static int leds[2] = { -1, -1 };
1903 static int leds_nargs;
1904 static char *dev_hint[MAX_DEV_HINTS];
1905 static int dev_hint_nargs;
1907 module_param(size, charp, 0444);
1908 module_param(fps, int, 0444);
1909 module_param(fbufs, int, 0444);
1910 module_param(mbufs, int, 0444);
1911 #ifdef CONFIG_USB_PWC_DEBUG
1912 module_param_named(trace, pwc_trace, int, 0644);
1914 module_param(power_save, int, 0444);
1915 module_param(compression, int, 0444);
1916 module_param_array(leds, int, &leds_nargs, 0444);
1917 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1919 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1920 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1921 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1922 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1923 MODULE_PARM_DESC(trace, "For debugging purposes");
1924 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1925 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1926 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1927 MODULE_PARM_DESC(dev_hint, "Device node hints");
1929 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1930 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1931 MODULE_LICENSE("GPL");
1932 MODULE_ALIAS("pwcx");
1933 MODULE_VERSION( PWC_VERSION );
1935 static int __init usb_pwc_init(void)
1938 char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1940 PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1941 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1942 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1943 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1946 if (fps < 4 || fps > 30) {
1947 PWC_ERROR("Framerate out of bounds (4-30).\n");
1951 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1955 /* string; try matching with array */
1956 for (sz = 0; sz < PSZ_MAX; sz++) {
1957 if (!strcmp(sizenames[sz], size)) { /* Found! */
1962 if (sz == PSZ_MAX) {
1963 PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1966 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);
1969 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1970 PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
1974 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
1977 if (fbufs < 2 || fbufs > MAX_FRAMES) {
1978 PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
1981 default_fbufs = fbufs;
1982 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
1984 #ifdef CONFIG_USB_PWC_DEBUG
1985 if (pwc_trace >= 0) {
1986 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1989 if (compression >= 0) {
1990 if (compression > 3) {
1991 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1994 pwc_preferred_compression = compression;
1995 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
1998 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
2004 /* Big device node whoopla. Basically, it allows you to assign a
2005 device node (/dev/videoX) to a camera, based on its type
2006 & serial number. The format is [type[.serialnumber]:]node.
2008 Any camera that isn't matched by these rules gets the next
2009 available free device node.
2011 for (i = 0; i < MAX_DEV_HINTS; i++) {
2012 char *s, *colon, *dot;
2014 /* This loop also initializes the array */
2015 device_hint[i].pdev = NULL;
2017 if (s != NULL && *s != '\0') {
2018 device_hint[i].type = -1; /* wildcard */
2019 strcpy(device_hint[i].serial_number, "*");
2021 /* parse string: chop at ':' & '/' */
2023 while (*colon != '\0' && *colon != ':')
2025 while (*dot != '\0' && *dot != '.')
2027 /* Few sanity checks */
2028 if (*dot != '\0' && dot > colon) {
2029 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
2033 if (*colon == '\0') {
2036 PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
2040 /* No type or serial number specified, just a number. */
2041 device_hint[i].device_node = pwc_atoi(s);
2045 /* There's a colon, so we have at least a type and a device node */
2046 device_hint[i].type = pwc_atoi(s);
2047 device_hint[i].device_node = pwc_atoi(colon + 1);
2049 /* There's a serial number as well */
2054 while (*dot != ':' && k < 29) {
2055 device_hint[i].serial_number[k++] = *dot;
2058 device_hint[i].serial_number[k] = '\0';
2061 PWC_TRACE("device_hint[%d]:\n", i);
2062 PWC_TRACE(" type : %d\n", device_hint[i].type);
2063 PWC_TRACE(" serial# : %s\n", device_hint[i].serial_number);
2064 PWC_TRACE(" node : %d\n", device_hint[i].device_node);
2067 device_hint[i].type = 0; /* not filled */
2068 } /* ..for MAX_DEV_HINTS */
2070 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
2071 return usb_register(&pwc_driver);
2074 static void __exit usb_pwc_exit(void)
2076 PWC_DEBUG_MODULE("Deregistering driver.\n");
2077 usb_deregister(&pwc_driver);
2078 PWC_INFO("Philips webcam module removed.\n");
2081 module_init(usb_pwc_init);
2082 module_exit(usb_pwc_exit);
2084 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */