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)
5 (C) 2011 Hans de Goede <hdegoede@redhat.com>
7 NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
8 driver and thus may have bugs that are not present in the original version.
9 Please send bug reports and support requests to <luc@saillard.org>.
10 The decompression routines have been implemented by reverse-engineering the
11 Nemosoft binary pwcx module. Caveat emptor.
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 This code forms the interface between the USB layers and the Philips
31 specific stuff. Some adanved stuff of the driver falls under an
32 NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
33 is thus not distributed in source form. The binary pwcx.o module
34 contains the code that falls under the NDA.
36 In case you're wondering: 'pwc' stands for "Philips WebCam", but
37 I really didn't want to type 'philips_web_cam' every time (I'm lazy as
38 any Linux kernel hacker, but I don't like uncomprehensible abbreviations
41 Oh yes, convention: to disctinguish between all the various pointers to
42 device-structures, I use these names for the pointer variables:
43 udev: struct usb_device *
44 vdev: struct video_device (member of pwc_dev)
45 pdev: struct pwc_devive *
49 - Alvarado: adding whitebalance code
50 - Alistar Moire: QuickCam 3000 Pro device/product ID
51 - Tony Hoyle: Creative Labs Webcam 5 device/product ID
52 - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
53 - Jk Fang: Sotec Afina Eye ID
54 - Xavier Roche: QuickCam Pro 4000 ID
55 - Jens Knudsen: QuickCam Zoom ID
56 - J. Debert: QuickCam for Notebooks ID
57 - Pham Thanh Nam: webcam snapshot button as an event input device
60 #include <linux/errno.h>
61 #include <linux/init.h>
63 #include <linux/module.h>
64 #include <linux/poll.h>
65 #include <linux/slab.h>
66 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
67 #include <linux/usb/input.h>
69 #include <linux/vmalloc.h>
71 #include <linux/kernel.h> /* simple_strtol() */
74 #include "pwc-kiara.h"
75 #include "pwc-timon.h"
76 #include "pwc-dec23.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
);
119 static void pwc_isoc_cleanup(struct pwc_device
*pdev
);
121 static struct usb_driver pwc_driver
= {
122 .name
= "Philips webcam", /* name */
123 .id_table
= pwc_device_table
,
124 .probe
= usb_pwc_probe
, /* probe() */
125 .disconnect
= usb_pwc_disconnect
, /* disconnect() */
128 #define MAX_DEV_HINTS 20
129 #define MAX_ISOC_ERRORS 20
131 #ifdef CONFIG_USB_PWC_DEBUG
132 int pwc_trace
= PWC_DEBUG_LEVEL
;
134 static int power_save
= -1;
135 static int leds
[2] = { 100, 0 };
139 static int pwc_video_close(struct file
*file
);
140 static ssize_t
pwc_video_read(struct file
*file
, char __user
*buf
,
141 size_t count
, loff_t
*ppos
);
142 static unsigned int pwc_video_poll(struct file
*file
, poll_table
*wait
);
143 static int pwc_video_mmap(struct file
*file
, struct vm_area_struct
*vma
);
145 static const struct v4l2_file_operations pwc_fops
= {
146 .owner
= THIS_MODULE
,
147 .open
= v4l2_fh_open
,
148 .release
= pwc_video_close
,
149 .read
= pwc_video_read
,
150 .poll
= pwc_video_poll
,
151 .mmap
= pwc_video_mmap
,
152 .unlocked_ioctl
= video_ioctl2
,
154 static struct video_device pwc_template
= {
155 .name
= "Philips Webcam", /* Filled in later */
156 .release
= video_device_release_empty
,
158 .ioctl_ops
= &pwc_ioctl_ops
,
161 /***************************************************************************/
162 /* Private functions */
164 struct pwc_frame_buf
*pwc_get_next_fill_buf(struct pwc_device
*pdev
)
166 unsigned long flags
= 0;
167 struct pwc_frame_buf
*buf
= NULL
;
169 spin_lock_irqsave(&pdev
->queued_bufs_lock
, flags
);
170 if (list_empty(&pdev
->queued_bufs
))
173 buf
= list_entry(pdev
->queued_bufs
.next
, struct pwc_frame_buf
, list
);
174 list_del(&buf
->list
);
176 spin_unlock_irqrestore(&pdev
->queued_bufs_lock
, flags
);
180 static void pwc_snapshot_button(struct pwc_device
*pdev
, int down
)
183 PWC_TRACE("Snapshot button pressed.\n");
185 PWC_TRACE("Snapshot button released.\n");
188 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
189 if (pdev
->button_dev
) {
190 input_report_key(pdev
->button_dev
, KEY_CAMERA
, down
);
191 input_sync(pdev
->button_dev
);
196 static void pwc_frame_complete(struct pwc_device
*pdev
)
198 struct pwc_frame_buf
*fbuf
= pdev
->fill_buf
;
200 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
201 frames on the USB wire after an exposure change. This conditition is
202 however detected in the cam and a bit is set in the header.
204 if (pdev
->type
== 730) {
205 unsigned char *ptr
= (unsigned char *)fbuf
->data
;
207 if (ptr
[1] == 1 && ptr
[0] & 0x10) {
208 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
209 pdev
->drop_frames
+= 2;
211 if ((ptr
[0] ^ pdev
->vmirror
) & 0x01) {
212 pwc_snapshot_button(pdev
, ptr
[0] & 0x01);
214 if ((ptr
[0] ^ pdev
->vmirror
) & 0x02) {
216 PWC_TRACE("Image is mirrored.\n");
218 PWC_TRACE("Image is normal.\n");
220 pdev
->vmirror
= ptr
[0] & 0x03;
221 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
222 after a short frame; this condition is filtered out specifically. A 4 byte
223 frame doesn't make sense anyway.
224 So we get either this sequence:
225 drop_bit set -> 4 byte frame -> short frame -> good frame
227 drop_bit set -> short frame -> good frame
228 So we drop either 3 or 2 frames in all!
230 if (fbuf
->filled
== 4)
232 } else if (pdev
->type
== 740 || pdev
->type
== 720) {
233 unsigned char *ptr
= (unsigned char *)fbuf
->data
;
234 if ((ptr
[0] ^ pdev
->vmirror
) & 0x01) {
235 pwc_snapshot_button(pdev
, ptr
[0] & 0x01);
237 pdev
->vmirror
= ptr
[0] & 0x03;
240 /* In case we were instructed to drop the frame, do so silently. */
241 if (pdev
->drop_frames
> 0) {
244 /* Check for underflow first */
245 if (fbuf
->filled
< pdev
->frame_total_size
) {
246 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
247 " discarded.\n", fbuf
->filled
);
249 fbuf
->vb
.v4l2_buf
.field
= V4L2_FIELD_NONE
;
250 fbuf
->vb
.v4l2_buf
.sequence
= pdev
->vframe_count
;
251 vb2_buffer_done(&fbuf
->vb
, VB2_BUF_STATE_DONE
);
252 pdev
->fill_buf
= NULL
;
256 pdev
->vframe_count
++;
259 /* This gets called for the Isochronous pipe (video). This is done in
260 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
262 static void pwc_isoc_handler(struct urb
*urb
)
264 struct pwc_device
*pdev
= (struct pwc_device
*)urb
->context
;
266 unsigned char *iso_buf
= NULL
;
268 if (urb
->status
== -ENOENT
|| urb
->status
== -ECONNRESET
||
269 urb
->status
== -ESHUTDOWN
) {
270 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb
, urb
->status
== -ENOENT
? "" : "a");
274 if (pdev
->fill_buf
== NULL
)
275 pdev
->fill_buf
= pwc_get_next_fill_buf(pdev
);
277 if (urb
->status
!= 0) {
281 switch(urb
->status
) {
282 case -ENOSR
: errmsg
= "Buffer error (overrun)"; break;
283 case -EPIPE
: errmsg
= "Stalled (device not responding)"; break;
284 case -EOVERFLOW
: errmsg
= "Babble (bad cable?)"; break;
285 case -EPROTO
: errmsg
= "Bit-stuff error (bad cable?)"; break;
286 case -EILSEQ
: errmsg
= "CRC/Timeout (could be anything)"; break;
287 case -ETIME
: errmsg
= "Device does not respond"; break;
289 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
290 urb
->status
, errmsg
);
291 /* Give up after a number of contiguous errors */
292 if (++pdev
->visoc_errors
> MAX_ISOC_ERRORS
)
294 PWC_ERROR("Too many ISOC errors, bailing out.\n");
295 if (pdev
->fill_buf
) {
296 vb2_buffer_done(&pdev
->fill_buf
->vb
,
297 VB2_BUF_STATE_ERROR
);
298 pdev
->fill_buf
= NULL
;
301 pdev
->vsync
= 0; /* Drop the current frame */
305 /* Reset ISOC error counter. We did get here, after all. */
306 pdev
->visoc_errors
= 0;
308 /* vsync: 0 = don't copy data
313 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
314 fst
= urb
->iso_frame_desc
[i
].status
;
315 flen
= urb
->iso_frame_desc
[i
].actual_length
;
316 iso_buf
= urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
318 PWC_ERROR("Iso frame %d has error %d\n", i
, fst
);
321 if (flen
> 0 && pdev
->vsync
) {
322 struct pwc_frame_buf
*fbuf
= pdev
->fill_buf
;
324 if (pdev
->vsync
== 1) {
325 do_gettimeofday(&fbuf
->vb
.v4l2_buf
.timestamp
);
329 if (flen
+ fbuf
->filled
> pdev
->frame_total_size
) {
330 PWC_ERROR("Frame overflow (%d > %d)\n",
332 pdev
->frame_total_size
);
333 pdev
->vsync
= 0; /* Let's wait for an EOF */
335 memcpy(fbuf
->data
+ fbuf
->filled
, iso_buf
,
337 fbuf
->filled
+= flen
;
340 if (flen
< pdev
->vlast_packet_size
) {
341 /* Shorter packet... end of frame */
342 if (pdev
->vsync
== 2)
343 pwc_frame_complete(pdev
);
344 if (pdev
->fill_buf
== NULL
)
345 pdev
->fill_buf
= pwc_get_next_fill_buf(pdev
);
346 if (pdev
->fill_buf
) {
347 pdev
->fill_buf
->filled
= 0;
351 pdev
->vlast_packet_size
= flen
;
355 i
= usb_submit_urb(urb
, GFP_ATOMIC
);
357 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i
);
360 static int pwc_isoc_init(struct pwc_device
*pdev
)
362 struct usb_device
*udev
;
365 struct usb_interface
*intf
;
366 struct usb_host_interface
*idesc
= NULL
;
367 int compression
= 0; /* 0..3 = uncompressed..high */
373 pdev
->vlast_packet_size
= 0;
374 pdev
->fill_buf
= NULL
;
375 pdev
->vframe_count
= 0;
376 pdev
->visoc_errors
= 0;
380 /* We first try with low compression and then retry with a higher
381 compression setting if there is not enough bandwidth. */
382 ret
= pwc_set_video_mode(pdev
, pdev
->width
, pdev
->height
, pdev
->pixfmt
,
383 pdev
->vframes
, &compression
, 1);
385 /* Get the current alternate interface, adjust packet size */
386 intf
= usb_ifnum_to_if(udev
, 0);
388 idesc
= usb_altnum_to_altsetting(intf
, pdev
->valternate
);
392 /* Search video endpoint */
393 pdev
->vmax_packet_size
= -1;
394 for (i
= 0; i
< idesc
->desc
.bNumEndpoints
; i
++) {
395 if ((idesc
->endpoint
[i
].desc
.bEndpointAddress
& 0xF) == pdev
->vendpoint
) {
396 pdev
->vmax_packet_size
= le16_to_cpu(idesc
->endpoint
[i
].desc
.wMaxPacketSize
);
401 if (pdev
->vmax_packet_size
< 0 || pdev
->vmax_packet_size
> ISO_MAX_FRAME_SIZE
) {
402 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
403 return -ENFILE
; /* Odd error, that should be noticeable */
406 /* Set alternate interface */
407 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev
->valternate
);
408 ret
= usb_set_interface(pdev
->udev
, 0, pdev
->valternate
);
409 if (ret
== -ENOSPC
&& compression
< 3) {
416 /* Allocate and init Isochronuous urbs */
417 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
418 urb
= usb_alloc_urb(ISO_FRAMES_PER_DESC
, GFP_KERNEL
);
420 PWC_ERROR("Failed to allocate urb %d\n", i
);
422 pwc_isoc_cleanup(pdev
);
426 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb
);
428 urb
->interval
= 1; // devik
430 urb
->pipe
= usb_rcvisocpipe(udev
, pdev
->vendpoint
);
431 urb
->transfer_flags
= URB_ISO_ASAP
| URB_NO_TRANSFER_DMA_MAP
;
432 urb
->transfer_buffer
= usb_alloc_coherent(udev
,
436 if (urb
->transfer_buffer
== NULL
) {
437 PWC_ERROR("Failed to allocate urb buffer %d\n", i
);
439 pwc_isoc_cleanup(pdev
);
442 urb
->transfer_buffer_length
= ISO_BUFFER_SIZE
;
443 urb
->complete
= pwc_isoc_handler
;
445 urb
->start_frame
= 0;
446 urb
->number_of_packets
= ISO_FRAMES_PER_DESC
;
447 for (j
= 0; j
< ISO_FRAMES_PER_DESC
; j
++) {
448 urb
->iso_frame_desc
[j
].offset
= j
* ISO_MAX_FRAME_SIZE
;
449 urb
->iso_frame_desc
[j
].length
= pdev
->vmax_packet_size
;
454 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
455 ret
= usb_submit_urb(pdev
->urbs
[i
], GFP_KERNEL
);
456 if (ret
== -ENOSPC
&& compression
< 3) {
459 pwc_isoc_cleanup(pdev
);
463 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i
, ret
);
465 pwc_isoc_cleanup(pdev
);
468 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev
->urbs
[i
]);
473 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
477 static void pwc_iso_stop(struct pwc_device
*pdev
)
481 /* Unlinking ISOC buffers one by one */
482 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
484 PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev
->urbs
[i
]);
485 usb_kill_urb(pdev
->urbs
[i
]);
490 static void pwc_iso_free(struct pwc_device
*pdev
)
494 /* Freeing ISOC buffers one by one */
495 for (i
= 0; i
< MAX_ISO_BUFS
; i
++) {
497 PWC_DEBUG_MEMORY("Freeing URB\n");
498 if (pdev
->urbs
[i
]->transfer_buffer
) {
499 usb_free_coherent(pdev
->udev
,
500 pdev
->urbs
[i
]->transfer_buffer_length
,
501 pdev
->urbs
[i
]->transfer_buffer
,
502 pdev
->urbs
[i
]->transfer_dma
);
504 usb_free_urb(pdev
->urbs
[i
]);
505 pdev
->urbs
[i
] = NULL
;
510 static void pwc_isoc_cleanup(struct pwc_device
*pdev
)
512 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
514 if (pdev
->iso_init
== 0)
519 usb_set_interface(pdev
->udev
, 0, 0);
522 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
525 static void pwc_cleanup_queued_bufs(struct pwc_device
*pdev
)
527 unsigned long flags
= 0;
529 spin_lock_irqsave(&pdev
->queued_bufs_lock
, flags
);
530 while (!list_empty(&pdev
->queued_bufs
)) {
531 struct pwc_frame_buf
*buf
;
533 buf
= list_entry(pdev
->queued_bufs
.next
, struct pwc_frame_buf
,
535 list_del(&buf
->list
);
536 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
538 spin_unlock_irqrestore(&pdev
->queued_bufs_lock
, flags
);
541 #ifdef CONFIG_USB_PWC_DEBUG
542 static const char *pwc_sensor_type_to_string(unsigned int sensor_type
)
544 switch(sensor_type
) {
546 return "Hyundai CMOS sensor";
548 return "Sony CCD sensor + TDA8787";
550 return "Sony CCD sensor + Exas 98L59";
552 return "Sony CCD sensor + ADI 9804";
554 return "Sharp CCD sensor + TDA8787";
556 return "Sharp CCD sensor + Exas 98L59";
558 return "Sharp CCD sensor + ADI 9804";
560 return "UPA 1021 sensor";
564 return "PAL MR sensor";
566 return "unknown type of sensor";
571 /***************************************************************************/
572 /* Video4Linux functions */
574 int pwc_test_n_set_capt_file(struct pwc_device
*pdev
, struct file
*file
)
578 mutex_lock(&pdev
->capt_file_lock
);
579 if (pdev
->capt_file
!= NULL
&&
580 pdev
->capt_file
!= file
) {
584 pdev
->capt_file
= file
;
586 mutex_unlock(&pdev
->capt_file_lock
);
590 static void pwc_video_release(struct v4l2_device
*v
)
592 struct pwc_device
*pdev
= container_of(v
, struct pwc_device
, v4l2_dev
);
594 v4l2_ctrl_handler_free(&pdev
->ctrl_handler
);
595 kfree(pdev
->ctrl_buf
);
599 static int pwc_video_close(struct file
*file
)
601 struct pwc_device
*pdev
= video_drvdata(file
);
603 if (pdev
->capt_file
== file
) {
604 vb2_queue_release(&pdev
->vb_queue
);
605 pdev
->capt_file
= NULL
;
607 return v4l2_fh_release(file
);
610 static ssize_t
pwc_video_read(struct file
*file
, char __user
*buf
,
611 size_t count
, loff_t
*ppos
)
613 struct pwc_device
*pdev
= video_drvdata(file
);
618 if (pwc_test_n_set_capt_file(pdev
, file
))
621 return vb2_read(&pdev
->vb_queue
, buf
, count
, ppos
,
622 file
->f_flags
& O_NONBLOCK
);
625 static unsigned int pwc_video_poll(struct file
*file
, poll_table
*wait
)
627 struct pwc_device
*pdev
= video_drvdata(file
);
632 return vb2_poll(&pdev
->vb_queue
, file
, wait
);
635 static int pwc_video_mmap(struct file
*file
, struct vm_area_struct
*vma
)
637 struct pwc_device
*pdev
= video_drvdata(file
);
639 if (pdev
->capt_file
!= file
)
642 return vb2_mmap(&pdev
->vb_queue
, vma
);
645 /***************************************************************************/
646 /* Videobuf2 operations */
648 static int queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*fmt
,
649 unsigned int *nbuffers
, unsigned int *nplanes
,
650 unsigned int sizes
[], void *alloc_ctxs
[])
652 struct pwc_device
*pdev
= vb2_get_drv_priv(vq
);
655 if (*nbuffers
< MIN_FRAMES
)
656 *nbuffers
= MIN_FRAMES
;
657 else if (*nbuffers
> MAX_FRAMES
)
658 *nbuffers
= MAX_FRAMES
;
662 size
= pwc_get_size(pdev
, MAX_WIDTH
, MAX_HEIGHT
);
663 sizes
[0] = PAGE_ALIGN(pwc_image_sizes
[size
][0] *
664 pwc_image_sizes
[size
][1] * 3 / 2);
669 static int buffer_init(struct vb2_buffer
*vb
)
671 struct pwc_frame_buf
*buf
= container_of(vb
, struct pwc_frame_buf
, vb
);
673 /* need vmalloc since frame buffer > 128K */
674 buf
->data
= vzalloc(PWC_FRAME_SIZE
);
675 if (buf
->data
== NULL
)
681 static int buffer_prepare(struct vb2_buffer
*vb
)
683 struct pwc_device
*pdev
= vb2_get_drv_priv(vb
->vb2_queue
);
685 /* Don't allow queing new buffers after device disconnection */
692 static int buffer_finish(struct vb2_buffer
*vb
)
694 struct pwc_device
*pdev
= vb2_get_drv_priv(vb
->vb2_queue
);
695 struct pwc_frame_buf
*buf
= container_of(vb
, struct pwc_frame_buf
, vb
);
698 * Application has called dqbuf and is getting back a buffer we've
699 * filled, take the pwc data we've stored in buf->data and decompress
700 * it into a usable format, storing the result in the vb2_buffer
702 return pwc_decompress(pdev
, buf
);
705 static void buffer_cleanup(struct vb2_buffer
*vb
)
707 struct pwc_frame_buf
*buf
= container_of(vb
, struct pwc_frame_buf
, vb
);
712 static void buffer_queue(struct vb2_buffer
*vb
)
714 struct pwc_device
*pdev
= vb2_get_drv_priv(vb
->vb2_queue
);
715 struct pwc_frame_buf
*buf
= container_of(vb
, struct pwc_frame_buf
, vb
);
716 unsigned long flags
= 0;
718 spin_lock_irqsave(&pdev
->queued_bufs_lock
, flags
);
719 /* Check the device has not disconnected between prep and queuing */
721 list_add_tail(&buf
->list
, &pdev
->queued_bufs
);
723 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
724 spin_unlock_irqrestore(&pdev
->queued_bufs_lock
, flags
);
727 static int start_streaming(struct vb2_queue
*vq
, unsigned int count
)
729 struct pwc_device
*pdev
= vb2_get_drv_priv(vq
);
732 mutex_lock(&pdev
->udevlock
);
738 /* Turn on camera and set LEDS on */
739 pwc_camera_power(pdev
, 1);
740 pwc_set_leds(pdev
, leds
[0], leds
[1]);
742 r
= pwc_isoc_init(pdev
);
744 /* If we failed turn camera and LEDS back off */
745 pwc_set_leds(pdev
, 0, 0);
746 pwc_camera_power(pdev
, 0);
747 /* And cleanup any queued bufs!! */
748 pwc_cleanup_queued_bufs(pdev
);
751 mutex_unlock(&pdev
->udevlock
);
755 static int stop_streaming(struct vb2_queue
*vq
)
757 struct pwc_device
*pdev
= vb2_get_drv_priv(vq
);
759 mutex_lock(&pdev
->udevlock
);
761 pwc_set_leds(pdev
, 0, 0);
762 pwc_camera_power(pdev
, 0);
763 pwc_isoc_cleanup(pdev
);
765 mutex_unlock(&pdev
->udevlock
);
767 pwc_cleanup_queued_bufs(pdev
);
772 static struct vb2_ops pwc_vb_queue_ops
= {
773 .queue_setup
= queue_setup
,
774 .buf_init
= buffer_init
,
775 .buf_prepare
= buffer_prepare
,
776 .buf_finish
= buffer_finish
,
777 .buf_cleanup
= buffer_cleanup
,
778 .buf_queue
= buffer_queue
,
779 .start_streaming
= start_streaming
,
780 .stop_streaming
= stop_streaming
,
783 /***************************************************************************/
786 /* This function gets called when a new device is plugged in or the usb core
790 static int usb_pwc_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
792 struct usb_device
*udev
= interface_to_usbdev(intf
);
793 struct pwc_device
*pdev
= NULL
;
794 int vendor_id
, product_id
, type_id
;
798 int my_power_save
= power_save
;
799 char serial_number
[30], *name
;
801 vendor_id
= le16_to_cpu(udev
->descriptor
.idVendor
);
802 product_id
= le16_to_cpu(udev
->descriptor
.idProduct
);
804 /* Check if we can handle this device */
805 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
806 vendor_id
, product_id
,
807 intf
->altsetting
->desc
.bInterfaceNumber
);
809 /* the interfaces are probed one by one. We are only interested in the
810 video interface (0) now.
811 Interface 1 is the Audio Control, and interface 2 Audio itself.
813 if (intf
->altsetting
->desc
.bInterfaceNumber
> 0)
816 if (vendor_id
== 0x0471) {
817 switch (product_id
) {
819 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
820 name
= "Philips 645 webcam";
824 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
825 name
= "Philips 646 webcam";
829 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
830 name
= "Askey VC010 webcam";
834 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
835 name
= "Philips 675 webcam";
839 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
840 name
= "Philips 680 webcam";
844 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
845 name
= "Philips 690 webcam";
849 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
850 name
= "Philips 730 webcam";
854 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
855 name
= "Philips 740 webcam";
859 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
860 name
= "Philips 750 webcam";
864 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
865 name
= "Philips 720K/40 webcam";
869 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
870 name
= "Philips SPC 900NC webcam";
878 else if (vendor_id
== 0x069A) {
881 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
882 name
= "Askey VC010 webcam";
890 else if (vendor_id
== 0x046d) {
893 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
894 name
= "Logitech QuickCam Pro 3000";
895 type_id
= 740; /* CCD sensor */
898 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
899 name
= "Logitech QuickCam Notebook Pro";
900 type_id
= 740; /* CCD sensor */
903 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
904 name
= "Logitech QuickCam Pro 4000";
905 type_id
= 740; /* CCD sensor */
906 if (my_power_save
== -1)
910 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
911 name
= "Logitech QuickCam Zoom";
912 type_id
= 740; /* CCD sensor */
915 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
916 name
= "Logitech QuickCam Zoom";
917 type_id
= 740; /* CCD sensor */
918 if (my_power_save
== -1)
922 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
923 name
= "Logitech QuickCam Orbit";
924 type_id
= 740; /* CCD sensor */
925 if (my_power_save
== -1)
927 features
|= FEATURE_MOTOR_PANTILT
;
930 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
931 name
= "Cisco VT Camera";
932 type_id
= 740; /* CCD sensor */
935 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
936 name
= "Logitech ViewPort AV 100";
937 type_id
= 740; /* CCD sensor */
939 case 0x08b8: /* Where this released? */
940 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
941 name
= "Logitech QuickCam (res.)";
942 type_id
= 730; /* Assuming CMOS */
949 else if (vendor_id
== 0x055d) {
950 /* I don't know the difference between the C10 and the C30;
951 I suppose the difference is the sensor, but both cameras
952 work equally well with a type_id of 675
956 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
957 name
= "Samsung MPC-C10";
961 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
962 name
= "Samsung MPC-C30";
966 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
967 name
= "Samsung MPC-C30";
975 else if (vendor_id
== 0x041e) {
978 PWC_INFO("Creative Labs Webcam 5 detected.\n");
979 name
= "Creative Labs Webcam 5";
981 if (my_power_save
== -1)
985 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
986 name
= "Creative Labs Webcam Pro Ex";
994 else if (vendor_id
== 0x04cc) {
997 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
998 name
= "Sotec Afina Eye";
1006 else if (vendor_id
== 0x06be) {
1007 switch(product_id
) {
1009 /* This is essentially the same cam as the Sotec Afina Eye */
1010 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1011 name
= "AME Co. Afina Eye";
1020 else if (vendor_id
== 0x0d81) {
1021 switch(product_id
) {
1023 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1024 name
= "Visionite VCS-UC300";
1025 type_id
= 740; /* CCD sensor */
1028 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1029 name
= "Visionite VCS-UM100";
1030 type_id
= 730; /* CMOS sensor */
1038 return -ENODEV
; /* Not any of the know types; but the list keeps growing. */
1040 if (my_power_save
== -1)
1043 memset(serial_number
, 0, 30);
1044 usb_string(udev
, udev
->descriptor
.iSerialNumber
, serial_number
, 29);
1045 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number
);
1047 if (udev
->descriptor
.bNumConfigurations
> 1)
1048 PWC_WARNING("Warning: more than 1 configuration available.\n");
1050 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1051 pdev
= kzalloc(sizeof(struct pwc_device
), GFP_KERNEL
);
1053 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1056 pdev
->type
= type_id
;
1057 pdev
->features
= features
;
1058 pwc_construct(pdev
); /* set min/max sizes correct */
1060 mutex_init(&pdev
->capt_file_lock
);
1061 mutex_init(&pdev
->udevlock
);
1062 spin_lock_init(&pdev
->queued_bufs_lock
);
1063 INIT_LIST_HEAD(&pdev
->queued_bufs
);
1066 pdev
->power_save
= my_power_save
;
1068 /* Init videobuf2 queue structure */
1069 memset(&pdev
->vb_queue
, 0, sizeof(pdev
->vb_queue
));
1070 pdev
->vb_queue
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1071 pdev
->vb_queue
.io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_READ
;
1072 pdev
->vb_queue
.drv_priv
= pdev
;
1073 pdev
->vb_queue
.buf_struct_size
= sizeof(struct pwc_frame_buf
);
1074 pdev
->vb_queue
.ops
= &pwc_vb_queue_ops
;
1075 pdev
->vb_queue
.mem_ops
= &vb2_vmalloc_memops
;
1076 vb2_queue_init(&pdev
->vb_queue
);
1078 /* Init video_device structure */
1079 memcpy(&pdev
->vdev
, &pwc_template
, sizeof(pwc_template
));
1080 strcpy(pdev
->vdev
.name
, name
);
1081 set_bit(V4L2_FL_USE_FH_PRIO
, &pdev
->vdev
.flags
);
1082 video_set_drvdata(&pdev
->vdev
, pdev
);
1084 pdev
->release
= le16_to_cpu(udev
->descriptor
.bcdDevice
);
1085 PWC_DEBUG_PROBE("Release: %04x\n", pdev
->release
);
1087 /* Allocate USB command buffers */
1088 pdev
->ctrl_buf
= kmalloc(sizeof(pdev
->cmd_buf
), GFP_KERNEL
);
1089 if (!pdev
->ctrl_buf
) {
1090 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1095 #ifdef CONFIG_USB_PWC_DEBUG
1096 /* Query sensor type */
1097 if (pwc_get_cmos_sensor(pdev
, &rc
) >= 0) {
1098 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1100 pwc_sensor_type_to_string(rc
), rc
);
1104 /* Set the leds off */
1105 pwc_set_leds(pdev
, 0, 0);
1107 /* Setup intial videomode */
1108 rc
= pwc_set_video_mode(pdev
, MAX_WIDTH
, MAX_HEIGHT
,
1109 V4L2_PIX_FMT_YUV420
, 30, &compression
, 1);
1113 /* Register controls (and read default values from camera */
1114 rc
= pwc_init_controls(pdev
);
1116 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc
);
1120 /* And powerdown the camera until streaming starts */
1121 pwc_camera_power(pdev
, 0);
1123 /* Register the v4l2_device structure */
1124 pdev
->v4l2_dev
.release
= pwc_video_release
;
1125 rc
= v4l2_device_register(&intf
->dev
, &pdev
->v4l2_dev
);
1127 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc
);
1128 goto err_free_controls
;
1131 pdev
->v4l2_dev
.ctrl_handler
= &pdev
->ctrl_handler
;
1132 pdev
->vdev
.v4l2_dev
= &pdev
->v4l2_dev
;
1134 rc
= video_register_device(&pdev
->vdev
, VFL_TYPE_GRABBER
, -1);
1136 PWC_ERROR("Failed to register as video device (%d).\n", rc
);
1137 goto err_unregister_v4l2_dev
;
1139 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev
->vdev
));
1141 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1142 /* register webcam snapshot button input device */
1143 pdev
->button_dev
= input_allocate_device();
1144 if (!pdev
->button_dev
) {
1145 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1147 goto err_video_unreg
;
1150 usb_make_path(udev
, pdev
->button_phys
, sizeof(pdev
->button_phys
));
1151 strlcat(pdev
->button_phys
, "/input0", sizeof(pdev
->button_phys
));
1153 pdev
->button_dev
->name
= "PWC snapshot button";
1154 pdev
->button_dev
->phys
= pdev
->button_phys
;
1155 usb_to_input_id(pdev
->udev
, &pdev
->button_dev
->id
);
1156 pdev
->button_dev
->dev
.parent
= &pdev
->udev
->dev
;
1157 pdev
->button_dev
->evbit
[0] = BIT_MASK(EV_KEY
);
1158 pdev
->button_dev
->keybit
[BIT_WORD(KEY_CAMERA
)] = BIT_MASK(KEY_CAMERA
);
1160 rc
= input_register_device(pdev
->button_dev
);
1162 input_free_device(pdev
->button_dev
);
1163 pdev
->button_dev
= NULL
;
1164 goto err_video_unreg
;
1171 video_unregister_device(&pdev
->vdev
);
1172 err_unregister_v4l2_dev
:
1173 v4l2_device_unregister(&pdev
->v4l2_dev
);
1175 v4l2_ctrl_handler_free(&pdev
->ctrl_handler
);
1177 kfree(pdev
->ctrl_buf
);
1182 /* The user yanked out the cable... */
1183 static void usb_pwc_disconnect(struct usb_interface
*intf
)
1185 struct v4l2_device
*v
= usb_get_intfdata(intf
);
1186 struct pwc_device
*pdev
= container_of(v
, struct pwc_device
, v4l2_dev
);
1188 mutex_lock(&pdev
->udevlock
);
1189 /* No need to keep the urbs around after disconnection */
1190 pwc_isoc_cleanup(pdev
);
1192 mutex_unlock(&pdev
->udevlock
);
1194 pwc_cleanup_queued_bufs(pdev
);
1196 video_unregister_device(&pdev
->vdev
);
1197 v4l2_device_unregister(&pdev
->v4l2_dev
);
1199 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1200 if (pdev
->button_dev
)
1201 input_unregister_device(pdev
->button_dev
);
1204 v4l2_device_put(&pdev
->v4l2_dev
);
1209 * Initialization code & module stuff
1212 static unsigned int leds_nargs
;
1214 #ifdef CONFIG_USB_PWC_DEBUG
1215 module_param_named(trace
, pwc_trace
, int, 0644);
1217 module_param(power_save
, int, 0644);
1218 module_param_array(leds
, int, &leds_nargs
, 0444);
1220 #ifdef CONFIG_USB_PWC_DEBUG
1221 MODULE_PARM_DESC(trace
, "For debugging purposes");
1223 MODULE_PARM_DESC(power_save
, "Turn power saving for new cameras on or off");
1224 MODULE_PARM_DESC(leds
, "LED on,off time in milliseconds");
1226 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1227 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1228 MODULE_LICENSE("GPL");
1229 MODULE_ALIAS("pwcx");
1230 MODULE_VERSION( PWC_VERSION
);
1232 static int __init
usb_pwc_init(void)
1234 return usb_register(&pwc_driver
);
1237 static void __exit
usb_pwc_exit(void)
1239 usb_deregister(&pwc_driver
);
1242 module_init(usb_pwc_init
);
1243 module_exit(usb_pwc_exit
);