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 = vzalloc(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;
300 /* Allocate decompressor table space */
301 if (DEVICE_USE_CODEC1(pdev->type))
302 err = pwc_dec1_alloc(pdev);
304 err = pwc_dec23_alloc(pdev);
307 PWC_ERROR("Failed to allocate decompress table.\n");
311 /* Allocate image buffer; double buffer for mmap() */
312 kbuf = pwc_rvmalloc(pwc_mbufs * pdev->len_per_image);
314 PWC_ERROR("Failed to allocate image buffer(s). needed (%d)\n",
315 pwc_mbufs * pdev->len_per_image);
318 PWC_DEBUG_MEMORY("Allocated image buffer at %p.\n", kbuf);
319 pdev->image_data = kbuf;
320 for (i = 0; i < pwc_mbufs; i++) {
321 pdev->images[i].offset = i * pdev->len_per_image;
322 pdev->images[i].vma_use_count = 0;
324 for (; i < MAX_IMAGES; i++) {
325 pdev->images[i].offset = 0;
330 PWC_DEBUG_MEMORY("<< pwc_allocate_buffers()\n");
334 static void pwc_free_buffers(struct pwc_device *pdev)
338 PWC_DEBUG_MEMORY("Entering free_buffers(%p).\n", pdev);
342 /* Release Iso-pipe buffers */
343 for (i = 0; i < MAX_ISO_BUFS; i++)
344 if (pdev->sbuf[i].data != NULL) {
345 PWC_DEBUG_MEMORY("Freeing ISO buffer at %p.\n", pdev->sbuf[i].data);
346 kfree(pdev->sbuf[i].data);
347 pdev->sbuf[i].data = NULL;
350 /* The same for frame buffers */
351 if (pdev->fbuf != NULL) {
352 for (i = 0; i < default_fbufs; i++) {
353 if (pdev->fbuf[i].data != NULL) {
354 PWC_DEBUG_MEMORY("Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data);
355 vfree(pdev->fbuf[i].data);
356 pdev->fbuf[i].data = NULL;
363 /* Intermediate decompression buffer & tables */
364 if (pdev->decompress_data != NULL) {
365 PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n", pdev->decompress_data);
366 kfree(pdev->decompress_data);
367 pdev->decompress_data = NULL;
370 /* Release image buffers */
371 if (pdev->image_data != NULL) {
372 PWC_DEBUG_MEMORY("Freeing image buffer at %p.\n", pdev->image_data);
373 pwc_rvfree(pdev->image_data, pwc_mbufs * pdev->len_per_image);
375 pdev->image_data = NULL;
377 PWC_DEBUG_MEMORY("Leaving free_buffers().\n");
380 /* The frame & image buffer mess.
382 Yes, this is a mess. Well, it used to be simple, but alas... In this
383 module, 3 buffers schemes are used to get the data from the USB bus to
384 the user program. The first scheme involves the ISO buffers (called thus
385 since they transport ISO data from the USB controller), and not really
386 interesting. Suffices to say the data from this buffer is quickly
387 gathered in an interrupt handler (pwc_isoc_handler) and placed into the
390 The frame buffer is the second scheme, and is the central element here.
391 It collects the data from a single frame from the camera (hence, the
392 name). Frames are delimited by the USB camera with a short USB packet,
393 so that's easy to detect. The frame buffers form a list that is filled
394 by the camera+USB controller and drained by the user process through
395 either read() or mmap().
397 The image buffer is the third scheme, in which frames are decompressed
398 and converted into planar format. For mmap() there is more than
399 one image buffer available.
401 The frame buffers provide the image buffering. In case the user process
402 is a bit slow, this introduces lag and some undesired side-effects.
403 The problem arises when the frame buffer is full. I used to drop the last
404 frame, which makes the data in the queue stale very quickly. But dropping
405 the frame at the head of the queue proved to be a litte bit more difficult.
406 I tried a circular linked scheme, but this introduced more problems than
409 Because filling and draining are completely asynchronous processes, this
410 requires some fiddling with pointers and mutexes.
412 Eventually, I came up with a system with 2 lists: an 'empty' frame list
413 and a 'full' frame list:
414 * Initially, all frame buffers but one are on the 'empty' list; the one
415 remaining buffer is our initial fill frame.
416 * If a frame is needed for filling, we try to take it from the 'empty'
417 list, unless that list is empty, in which case we take the buffer at
418 the head of the 'full' list.
419 * When our fill buffer has been filled, it is appended to the 'full'
421 * If a frame is needed by read() or mmap(), it is taken from the head of
422 the 'full' list, handled, and then appended to the 'empty' list. If no
423 buffer is present on the 'full' list, we wait.
424 The advantage is that the buffer that is currently being decompressed/
425 converted, is on neither list, and thus not in our way (any other scheme
426 I tried had the problem of old data lingering in the queue).
428 Whatever strategy you choose, it always remains a tradeoff: with more
429 frame buffers the chances of a missed frame are reduced. On the other
430 hand, on slower machines it introduces lag because the queue will
435 \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.
437 static int pwc_next_fill_frame(struct pwc_device *pdev)
443 spin_lock_irqsave(&pdev->ptrlock, flags);
444 if (pdev->fill_frame != NULL) {
445 /* append to 'full' list */
446 if (pdev->full_frames == NULL) {
447 pdev->full_frames = pdev->fill_frame;
448 pdev->full_frames_tail = pdev->full_frames;
451 pdev->full_frames_tail->next = pdev->fill_frame;
452 pdev->full_frames_tail = pdev->fill_frame;
455 if (pdev->empty_frames != NULL) {
456 /* We have empty frames available. That's easy */
457 pdev->fill_frame = pdev->empty_frames;
458 pdev->empty_frames = pdev->empty_frames->next;
461 /* Hmm. Take it from the full list */
463 if (pdev->full_frames == NULL) {
464 PWC_ERROR("Neither empty or full frames available!\n");
465 spin_unlock_irqrestore(&pdev->ptrlock, flags);
468 pdev->fill_frame = pdev->full_frames;
469 pdev->full_frames = pdev->full_frames->next;
472 pdev->fill_frame->next = NULL;
473 spin_unlock_irqrestore(&pdev->ptrlock, flags);
479 \brief Reset all buffers, pointers and lists, except for the image_used[] buffer.
481 If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble.
483 static void pwc_reset_buffers(struct pwc_device *pdev)
488 PWC_DEBUG_MEMORY(">> %s __enter__\n", __func__);
490 spin_lock_irqsave(&pdev->ptrlock, flags);
491 pdev->full_frames = NULL;
492 pdev->full_frames_tail = NULL;
493 for (i = 0; i < default_fbufs; i++) {
494 pdev->fbuf[i].filled = 0;
496 pdev->fbuf[i].next = &pdev->fbuf[i - 1];
498 pdev->fbuf->next = NULL;
500 pdev->empty_frames = &pdev->fbuf[default_fbufs - 1];
501 pdev->empty_frames_tail = pdev->fbuf;
502 pdev->read_frame = NULL;
503 pdev->fill_frame = pdev->empty_frames;
504 pdev->empty_frames = pdev->empty_frames->next;
506 pdev->image_read_pos = 0;
507 pdev->fill_image = 0;
508 spin_unlock_irqrestore(&pdev->ptrlock, flags);
510 PWC_DEBUG_MEMORY("<< %s __leaving__\n", __func__);
515 \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.
517 int pwc_handle_frame(struct pwc_device *pdev)
522 spin_lock_irqsave(&pdev->ptrlock, flags);
523 /* First grab our read_frame; this is removed from all lists, so
524 we can release the lock after this without problems */
525 if (pdev->read_frame != NULL) {
526 /* This can't theoretically happen */
527 PWC_ERROR("Huh? Read frame still in use?\n");
528 spin_unlock_irqrestore(&pdev->ptrlock, flags);
533 if (pdev->full_frames == NULL) {
534 PWC_ERROR("Woops. No frames ready.\n");
537 pdev->read_frame = pdev->full_frames;
538 pdev->full_frames = pdev->full_frames->next;
539 pdev->read_frame->next = NULL;
542 if (pdev->read_frame != NULL) {
543 /* Decompression is a lengthy process, so it's outside of the lock.
544 This gives the isoc_handler the opportunity to fill more frames
547 spin_unlock_irqrestore(&pdev->ptrlock, flags);
548 ret = pwc_decompress(pdev);
549 spin_lock_irqsave(&pdev->ptrlock, flags);
551 /* We're done with read_buffer, tack it to the end of the empty buffer list */
552 if (pdev->empty_frames == NULL) {
553 pdev->empty_frames = pdev->read_frame;
554 pdev->empty_frames_tail = pdev->empty_frames;
557 pdev->empty_frames_tail->next = pdev->read_frame;
558 pdev->empty_frames_tail = pdev->read_frame;
560 pdev->read_frame = NULL;
562 spin_unlock_irqrestore(&pdev->ptrlock, flags);
567 \brief Advance pointers of image buffer (after each user request)
569 void pwc_next_image(struct pwc_device *pdev)
571 pdev->image_used[pdev->fill_image] = 0;
572 pdev->fill_image = (pdev->fill_image + 1) % pwc_mbufs;
576 * Print debug information when a frame is discarded because all of our buffer
579 static void pwc_frame_dumped(struct pwc_device *pdev)
581 pdev->vframes_dumped++;
582 if (pdev->vframe_count < FRAME_LOWMARK)
585 if (pdev->vframes_dumped < 20)
586 PWC_DEBUG_FLOW("Dumping frame %d\n", pdev->vframe_count);
587 else if (pdev->vframes_dumped == 20)
588 PWC_DEBUG_FLOW("Dumping frame %d (last message)\n",
592 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
595 PWC_TRACE("Snapshot button pressed.\n");
596 pdev->snapshot_button_status = 1;
598 PWC_TRACE("Snapshot button released.\n");
601 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
602 if (pdev->button_dev) {
603 input_report_key(pdev->button_dev, KEY_CAMERA, down);
604 input_sync(pdev->button_dev);
609 static int pwc_rcv_short_packet(struct pwc_device *pdev, const struct pwc_frame_buf *fbuf)
613 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
614 frames on the USB wire after an exposure change. This conditition is
615 however detected in the cam and a bit is set in the header.
617 if (pdev->type == 730) {
618 unsigned char *ptr = (unsigned char *)fbuf->data;
620 if (ptr[1] == 1 && ptr[0] & 0x10) {
621 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
622 pdev->drop_frames += 2;
623 pdev->vframes_error++;
625 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
626 pwc_snapshot_button(pdev, ptr[0] & 0x01);
628 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
630 PWC_TRACE("Image is mirrored.\n");
632 PWC_TRACE("Image is normal.\n");
634 pdev->vmirror = ptr[0] & 0x03;
635 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
636 after a short frame; this condition is filtered out specifically. A 4 byte
637 frame doesn't make sense anyway.
638 So we get either this sequence:
639 drop_bit set -> 4 byte frame -> short frame -> good frame
641 drop_bit set -> short frame -> good frame
642 So we drop either 3 or 2 frames in all!
644 if (fbuf->filled == 4)
647 else if (pdev->type == 740 || pdev->type == 720) {
648 unsigned char *ptr = (unsigned char *)fbuf->data;
649 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
650 pwc_snapshot_button(pdev, ptr[0] & 0x01);
652 pdev->vmirror = ptr[0] & 0x03;
655 /* In case we were instructed to drop the frame, do so silently.
656 The buffer pointers are not updated either (but the counters are reset below).
658 if (pdev->drop_frames > 0)
661 /* Check for underflow first */
662 if (fbuf->filled < pdev->frame_total_size) {
663 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
664 " discarded.\n", fbuf->filled);
665 pdev->vframes_error++;
668 /* Send only once per EOF */
669 awake = 1; /* delay wake_ups */
671 /* Find our next frame to fill. This will always succeed, since we
672 * nick a frame from either empty or full list, but if we had to
673 * take it from the full list, it means a frame got dropped.
675 if (pwc_next_fill_frame(pdev))
676 pwc_frame_dumped(pdev);
680 pdev->vframe_count++;
684 /* This gets called for the Isochronous pipe (video). This is done in
685 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
687 static void pwc_isoc_handler(struct urb *urb)
689 struct pwc_device *pdev;
692 struct pwc_frame_buf *fbuf;
693 unsigned char *fillptr = NULL, *iso_buf = NULL;
696 pdev = (struct pwc_device *)urb->context;
698 PWC_ERROR("isoc_handler() called with NULL device?!\n");
702 if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
703 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
706 if (urb->status != -EINPROGRESS && urb->status != 0) {
710 switch(urb->status) {
711 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
712 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
713 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
714 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
715 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
716 case -ETIME: errmsg = "Device does not respond"; break;
718 PWC_DEBUG_FLOW("pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
719 /* Give up after a number of contiguous errors on the USB bus.
720 Appearantly something is wrong so we simulate an unplug event.
722 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
724 PWC_INFO("Too many ISOC errors, bailing out.\n");
725 pdev->error_status = EIO;
727 wake_up_interruptible(&pdev->frameq);
729 goto handler_end; // ugly, but practical
732 fbuf = pdev->fill_frame;
734 PWC_ERROR("pwc_isoc_handler without valid fill frame.\n");
739 fillptr = fbuf->data + fbuf->filled;
742 /* Reset ISOC error counter. We did get here, after all. */
743 pdev->visoc_errors = 0;
745 /* vsync: 0 = don't copy data
750 for (i = 0; i < urb->number_of_packets; i++) {
751 fst = urb->iso_frame_desc[i].status;
752 flen = urb->iso_frame_desc[i].actual_length;
753 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
755 if (flen > 0) { /* if valid data... */
756 if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */
759 /* ...copy data to frame buffer, if possible */
760 if (flen + fbuf->filled > pdev->frame_total_size) {
761 PWC_DEBUG_FLOW("Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen, pdev->frame_total_size);
762 pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */
763 pdev->vframes_error++;
766 memmove(fillptr, iso_buf, flen);
770 fbuf->filled += flen;
773 if (flen < pdev->vlast_packet_size) {
774 /* Shorter packet... We probably have the end of an image-frame;
775 wake up read() process and let select()/poll() do something.
776 Decompression is done in user time over there.
778 if (pdev->vsync == 2) {
779 if (pwc_rcv_short_packet(pdev, fbuf)) {
781 fbuf = pdev->fill_frame;
785 fillptr = fbuf->data;
789 pdev->vlast_packet_size = flen;
790 } /* ..status == 0 */
792 /* This is normally not interesting to the user, unless
793 * you are really debugging something, default = 0 */
794 static int iso_error;
797 PWC_DEBUG_FLOW("Iso frame %d of USB has error %d\n", i, fst);
803 wake_up_interruptible(&pdev->frameq);
805 urb->dev = pdev->udev;
806 i = usb_submit_urb(urb, GFP_ATOMIC);
808 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
812 int pwc_isoc_init(struct pwc_device *pdev)
814 struct usb_device *udev;
818 struct usb_interface *intf;
819 struct usb_host_interface *idesc = NULL;
828 /* Get the current alternate interface, adjust packet size */
829 if (!udev->actconfig)
831 intf = usb_ifnum_to_if(udev, 0);
833 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
838 /* Search video endpoint */
839 pdev->vmax_packet_size = -1;
840 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
841 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
842 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
847 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
848 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
849 return -ENFILE; /* Odd error, that should be noticeable */
852 /* Set alternate interface */
854 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
855 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
859 for (i = 0; i < MAX_ISO_BUFS; i++) {
860 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
862 PWC_ERROR("Failed to allocate urb %d\n", i);
866 pdev->sbuf[i].urb = urb;
867 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
870 /* De-allocate in reverse order */
872 usb_free_urb(pdev->sbuf[i].urb);
873 pdev->sbuf[i].urb = NULL;
878 /* init URB structure */
879 for (i = 0; i < MAX_ISO_BUFS; i++) {
880 urb = pdev->sbuf[i].urb;
882 urb->interval = 1; // devik
884 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
885 urb->transfer_flags = URB_ISO_ASAP;
886 urb->transfer_buffer = pdev->sbuf[i].data;
887 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
888 urb->complete = pwc_isoc_handler;
890 urb->start_frame = 0;
891 urb->number_of_packets = ISO_FRAMES_PER_DESC;
892 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
893 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
894 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
899 for (i = 0; i < MAX_ISO_BUFS; i++) {
900 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL);
902 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
904 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->sbuf[i].urb);
909 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
913 static void pwc_iso_stop(struct pwc_device *pdev)
917 /* Unlinking ISOC buffers one by one */
918 for (i = 0; i < MAX_ISO_BUFS; i++) {
921 urb = pdev->sbuf[i].urb;
923 PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb);
929 static void pwc_iso_free(struct pwc_device *pdev)
933 /* Freeing ISOC buffers one by one */
934 for (i = 0; i < MAX_ISO_BUFS; i++) {
937 urb = pdev->sbuf[i].urb;
939 PWC_DEBUG_MEMORY("Freeing URB\n");
941 pdev->sbuf[i].urb = NULL;
946 void pwc_isoc_cleanup(struct pwc_device *pdev)
948 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
951 if (pdev->iso_init == 0)
957 /* Stop camera, but only if we are sure the camera is still there (unplug
958 is signalled by EPIPE)
960 if (pdev->error_status && pdev->error_status != EPIPE) {
961 PWC_DEBUG_OPEN("Setting alternate interface 0.\n");
962 usb_set_interface(pdev->udev, 0, 0);
966 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
972 static struct pwc_device *cd_to_pwc(struct device *cd)
974 struct video_device *vdev = to_video_device(cd);
975 return video_get_drvdata(vdev);
978 static ssize_t show_pan_tilt(struct device *class_dev,
979 struct device_attribute *attr, char *buf)
981 struct pwc_device *pdev = cd_to_pwc(class_dev);
982 return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
985 static ssize_t store_pan_tilt(struct device *class_dev,
986 struct device_attribute *attr,
987 const char *buf, size_t count)
989 struct pwc_device *pdev = cd_to_pwc(class_dev);
993 if (strncmp(buf, "reset", 5) == 0)
994 ret = pwc_mpt_reset(pdev, 0x3);
996 else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
997 ret = pwc_mpt_set_angle(pdev, pan, tilt);
1003 static DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
1006 static ssize_t show_snapshot_button_status(struct device *class_dev,
1007 struct device_attribute *attr, char *buf)
1009 struct pwc_device *pdev = cd_to_pwc(class_dev);
1010 int status = pdev->snapshot_button_status;
1011 pdev->snapshot_button_status = 0;
1012 return sprintf(buf, "%d\n", status);
1015 static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
1018 static int pwc_create_sysfs_files(struct video_device *vdev)
1020 struct pwc_device *pdev = video_get_drvdata(vdev);
1023 rc = device_create_file(&vdev->dev, &dev_attr_button);
1026 if (pdev->features & FEATURE_MOTOR_PANTILT) {
1027 rc = device_create_file(&vdev->dev, &dev_attr_pan_tilt);
1035 device_remove_file(&vdev->dev, &dev_attr_button);
1037 PWC_ERROR("Could not create sysfs files.\n");
1041 static void pwc_remove_sysfs_files(struct video_device *vdev)
1043 struct pwc_device *pdev = video_get_drvdata(vdev);
1045 if (pdev->features & FEATURE_MOTOR_PANTILT)
1046 device_remove_file(&vdev->dev, &dev_attr_pan_tilt);
1047 device_remove_file(&vdev->dev, &dev_attr_button);
1050 #ifdef CONFIG_USB_PWC_DEBUG
1051 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
1053 switch(sensor_type) {
1055 return "Hyundai CMOS sensor";
1057 return "Sony CCD sensor + TDA8787";
1059 return "Sony CCD sensor + Exas 98L59";
1061 return "Sony CCD sensor + ADI 9804";
1063 return "Sharp CCD sensor + TDA8787";
1065 return "Sharp CCD sensor + Exas 98L59";
1067 return "Sharp CCD sensor + ADI 9804";
1069 return "UPA 1021 sensor";
1071 return "VGA sensor";
1073 return "PAL MR sensor";
1075 return "unknown type of sensor";
1080 /***************************************************************************/
1081 /* Video4Linux functions */
1083 static int pwc_video_open(struct file *file)
1086 struct video_device *vdev = video_devdata(file);
1087 struct pwc_device *pdev;
1089 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
1091 pdev = video_get_drvdata(vdev);
1094 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1098 mutex_lock(&pdev->modlock);
1099 pwc_construct(pdev); /* set min/max sizes correct */
1100 if (!pdev->usb_init) {
1101 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1104 /* Query sensor type */
1105 ret = pwc_get_cmos_sensor(pdev, &i);
1108 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1110 pwc_sensor_type_to_string(i), i);
1114 /* Turn on camera */
1116 i = pwc_camera_power(pdev, 1);
1118 PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
1120 /* Set LED on/off time */
1121 if (pwc_set_leds(pdev, led_on, led_off) < 0)
1122 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1125 /* So far, so good. Allocate memory. */
1126 i = pwc_allocate_buffers(pdev);
1128 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1129 pwc_free_buffers(pdev);
1130 mutex_unlock(&pdev->modlock);
1134 /* Reset buffers & parameters */
1135 pwc_reset_buffers(pdev);
1136 for (i = 0; i < pwc_mbufs; i++)
1137 pdev->image_used[i] = 0;
1138 pdev->vframe_count = 0;
1139 pdev->vframes_dumped = 0;
1140 pdev->vframes_error = 0;
1141 pdev->visoc_errors = 0;
1142 pdev->error_status = 0;
1143 pwc_construct(pdev); /* set min/max sizes correct */
1145 /* Set some defaults */
1146 pdev->vsnapshot = 0;
1148 /* Set video size, first try the last used video size
1149 (or the default one); if that fails try QCIF/10 or QSIF/10;
1150 it that fails too, give up.
1152 i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1154 unsigned int default_resolution;
1155 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1156 if (pdev->type>= 730)
1157 default_resolution = PSZ_QSIF;
1159 default_resolution = PSZ_QCIF;
1161 i = pwc_set_video_mode(pdev,
1162 pwc_image_sizes[default_resolution].x,
1163 pwc_image_sizes[default_resolution].y,
1169 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1170 pwc_free_buffers(pdev);
1171 mutex_unlock(&pdev->modlock);
1175 /* Initialize the webcam to sane value */
1176 pwc_set_brightness(pdev, 0x7fff);
1177 pwc_set_agc(pdev, 1, 0);
1180 file->private_data = vdev;
1181 mutex_unlock(&pdev->modlock);
1182 PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1187 static void pwc_cleanup(struct pwc_device *pdev)
1189 pwc_remove_sysfs_files(pdev->vdev);
1190 video_unregister_device(pdev->vdev);
1192 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1193 if (pdev->button_dev)
1194 input_unregister_device(pdev->button_dev);
1200 /* Note that all cleanup is done in the reverse order as in _open */
1201 static int pwc_video_close(struct file *file)
1203 struct video_device *vdev = file->private_data;
1204 struct pwc_device *pdev;
1207 PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
1209 pdev = video_get_drvdata(vdev);
1210 mutex_lock(&pdev->modlock);
1211 if (pdev->vopen == 0)
1212 PWC_DEBUG_MODULE("video_close() called on closed device?\n");
1214 /* Dump statistics, but only if a reasonable amount of frames were
1215 processed (to prevent endless log-entries in case of snap-shot
1218 if (pdev->vframe_count > 20)
1219 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);
1221 if (DEVICE_USE_CODEC1(pdev->type))
1226 pwc_isoc_cleanup(pdev);
1227 pwc_free_buffers(pdev);
1229 /* Turn off LEDS and power down camera, but only when not unplugged */
1230 if (!pdev->unplugged) {
1232 if (pwc_set_leds(pdev, 0, 0) < 0)
1233 PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
1235 i = pwc_camera_power(pdev, 0);
1237 PWC_ERROR("Failed to power down camera (%d)\n", i);
1240 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
1243 /* search device_hint[] table if we occupy a slot, by any chance */
1244 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1245 if (device_hint[hint].pdev == pdev)
1246 device_hint[hint].pdev = NULL;
1248 mutex_unlock(&pdev->modlock);
1254 * FIXME: what about two parallel reads ????
1255 * ANSWER: Not supported. You can't open the device more than once,
1256 despite what the V4L1 interface says. First, I don't see
1257 the need, second there's no mechanism of alerting the
1258 2nd/3rd/... process of events like changing image size.
1259 And I don't see the point of blocking that for the
1260 2nd/3rd/... process.
1261 In multi-threaded environments reading parallel from any
1262 device is tricky anyhow.
1265 static ssize_t pwc_video_read(struct file *file, char __user *buf,
1266 size_t count, loff_t *ppos)
1268 struct video_device *vdev = file->private_data;
1269 struct pwc_device *pdev;
1270 int noblock = file->f_flags & O_NONBLOCK;
1271 DECLARE_WAITQUEUE(wait, current);
1272 int bytes_to_read, rv = 0;
1273 void *image_buffer_addr;
1275 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1279 pdev = video_get_drvdata(vdev);
1283 mutex_lock(&pdev->modlock);
1284 if (pdev->error_status) {
1285 rv = -pdev->error_status; /* Something happened, report what. */
1289 /* Start the stream (if not already started) */
1290 rv = pwc_isoc_init(pdev);
1294 /* In case we're doing partial reads, we don't have to wait for a frame */
1295 if (pdev->image_read_pos == 0) {
1296 /* Do wait queueing according to the (doc)book */
1297 add_wait_queue(&pdev->frameq, &wait);
1298 while (pdev->full_frames == NULL) {
1299 /* Check for unplugged/etc. here */
1300 if (pdev->error_status) {
1301 remove_wait_queue(&pdev->frameq, &wait);
1302 set_current_state(TASK_RUNNING);
1303 rv = -pdev->error_status ;
1307 remove_wait_queue(&pdev->frameq, &wait);
1308 set_current_state(TASK_RUNNING);
1312 if (signal_pending(current)) {
1313 remove_wait_queue(&pdev->frameq, &wait);
1314 set_current_state(TASK_RUNNING);
1319 set_current_state(TASK_INTERRUPTIBLE);
1321 remove_wait_queue(&pdev->frameq, &wait);
1322 set_current_state(TASK_RUNNING);
1324 /* Decompress and release frame */
1325 if (pwc_handle_frame(pdev)) {
1331 PWC_DEBUG_READ("Copying data to user space.\n");
1332 if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
1333 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1335 bytes_to_read = pdev->view.size;
1337 /* copy bytes to user space; we allow for partial reads */
1338 if (count + pdev->image_read_pos > bytes_to_read)
1339 count = bytes_to_read - pdev->image_read_pos;
1340 image_buffer_addr = pdev->image_data;
1341 image_buffer_addr += pdev->images[pdev->fill_image].offset;
1342 image_buffer_addr += pdev->image_read_pos;
1343 if (copy_to_user(buf, image_buffer_addr, count)) {
1347 pdev->image_read_pos += count;
1348 if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
1349 pdev->image_read_pos = 0;
1350 pwc_next_image(pdev);
1352 mutex_unlock(&pdev->modlock);
1355 mutex_unlock(&pdev->modlock);
1359 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1361 struct video_device *vdev = file->private_data;
1362 struct pwc_device *pdev;
1367 pdev = video_get_drvdata(vdev);
1371 /* Start the stream (if not already started) */
1372 mutex_lock(&pdev->modlock);
1373 ret = pwc_isoc_init(pdev);
1374 mutex_unlock(&pdev->modlock);
1378 poll_wait(file, &pdev->frameq, wait);
1379 if (pdev->error_status)
1381 if (pdev->full_frames != NULL) /* we have frames waiting */
1382 return (POLLIN | POLLRDNORM);
1387 static long pwc_video_ioctl(struct file *file,
1388 unsigned int cmd, unsigned long arg)
1390 struct video_device *vdev = file->private_data;
1391 struct pwc_device *pdev;
1396 pdev = video_get_drvdata(vdev);
1398 mutex_lock(&pdev->modlock);
1399 if (!pdev->unplugged)
1400 r = video_usercopy(file, cmd, arg, pwc_video_do_ioctl);
1401 mutex_unlock(&pdev->modlock);
1406 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1408 struct video_device *vdev = file->private_data;
1409 struct pwc_device *pdev;
1410 unsigned long start;
1412 unsigned long page, pos = 0;
1415 PWC_DEBUG_MEMORY(">> %s\n", __func__);
1416 pdev = video_get_drvdata(vdev);
1417 size = vma->vm_end - vma->vm_start;
1418 start = vma->vm_start;
1420 /* Find the idx buffer for this mapping */
1421 for (index = 0; index < pwc_mbufs; index++) {
1422 pos = pdev->images[index].offset;
1423 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1426 if (index == MAX_IMAGES)
1430 * Special case for v4l1. In v4l1, we map only one big buffer,
1431 * but in v4l2 each buffer is mapped
1433 unsigned long total_size;
1434 total_size = pwc_mbufs * pdev->len_per_image;
1435 if (size != pdev->len_per_image && size != total_size) {
1436 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1437 size, pdev->len_per_image, total_size);
1440 } else if (size > pdev->len_per_image)
1443 vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
1445 pos += (unsigned long)pdev->image_data;
1447 page = vmalloc_to_pfn((void *)pos);
1448 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1452 if (size > PAGE_SIZE)
1460 /***************************************************************************/
1463 /* This function gets called when a new device is plugged in or the usb core
1467 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1469 struct usb_device *udev = interface_to_usbdev(intf);
1470 struct pwc_device *pdev = NULL;
1471 int vendor_id, product_id, type_id;
1474 int video_nr = -1; /* default: use next available device */
1475 char serial_number[30], *name;
1477 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1478 product_id = le16_to_cpu(udev->descriptor.idProduct);
1480 /* Check if we can handle this device */
1481 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1482 vendor_id, product_id,
1483 intf->altsetting->desc.bInterfaceNumber);
1485 /* the interfaces are probed one by one. We are only interested in the
1486 video interface (0) now.
1487 Interface 1 is the Audio Control, and interface 2 Audio itself.
1489 if (intf->altsetting->desc.bInterfaceNumber > 0)
1492 if (vendor_id == 0x0471) {
1493 switch (product_id) {
1495 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1496 name = "Philips 645 webcam";
1500 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1501 name = "Philips 646 webcam";
1505 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1506 name = "Askey VC010 webcam";
1510 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1511 name = "Philips 675 webcam";
1515 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1516 name = "Philips 680 webcam";
1520 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1521 name = "Philips 690 webcam";
1525 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1526 name = "Philips 730 webcam";
1530 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1531 name = "Philips 740 webcam";
1535 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1536 name = "Philips 750 webcam";
1540 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1541 name = "Philips 720K/40 webcam";
1545 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1546 name = "Philips SPC 900NC webcam";
1554 else if (vendor_id == 0x069A) {
1555 switch(product_id) {
1557 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1558 name = "Askey VC010 webcam";
1566 else if (vendor_id == 0x046d) {
1567 switch(product_id) {
1569 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1570 name = "Logitech QuickCam Pro 3000";
1571 type_id = 740; /* CCD sensor */
1574 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1575 name = "Logitech QuickCam Notebook Pro";
1576 type_id = 740; /* CCD sensor */
1579 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1580 name = "Logitech QuickCam Pro 4000";
1581 type_id = 740; /* CCD sensor */
1584 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1585 name = "Logitech QuickCam Zoom";
1586 type_id = 740; /* CCD sensor */
1589 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1590 name = "Logitech QuickCam Zoom";
1591 type_id = 740; /* CCD sensor */
1595 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1596 name = "Logitech QuickCam Orbit";
1597 type_id = 740; /* CCD sensor */
1598 features |= FEATURE_MOTOR_PANTILT;
1601 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1602 name = "Cisco VT Camera";
1603 type_id = 740; /* CCD sensor */
1606 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1607 name = "Logitech ViewPort AV 100";
1608 type_id = 740; /* CCD sensor */
1610 case 0x08b8: /* Where this released? */
1611 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1612 name = "Logitech QuickCam (res.)";
1613 type_id = 730; /* Assuming CMOS */
1620 else if (vendor_id == 0x055d) {
1621 /* I don't know the difference between the C10 and the C30;
1622 I suppose the difference is the sensor, but both cameras
1623 work equally well with a type_id of 675
1625 switch(product_id) {
1627 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1628 name = "Samsung MPC-C10";
1632 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1633 name = "Samsung MPC-C30";
1637 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1638 name = "Samsung MPC-C30";
1646 else if (vendor_id == 0x041e) {
1647 switch(product_id) {
1649 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1650 name = "Creative Labs Webcam 5";
1654 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1655 name = "Creative Labs Webcam Pro Ex";
1663 else if (vendor_id == 0x04cc) {
1664 switch(product_id) {
1666 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1667 name = "Sotec Afina Eye";
1675 else if (vendor_id == 0x06be) {
1676 switch(product_id) {
1678 /* This is essentially the same cam as the Sotec Afina Eye */
1679 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1680 name = "AME Co. Afina Eye";
1689 else if (vendor_id == 0x0d81) {
1690 switch(product_id) {
1692 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1693 name = "Visionite VCS-UC300";
1694 type_id = 740; /* CCD sensor */
1697 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1698 name = "Visionite VCS-UM100";
1699 type_id = 730; /* CMOS sensor */
1707 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1709 memset(serial_number, 0, 30);
1710 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1711 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1713 if (udev->descriptor.bNumConfigurations > 1)
1714 PWC_WARNING("Warning: more than 1 configuration available.\n");
1716 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1717 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1719 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1722 pdev->type = type_id;
1723 pdev->vsize = default_size;
1724 pdev->vframes = default_fps;
1725 strcpy(pdev->serial, serial_number);
1726 pdev->features = features;
1727 if (vendor_id == 0x046D && product_id == 0x08B5) {
1728 /* Logitech QuickCam Orbit
1729 The ranges have been determined experimentally; they may differ from cam to cam.
1730 Also, the exact ranges left-right and up-down are different for my cam
1732 pdev->angle_range.pan_min = -7000;
1733 pdev->angle_range.pan_max = 7000;
1734 pdev->angle_range.tilt_min = -3000;
1735 pdev->angle_range.tilt_max = 2500;
1738 mutex_init(&pdev->modlock);
1739 spin_lock_init(&pdev->ptrlock);
1742 init_waitqueue_head(&pdev->frameq);
1743 pdev->vcompression = pwc_preferred_compression;
1745 /* Allocate video_device structure */
1746 pdev->vdev = video_device_alloc();
1748 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
1752 memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
1753 pdev->vdev->parent = &intf->dev;
1754 strcpy(pdev->vdev->name, name);
1755 video_set_drvdata(pdev->vdev, pdev);
1757 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1758 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1760 /* Now search device_hint[] table for a match, so we can hint a node number. */
1761 for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1762 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1763 (device_hint[hint].pdev == NULL)) {
1764 /* so far, so good... try serial number */
1765 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1767 video_nr = device_hint[hint].device_node;
1768 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1774 pdev->vdev->release = video_device_release;
1777 if (hint < MAX_DEV_HINTS)
1778 device_hint[hint].pdev = pdev;
1780 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1781 usb_set_intfdata(intf, pdev);
1783 /* Set the leds off */
1784 pwc_set_leds(pdev, 0, 0);
1785 pwc_camera_power(pdev, 0);
1787 rc = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1789 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1790 goto err_video_release;
1792 rc = pwc_create_sysfs_files(pdev->vdev);
1794 goto err_video_unreg;
1796 PWC_INFO("Registered as %s.\n", video_device_node_name(pdev->vdev));
1798 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1799 /* register webcam snapshot button input device */
1800 pdev->button_dev = input_allocate_device();
1801 if (!pdev->button_dev) {
1802 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1804 pwc_remove_sysfs_files(pdev->vdev);
1805 goto err_video_unreg;
1808 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1809 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1811 pdev->button_dev->name = "PWC snapshot button";
1812 pdev->button_dev->phys = pdev->button_phys;
1813 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1814 pdev->button_dev->dev.parent = &pdev->udev->dev;
1815 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1816 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1818 rc = input_register_device(pdev->button_dev);
1820 input_free_device(pdev->button_dev);
1821 pdev->button_dev = NULL;
1822 pwc_remove_sysfs_files(pdev->vdev);
1823 goto err_video_unreg;
1830 if (hint < MAX_DEV_HINTS)
1831 device_hint[hint].pdev = NULL;
1832 video_unregister_device(pdev->vdev);
1833 pdev->vdev = NULL; /* So we don't try to release it below */
1835 video_device_release(pdev->vdev);
1841 /* The user yanked out the cable... */
1842 static void usb_pwc_disconnect(struct usb_interface *intf)
1844 struct pwc_device *pdev;
1847 pdev = usb_get_intfdata (intf);
1848 mutex_lock(&pdev->modlock);
1849 usb_set_intfdata (intf, NULL);
1851 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1852 goto disconnect_out;
1854 if (pdev->udev == NULL) {
1855 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1856 goto disconnect_out;
1858 if (pdev->udev != interface_to_usbdev(intf)) {
1859 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1860 goto disconnect_out;
1863 /* We got unplugged; this is signalled by an EPIPE error code */
1865 PWC_INFO("Disconnected while webcam is in use!\n");
1866 pdev->error_status = EPIPE;
1869 /* Alert waiting processes */
1870 wake_up_interruptible(&pdev->frameq);
1871 /* Wait until device is closed */
1873 pdev->unplugged = 1;
1876 /* Device is closed, so we can safely unregister it */
1877 PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
1881 /* search device_hint[] table if we occupy a slot, by any chance */
1882 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1883 if (device_hint[hint].pdev == pdev)
1884 device_hint[hint].pdev = NULL;
1887 mutex_unlock(&pdev->modlock);
1892 * Initialization code & module stuff
1899 static int compression = -1;
1900 static int leds[2] = { -1, -1 };
1901 static unsigned int leds_nargs;
1902 static char *dev_hint[MAX_DEV_HINTS];
1903 static unsigned int dev_hint_nargs;
1905 module_param(size, charp, 0444);
1906 module_param(fps, int, 0444);
1907 module_param(fbufs, int, 0444);
1908 module_param(mbufs, int, 0444);
1909 #ifdef CONFIG_USB_PWC_DEBUG
1910 module_param_named(trace, pwc_trace, int, 0644);
1912 module_param(power_save, int, 0444);
1913 module_param(compression, int, 0444);
1914 module_param_array(leds, int, &leds_nargs, 0444);
1915 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1917 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1918 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1919 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1920 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1921 #ifdef CONFIG_USB_PWC_DEBUG
1922 MODULE_PARM_DESC(trace, "For debugging purposes");
1924 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1925 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1926 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1927 MODULE_PARM_DESC(dev_hint, "Device node hints");
1929 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1930 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1931 MODULE_LICENSE("GPL");
1932 MODULE_ALIAS("pwcx");
1933 MODULE_VERSION( PWC_VERSION );
1935 static int __init usb_pwc_init(void)
1938 char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1940 PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1941 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1942 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1943 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1946 if (fps < 4 || fps > 30) {
1947 PWC_ERROR("Framerate out of bounds (4-30).\n");
1951 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1955 /* string; try matching with array */
1956 for (sz = 0; sz < PSZ_MAX; sz++) {
1957 if (!strcmp(sizenames[sz], size)) { /* Found! */
1962 if (sz == PSZ_MAX) {
1963 PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1966 PWC_DEBUG_MODULE("Default image size set to %s [%dx%d].\n", sizenames[default_size], pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y);
1969 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1970 PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
1974 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
1977 if (fbufs < 2 || fbufs > MAX_FRAMES) {
1978 PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
1981 default_fbufs = fbufs;
1982 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
1984 #ifdef CONFIG_USB_PWC_DEBUG
1985 if (pwc_trace >= 0) {
1986 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1989 if (compression >= 0) {
1990 if (compression > 3) {
1991 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1994 pwc_preferred_compression = compression;
1995 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
1998 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
2004 /* Big device node whoopla. Basically, it allows you to assign a
2005 device node (/dev/videoX) to a camera, based on its type
2006 & serial number. The format is [type[.serialnumber]:]node.
2008 Any camera that isn't matched by these rules gets the next
2009 available free device node.
2011 for (i = 0; i < MAX_DEV_HINTS; i++) {
2012 char *s, *colon, *dot;
2014 /* This loop also initializes the array */
2015 device_hint[i].pdev = NULL;
2017 if (s != NULL && *s != '\0') {
2018 device_hint[i].type = -1; /* wildcard */
2019 strcpy(device_hint[i].serial_number, "*");
2021 /* parse string: chop at ':' & '/' */
2023 while (*colon != '\0' && *colon != ':')
2025 while (*dot != '\0' && *dot != '.')
2027 /* Few sanity checks */
2028 if (*dot != '\0' && dot > colon) {
2029 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
2033 if (*colon == '\0') {
2036 PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
2040 /* No type or serial number specified, just a number. */
2041 device_hint[i].device_node =
2042 simple_strtol(s, NULL, 10);
2046 /* There's a colon, so we have at least a type and a device node */
2047 device_hint[i].type =
2048 simple_strtol(s, NULL, 10);
2049 device_hint[i].device_node =
2050 simple_strtol(colon + 1, NULL, 10);
2052 /* There's a serial number as well */
2057 while (*dot != ':' && k < 29) {
2058 device_hint[i].serial_number[k++] = *dot;
2061 device_hint[i].serial_number[k] = '\0';
2064 PWC_TRACE("device_hint[%d]:\n", i);
2065 PWC_TRACE(" type : %d\n", device_hint[i].type);
2066 PWC_TRACE(" serial# : %s\n", device_hint[i].serial_number);
2067 PWC_TRACE(" node : %d\n", device_hint[i].device_node);
2070 device_hint[i].type = 0; /* not filled */
2071 } /* ..for MAX_DEV_HINTS */
2073 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
2074 return usb_register(&pwc_driver);
2077 static void __exit usb_pwc_exit(void)
2079 PWC_DEBUG_MODULE("Deregistering driver.\n");
2080 usb_deregister(&pwc_driver);
2081 PWC_INFO("Philips webcam module removed.\n");
2084 module_init(usb_pwc_init);
2085 module_exit(usb_pwc_exit);
2087 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */