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 (member of pwc_dev)
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 int pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
155 static void pwc_video_release(struct video_device *vfd);
157 static const struct v4l2_file_operations pwc_fops = {
158 .owner = THIS_MODULE,
159 .open = pwc_video_open,
160 .release = pwc_video_close,
161 .read = pwc_video_read,
162 .poll = pwc_video_poll,
163 .mmap = pwc_video_mmap,
164 .unlocked_ioctl = video_ioctl2,
166 static struct video_device pwc_template = {
167 .name = "Philips Webcam", /* Filled in later */
168 .release = pwc_video_release,
170 .ioctl_ops = &pwc_ioctl_ops,
173 /***************************************************************************/
174 /* Private functions */
176 /* Here we want the physical address of the memory.
177 * This is used when initializing the contents of the area.
182 static void *pwc_rvmalloc(unsigned long size)
187 mem=vmalloc_32(size);
191 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
192 adr=(unsigned long) mem;
195 SetPageReserved(vmalloc_to_page((void *)adr));
202 static void pwc_rvfree(void * mem, unsigned long size)
209 adr=(unsigned long) mem;
210 while ((long) size > 0)
212 ClearPageReserved(vmalloc_to_page((void *)adr));
222 static int pwc_allocate_buffers(struct pwc_device *pdev)
227 PWC_DEBUG_MEMORY(">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev);
232 /* Allocate Isochronuous pipe buffers */
233 for (i = 0; i < MAX_ISO_BUFS; i++) {
234 if (pdev->sbuf[i].data == NULL) {
235 kbuf = kzalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
237 PWC_ERROR("Failed to allocate iso buffer %d.\n", i);
240 PWC_DEBUG_MEMORY("Allocated iso buffer at %p.\n", kbuf);
241 pdev->sbuf[i].data = kbuf;
245 /* Allocate frame buffer structure */
246 if (pdev->fbuf == NULL) {
247 kbuf = kzalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);
249 PWC_ERROR("Failed to allocate frame buffer structure.\n");
252 PWC_DEBUG_MEMORY("Allocated frame buffer structure at %p.\n", kbuf);
256 /* create frame buffers, and make circular ring */
257 for (i = 0; i < default_fbufs; i++) {
258 if (pdev->fbuf[i].data == NULL) {
259 kbuf = vzalloc(PWC_FRAME_SIZE); /* need vmalloc since frame buffer > 128K */
261 PWC_ERROR("Failed to allocate frame buffer %d.\n", i);
264 PWC_DEBUG_MEMORY("Allocated frame buffer %d at %p.\n", i, kbuf);
265 pdev->fbuf[i].data = kbuf;
269 /* Allocate decompressor table space */
270 if (DEVICE_USE_CODEC1(pdev->type))
271 err = pwc_dec1_alloc(pdev);
273 err = pwc_dec23_alloc(pdev);
276 PWC_ERROR("Failed to allocate decompress table.\n");
280 /* Allocate image buffer; double buffer for mmap() */
281 kbuf = pwc_rvmalloc(pwc_mbufs * pdev->len_per_image);
283 PWC_ERROR("Failed to allocate image buffer(s). needed (%d)\n",
284 pwc_mbufs * pdev->len_per_image);
287 PWC_DEBUG_MEMORY("Allocated image buffer at %p.\n", kbuf);
288 pdev->image_data = kbuf;
289 for (i = 0; i < pwc_mbufs; i++) {
290 pdev->images[i].offset = i * pdev->len_per_image;
291 pdev->images[i].vma_use_count = 0;
293 for (; i < MAX_IMAGES; i++) {
294 pdev->images[i].offset = 0;
299 PWC_DEBUG_MEMORY("<< pwc_allocate_buffers()\n");
303 static void pwc_free_buffers(struct pwc_device *pdev)
307 PWC_DEBUG_MEMORY("Entering free_buffers(%p).\n", pdev);
311 /* Release Iso-pipe buffers */
312 for (i = 0; i < MAX_ISO_BUFS; i++)
313 if (pdev->sbuf[i].data != NULL) {
314 PWC_DEBUG_MEMORY("Freeing ISO buffer at %p.\n", pdev->sbuf[i].data);
315 kfree(pdev->sbuf[i].data);
316 pdev->sbuf[i].data = NULL;
319 /* The same for frame buffers */
320 if (pdev->fbuf != NULL) {
321 for (i = 0; i < default_fbufs; i++) {
322 if (pdev->fbuf[i].data != NULL) {
323 PWC_DEBUG_MEMORY("Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data);
324 vfree(pdev->fbuf[i].data);
325 pdev->fbuf[i].data = NULL;
332 /* Intermediate decompression buffer & tables */
333 if (pdev->decompress_data != NULL) {
334 PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n", pdev->decompress_data);
335 kfree(pdev->decompress_data);
336 pdev->decompress_data = NULL;
339 /* Release image buffers */
340 if (pdev->image_data != NULL) {
341 PWC_DEBUG_MEMORY("Freeing image buffer at %p.\n", pdev->image_data);
342 pwc_rvfree(pdev->image_data, pwc_mbufs * pdev->len_per_image);
344 pdev->image_data = NULL;
346 PWC_DEBUG_MEMORY("Leaving free_buffers().\n");
349 /* The frame & image buffer mess.
351 Yes, this is a mess. Well, it used to be simple, but alas... In this
352 module, 3 buffers schemes are used to get the data from the USB bus to
353 the user program. The first scheme involves the ISO buffers (called thus
354 since they transport ISO data from the USB controller), and not really
355 interesting. Suffices to say the data from this buffer is quickly
356 gathered in an interrupt handler (pwc_isoc_handler) and placed into the
359 The frame buffer is the second scheme, and is the central element here.
360 It collects the data from a single frame from the camera (hence, the
361 name). Frames are delimited by the USB camera with a short USB packet,
362 so that's easy to detect. The frame buffers form a list that is filled
363 by the camera+USB controller and drained by the user process through
364 either read() or mmap().
366 The image buffer is the third scheme, in which frames are decompressed
367 and converted into planar format. For mmap() there is more than
368 one image buffer available.
370 The frame buffers provide the image buffering. In case the user process
371 is a bit slow, this introduces lag and some undesired side-effects.
372 The problem arises when the frame buffer is full. I used to drop the last
373 frame, which makes the data in the queue stale very quickly. But dropping
374 the frame at the head of the queue proved to be a litte bit more difficult.
375 I tried a circular linked scheme, but this introduced more problems than
378 Because filling and draining are completely asynchronous processes, this
379 requires some fiddling with pointers and mutexes.
381 Eventually, I came up with a system with 2 lists: an 'empty' frame list
382 and a 'full' frame list:
383 * Initially, all frame buffers but one are on the 'empty' list; the one
384 remaining buffer is our initial fill frame.
385 * If a frame is needed for filling, we try to take it from the 'empty'
386 list, unless that list is empty, in which case we take the buffer at
387 the head of the 'full' list.
388 * When our fill buffer has been filled, it is appended to the 'full'
390 * If a frame is needed by read() or mmap(), it is taken from the head of
391 the 'full' list, handled, and then appended to the 'empty' list. If no
392 buffer is present on the 'full' list, we wait.
393 The advantage is that the buffer that is currently being decompressed/
394 converted, is on neither list, and thus not in our way (any other scheme
395 I tried had the problem of old data lingering in the queue).
397 Whatever strategy you choose, it always remains a tradeoff: with more
398 frame buffers the chances of a missed frame are reduced. On the other
399 hand, on slower machines it introduces lag because the queue will
404 \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.
406 static int pwc_next_fill_frame(struct pwc_device *pdev)
412 spin_lock_irqsave(&pdev->ptrlock, flags);
413 if (pdev->fill_frame != NULL) {
414 /* append to 'full' list */
415 if (pdev->full_frames == NULL) {
416 pdev->full_frames = pdev->fill_frame;
417 pdev->full_frames_tail = pdev->full_frames;
420 pdev->full_frames_tail->next = pdev->fill_frame;
421 pdev->full_frames_tail = pdev->fill_frame;
424 if (pdev->empty_frames != NULL) {
425 /* We have empty frames available. That's easy */
426 pdev->fill_frame = pdev->empty_frames;
427 pdev->empty_frames = pdev->empty_frames->next;
430 /* Hmm. Take it from the full list */
432 if (pdev->full_frames == NULL) {
433 PWC_ERROR("Neither empty or full frames available!\n");
434 spin_unlock_irqrestore(&pdev->ptrlock, flags);
437 pdev->fill_frame = pdev->full_frames;
438 pdev->full_frames = pdev->full_frames->next;
441 pdev->fill_frame->next = NULL;
442 spin_unlock_irqrestore(&pdev->ptrlock, flags);
448 \brief Reset all buffers, pointers and lists, except for the image_used[] buffer.
450 If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble.
452 static void pwc_reset_buffers(struct pwc_device *pdev)
457 PWC_DEBUG_MEMORY(">> %s __enter__\n", __func__);
459 spin_lock_irqsave(&pdev->ptrlock, flags);
460 pdev->full_frames = NULL;
461 pdev->full_frames_tail = NULL;
462 for (i = 0; i < default_fbufs; i++) {
463 pdev->fbuf[i].filled = 0;
465 pdev->fbuf[i].next = &pdev->fbuf[i - 1];
467 pdev->fbuf->next = NULL;
469 pdev->empty_frames = &pdev->fbuf[default_fbufs - 1];
470 pdev->empty_frames_tail = pdev->fbuf;
471 pdev->read_frame = NULL;
472 pdev->fill_frame = pdev->empty_frames;
473 pdev->empty_frames = pdev->empty_frames->next;
475 pdev->image_read_pos = 0;
476 pdev->fill_image = 0;
477 spin_unlock_irqrestore(&pdev->ptrlock, flags);
479 PWC_DEBUG_MEMORY("<< %s __leaving__\n", __func__);
484 \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.
486 int pwc_handle_frame(struct pwc_device *pdev)
491 spin_lock_irqsave(&pdev->ptrlock, flags);
492 /* First grab our read_frame; this is removed from all lists, so
493 we can release the lock after this without problems */
494 if (pdev->read_frame != NULL) {
495 /* This can't theoretically happen */
496 PWC_ERROR("Huh? Read frame still in use?\n");
497 spin_unlock_irqrestore(&pdev->ptrlock, flags);
502 if (pdev->full_frames == NULL) {
503 PWC_ERROR("Woops. No frames ready.\n");
506 pdev->read_frame = pdev->full_frames;
507 pdev->full_frames = pdev->full_frames->next;
508 pdev->read_frame->next = NULL;
511 if (pdev->read_frame != NULL) {
512 /* Decompression is a lengthy process, so it's outside of the lock.
513 This gives the isoc_handler the opportunity to fill more frames
516 spin_unlock_irqrestore(&pdev->ptrlock, flags);
517 ret = pwc_decompress(pdev);
518 spin_lock_irqsave(&pdev->ptrlock, flags);
520 /* We're done with read_buffer, tack it to the end of the empty buffer list */
521 if (pdev->empty_frames == NULL) {
522 pdev->empty_frames = pdev->read_frame;
523 pdev->empty_frames_tail = pdev->empty_frames;
526 pdev->empty_frames_tail->next = pdev->read_frame;
527 pdev->empty_frames_tail = pdev->read_frame;
529 pdev->read_frame = NULL;
531 spin_unlock_irqrestore(&pdev->ptrlock, flags);
536 \brief Advance pointers of image buffer (after each user request)
538 void pwc_next_image(struct pwc_device *pdev)
540 pdev->image_used[pdev->fill_image] = 0;
541 pdev->fill_image = (pdev->fill_image + 1) % pwc_mbufs;
545 * Print debug information when a frame is discarded because all of our buffer
548 static void pwc_frame_dumped(struct pwc_device *pdev)
550 pdev->vframes_dumped++;
551 if (pdev->vframe_count < FRAME_LOWMARK)
554 if (pdev->vframes_dumped < 20)
555 PWC_DEBUG_FLOW("Dumping frame %d\n", pdev->vframe_count);
556 else if (pdev->vframes_dumped == 20)
557 PWC_DEBUG_FLOW("Dumping frame %d (last message)\n",
561 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
564 PWC_TRACE("Snapshot button pressed.\n");
565 pdev->snapshot_button_status = 1;
567 PWC_TRACE("Snapshot button released.\n");
570 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
571 if (pdev->button_dev) {
572 input_report_key(pdev->button_dev, KEY_CAMERA, down);
573 input_sync(pdev->button_dev);
578 static int pwc_rcv_short_packet(struct pwc_device *pdev, const struct pwc_frame_buf *fbuf)
582 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
583 frames on the USB wire after an exposure change. This conditition is
584 however detected in the cam and a bit is set in the header.
586 if (pdev->type == 730) {
587 unsigned char *ptr = (unsigned char *)fbuf->data;
589 if (ptr[1] == 1 && ptr[0] & 0x10) {
590 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
591 pdev->drop_frames += 2;
592 pdev->vframes_error++;
594 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
595 pwc_snapshot_button(pdev, ptr[0] & 0x01);
597 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
599 PWC_TRACE("Image is mirrored.\n");
601 PWC_TRACE("Image is normal.\n");
603 pdev->vmirror = ptr[0] & 0x03;
604 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
605 after a short frame; this condition is filtered out specifically. A 4 byte
606 frame doesn't make sense anyway.
607 So we get either this sequence:
608 drop_bit set -> 4 byte frame -> short frame -> good frame
610 drop_bit set -> short frame -> good frame
611 So we drop either 3 or 2 frames in all!
613 if (fbuf->filled == 4)
616 else if (pdev->type == 740 || pdev->type == 720) {
617 unsigned char *ptr = (unsigned char *)fbuf->data;
618 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
619 pwc_snapshot_button(pdev, ptr[0] & 0x01);
621 pdev->vmirror = ptr[0] & 0x03;
624 /* In case we were instructed to drop the frame, do so silently.
625 The buffer pointers are not updated either (but the counters are reset below).
627 if (pdev->drop_frames > 0)
630 /* Check for underflow first */
631 if (fbuf->filled < pdev->frame_total_size) {
632 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
633 " discarded.\n", fbuf->filled);
634 pdev->vframes_error++;
637 /* Send only once per EOF */
638 awake = 1; /* delay wake_ups */
640 /* Find our next frame to fill. This will always succeed, since we
641 * nick a frame from either empty or full list, but if we had to
642 * take it from the full list, it means a frame got dropped.
644 if (pwc_next_fill_frame(pdev))
645 pwc_frame_dumped(pdev);
649 pdev->vframe_count++;
653 /* This gets called for the Isochronous pipe (video). This is done in
654 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
656 static void pwc_isoc_handler(struct urb *urb)
658 struct pwc_device *pdev;
661 struct pwc_frame_buf *fbuf;
662 unsigned char *fillptr = NULL, *iso_buf = NULL;
665 pdev = (struct pwc_device *)urb->context;
667 PWC_ERROR("isoc_handler() called with NULL device?!\n");
671 if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
672 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
675 if (urb->status != -EINPROGRESS && urb->status != 0) {
679 switch(urb->status) {
680 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
681 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
682 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
683 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
684 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
685 case -ETIME: errmsg = "Device does not respond"; break;
687 PWC_DEBUG_FLOW("pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
688 /* Give up after a number of contiguous errors on the USB bus.
689 Appearantly something is wrong so we simulate an unplug event.
691 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
693 PWC_INFO("Too many ISOC errors, bailing out.\n");
694 pdev->error_status = EIO;
696 wake_up_interruptible(&pdev->frameq);
698 goto handler_end; // ugly, but practical
701 fbuf = pdev->fill_frame;
703 PWC_ERROR("pwc_isoc_handler without valid fill frame.\n");
708 fillptr = fbuf->data + fbuf->filled;
711 /* Reset ISOC error counter. We did get here, after all. */
712 pdev->visoc_errors = 0;
714 /* vsync: 0 = don't copy data
719 for (i = 0; i < urb->number_of_packets; i++) {
720 fst = urb->iso_frame_desc[i].status;
721 flen = urb->iso_frame_desc[i].actual_length;
722 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
724 if (flen > 0) { /* if valid data... */
725 if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */
728 /* ...copy data to frame buffer, if possible */
729 if (flen + fbuf->filled > pdev->frame_total_size) {
730 PWC_DEBUG_FLOW("Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen, pdev->frame_total_size);
731 pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */
732 pdev->vframes_error++;
735 memmove(fillptr, iso_buf, flen);
739 fbuf->filled += flen;
742 if (flen < pdev->vlast_packet_size) {
743 /* Shorter packet... We probably have the end of an image-frame;
744 wake up read() process and let select()/poll() do something.
745 Decompression is done in user time over there.
747 if (pdev->vsync == 2) {
748 if (pwc_rcv_short_packet(pdev, fbuf)) {
750 fbuf = pdev->fill_frame;
754 fillptr = fbuf->data;
758 pdev->vlast_packet_size = flen;
759 } /* ..status == 0 */
761 /* This is normally not interesting to the user, unless
762 * you are really debugging something, default = 0 */
763 static int iso_error;
766 PWC_DEBUG_FLOW("Iso frame %d of USB has error %d\n", i, fst);
772 wake_up_interruptible(&pdev->frameq);
774 urb->dev = pdev->udev;
775 i = usb_submit_urb(urb, GFP_ATOMIC);
777 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
781 int pwc_isoc_init(struct pwc_device *pdev)
783 struct usb_device *udev;
787 struct usb_interface *intf;
788 struct usb_host_interface *idesc = NULL;
797 /* Get the current alternate interface, adjust packet size */
798 if (!udev->actconfig)
800 intf = usb_ifnum_to_if(udev, 0);
802 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
807 /* Search video endpoint */
808 pdev->vmax_packet_size = -1;
809 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
810 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
811 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
816 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
817 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
818 return -ENFILE; /* Odd error, that should be noticeable */
821 /* Set alternate interface */
823 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
824 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
828 for (i = 0; i < MAX_ISO_BUFS; i++) {
829 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
831 PWC_ERROR("Failed to allocate urb %d\n", i);
835 pdev->sbuf[i].urb = urb;
836 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
839 /* De-allocate in reverse order */
841 usb_free_urb(pdev->sbuf[i].urb);
842 pdev->sbuf[i].urb = NULL;
847 /* init URB structure */
848 for (i = 0; i < MAX_ISO_BUFS; i++) {
849 urb = pdev->sbuf[i].urb;
851 urb->interval = 1; // devik
853 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
854 urb->transfer_flags = URB_ISO_ASAP;
855 urb->transfer_buffer = pdev->sbuf[i].data;
856 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
857 urb->complete = pwc_isoc_handler;
859 urb->start_frame = 0;
860 urb->number_of_packets = ISO_FRAMES_PER_DESC;
861 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
862 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
863 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
868 for (i = 0; i < MAX_ISO_BUFS; i++) {
869 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL);
871 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
873 pwc_isoc_cleanup(pdev);
876 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->sbuf[i].urb);
881 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
885 static void pwc_iso_stop(struct pwc_device *pdev)
889 /* Unlinking ISOC buffers one by one */
890 for (i = 0; i < MAX_ISO_BUFS; i++) {
893 urb = pdev->sbuf[i].urb;
895 PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb);
901 static void pwc_iso_free(struct pwc_device *pdev)
905 /* Freeing ISOC buffers one by one */
906 for (i = 0; i < MAX_ISO_BUFS; i++) {
909 urb = pdev->sbuf[i].urb;
911 PWC_DEBUG_MEMORY("Freeing URB\n");
913 pdev->sbuf[i].urb = NULL;
918 void pwc_isoc_cleanup(struct pwc_device *pdev)
920 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
923 if (pdev->iso_init == 0)
929 /* Stop camera, but only if we are sure the camera is still there (unplug
930 is signalled by EPIPE)
932 if (pdev->error_status != EPIPE) {
933 PWC_DEBUG_OPEN("Setting alternate interface 0.\n");
934 usb_set_interface(pdev->udev, 0, 0);
938 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
944 static struct pwc_device *cd_to_pwc(struct device *cd)
946 struct video_device *vdev = to_video_device(cd);
947 return video_get_drvdata(vdev);
950 static ssize_t show_pan_tilt(struct device *class_dev,
951 struct device_attribute *attr, char *buf)
953 struct pwc_device *pdev = cd_to_pwc(class_dev);
954 return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
957 static ssize_t store_pan_tilt(struct device *class_dev,
958 struct device_attribute *attr,
959 const char *buf, size_t count)
961 struct pwc_device *pdev = cd_to_pwc(class_dev);
965 if (strncmp(buf, "reset", 5) == 0)
966 ret = pwc_mpt_reset(pdev, 0x3);
968 else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
969 ret = pwc_mpt_set_angle(pdev, pan, tilt);
975 static DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
978 static ssize_t show_snapshot_button_status(struct device *class_dev,
979 struct device_attribute *attr, char *buf)
981 struct pwc_device *pdev = cd_to_pwc(class_dev);
982 int status = pdev->snapshot_button_status;
983 pdev->snapshot_button_status = 0;
984 return sprintf(buf, "%d\n", status);
987 static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
990 static int pwc_create_sysfs_files(struct pwc_device *pdev)
994 rc = device_create_file(&pdev->vdev.dev, &dev_attr_button);
997 if (pdev->features & FEATURE_MOTOR_PANTILT) {
998 rc = device_create_file(&pdev->vdev.dev, &dev_attr_pan_tilt);
1006 device_remove_file(&pdev->vdev.dev, &dev_attr_button);
1008 PWC_ERROR("Could not create sysfs files.\n");
1012 static void pwc_remove_sysfs_files(struct pwc_device *pdev)
1014 if (pdev->features & FEATURE_MOTOR_PANTILT)
1015 device_remove_file(&pdev->vdev.dev, &dev_attr_pan_tilt);
1016 device_remove_file(&pdev->vdev.dev, &dev_attr_button);
1019 #ifdef CONFIG_USB_PWC_DEBUG
1020 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
1022 switch(sensor_type) {
1024 return "Hyundai CMOS sensor";
1026 return "Sony CCD sensor + TDA8787";
1028 return "Sony CCD sensor + Exas 98L59";
1030 return "Sony CCD sensor + ADI 9804";
1032 return "Sharp CCD sensor + TDA8787";
1034 return "Sharp CCD sensor + Exas 98L59";
1036 return "Sharp CCD sensor + ADI 9804";
1038 return "UPA 1021 sensor";
1040 return "VGA sensor";
1042 return "PAL MR sensor";
1044 return "unknown type of sensor";
1049 /***************************************************************************/
1050 /* Video4Linux functions */
1052 static int pwc_video_open(struct file *file)
1055 struct video_device *vdev = video_devdata(file);
1056 struct pwc_device *pdev;
1058 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
1060 pdev = video_get_drvdata(vdev);
1063 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1067 pwc_construct(pdev); /* set min/max sizes correct */
1068 if (!pdev->usb_init) {
1069 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1072 /* Query sensor type */
1073 ret = pwc_get_cmos_sensor(pdev, &i);
1076 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1078 pwc_sensor_type_to_string(i), i);
1082 /* Turn on camera */
1084 i = pwc_camera_power(pdev, 1);
1086 PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
1088 /* Set LED on/off time */
1089 if (pwc_set_leds(pdev, led_on, led_off) < 0)
1090 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1093 /* So far, so good. Allocate memory. */
1094 i = pwc_allocate_buffers(pdev);
1096 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1097 pwc_free_buffers(pdev);
1101 /* Reset buffers & parameters */
1102 pwc_reset_buffers(pdev);
1103 for (i = 0; i < pwc_mbufs; i++)
1104 pdev->image_used[i] = 0;
1105 pdev->vframe_count = 0;
1106 pdev->vframes_dumped = 0;
1107 pdev->vframes_error = 0;
1108 pdev->visoc_errors = 0;
1109 pdev->error_status = 0;
1110 pwc_construct(pdev); /* set min/max sizes correct */
1112 /* Set some defaults */
1113 pdev->vsnapshot = 0;
1115 /* Set video size, first try the last used video size
1116 (or the default one); if that fails try QCIF/10 or QSIF/10;
1117 it that fails too, give up.
1119 i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1121 unsigned int default_resolution;
1122 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1123 if (pdev->type>= 730)
1124 default_resolution = PSZ_QSIF;
1126 default_resolution = PSZ_QCIF;
1128 i = pwc_set_video_mode(pdev,
1129 pwc_image_sizes[default_resolution].x,
1130 pwc_image_sizes[default_resolution].y,
1136 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1137 pwc_free_buffers(pdev);
1141 /* Initialize the webcam to sane value */
1142 pwc_set_brightness(pdev, 0x7fff);
1143 pwc_set_agc(pdev, 1, 0);
1146 file->private_data = vdev;
1147 PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1151 static void pwc_video_release(struct video_device *vfd)
1153 struct pwc_device *pdev = container_of(vfd, struct pwc_device, vdev);
1156 /* search device_hint[] table if we occupy a slot, by any chance */
1157 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1158 if (device_hint[hint].pdev == pdev)
1159 device_hint[hint].pdev = NULL;
1164 /* Note that all cleanup is done in the reverse order as in _open */
1165 static int pwc_video_close(struct file *file)
1167 struct video_device *vdev = file->private_data;
1168 struct pwc_device *pdev;
1171 PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
1173 pdev = video_get_drvdata(vdev);
1174 if (pdev->vopen == 0)
1175 PWC_DEBUG_MODULE("video_close() called on closed device?\n");
1177 /* Dump statistics, but only if a reasonable amount of frames were
1178 processed (to prevent endless log-entries in case of snap-shot
1181 if (pdev->vframe_count > 20)
1182 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);
1184 if (DEVICE_USE_CODEC1(pdev->type))
1189 pwc_isoc_cleanup(pdev);
1190 pwc_free_buffers(pdev);
1192 /* Turn off LEDS and power down camera, but only when not unplugged */
1193 if (!pdev->unplugged) {
1195 if (pwc_set_leds(pdev, 0, 0) < 0)
1196 PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
1198 i = pwc_camera_power(pdev, 0);
1200 PWC_ERROR("Failed to power down camera (%d)\n", i);
1203 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
1210 * FIXME: what about two parallel reads ????
1211 * ANSWER: Not supported. You can't open the device more than once,
1212 despite what the V4L1 interface says. First, I don't see
1213 the need, second there's no mechanism of alerting the
1214 2nd/3rd/... process of events like changing image size.
1215 And I don't see the point of blocking that for the
1216 2nd/3rd/... process.
1217 In multi-threaded environments reading parallel from any
1218 device is tricky anyhow.
1221 static ssize_t pwc_video_read(struct file *file, char __user *buf,
1222 size_t count, loff_t *ppos)
1224 struct video_device *vdev = file->private_data;
1225 struct pwc_device *pdev;
1226 int noblock = file->f_flags & O_NONBLOCK;
1227 DECLARE_WAITQUEUE(wait, current);
1228 int bytes_to_read, rv = 0;
1229 void *image_buffer_addr;
1231 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1235 pdev = video_get_drvdata(vdev);
1239 if (pdev->error_status) {
1240 rv = -pdev->error_status; /* Something happened, report what. */
1244 /* Start the stream (if not already started) */
1245 rv = pwc_isoc_init(pdev);
1249 /* In case we're doing partial reads, we don't have to wait for a frame */
1250 if (pdev->image_read_pos == 0) {
1251 /* Do wait queueing according to the (doc)book */
1252 add_wait_queue(&pdev->frameq, &wait);
1253 while (pdev->full_frames == NULL) {
1254 /* Check for unplugged/etc. here */
1255 if (pdev->error_status) {
1256 remove_wait_queue(&pdev->frameq, &wait);
1257 set_current_state(TASK_RUNNING);
1258 rv = -pdev->error_status ;
1262 remove_wait_queue(&pdev->frameq, &wait);
1263 set_current_state(TASK_RUNNING);
1267 if (signal_pending(current)) {
1268 remove_wait_queue(&pdev->frameq, &wait);
1269 set_current_state(TASK_RUNNING);
1273 mutex_unlock(&pdev->modlock);
1275 set_current_state(TASK_INTERRUPTIBLE);
1276 mutex_lock(&pdev->modlock);
1278 remove_wait_queue(&pdev->frameq, &wait);
1279 set_current_state(TASK_RUNNING);
1281 /* Decompress and release frame */
1282 if (pwc_handle_frame(pdev)) {
1288 PWC_DEBUG_READ("Copying data to user space.\n");
1289 if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
1290 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1292 bytes_to_read = pdev->view.size;
1294 /* copy bytes to user space; we allow for partial reads */
1295 if (count + pdev->image_read_pos > bytes_to_read)
1296 count = bytes_to_read - pdev->image_read_pos;
1297 image_buffer_addr = pdev->image_data;
1298 image_buffer_addr += pdev->images[pdev->fill_image].offset;
1299 image_buffer_addr += pdev->image_read_pos;
1300 if (copy_to_user(buf, image_buffer_addr, count)) {
1304 pdev->image_read_pos += count;
1305 if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
1306 pdev->image_read_pos = 0;
1307 pwc_next_image(pdev);
1314 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1316 struct video_device *vdev = file->private_data;
1317 struct pwc_device *pdev;
1322 pdev = video_get_drvdata(vdev);
1326 /* Start the stream (if not already started) */
1327 ret = pwc_isoc_init(pdev);
1331 poll_wait(file, &pdev->frameq, wait);
1332 if (pdev->error_status)
1334 if (pdev->full_frames != NULL) /* we have frames waiting */
1335 return (POLLIN | POLLRDNORM);
1340 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1342 struct video_device *vdev = file->private_data;
1343 struct pwc_device *pdev;
1344 unsigned long start;
1346 unsigned long page, pos = 0;
1349 PWC_DEBUG_MEMORY(">> %s\n", __func__);
1350 pdev = video_get_drvdata(vdev);
1351 size = vma->vm_end - vma->vm_start;
1352 start = vma->vm_start;
1354 /* Find the idx buffer for this mapping */
1355 for (index = 0; index < pwc_mbufs; index++) {
1356 pos = pdev->images[index].offset;
1357 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1360 if (index == MAX_IMAGES)
1364 * Special case for v4l1. In v4l1, we map only one big buffer,
1365 * but in v4l2 each buffer is mapped
1367 unsigned long total_size;
1368 total_size = pwc_mbufs * pdev->len_per_image;
1369 if (size != pdev->len_per_image && size != total_size) {
1370 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1371 size, pdev->len_per_image, total_size);
1374 } else if (size > pdev->len_per_image)
1377 vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
1379 pos += (unsigned long)pdev->image_data;
1381 page = vmalloc_to_pfn((void *)pos);
1382 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1386 if (size > PAGE_SIZE)
1394 /***************************************************************************/
1397 /* This function gets called when a new device is plugged in or the usb core
1401 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1403 struct usb_device *udev = interface_to_usbdev(intf);
1404 struct pwc_device *pdev = NULL;
1405 int vendor_id, product_id, type_id;
1408 int video_nr = -1; /* default: use next available device */
1409 char serial_number[30], *name;
1411 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1412 product_id = le16_to_cpu(udev->descriptor.idProduct);
1414 /* Check if we can handle this device */
1415 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1416 vendor_id, product_id,
1417 intf->altsetting->desc.bInterfaceNumber);
1419 /* the interfaces are probed one by one. We are only interested in the
1420 video interface (0) now.
1421 Interface 1 is the Audio Control, and interface 2 Audio itself.
1423 if (intf->altsetting->desc.bInterfaceNumber > 0)
1426 if (vendor_id == 0x0471) {
1427 switch (product_id) {
1429 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1430 name = "Philips 645 webcam";
1434 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1435 name = "Philips 646 webcam";
1439 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1440 name = "Askey VC010 webcam";
1444 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1445 name = "Philips 675 webcam";
1449 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1450 name = "Philips 680 webcam";
1454 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1455 name = "Philips 690 webcam";
1459 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1460 name = "Philips 730 webcam";
1464 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1465 name = "Philips 740 webcam";
1469 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1470 name = "Philips 750 webcam";
1474 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1475 name = "Philips 720K/40 webcam";
1479 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1480 name = "Philips SPC 900NC webcam";
1488 else if (vendor_id == 0x069A) {
1489 switch(product_id) {
1491 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1492 name = "Askey VC010 webcam";
1500 else if (vendor_id == 0x046d) {
1501 switch(product_id) {
1503 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1504 name = "Logitech QuickCam Pro 3000";
1505 type_id = 740; /* CCD sensor */
1508 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1509 name = "Logitech QuickCam Notebook Pro";
1510 type_id = 740; /* CCD sensor */
1513 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1514 name = "Logitech QuickCam Pro 4000";
1515 type_id = 740; /* CCD sensor */
1518 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1519 name = "Logitech QuickCam Zoom";
1520 type_id = 740; /* CCD sensor */
1523 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1524 name = "Logitech QuickCam Zoom";
1525 type_id = 740; /* CCD sensor */
1529 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1530 name = "Logitech QuickCam Orbit";
1531 type_id = 740; /* CCD sensor */
1532 features |= FEATURE_MOTOR_PANTILT;
1535 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1536 name = "Cisco VT Camera";
1537 type_id = 740; /* CCD sensor */
1540 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1541 name = "Logitech ViewPort AV 100";
1542 type_id = 740; /* CCD sensor */
1544 case 0x08b8: /* Where this released? */
1545 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1546 name = "Logitech QuickCam (res.)";
1547 type_id = 730; /* Assuming CMOS */
1554 else if (vendor_id == 0x055d) {
1555 /* I don't know the difference between the C10 and the C30;
1556 I suppose the difference is the sensor, but both cameras
1557 work equally well with a type_id of 675
1559 switch(product_id) {
1561 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1562 name = "Samsung MPC-C10";
1566 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1567 name = "Samsung MPC-C30";
1571 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1572 name = "Samsung MPC-C30";
1580 else if (vendor_id == 0x041e) {
1581 switch(product_id) {
1583 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1584 name = "Creative Labs Webcam 5";
1588 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1589 name = "Creative Labs Webcam Pro Ex";
1597 else if (vendor_id == 0x04cc) {
1598 switch(product_id) {
1600 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1601 name = "Sotec Afina Eye";
1609 else if (vendor_id == 0x06be) {
1610 switch(product_id) {
1612 /* This is essentially the same cam as the Sotec Afina Eye */
1613 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1614 name = "AME Co. Afina Eye";
1623 else if (vendor_id == 0x0d81) {
1624 switch(product_id) {
1626 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1627 name = "Visionite VCS-UC300";
1628 type_id = 740; /* CCD sensor */
1631 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1632 name = "Visionite VCS-UM100";
1633 type_id = 730; /* CMOS sensor */
1641 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1643 memset(serial_number, 0, 30);
1644 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1645 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1647 if (udev->descriptor.bNumConfigurations > 1)
1648 PWC_WARNING("Warning: more than 1 configuration available.\n");
1650 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1651 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1653 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1656 pdev->type = type_id;
1657 pdev->vsize = default_size;
1658 pdev->vframes = default_fps;
1659 strcpy(pdev->serial, serial_number);
1660 pdev->features = features;
1661 if (vendor_id == 0x046D && product_id == 0x08B5) {
1662 /* Logitech QuickCam Orbit
1663 The ranges have been determined experimentally; they may differ from cam to cam.
1664 Also, the exact ranges left-right and up-down are different for my cam
1666 pdev->angle_range.pan_min = -7000;
1667 pdev->angle_range.pan_max = 7000;
1668 pdev->angle_range.tilt_min = -3000;
1669 pdev->angle_range.tilt_max = 2500;
1672 mutex_init(&pdev->modlock);
1673 spin_lock_init(&pdev->ptrlock);
1676 init_waitqueue_head(&pdev->frameq);
1677 pdev->vcompression = pwc_preferred_compression;
1679 /* Init video_device structure */
1680 memcpy(&pdev->vdev, &pwc_template, sizeof(pwc_template));
1681 pdev->vdev.parent = &intf->dev;
1682 pdev->vdev.lock = &pdev->modlock;
1683 strcpy(pdev->vdev.name, name);
1684 video_set_drvdata(&pdev->vdev, pdev);
1686 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1687 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1689 /* Now search device_hint[] table for a match, so we can hint a node number. */
1690 for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1691 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1692 (device_hint[hint].pdev == NULL)) {
1693 /* so far, so good... try serial number */
1694 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1696 video_nr = device_hint[hint].device_node;
1697 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1704 if (hint < MAX_DEV_HINTS)
1705 device_hint[hint].pdev = pdev;
1707 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1708 usb_set_intfdata(intf, pdev);
1710 /* Set the leds off */
1711 pwc_set_leds(pdev, 0, 0);
1712 pwc_camera_power(pdev, 0);
1714 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1716 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1719 rc = pwc_create_sysfs_files(pdev);
1721 goto err_video_unreg;
1723 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1725 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1726 /* register webcam snapshot button input device */
1727 pdev->button_dev = input_allocate_device();
1728 if (!pdev->button_dev) {
1729 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1731 pwc_remove_sysfs_files(pdev);
1732 goto err_video_unreg;
1735 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1736 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1738 pdev->button_dev->name = "PWC snapshot button";
1739 pdev->button_dev->phys = pdev->button_phys;
1740 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1741 pdev->button_dev->dev.parent = &pdev->udev->dev;
1742 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1743 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1745 rc = input_register_device(pdev->button_dev);
1747 input_free_device(pdev->button_dev);
1748 pdev->button_dev = NULL;
1749 pwc_remove_sysfs_files(pdev);
1750 goto err_video_unreg;
1757 if (hint < MAX_DEV_HINTS)
1758 device_hint[hint].pdev = NULL;
1759 video_unregister_device(&pdev->vdev);
1765 /* The user yanked out the cable... */
1766 static void usb_pwc_disconnect(struct usb_interface *intf)
1768 struct pwc_device *pdev = usb_get_intfdata(intf);
1770 mutex_lock(&pdev->modlock);
1771 usb_set_intfdata (intf, NULL);
1773 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1774 goto disconnect_out;
1776 if (pdev->udev == NULL) {
1777 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1778 goto disconnect_out;
1780 if (pdev->udev != interface_to_usbdev(intf)) {
1781 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1782 goto disconnect_out;
1785 /* We got unplugged; this is signalled by an EPIPE error code */
1786 pdev->error_status = EPIPE;
1787 pdev->unplugged = 1;
1789 /* Alert waiting processes */
1790 wake_up_interruptible(&pdev->frameq);
1792 /* No need to keep the urbs around after disconnection */
1793 pwc_isoc_cleanup(pdev);
1796 mutex_unlock(&pdev->modlock);
1798 pwc_remove_sysfs_files(pdev);
1799 video_unregister_device(&pdev->vdev);
1801 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1802 if (pdev->button_dev)
1803 input_unregister_device(pdev->button_dev);
1809 * Initialization code & module stuff
1816 static int compression = -1;
1817 static int leds[2] = { -1, -1 };
1818 static unsigned int leds_nargs;
1819 static char *dev_hint[MAX_DEV_HINTS];
1820 static unsigned int dev_hint_nargs;
1822 module_param(size, charp, 0444);
1823 module_param(fps, int, 0444);
1824 module_param(fbufs, int, 0444);
1825 module_param(mbufs, int, 0444);
1826 #ifdef CONFIG_USB_PWC_DEBUG
1827 module_param_named(trace, pwc_trace, int, 0644);
1829 module_param(power_save, int, 0444);
1830 module_param(compression, int, 0444);
1831 module_param_array(leds, int, &leds_nargs, 0444);
1832 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1834 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1835 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1836 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1837 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1838 #ifdef CONFIG_USB_PWC_DEBUG
1839 MODULE_PARM_DESC(trace, "For debugging purposes");
1841 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1842 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1843 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1844 MODULE_PARM_DESC(dev_hint, "Device node hints");
1846 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1847 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1848 MODULE_LICENSE("GPL");
1849 MODULE_ALIAS("pwcx");
1850 MODULE_VERSION( PWC_VERSION );
1852 static int __init usb_pwc_init(void)
1855 char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1857 PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1858 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1859 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1860 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1863 if (fps < 4 || fps > 30) {
1864 PWC_ERROR("Framerate out of bounds (4-30).\n");
1868 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1872 /* string; try matching with array */
1873 for (sz = 0; sz < PSZ_MAX; sz++) {
1874 if (!strcmp(sizenames[sz], size)) { /* Found! */
1879 if (sz == PSZ_MAX) {
1880 PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1883 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);
1886 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1887 PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
1891 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
1894 if (fbufs < 2 || fbufs > MAX_FRAMES) {
1895 PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
1898 default_fbufs = fbufs;
1899 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
1901 #ifdef CONFIG_USB_PWC_DEBUG
1902 if (pwc_trace >= 0) {
1903 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1906 if (compression >= 0) {
1907 if (compression > 3) {
1908 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1911 pwc_preferred_compression = compression;
1912 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
1915 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
1921 /* Big device node whoopla. Basically, it allows you to assign a
1922 device node (/dev/videoX) to a camera, based on its type
1923 & serial number. The format is [type[.serialnumber]:]node.
1925 Any camera that isn't matched by these rules gets the next
1926 available free device node.
1928 for (i = 0; i < MAX_DEV_HINTS; i++) {
1929 char *s, *colon, *dot;
1931 /* This loop also initializes the array */
1932 device_hint[i].pdev = NULL;
1934 if (s != NULL && *s != '\0') {
1935 device_hint[i].type = -1; /* wildcard */
1936 strcpy(device_hint[i].serial_number, "*");
1938 /* parse string: chop at ':' & '/' */
1940 while (*colon != '\0' && *colon != ':')
1942 while (*dot != '\0' && *dot != '.')
1944 /* Few sanity checks */
1945 if (*dot != '\0' && dot > colon) {
1946 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
1950 if (*colon == '\0') {
1953 PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
1957 /* No type or serial number specified, just a number. */
1958 device_hint[i].device_node =
1959 simple_strtol(s, NULL, 10);
1963 /* There's a colon, so we have at least a type and a device node */
1964 device_hint[i].type =
1965 simple_strtol(s, NULL, 10);
1966 device_hint[i].device_node =
1967 simple_strtol(colon + 1, NULL, 10);
1969 /* There's a serial number as well */
1974 while (*dot != ':' && k < 29) {
1975 device_hint[i].serial_number[k++] = *dot;
1978 device_hint[i].serial_number[k] = '\0';
1981 PWC_TRACE("device_hint[%d]:\n", i);
1982 PWC_TRACE(" type : %d\n", device_hint[i].type);
1983 PWC_TRACE(" serial# : %s\n", device_hint[i].serial_number);
1984 PWC_TRACE(" node : %d\n", device_hint[i].device_node);
1987 device_hint[i].type = 0; /* not filled */
1988 } /* ..for MAX_DEV_HINTS */
1990 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
1991 return usb_register(&pwc_driver);
1994 static void __exit usb_pwc_exit(void)
1996 PWC_DEBUG_MODULE("Deregistering driver.\n");
1997 usb_deregister(&pwc_driver);
1998 PWC_INFO("Philips webcam module removed.\n");
2001 module_init(usb_pwc_init);
2002 module_exit(usb_pwc_exit);
2004 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */