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
56 - Pham Thanh Nam: webcam snapshot button as an event input device
59 #include <linux/errno.h>
60 #include <linux/init.h>
62 #include <linux/module.h>
63 #include <linux/poll.h>
64 #include <linux/slab.h>
65 #include <linux/smp_lock.h>
66 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
67 #include <linux/usb/input.h>
69 #include <linux/vmalloc.h>
71 #include <linux/kernel.h> /* simple_strtol() */
74 #include "pwc-kiara.h"
75 #include "pwc-timon.h"
76 #include "pwc-dec23.h"
78 #include "pwc-uncompress.h"
80 /* Function prototypes and driver templates */
82 /* hotplug device table support */
83 static const struct usb_device_id pwc_device_table [] = {
84 { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */
85 { USB_DEVICE(0x0471, 0x0303) },
86 { USB_DEVICE(0x0471, 0x0304) },
87 { USB_DEVICE(0x0471, 0x0307) },
88 { USB_DEVICE(0x0471, 0x0308) },
89 { USB_DEVICE(0x0471, 0x030C) },
90 { USB_DEVICE(0x0471, 0x0310) },
91 { USB_DEVICE(0x0471, 0x0311) }, /* Philips ToUcam PRO II */
92 { USB_DEVICE(0x0471, 0x0312) },
93 { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
94 { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC PC Camera */
95 { USB_DEVICE(0x069A, 0x0001) }, /* Askey */
96 { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
97 { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
98 { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
99 { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
100 { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
101 { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
102 { USB_DEVICE(0x046D, 0x08B6) }, /* Cisco VT Camera */
103 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
104 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
105 { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
106 { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
107 { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
108 { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
109 { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
110 { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
111 { USB_DEVICE(0x06BE, 0x8116) }, /* new Afina Eye */
112 { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
113 { USB_DEVICE(0x0d81, 0x1900) },
116 MODULE_DEVICE_TABLE(usb, pwc_device_table);
118 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
119 static void usb_pwc_disconnect(struct usb_interface *intf);
121 static struct usb_driver pwc_driver = {
122 .name = "Philips webcam", /* name */
123 .id_table = pwc_device_table,
124 .probe = usb_pwc_probe, /* probe() */
125 .disconnect = usb_pwc_disconnect, /* disconnect() */
128 #define MAX_DEV_HINTS 20
129 #define MAX_ISOC_ERRORS 20
131 static int default_size = PSZ_QCIF;
132 static int default_fps = 10;
133 static int default_fbufs = 3; /* Default number of frame buffers */
134 int pwc_mbufs = 2; /* Default number of mmap() buffers */
135 #ifdef CONFIG_USB_PWC_DEBUG
136 int pwc_trace = PWC_DEBUG_LEVEL;
138 static int power_save;
139 static int led_on = 100, led_off; /* defaults to LED that is on while in use */
140 static int pwc_preferred_compression = 1; /* 0..3 = uncompressed..high */
143 char serial_number[30];
145 struct pwc_device *pdev;
146 } device_hint[MAX_DEV_HINTS];
150 static int pwc_video_open(struct file *file);
151 static int pwc_video_close(struct file *file);
152 static ssize_t pwc_video_read(struct file *file, char __user *buf,
153 size_t count, loff_t *ppos);
154 static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
155 static long pwc_video_ioctl(struct file *file,
156 unsigned int ioctlnr, unsigned long arg);
157 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
159 static const struct v4l2_file_operations pwc_fops = {
160 .owner = THIS_MODULE,
161 .open = pwc_video_open,
162 .release = pwc_video_close,
163 .read = pwc_video_read,
164 .poll = pwc_video_poll,
165 .mmap = pwc_video_mmap,
166 .ioctl = pwc_video_ioctl,
168 static struct video_device pwc_template = {
169 .name = "Philips Webcam", /* Filled in later */
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 void pwc_snapshot_button(struct pwc_device *pdev, int down)
598 PWC_TRACE("Snapshot button pressed.\n");
599 pdev->snapshot_button_status = 1;
601 PWC_TRACE("Snapshot button released.\n");
604 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
605 if (pdev->button_dev) {
606 input_report_key(pdev->button_dev, KEY_CAMERA, down);
607 input_sync(pdev->button_dev);
612 static int pwc_rcv_short_packet(struct pwc_device *pdev, const struct pwc_frame_buf *fbuf)
616 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
617 frames on the USB wire after an exposure change. This conditition is
618 however detected in the cam and a bit is set in the header.
620 if (pdev->type == 730) {
621 unsigned char *ptr = (unsigned char *)fbuf->data;
623 if (ptr[1] == 1 && ptr[0] & 0x10) {
624 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
625 pdev->drop_frames += 2;
626 pdev->vframes_error++;
628 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
629 pwc_snapshot_button(pdev, ptr[0] & 0x01);
631 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
633 PWC_TRACE("Image is mirrored.\n");
635 PWC_TRACE("Image is normal.\n");
637 pdev->vmirror = ptr[0] & 0x03;
638 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
639 after a short frame; this condition is filtered out specifically. A 4 byte
640 frame doesn't make sense anyway.
641 So we get either this sequence:
642 drop_bit set -> 4 byte frame -> short frame -> good frame
644 drop_bit set -> short frame -> good frame
645 So we drop either 3 or 2 frames in all!
647 if (fbuf->filled == 4)
650 else if (pdev->type == 740 || pdev->type == 720) {
651 unsigned char *ptr = (unsigned char *)fbuf->data;
652 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
653 pwc_snapshot_button(pdev, ptr[0] & 0x01);
655 pdev->vmirror = ptr[0] & 0x03;
658 /* In case we were instructed to drop the frame, do so silently.
659 The buffer pointers are not updated either (but the counters are reset below).
661 if (pdev->drop_frames > 0)
664 /* Check for underflow first */
665 if (fbuf->filled < pdev->frame_total_size) {
666 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
667 " discarded.\n", fbuf->filled);
668 pdev->vframes_error++;
671 /* Send only once per EOF */
672 awake = 1; /* delay wake_ups */
674 /* Find our next frame to fill. This will always succeed, since we
675 * nick a frame from either empty or full list, but if we had to
676 * take it from the full list, it means a frame got dropped.
678 if (pwc_next_fill_frame(pdev))
679 pwc_frame_dumped(pdev);
683 pdev->vframe_count++;
687 /* This gets called for the Isochronous pipe (video). This is done in
688 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
690 static void pwc_isoc_handler(struct urb *urb)
692 struct pwc_device *pdev;
695 struct pwc_frame_buf *fbuf;
696 unsigned char *fillptr = NULL, *iso_buf = NULL;
699 pdev = (struct pwc_device *)urb->context;
701 PWC_ERROR("isoc_handler() called with NULL device?!\n");
705 if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
706 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
709 if (urb->status != -EINPROGRESS && urb->status != 0) {
713 switch(urb->status) {
714 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
715 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
716 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
717 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
718 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
719 case -ETIME: errmsg = "Device does not respond"; break;
721 PWC_DEBUG_FLOW("pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
722 /* Give up after a number of contiguous errors on the USB bus.
723 Appearantly something is wrong so we simulate an unplug event.
725 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
727 PWC_INFO("Too many ISOC errors, bailing out.\n");
728 pdev->error_status = EIO;
730 wake_up_interruptible(&pdev->frameq);
732 goto handler_end; // ugly, but practical
735 fbuf = pdev->fill_frame;
737 PWC_ERROR("pwc_isoc_handler without valid fill frame.\n");
742 fillptr = fbuf->data + fbuf->filled;
745 /* Reset ISOC error counter. We did get here, after all. */
746 pdev->visoc_errors = 0;
748 /* vsync: 0 = don't copy data
753 for (i = 0; i < urb->number_of_packets; i++) {
754 fst = urb->iso_frame_desc[i].status;
755 flen = urb->iso_frame_desc[i].actual_length;
756 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
758 if (flen > 0) { /* if valid data... */
759 if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */
762 /* ...copy data to frame buffer, if possible */
763 if (flen + fbuf->filled > pdev->frame_total_size) {
764 PWC_DEBUG_FLOW("Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen, pdev->frame_total_size);
765 pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */
766 pdev->vframes_error++;
769 memmove(fillptr, iso_buf, flen);
773 fbuf->filled += flen;
776 if (flen < pdev->vlast_packet_size) {
777 /* Shorter packet... We probably have the end of an image-frame;
778 wake up read() process and let select()/poll() do something.
779 Decompression is done in user time over there.
781 if (pdev->vsync == 2) {
782 if (pwc_rcv_short_packet(pdev, fbuf)) {
784 fbuf = pdev->fill_frame;
788 fillptr = fbuf->data;
792 pdev->vlast_packet_size = flen;
793 } /* ..status == 0 */
795 /* This is normally not interesting to the user, unless
796 * you are really debugging something, default = 0 */
797 static int iso_error;
800 PWC_DEBUG_FLOW("Iso frame %d of USB has error %d\n", i, fst);
806 wake_up_interruptible(&pdev->frameq);
808 urb->dev = pdev->udev;
809 i = usb_submit_urb(urb, GFP_ATOMIC);
811 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
815 int pwc_isoc_init(struct pwc_device *pdev)
817 struct usb_device *udev;
821 struct usb_interface *intf;
822 struct usb_host_interface *idesc = NULL;
831 /* Get the current alternate interface, adjust packet size */
832 if (!udev->actconfig)
834 intf = usb_ifnum_to_if(udev, 0);
836 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
841 /* Search video endpoint */
842 pdev->vmax_packet_size = -1;
843 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
844 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
845 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
850 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
851 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
852 return -ENFILE; /* Odd error, that should be noticeable */
855 /* Set alternate interface */
857 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
858 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
862 for (i = 0; i < MAX_ISO_BUFS; i++) {
863 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
865 PWC_ERROR("Failed to allocate urb %d\n", i);
869 pdev->sbuf[i].urb = urb;
870 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
873 /* De-allocate in reverse order */
875 usb_free_urb(pdev->sbuf[i].urb);
876 pdev->sbuf[i].urb = NULL;
881 /* init URB structure */
882 for (i = 0; i < MAX_ISO_BUFS; i++) {
883 urb = pdev->sbuf[i].urb;
885 urb->interval = 1; // devik
887 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
888 urb->transfer_flags = URB_ISO_ASAP;
889 urb->transfer_buffer = pdev->sbuf[i].data;
890 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
891 urb->complete = pwc_isoc_handler;
893 urb->start_frame = 0;
894 urb->number_of_packets = ISO_FRAMES_PER_DESC;
895 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
896 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
897 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
902 for (i = 0; i < MAX_ISO_BUFS; i++) {
903 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL);
905 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
907 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->sbuf[i].urb);
912 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
916 static void pwc_iso_stop(struct pwc_device *pdev)
920 /* Unlinking ISOC buffers one by one */
921 for (i = 0; i < MAX_ISO_BUFS; i++) {
924 urb = pdev->sbuf[i].urb;
926 PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb);
932 static void pwc_iso_free(struct pwc_device *pdev)
936 /* Freeing ISOC buffers one by one */
937 for (i = 0; i < MAX_ISO_BUFS; i++) {
940 urb = pdev->sbuf[i].urb;
942 PWC_DEBUG_MEMORY("Freeing URB\n");
944 pdev->sbuf[i].urb = NULL;
949 void pwc_isoc_cleanup(struct pwc_device *pdev)
951 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
954 if (pdev->iso_init == 0)
960 /* Stop camera, but only if we are sure the camera is still there (unplug
961 is signalled by EPIPE)
963 if (pdev->error_status && pdev->error_status != EPIPE) {
964 PWC_DEBUG_OPEN("Setting alternate interface 0.\n");
965 usb_set_interface(pdev->udev, 0, 0);
969 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
972 int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot)
976 /* Stop isoc stuff */
977 pwc_isoc_cleanup(pdev);
978 /* Reset parameters */
979 pwc_reset_buffers(pdev);
980 /* Try to set video mode... */
981 start = ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot);
983 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 1 failed.\n");
984 /* That failed... restore old mode (we know that worked) */
985 start = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
987 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 2 failed.\n");
992 if (pwc_isoc_init(pdev) < 0)
994 PWC_WARNING("Failed to restart ISOC transfers in pwc_try_video_mode.\n");
995 ret = -EAGAIN; /* let's try again, who knows if it works a second time */
998 pdev->drop_frames++; /* try to avoid garbage during switch */
999 return ret; /* Return original error code */
1005 static struct pwc_device *cd_to_pwc(struct device *cd)
1007 struct video_device *vdev = to_video_device(cd);
1008 return video_get_drvdata(vdev);
1011 static ssize_t show_pan_tilt(struct device *class_dev,
1012 struct device_attribute *attr, char *buf)
1014 struct pwc_device *pdev = cd_to_pwc(class_dev);
1015 return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
1018 static ssize_t store_pan_tilt(struct device *class_dev,
1019 struct device_attribute *attr,
1020 const char *buf, size_t count)
1022 struct pwc_device *pdev = cd_to_pwc(class_dev);
1026 if (strncmp(buf, "reset", 5) == 0)
1027 ret = pwc_mpt_reset(pdev, 0x3);
1029 else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
1030 ret = pwc_mpt_set_angle(pdev, pan, tilt);
1036 static DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
1039 static ssize_t show_snapshot_button_status(struct device *class_dev,
1040 struct device_attribute *attr, char *buf)
1042 struct pwc_device *pdev = cd_to_pwc(class_dev);
1043 int status = pdev->snapshot_button_status;
1044 pdev->snapshot_button_status = 0;
1045 return sprintf(buf, "%d\n", status);
1048 static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
1051 static int pwc_create_sysfs_files(struct video_device *vdev)
1053 struct pwc_device *pdev = video_get_drvdata(vdev);
1056 rc = device_create_file(&vdev->dev, &dev_attr_button);
1059 if (pdev->features & FEATURE_MOTOR_PANTILT) {
1060 rc = device_create_file(&vdev->dev, &dev_attr_pan_tilt);
1068 device_remove_file(&vdev->dev, &dev_attr_button);
1070 PWC_ERROR("Could not create sysfs files.\n");
1074 static void pwc_remove_sysfs_files(struct video_device *vdev)
1076 struct pwc_device *pdev = video_get_drvdata(vdev);
1078 if (pdev->features & FEATURE_MOTOR_PANTILT)
1079 device_remove_file(&vdev->dev, &dev_attr_pan_tilt);
1080 device_remove_file(&vdev->dev, &dev_attr_button);
1083 #ifdef CONFIG_USB_PWC_DEBUG
1084 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
1086 switch(sensor_type) {
1088 return "Hyundai CMOS sensor";
1090 return "Sony CCD sensor + TDA8787";
1092 return "Sony CCD sensor + Exas 98L59";
1094 return "Sony CCD sensor + ADI 9804";
1096 return "Sharp CCD sensor + TDA8787";
1098 return "Sharp CCD sensor + Exas 98L59";
1100 return "Sharp CCD sensor + ADI 9804";
1102 return "UPA 1021 sensor";
1104 return "VGA sensor";
1106 return "PAL MR sensor";
1108 return "unknown type of sensor";
1113 /***************************************************************************/
1114 /* Video4Linux functions */
1116 static int pwc_video_open(struct file *file)
1119 struct video_device *vdev = video_devdata(file);
1120 struct pwc_device *pdev;
1122 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
1124 pdev = video_get_drvdata(vdev);
1127 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1131 mutex_lock(&pdev->modlock);
1132 pwc_construct(pdev); /* set min/max sizes correct */
1133 if (!pdev->usb_init) {
1134 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1137 /* Query sensor type */
1138 ret = pwc_get_cmos_sensor(pdev, &i);
1141 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1143 pwc_sensor_type_to_string(i), i);
1147 /* Turn on camera */
1149 i = pwc_camera_power(pdev, 1);
1151 PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
1153 /* Set LED on/off time */
1154 if (pwc_set_leds(pdev, led_on, led_off) < 0)
1155 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1158 /* So far, so good. Allocate memory. */
1159 i = pwc_allocate_buffers(pdev);
1161 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1162 pwc_free_buffers(pdev);
1163 mutex_unlock(&pdev->modlock);
1167 /* Reset buffers & parameters */
1168 pwc_reset_buffers(pdev);
1169 for (i = 0; i < pwc_mbufs; i++)
1170 pdev->image_used[i] = 0;
1171 pdev->vframe_count = 0;
1172 pdev->vframes_dumped = 0;
1173 pdev->vframes_error = 0;
1174 pdev->visoc_errors = 0;
1175 pdev->error_status = 0;
1176 pwc_construct(pdev); /* set min/max sizes correct */
1178 /* Set some defaults */
1179 pdev->vsnapshot = 0;
1181 /* Start iso pipe for video; first try the last used video size
1182 (or the default one); if that fails try QCIF/10 or QSIF/10;
1183 it that fails too, give up.
1185 i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1187 unsigned int default_resolution;
1188 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1189 if (pdev->type>= 730)
1190 default_resolution = PSZ_QSIF;
1192 default_resolution = PSZ_QCIF;
1194 i = pwc_set_video_mode(pdev,
1195 pwc_image_sizes[default_resolution].x,
1196 pwc_image_sizes[default_resolution].y,
1202 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1203 pwc_free_buffers(pdev);
1204 mutex_unlock(&pdev->modlock);
1208 i = pwc_isoc_init(pdev);
1210 PWC_DEBUG_OPEN("Failed to init ISOC stuff = %d.\n", i);
1211 pwc_isoc_cleanup(pdev);
1212 pwc_free_buffers(pdev);
1213 mutex_unlock(&pdev->modlock);
1217 /* Initialize the webcam to sane value */
1218 pwc_set_brightness(pdev, 0x7fff);
1219 pwc_set_agc(pdev, 1, 0);
1222 file->private_data = vdev;
1223 mutex_unlock(&pdev->modlock);
1224 PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1229 static void pwc_cleanup(struct pwc_device *pdev)
1231 pwc_remove_sysfs_files(pdev->vdev);
1232 video_unregister_device(pdev->vdev);
1234 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1235 if (pdev->button_dev)
1236 input_unregister_device(pdev->button_dev);
1242 /* Note that all cleanup is done in the reverse order as in _open */
1243 static int pwc_video_close(struct file *file)
1245 struct video_device *vdev = file->private_data;
1246 struct pwc_device *pdev;
1249 PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
1252 pdev = video_get_drvdata(vdev);
1253 if (pdev->vopen == 0)
1254 PWC_DEBUG_MODULE("video_close() called on closed device?\n");
1256 /* Dump statistics, but only if a reasonable amount of frames were
1257 processed (to prevent endless log-entries in case of snap-shot
1260 if (pdev->vframe_count > 20)
1261 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);
1263 if (DEVICE_USE_CODEC1(pdev->type))
1268 pwc_isoc_cleanup(pdev);
1269 pwc_free_buffers(pdev);
1271 /* Turn off LEDS and power down camera, but only when not unplugged */
1272 if (!pdev->unplugged) {
1274 if (pwc_set_leds(pdev, 0, 0) < 0)
1275 PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
1277 i = pwc_camera_power(pdev, 0);
1279 PWC_ERROR("Failed to power down camera (%d)\n", i);
1282 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
1285 /* search device_hint[] table if we occupy a slot, by any chance */
1286 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1287 if (device_hint[hint].pdev == pdev)
1288 device_hint[hint].pdev = NULL;
1296 * FIXME: what about two parallel reads ????
1297 * ANSWER: Not supported. You can't open the device more than once,
1298 despite what the V4L1 interface says. First, I don't see
1299 the need, second there's no mechanism of alerting the
1300 2nd/3rd/... process of events like changing image size.
1301 And I don't see the point of blocking that for the
1302 2nd/3rd/... process.
1303 In multi-threaded environments reading parallel from any
1304 device is tricky anyhow.
1307 static ssize_t pwc_video_read(struct file *file, char __user *buf,
1308 size_t count, loff_t *ppos)
1310 struct video_device *vdev = file->private_data;
1311 struct pwc_device *pdev;
1312 int noblock = file->f_flags & O_NONBLOCK;
1313 DECLARE_WAITQUEUE(wait, current);
1314 int bytes_to_read, rv = 0;
1315 void *image_buffer_addr;
1317 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1321 pdev = video_get_drvdata(vdev);
1325 mutex_lock(&pdev->modlock);
1326 if (pdev->error_status) {
1327 rv = -pdev->error_status; /* Something happened, report what. */
1331 /* In case we're doing partial reads, we don't have to wait for a frame */
1332 if (pdev->image_read_pos == 0) {
1333 /* Do wait queueing according to the (doc)book */
1334 add_wait_queue(&pdev->frameq, &wait);
1335 while (pdev->full_frames == NULL) {
1336 /* Check for unplugged/etc. here */
1337 if (pdev->error_status) {
1338 remove_wait_queue(&pdev->frameq, &wait);
1339 set_current_state(TASK_RUNNING);
1340 rv = -pdev->error_status ;
1344 remove_wait_queue(&pdev->frameq, &wait);
1345 set_current_state(TASK_RUNNING);
1349 if (signal_pending(current)) {
1350 remove_wait_queue(&pdev->frameq, &wait);
1351 set_current_state(TASK_RUNNING);
1356 set_current_state(TASK_INTERRUPTIBLE);
1358 remove_wait_queue(&pdev->frameq, &wait);
1359 set_current_state(TASK_RUNNING);
1361 /* Decompress and release frame */
1362 if (pwc_handle_frame(pdev)) {
1368 PWC_DEBUG_READ("Copying data to user space.\n");
1369 if (pdev->vpalette == VIDEO_PALETTE_RAW)
1370 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1372 bytes_to_read = pdev->view.size;
1374 /* copy bytes to user space; we allow for partial reads */
1375 if (count + pdev->image_read_pos > bytes_to_read)
1376 count = bytes_to_read - pdev->image_read_pos;
1377 image_buffer_addr = pdev->image_data;
1378 image_buffer_addr += pdev->images[pdev->fill_image].offset;
1379 image_buffer_addr += pdev->image_read_pos;
1380 if (copy_to_user(buf, image_buffer_addr, count)) {
1384 pdev->image_read_pos += count;
1385 if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
1386 pdev->image_read_pos = 0;
1387 pwc_next_image(pdev);
1389 mutex_unlock(&pdev->modlock);
1392 mutex_unlock(&pdev->modlock);
1396 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1398 struct video_device *vdev = file->private_data;
1399 struct pwc_device *pdev;
1403 pdev = video_get_drvdata(vdev);
1407 poll_wait(file, &pdev->frameq, wait);
1408 if (pdev->error_status)
1410 if (pdev->full_frames != NULL) /* we have frames waiting */
1411 return (POLLIN | POLLRDNORM);
1416 static long pwc_video_ioctl(struct file *file,
1417 unsigned int cmd, unsigned long arg)
1419 struct video_device *vdev = file->private_data;
1420 struct pwc_device *pdev;
1425 pdev = video_get_drvdata(vdev);
1427 mutex_lock(&pdev->modlock);
1428 if (!pdev->unplugged)
1429 r = video_usercopy(file, cmd, arg, pwc_video_do_ioctl);
1430 mutex_unlock(&pdev->modlock);
1435 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1437 struct video_device *vdev = file->private_data;
1438 struct pwc_device *pdev;
1439 unsigned long start;
1441 unsigned long page, pos = 0;
1444 PWC_DEBUG_MEMORY(">> %s\n", __func__);
1445 pdev = video_get_drvdata(vdev);
1446 size = vma->vm_end - vma->vm_start;
1447 start = vma->vm_start;
1449 /* Find the idx buffer for this mapping */
1450 for (index = 0; index < pwc_mbufs; index++) {
1451 pos = pdev->images[index].offset;
1452 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1455 if (index == MAX_IMAGES)
1459 * Special case for v4l1. In v4l1, we map only one big buffer,
1460 * but in v4l2 each buffer is mapped
1462 unsigned long total_size;
1463 total_size = pwc_mbufs * pdev->len_per_image;
1464 if (size != pdev->len_per_image && size != total_size) {
1465 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1466 size, pdev->len_per_image, total_size);
1469 } else if (size > pdev->len_per_image)
1472 vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
1474 pos += (unsigned long)pdev->image_data;
1476 page = vmalloc_to_pfn((void *)pos);
1477 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1481 if (size > PAGE_SIZE)
1489 /***************************************************************************/
1492 /* This function gets called when a new device is plugged in or the usb core
1496 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1498 struct usb_device *udev = interface_to_usbdev(intf);
1499 struct pwc_device *pdev = NULL;
1500 int vendor_id, product_id, type_id;
1503 int video_nr = -1; /* default: use next available device */
1504 char serial_number[30], *name;
1506 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1507 product_id = le16_to_cpu(udev->descriptor.idProduct);
1509 /* Check if we can handle this device */
1510 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1511 vendor_id, product_id,
1512 intf->altsetting->desc.bInterfaceNumber);
1514 /* the interfaces are probed one by one. We are only interested in the
1515 video interface (0) now.
1516 Interface 1 is the Audio Control, and interface 2 Audio itself.
1518 if (intf->altsetting->desc.bInterfaceNumber > 0)
1521 if (vendor_id == 0x0471) {
1522 switch (product_id) {
1524 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1525 name = "Philips 645 webcam";
1529 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1530 name = "Philips 646 webcam";
1534 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1535 name = "Askey VC010 webcam";
1539 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1540 name = "Philips 675 webcam";
1544 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1545 name = "Philips 680 webcam";
1549 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1550 name = "Philips 690 webcam";
1554 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1555 name = "Philips 730 webcam";
1559 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1560 name = "Philips 740 webcam";
1564 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1565 name = "Philips 750 webcam";
1569 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1570 name = "Philips 720K/40 webcam";
1574 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1575 name = "Philips SPC 900NC webcam";
1583 else if (vendor_id == 0x069A) {
1584 switch(product_id) {
1586 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1587 name = "Askey VC010 webcam";
1595 else if (vendor_id == 0x046d) {
1596 switch(product_id) {
1598 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1599 name = "Logitech QuickCam Pro 3000";
1600 type_id = 740; /* CCD sensor */
1603 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1604 name = "Logitech QuickCam Notebook Pro";
1605 type_id = 740; /* CCD sensor */
1608 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1609 name = "Logitech QuickCam Pro 4000";
1610 type_id = 740; /* CCD sensor */
1613 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1614 name = "Logitech QuickCam Zoom";
1615 type_id = 740; /* CCD sensor */
1618 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1619 name = "Logitech QuickCam Zoom";
1620 type_id = 740; /* CCD sensor */
1624 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1625 name = "Logitech QuickCam Orbit";
1626 type_id = 740; /* CCD sensor */
1627 features |= FEATURE_MOTOR_PANTILT;
1630 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1631 name = "Cisco VT Camera";
1632 type_id = 740; /* CCD sensor */
1635 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1636 name = "Logitech ViewPort AV 100";
1637 type_id = 740; /* CCD sensor */
1639 case 0x08b8: /* Where this released? */
1640 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1641 name = "Logitech QuickCam (res.)";
1642 type_id = 730; /* Assuming CMOS */
1649 else if (vendor_id == 0x055d) {
1650 /* I don't know the difference between the C10 and the C30;
1651 I suppose the difference is the sensor, but both cameras
1652 work equally well with a type_id of 675
1654 switch(product_id) {
1656 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1657 name = "Samsung MPC-C10";
1661 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1662 name = "Samsung MPC-C30";
1666 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1667 name = "Samsung MPC-C30";
1675 else if (vendor_id == 0x041e) {
1676 switch(product_id) {
1678 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1679 name = "Creative Labs Webcam 5";
1683 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1684 name = "Creative Labs Webcam Pro Ex";
1692 else if (vendor_id == 0x04cc) {
1693 switch(product_id) {
1695 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1696 name = "Sotec Afina Eye";
1704 else if (vendor_id == 0x06be) {
1705 switch(product_id) {
1707 /* This is essentially the same cam as the Sotec Afina Eye */
1708 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1709 name = "AME Co. Afina Eye";
1718 else if (vendor_id == 0x0d81) {
1719 switch(product_id) {
1721 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1722 name = "Visionite VCS-UC300";
1723 type_id = 740; /* CCD sensor */
1726 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1727 name = "Visionite VCS-UM100";
1728 type_id = 730; /* CMOS sensor */
1736 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1738 memset(serial_number, 0, 30);
1739 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1740 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1742 if (udev->descriptor.bNumConfigurations > 1)
1743 PWC_WARNING("Warning: more than 1 configuration available.\n");
1745 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1746 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1748 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1751 pdev->type = type_id;
1752 pdev->vsize = default_size;
1753 pdev->vframes = default_fps;
1754 strcpy(pdev->serial, serial_number);
1755 pdev->features = features;
1756 if (vendor_id == 0x046D && product_id == 0x08B5) {
1757 /* Logitech QuickCam Orbit
1758 The ranges have been determined experimentally; they may differ from cam to cam.
1759 Also, the exact ranges left-right and up-down are different for my cam
1761 pdev->angle_range.pan_min = -7000;
1762 pdev->angle_range.pan_max = 7000;
1763 pdev->angle_range.tilt_min = -3000;
1764 pdev->angle_range.tilt_max = 2500;
1767 mutex_init(&pdev->modlock);
1768 spin_lock_init(&pdev->ptrlock);
1771 init_waitqueue_head(&pdev->frameq);
1772 pdev->vcompression = pwc_preferred_compression;
1774 /* Allocate video_device structure */
1775 pdev->vdev = video_device_alloc();
1777 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
1781 memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
1782 pdev->vdev->parent = &intf->dev;
1783 strcpy(pdev->vdev->name, name);
1784 video_set_drvdata(pdev->vdev, pdev);
1786 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1787 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1789 /* Now search device_hint[] table for a match, so we can hint a node number. */
1790 for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1791 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1792 (device_hint[hint].pdev == NULL)) {
1793 /* so far, so good... try serial number */
1794 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1796 video_nr = device_hint[hint].device_node;
1797 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1803 pdev->vdev->release = video_device_release;
1804 rc = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1806 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1807 goto err_video_release;
1810 PWC_INFO("Registered as /dev/video%d.\n", pdev->vdev->num);
1813 if (hint < MAX_DEV_HINTS)
1814 device_hint[hint].pdev = pdev;
1816 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1817 usb_set_intfdata(intf, pdev);
1818 rc = pwc_create_sysfs_files(pdev->vdev);
1820 goto err_video_unreg;
1822 /* Set the leds off */
1823 pwc_set_leds(pdev, 0, 0);
1824 pwc_camera_power(pdev, 0);
1826 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1827 /* register webcam snapshot button input device */
1828 pdev->button_dev = input_allocate_device();
1829 if (!pdev->button_dev) {
1830 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1832 pwc_remove_sysfs_files(pdev->vdev);
1833 goto err_video_unreg;
1836 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1837 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1839 pdev->button_dev->name = "PWC snapshot button";
1840 pdev->button_dev->phys = pdev->button_phys;
1841 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1842 pdev->button_dev->dev.parent = &pdev->udev->dev;
1843 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1844 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1846 rc = input_register_device(pdev->button_dev);
1848 input_free_device(pdev->button_dev);
1849 pdev->button_dev = NULL;
1850 pwc_remove_sysfs_files(pdev->vdev);
1851 goto err_video_unreg;
1858 if (hint < MAX_DEV_HINTS)
1859 device_hint[hint].pdev = NULL;
1860 video_unregister_device(pdev->vdev);
1861 pdev->vdev = NULL; /* So we don't try to release it below */
1863 video_device_release(pdev->vdev);
1869 /* The user yanked out the cable... */
1870 static void usb_pwc_disconnect(struct usb_interface *intf)
1872 struct pwc_device *pdev;
1876 pdev = usb_get_intfdata (intf);
1877 usb_set_intfdata (intf, NULL);
1879 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1880 goto disconnect_out;
1882 if (pdev->udev == NULL) {
1883 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1884 goto disconnect_out;
1886 if (pdev->udev != interface_to_usbdev(intf)) {
1887 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1888 goto disconnect_out;
1891 /* We got unplugged; this is signalled by an EPIPE error code */
1893 PWC_INFO("Disconnected while webcam is in use!\n");
1894 pdev->error_status = EPIPE;
1897 /* Alert waiting processes */
1898 wake_up_interruptible(&pdev->frameq);
1899 /* Wait until device is closed */
1901 mutex_lock(&pdev->modlock);
1902 pdev->unplugged = 1;
1903 mutex_unlock(&pdev->modlock);
1906 /* Device is closed, so we can safely unregister it */
1907 PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
1911 /* search device_hint[] table if we occupy a slot, by any chance */
1912 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1913 if (device_hint[hint].pdev == pdev)
1914 device_hint[hint].pdev = NULL;
1922 * Initialization code & module stuff
1929 static int compression = -1;
1930 static int leds[2] = { -1, -1 };
1931 static unsigned int leds_nargs;
1932 static char *dev_hint[MAX_DEV_HINTS];
1933 static unsigned int dev_hint_nargs;
1935 module_param(size, charp, 0444);
1936 module_param(fps, int, 0444);
1937 module_param(fbufs, int, 0444);
1938 module_param(mbufs, int, 0444);
1939 #ifdef CONFIG_USB_PWC_DEBUG
1940 module_param_named(trace, pwc_trace, int, 0644);
1942 module_param(power_save, int, 0444);
1943 module_param(compression, int, 0444);
1944 module_param_array(leds, int, &leds_nargs, 0444);
1945 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1947 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1948 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1949 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1950 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1951 MODULE_PARM_DESC(trace, "For debugging purposes");
1952 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1953 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1954 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1955 MODULE_PARM_DESC(dev_hint, "Device node hints");
1957 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1958 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1959 MODULE_LICENSE("GPL");
1960 MODULE_ALIAS("pwcx");
1961 MODULE_VERSION( PWC_VERSION );
1963 static int __init usb_pwc_init(void)
1966 char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1968 PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1969 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1970 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1971 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1974 if (fps < 4 || fps > 30) {
1975 PWC_ERROR("Framerate out of bounds (4-30).\n");
1979 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1983 /* string; try matching with array */
1984 for (sz = 0; sz < PSZ_MAX; sz++) {
1985 if (!strcmp(sizenames[sz], size)) { /* Found! */
1990 if (sz == PSZ_MAX) {
1991 PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1994 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);
1997 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1998 PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
2002 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
2005 if (fbufs < 2 || fbufs > MAX_FRAMES) {
2006 PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
2009 default_fbufs = fbufs;
2010 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
2012 #ifdef CONFIG_USB_PWC_DEBUG
2013 if (pwc_trace >= 0) {
2014 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
2017 if (compression >= 0) {
2018 if (compression > 3) {
2019 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
2022 pwc_preferred_compression = compression;
2023 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
2026 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
2032 /* Big device node whoopla. Basically, it allows you to assign a
2033 device node (/dev/videoX) to a camera, based on its type
2034 & serial number. The format is [type[.serialnumber]:]node.
2036 Any camera that isn't matched by these rules gets the next
2037 available free device node.
2039 for (i = 0; i < MAX_DEV_HINTS; i++) {
2040 char *s, *colon, *dot;
2042 /* This loop also initializes the array */
2043 device_hint[i].pdev = NULL;
2045 if (s != NULL && *s != '\0') {
2046 device_hint[i].type = -1; /* wildcard */
2047 strcpy(device_hint[i].serial_number, "*");
2049 /* parse string: chop at ':' & '/' */
2051 while (*colon != '\0' && *colon != ':')
2053 while (*dot != '\0' && *dot != '.')
2055 /* Few sanity checks */
2056 if (*dot != '\0' && dot > colon) {
2057 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
2061 if (*colon == '\0') {
2064 PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
2068 /* No type or serial number specified, just a number. */
2069 device_hint[i].device_node =
2070 simple_strtol(s, NULL, 10);
2074 /* There's a colon, so we have at least a type and a device node */
2075 device_hint[i].type =
2076 simple_strtol(s, NULL, 10);
2077 device_hint[i].device_node =
2078 simple_strtol(colon + 1, NULL, 10);
2080 /* There's a serial number as well */
2085 while (*dot != ':' && k < 29) {
2086 device_hint[i].serial_number[k++] = *dot;
2089 device_hint[i].serial_number[k] = '\0';
2092 PWC_TRACE("device_hint[%d]:\n", i);
2093 PWC_TRACE(" type : %d\n", device_hint[i].type);
2094 PWC_TRACE(" serial# : %s\n", device_hint[i].serial_number);
2095 PWC_TRACE(" node : %d\n", device_hint[i].device_node);
2098 device_hint[i].type = 0; /* not filled */
2099 } /* ..for MAX_DEV_HINTS */
2101 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
2102 return usb_register(&pwc_driver);
2105 static void __exit usb_pwc_exit(void)
2107 PWC_DEBUG_MODULE("Deregistering driver.\n");
2108 usb_deregister(&pwc_driver);
2109 PWC_INFO("Philips webcam module removed.\n");
2112 module_init(usb_pwc_init);
2113 module_exit(usb_pwc_exit);
2115 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */