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 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
66 #include <linux/usb/input.h>
68 #include <linux/vmalloc.h>
70 #include <linux/kernel.h> /* simple_strtol() */
73 #include "pwc-kiara.h"
74 #include "pwc-timon.h"
75 #include "pwc-dec23.h"
77 #include "pwc-uncompress.h"
79 /* Function prototypes and driver templates */
81 /* hotplug device table support */
82 static const struct usb_device_id pwc_device_table [] = {
83 { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */
84 { USB_DEVICE(0x0471, 0x0303) },
85 { USB_DEVICE(0x0471, 0x0304) },
86 { USB_DEVICE(0x0471, 0x0307) },
87 { USB_DEVICE(0x0471, 0x0308) },
88 { USB_DEVICE(0x0471, 0x030C) },
89 { USB_DEVICE(0x0471, 0x0310) },
90 { USB_DEVICE(0x0471, 0x0311) }, /* Philips ToUcam PRO II */
91 { USB_DEVICE(0x0471, 0x0312) },
92 { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
93 { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC PC Camera */
94 { USB_DEVICE(0x069A, 0x0001) }, /* Askey */
95 { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
96 { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
97 { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
98 { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
99 { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
100 { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
101 { USB_DEVICE(0x046D, 0x08B6) }, /* Cisco VT Camera */
102 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
103 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
104 { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
105 { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
106 { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
107 { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
108 { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
109 { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
110 { USB_DEVICE(0x06BE, 0x8116) }, /* new Afina Eye */
111 { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
112 { USB_DEVICE(0x0d81, 0x1900) },
115 MODULE_DEVICE_TABLE(usb, pwc_device_table);
117 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
118 static void usb_pwc_disconnect(struct usb_interface *intf);
120 static struct usb_driver pwc_driver = {
121 .name = "Philips webcam", /* name */
122 .id_table = pwc_device_table,
123 .probe = usb_pwc_probe, /* probe() */
124 .disconnect = usb_pwc_disconnect, /* disconnect() */
127 #define MAX_DEV_HINTS 20
128 #define MAX_ISOC_ERRORS 20
130 static int default_size = PSZ_QCIF;
131 static int default_fps = 10;
132 static int default_fbufs = 3; /* Default number of frame buffers */
133 int pwc_mbufs = 2; /* Default number of mmap() buffers */
134 #ifdef CONFIG_USB_PWC_DEBUG
135 int pwc_trace = PWC_DEBUG_LEVEL;
137 static int power_save;
138 static int led_on = 100, led_off; /* defaults to LED that is on while in use */
139 static int pwc_preferred_compression = 1; /* 0..3 = uncompressed..high */
142 char serial_number[30];
144 struct pwc_device *pdev;
145 } device_hint[MAX_DEV_HINTS];
149 static int pwc_video_open(struct file *file);
150 static int pwc_video_close(struct file *file);
151 static ssize_t pwc_video_read(struct file *file, char __user *buf,
152 size_t count, loff_t *ppos);
153 static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
154 static long pwc_video_ioctl(struct file *file,
155 unsigned int ioctlnr, unsigned long arg);
156 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
158 static const struct v4l2_file_operations pwc_fops = {
159 .owner = THIS_MODULE,
160 .open = pwc_video_open,
161 .release = pwc_video_close,
162 .read = pwc_video_read,
163 .poll = pwc_video_poll,
164 .mmap = pwc_video_mmap,
165 .unlocked_ioctl = pwc_video_ioctl,
167 static struct video_device pwc_template = {
168 .name = "Philips Webcam", /* Filled in later */
169 .release = video_device_release,
173 /***************************************************************************/
175 /* Okay, this is some magic that I worked out and the reasoning behind it...
177 The biggest problem with any USB device is of course: "what to do
178 when the user unplugs the device while it is in use by an application?"
179 We have several options:
180 1) Curse them with the 7 plagues when they do (requires divine intervention)
181 2) Tell them not to (won't work: they'll do it anyway)
182 3) Oops the kernel (this will have a negative effect on a user's uptime)
183 4) Do something sensible.
185 Of course, we go for option 4.
187 It happens that this device will be linked to two times, once from
188 usb_device and once from the video_device in their respective 'private'
189 pointers. This is done when the device is probed() and all initialization
190 succeeded. The pwc_device struct links back to both structures.
192 When a device is unplugged while in use it will be removed from the
193 list of known USB devices; I also de-register it as a V4L device, but
194 unfortunately I can't free the memory since the struct is still in use
195 by the file descriptor. This free-ing is then deferend until the first
196 opportunity. Crude, but it works.
198 A small 'advantage' is that if a user unplugs the cam and plugs it back
199 in, it should get assigned the same video device minor, but unfortunately
200 it's non-trivial to re-link the cam back to the video device... (that
201 would surely be magic! :))
204 /***************************************************************************/
205 /* Private functions */
207 /* Here we want the physical address of the memory.
208 * This is used when initializing the contents of the area.
213 static void *pwc_rvmalloc(unsigned long size)
218 mem=vmalloc_32(size);
222 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
223 adr=(unsigned long) mem;
226 SetPageReserved(vmalloc_to_page((void *)adr));
233 static void pwc_rvfree(void * mem, unsigned long size)
240 adr=(unsigned long) mem;
241 while ((long) size > 0)
243 ClearPageReserved(vmalloc_to_page((void *)adr));
253 static int pwc_allocate_buffers(struct pwc_device *pdev)
258 PWC_DEBUG_MEMORY(">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev);
263 /* Allocate Isochronuous pipe buffers */
264 for (i = 0; i < MAX_ISO_BUFS; i++) {
265 if (pdev->sbuf[i].data == NULL) {
266 kbuf = kzalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
268 PWC_ERROR("Failed to allocate iso buffer %d.\n", i);
271 PWC_DEBUG_MEMORY("Allocated iso buffer at %p.\n", kbuf);
272 pdev->sbuf[i].data = kbuf;
276 /* Allocate frame buffer structure */
277 if (pdev->fbuf == NULL) {
278 kbuf = kzalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);
280 PWC_ERROR("Failed to allocate frame buffer structure.\n");
283 PWC_DEBUG_MEMORY("Allocated frame buffer structure at %p.\n", kbuf);
287 /* create frame buffers, and make circular ring */
288 for (i = 0; i < default_fbufs; i++) {
289 if (pdev->fbuf[i].data == NULL) {
290 kbuf = vmalloc(PWC_FRAME_SIZE); /* need vmalloc since frame buffer > 128K */
292 PWC_ERROR("Failed to allocate frame buffer %d.\n", i);
295 PWC_DEBUG_MEMORY("Allocated frame buffer %d at %p.\n", i, kbuf);
296 pdev->fbuf[i].data = kbuf;
297 memset(kbuf, 0, PWC_FRAME_SIZE);
301 /* Allocate decompressor table space */
302 if (DEVICE_USE_CODEC1(pdev->type))
303 err = pwc_dec1_alloc(pdev);
305 err = pwc_dec23_alloc(pdev);
308 PWC_ERROR("Failed to allocate decompress table.\n");
312 /* Allocate image buffer; double buffer for mmap() */
313 kbuf = pwc_rvmalloc(pwc_mbufs * pdev->len_per_image);
315 PWC_ERROR("Failed to allocate image buffer(s). needed (%d)\n",
316 pwc_mbufs * pdev->len_per_image);
319 PWC_DEBUG_MEMORY("Allocated image buffer at %p.\n", kbuf);
320 pdev->image_data = kbuf;
321 for (i = 0; i < pwc_mbufs; i++) {
322 pdev->images[i].offset = i * pdev->len_per_image;
323 pdev->images[i].vma_use_count = 0;
325 for (; i < MAX_IMAGES; i++) {
326 pdev->images[i].offset = 0;
331 PWC_DEBUG_MEMORY("<< pwc_allocate_buffers()\n");
335 static void pwc_free_buffers(struct pwc_device *pdev)
339 PWC_DEBUG_MEMORY("Entering free_buffers(%p).\n", pdev);
343 /* Release Iso-pipe buffers */
344 for (i = 0; i < MAX_ISO_BUFS; i++)
345 if (pdev->sbuf[i].data != NULL) {
346 PWC_DEBUG_MEMORY("Freeing ISO buffer at %p.\n", pdev->sbuf[i].data);
347 kfree(pdev->sbuf[i].data);
348 pdev->sbuf[i].data = NULL;
351 /* The same for frame buffers */
352 if (pdev->fbuf != NULL) {
353 for (i = 0; i < default_fbufs; i++) {
354 if (pdev->fbuf[i].data != NULL) {
355 PWC_DEBUG_MEMORY("Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data);
356 vfree(pdev->fbuf[i].data);
357 pdev->fbuf[i].data = NULL;
364 /* Intermediate decompression buffer & tables */
365 if (pdev->decompress_data != NULL) {
366 PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n", pdev->decompress_data);
367 kfree(pdev->decompress_data);
368 pdev->decompress_data = NULL;
371 /* Release image buffers */
372 if (pdev->image_data != NULL) {
373 PWC_DEBUG_MEMORY("Freeing image buffer at %p.\n", pdev->image_data);
374 pwc_rvfree(pdev->image_data, pwc_mbufs * pdev->len_per_image);
376 pdev->image_data = NULL;
378 PWC_DEBUG_MEMORY("Leaving free_buffers().\n");
381 /* The frame & image buffer mess.
383 Yes, this is a mess. Well, it used to be simple, but alas... In this
384 module, 3 buffers schemes are used to get the data from the USB bus to
385 the user program. The first scheme involves the ISO buffers (called thus
386 since they transport ISO data from the USB controller), and not really
387 interesting. Suffices to say the data from this buffer is quickly
388 gathered in an interrupt handler (pwc_isoc_handler) and placed into the
391 The frame buffer is the second scheme, and is the central element here.
392 It collects the data from a single frame from the camera (hence, the
393 name). Frames are delimited by the USB camera with a short USB packet,
394 so that's easy to detect. The frame buffers form a list that is filled
395 by the camera+USB controller and drained by the user process through
396 either read() or mmap().
398 The image buffer is the third scheme, in which frames are decompressed
399 and converted into planar format. For mmap() there is more than
400 one image buffer available.
402 The frame buffers provide the image buffering. In case the user process
403 is a bit slow, this introduces lag and some undesired side-effects.
404 The problem arises when the frame buffer is full. I used to drop the last
405 frame, which makes the data in the queue stale very quickly. But dropping
406 the frame at the head of the queue proved to be a litte bit more difficult.
407 I tried a circular linked scheme, but this introduced more problems than
410 Because filling and draining are completely asynchronous processes, this
411 requires some fiddling with pointers and mutexes.
413 Eventually, I came up with a system with 2 lists: an 'empty' frame list
414 and a 'full' frame list:
415 * Initially, all frame buffers but one are on the 'empty' list; the one
416 remaining buffer is our initial fill frame.
417 * If a frame is needed for filling, we try to take it from the 'empty'
418 list, unless that list is empty, in which case we take the buffer at
419 the head of the 'full' list.
420 * When our fill buffer has been filled, it is appended to the 'full'
422 * If a frame is needed by read() or mmap(), it is taken from the head of
423 the 'full' list, handled, and then appended to the 'empty' list. If no
424 buffer is present on the 'full' list, we wait.
425 The advantage is that the buffer that is currently being decompressed/
426 converted, is on neither list, and thus not in our way (any other scheme
427 I tried had the problem of old data lingering in the queue).
429 Whatever strategy you choose, it always remains a tradeoff: with more
430 frame buffers the chances of a missed frame are reduced. On the other
431 hand, on slower machines it introduces lag because the queue will
436 \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.
438 static int pwc_next_fill_frame(struct pwc_device *pdev)
444 spin_lock_irqsave(&pdev->ptrlock, flags);
445 if (pdev->fill_frame != NULL) {
446 /* append to 'full' list */
447 if (pdev->full_frames == NULL) {
448 pdev->full_frames = pdev->fill_frame;
449 pdev->full_frames_tail = pdev->full_frames;
452 pdev->full_frames_tail->next = pdev->fill_frame;
453 pdev->full_frames_tail = pdev->fill_frame;
456 if (pdev->empty_frames != NULL) {
457 /* We have empty frames available. That's easy */
458 pdev->fill_frame = pdev->empty_frames;
459 pdev->empty_frames = pdev->empty_frames->next;
462 /* Hmm. Take it from the full list */
464 if (pdev->full_frames == NULL) {
465 PWC_ERROR("Neither empty or full frames available!\n");
466 spin_unlock_irqrestore(&pdev->ptrlock, flags);
469 pdev->fill_frame = pdev->full_frames;
470 pdev->full_frames = pdev->full_frames->next;
473 pdev->fill_frame->next = NULL;
474 spin_unlock_irqrestore(&pdev->ptrlock, flags);
480 \brief Reset all buffers, pointers and lists, except for the image_used[] buffer.
482 If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble.
484 static void pwc_reset_buffers(struct pwc_device *pdev)
489 PWC_DEBUG_MEMORY(">> %s __enter__\n", __func__);
491 spin_lock_irqsave(&pdev->ptrlock, flags);
492 pdev->full_frames = NULL;
493 pdev->full_frames_tail = NULL;
494 for (i = 0; i < default_fbufs; i++) {
495 pdev->fbuf[i].filled = 0;
497 pdev->fbuf[i].next = &pdev->fbuf[i - 1];
499 pdev->fbuf->next = NULL;
501 pdev->empty_frames = &pdev->fbuf[default_fbufs - 1];
502 pdev->empty_frames_tail = pdev->fbuf;
503 pdev->read_frame = NULL;
504 pdev->fill_frame = pdev->empty_frames;
505 pdev->empty_frames = pdev->empty_frames->next;
507 pdev->image_read_pos = 0;
508 pdev->fill_image = 0;
509 spin_unlock_irqrestore(&pdev->ptrlock, flags);
511 PWC_DEBUG_MEMORY("<< %s __leaving__\n", __func__);
516 \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.
518 int pwc_handle_frame(struct pwc_device *pdev)
523 spin_lock_irqsave(&pdev->ptrlock, flags);
524 /* First grab our read_frame; this is removed from all lists, so
525 we can release the lock after this without problems */
526 if (pdev->read_frame != NULL) {
527 /* This can't theoretically happen */
528 PWC_ERROR("Huh? Read frame still in use?\n");
529 spin_unlock_irqrestore(&pdev->ptrlock, flags);
534 if (pdev->full_frames == NULL) {
535 PWC_ERROR("Woops. No frames ready.\n");
538 pdev->read_frame = pdev->full_frames;
539 pdev->full_frames = pdev->full_frames->next;
540 pdev->read_frame->next = NULL;
543 if (pdev->read_frame != NULL) {
544 /* Decompression is a lengthy process, so it's outside of the lock.
545 This gives the isoc_handler the opportunity to fill more frames
548 spin_unlock_irqrestore(&pdev->ptrlock, flags);
549 ret = pwc_decompress(pdev);
550 spin_lock_irqsave(&pdev->ptrlock, flags);
552 /* We're done with read_buffer, tack it to the end of the empty buffer list */
553 if (pdev->empty_frames == NULL) {
554 pdev->empty_frames = pdev->read_frame;
555 pdev->empty_frames_tail = pdev->empty_frames;
558 pdev->empty_frames_tail->next = pdev->read_frame;
559 pdev->empty_frames_tail = pdev->read_frame;
561 pdev->read_frame = NULL;
563 spin_unlock_irqrestore(&pdev->ptrlock, flags);
568 \brief Advance pointers of image buffer (after each user request)
570 void pwc_next_image(struct pwc_device *pdev)
572 pdev->image_used[pdev->fill_image] = 0;
573 pdev->fill_image = (pdev->fill_image + 1) % pwc_mbufs;
577 * Print debug information when a frame is discarded because all of our buffer
580 static void pwc_frame_dumped(struct pwc_device *pdev)
582 pdev->vframes_dumped++;
583 if (pdev->vframe_count < FRAME_LOWMARK)
586 if (pdev->vframes_dumped < 20)
587 PWC_DEBUG_FLOW("Dumping frame %d\n", pdev->vframe_count);
588 else if (pdev->vframes_dumped == 20)
589 PWC_DEBUG_FLOW("Dumping frame %d (last message)\n",
593 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
596 PWC_TRACE("Snapshot button pressed.\n");
597 pdev->snapshot_button_status = 1;
599 PWC_TRACE("Snapshot button released.\n");
602 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
603 if (pdev->button_dev) {
604 input_report_key(pdev->button_dev, KEY_CAMERA, down);
605 input_sync(pdev->button_dev);
610 static int pwc_rcv_short_packet(struct pwc_device *pdev, const struct pwc_frame_buf *fbuf)
614 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
615 frames on the USB wire after an exposure change. This conditition is
616 however detected in the cam and a bit is set in the header.
618 if (pdev->type == 730) {
619 unsigned char *ptr = (unsigned char *)fbuf->data;
621 if (ptr[1] == 1 && ptr[0] & 0x10) {
622 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
623 pdev->drop_frames += 2;
624 pdev->vframes_error++;
626 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
627 pwc_snapshot_button(pdev, ptr[0] & 0x01);
629 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
631 PWC_TRACE("Image is mirrored.\n");
633 PWC_TRACE("Image is normal.\n");
635 pdev->vmirror = ptr[0] & 0x03;
636 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
637 after a short frame; this condition is filtered out specifically. A 4 byte
638 frame doesn't make sense anyway.
639 So we get either this sequence:
640 drop_bit set -> 4 byte frame -> short frame -> good frame
642 drop_bit set -> short frame -> good frame
643 So we drop either 3 or 2 frames in all!
645 if (fbuf->filled == 4)
648 else if (pdev->type == 740 || pdev->type == 720) {
649 unsigned char *ptr = (unsigned char *)fbuf->data;
650 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
651 pwc_snapshot_button(pdev, ptr[0] & 0x01);
653 pdev->vmirror = ptr[0] & 0x03;
656 /* In case we were instructed to drop the frame, do so silently.
657 The buffer pointers are not updated either (but the counters are reset below).
659 if (pdev->drop_frames > 0)
662 /* Check for underflow first */
663 if (fbuf->filled < pdev->frame_total_size) {
664 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
665 " discarded.\n", fbuf->filled);
666 pdev->vframes_error++;
669 /* Send only once per EOF */
670 awake = 1; /* delay wake_ups */
672 /* Find our next frame to fill. This will always succeed, since we
673 * nick a frame from either empty or full list, but if we had to
674 * take it from the full list, it means a frame got dropped.
676 if (pwc_next_fill_frame(pdev))
677 pwc_frame_dumped(pdev);
681 pdev->vframe_count++;
685 /* This gets called for the Isochronous pipe (video). This is done in
686 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
688 static void pwc_isoc_handler(struct urb *urb)
690 struct pwc_device *pdev;
693 struct pwc_frame_buf *fbuf;
694 unsigned char *fillptr = NULL, *iso_buf = NULL;
697 pdev = (struct pwc_device *)urb->context;
699 PWC_ERROR("isoc_handler() called with NULL device?!\n");
703 if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
704 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
707 if (urb->status != -EINPROGRESS && urb->status != 0) {
711 switch(urb->status) {
712 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
713 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
714 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
715 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
716 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
717 case -ETIME: errmsg = "Device does not respond"; break;
719 PWC_DEBUG_FLOW("pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
720 /* Give up after a number of contiguous errors on the USB bus.
721 Appearantly something is wrong so we simulate an unplug event.
723 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
725 PWC_INFO("Too many ISOC errors, bailing out.\n");
726 pdev->error_status = EIO;
728 wake_up_interruptible(&pdev->frameq);
730 goto handler_end; // ugly, but practical
733 fbuf = pdev->fill_frame;
735 PWC_ERROR("pwc_isoc_handler without valid fill frame.\n");
740 fillptr = fbuf->data + fbuf->filled;
743 /* Reset ISOC error counter. We did get here, after all. */
744 pdev->visoc_errors = 0;
746 /* vsync: 0 = don't copy data
751 for (i = 0; i < urb->number_of_packets; i++) {
752 fst = urb->iso_frame_desc[i].status;
753 flen = urb->iso_frame_desc[i].actual_length;
754 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
756 if (flen > 0) { /* if valid data... */
757 if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */
760 /* ...copy data to frame buffer, if possible */
761 if (flen + fbuf->filled > pdev->frame_total_size) {
762 PWC_DEBUG_FLOW("Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen, pdev->frame_total_size);
763 pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */
764 pdev->vframes_error++;
767 memmove(fillptr, iso_buf, flen);
771 fbuf->filled += flen;
774 if (flen < pdev->vlast_packet_size) {
775 /* Shorter packet... We probably have the end of an image-frame;
776 wake up read() process and let select()/poll() do something.
777 Decompression is done in user time over there.
779 if (pdev->vsync == 2) {
780 if (pwc_rcv_short_packet(pdev, fbuf)) {
782 fbuf = pdev->fill_frame;
786 fillptr = fbuf->data;
790 pdev->vlast_packet_size = flen;
791 } /* ..status == 0 */
793 /* This is normally not interesting to the user, unless
794 * you are really debugging something, default = 0 */
795 static int iso_error;
798 PWC_DEBUG_FLOW("Iso frame %d of USB has error %d\n", i, fst);
804 wake_up_interruptible(&pdev->frameq);
806 urb->dev = pdev->udev;
807 i = usb_submit_urb(urb, GFP_ATOMIC);
809 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
813 int pwc_isoc_init(struct pwc_device *pdev)
815 struct usb_device *udev;
819 struct usb_interface *intf;
820 struct usb_host_interface *idesc = NULL;
829 /* Get the current alternate interface, adjust packet size */
830 if (!udev->actconfig)
832 intf = usb_ifnum_to_if(udev, 0);
834 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
839 /* Search video endpoint */
840 pdev->vmax_packet_size = -1;
841 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
842 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
843 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
848 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
849 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
850 return -ENFILE; /* Odd error, that should be noticeable */
853 /* Set alternate interface */
855 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
856 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
860 for (i = 0; i < MAX_ISO_BUFS; i++) {
861 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
863 PWC_ERROR("Failed to allocate urb %d\n", i);
867 pdev->sbuf[i].urb = urb;
868 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
871 /* De-allocate in reverse order */
873 usb_free_urb(pdev->sbuf[i].urb);
874 pdev->sbuf[i].urb = NULL;
879 /* init URB structure */
880 for (i = 0; i < MAX_ISO_BUFS; i++) {
881 urb = pdev->sbuf[i].urb;
883 urb->interval = 1; // devik
885 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
886 urb->transfer_flags = URB_ISO_ASAP;
887 urb->transfer_buffer = pdev->sbuf[i].data;
888 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
889 urb->complete = pwc_isoc_handler;
891 urb->start_frame = 0;
892 urb->number_of_packets = ISO_FRAMES_PER_DESC;
893 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
894 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
895 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
900 for (i = 0; i < MAX_ISO_BUFS; i++) {
901 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL);
903 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
905 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->sbuf[i].urb);
910 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
914 static void pwc_iso_stop(struct pwc_device *pdev)
918 /* Unlinking ISOC buffers one by one */
919 for (i = 0; i < MAX_ISO_BUFS; i++) {
922 urb = pdev->sbuf[i].urb;
924 PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb);
930 static void pwc_iso_free(struct pwc_device *pdev)
934 /* Freeing ISOC buffers one by one */
935 for (i = 0; i < MAX_ISO_BUFS; i++) {
938 urb = pdev->sbuf[i].urb;
940 PWC_DEBUG_MEMORY("Freeing URB\n");
942 pdev->sbuf[i].urb = NULL;
947 void pwc_isoc_cleanup(struct pwc_device *pdev)
949 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
952 if (pdev->iso_init == 0)
958 /* Stop camera, but only if we are sure the camera is still there (unplug
959 is signalled by EPIPE)
961 if (pdev->error_status && pdev->error_status != EPIPE) {
962 PWC_DEBUG_OPEN("Setting alternate interface 0.\n");
963 usb_set_interface(pdev->udev, 0, 0);
967 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
970 int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot)
974 /* Stop isoc stuff */
975 pwc_isoc_cleanup(pdev);
976 /* Reset parameters */
977 pwc_reset_buffers(pdev);
978 /* Try to set video mode... */
979 start = ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot);
981 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 1 failed.\n");
982 /* That failed... restore old mode (we know that worked) */
983 start = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
985 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 2 failed.\n");
990 if (pwc_isoc_init(pdev) < 0)
992 PWC_WARNING("Failed to restart ISOC transfers in pwc_try_video_mode.\n");
993 ret = -EAGAIN; /* let's try again, who knows if it works a second time */
996 pdev->drop_frames++; /* try to avoid garbage during switch */
997 return ret; /* Return original error code */
1003 static struct pwc_device *cd_to_pwc(struct device *cd)
1005 struct video_device *vdev = to_video_device(cd);
1006 return video_get_drvdata(vdev);
1009 static ssize_t show_pan_tilt(struct device *class_dev,
1010 struct device_attribute *attr, char *buf)
1012 struct pwc_device *pdev = cd_to_pwc(class_dev);
1013 return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
1016 static ssize_t store_pan_tilt(struct device *class_dev,
1017 struct device_attribute *attr,
1018 const char *buf, size_t count)
1020 struct pwc_device *pdev = cd_to_pwc(class_dev);
1024 if (strncmp(buf, "reset", 5) == 0)
1025 ret = pwc_mpt_reset(pdev, 0x3);
1027 else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
1028 ret = pwc_mpt_set_angle(pdev, pan, tilt);
1034 static DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
1037 static ssize_t show_snapshot_button_status(struct device *class_dev,
1038 struct device_attribute *attr, char *buf)
1040 struct pwc_device *pdev = cd_to_pwc(class_dev);
1041 int status = pdev->snapshot_button_status;
1042 pdev->snapshot_button_status = 0;
1043 return sprintf(buf, "%d\n", status);
1046 static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
1049 static int pwc_create_sysfs_files(struct video_device *vdev)
1051 struct pwc_device *pdev = video_get_drvdata(vdev);
1054 rc = device_create_file(&vdev->dev, &dev_attr_button);
1057 if (pdev->features & FEATURE_MOTOR_PANTILT) {
1058 rc = device_create_file(&vdev->dev, &dev_attr_pan_tilt);
1066 device_remove_file(&vdev->dev, &dev_attr_button);
1068 PWC_ERROR("Could not create sysfs files.\n");
1072 static void pwc_remove_sysfs_files(struct video_device *vdev)
1074 struct pwc_device *pdev = video_get_drvdata(vdev);
1076 if (pdev->features & FEATURE_MOTOR_PANTILT)
1077 device_remove_file(&vdev->dev, &dev_attr_pan_tilt);
1078 device_remove_file(&vdev->dev, &dev_attr_button);
1081 #ifdef CONFIG_USB_PWC_DEBUG
1082 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
1084 switch(sensor_type) {
1086 return "Hyundai CMOS sensor";
1088 return "Sony CCD sensor + TDA8787";
1090 return "Sony CCD sensor + Exas 98L59";
1092 return "Sony CCD sensor + ADI 9804";
1094 return "Sharp CCD sensor + TDA8787";
1096 return "Sharp CCD sensor + Exas 98L59";
1098 return "Sharp CCD sensor + ADI 9804";
1100 return "UPA 1021 sensor";
1102 return "VGA sensor";
1104 return "PAL MR sensor";
1106 return "unknown type of sensor";
1111 /***************************************************************************/
1112 /* Video4Linux functions */
1114 static int pwc_video_open(struct file *file)
1117 struct video_device *vdev = video_devdata(file);
1118 struct pwc_device *pdev;
1120 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
1122 pdev = video_get_drvdata(vdev);
1125 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1129 mutex_lock(&pdev->modlock);
1130 pwc_construct(pdev); /* set min/max sizes correct */
1131 if (!pdev->usb_init) {
1132 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1135 /* Query sensor type */
1136 ret = pwc_get_cmos_sensor(pdev, &i);
1139 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1141 pwc_sensor_type_to_string(i), i);
1145 /* Turn on camera */
1147 i = pwc_camera_power(pdev, 1);
1149 PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
1151 /* Set LED on/off time */
1152 if (pwc_set_leds(pdev, led_on, led_off) < 0)
1153 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1156 /* So far, so good. Allocate memory. */
1157 i = pwc_allocate_buffers(pdev);
1159 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1160 pwc_free_buffers(pdev);
1161 mutex_unlock(&pdev->modlock);
1165 /* Reset buffers & parameters */
1166 pwc_reset_buffers(pdev);
1167 for (i = 0; i < pwc_mbufs; i++)
1168 pdev->image_used[i] = 0;
1169 pdev->vframe_count = 0;
1170 pdev->vframes_dumped = 0;
1171 pdev->vframes_error = 0;
1172 pdev->visoc_errors = 0;
1173 pdev->error_status = 0;
1174 pwc_construct(pdev); /* set min/max sizes correct */
1176 /* Set some defaults */
1177 pdev->vsnapshot = 0;
1179 /* Start iso pipe for video; first try the last used video size
1180 (or the default one); if that fails try QCIF/10 or QSIF/10;
1181 it that fails too, give up.
1183 i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1185 unsigned int default_resolution;
1186 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1187 if (pdev->type>= 730)
1188 default_resolution = PSZ_QSIF;
1190 default_resolution = PSZ_QCIF;
1192 i = pwc_set_video_mode(pdev,
1193 pwc_image_sizes[default_resolution].x,
1194 pwc_image_sizes[default_resolution].y,
1200 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1201 pwc_free_buffers(pdev);
1202 mutex_unlock(&pdev->modlock);
1206 i = pwc_isoc_init(pdev);
1208 PWC_DEBUG_OPEN("Failed to init ISOC stuff = %d.\n", i);
1209 pwc_isoc_cleanup(pdev);
1210 pwc_free_buffers(pdev);
1211 mutex_unlock(&pdev->modlock);
1215 /* Initialize the webcam to sane value */
1216 pwc_set_brightness(pdev, 0x7fff);
1217 pwc_set_agc(pdev, 1, 0);
1220 file->private_data = vdev;
1221 mutex_unlock(&pdev->modlock);
1222 PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1227 static void pwc_cleanup(struct pwc_device *pdev)
1229 pwc_remove_sysfs_files(pdev->vdev);
1230 video_unregister_device(pdev->vdev);
1232 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1233 if (pdev->button_dev)
1234 input_unregister_device(pdev->button_dev);
1240 /* Note that all cleanup is done in the reverse order as in _open */
1241 static int pwc_video_close(struct file *file)
1243 struct video_device *vdev = file->private_data;
1244 struct pwc_device *pdev;
1247 PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
1249 pdev = video_get_drvdata(vdev);
1250 mutex_lock(&pdev->modlock);
1251 if (pdev->vopen == 0)
1252 PWC_DEBUG_MODULE("video_close() called on closed device?\n");
1254 /* Dump statistics, but only if a reasonable amount of frames were
1255 processed (to prevent endless log-entries in case of snap-shot
1258 if (pdev->vframe_count > 20)
1259 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);
1261 if (DEVICE_USE_CODEC1(pdev->type))
1266 pwc_isoc_cleanup(pdev);
1267 pwc_free_buffers(pdev);
1269 /* Turn off LEDS and power down camera, but only when not unplugged */
1270 if (!pdev->unplugged) {
1272 if (pwc_set_leds(pdev, 0, 0) < 0)
1273 PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
1275 i = pwc_camera_power(pdev, 0);
1277 PWC_ERROR("Failed to power down camera (%d)\n", i);
1280 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
1283 /* search device_hint[] table if we occupy a slot, by any chance */
1284 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1285 if (device_hint[hint].pdev == pdev)
1286 device_hint[hint].pdev = NULL;
1288 mutex_unlock(&pdev->modlock);
1294 * FIXME: what about two parallel reads ????
1295 * ANSWER: Not supported. You can't open the device more than once,
1296 despite what the V4L1 interface says. First, I don't see
1297 the need, second there's no mechanism of alerting the
1298 2nd/3rd/... process of events like changing image size.
1299 And I don't see the point of blocking that for the
1300 2nd/3rd/... process.
1301 In multi-threaded environments reading parallel from any
1302 device is tricky anyhow.
1305 static ssize_t pwc_video_read(struct file *file, char __user *buf,
1306 size_t count, loff_t *ppos)
1308 struct video_device *vdev = file->private_data;
1309 struct pwc_device *pdev;
1310 int noblock = file->f_flags & O_NONBLOCK;
1311 DECLARE_WAITQUEUE(wait, current);
1312 int bytes_to_read, rv = 0;
1313 void *image_buffer_addr;
1315 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1319 pdev = video_get_drvdata(vdev);
1323 mutex_lock(&pdev->modlock);
1324 if (pdev->error_status) {
1325 rv = -pdev->error_status; /* Something happened, report what. */
1329 /* In case we're doing partial reads, we don't have to wait for a frame */
1330 if (pdev->image_read_pos == 0) {
1331 /* Do wait queueing according to the (doc)book */
1332 add_wait_queue(&pdev->frameq, &wait);
1333 while (pdev->full_frames == NULL) {
1334 /* Check for unplugged/etc. here */
1335 if (pdev->error_status) {
1336 remove_wait_queue(&pdev->frameq, &wait);
1337 set_current_state(TASK_RUNNING);
1338 rv = -pdev->error_status ;
1342 remove_wait_queue(&pdev->frameq, &wait);
1343 set_current_state(TASK_RUNNING);
1347 if (signal_pending(current)) {
1348 remove_wait_queue(&pdev->frameq, &wait);
1349 set_current_state(TASK_RUNNING);
1354 set_current_state(TASK_INTERRUPTIBLE);
1356 remove_wait_queue(&pdev->frameq, &wait);
1357 set_current_state(TASK_RUNNING);
1359 /* Decompress and release frame */
1360 if (pwc_handle_frame(pdev)) {
1366 PWC_DEBUG_READ("Copying data to user space.\n");
1367 if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
1368 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1370 bytes_to_read = pdev->view.size;
1372 /* copy bytes to user space; we allow for partial reads */
1373 if (count + pdev->image_read_pos > bytes_to_read)
1374 count = bytes_to_read - pdev->image_read_pos;
1375 image_buffer_addr = pdev->image_data;
1376 image_buffer_addr += pdev->images[pdev->fill_image].offset;
1377 image_buffer_addr += pdev->image_read_pos;
1378 if (copy_to_user(buf, image_buffer_addr, count)) {
1382 pdev->image_read_pos += count;
1383 if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
1384 pdev->image_read_pos = 0;
1385 pwc_next_image(pdev);
1387 mutex_unlock(&pdev->modlock);
1390 mutex_unlock(&pdev->modlock);
1394 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1396 struct video_device *vdev = file->private_data;
1397 struct pwc_device *pdev;
1401 pdev = video_get_drvdata(vdev);
1405 poll_wait(file, &pdev->frameq, wait);
1406 if (pdev->error_status)
1408 if (pdev->full_frames != NULL) /* we have frames waiting */
1409 return (POLLIN | POLLRDNORM);
1414 static long pwc_video_ioctl(struct file *file,
1415 unsigned int cmd, unsigned long arg)
1417 struct video_device *vdev = file->private_data;
1418 struct pwc_device *pdev;
1423 pdev = video_get_drvdata(vdev);
1425 mutex_lock(&pdev->modlock);
1426 if (!pdev->unplugged)
1427 r = video_usercopy(file, cmd, arg, pwc_video_do_ioctl);
1428 mutex_unlock(&pdev->modlock);
1433 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1435 struct video_device *vdev = file->private_data;
1436 struct pwc_device *pdev;
1437 unsigned long start;
1439 unsigned long page, pos = 0;
1442 PWC_DEBUG_MEMORY(">> %s\n", __func__);
1443 pdev = video_get_drvdata(vdev);
1444 size = vma->vm_end - vma->vm_start;
1445 start = vma->vm_start;
1447 /* Find the idx buffer for this mapping */
1448 for (index = 0; index < pwc_mbufs; index++) {
1449 pos = pdev->images[index].offset;
1450 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1453 if (index == MAX_IMAGES)
1457 * Special case for v4l1. In v4l1, we map only one big buffer,
1458 * but in v4l2 each buffer is mapped
1460 unsigned long total_size;
1461 total_size = pwc_mbufs * pdev->len_per_image;
1462 if (size != pdev->len_per_image && size != total_size) {
1463 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1464 size, pdev->len_per_image, total_size);
1467 } else if (size > pdev->len_per_image)
1470 vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
1472 pos += (unsigned long)pdev->image_data;
1474 page = vmalloc_to_pfn((void *)pos);
1475 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1479 if (size > PAGE_SIZE)
1487 /***************************************************************************/
1490 /* This function gets called when a new device is plugged in or the usb core
1494 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1496 struct usb_device *udev = interface_to_usbdev(intf);
1497 struct pwc_device *pdev = NULL;
1498 int vendor_id, product_id, type_id;
1501 int video_nr = -1; /* default: use next available device */
1502 char serial_number[30], *name;
1504 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1505 product_id = le16_to_cpu(udev->descriptor.idProduct);
1507 /* Check if we can handle this device */
1508 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1509 vendor_id, product_id,
1510 intf->altsetting->desc.bInterfaceNumber);
1512 /* the interfaces are probed one by one. We are only interested in the
1513 video interface (0) now.
1514 Interface 1 is the Audio Control, and interface 2 Audio itself.
1516 if (intf->altsetting->desc.bInterfaceNumber > 0)
1519 if (vendor_id == 0x0471) {
1520 switch (product_id) {
1522 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1523 name = "Philips 645 webcam";
1527 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1528 name = "Philips 646 webcam";
1532 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1533 name = "Askey VC010 webcam";
1537 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1538 name = "Philips 675 webcam";
1542 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1543 name = "Philips 680 webcam";
1547 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1548 name = "Philips 690 webcam";
1552 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1553 name = "Philips 730 webcam";
1557 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1558 name = "Philips 740 webcam";
1562 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1563 name = "Philips 750 webcam";
1567 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1568 name = "Philips 720K/40 webcam";
1572 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1573 name = "Philips SPC 900NC webcam";
1581 else if (vendor_id == 0x069A) {
1582 switch(product_id) {
1584 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1585 name = "Askey VC010 webcam";
1593 else if (vendor_id == 0x046d) {
1594 switch(product_id) {
1596 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1597 name = "Logitech QuickCam Pro 3000";
1598 type_id = 740; /* CCD sensor */
1601 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1602 name = "Logitech QuickCam Notebook Pro";
1603 type_id = 740; /* CCD sensor */
1606 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1607 name = "Logitech QuickCam Pro 4000";
1608 type_id = 740; /* CCD sensor */
1611 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1612 name = "Logitech QuickCam Zoom";
1613 type_id = 740; /* CCD sensor */
1616 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1617 name = "Logitech QuickCam Zoom";
1618 type_id = 740; /* CCD sensor */
1622 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1623 name = "Logitech QuickCam Orbit";
1624 type_id = 740; /* CCD sensor */
1625 features |= FEATURE_MOTOR_PANTILT;
1628 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1629 name = "Cisco VT Camera";
1630 type_id = 740; /* CCD sensor */
1633 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1634 name = "Logitech ViewPort AV 100";
1635 type_id = 740; /* CCD sensor */
1637 case 0x08b8: /* Where this released? */
1638 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1639 name = "Logitech QuickCam (res.)";
1640 type_id = 730; /* Assuming CMOS */
1647 else if (vendor_id == 0x055d) {
1648 /* I don't know the difference between the C10 and the C30;
1649 I suppose the difference is the sensor, but both cameras
1650 work equally well with a type_id of 675
1652 switch(product_id) {
1654 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1655 name = "Samsung MPC-C10";
1659 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1660 name = "Samsung MPC-C30";
1664 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1665 name = "Samsung MPC-C30";
1673 else if (vendor_id == 0x041e) {
1674 switch(product_id) {
1676 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1677 name = "Creative Labs Webcam 5";
1681 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1682 name = "Creative Labs Webcam Pro Ex";
1690 else if (vendor_id == 0x04cc) {
1691 switch(product_id) {
1693 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1694 name = "Sotec Afina Eye";
1702 else if (vendor_id == 0x06be) {
1703 switch(product_id) {
1705 /* This is essentially the same cam as the Sotec Afina Eye */
1706 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1707 name = "AME Co. Afina Eye";
1716 else if (vendor_id == 0x0d81) {
1717 switch(product_id) {
1719 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1720 name = "Visionite VCS-UC300";
1721 type_id = 740; /* CCD sensor */
1724 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1725 name = "Visionite VCS-UM100";
1726 type_id = 730; /* CMOS sensor */
1734 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1736 memset(serial_number, 0, 30);
1737 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1738 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1740 if (udev->descriptor.bNumConfigurations > 1)
1741 PWC_WARNING("Warning: more than 1 configuration available.\n");
1743 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1744 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1746 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1749 pdev->type = type_id;
1750 pdev->vsize = default_size;
1751 pdev->vframes = default_fps;
1752 strcpy(pdev->serial, serial_number);
1753 pdev->features = features;
1754 if (vendor_id == 0x046D && product_id == 0x08B5) {
1755 /* Logitech QuickCam Orbit
1756 The ranges have been determined experimentally; they may differ from cam to cam.
1757 Also, the exact ranges left-right and up-down are different for my cam
1759 pdev->angle_range.pan_min = -7000;
1760 pdev->angle_range.pan_max = 7000;
1761 pdev->angle_range.tilt_min = -3000;
1762 pdev->angle_range.tilt_max = 2500;
1765 mutex_init(&pdev->modlock);
1766 spin_lock_init(&pdev->ptrlock);
1769 init_waitqueue_head(&pdev->frameq);
1770 pdev->vcompression = pwc_preferred_compression;
1772 /* Allocate video_device structure */
1773 pdev->vdev = video_device_alloc();
1775 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
1779 memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
1780 pdev->vdev->parent = &intf->dev;
1781 strcpy(pdev->vdev->name, name);
1782 video_set_drvdata(pdev->vdev, pdev);
1784 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1785 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1787 /* Now search device_hint[] table for a match, so we can hint a node number. */
1788 for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1789 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1790 (device_hint[hint].pdev == NULL)) {
1791 /* so far, so good... try serial number */
1792 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1794 video_nr = device_hint[hint].device_node;
1795 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1801 pdev->vdev->release = video_device_release;
1804 if (hint < MAX_DEV_HINTS)
1805 device_hint[hint].pdev = pdev;
1807 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1808 usb_set_intfdata(intf, pdev);
1810 /* Set the leds off */
1811 pwc_set_leds(pdev, 0, 0);
1812 pwc_camera_power(pdev, 0);
1814 rc = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1816 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1817 goto err_video_release;
1819 rc = pwc_create_sysfs_files(pdev->vdev);
1821 goto err_video_unreg;
1823 PWC_INFO("Registered as %s.\n", video_device_node_name(pdev->vdev));
1825 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1826 /* register webcam snapshot button input device */
1827 pdev->button_dev = input_allocate_device();
1828 if (!pdev->button_dev) {
1829 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1831 pwc_remove_sysfs_files(pdev->vdev);
1832 goto err_video_unreg;
1835 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1836 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1838 pdev->button_dev->name = "PWC snapshot button";
1839 pdev->button_dev->phys = pdev->button_phys;
1840 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1841 pdev->button_dev->dev.parent = &pdev->udev->dev;
1842 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1843 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1845 rc = input_register_device(pdev->button_dev);
1847 input_free_device(pdev->button_dev);
1848 pdev->button_dev = NULL;
1849 pwc_remove_sysfs_files(pdev->vdev);
1850 goto err_video_unreg;
1857 if (hint < MAX_DEV_HINTS)
1858 device_hint[hint].pdev = NULL;
1859 video_unregister_device(pdev->vdev);
1860 pdev->vdev = NULL; /* So we don't try to release it below */
1862 video_device_release(pdev->vdev);
1868 /* The user yanked out the cable... */
1869 static void usb_pwc_disconnect(struct usb_interface *intf)
1871 struct pwc_device *pdev;
1874 pdev = usb_get_intfdata (intf);
1875 mutex_lock(&pdev->modlock);
1876 usb_set_intfdata (intf, NULL);
1878 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1879 goto disconnect_out;
1881 if (pdev->udev == NULL) {
1882 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1883 goto disconnect_out;
1885 if (pdev->udev != interface_to_usbdev(intf)) {
1886 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1887 goto disconnect_out;
1890 /* We got unplugged; this is signalled by an EPIPE error code */
1892 PWC_INFO("Disconnected while webcam is in use!\n");
1893 pdev->error_status = EPIPE;
1896 /* Alert waiting processes */
1897 wake_up_interruptible(&pdev->frameq);
1898 /* Wait until device is closed */
1900 pdev->unplugged = 1;
1903 /* Device is closed, so we can safely unregister it */
1904 PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
1908 /* search device_hint[] table if we occupy a slot, by any chance */
1909 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1910 if (device_hint[hint].pdev == pdev)
1911 device_hint[hint].pdev = NULL;
1914 mutex_unlock(&pdev->modlock);
1919 * Initialization code & module stuff
1926 static int compression = -1;
1927 static int leds[2] = { -1, -1 };
1928 static unsigned int leds_nargs;
1929 static char *dev_hint[MAX_DEV_HINTS];
1930 static unsigned int dev_hint_nargs;
1932 module_param(size, charp, 0444);
1933 module_param(fps, int, 0444);
1934 module_param(fbufs, int, 0444);
1935 module_param(mbufs, int, 0444);
1936 #ifdef CONFIG_USB_PWC_DEBUG
1937 module_param_named(trace, pwc_trace, int, 0644);
1939 module_param(power_save, int, 0444);
1940 module_param(compression, int, 0444);
1941 module_param_array(leds, int, &leds_nargs, 0444);
1942 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1944 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1945 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1946 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1947 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1948 #ifdef CONFIG_USB_PWC_DEBUG
1949 MODULE_PARM_DESC(trace, "For debugging purposes");
1951 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1952 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1953 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1954 MODULE_PARM_DESC(dev_hint, "Device node hints");
1956 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1957 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1958 MODULE_LICENSE("GPL");
1959 MODULE_ALIAS("pwcx");
1960 MODULE_VERSION( PWC_VERSION );
1962 static int __init usb_pwc_init(void)
1965 char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1967 PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1968 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1969 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1970 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1973 if (fps < 4 || fps > 30) {
1974 PWC_ERROR("Framerate out of bounds (4-30).\n");
1978 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1982 /* string; try matching with array */
1983 for (sz = 0; sz < PSZ_MAX; sz++) {
1984 if (!strcmp(sizenames[sz], size)) { /* Found! */
1989 if (sz == PSZ_MAX) {
1990 PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1993 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);
1996 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1997 PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
2001 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
2004 if (fbufs < 2 || fbufs > MAX_FRAMES) {
2005 PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
2008 default_fbufs = fbufs;
2009 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
2011 #ifdef CONFIG_USB_PWC_DEBUG
2012 if (pwc_trace >= 0) {
2013 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
2016 if (compression >= 0) {
2017 if (compression > 3) {
2018 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
2021 pwc_preferred_compression = compression;
2022 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
2025 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
2031 /* Big device node whoopla. Basically, it allows you to assign a
2032 device node (/dev/videoX) to a camera, based on its type
2033 & serial number. The format is [type[.serialnumber]:]node.
2035 Any camera that isn't matched by these rules gets the next
2036 available free device node.
2038 for (i = 0; i < MAX_DEV_HINTS; i++) {
2039 char *s, *colon, *dot;
2041 /* This loop also initializes the array */
2042 device_hint[i].pdev = NULL;
2044 if (s != NULL && *s != '\0') {
2045 device_hint[i].type = -1; /* wildcard */
2046 strcpy(device_hint[i].serial_number, "*");
2048 /* parse string: chop at ':' & '/' */
2050 while (*colon != '\0' && *colon != ':')
2052 while (*dot != '\0' && *dot != '.')
2054 /* Few sanity checks */
2055 if (*dot != '\0' && dot > colon) {
2056 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
2060 if (*colon == '\0') {
2063 PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
2067 /* No type or serial number specified, just a number. */
2068 device_hint[i].device_node =
2069 simple_strtol(s, NULL, 10);
2073 /* There's a colon, so we have at least a type and a device node */
2074 device_hint[i].type =
2075 simple_strtol(s, NULL, 10);
2076 device_hint[i].device_node =
2077 simple_strtol(colon + 1, NULL, 10);
2079 /* There's a serial number as well */
2084 while (*dot != ':' && k < 29) {
2085 device_hint[i].serial_number[k++] = *dot;
2088 device_hint[i].serial_number[k] = '\0';
2091 PWC_TRACE("device_hint[%d]:\n", i);
2092 PWC_TRACE(" type : %d\n", device_hint[i].type);
2093 PWC_TRACE(" serial# : %s\n", device_hint[i].serial_number);
2094 PWC_TRACE(" node : %d\n", device_hint[i].device_node);
2097 device_hint[i].type = 0; /* not filled */
2098 } /* ..for MAX_DEV_HINTS */
2100 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
2101 return usb_register(&pwc_driver);
2104 static void __exit usb_pwc_exit(void)
2106 PWC_DEBUG_MODULE("Deregistering driver.\n");
2107 usb_deregister(&pwc_driver);
2108 PWC_INFO("Philips webcam module removed.\n");
2111 module_init(usb_pwc_init);
2112 module_exit(usb_pwc_exit);
2114 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */