1 /* Linux driver for Philips webcam
2 USB and Video4Linux interface part.
3 (C) 1999-2004 Nemosoft Unv.
4 (C) 2004-2006 Luc Saillard (luc@saillard.org)
6 NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
7 driver and thus may have bugs that are not present in the original version.
8 Please send bug reports and support requests to <luc@saillard.org>.
9 The decompression routines have been implemented by reverse-engineering the
10 Nemosoft binary pwcx module. Caveat emptor.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 This code forms the interface between the USB layers and the Philips
30 specific stuff. Some adanved stuff of the driver falls under an
31 NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
32 is thus not distributed in source form. The binary pwcx.o module
33 contains the code that falls under the NDA.
35 In case you're wondering: 'pwc' stands for "Philips WebCam", but
36 I really didn't want to type 'philips_web_cam' every time (I'm lazy as
37 any Linux kernel hacker, but I don't like uncomprehensible abbreviations
40 Oh yes, convention: to disctinguish between all the various pointers to
41 device-structures, I use these names for the pointer variables:
42 udev: struct usb_device *
43 vdev: struct video_device *
44 pdev: struct pwc_devive *
48 - Alvarado: adding whitebalance code
49 - Alistar Moire: QuickCam 3000 Pro device/product ID
50 - Tony Hoyle: Creative Labs Webcam 5 device/product ID
51 - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
52 - Jk Fang: Sotec Afina Eye ID
53 - Xavier Roche: QuickCam Pro 4000 ID
54 - Jens Knudsen: QuickCam Zoom ID
55 - J. Debert: QuickCam for Notebooks ID
58 #include <linux/errno.h>
59 #include <linux/init.h>
61 #include <linux/module.h>
62 #include <linux/poll.h>
63 #include <linux/slab.h>
64 #include <linux/vmalloc.h>
65 #include <linux/version.h>
67 #include <linux/moduleparam.h>
70 #include "pwc-kiara.h"
71 #include "pwc-timon.h"
72 #include "pwc-dec23.h"
74 #include "pwc-uncompress.h"
76 /* Function prototypes and driver templates */
78 /* hotplug device table support */
79 static const struct usb_device_id pwc_device_table
[] = {
80 { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */
81 { USB_DEVICE(0x0471, 0x0303) },
82 { USB_DEVICE(0x0471, 0x0304) },
83 { USB_DEVICE(0x0471, 0x0307) },
84 { USB_DEVICE(0x0471, 0x0308) },
85 { USB_DEVICE(0x0471, 0x030C) },
86 { USB_DEVICE(0x0471, 0x0310) },
87 { USB_DEVICE(0x0471, 0x0311) }, /* Philips ToUcam PRO II */
88 { USB_DEVICE(0x0471, 0x0312) },
89 { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
90 { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC PC Camera */
91 { USB_DEVICE(0x069A, 0x0001) }, /* Askey */
92 { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
93 { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
94 { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
95 { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
96 { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
97 { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
98 { USB_DEVICE(0x046D, 0x08B6) }, /* Logitech (reserved) */
99 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech (reserved) */
100 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
101 { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
102 { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
103 { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
104 { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
105 { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
106 { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
107 { USB_DEVICE(0x06BE, 0x8116) }, /* new Afina Eye */
108 { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
109 { USB_DEVICE(0x0d81, 0x1900) },
112 MODULE_DEVICE_TABLE(usb
, pwc_device_table
);
114 static int usb_pwc_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
);
115 static void usb_pwc_disconnect(struct usb_interface
*intf
);
117 static struct usb_driver pwc_driver
= {
118 .name
= "Philips webcam", /* name */
119 .id_table
= pwc_device_table
,
120 .probe
= usb_pwc_probe
, /* probe() */
121 .disconnect
= usb_pwc_disconnect
, /* disconnect() */
124 #define MAX_DEV_HINTS 20
125 #define MAX_ISOC_ERRORS 20
127 static int default_size
= PSZ_QCIF
;
128 static int default_fps
= 10;
129 static int default_fbufs
= 3; /* Default number of frame buffers */
130 int pwc_mbufs
= 2; /* Default number of mmap() buffers */
132 int pwc_trace
= PWC_DEBUG_LEVEL
;
134 static int power_save
= 0;
135 static int led_on
= 100, led_off
= 0; /* defaults to LED that is on while in use */
136 static int pwc_preferred_compression
= 1; /* 0..3 = uncompressed..high */
139 char serial_number
[30];
141 struct pwc_device
*pdev
;
142 } device_hint
[MAX_DEV_HINTS
];
146 static int pwc_video_open(struct inode
*inode
, struct file
*file
);
147 static int pwc_video_close(struct inode
*inode
, struct file
*file
);
148 static ssize_t
pwc_video_read(struct file
*file
, char __user
*buf
,
149 size_t count
, loff_t
*ppos
);
150 static unsigned int pwc_video_poll(struct file
*file
, poll_table
*wait
);
151 static int pwc_video_ioctl(struct inode
*inode
, struct file
*file
,
152 unsigned int ioctlnr
, unsigned long arg
);
153 static int pwc_video_mmap(struct file
*file
, struct vm_area_struct
*vma
);
155 static struct file_operations pwc_fops
= {
156 .owner
= THIS_MODULE
,
157 .open
= pwc_video_open
,
158 .release
= pwc_video_close
,
159 .read
= pwc_video_read
,
160 .poll
= pwc_video_poll
,
161 .mmap
= pwc_video_mmap
,
162 .ioctl
= pwc_video_ioctl
,
163 .compat_ioctl
= v4l_compat_ioctl32
,
166 static struct video_device pwc_template
= {
167 .owner
= THIS_MODULE
,
168 .name
= "Philips Webcam", /* Filled in later */
169 .type
= VID_TYPE_CAPTURE
,
170 .hardware
= VID_HARDWARE_PWC
,
171 .release
= video_device_release
,
176 /***************************************************************************/
178 /* Okay, this is some magic that I worked out and the reasoning behind it...
180 The biggest problem with any USB device is of course: "what to do
181 when the user unplugs the device while it is in use by an application?"
182 We have several options:
183 1) Curse them with the 7 plagues when they do (requires divine intervention)
184 2) Tell them not to (won't work: they'll do it anyway)
185 3) Oops the kernel (this will have a negative effect on a user's uptime)
186 4) Do something sensible.
188 Of course, we go for option 4.
190 It happens that this device will be linked to two times, once from
191 usb_device and once from the video_device in their respective 'private'
192 pointers. This is done when the device is probed() and all initialization
193 succeeded. The pwc_device struct links back to both structures.
195 When a device is unplugged while in use it will be removed from the
196 list of known USB devices; I also de-register it as a V4L device, but
197 unfortunately I can't free the memory since the struct is still in use
198 by the file descriptor. This free-ing is then deferend until the first
199 opportunity. Crude, but it works.
201 A small 'advantage' is that if a user unplugs the cam and plugs it back
202 in, it should get assigned the same video device minor, but unfortunately
203 it's non-trivial to re-link the cam back to the video device... (that
204 would surely be magic! :))
207 /***************************************************************************/
208 /* Private functions */
210 /* Here we want the physical address of the memory.
211 * This is used when initializing the contents of the area.
216 static void *pwc_rvmalloc(unsigned long size
)
221 mem
=vmalloc_32(size
);
225 memset(mem
, 0, size
); /* Clear the ram out, no junk to the user */
226 adr
=(unsigned long) mem
;
229 SetPageReserved(vmalloc_to_page((void *)adr
));
236 static void pwc_rvfree(void * mem
, unsigned long size
)
243 adr
=(unsigned long) mem
;
244 while ((long) size
> 0)
246 ClearPageReserved(vmalloc_to_page((void *)adr
));
256 static int pwc_allocate_buffers(struct pwc_device
*pdev
)
261 PWC_DEBUG_MEMORY(">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev
);
266 /* Allocate Isochronuous pipe buffers */
267 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
268 if (pdev
->sbuf
[i
].data
== NULL
) {
269 kbuf
= kzalloc(ISO_BUFFER_SIZE
, GFP_KERNEL
);
271 PWC_ERROR("Failed to allocate iso buffer %d.\n", i
);
274 PWC_DEBUG_MEMORY("Allocated iso buffer at %p.\n", kbuf
);
275 pdev
->sbuf
[i
].data
= kbuf
;
279 /* Allocate frame buffer structure */
280 if (pdev
->fbuf
== NULL
) {
281 kbuf
= kzalloc(default_fbufs
* sizeof(struct pwc_frame_buf
), GFP_KERNEL
);
283 PWC_ERROR("Failed to allocate frame buffer structure.\n");
286 PWC_DEBUG_MEMORY("Allocated frame buffer structure at %p.\n", kbuf
);
290 /* create frame buffers, and make circular ring */
291 for (i
= 0; i
< default_fbufs
; i
++) {
292 if (pdev
->fbuf
[i
].data
== NULL
) {
293 kbuf
= vmalloc(PWC_FRAME_SIZE
); /* need vmalloc since frame buffer > 128K */
295 PWC_ERROR("Failed to allocate frame buffer %d.\n", i
);
298 PWC_DEBUG_MEMORY("Allocated frame buffer %d at %p.\n", i
, kbuf
);
299 pdev
->fbuf
[i
].data
= kbuf
;
300 memset(kbuf
, 0, PWC_FRAME_SIZE
);
304 /* Allocate decompressor table space */
305 if (DEVICE_USE_CODEC1(pdev
->type
))
306 err
= pwc_dec1_alloc(pdev
);
308 err
= pwc_dec23_alloc(pdev
);
311 PWC_ERROR("Failed to allocate decompress table.\n");
315 /* Allocate image buffer; double buffer for mmap() */
316 kbuf
= pwc_rvmalloc(pwc_mbufs
* pdev
->len_per_image
);
318 PWC_ERROR("Failed to allocate image buffer(s). needed (%d)\n",
319 pwc_mbufs
* pdev
->len_per_image
);
322 PWC_DEBUG_MEMORY("Allocated image buffer at %p.\n", kbuf
);
323 pdev
->image_data
= kbuf
;
324 for (i
= 0; i
< pwc_mbufs
; i
++) {
325 pdev
->images
[i
].offset
= i
* pdev
->len_per_image
;
326 pdev
->images
[i
].vma_use_count
= 0;
328 for (; i
< MAX_IMAGES
; i
++) {
329 pdev
->images
[i
].offset
= 0;
334 PWC_DEBUG_MEMORY("<< pwc_allocate_buffers()\n");
338 static void pwc_free_buffers(struct pwc_device
*pdev
)
342 PWC_DEBUG_MEMORY("Entering free_buffers(%p).\n", pdev
);
346 /* Release Iso-pipe buffers */
347 for (i
= 0; i
< MAX_ISO_BUFS
; i
++)
348 if (pdev
->sbuf
[i
].data
!= NULL
) {
349 PWC_DEBUG_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 PWC_DEBUG_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 PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n", pdev
->decompress_data
);
370 kfree(pdev
->decompress_data
);
371 pdev
->decompress_data
= NULL
;
374 /* Release image buffers */
375 if (pdev
->image_data
!= NULL
) {
376 PWC_DEBUG_MEMORY("Freeing image buffer at %p.\n", pdev
->image_data
);
377 pwc_rvfree(pdev
->image_data
, pwc_mbufs
* pdev
->len_per_image
);
379 pdev
->image_data
= NULL
;
381 PWC_DEBUG_MEMORY("Leaving free_buffers().\n");
384 /* The frame & image buffer mess.
386 Yes, this is a mess. Well, it used to be simple, but alas... In this
387 module, 3 buffers schemes are used to get the data from the USB bus to
388 the user program. The first scheme involves the ISO buffers (called thus
389 since they transport ISO data from the USB controller), and not really
390 interesting. Suffices to say the data from this buffer is quickly
391 gathered in an interrupt handler (pwc_isoc_handler) and placed into the
394 The frame buffer is the second scheme, and is the central element here.
395 It collects the data from a single frame from the camera (hence, the
396 name). Frames are delimited by the USB camera with a short USB packet,
397 so that's easy to detect. The frame buffers form a list that is filled
398 by the camera+USB controller and drained by the user process through
399 either read() or mmap().
401 The image buffer is the third scheme, in which frames are decompressed
402 and converted into planar format. For mmap() there is more than
403 one image buffer available.
405 The frame buffers provide the image buffering. In case the user process
406 is a bit slow, this introduces lag and some undesired side-effects.
407 The problem arises when the frame buffer is full. I used to drop the last
408 frame, which makes the data in the queue stale very quickly. But dropping
409 the frame at the head of the queue proved to be a litte bit more difficult.
410 I tried a circular linked scheme, but this introduced more problems than
413 Because filling and draining are completely asynchronous processes, this
414 requires some fiddling with pointers and mutexes.
416 Eventually, I came up with a system with 2 lists: an 'empty' frame list
417 and a 'full' frame list:
418 * Initially, all frame buffers but one are on the 'empty' list; the one
419 remaining buffer is our initial fill frame.
420 * If a frame is needed for filling, we try to take it from the 'empty'
421 list, unless that list is empty, in which case we take the buffer at
422 the head of the 'full' list.
423 * When our fill buffer has been filled, it is appended to the 'full'
425 * If a frame is needed by read() or mmap(), it is taken from the head of
426 the 'full' list, handled, and then appended to the 'empty' list. If no
427 buffer is present on the 'full' list, we wait.
428 The advantage is that the buffer that is currently being decompressed/
429 converted, is on neither list, and thus not in our way (any other scheme
430 I tried had the problem of old data lingering in the queue).
432 Whatever strategy you choose, it always remains a tradeoff: with more
433 frame buffers the chances of a missed frame are reduced. On the other
434 hand, on slower machines it introduces lag because the queue will
439 \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.
441 static int pwc_next_fill_frame(struct pwc_device
*pdev
)
447 spin_lock_irqsave(&pdev
->ptrlock
, flags
);
448 if (pdev
->fill_frame
!= NULL
) {
449 /* append to 'full' list */
450 if (pdev
->full_frames
== NULL
) {
451 pdev
->full_frames
= pdev
->fill_frame
;
452 pdev
->full_frames_tail
= pdev
->full_frames
;
455 pdev
->full_frames_tail
->next
= pdev
->fill_frame
;
456 pdev
->full_frames_tail
= pdev
->fill_frame
;
459 if (pdev
->empty_frames
!= NULL
) {
460 /* We have empty frames available. That's easy */
461 pdev
->fill_frame
= pdev
->empty_frames
;
462 pdev
->empty_frames
= pdev
->empty_frames
->next
;
465 /* Hmm. Take it from the full list */
467 if (pdev
->full_frames
== NULL
) {
468 PWC_ERROR("Neither empty or full frames available!\n");
469 spin_unlock_irqrestore(&pdev
->ptrlock
, flags
);
472 pdev
->fill_frame
= pdev
->full_frames
;
473 pdev
->full_frames
= pdev
->full_frames
->next
;
476 pdev
->fill_frame
->next
= NULL
;
477 spin_unlock_irqrestore(&pdev
->ptrlock
, flags
);
483 \brief Reset all buffers, pointers and lists, except for the image_used[] buffer.
485 If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble.
487 static void pwc_reset_buffers(struct pwc_device
*pdev
)
492 PWC_DEBUG_MEMORY(">> %s __enter__\n", __FUNCTION__
);
494 spin_lock_irqsave(&pdev
->ptrlock
, flags
);
495 pdev
->full_frames
= NULL
;
496 pdev
->full_frames_tail
= NULL
;
497 for (i
= 0; i
< default_fbufs
; i
++) {
498 pdev
->fbuf
[i
].filled
= 0;
500 pdev
->fbuf
[i
].next
= &pdev
->fbuf
[i
- 1];
502 pdev
->fbuf
->next
= NULL
;
504 pdev
->empty_frames
= &pdev
->fbuf
[default_fbufs
- 1];
505 pdev
->empty_frames_tail
= pdev
->fbuf
;
506 pdev
->read_frame
= NULL
;
507 pdev
->fill_frame
= pdev
->empty_frames
;
508 pdev
->empty_frames
= pdev
->empty_frames
->next
;
510 pdev
->image_read_pos
= 0;
511 pdev
->fill_image
= 0;
512 spin_unlock_irqrestore(&pdev
->ptrlock
, flags
);
514 PWC_DEBUG_MEMORY("<< %s __leaving__\n", __FUNCTION__
);
519 \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.
521 int pwc_handle_frame(struct pwc_device
*pdev
)
526 spin_lock_irqsave(&pdev
->ptrlock
, flags
);
527 /* First grab our read_frame; this is removed from all lists, so
528 we can release the lock after this without problems */
529 if (pdev
->read_frame
!= NULL
) {
530 /* This can't theoretically happen */
531 PWC_ERROR("Huh? Read frame still in use?\n");
532 spin_unlock_irqrestore(&pdev
->ptrlock
, flags
);
537 if (pdev
->full_frames
== NULL
) {
538 PWC_ERROR("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
) {
547 /* Decompression is a lenghty process, so it's outside of the lock.
548 This gives the isoc_handler the opportunity to fill more frames
551 spin_unlock_irqrestore(&pdev
->ptrlock
, flags
);
552 ret
= pwc_decompress(pdev
);
553 spin_lock_irqsave(&pdev
->ptrlock
, flags
);
555 /* We're done with read_buffer, tack it to the end of the empty buffer list */
556 if (pdev
->empty_frames
== NULL
) {
557 pdev
->empty_frames
= pdev
->read_frame
;
558 pdev
->empty_frames_tail
= pdev
->empty_frames
;
561 pdev
->empty_frames_tail
->next
= pdev
->read_frame
;
562 pdev
->empty_frames_tail
= pdev
->read_frame
;
564 pdev
->read_frame
= NULL
;
566 spin_unlock_irqrestore(&pdev
->ptrlock
, flags
);
571 \brief Advance pointers of image buffer (after each user request)
573 void pwc_next_image(struct pwc_device
*pdev
)
575 pdev
->image_used
[pdev
->fill_image
] = 0;
576 pdev
->fill_image
= (pdev
->fill_image
+ 1) % pwc_mbufs
;
580 * Print debug information when a frame is discarded because all of our buffer
583 static void pwc_frame_dumped(struct pwc_device
*pdev
)
585 pdev
->vframes_dumped
++;
586 if (pdev
->vframe_count
< FRAME_LOWMARK
)
589 if (pdev
->vframes_dumped
< 20)
590 PWC_DEBUG_FLOW("Dumping frame %d\n", pdev
->vframe_count
);
591 else if (pdev
->vframes_dumped
== 20)
592 PWC_DEBUG_FLOW("Dumping frame %d (last message)\n",
596 static int pwc_rcv_short_packet(struct pwc_device
*pdev
, const struct pwc_frame_buf
*fbuf
)
600 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
601 frames on the USB wire after an exposure change. This conditition is
602 however detected in the cam and a bit is set in the header.
604 if (pdev
->type
== 730) {
605 unsigned char *ptr
= (unsigned char *)fbuf
->data
;
607 if (ptr
[1] == 1 && ptr
[0] & 0x10) {
608 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
609 pdev
->drop_frames
+= 2;
610 pdev
->vframes_error
++;
612 if ((ptr
[0] ^ pdev
->vmirror
) & 0x01) {
614 pdev
->snapshot_button_status
= 1;
615 PWC_TRACE("Snapshot button pressed.\n");
618 PWC_TRACE("Snapshot button released.\n");
621 if ((ptr
[0] ^ pdev
->vmirror
) & 0x02) {
623 PWC_TRACE("Image is mirrored.\n");
625 PWC_TRACE("Image is normal.\n");
627 pdev
->vmirror
= ptr
[0] & 0x03;
628 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
629 after a short frame; this condition is filtered out specifically. A 4 byte
630 frame doesn't make sense anyway.
631 So we get either this sequence:
632 drop_bit set -> 4 byte frame -> short frame -> good frame
634 drop_bit set -> short frame -> good frame
635 So we drop either 3 or 2 frames in all!
637 if (fbuf
->filled
== 4)
640 else if (pdev
->type
== 740 || pdev
->type
== 720) {
641 unsigned char *ptr
= (unsigned char *)fbuf
->data
;
642 if ((ptr
[0] ^ pdev
->vmirror
) & 0x01) {
644 pdev
->snapshot_button_status
= 1;
645 PWC_TRACE("Snapshot button pressed.\n");
648 PWC_TRACE("Snapshot button released.\n");
650 pdev
->vmirror
= ptr
[0] & 0x03;
653 /* In case we were instructed to drop the frame, do so silently.
654 The buffer pointers are not updated either (but the counters are reset below).
656 if (pdev
->drop_frames
> 0)
659 /* Check for underflow first */
660 if (fbuf
->filled
< pdev
->frame_total_size
) {
661 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
662 " discarded.\n", fbuf
->filled
);
663 pdev
->vframes_error
++;
666 /* Send only once per EOF */
667 awake
= 1; /* delay wake_ups */
669 /* Find our next frame to fill. This will always succeed, since we
670 * nick a frame from either empty or full list, but if we had to
671 * take it from the full list, it means a frame got dropped.
673 if (pwc_next_fill_frame(pdev
))
674 pwc_frame_dumped(pdev
);
678 pdev
->vframe_count
++;
682 /* This gets called for the Isochronous pipe (video). This is done in
683 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
685 static void pwc_isoc_handler(struct urb
*urb
)
687 struct pwc_device
*pdev
;
690 struct pwc_frame_buf
*fbuf
;
691 unsigned char *fillptr
= NULL
, *iso_buf
= NULL
;
694 pdev
= (struct pwc_device
*)urb
->context
;
696 PWC_ERROR("isoc_handler() called with NULL device?!\n");
700 if (urb
->status
== -ENOENT
|| urb
->status
== -ECONNRESET
) {
701 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb
, urb
->status
== -ENOENT
? "" : "a");
704 if (urb
->status
!= -EINPROGRESS
&& urb
->status
!= 0) {
708 switch(urb
->status
) {
709 case -ENOSR
: errmsg
= "Buffer error (overrun)"; break;
710 case -EPIPE
: errmsg
= "Stalled (device not responding)"; break;
711 case -EOVERFLOW
: errmsg
= "Babble (bad cable?)"; break;
712 case -EPROTO
: errmsg
= "Bit-stuff error (bad cable?)"; break;
713 case -EILSEQ
: errmsg
= "CRC/Timeout (could be anything)"; break;
714 case -ETIME
: errmsg
= "Device does not respond"; break;
716 PWC_DEBUG_FLOW("pwc_isoc_handler() called with status %d [%s].\n", urb
->status
, errmsg
);
717 /* Give up after a number of contiguous errors on the USB bus.
718 Appearantly something is wrong so we simulate an unplug event.
720 if (++pdev
->visoc_errors
> MAX_ISOC_ERRORS
)
722 PWC_INFO("Too many ISOC errors, bailing out.\n");
723 pdev
->error_status
= EIO
;
725 wake_up_interruptible(&pdev
->frameq
);
727 goto handler_end
; // ugly, but practical
730 fbuf
= pdev
->fill_frame
;
732 PWC_ERROR("pwc_isoc_handler without valid fill frame.\n");
737 fillptr
= fbuf
->data
+ fbuf
->filled
;
740 /* Reset ISOC error counter. We did get here, after all. */
741 pdev
->visoc_errors
= 0;
743 /* vsync: 0 = don't copy data
748 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
749 fst
= urb
->iso_frame_desc
[i
].status
;
750 flen
= urb
->iso_frame_desc
[i
].actual_length
;
751 iso_buf
= urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
753 if (flen
> 0) { /* if valid data... */
754 if (pdev
->vsync
> 0) { /* ...and we are not sync-hunting... */
757 /* ...copy data to frame buffer, if possible */
758 if (flen
+ fbuf
->filled
> pdev
->frame_total_size
) {
759 PWC_DEBUG_FLOW("Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen
, pdev
->frame_total_size
);
760 pdev
->vsync
= 0; /* Hmm, let's wait for an EOF (end-of-frame) */
761 pdev
->vframes_error
++;
764 memmove(fillptr
, iso_buf
, flen
);
768 fbuf
->filled
+= flen
;
771 if (flen
< pdev
->vlast_packet_size
) {
772 /* Shorter packet... We probably have the end of an image-frame;
773 wake up read() process and let select()/poll() do something.
774 Decompression is done in user time over there.
776 if (pdev
->vsync
== 2) {
777 if (pwc_rcv_short_packet(pdev
, fbuf
)) {
779 fbuf
= pdev
->fill_frame
;
783 fillptr
= fbuf
->data
;
787 pdev
->vlast_packet_size
= flen
;
788 } /* ..status == 0 */
790 /* This is normally not interesting to the user, unless
791 * you are really debugging something */
792 static int iso_error
= 0;
795 PWC_DEBUG_FLOW("Iso frame %d of USB has error %d\n", i
, fst
);
801 wake_up_interruptible(&pdev
->frameq
);
803 urb
->dev
= pdev
->udev
;
804 i
= usb_submit_urb(urb
, GFP_ATOMIC
);
806 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i
);
810 int pwc_isoc_init(struct pwc_device
*pdev
)
812 struct usb_device
*udev
;
816 struct usb_interface
*intf
;
817 struct usb_host_interface
*idesc
= NULL
;
826 /* Get the current alternate interface, adjust packet size */
827 if (!udev
->actconfig
)
829 intf
= usb_ifnum_to_if(udev
, 0);
831 idesc
= usb_altnum_to_altsetting(intf
, pdev
->valternate
);
836 /* Search video endpoint */
837 pdev
->vmax_packet_size
= -1;
838 for (i
= 0; i
< idesc
->desc
.bNumEndpoints
; i
++) {
839 if ((idesc
->endpoint
[i
].desc
.bEndpointAddress
& 0xF) == pdev
->vendpoint
) {
840 pdev
->vmax_packet_size
= le16_to_cpu(idesc
->endpoint
[i
].desc
.wMaxPacketSize
);
845 if (pdev
->vmax_packet_size
< 0 || pdev
->vmax_packet_size
> ISO_MAX_FRAME_SIZE
) {
846 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
847 return -ENFILE
; /* Odd error, that should be noticeable */
850 /* Set alternate interface */
852 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev
->valternate
);
853 ret
= usb_set_interface(pdev
->udev
, 0, pdev
->valternate
);
857 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
858 urb
= usb_alloc_urb(ISO_FRAMES_PER_DESC
, GFP_KERNEL
);
860 PWC_ERROR("Failed to allocate urb %d\n", i
);
864 pdev
->sbuf
[i
].urb
= urb
;
865 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb
);
868 /* De-allocate in reverse order */
870 if (pdev
->sbuf
[i
].urb
!= NULL
)
871 usb_free_urb(pdev
->sbuf
[i
].urb
);
872 pdev
->sbuf
[i
].urb
= NULL
;
877 /* init URB structure */
878 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
879 urb
= pdev
->sbuf
[i
].urb
;
881 urb
->interval
= 1; // devik
883 urb
->pipe
= usb_rcvisocpipe(udev
, pdev
->vendpoint
);
884 urb
->transfer_flags
= URB_ISO_ASAP
;
885 urb
->transfer_buffer
= pdev
->sbuf
[i
].data
;
886 urb
->transfer_buffer_length
= ISO_BUFFER_SIZE
;
887 urb
->complete
= pwc_isoc_handler
;
889 urb
->start_frame
= 0;
890 urb
->number_of_packets
= ISO_FRAMES_PER_DESC
;
891 for (j
= 0; j
< ISO_FRAMES_PER_DESC
; j
++) {
892 urb
->iso_frame_desc
[j
].offset
= j
* ISO_MAX_FRAME_SIZE
;
893 urb
->iso_frame_desc
[j
].length
= pdev
->vmax_packet_size
;
898 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
899 ret
= usb_submit_urb(pdev
->sbuf
[i
].urb
, GFP_KERNEL
);
901 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i
, ret
);
903 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev
->sbuf
[i
].urb
);
908 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
912 void pwc_isoc_cleanup(struct pwc_device
*pdev
)
916 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
919 if (pdev
->iso_init
== 0)
922 /* Unlinking ISOC buffers one by one */
923 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
926 urb
= pdev
->sbuf
[i
].urb
;
928 if (pdev
->iso_init
) {
929 PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb
);
932 PWC_DEBUG_MEMORY("Freeing URB\n");
934 pdev
->sbuf
[i
].urb
= NULL
;
938 /* Stop camera, but only if we are sure the camera is still there (unplug
939 is signalled by EPIPE)
941 if (pdev
->error_status
&& pdev
->error_status
!= EPIPE
) {
942 PWC_DEBUG_OPEN("Setting alternate interface 0.\n");
943 usb_set_interface(pdev
->udev
, 0, 0);
947 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
950 int pwc_try_video_mode(struct pwc_device
*pdev
, int width
, int height
, int new_fps
, int new_compression
, int new_snapshot
)
954 /* Stop isoc stuff */
955 pwc_isoc_cleanup(pdev
);
956 /* Reset parameters */
957 pwc_reset_buffers(pdev
);
958 /* Try to set video mode... */
959 start
= ret
= pwc_set_video_mode(pdev
, width
, height
, new_fps
, new_compression
, new_snapshot
);
961 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 1 failed.\n");
962 /* That failed... restore old mode (we know that worked) */
963 start
= pwc_set_video_mode(pdev
, pdev
->view
.x
, pdev
->view
.y
, pdev
->vframes
, pdev
->vcompression
, pdev
->vsnapshot
);
965 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 2 failed.\n");
970 if (pwc_isoc_init(pdev
) < 0)
972 PWC_WARNING("Failed to restart ISOC transfers in pwc_try_video_mode.\n");
973 ret
= -EAGAIN
; /* let's try again, who knows if it works a second time */
976 pdev
->drop_frames
++; /* try to avoid garbage during switch */
977 return ret
; /* Return original error code */
983 static struct pwc_device
*cd_to_pwc(struct class_device
*cd
)
985 struct video_device
*vdev
= to_video_device(cd
);
986 return video_get_drvdata(vdev
);
989 static ssize_t
show_pan_tilt(struct class_device
*class_dev
, char *buf
)
991 struct pwc_device
*pdev
= cd_to_pwc(class_dev
);
992 return sprintf(buf
, "%d %d\n", pdev
->pan_angle
, pdev
->tilt_angle
);
995 static ssize_t
store_pan_tilt(struct class_device
*class_dev
, const char *buf
,
998 struct pwc_device
*pdev
= cd_to_pwc(class_dev
);
1002 if (strncmp(buf
, "reset", 5) == 0)
1003 ret
= pwc_mpt_reset(pdev
, 0x3);
1005 else if (sscanf(buf
, "%d %d", &pan
, &tilt
) > 0)
1006 ret
= pwc_mpt_set_angle(pdev
, pan
, tilt
);
1012 static CLASS_DEVICE_ATTR(pan_tilt
, S_IRUGO
| S_IWUSR
, show_pan_tilt
,
1015 static ssize_t
show_snapshot_button_status(struct class_device
*class_dev
, char *buf
)
1017 struct pwc_device
*pdev
= cd_to_pwc(class_dev
);
1018 int status
= pdev
->snapshot_button_status
;
1019 pdev
->snapshot_button_status
= 0;
1020 return sprintf(buf
, "%d\n", status
);
1023 static CLASS_DEVICE_ATTR(button
, S_IRUGO
| S_IWUSR
, show_snapshot_button_status
,
1026 static int pwc_create_sysfs_files(struct video_device
*vdev
)
1028 struct pwc_device
*pdev
= video_get_drvdata(vdev
);
1031 rc
= video_device_create_file(vdev
, &class_device_attr_button
);
1034 if (pdev
->features
& FEATURE_MOTOR_PANTILT
) {
1035 rc
= video_device_create_file(vdev
,&class_device_attr_pan_tilt
);
1036 if (rc
) goto err_button
;
1042 video_device_remove_file(vdev
, &class_device_attr_button
);
1047 static void pwc_remove_sysfs_files(struct video_device
*vdev
)
1049 struct pwc_device
*pdev
= video_get_drvdata(vdev
);
1050 if (pdev
->features
& FEATURE_MOTOR_PANTILT
)
1051 video_device_remove_file(vdev
, &class_device_attr_pan_tilt
);
1052 video_device_remove_file(vdev
, &class_device_attr_button
);
1055 #if CONFIG_PWC_DEBUG
1056 static const char *pwc_sensor_type_to_string(unsigned int sensor_type
)
1058 switch(sensor_type
) {
1060 return "Hyundai CMOS sensor";
1062 return "Sony CCD sensor + TDA8787";
1064 return "Sony CCD sensor + Exas 98L59";
1066 return "Sony CCD sensor + ADI 9804";
1068 return "Sharp CCD sensor + TDA8787";
1070 return "Sharp CCD sensor + Exas 98L59";
1072 return "Sharp CCD sensor + ADI 9804";
1074 return "UPA 1021 sensor";
1076 return "VGA sensor";
1078 return "PAL MR sensor";
1080 return "unknown type of sensor";
1085 /***************************************************************************/
1086 /* Video4Linux functions */
1088 static int pwc_video_open(struct inode
*inode
, struct file
*file
)
1091 struct video_device
*vdev
= video_devdata(file
);
1092 struct pwc_device
*pdev
;
1094 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev
);
1096 pdev
= (struct pwc_device
*)vdev
->priv
;
1100 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1104 down(&pdev
->modlock
);
1105 if (!pdev
->usb_init
) {
1106 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1109 /* Query sensor type */
1110 ret
= pwc_get_cmos_sensor(pdev
, &i
);
1113 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1115 pwc_sensor_type_to_string(i
), i
);
1119 /* Turn on camera */
1121 i
= pwc_camera_power(pdev
, 1);
1123 PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i
);
1125 /* Set LED on/off time */
1126 if (pwc_set_leds(pdev
, led_on
, led_off
) < 0)
1127 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1129 pwc_construct(pdev
); /* set min/max sizes correct */
1131 /* So far, so good. Allocate memory. */
1132 i
= pwc_allocate_buffers(pdev
);
1134 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1135 pwc_free_buffers(pdev
);
1140 /* Reset buffers & parameters */
1141 pwc_reset_buffers(pdev
);
1142 for (i
= 0; i
< pwc_mbufs
; i
++)
1143 pdev
->image_used
[i
] = 0;
1144 pdev
->vframe_count
= 0;
1145 pdev
->vframes_dumped
= 0;
1146 pdev
->vframes_error
= 0;
1147 pdev
->visoc_errors
= 0;
1148 pdev
->error_status
= 0;
1149 pwc_construct(pdev
); /* set min/max sizes correct */
1151 /* Set some defaults */
1152 pdev
->vsnapshot
= 0;
1154 /* Start iso pipe for video; first try the last used video size
1155 (or the default one); if that fails try QCIF/10 or QSIF/10;
1156 it that fails too, give up.
1158 i
= pwc_set_video_mode(pdev
, pwc_image_sizes
[pdev
->vsize
].x
, pwc_image_sizes
[pdev
->vsize
].y
, pdev
->vframes
, pdev
->vcompression
, 0);
1160 unsigned int default_resolution
;
1161 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1162 if (pdev
->type
>= 730)
1163 default_resolution
= PSZ_QSIF
;
1165 default_resolution
= PSZ_QCIF
;
1167 i
= pwc_set_video_mode(pdev
,
1168 pwc_image_sizes
[default_resolution
].x
,
1169 pwc_image_sizes
[default_resolution
].y
,
1175 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1176 pwc_free_buffers(pdev
);
1181 i
= pwc_isoc_init(pdev
);
1183 PWC_DEBUG_OPEN("Failed to init ISOC stuff = %d.\n", i
);
1184 pwc_isoc_cleanup(pdev
);
1185 pwc_free_buffers(pdev
);
1190 /* Initialize the webcam to sane value */
1191 pwc_set_brightness(pdev
, 0x7fff);
1192 pwc_set_agc(pdev
, 1, 0);
1195 file
->private_data
= vdev
;
1197 PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1201 /* Note that all cleanup is done in the reverse order as in _open */
1202 static int pwc_video_close(struct inode
*inode
, struct file
*file
)
1204 struct video_device
*vdev
= file
->private_data
;
1205 struct pwc_device
*pdev
;
1208 PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev
);
1210 pdev
= (struct pwc_device
*)vdev
->priv
;
1211 if (pdev
->vopen
== 0)
1212 PWC_DEBUG_MODULE("video_close() called on closed device?\n");
1214 /* Dump statistics, but only if a reasonable amount of frames were
1215 processed (to prevent endless log-entries in case of snap-shot
1218 if (pdev
->vframe_count
> 20)
1219 PWC_DEBUG_MODULE("Closing video device: %d frames received, dumped %d frames, %d frames with errors.\n", pdev
->vframe_count
, pdev
->vframes_dumped
, pdev
->vframes_error
);
1221 if (DEVICE_USE_CODEC1(pdev
->type
))
1226 pwc_isoc_cleanup(pdev
);
1227 pwc_free_buffers(pdev
);
1229 /* Turn off LEDS and power down camera, but only when not unplugged */
1230 if (pdev
->error_status
!= EPIPE
) {
1232 if (pwc_set_leds(pdev
, 0, 0) < 0)
1233 PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
1235 i
= pwc_camera_power(pdev
, 0);
1237 PWC_ERROR("Failed to power down camera (%d)\n", i
);
1241 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev
->vopen
);
1246 * FIXME: what about two parallel reads ????
1247 * ANSWER: Not supported. You can't open the device more than once,
1248 despite what the V4L1 interface says. First, I don't see
1249 the need, second there's no mechanism of alerting the
1250 2nd/3rd/... process of events like changing image size.
1251 And I don't see the point of blocking that for the
1252 2nd/3rd/... process.
1253 In multi-threaded environments reading parallel from any
1254 device is tricky anyhow.
1257 static ssize_t
pwc_video_read(struct file
*file
, char __user
*buf
,
1258 size_t count
, loff_t
*ppos
)
1260 struct video_device
*vdev
= file
->private_data
;
1261 struct pwc_device
*pdev
;
1262 int noblock
= file
->f_flags
& O_NONBLOCK
;
1263 DECLARE_WAITQUEUE(wait
, current
);
1265 void *image_buffer_addr
;
1267 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1274 if (pdev
->error_status
)
1275 return -pdev
->error_status
; /* Something happened, report what. */
1277 /* In case we're doing partial reads, we don't have to wait for a frame */
1278 if (pdev
->image_read_pos
== 0) {
1279 /* Do wait queueing according to the (doc)book */
1280 add_wait_queue(&pdev
->frameq
, &wait
);
1281 while (pdev
->full_frames
== NULL
) {
1282 /* Check for unplugged/etc. here */
1283 if (pdev
->error_status
) {
1284 remove_wait_queue(&pdev
->frameq
, &wait
);
1285 set_current_state(TASK_RUNNING
);
1286 return -pdev
->error_status
;
1289 remove_wait_queue(&pdev
->frameq
, &wait
);
1290 set_current_state(TASK_RUNNING
);
1291 return -EWOULDBLOCK
;
1293 if (signal_pending(current
)) {
1294 remove_wait_queue(&pdev
->frameq
, &wait
);
1295 set_current_state(TASK_RUNNING
);
1296 return -ERESTARTSYS
;
1299 set_current_state(TASK_INTERRUPTIBLE
);
1301 remove_wait_queue(&pdev
->frameq
, &wait
);
1302 set_current_state(TASK_RUNNING
);
1304 /* Decompress and release frame */
1305 if (pwc_handle_frame(pdev
))
1309 PWC_DEBUG_READ("Copying data to user space.\n");
1310 if (pdev
->vpalette
== VIDEO_PALETTE_RAW
)
1311 bytes_to_read
= pdev
->frame_size
+ sizeof(struct pwc_raw_frame
);
1313 bytes_to_read
= pdev
->view
.size
;
1315 /* copy bytes to user space; we allow for partial reads */
1316 if (count
+ pdev
->image_read_pos
> bytes_to_read
)
1317 count
= bytes_to_read
- pdev
->image_read_pos
;
1318 image_buffer_addr
= pdev
->image_data
;
1319 image_buffer_addr
+= pdev
->images
[pdev
->fill_image
].offset
;
1320 image_buffer_addr
+= pdev
->image_read_pos
;
1321 if (copy_to_user(buf
, image_buffer_addr
, count
))
1323 pdev
->image_read_pos
+= count
;
1324 if (pdev
->image_read_pos
>= bytes_to_read
) { /* All data has been read */
1325 pdev
->image_read_pos
= 0;
1326 pwc_next_image(pdev
);
1331 static unsigned int pwc_video_poll(struct file
*file
, poll_table
*wait
)
1333 struct video_device
*vdev
= file
->private_data
;
1334 struct pwc_device
*pdev
;
1342 poll_wait(file
, &pdev
->frameq
, wait
);
1343 if (pdev
->error_status
)
1345 if (pdev
->full_frames
!= NULL
) /* we have frames waiting */
1346 return (POLLIN
| POLLRDNORM
);
1351 static int pwc_video_ioctl(struct inode
*inode
, struct file
*file
,
1352 unsigned int cmd
, unsigned long arg
)
1354 return video_usercopy(inode
, file
, cmd
, arg
, pwc_video_do_ioctl
);
1357 static int pwc_video_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1359 struct video_device
*vdev
= file
->private_data
;
1360 struct pwc_device
*pdev
;
1361 unsigned long start
;
1363 unsigned long page
, pos
= 0;
1366 PWC_DEBUG_MEMORY(">> %s\n", __FUNCTION__
);
1368 size
= vma
->vm_end
- vma
->vm_start
;
1369 start
= vma
->vm_start
;
1371 /* Find the idx buffer for this mapping */
1372 for (index
= 0; index
< pwc_mbufs
; index
++) {
1373 pos
= pdev
->images
[index
].offset
;
1374 if ((pos
>>PAGE_SHIFT
) == vma
->vm_pgoff
)
1377 if (index
== MAX_IMAGES
)
1381 * Special case for v4l1. In v4l1, we map only one big buffer,
1382 * but in v4l2 each buffer is mapped
1384 unsigned long total_size
;
1385 total_size
= pwc_mbufs
* pdev
->len_per_image
;
1386 if (size
!= pdev
->len_per_image
&& size
!= total_size
) {
1387 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1388 size
, pdev
->len_per_image
, total_size
);
1391 } else if (size
> pdev
->len_per_image
)
1394 vma
->vm_flags
|= VM_IO
; /* from 2.6.9-acX */
1396 pos
+= (unsigned long)pdev
->image_data
;
1398 page
= vmalloc_to_pfn((void *)pos
);
1399 if (remap_pfn_range(vma
, start
, page
, PAGE_SIZE
, PAGE_SHARED
))
1403 if (size
> PAGE_SIZE
)
1411 /***************************************************************************/
1414 /* This function gets called when a new device is plugged in or the usb core
1418 static int usb_pwc_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
1420 struct usb_device
*udev
= interface_to_usbdev(intf
);
1421 struct pwc_device
*pdev
= NULL
;
1422 int vendor_id
, product_id
, type_id
;
1425 int video_nr
= -1; /* default: use next available device */
1426 char serial_number
[30], *name
;
1428 vendor_id
= le16_to_cpu(udev
->descriptor
.idVendor
);
1429 product_id
= le16_to_cpu(udev
->descriptor
.idProduct
);
1431 /* Check if we can handle this device */
1432 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1433 vendor_id
, product_id
,
1434 intf
->altsetting
->desc
.bInterfaceNumber
);
1436 /* the interfaces are probed one by one. We are only interested in the
1437 video interface (0) now.
1438 Interface 1 is the Audio Control, and interface 2 Audio itself.
1440 if (intf
->altsetting
->desc
.bInterfaceNumber
> 0)
1443 if (vendor_id
== 0x0471) {
1444 switch (product_id
) {
1446 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1447 name
= "Philips 645 webcam";
1451 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1452 name
= "Philips 646 webcam";
1456 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1457 name
= "Askey VC010 webcam";
1461 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1462 name
= "Philips 675 webcam";
1466 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1467 name
= "Philips 680 webcam";
1471 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1472 name
= "Philips 690 webcam";
1476 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1477 name
= "Philips 730 webcam";
1481 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1482 name
= "Philips 740 webcam";
1486 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1487 name
= "Philips 750 webcam";
1491 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1492 name
= "Philips 720K/40 webcam";
1496 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1497 name
= "Philips SPC 900NC webcam";
1505 else if (vendor_id
== 0x069A) {
1506 switch(product_id
) {
1508 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1509 name
= "Askey VC010 webcam";
1517 else if (vendor_id
== 0x046d) {
1518 switch(product_id
) {
1520 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1521 name
= "Logitech QuickCam Pro 3000";
1522 type_id
= 740; /* CCD sensor */
1525 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1526 name
= "Logitech QuickCam Notebook Pro";
1527 type_id
= 740; /* CCD sensor */
1530 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1531 name
= "Logitech QuickCam Pro 4000";
1532 type_id
= 740; /* CCD sensor */
1535 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1536 name
= "Logitech QuickCam Zoom";
1537 type_id
= 740; /* CCD sensor */
1540 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1541 name
= "Logitech QuickCam Zoom";
1542 type_id
= 740; /* CCD sensor */
1546 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1547 name
= "Logitech QuickCam Orbit";
1548 type_id
= 740; /* CCD sensor */
1549 features
|= FEATURE_MOTOR_PANTILT
;
1554 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1555 name
= "Logitech QuickCam (res.)";
1556 type_id
= 730; /* Assuming CMOS */
1563 else if (vendor_id
== 0x055d) {
1564 /* I don't know the difference between the C10 and the C30;
1565 I suppose the difference is the sensor, but both cameras
1566 work equally well with a type_id of 675
1568 switch(product_id
) {
1570 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1571 name
= "Samsung MPC-C10";
1575 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1576 name
= "Samsung MPC-C30";
1580 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1581 name
= "Samsung MPC-C30";
1589 else if (vendor_id
== 0x041e) {
1590 switch(product_id
) {
1592 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1593 name
= "Creative Labs Webcam 5";
1597 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1598 name
= "Creative Labs Webcam Pro Ex";
1606 else if (vendor_id
== 0x04cc) {
1607 switch(product_id
) {
1609 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1610 name
= "Sotec Afina Eye";
1618 else if (vendor_id
== 0x06be) {
1619 switch(product_id
) {
1621 /* This is essentially the same cam as the Sotec Afina Eye */
1622 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1623 name
= "AME Co. Afina Eye";
1632 else if (vendor_id
== 0x0d81) {
1633 switch(product_id
) {
1635 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1636 name
= "Visionite VCS-UC300";
1637 type_id
= 740; /* CCD sensor */
1640 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1641 name
= "Visionite VCS-UM100";
1642 type_id
= 730; /* CMOS sensor */
1650 return -ENODEV
; /* Not any of the know types; but the list keeps growing. */
1652 memset(serial_number
, 0, 30);
1653 usb_string(udev
, udev
->descriptor
.iSerialNumber
, serial_number
, 29);
1654 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number
);
1656 if (udev
->descriptor
.bNumConfigurations
> 1)
1657 PWC_WARNING("Warning: more than 1 configuration available.\n");
1659 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1660 pdev
= kzalloc(sizeof(struct pwc_device
), GFP_KERNEL
);
1662 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1665 pdev
->type
= type_id
;
1666 pdev
->vsize
= default_size
;
1667 pdev
->vframes
= default_fps
;
1668 strcpy(pdev
->serial
, serial_number
);
1669 pdev
->features
= features
;
1670 if (vendor_id
== 0x046D && product_id
== 0x08B5)
1672 /* Logitech QuickCam Orbit
1673 The ranges have been determined experimentally; they may differ from cam to cam.
1674 Also, the exact ranges left-right and up-down are different for my cam
1676 pdev
->angle_range
.pan_min
= -7000;
1677 pdev
->angle_range
.pan_max
= 7000;
1678 pdev
->angle_range
.tilt_min
= -3000;
1679 pdev
->angle_range
.tilt_max
= 2500;
1682 init_MUTEX(&pdev
->modlock
);
1683 spin_lock_init(&pdev
->ptrlock
);
1686 init_waitqueue_head(&pdev
->frameq
);
1687 pdev
->vcompression
= pwc_preferred_compression
;
1689 /* Allocate video_device structure */
1690 pdev
->vdev
= video_device_alloc();
1691 if (pdev
->vdev
== 0)
1693 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
1697 memcpy(pdev
->vdev
, &pwc_template
, sizeof(pwc_template
));
1698 pdev
->vdev
->dev
= &(udev
->dev
);
1699 strcpy(pdev
->vdev
->name
, name
);
1700 pdev
->vdev
->owner
= THIS_MODULE
;
1701 video_set_drvdata(pdev
->vdev
, pdev
);
1703 pdev
->release
= le16_to_cpu(udev
->descriptor
.bcdDevice
);
1704 PWC_DEBUG_PROBE("Release: %04x\n", pdev
->release
);
1706 /* Now search device_hint[] table for a match, so we can hint a node number. */
1707 for (hint
= 0; hint
< MAX_DEV_HINTS
; hint
++) {
1708 if (((device_hint
[hint
].type
== -1) || (device_hint
[hint
].type
== pdev
->type
)) &&
1709 (device_hint
[hint
].pdev
== NULL
)) {
1710 /* so far, so good... try serial number */
1711 if ((device_hint
[hint
].serial_number
[0] == '*') || !strcmp(device_hint
[hint
].serial_number
, serial_number
)) {
1713 video_nr
= device_hint
[hint
].device_node
;
1714 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr
);
1720 pdev
->vdev
->release
= video_device_release
;
1721 i
= video_register_device(pdev
->vdev
, VFL_TYPE_GRABBER
, video_nr
);
1723 PWC_ERROR("Failed to register as video device (%d).\n", i
);
1728 PWC_INFO("Registered as /dev/video%d.\n", pdev
->vdev
->minor
& 0x3F);
1732 if (hint
< MAX_DEV_HINTS
)
1733 device_hint
[hint
].pdev
= pdev
;
1735 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev
);
1736 usb_set_intfdata (intf
, pdev
);
1737 rc
= pwc_create_sysfs_files(pdev
->vdev
);
1741 /* Set the leds off */
1742 pwc_set_leds(pdev
, 0, 0);
1743 pwc_camera_power(pdev
, 0);
1748 if (hint
< MAX_DEV_HINTS
)
1749 device_hint
[hint
].pdev
= NULL
;
1750 video_unregister_device(pdev
->vdev
);
1752 video_device_release(pdev
->vdev
); /* Drip... drip... drip... */
1753 kfree(pdev
); /* Oops, no memory leaks please */
1757 /* The user janked out the cable... */
1758 static void usb_pwc_disconnect(struct usb_interface
*intf
)
1760 struct pwc_device
*pdev
;
1764 pdev
= usb_get_intfdata (intf
);
1765 usb_set_intfdata (intf
, NULL
);
1767 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1768 goto disconnect_out
;
1770 if (pdev
->udev
== NULL
) {
1771 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev
);
1772 goto disconnect_out
;
1774 if (pdev
->udev
!= interface_to_usbdev(intf
)) {
1775 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1776 goto disconnect_out
;
1779 /* We got unplugged; this is signalled by an EPIPE error code */
1781 PWC_INFO("Disconnected while webcam is in use!\n");
1782 pdev
->error_status
= EPIPE
;
1785 /* Alert waiting processes */
1786 wake_up_interruptible(&pdev
->frameq
);
1787 /* Wait until device is closed */
1790 /* Device is now closed, so we can safely unregister it */
1791 PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
1792 pwc_remove_sysfs_files(pdev
->vdev
);
1793 video_unregister_device(pdev
->vdev
);
1795 /* Free memory (don't set pdev to 0 just yet) */
1799 /* search device_hint[] table if we occupy a slot, by any chance */
1800 for (hint
= 0; hint
< MAX_DEV_HINTS
; hint
++)
1801 if (device_hint
[hint
].pdev
== pdev
)
1802 device_hint
[hint
].pdev
= NULL
;
1808 /* *grunt* We have to do atoi ourselves :-( */
1809 static int pwc_atoi(const char *s
)
1814 while (*s
!= '\0' && *s
>= '0' && *s
<= '9') {
1815 k
= 10 * k
+ (*s
- '0');
1823 * Initialization code & module stuff
1830 static int compression
= -1;
1831 static int leds
[2] = { -1, -1 };
1832 static int leds_nargs
;
1833 static char *dev_hint
[MAX_DEV_HINTS
];
1834 static int dev_hint_nargs
;
1836 module_param(size
, charp
, 0444);
1837 module_param(fps
, int, 0444);
1838 module_param(fbufs
, int, 0444);
1839 module_param(mbufs
, int, 0444);
1840 #if CONFIG_PWC_DEBUG
1841 module_param_named(trace
, pwc_trace
, int, 0644);
1843 module_param(power_save
, int, 0444);
1844 module_param(compression
, int, 0444);
1845 module_param_array(leds
, int, &leds_nargs
, 0444);
1846 module_param_array(dev_hint
, charp
, &dev_hint_nargs
, 0444);
1848 MODULE_PARM_DESC(size
, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1849 MODULE_PARM_DESC(fps
, "Initial frames per second. Varies with model, useful range 5-30");
1850 MODULE_PARM_DESC(fbufs
, "Number of internal frame buffers to reserve");
1851 MODULE_PARM_DESC(mbufs
, "Number of external (mmap()ed) image buffers");
1852 MODULE_PARM_DESC(trace
, "For debugging purposes");
1853 MODULE_PARM_DESC(power_save
, "Turn power save feature in camera on or off");
1854 MODULE_PARM_DESC(compression
, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1855 MODULE_PARM_DESC(leds
, "LED on,off time in milliseconds");
1856 MODULE_PARM_DESC(dev_hint
, "Device node hints");
1858 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1859 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1860 MODULE_LICENSE("GPL");
1861 MODULE_ALIAS("pwcx");
1862 MODULE_VERSION( PWC_VERSION
);
1864 static int __init
usb_pwc_init(void)
1867 char *sizenames
[PSZ_MAX
] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1869 PWC_INFO("Philips webcam module version " PWC_VERSION
" loaded.\n");
1870 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1871 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1872 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1875 if (fps
< 4 || fps
> 30) {
1876 PWC_ERROR("Framerate out of bounds (4-30).\n");
1880 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps
);
1884 /* string; try matching with array */
1885 for (sz
= 0; sz
< PSZ_MAX
; sz
++) {
1886 if (!strcmp(sizenames
[sz
], size
)) { /* Found! */
1891 if (sz
== PSZ_MAX
) {
1892 PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1895 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
);
1898 if (mbufs
< 1 || mbufs
> MAX_IMAGES
) {
1899 PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES
);
1903 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs
);
1906 if (fbufs
< 2 || fbufs
> MAX_FRAMES
) {
1907 PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES
);
1910 default_fbufs
= fbufs
;
1911 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs
);
1913 #if CONFIG_PWC_DEBUG
1914 if (pwc_trace
>= 0) {
1915 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace
);
1918 if (compression
>= 0) {
1919 if (compression
> 3) {
1920 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1923 pwc_preferred_compression
= compression
;
1924 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression
);
1927 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
1933 /* Big device node whoopla. Basically, it allows you to assign a
1934 device node (/dev/videoX) to a camera, based on its type
1935 & serial number. The format is [type[.serialnumber]:]node.
1937 Any camera that isn't matched by these rules gets the next
1938 available free device node.
1940 for (i
= 0; i
< MAX_DEV_HINTS
; i
++) {
1941 char *s
, *colon
, *dot
;
1943 /* This loop also initializes the array */
1944 device_hint
[i
].pdev
= NULL
;
1946 if (s
!= NULL
&& *s
!= '\0') {
1947 device_hint
[i
].type
= -1; /* wildcard */
1948 strcpy(device_hint
[i
].serial_number
, "*");
1950 /* parse string: chop at ':' & '/' */
1952 while (*colon
!= '\0' && *colon
!= ':')
1954 while (*dot
!= '\0' && *dot
!= '.')
1956 /* Few sanity checks */
1957 if (*dot
!= '\0' && dot
> colon
) {
1958 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
1962 if (*colon
== '\0') {
1965 PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
1969 /* No type or serial number specified, just a number. */
1970 device_hint
[i
].device_node
= pwc_atoi(s
);
1974 /* There's a colon, so we have at least a type and a device node */
1975 device_hint
[i
].type
= pwc_atoi(s
);
1976 device_hint
[i
].device_node
= pwc_atoi(colon
+ 1);
1978 /* There's a serial number as well */
1983 while (*dot
!= ':' && k
< 29) {
1984 device_hint
[i
].serial_number
[k
++] = *dot
;
1987 device_hint
[i
].serial_number
[k
] = '\0';
1990 PWC_TRACE("device_hint[%d]:\n", i
);
1991 PWC_TRACE(" type : %d\n", device_hint
[i
].type
);
1992 PWC_TRACE(" serial# : %s\n", device_hint
[i
].serial_number
);
1993 PWC_TRACE(" node : %d\n", device_hint
[i
].device_node
);
1996 device_hint
[i
].type
= 0; /* not filled */
1997 } /* ..for MAX_DEV_HINTS */
1999 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver
);
2000 return usb_register(&pwc_driver
);
2003 static void __exit
usb_pwc_exit(void)
2005 PWC_DEBUG_MODULE("Deregistering driver.\n");
2006 usb_deregister(&pwc_driver
);
2007 PWC_INFO("Philips webcam module removed.\n");
2010 module_init(usb_pwc_init
);
2011 module_exit(usb_pwc_exit
);
2013 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */