1 /* Linux driver for Philips webcam
2 USB and Video4Linux interface part.
3 (C) 1999-2003 Nemosoft Unv.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 This code forms the interface between the USB layers and the Philips
23 specific stuff. Some adanved stuff of the driver falls under an
24 NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
25 is thus not distributed in source form. The binary pwcx.o module
26 contains the code that falls under the NDA.
28 In case you're wondering: 'pwc' stands for "Philips WebCam", but
29 I really didn't want to type 'philips_web_cam' every time (I'm lazy as
30 any Linux kernel hacker, but I don't like uncomprehensible abbreviations
33 Oh yes, convention: to disctinguish between all the various pointers to
34 device-structures, I use these names for the pointer variables:
35 udev: struct usb_device *
36 vdev: struct video_device *
37 pdev: struct pwc_devive *
41 - Alvarado: adding whitebalance code
42 - Alistar Moire: QuickCam 3000 Pro device/product ID
43 - Tony Hoyle: Creative Labs Webcam 5 device/product ID
44 - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
45 - Jk Fang: SOTEC Afina Eye ID
46 - Xavier Roche: QuickCam Pro 4000 ID
47 - Jens Knudsen: QuickCam Zoom ID
48 - J. Debert: QuickCam for Notebooks ID
51 #include <linux/errno.h>
52 #include <linux/init.h>
54 #include <linux/module.h>
55 #include <linux/poll.h>
56 #include <linux/slab.h>
57 #include <linux/vmalloc.h>
61 #include "pwc-ioctl.h"
62 #include "pwc-uncompress.h"
64 /* Function prototypes and driver templates */
66 /* hotplug device table support */
67 static struct usb_device_id pwc_device_table [] = {
68 { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */
69 { USB_DEVICE(0x0471, 0x0303) },
70 { USB_DEVICE(0x0471, 0x0304) },
71 { USB_DEVICE(0x0471, 0x0307) },
72 { USB_DEVICE(0x0471, 0x0308) },
73 { USB_DEVICE(0x0471, 0x030C) },
74 { USB_DEVICE(0x0471, 0x0310) },
75 { USB_DEVICE(0x0471, 0x0311) },
76 { USB_DEVICE(0x0471, 0x0312) },
77 { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
78 { USB_DEVICE(0x069A, 0x0001) }, /* Askey */
79 { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
80 { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
81 { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
82 { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
83 { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
84 { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
85 { USB_DEVICE(0x046D, 0x08B6) }, /* Logitech (reserved) */
86 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech (reserved) */
87 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
88 { USB_DEVICE(0x055D, 0x9000) }, /* Samsung */
89 { USB_DEVICE(0x055D, 0x9001) },
90 { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
91 { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
92 { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
93 { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
94 { USB_DEVICE(0x0d81, 0x1900) },
97 MODULE_DEVICE_TABLE(usb, pwc_device_table);
99 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
100 static void usb_pwc_disconnect(struct usb_interface *intf);
102 static struct usb_driver pwc_driver = {
103 .owner = THIS_MODULE,
104 .name = "Philips webcam", /* name */
105 .id_table = pwc_device_table,
106 .probe = usb_pwc_probe, /* probe() */
107 .disconnect = usb_pwc_disconnect, /* disconnect() */
110 #define MAX_DEV_HINTS 20
111 #define MAX_ISOC_ERRORS 20
113 static int default_size = PSZ_QCIF;
114 static int default_fps = 10;
115 static int default_fbufs = 3; /* Default number of frame buffers */
116 static int default_mbufs = 2; /* Default number of mmap() buffers */
117 int pwc_trace = TRACE_MODULE | TRACE_FLOW | TRACE_PWCX;
118 static int power_save = 0;
119 static int led_on = 100, led_off = 0; /* defaults to LED that is on while in use */
120 int pwc_preferred_compression = 2; /* 0..3 = uncompressed..high */
123 char serial_number[30];
125 struct pwc_device *pdev;
126 } device_hint[MAX_DEV_HINTS];
130 static int pwc_video_open(struct inode *inode, struct file *file);
131 static int pwc_video_close(struct inode *inode, struct file *file);
132 static ssize_t pwc_video_read(struct file *file, char __user *buf,
133 size_t count, loff_t *ppos);
134 static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
135 static int pwc_video_ioctl(struct inode *inode, struct file *file,
136 unsigned int ioctlnr, unsigned long arg);
137 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
139 static struct file_operations pwc_fops = {
140 .owner = THIS_MODULE,
141 .open = pwc_video_open,
142 .release = pwc_video_close,
143 .read = pwc_video_read,
144 .poll = pwc_video_poll,
145 .mmap = pwc_video_mmap,
146 .ioctl = pwc_video_ioctl,
149 static struct video_device pwc_template = {
150 .owner = THIS_MODULE,
151 .name = "Philips Webcam", /* Filled in later */
152 .type = VID_TYPE_CAPTURE,
153 .hardware = VID_HARDWARE_PWC,
157 /***************************************************************************/
159 /* Okay, this is some magic that I worked out and the reasoning behind it...
161 The biggest problem with any USB device is of course: "what to do
162 when the user unplugs the device while it is in use by an application?"
163 We have several options:
164 1) Curse them with the 7 plagues when they do (requires divine intervention)
165 2) Tell them not to (won't work: they'll do it anyway)
166 3) Oops the kernel (this will have a negative effect on a user's uptime)
167 4) Do something sensible.
169 Of course, we go for option 4.
171 It happens that this device will be linked to two times, once from
172 usb_device and once from the video_device in their respective 'private'
173 pointers. This is done when the device is probed() and all initialization
174 succeeded. The pwc_device struct links back to both structures.
176 When a device is unplugged while in use it will be removed from the
177 list of known USB devices; I also de-register it as a V4L device, but
178 unfortunately I can't free the memory since the struct is still in use
179 by the file descriptor. This free-ing is then deferend until the first
180 opportunity. Crude, but it works.
182 A small 'advantage' is that if a user unplugs the cam and plugs it back
183 in, it should get assigned the same video device minor, but unfortunately
184 it's non-trivial to re-link the cam back to the video device... (that
185 would surely be magic! :))
188 /***************************************************************************/
189 /* Private functions */
191 /* Here we want the physical address of the memory.
192 * This is used when initializing the contents of the area.
194 static inline unsigned long kvirt_to_pa(unsigned long adr)
196 unsigned long kva, ret;
198 kva = (unsigned long) page_address(vmalloc_to_page((void *)adr));
199 kva |= adr & (PAGE_SIZE-1); /* restore the offset */
204 static void * rvmalloc(unsigned long size)
209 size=PAGE_ALIGN(size);
210 mem=vmalloc_32(size);
213 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
214 adr=(unsigned long) mem;
217 SetPageReserved(vmalloc_to_page((void *)adr));
225 static void rvfree(void * mem, unsigned long size)
231 adr=(unsigned long) mem;
232 while ((long) size > 0)
234 ClearPageReserved(vmalloc_to_page((void *)adr));
245 static int pwc_allocate_buffers(struct pwc_device *pdev)
250 Trace(TRACE_MEMORY, ">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev);
256 if (pdev->magic != PWC_MAGIC) {
257 Err("allocate_buffers(): magic failed.\n");
261 /* Allocate Isochronous pipe buffers */
262 for (i = 0; i < MAX_ISO_BUFS; i++) {
263 if (pdev->sbuf[i].data == NULL) {
264 kbuf = kmalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
266 Err("Failed to allocate iso buffer %d.\n", i);
269 Trace(TRACE_MEMORY, "Allocated iso buffer at %p.\n", kbuf);
270 pdev->sbuf[i].data = kbuf;
271 memset(kbuf, 0, ISO_BUFFER_SIZE);
275 /* Allocate frame buffer structure */
276 if (pdev->fbuf == NULL) {
277 kbuf = kmalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);
279 Err("Failed to allocate frame buffer structure.\n");
282 Trace(TRACE_MEMORY, "Allocated frame buffer structure at %p.\n", kbuf);
284 memset(kbuf, 0, default_fbufs * sizeof(struct pwc_frame_buf));
286 /* create frame buffers, and make circular ring */
287 for (i = 0; i < default_fbufs; i++) {
288 if (pdev->fbuf[i].data == NULL) {
289 kbuf = vmalloc(PWC_FRAME_SIZE); /* need vmalloc since frame buffer > 128K */
291 Err("Failed to allocate frame buffer %d.\n", i);
294 Trace(TRACE_MEMORY, "Allocated frame buffer %d at %p.\n", i, kbuf);
295 pdev->fbuf[i].data = kbuf;
296 memset(kbuf, 128, PWC_FRAME_SIZE);
300 /* Allocate decompressor table space */
302 if (pdev->decompressor != NULL) {
303 kbuf = kmalloc(pdev->decompressor->table_size, GFP_KERNEL);
305 Err("Failed to allocate decompress table.\n");
308 Trace(TRACE_MEMORY, "Allocated decompress table %p.\n", kbuf);
310 pdev->decompress_data = kbuf;
312 /* Allocate image buffer; double buffer for mmap() */
313 kbuf = rvmalloc(default_mbufs * pdev->len_per_image);
315 Err("Failed to allocate image buffer(s).\n");
318 Trace(TRACE_MEMORY, "Allocated image buffer at %p.\n", kbuf);
319 pdev->image_data = kbuf;
320 for (i = 0; i < default_mbufs; i++)
321 pdev->image_ptr[i] = kbuf + i * pdev->len_per_image;
322 for (; i < MAX_IMAGES; i++)
323 pdev->image_ptr[i] = NULL;
327 Trace(TRACE_MEMORY, "<< pwc_allocate_buffers()\n");
331 static void pwc_free_buffers(struct pwc_device *pdev)
335 Trace(TRACE_MEMORY, "Entering free_buffers(%p).\n", pdev);
340 if (pdev->magic != PWC_MAGIC) {
341 Err("free_buffers(): magic failed.\n");
346 /* Release Iso-pipe buffers */
347 for (i = 0; i < MAX_ISO_BUFS; i++)
348 if (pdev->sbuf[i].data != NULL) {
349 Trace(TRACE_MEMORY, "Freeing ISO buffer at %p.\n", pdev->sbuf[i].data);
350 kfree(pdev->sbuf[i].data);
351 pdev->sbuf[i].data = NULL;
354 /* The same for frame buffers */
355 if (pdev->fbuf != NULL) {
356 for (i = 0; i < default_fbufs; i++) {
357 if (pdev->fbuf[i].data != NULL) {
358 Trace(TRACE_MEMORY, "Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data);
359 vfree(pdev->fbuf[i].data);
360 pdev->fbuf[i].data = NULL;
367 /* Intermediate decompression buffer & tables */
368 if (pdev->decompress_data != NULL) {
369 Trace(TRACE_MEMORY, "Freeing decompression buffer at %p.\n", pdev->decompress_data);
370 kfree(pdev->decompress_data);
371 pdev->decompress_data = NULL;
373 pdev->decompressor = NULL;
375 /* Release image buffers */
376 if (pdev->image_data != NULL) {
377 Trace(TRACE_MEMORY, "Freeing image buffer at %p.\n", pdev->image_data);
378 rvfree(pdev->image_data, default_mbufs * pdev->len_per_image);
380 pdev->image_data = NULL;
382 Trace(TRACE_MEMORY, "Leaving free_buffers().\n");
385 /* The frame & image buffer mess.
387 Yes, this is a mess. Well, it used to be simple, but alas... In this
388 module, 3 buffers schemes are used to get the data from the USB bus to
389 the user program. The first scheme involves the ISO buffers (called thus
390 since they transport ISO data from the USB controller), and not really
391 interesting. Suffices to say the data from this buffer is quickly
392 gathered in an interrupt handler (pwc_isoc_handler) and placed into the
395 The frame buffer is the second scheme, and is the central element here.
396 It collects the data from a single frame from the camera (hence, the
397 name). Frames are delimited by the USB camera with a short USB packet,
398 so that's easy to detect. The frame buffers form a list that is filled
399 by the camera+USB controller and drained by the user process through
400 either read() or mmap().
402 The image buffer is the third scheme, in which frames are decompressed
403 and converted into planar format. For mmap() there is more than
404 one image buffer available.
406 The frame buffers provide the image buffering. In case the user process
407 is a bit slow, this introduces lag and some undesired side-effects.
408 The problem arises when the frame buffer is full. I used to drop the last
409 frame, which makes the data in the queue stale very quickly. But dropping
410 the frame at the head of the queue proved to be a litte bit more difficult.
411 I tried a circular linked scheme, but this introduced more problems than
414 Because filling and draining are completely asynchronous processes, this
415 requires some fiddling with pointers and mutexes.
417 Eventually, I came up with a system with 2 lists: an 'empty' frame list
418 and a 'full' frame list:
419 * Initially, all frame buffers but one are on the 'empty' list; the one
420 remaining buffer is our initial fill frame.
421 * If a frame is needed for filling, we try to take it from the 'empty'
422 list, unless that list is empty, in which case we take the buffer at
423 the head of the 'full' list.
424 * When our fill buffer has been filled, it is appended to the 'full'
426 * If a frame is needed by read() or mmap(), it is taken from the head of
427 the 'full' list, handled, and then appended to the 'empty' list. If no
428 buffer is present on the 'full' list, we wait.
429 The advantage is that the buffer that is currently being decompressed/
430 converted, is on neither list, and thus not in our way (any other scheme
431 I tried had the problem of old data lingering in the queue).
433 Whatever strategy you choose, it always remains a tradeoff: with more
434 frame buffers the chances of a missed frame are reduced. On the other
435 hand, on slower machines it introduces lag because the queue will
440 \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.
442 static inline int pwc_next_fill_frame(struct pwc_device *pdev)
448 spin_lock_irqsave(&pdev->ptrlock, flags);
449 if (pdev->fill_frame != NULL) {
450 /* append to 'full' list */
451 if (pdev->full_frames == NULL) {
452 pdev->full_frames = pdev->fill_frame;
453 pdev->full_frames_tail = pdev->full_frames;
456 pdev->full_frames_tail->next = pdev->fill_frame;
457 pdev->full_frames_tail = pdev->fill_frame;
460 if (pdev->empty_frames != NULL) {
461 /* We have empty frames available. That's easy */
462 pdev->fill_frame = pdev->empty_frames;
463 pdev->empty_frames = pdev->empty_frames->next;
466 /* Hmm. Take it from the full list */
469 if (pdev->full_frames == NULL) {
470 Err("Neither empty or full frames available!\n");
471 spin_unlock_irqrestore(&pdev->ptrlock, flags);
475 pdev->fill_frame = pdev->full_frames;
476 pdev->full_frames = pdev->full_frames->next;
479 pdev->fill_frame->next = NULL;
481 Trace(TRACE_SEQUENCE, "Assigning sequence number %d.\n", pdev->sequence);
482 pdev->fill_frame->sequence = pdev->sequence++;
484 spin_unlock_irqrestore(&pdev->ptrlock, flags);
490 \brief Reset all buffers, pointers and lists, except for the image_used[] buffer.
492 If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble.
494 static void pwc_reset_buffers(struct pwc_device *pdev)
499 spin_lock_irqsave(&pdev->ptrlock, flags);
500 pdev->full_frames = NULL;
501 pdev->full_frames_tail = NULL;
502 for (i = 0; i < default_fbufs; i++) {
503 pdev->fbuf[i].filled = 0;
505 pdev->fbuf[i].next = &pdev->fbuf[i - 1];
507 pdev->fbuf->next = NULL;
509 pdev->empty_frames = &pdev->fbuf[default_fbufs - 1];
510 pdev->empty_frames_tail = pdev->fbuf;
511 pdev->read_frame = NULL;
512 pdev->fill_frame = pdev->empty_frames;
513 pdev->empty_frames = pdev->empty_frames->next;
515 pdev->image_read_pos = 0;
516 pdev->fill_image = 0;
517 spin_unlock_irqrestore(&pdev->ptrlock, flags);
522 \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.
524 static int pwc_handle_frame(struct pwc_device *pdev)
529 spin_lock_irqsave(&pdev->ptrlock, flags);
530 /* First grab our read_frame; this is removed from all lists, so
531 we can release the lock after this without problems */
532 if (pdev->read_frame != NULL) {
533 /* This can't theoretically happen */
534 Err("Huh? Read frame still in use?\n");
537 if (pdev->full_frames == NULL) {
538 Err("Woops. No frames ready.\n");
541 pdev->read_frame = pdev->full_frames;
542 pdev->full_frames = pdev->full_frames->next;
543 pdev->read_frame->next = NULL;
546 if (pdev->read_frame != NULL) {
548 Trace(TRACE_SEQUENCE, "Decompressing frame %d\n", pdev->read_frame->sequence);
550 /* Decompression is a lenghty process, so it's outside of the lock.
551 This gives the isoc_handler the opportunity to fill more frames
554 spin_unlock_irqrestore(&pdev->ptrlock, flags);
555 ret = pwc_decompress(pdev);
556 spin_lock_irqsave(&pdev->ptrlock, flags);
558 /* We're done with read_buffer, tack it to the end of the empty buffer list */
559 if (pdev->empty_frames == NULL) {
560 pdev->empty_frames = pdev->read_frame;
561 pdev->empty_frames_tail = pdev->empty_frames;
564 pdev->empty_frames_tail->next = pdev->read_frame;
565 pdev->empty_frames_tail = pdev->read_frame;
567 pdev->read_frame = NULL;
570 spin_unlock_irqrestore(&pdev->ptrlock, flags);
575 \brief Advance pointers of image buffer (after each user request)
577 static inline void pwc_next_image(struct pwc_device *pdev)
579 pdev->image_used[pdev->fill_image] = 0;
580 pdev->fill_image = (pdev->fill_image + 1) % default_mbufs;
584 /* This gets called for the Isochronous pipe (video). This is done in
585 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
587 static void pwc_isoc_handler(struct urb *urb, struct pt_regs *regs)
589 struct pwc_device *pdev;
592 struct pwc_frame_buf *fbuf;
593 unsigned char *fillptr = 0, *iso_buf = 0;
596 pdev = (struct pwc_device *)urb->context;
598 Err("isoc_handler() called with NULL device?!\n");
602 if (pdev->magic != PWC_MAGIC) {
603 Err("isoc_handler() called with bad magic!\n");
607 if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
608 Trace(TRACE_OPEN, "pwc_isoc_handler(): URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
611 if (urb->status != -EINPROGRESS && urb->status != 0) {
615 switch(urb->status) {
616 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
617 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
618 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
619 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
620 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
621 case -ETIMEDOUT: errmsg = "NAK (device does not respond)"; break;
623 Trace(TRACE_FLOW, "pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
624 /* Give up after a number of contiguous errors on the USB bus.
625 Appearantly something is wrong so we simulate an unplug event.
627 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
629 Info("Too many ISOC errors, bailing out.\n");
630 pdev->error_status = EIO;
632 wake_up_interruptible(&pdev->frameq);
634 goto handler_end; // ugly, but practical
637 fbuf = pdev->fill_frame;
639 Err("pwc_isoc_handler without valid fill frame.\n");
644 fillptr = fbuf->data + fbuf->filled;
647 /* Reset ISOC error counter. We did get here, after all. */
648 pdev->visoc_errors = 0;
650 /* vsync: 0 = don't copy data
655 for (i = 0; i < urb->number_of_packets; i++) {
656 fst = urb->iso_frame_desc[i].status;
657 flen = urb->iso_frame_desc[i].actual_length;
658 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
660 if (flen > 0) { /* if valid data... */
661 if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */
664 /* ...copy data to frame buffer, if possible */
665 if (flen + fbuf->filled > pdev->frame_size) {
666 Trace(TRACE_FLOW, "Frame buffer overflow (flen = %d, frame_size = %d).\n", flen, pdev->frame_size);
667 pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */
668 pdev->vframes_error++;
671 memmove(fillptr, iso_buf, flen);
675 fbuf->filled += flen;
678 if (flen < pdev->vlast_packet_size) {
679 /* Shorter packet... We probably have the end of an image-frame;
680 wake up read() process and let select()/poll() do something.
681 Decompression is done in user time over there.
683 if (pdev->vsync == 2) {
684 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
685 frames on the USB wire after an exposure change. This conditition is
686 however detected in the cam and a bit is set in the header.
688 if (pdev->type == 730) {
689 unsigned char *ptr = (unsigned char *)fbuf->data;
691 if (ptr[1] == 1 && ptr[0] & 0x10) {
693 Debug("Hyundai CMOS sensor bug. Dropping frame %d.\n", fbuf->sequence);
695 pdev->drop_frames += 2;
696 pdev->vframes_error++;
698 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
700 Info("Snapshot button pressed.\n");
702 Info("Snapshot button released.\n");
704 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
706 Info("Image is mirrored.\n");
708 Info("Image is normal.\n");
710 pdev->vmirror = ptr[0] & 0x03;
711 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
712 after a short frame; this condition is filtered out specifically. A 4 byte
713 frame doesn't make sense anyway.
714 So we get either this sequence:
715 drop_bit set -> 4 byte frame -> short frame -> good frame
717 drop_bit set -> short frame -> good frame
718 So we drop either 3 or 2 frames in all!
720 if (fbuf->filled == 4)
724 /* In case we were instructed to drop the frame, do so silently.
725 The buffer pointers are not updated either (but the counters are reset below).
727 if (pdev->drop_frames > 0)
730 /* Check for underflow first */
731 if (fbuf->filled < pdev->frame_size) {
732 Trace(TRACE_FLOW, "Frame buffer underflow (%d bytes); discarded.\n", fbuf->filled);
733 pdev->vframes_error++;
736 /* Send only once per EOF */
737 awake = 1; /* delay wake_ups */
739 /* Find our next frame to fill. This will always succeed, since we
740 * nick a frame from either empty or full list, but if we had to
741 * take it from the full list, it means a frame got dropped.
743 if (pwc_next_fill_frame(pdev)) {
744 pdev->vframes_dumped++;
745 if ((pdev->vframe_count > FRAME_LOWMARK) && (pwc_trace & TRACE_FLOW)) {
746 if (pdev->vframes_dumped < 20)
747 Trace(TRACE_FLOW, "Dumping frame %d.\n", pdev->vframe_count);
748 if (pdev->vframes_dumped == 20)
749 Trace(TRACE_FLOW, "Dumping frame %d (last message).\n", pdev->vframe_count);
752 fbuf = pdev->fill_frame;
755 pdev->vframe_count++;
758 fillptr = fbuf->data;
760 } /* .. flen < last_packet_size */
761 pdev->vlast_packet_size = flen;
762 } /* ..status == 0 */
764 /* This is normally not interesting to the user, unless you are really debugging something */
766 static int iso_error = 0;
769 Trace(TRACE_FLOW, "Iso frame %d of USB has error %d\n", i, fst);
776 wake_up_interruptible(&pdev->frameq);
778 urb->dev = pdev->udev;
779 i = usb_submit_urb(urb, GFP_ATOMIC);
781 Err("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
785 static int pwc_isoc_init(struct pwc_device *pdev)
787 struct usb_device *udev;
791 struct usb_interface *intf;
792 struct usb_host_interface *idesc = NULL;
801 /* Get the current alternate interface, adjust packet size */
802 if (!udev->actconfig)
804 intf = usb_ifnum_to_if(udev, 0);
806 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
810 /* Search video endpoint */
811 pdev->vmax_packet_size = -1;
812 for (i = 0; i < idesc->desc.bNumEndpoints; i++)
813 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
814 pdev->vmax_packet_size = idesc->endpoint[i].desc.wMaxPacketSize;
818 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
819 Err("Failed to find packet size for video endpoint in current alternate setting.\n");
820 return -ENFILE; /* Odd error, that should be noticeable */
823 /* Set alternate interface */
825 Trace(TRACE_OPEN, "Setting alternate interface %d\n", pdev->valternate);
826 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
830 for (i = 0; i < MAX_ISO_BUFS; i++) {
831 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
833 Err("Failed to allocate urb %d\n", i);
837 pdev->sbuf[i].urb = urb;
838 Trace(TRACE_MEMORY, "Allocated URB at 0x%p\n", urb);
841 /* De-allocate in reverse order */
843 if (pdev->sbuf[i].urb != NULL)
844 usb_free_urb(pdev->sbuf[i].urb);
845 pdev->sbuf[i].urb = NULL;
851 /* init URB structure */
852 for (i = 0; i < MAX_ISO_BUFS; i++) {
853 urb = pdev->sbuf[i].urb;
855 urb->interval = 1; // devik
857 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
858 urb->transfer_flags = URB_ISO_ASAP;
859 urb->transfer_buffer = pdev->sbuf[i].data;
860 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
861 urb->complete = pwc_isoc_handler;
863 urb->start_frame = 0;
864 urb->number_of_packets = ISO_FRAMES_PER_DESC;
865 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
866 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
867 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
872 for (i = 0; i < MAX_ISO_BUFS; i++) {
873 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL);
875 Err("isoc_init() submit_urb %d failed with error %d\n", i, ret);
877 Trace(TRACE_OPEN, "URB 0x%p submitted.\n", pdev->sbuf[i].urb);
882 Trace(TRACE_OPEN, "<< pwc_isoc_init()\n");
886 static void pwc_isoc_cleanup(struct pwc_device *pdev)
890 Trace(TRACE_OPEN, ">> pwc_isoc_cleanup()\n");
894 /* Unlinking ISOC buffers one by one */
895 for (i = 0; i < MAX_ISO_BUFS; i++) {
898 urb = pdev->sbuf[i].urb;
900 if (pdev->iso_init) {
901 Trace(TRACE_MEMORY, "Unlinking URB %p\n", urb);
904 Trace(TRACE_MEMORY, "Freeing URB\n");
906 pdev->sbuf[i].urb = NULL;
910 /* Stop camera, but only if we are sure the camera is still there (unplug
911 is signalled by EPIPE)
913 if (pdev->error_status && pdev->error_status != EPIPE) {
914 Trace(TRACE_OPEN, "Setting alternate interface 0.\n");
915 usb_set_interface(pdev->udev, 0, 0);
919 Trace(TRACE_OPEN, "<< pwc_isoc_cleanup()\n");
922 int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot)
926 /* Stop isoc stuff */
927 pwc_isoc_cleanup(pdev);
928 /* Reset parameters */
929 pwc_reset_buffers(pdev);
930 /* Try to set video mode... */
931 start = ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot);
933 Trace(TRACE_FLOW, "pwc_set_video_mode attempt 1 failed.\n");
934 /* That failed... restore old mode (we know that worked) */
935 start = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
937 Trace(TRACE_FLOW, "pwc_set_video_mode attempt 2 failed.\n");
942 if (pwc_isoc_init(pdev) < 0)
944 Info("Failed to restart ISOC transfers in pwc_try_video_mode.\n");
945 ret = -EAGAIN; /* let's try again, who knows if it works a second time */
948 pdev->drop_frames++; /* try to avoid garbage during switch */
949 return ret; /* Return original error code */
953 /***************************************************************************/
954 /* Video4Linux functions */
956 static int pwc_video_open(struct inode *inode, struct file *file)
959 struct video_device *vdev = video_devdata(file);
960 struct pwc_device *pdev;
962 Trace(TRACE_OPEN, ">> video_open called(vdev = 0x%p).\n", vdev);
964 pdev = (struct pwc_device *)vdev->priv;
970 down(&pdev->modlock);
971 if (!pdev->usb_init) {
972 Trace(TRACE_OPEN, "Doing first time initialization.\n");
975 if (pwc_trace & TRACE_OPEN) {
976 /* Query sensor type */
977 const char *sensor_type = NULL;
979 i = pwc_get_cmos_sensor(pdev);
981 case -1: /* Unknown, show nothing */; break;
982 case 0x00: sensor_type = "Hyundai CMOS sensor"; break;
983 case 0x20: sensor_type = "Sony CCD sensor + TDA8787"; break;
984 case 0x2E: sensor_type = "Sony CCD sensor + Exas 98L59"; break;
985 case 0x2F: sensor_type = "Sony CCD sensor + ADI 9804"; break;
986 case 0x30: sensor_type = "Sharp CCD sensor + TDA8787"; break;
987 case 0x3E: sensor_type = "Sharp CCD sensor + Exas 98L59"; break;
988 case 0x3F: sensor_type = "Sharp CCD sensor + ADI 9804"; break;
989 case 0x40: sensor_type = "UPA 1021 sensor"; break;
990 case 0x100: sensor_type = "VGA sensor"; break;
991 case 0x101: sensor_type = "PAL MR sensor"; break;
992 default: sensor_type = "unknown type of sensor"; break;
994 if (sensor_type != NULL)
995 Info("This %s camera is equipped with a %s (%d).\n", pdev->vdev.name, sensor_type, i);
1001 i = pwc_camera_power(pdev, 1);
1003 Info("Failed to restore power to the camera! (%d)\n", i);
1005 /* Set LED on/off time */
1006 if (pwc_set_leds(pdev, led_on, led_off) < 0)
1007 Info("Failed to set LED on/off time.\n");
1009 /* Find our decompressor, if any */
1010 pdev->decompressor = pwc_find_decompressor(pdev->type);
1012 Debug("Found decompressor for %d at 0x%p\n", pdev->type, pdev->decompressor);
1014 pwc_construct(pdev); /* set min/max sizes correct */
1016 /* So far, so good. Allocate memory. */
1017 i = pwc_allocate_buffers(pdev);
1019 Trace(TRACE_OPEN, "Failed to allocate buffer memory.\n");
1024 /* Reset buffers & parameters */
1025 pwc_reset_buffers(pdev);
1026 for (i = 0; i < default_mbufs; i++)
1027 pdev->image_used[i] = 0;
1028 pdev->vframe_count = 0;
1029 pdev->vframes_dumped = 0;
1030 pdev->vframes_error = 0;
1031 pdev->visoc_errors = 0;
1032 pdev->error_status = 0;
1036 pwc_construct(pdev); /* set min/max sizes correct */
1038 /* Set some defaults */
1039 pdev->vsnapshot = 0;
1040 /* Start iso pipe for video; first try the last used video size
1041 (or the default one); if that fails try QCIF/10 or QSIF/10;
1042 it that fails too, give up.
1044 i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1046 Trace(TRACE_OPEN, "First attempt at set_video_mode failed.\n");
1047 if (pdev->type == 730 || pdev->type == 740 || pdev->type == 750)
1048 i = pwc_set_video_mode(pdev, pwc_image_sizes[PSZ_QSIF].x, pwc_image_sizes[PSZ_QSIF].y, 10, pdev->vcompression, 0);
1050 i = pwc_set_video_mode(pdev, pwc_image_sizes[PSZ_QCIF].x, pwc_image_sizes[PSZ_QCIF].y, 10, pdev->vcompression, 0);
1053 Trace(TRACE_OPEN, "Second attempt at set_video_mode failed.\n");
1058 i = pwc_isoc_init(pdev);
1060 Trace(TRACE_OPEN, "Failed to init ISOC stuff = %d.\n", i);
1066 file->private_data = vdev;
1067 /* lock decompressor; this has a small race condition, since we
1068 could in theory unload pwcx.o between pwc_find_decompressor()
1069 above and this call. I doubt it's ever going to be a problem.
1071 if (pdev->decompressor != NULL)
1072 pdev->decompressor->lock();
1074 Trace(TRACE_OPEN, "<< video_open() returns 0.\n");
1078 /* Note that all cleanup is done in the reverse order as in _open */
1079 static int pwc_video_close(struct inode *inode, struct file *file)
1081 struct video_device *vdev = file->private_data;
1082 struct pwc_device *pdev;
1085 Trace(TRACE_OPEN, ">> video_close called(vdev = 0x%p).\n", vdev);
1087 pdev = (struct pwc_device *)vdev->priv;
1088 if (pdev->vopen == 0)
1089 Info("video_close() called on closed device?\n");
1091 /* Dump statistics, but only if a reasonable amount of frames were
1092 processed (to prevent endless log-entries in case of snap-shot
1095 if (pdev->vframe_count > 20)
1096 Info("Closing video device: %d frames received, dumped %d frames, %d frames with errors.\n", pdev->vframe_count, pdev->vframes_dumped, pdev->vframes_error);
1098 if (pdev->decompressor != NULL) {
1099 pdev->decompressor->exit();
1100 pdev->decompressor->unlock();
1101 pdev->decompressor = NULL;
1104 pwc_isoc_cleanup(pdev);
1105 pwc_free_buffers(pdev);
1107 /* Turn off LEDS and power down camera, but only when not unplugged */
1108 if (pdev->error_status != EPIPE) {
1110 if (pwc_set_leds(pdev, 0, 0) < 0)
1111 Info("Failed to set LED on/off time.\n");
1113 i = pwc_camera_power(pdev, 0);
1115 Err("Failed to power down camera (%d)\n", i);
1119 Trace(TRACE_OPEN, "<< video_close()\n");
1124 * FIXME: what about two parallel reads ????
1125 * ANSWER: Not supported. You can't open the device more than once,
1126 despite what the V4L1 interface says. First, I don't see
1127 the need, second there's no mechanism of alerting the
1128 2nd/3rd/... process of events like changing image size.
1129 And I don't see the point of blocking that for the
1130 2nd/3rd/... process.
1131 In multi-threaded environments reading parallel from any
1132 device is tricky anyhow.
1135 static ssize_t pwc_video_read(struct file *file, char __user *buf,
1136 size_t count, loff_t *ppos)
1138 struct video_device *vdev = file->private_data;
1139 struct pwc_device *pdev;
1140 int noblock = file->f_flags & O_NONBLOCK;
1141 DECLARE_WAITQUEUE(wait, current);
1143 Trace(TRACE_READ, "video_read(0x%p, %p, %d) called.\n", vdev, buf, count);
1149 if (pdev->error_status)
1150 return -pdev->error_status; /* Something happened, report what. */
1152 /* In case we're doing partial reads, we don't have to wait for a frame */
1153 if (pdev->image_read_pos == 0) {
1154 /* Do wait queueing according to the (doc)book */
1155 add_wait_queue(&pdev->frameq, &wait);
1156 while (pdev->full_frames == NULL) {
1157 /* Check for unplugged/etc. here */
1158 if (pdev->error_status) {
1159 remove_wait_queue(&pdev->frameq, &wait);
1160 set_current_state(TASK_RUNNING);
1161 return -pdev->error_status ;
1164 remove_wait_queue(&pdev->frameq, &wait);
1165 set_current_state(TASK_RUNNING);
1166 return -EWOULDBLOCK;
1168 if (signal_pending(current)) {
1169 remove_wait_queue(&pdev->frameq, &wait);
1170 set_current_state(TASK_RUNNING);
1171 return -ERESTARTSYS;
1174 set_current_state(TASK_INTERRUPTIBLE);
1176 remove_wait_queue(&pdev->frameq, &wait);
1177 set_current_state(TASK_RUNNING);
1179 /* Decompress and release frame */
1180 if (pwc_handle_frame(pdev))
1184 Trace(TRACE_READ, "Copying data to user space.\n");
1185 /* copy bytes to user space; we allow for partial reads */
1186 if (count + pdev->image_read_pos > pdev->view.size)
1187 count = pdev->view.size - pdev->image_read_pos;
1188 if (copy_to_user(buf, pdev->image_ptr[pdev->fill_image] + pdev->image_read_pos, count))
1190 pdev->image_read_pos += count;
1191 if (pdev->image_read_pos >= pdev->view.size) { /* All data has been read */
1192 pdev->image_read_pos = 0;
1193 pwc_next_image(pdev);
1198 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1200 struct video_device *vdev = file->private_data;
1201 struct pwc_device *pdev;
1209 poll_wait(file, &pdev->frameq, wait);
1210 if (pdev->error_status)
1212 if (pdev->full_frames != NULL) /* we have frames waiting */
1213 return (POLLIN | POLLRDNORM);
1218 static int pwc_video_do_ioctl(struct inode *inode, struct file *file,
1219 unsigned int cmd, void *arg)
1221 struct video_device *vdev = file->private_data;
1222 struct pwc_device *pdev;
1223 DECLARE_WAITQUEUE(wait, current);
1232 /* Query cabapilities */
1235 struct video_capability *caps = arg;
1237 strcpy(caps->name, vdev->name);
1238 caps->type = VID_TYPE_CAPTURE;
1241 caps->minwidth = pdev->view_min.x;
1242 caps->minheight = pdev->view_min.y;
1243 caps->maxwidth = pdev->view_max.x;
1244 caps->maxheight = pdev->view_max.y;
1248 /* Channel functions (simulate 1 channel) */
1251 struct video_channel *v = arg;
1253 if (v->channel != 0)
1257 v->type = VIDEO_TYPE_CAMERA;
1258 strcpy(v->name, "Webcam");
1264 /* The spec says the argument is an integer, but
1265 the bttv driver uses a video_channel arg, which
1266 makes sense becasue it also has the norm flag.
1268 struct video_channel *v = arg;
1269 if (v->channel != 0)
1275 /* Picture functions; contrast etc. */
1278 struct video_picture *p = arg;
1283 val = pwc_get_brightness(pdev);
1285 p->brightness = val;
1287 p->brightness = 0xffff;
1288 val = pwc_get_contrast(pdev);
1292 p->contrast = 0xffff;
1293 /* Gamma, Whiteness, what's the difference? :) */
1294 val = pwc_get_gamma(pdev);
1298 p->whiteness = 0xffff;
1299 val = pwc_get_saturation(pdev);
1305 p->palette = VIDEO_PALETTE_YUV420P;
1306 p->hue = 0xFFFF; /* N/A */
1312 struct video_picture *p = arg;
1314 * FIXME: Suppose we are mid read
1315 ANSWER: No problem: the firmware of the camera
1316 can handle brightness/contrast/etc
1317 changes at _any_ time, and the palette
1318 is used exactly once in the uncompress
1321 if (p->palette && p->palette != VIDEO_PALETTE_YUV420P) {
1324 pwc_set_brightness(pdev, p->brightness);
1325 pwc_set_contrast(pdev, p->contrast);
1326 pwc_set_gamma(pdev, p->whiteness);
1327 pwc_set_saturation(pdev, p->colour);
1331 /* Window/size parameters */
1334 struct video_window *vw = arg;
1338 vw->width = pdev->view.x;
1339 vw->height = pdev->view.y;
1341 vw->flags = (pdev->vframes << PWC_FPS_SHIFT) |
1342 (pdev->vsnapshot ? PWC_FPS_SNAPSHOT : 0);
1348 struct video_window *vw = arg;
1349 int fps, snapshot, ret;
1351 fps = (vw->flags & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
1352 snapshot = vw->flags & PWC_FPS_SNAPSHOT;
1354 fps = pdev->vframes;
1355 if (pdev->view.x == vw->width && pdev->view.y && fps == pdev->vframes && snapshot == pdev->vsnapshot)
1357 ret = pwc_try_video_mode(pdev, vw->width, vw->height, fps, pdev->vcompression, snapshot);
1363 /* We don't have overlay support (yet) */
1366 struct video_buffer *vb = arg;
1368 memset(vb,0,sizeof(*vb));
1372 /* mmap() functions */
1375 /* Tell the user program how much memory is needed for a mmap() */
1376 struct video_mbuf *vm = arg;
1379 memset(vm, 0, sizeof(*vm));
1380 vm->size = default_mbufs * pdev->len_per_image;
1381 vm->frames = default_mbufs; /* double buffering should be enough for most applications */
1382 for (i = 0; i < default_mbufs; i++)
1383 vm->offsets[i] = i * pdev->len_per_image;
1387 case VIDIOCMCAPTURE:
1389 /* Start capture into a given image buffer (called 'frame' in video_mmap structure) */
1390 struct video_mmap *vm = arg;
1392 Trace(TRACE_READ, "VIDIOCMCAPTURE: %dx%d, frame %d, format %d\n", vm->width, vm->height, vm->frame, vm->format);
1393 if (vm->frame < 0 || vm->frame >= default_mbufs)
1396 /* xawtv is nasty. It probes the available palettes
1397 by setting a very small image size and trying
1398 various palettes... The driver doesn't support
1399 such small images, so I'm working around it.
1401 if (vm->format && vm->format != VIDEO_PALETTE_YUV420P)
1404 if ((vm->width != pdev->view.x || vm->height != pdev->view.y) &&
1405 (vm->width >= pdev->view_min.x && vm->height >= pdev->view_min.y)) {
1408 Trace(TRACE_OPEN, "VIDIOCMCAPTURE: changing size to please xawtv :-(.\n");
1409 ret = pwc_try_video_mode(pdev, vm->width, vm->height, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
1412 } /* ... size mismatch */
1414 /* FIXME: should we lock here? */
1415 if (pdev->image_used[vm->frame])
1416 return -EBUSY; /* buffer wasn't available. Bummer */
1417 pdev->image_used[vm->frame] = 1;
1419 /* Okay, we're done here. In the SYNC call we wait until a
1420 frame comes available, then expand image into the given
1422 In contrast to the CPiA cam the Philips cams deliver a
1423 constant stream, almost like a grabber card. Also,
1424 we have separate buffers for the rawdata and the image,
1425 meaning we can nearly always expand into the requested buffer.
1427 Trace(TRACE_READ, "VIDIOCMCAPTURE done.\n");
1433 /* The doc says: "Whenever a buffer is used it should
1434 call VIDIOCSYNC to free this frame up and continue."
1436 The only odd thing about this whole procedure is
1437 that MCAPTURE flags the buffer as "in use", and
1438 SYNC immediately unmarks it, while it isn't
1439 after SYNC that you know that the buffer actually
1440 got filled! So you better not start a CAPTURE in
1441 the same frame immediately (use double buffering).
1442 This is not a problem for this cam, since it has
1443 extra intermediate buffers, but a hardware
1444 grabber card will then overwrite the buffer
1450 Trace(TRACE_READ, "VIDIOCSYNC called (%d).\n", *mbuf);
1453 if (*mbuf < 0 || *mbuf >= default_mbufs)
1455 /* check if this buffer was requested anyway */
1456 if (pdev->image_used[*mbuf] == 0)
1459 /* Add ourselves to the frame wait-queue.
1461 FIXME: needs auditing for safety.
1462 QUESTION: In what respect? I think that using the
1465 add_wait_queue(&pdev->frameq, &wait);
1466 while (pdev->full_frames == NULL) {
1467 if (pdev->error_status) {
1468 remove_wait_queue(&pdev->frameq, &wait);
1469 set_current_state(TASK_RUNNING);
1470 return -pdev->error_status;
1473 if (signal_pending(current)) {
1474 remove_wait_queue(&pdev->frameq, &wait);
1475 set_current_state(TASK_RUNNING);
1476 return -ERESTARTSYS;
1479 set_current_state(TASK_INTERRUPTIBLE);
1481 remove_wait_queue(&pdev->frameq, &wait);
1482 set_current_state(TASK_RUNNING);
1484 /* The frame is ready. Expand in the image buffer
1485 requested by the user. I don't care if you
1486 mmap() 5 buffers and request data in this order:
1487 buffer 4 2 3 0 1 2 3 0 4 3 1 . . .
1488 Grabber hardware may not be so forgiving.
1490 Trace(TRACE_READ, "VIDIOCSYNC: frame ready.\n");
1491 pdev->fill_image = *mbuf; /* tell in which buffer we want the image to be expanded */
1492 /* Decompress, etc */
1493 ret = pwc_handle_frame(pdev);
1494 pdev->image_used[*mbuf] = 0;
1502 struct video_audio *v = arg;
1504 strcpy(v->name, "Microphone");
1505 v->audio = -1; /* unknown audio minor */
1507 v->mode = VIDEO_SOUND_MONO;
1511 v->balance = 0x8000;
1518 /* Dummy: nothing can be set */
1524 struct video_unit *vu = arg;
1526 vu->video = pdev->vdev.minor & 0x3F;
1527 vu->audio = -1; /* not known yet */
1534 return pwc_ioctl(pdev, cmd, arg);
1539 static int pwc_video_ioctl(struct inode *inode, struct file *file,
1540 unsigned int cmd, unsigned long arg)
1542 return video_usercopy(inode, file, cmd, arg, pwc_video_do_ioctl);
1546 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1548 struct video_device *vdev = file->private_data;
1549 struct pwc_device *pdev;
1550 unsigned long start = vma->vm_start;
1551 unsigned long size = vma->vm_end-vma->vm_start;
1552 unsigned long page, pos;
1554 Trace(TRACE_MEMORY, "mmap(0x%p, 0x%lx, %lu) called.\n", vdev, start, size);
1557 pos = (unsigned long)pdev->image_data;
1559 page = kvirt_to_pa(pos);
1560 if (remap_page_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1565 if (size > PAGE_SIZE)
1574 /***************************************************************************/
1577 /* This function gets called when a new device is plugged in or the usb core
1581 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1583 struct usb_device *udev = interface_to_usbdev(intf);
1584 struct pwc_device *pdev = NULL;
1585 int vendor_id, product_id, type_id;
1588 int video_nr = -1; /* default: use next available device */
1589 char serial_number[30], *name;
1591 /* Check if we can handle this device */
1592 Trace(TRACE_PROBE, "probe() called [%04X %04X], if %d\n",
1593 udev->descriptor.idVendor, udev->descriptor.idProduct,
1594 intf->altsetting->desc.bInterfaceNumber);
1596 /* the interfaces are probed one by one. We are only interested in the
1597 video interface (0) now.
1598 Interface 1 is the Audio Control, and interface 2 Audio itself.
1600 if (intf->altsetting->desc.bInterfaceNumber > 0)
1603 vendor_id = udev->descriptor.idVendor;
1604 product_id = udev->descriptor.idProduct;
1606 if (vendor_id == 0x0471) {
1607 switch (product_id) {
1609 Info("Philips PCA645VC USB webcam detected.\n");
1610 name = "Philips 645 webcam";
1614 Info("Philips PCA646VC USB webcam detected.\n");
1615 name = "Philips 646 webcam";
1619 Info("Askey VC010 type 2 USB webcam detected.\n");
1620 name = "Askey VC010 webcam";
1624 Info("Philips PCVC675K (Vesta) USB webcam detected.\n");
1625 name = "Philips 675 webcam";
1629 Info("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1630 name = "Philips 680 webcam";
1634 Info("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1635 name = "Philips 690 webcam";
1639 Info("Philips PCVC730K (ToUCam Fun) USB webcam detected.\n");
1640 name = "Philips 730 webcam";
1644 Info("Philips PCVC740K (ToUCam Pro) USB webcam detected.\n");
1645 name = "Philips 740 webcam";
1649 Info("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1650 name = "Philips 750 webcam";
1654 Info("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1655 name = "Philips 720K/40 webcam";
1663 else if (vendor_id == 0x069A) {
1664 switch(product_id) {
1666 Info("Askey VC010 type 1 USB webcam detected.\n");
1667 name = "Askey VC010 webcam";
1675 else if (vendor_id == 0x046d) {
1676 switch(product_id) {
1678 Info("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1679 name = "Logitech QuickCam Pro 3000";
1680 type_id = 740; /* CCD sensor */
1683 Info("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1684 name = "Logitech QuickCam Notebook Pro";
1685 type_id = 740; /* CCD sensor */
1688 Info("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1689 name = "Logitech QuickCam Pro 4000";
1690 type_id = 740; /* CCD sensor */
1693 Info("Logitech QuickCam Zoom USB webcam detected.\n");
1694 name = "Logitech QuickCam Zoom";
1695 type_id = 740; /* CCD sensor */
1698 Info("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1699 name = "Logitech QuickCam Zoom";
1700 type_id = 740; /* CCD sensor */
1703 Info("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1704 name = "Logitech QuickCam Orbit";
1705 type_id = 740; /* CCD sensor */
1706 features |= FEATURE_MOTOR_PANTILT;
1711 Info("Logitech QuickCam detected (reserved ID).\n");
1712 name = "Logitech QuickCam (res.)";
1713 type_id = 730; /* Assuming CMOS */
1720 else if (vendor_id == 0x055d) {
1721 /* I don't know the difference between the C10 and the C30;
1722 I suppose the difference is the sensor, but both cameras
1723 work equally well with a type_id of 675
1725 switch(product_id) {
1727 Info("Samsung MPC-C10 USB webcam detected.\n");
1728 name = "Samsung MPC-C10";
1732 Info("Samsung MPC-C30 USB webcam detected.\n");
1733 name = "Samsung MPC-C30";
1741 else if (vendor_id == 0x041e) {
1742 switch(product_id) {
1744 Info("Creative Labs Webcam 5 detected.\n");
1745 name = "Creative Labs Webcam 5";
1749 Info("Creative Labs Webcam Pro Ex detected.\n");
1750 name = "Creative Labs Webcam Pro Ex";
1758 else if (vendor_id == 0x04cc) {
1759 switch(product_id) {
1761 Info("Sotec Afina Eye USB webcam detected.\n");
1762 name = "Sotec Afina Eye";
1770 else if (vendor_id == 0x0d81) {
1771 switch(product_id) {
1773 Info("Visionite VCS-UC300 USB webcam detected.\n");
1774 name = "Visionite VCS-UC300";
1775 type_id = 740; /* CCD sensor */
1778 Info("Visionite VCS-UM100 USB webcam detected.\n");
1779 name = "Visionite VCS-UM100";
1780 type_id = 730; /* CMOS sensor */
1788 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1790 memset(serial_number, 0, 30);
1791 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1792 Trace(TRACE_PROBE, "Device serial number is %s\n", serial_number);
1794 if (udev->descriptor.bNumConfigurations > 1)
1795 Info("Warning: more than 1 configuration available.\n");
1797 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1798 pdev = kmalloc(sizeof(struct pwc_device), GFP_KERNEL);
1800 Err("Oops, could not allocate memory for pwc_device.\n");
1803 memset(pdev, 0, sizeof(struct pwc_device));
1804 pdev->type = type_id;
1805 pdev->vsize = default_size;
1806 pdev->vframes = default_fps;
1807 pdev->features = features;
1808 if (vendor_id == 0x046D && product_id == 0x08B5)
1810 /* Logitech QuickCam Orbit
1811 The ranges have been determined experimentally; they may differ from cam to cam.
1812 Also, the exact ranges left-right and up-down are different for my cam
1814 pdev->angle_range.pan_min = -7000;
1815 pdev->angle_range.pan_max = 7000;
1816 pdev->angle_range.tilt_min = -3000;
1817 pdev->angle_range.tilt_max = 2500;
1818 pdev->angle_range.zoom_min = -1;
1819 pdev->angle_range.zoom_max = -1;
1822 init_MUTEX(&pdev->modlock);
1823 pdev->ptrlock = SPIN_LOCK_UNLOCKED;
1826 init_waitqueue_head(&pdev->frameq);
1827 pdev->vcompression = pwc_preferred_compression;
1829 memcpy(&pdev->vdev, &pwc_template, sizeof(pwc_template));
1830 strcpy(pdev->vdev.name, name);
1831 pdev->vdev.owner = THIS_MODULE;
1832 pdev->vdev.priv = pdev;
1834 pdev->release = udev->descriptor.bcdDevice;
1835 Trace(TRACE_PROBE, "Release: %04x\n", pdev->release);
1837 /* Now search device_hint[] table for a match, so we can hint a node number. */
1838 for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1839 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1840 (device_hint[hint].pdev == NULL)) {
1841 /* so far, so good... try serial number */
1842 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1844 video_nr = device_hint[hint].device_node;
1845 Trace(TRACE_PROBE, "Found hint, will try to register as /dev/video%d\n", video_nr);
1851 pdev->vdev.release = video_device_release;
1852 i = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1854 Err("Failed to register as video device (%d).\n", i);
1855 kfree(pdev); /* Oops, no memory leaks please */
1859 Info("Registered as /dev/video%d.\n", pdev->vdev.minor & 0x3F);
1863 if (hint < MAX_DEV_HINTS)
1864 device_hint[hint].pdev = pdev;
1866 Trace(TRACE_PROBE, "probe() function returning struct at 0x%p.\n", pdev);
1867 usb_set_intfdata (intf, pdev);
1871 /* The user janked out the cable... */
1872 static void usb_pwc_disconnect(struct usb_interface *intf)
1874 struct pwc_device *pdev;
1878 pdev = usb_get_intfdata (intf);
1879 usb_set_intfdata (intf, NULL);
1881 Err("pwc_disconnect() Called without private pointer.\n");
1882 goto disconnect_out;
1884 if (pdev->udev == NULL) {
1885 Err("pwc_disconnect() already called for %p\n", pdev);
1886 goto disconnect_out;
1888 if (pdev->udev != interface_to_usbdev(intf)) {
1889 Err("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1890 goto disconnect_out;
1893 if (pdev->magic != PWC_MAGIC) {
1894 Err("pwc_disconnect() Magic number failed. Consult your scrolls and try again.\n");
1895 goto disconnect_out;
1899 /* We got unplugged; this is signalled by an EPIPE error code */
1901 Info("Disconnected while webcam is in use!\n");
1902 pdev->error_status = EPIPE;
1905 /* Alert waiting processes */
1906 wake_up_interruptible(&pdev->frameq);
1907 /* Wait until device is closed */
1910 /* Device is now closed, so we can safely unregister it */
1911 Trace(TRACE_PROBE, "Unregistering video device in disconnect().\n");
1912 video_unregister_device(&pdev->vdev);
1914 /* Free memory (don't set pdev to 0 just yet) */
1918 /* search device_hint[] table if we occupy a slot, by any chance */
1919 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1920 if (device_hint[hint].pdev == pdev)
1921 device_hint[hint].pdev = NULL;
1927 /* *grunt* We have to do atoi ourselves :-( */
1928 static int pwc_atoi(const char *s)
1933 while (*s != '\0' && *s >= '0' && *s <= '9') {
1934 k = 10 * k + (*s - '0');
1942 * Initialization code & module stuff
1945 static char *size = NULL;
1947 static int fbufs = 0;
1948 static int mbufs = 0;
1949 static int trace = -1;
1950 static int compression = -1;
1951 static int leds[2] = { -1, -1 };
1952 static char *dev_hint[MAX_DEV_HINTS] = { };
1954 MODULE_PARM(size, "s");
1955 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1956 MODULE_PARM(fps, "i");
1957 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1958 MODULE_PARM(fbufs, "i");
1959 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1960 MODULE_PARM(mbufs, "i");
1961 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1962 MODULE_PARM(trace, "i");
1963 MODULE_PARM_DESC(trace, "For debugging purposes");
1964 MODULE_PARM(power_save, "i");
1965 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1966 MODULE_PARM(compression, "i");
1967 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1968 MODULE_PARM(leds, "2i");
1969 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1970 MODULE_PARM(dev_hint, "0-20s");
1971 MODULE_PARM_DESC(dev_hint, "Device node hints");
1973 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1974 MODULE_AUTHOR("Nemosoft Unv. <nemosoft@smcc.demon.nl>");
1975 MODULE_LICENSE("GPL");
1977 static int __init usb_pwc_init(void)
1980 char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1982 Info("Philips PCA645/646 + PCVC675/680/690 + PCVC730/740/750 webcam module version " PWC_VERSION " loaded.\n");
1983 Info("Also supports the Askey VC010, various Logitech QuickCams, Samsung MPC-C10 and MPC-C30,\n");
1984 Info("the Creative WebCam 5, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1987 if (fps < 4 || fps > 30) {
1988 Err("Framerate out of bounds (4-30).\n");
1992 Info("Default framerate set to %d.\n", default_fps);
1996 /* string; try matching with array */
1997 for (sz = 0; sz < PSZ_MAX; sz++) {
1998 if (!strcmp(sizenames[sz], size)) { /* Found! */
2003 if (sz == PSZ_MAX) {
2004 Err("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
2007 Info("Default image size set to %s [%dx%d].\n", sizenames[default_size], pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y);
2010 if (mbufs < 1 || mbufs > MAX_IMAGES) {
2011 Err("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
2014 default_mbufs = mbufs;
2015 Info("Number of image buffers set to %d.\n", default_mbufs);
2018 if (fbufs < 2 || fbufs > MAX_FRAMES) {
2019 Err("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
2022 default_fbufs = fbufs;
2023 Info("Number of frame buffers set to %d.\n", default_fbufs);
2026 Info("Trace options: 0x%04x\n", trace);
2029 if (compression >= 0) {
2030 if (compression > 3) {
2031 Err("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
2034 pwc_preferred_compression = compression;
2035 Info("Preferred compression set to %d.\n", pwc_preferred_compression);
2038 Info("Enabling power save on open/close.\n");
2044 /* Big device node whoopla. Basically, it allows you to assign a
2045 device node (/dev/videoX) to a camera, based on its type
2046 & serial number. The format is [type[.serialnumber]:]node.
2048 Any camera that isn't matched by these rules gets the next
2049 available free device node.
2051 for (i = 0; i < MAX_DEV_HINTS; i++) {
2052 char *s, *colon, *dot;
2054 /* This loop also initializes the array */
2055 device_hint[i].pdev = NULL;
2057 if (s != NULL && *s != '\0') {
2058 device_hint[i].type = -1; /* wildcard */
2059 strcpy(device_hint[i].serial_number, "*");
2061 /* parse string: chop at ':' & '/' */
2063 while (*colon != '\0' && *colon != ':')
2065 while (*dot != '\0' && *dot != '.')
2067 /* Few sanity checks */
2068 if (*dot != '\0' && dot > colon) {
2069 Err("Malformed camera hint: the colon must be after the dot.\n");
2073 if (*colon == '\0') {
2076 Err("Malformed camera hint: no colon + device node given.\n");
2080 /* No type or serial number specified, just a number. */
2081 device_hint[i].device_node = pwc_atoi(s);
2085 /* There's a colon, so we have at least a type and a device node */
2086 device_hint[i].type = pwc_atoi(s);
2087 device_hint[i].device_node = pwc_atoi(colon + 1);
2089 /* There's a serial number as well */
2094 while (*dot != ':' && k < 29) {
2095 device_hint[i].serial_number[k++] = *dot;
2098 device_hint[i].serial_number[k] = '\0';
2102 Debug("device_hint[%d]:\n", i);
2103 Debug(" type : %d\n", device_hint[i].type);
2104 Debug(" serial# : %s\n", device_hint[i].serial_number);
2105 Debug(" node : %d\n", device_hint[i].device_node);
2109 device_hint[i].type = 0; /* not filled */
2110 } /* ..for MAX_DEV_HINTS */
2112 Trace(TRACE_PROBE, "Registering driver at address 0x%p.\n", &pwc_driver);
2113 return usb_register(&pwc_driver);
2116 static void __exit usb_pwc_exit(void)
2118 Trace(TRACE_MODULE, "Deregistering driver.\n");
2119 usb_deregister(&pwc_driver);
2120 Info("Philips webcam module removed.\n");
2123 module_init(usb_pwc_init);
2124 module_exit(usb_pwc_exit);