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>
6
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.
12
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.
17
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.
22
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
26
27 */
28
29 /*
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.
35
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
39 without explanation).
40
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 *
46 */
47
48 /* Contributors:
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
58 */
59
60 #include <linux/errno.h>
61 #include <linux/init.h>
62 #include <linux/mm.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>
68 #endif
69 #include <linux/vmalloc.h>
70 #include <asm/io.h>
71 #include <linux/kernel.h> /* simple_strtol() */
72
73 #include "pwc.h"
74 #include "pwc-kiara.h"
75 #include "pwc-timon.h"
76 #include "pwc-dec23.h"
77 #include "pwc-dec1.h"
78
79 /* Function prototypes and driver templates */
80
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(0x0471, 0x032C) }, /* Philips SPC 880NC PC Camera */
95 { USB_DEVICE(0x069A, 0x0001) }, /* Askey */
96 { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
97 { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
98 { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
99 { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
100 { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
101 { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
102 { USB_DEVICE(0x046D, 0x08B6) }, /* Cisco VT Camera */
103 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
104 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
105 { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
106 { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
107 { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
108 { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
109 { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
110 { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
111 { USB_DEVICE(0x06BE, 0x8116) }, /* new Afina Eye */
112 { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
113 { USB_DEVICE(0x0d81, 0x1900) },
114 { }
115 };
116 MODULE_DEVICE_TABLE(usb, pwc_device_table);
117
118 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
119 static void usb_pwc_disconnect(struct usb_interface *intf);
120 static void pwc_isoc_cleanup(struct pwc_device *pdev);
121
122 static struct usb_driver pwc_driver = {
123 .name = "Philips webcam", /* name */
124 .id_table = pwc_device_table,
125 .probe = usb_pwc_probe, /* probe() */
126 .disconnect = usb_pwc_disconnect, /* disconnect() */
127 };
128
129 #define MAX_DEV_HINTS 20
130 #define MAX_ISOC_ERRORS 20
131
132 #ifdef CONFIG_USB_PWC_DEBUG
133 int pwc_trace = PWC_DEBUG_LEVEL;
134 #endif
135 static int power_save = -1;
136 static int leds[2] = { 100, 0 };
137
138 /***/
139
140 static const struct v4l2_file_operations pwc_fops = {
141 .owner = THIS_MODULE,
142 .open = v4l2_fh_open,
143 .release = vb2_fop_release,
144 .read = vb2_fop_read,
145 .poll = vb2_fop_poll,
146 .mmap = vb2_fop_mmap,
147 .unlocked_ioctl = video_ioctl2,
148 };
149 static struct video_device pwc_template = {
150 .name = "Philips Webcam", /* Filled in later */
151 .release = video_device_release_empty,
152 .fops = &pwc_fops,
153 .ioctl_ops = &pwc_ioctl_ops,
154 };
155
156 /***************************************************************************/
157 /* Private functions */
158
pwc_get_next_fill_buf(struct pwc_device * pdev)159 static struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
160 {
161 unsigned long flags = 0;
162 struct pwc_frame_buf *buf = NULL;
163
164 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
165 if (list_empty(&pdev->queued_bufs))
166 goto leave;
167
168 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
169 list_del(&buf->list);
170 leave:
171 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
172 return buf;
173 }
174
pwc_snapshot_button(struct pwc_device * pdev,int down)175 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
176 {
177 if (down) {
178 PWC_TRACE("Snapshot button pressed.\n");
179 } else {
180 PWC_TRACE("Snapshot button released.\n");
181 }
182
183 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
184 if (pdev->button_dev) {
185 input_report_key(pdev->button_dev, KEY_CAMERA, down);
186 input_sync(pdev->button_dev);
187 }
188 #endif
189 }
190
pwc_frame_complete(struct pwc_device * pdev)191 static void pwc_frame_complete(struct pwc_device *pdev)
192 {
193 struct pwc_frame_buf *fbuf = pdev->fill_buf;
194
195 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
196 frames on the USB wire after an exposure change. This conditition is
197 however detected in the cam and a bit is set in the header.
198 */
199 if (pdev->type == 730) {
200 unsigned char *ptr = (unsigned char *)fbuf->data;
201
202 if (ptr[1] == 1 && ptr[0] & 0x10) {
203 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
204 pdev->drop_frames += 2;
205 }
206 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
207 pwc_snapshot_button(pdev, ptr[0] & 0x01);
208 }
209 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
210 if (ptr[0] & 0x02)
211 PWC_TRACE("Image is mirrored.\n");
212 else
213 PWC_TRACE("Image is normal.\n");
214 }
215 pdev->vmirror = ptr[0] & 0x03;
216 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
217 after a short frame; this condition is filtered out specifically. A 4 byte
218 frame doesn't make sense anyway.
219 So we get either this sequence:
220 drop_bit set -> 4 byte frame -> short frame -> good frame
221 Or this one:
222 drop_bit set -> short frame -> good frame
223 So we drop either 3 or 2 frames in all!
224 */
225 if (fbuf->filled == 4)
226 pdev->drop_frames++;
227 } else if (pdev->type == 740 || pdev->type == 720) {
228 unsigned char *ptr = (unsigned char *)fbuf->data;
229 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
230 pwc_snapshot_button(pdev, ptr[0] & 0x01);
231 }
232 pdev->vmirror = ptr[0] & 0x03;
233 }
234
235 /* In case we were instructed to drop the frame, do so silently. */
236 if (pdev->drop_frames > 0) {
237 pdev->drop_frames--;
238 } else {
239 /* Check for underflow first */
240 if (fbuf->filled < pdev->frame_total_size) {
241 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
242 " discarded.\n", fbuf->filled);
243 } else {
244 fbuf->vb.v4l2_buf.field = V4L2_FIELD_NONE;
245 fbuf->vb.v4l2_buf.sequence = pdev->vframe_count;
246 vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
247 pdev->fill_buf = NULL;
248 pdev->vsync = 0;
249 }
250 } /* !drop_frames */
251 pdev->vframe_count++;
252 }
253
254 /* This gets called for the Isochronous pipe (video). This is done in
255 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
256 */
pwc_isoc_handler(struct urb * urb)257 static void pwc_isoc_handler(struct urb *urb)
258 {
259 struct pwc_device *pdev = (struct pwc_device *)urb->context;
260 int i, fst, flen;
261 unsigned char *iso_buf = NULL;
262
263 if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
264 urb->status == -ESHUTDOWN) {
265 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
266 return;
267 }
268
269 if (pdev->fill_buf == NULL)
270 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
271
272 if (urb->status != 0) {
273 const char *errmsg;
274
275 errmsg = "Unknown";
276 switch(urb->status) {
277 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
278 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
279 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
280 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
281 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
282 case -ETIME: errmsg = "Device does not respond"; break;
283 }
284 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
285 urb->status, errmsg);
286 /* Give up after a number of contiguous errors */
287 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
288 {
289 PWC_ERROR("Too many ISOC errors, bailing out.\n");
290 if (pdev->fill_buf) {
291 vb2_buffer_done(&pdev->fill_buf->vb,
292 VB2_BUF_STATE_ERROR);
293 pdev->fill_buf = NULL;
294 }
295 }
296 pdev->vsync = 0; /* Drop the current frame */
297 goto handler_end;
298 }
299
300 /* Reset ISOC error counter. We did get here, after all. */
301 pdev->visoc_errors = 0;
302
303 /* vsync: 0 = don't copy data
304 1 = sync-hunt
305 2 = synched
306 */
307 /* Compact data */
308 for (i = 0; i < urb->number_of_packets; i++) {
309 fst = urb->iso_frame_desc[i].status;
310 flen = urb->iso_frame_desc[i].actual_length;
311 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
312 if (fst != 0) {
313 PWC_ERROR("Iso frame %d has error %d\n", i, fst);
314 continue;
315 }
316 if (flen > 0 && pdev->vsync) {
317 struct pwc_frame_buf *fbuf = pdev->fill_buf;
318
319 if (pdev->vsync == 1) {
320 v4l2_get_timestamp(
321 &fbuf->vb.v4l2_buf.timestamp);
322 pdev->vsync = 2;
323 }
324
325 if (flen + fbuf->filled > pdev->frame_total_size) {
326 PWC_ERROR("Frame overflow (%d > %d)\n",
327 flen + fbuf->filled,
328 pdev->frame_total_size);
329 pdev->vsync = 0; /* Let's wait for an EOF */
330 } else {
331 memcpy(fbuf->data + fbuf->filled, iso_buf,
332 flen);
333 fbuf->filled += flen;
334 }
335 }
336 if (flen < pdev->vlast_packet_size) {
337 /* Shorter packet... end of frame */
338 if (pdev->vsync == 2)
339 pwc_frame_complete(pdev);
340 if (pdev->fill_buf == NULL)
341 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
342 if (pdev->fill_buf) {
343 pdev->fill_buf->filled = 0;
344 pdev->vsync = 1;
345 }
346 }
347 pdev->vlast_packet_size = flen;
348 }
349
350 handler_end:
351 i = usb_submit_urb(urb, GFP_ATOMIC);
352 if (i != 0)
353 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
354 }
355
356 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
pwc_isoc_init(struct pwc_device * pdev)357 static int pwc_isoc_init(struct pwc_device *pdev)
358 {
359 struct usb_device *udev;
360 struct urb *urb;
361 int i, j, ret;
362 struct usb_interface *intf;
363 struct usb_host_interface *idesc = NULL;
364 int compression = 0; /* 0..3 = uncompressed..high */
365
366 pdev->vsync = 0;
367 pdev->vlast_packet_size = 0;
368 pdev->fill_buf = NULL;
369 pdev->vframe_count = 0;
370 pdev->visoc_errors = 0;
371 udev = pdev->udev;
372
373 retry:
374 /* We first try with low compression and then retry with a higher
375 compression setting if there is not enough bandwidth. */
376 ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
377 pdev->vframes, &compression, 1);
378
379 /* Get the current alternate interface, adjust packet size */
380 intf = usb_ifnum_to_if(udev, 0);
381 if (intf)
382 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
383 if (!idesc)
384 return -EIO;
385
386 /* Search video endpoint */
387 pdev->vmax_packet_size = -1;
388 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
389 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
390 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
391 break;
392 }
393 }
394
395 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
396 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
397 return -ENFILE; /* Odd error, that should be noticeable */
398 }
399
400 /* Set alternate interface */
401 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
402 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
403 if (ret == -ENOSPC && compression < 3) {
404 compression++;
405 goto retry;
406 }
407 if (ret < 0)
408 return ret;
409
410 /* Allocate and init Isochronuous urbs */
411 for (i = 0; i < MAX_ISO_BUFS; i++) {
412 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
413 if (urb == NULL) {
414 PWC_ERROR("Failed to allocate urb %d\n", i);
415 pwc_isoc_cleanup(pdev);
416 return -ENOMEM;
417 }
418 pdev->urbs[i] = urb;
419 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
420
421 urb->interval = 1; // devik
422 urb->dev = udev;
423 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
424 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
425 urb->transfer_buffer = usb_alloc_coherent(udev,
426 ISO_BUFFER_SIZE,
427 GFP_KERNEL,
428 &urb->transfer_dma);
429 if (urb->transfer_buffer == NULL) {
430 PWC_ERROR("Failed to allocate urb buffer %d\n", i);
431 pwc_isoc_cleanup(pdev);
432 return -ENOMEM;
433 }
434 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
435 urb->complete = pwc_isoc_handler;
436 urb->context = pdev;
437 urb->start_frame = 0;
438 urb->number_of_packets = ISO_FRAMES_PER_DESC;
439 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
440 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
441 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
442 }
443 }
444
445 /* link */
446 for (i = 0; i < MAX_ISO_BUFS; i++) {
447 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
448 if (ret == -ENOSPC && compression < 3) {
449 compression++;
450 pwc_isoc_cleanup(pdev);
451 goto retry;
452 }
453 if (ret) {
454 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
455 pwc_isoc_cleanup(pdev);
456 return ret;
457 }
458 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
459 }
460
461 /* All is done... */
462 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
463 return 0;
464 }
465
pwc_iso_stop(struct pwc_device * pdev)466 static void pwc_iso_stop(struct pwc_device *pdev)
467 {
468 int i;
469
470 /* Unlinking ISOC buffers one by one */
471 for (i = 0; i < MAX_ISO_BUFS; i++) {
472 if (pdev->urbs[i]) {
473 PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
474 usb_kill_urb(pdev->urbs[i]);
475 }
476 }
477 }
478
pwc_iso_free(struct pwc_device * pdev)479 static void pwc_iso_free(struct pwc_device *pdev)
480 {
481 int i;
482
483 /* Freeing ISOC buffers one by one */
484 for (i = 0; i < MAX_ISO_BUFS; i++) {
485 if (pdev->urbs[i]) {
486 PWC_DEBUG_MEMORY("Freeing URB\n");
487 if (pdev->urbs[i]->transfer_buffer) {
488 usb_free_coherent(pdev->udev,
489 pdev->urbs[i]->transfer_buffer_length,
490 pdev->urbs[i]->transfer_buffer,
491 pdev->urbs[i]->transfer_dma);
492 }
493 usb_free_urb(pdev->urbs[i]);
494 pdev->urbs[i] = NULL;
495 }
496 }
497 }
498
499 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
pwc_isoc_cleanup(struct pwc_device * pdev)500 static void pwc_isoc_cleanup(struct pwc_device *pdev)
501 {
502 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
503
504 pwc_iso_stop(pdev);
505 pwc_iso_free(pdev);
506 usb_set_interface(pdev->udev, 0, 0);
507
508 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
509 }
510
511 /* Must be called with vb_queue_lock hold */
pwc_cleanup_queued_bufs(struct pwc_device * pdev,enum vb2_buffer_state state)512 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev,
513 enum vb2_buffer_state state)
514 {
515 unsigned long flags = 0;
516
517 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
518 while (!list_empty(&pdev->queued_bufs)) {
519 struct pwc_frame_buf *buf;
520
521 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
522 list);
523 list_del(&buf->list);
524 vb2_buffer_done(&buf->vb, state);
525 }
526 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
527 }
528
529 #ifdef CONFIG_USB_PWC_DEBUG
pwc_sensor_type_to_string(unsigned int sensor_type)530 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
531 {
532 switch(sensor_type) {
533 case 0x00:
534 return "Hyundai CMOS sensor";
535 case 0x20:
536 return "Sony CCD sensor + TDA8787";
537 case 0x2E:
538 return "Sony CCD sensor + Exas 98L59";
539 case 0x2F:
540 return "Sony CCD sensor + ADI 9804";
541 case 0x30:
542 return "Sharp CCD sensor + TDA8787";
543 case 0x3E:
544 return "Sharp CCD sensor + Exas 98L59";
545 case 0x3F:
546 return "Sharp CCD sensor + ADI 9804";
547 case 0x40:
548 return "UPA 1021 sensor";
549 case 0x100:
550 return "VGA sensor";
551 case 0x101:
552 return "PAL MR sensor";
553 default:
554 return "unknown type of sensor";
555 }
556 }
557 #endif
558
559 /***************************************************************************/
560 /* Video4Linux functions */
561
pwc_video_release(struct v4l2_device * v)562 static void pwc_video_release(struct v4l2_device *v)
563 {
564 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
565
566 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
567 v4l2_device_unregister(&pdev->v4l2_dev);
568 kfree(pdev->ctrl_buf);
569 kfree(pdev);
570 }
571
572 /***************************************************************************/
573 /* Videobuf2 operations */
574
queue_setup(struct vb2_queue * vq,const struct v4l2_format * fmt,unsigned int * nbuffers,unsigned int * nplanes,unsigned int sizes[],void * alloc_ctxs[])575 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
576 unsigned int *nbuffers, unsigned int *nplanes,
577 unsigned int sizes[], void *alloc_ctxs[])
578 {
579 struct pwc_device *pdev = vb2_get_drv_priv(vq);
580 int size;
581
582 if (*nbuffers < MIN_FRAMES)
583 *nbuffers = MIN_FRAMES;
584 else if (*nbuffers > MAX_FRAMES)
585 *nbuffers = MAX_FRAMES;
586
587 *nplanes = 1;
588
589 size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
590 sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
591 pwc_image_sizes[size][1] * 3 / 2);
592
593 return 0;
594 }
595
buffer_init(struct vb2_buffer * vb)596 static int buffer_init(struct vb2_buffer *vb)
597 {
598 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
599
600 /* need vmalloc since frame buffer > 128K */
601 buf->data = vzalloc(PWC_FRAME_SIZE);
602 if (buf->data == NULL)
603 return -ENOMEM;
604
605 return 0;
606 }
607
buffer_prepare(struct vb2_buffer * vb)608 static int buffer_prepare(struct vb2_buffer *vb)
609 {
610 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
611
612 /* Don't allow queing new buffers after device disconnection */
613 if (!pdev->udev)
614 return -ENODEV;
615
616 return 0;
617 }
618
buffer_finish(struct vb2_buffer * vb)619 static void buffer_finish(struct vb2_buffer *vb)
620 {
621 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
622 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
623
624 if (vb->state == VB2_BUF_STATE_DONE) {
625 /*
626 * Application has called dqbuf and is getting back a buffer
627 * we've filled, take the pwc data we've stored in buf->data
628 * and decompress it into a usable format, storing the result
629 * in the vb2_buffer.
630 */
631 pwc_decompress(pdev, buf);
632 }
633 }
634
buffer_cleanup(struct vb2_buffer * vb)635 static void buffer_cleanup(struct vb2_buffer *vb)
636 {
637 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
638
639 vfree(buf->data);
640 }
641
buffer_queue(struct vb2_buffer * vb)642 static void buffer_queue(struct vb2_buffer *vb)
643 {
644 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
645 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
646 unsigned long flags = 0;
647
648 /* Check the device has not disconnected between prep and queuing */
649 if (!pdev->udev) {
650 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
651 return;
652 }
653
654 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
655 list_add_tail(&buf->list, &pdev->queued_bufs);
656 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
657 }
658
start_streaming(struct vb2_queue * vq,unsigned int count)659 static int start_streaming(struct vb2_queue *vq, unsigned int count)
660 {
661 struct pwc_device *pdev = vb2_get_drv_priv(vq);
662 int r;
663
664 if (!pdev->udev)
665 return -ENODEV;
666
667 if (mutex_lock_interruptible(&pdev->v4l2_lock))
668 return -ERESTARTSYS;
669 /* Turn on camera and set LEDS on */
670 pwc_camera_power(pdev, 1);
671 pwc_set_leds(pdev, leds[0], leds[1]);
672
673 r = pwc_isoc_init(pdev);
674 if (r) {
675 /* If we failed turn camera and LEDS back off */
676 pwc_set_leds(pdev, 0, 0);
677 pwc_camera_power(pdev, 0);
678 /* And cleanup any queued bufs!! */
679 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED);
680 }
681 mutex_unlock(&pdev->v4l2_lock);
682
683 return r;
684 }
685
stop_streaming(struct vb2_queue * vq)686 static void stop_streaming(struct vb2_queue *vq)
687 {
688 struct pwc_device *pdev = vb2_get_drv_priv(vq);
689
690 mutex_lock(&pdev->v4l2_lock);
691 if (pdev->udev) {
692 pwc_set_leds(pdev, 0, 0);
693 pwc_camera_power(pdev, 0);
694 pwc_isoc_cleanup(pdev);
695 }
696
697 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR);
698 if (pdev->fill_buf)
699 vb2_buffer_done(&pdev->fill_buf->vb, VB2_BUF_STATE_ERROR);
700 mutex_unlock(&pdev->v4l2_lock);
701 }
702
703 static struct vb2_ops pwc_vb_queue_ops = {
704 .queue_setup = queue_setup,
705 .buf_init = buffer_init,
706 .buf_prepare = buffer_prepare,
707 .buf_finish = buffer_finish,
708 .buf_cleanup = buffer_cleanup,
709 .buf_queue = buffer_queue,
710 .start_streaming = start_streaming,
711 .stop_streaming = stop_streaming,
712 .wait_prepare = vb2_ops_wait_prepare,
713 .wait_finish = vb2_ops_wait_finish,
714 };
715
716 /***************************************************************************/
717 /* USB functions */
718
719 /* This function gets called when a new device is plugged in or the usb core
720 * is loaded.
721 */
722
usb_pwc_probe(struct usb_interface * intf,const struct usb_device_id * id)723 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
724 {
725 struct usb_device *udev = interface_to_usbdev(intf);
726 struct pwc_device *pdev = NULL;
727 int vendor_id, product_id, type_id;
728 int rc;
729 int features = 0;
730 int compression = 0;
731 int my_power_save = power_save;
732 char serial_number[30], *name;
733
734 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
735 product_id = le16_to_cpu(udev->descriptor.idProduct);
736
737 /* Check if we can handle this device */
738 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
739 vendor_id, product_id,
740 intf->altsetting->desc.bInterfaceNumber);
741
742 /* the interfaces are probed one by one. We are only interested in the
743 video interface (0) now.
744 Interface 1 is the Audio Control, and interface 2 Audio itself.
745 */
746 if (intf->altsetting->desc.bInterfaceNumber > 0)
747 return -ENODEV;
748
749 if (vendor_id == 0x0471) {
750 switch (product_id) {
751 case 0x0302:
752 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
753 name = "Philips 645 webcam";
754 type_id = 645;
755 break;
756 case 0x0303:
757 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
758 name = "Philips 646 webcam";
759 type_id = 646;
760 break;
761 case 0x0304:
762 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
763 name = "Askey VC010 webcam";
764 type_id = 646;
765 break;
766 case 0x0307:
767 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
768 name = "Philips 675 webcam";
769 type_id = 675;
770 break;
771 case 0x0308:
772 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
773 name = "Philips 680 webcam";
774 type_id = 680;
775 break;
776 case 0x030C:
777 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
778 name = "Philips 690 webcam";
779 type_id = 690;
780 break;
781 case 0x0310:
782 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
783 name = "Philips 730 webcam";
784 type_id = 730;
785 break;
786 case 0x0311:
787 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
788 name = "Philips 740 webcam";
789 type_id = 740;
790 break;
791 case 0x0312:
792 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
793 name = "Philips 750 webcam";
794 type_id = 750;
795 break;
796 case 0x0313:
797 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
798 name = "Philips 720K/40 webcam";
799 type_id = 720;
800 break;
801 case 0x0329:
802 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
803 name = "Philips SPC 900NC webcam";
804 type_id = 740;
805 break;
806 case 0x032C:
807 PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
808 name = "Philips SPC 880NC webcam";
809 type_id = 740;
810 break;
811 default:
812 return -ENODEV;
813 break;
814 }
815 }
816 else if (vendor_id == 0x069A) {
817 switch(product_id) {
818 case 0x0001:
819 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
820 name = "Askey VC010 webcam";
821 type_id = 645;
822 break;
823 default:
824 return -ENODEV;
825 break;
826 }
827 }
828 else if (vendor_id == 0x046d) {
829 switch(product_id) {
830 case 0x08b0:
831 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
832 name = "Logitech QuickCam Pro 3000";
833 type_id = 740; /* CCD sensor */
834 break;
835 case 0x08b1:
836 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
837 name = "Logitech QuickCam Notebook Pro";
838 type_id = 740; /* CCD sensor */
839 break;
840 case 0x08b2:
841 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
842 name = "Logitech QuickCam Pro 4000";
843 type_id = 740; /* CCD sensor */
844 if (my_power_save == -1)
845 my_power_save = 1;
846 break;
847 case 0x08b3:
848 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
849 name = "Logitech QuickCam Zoom";
850 type_id = 740; /* CCD sensor */
851 break;
852 case 0x08B4:
853 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
854 name = "Logitech QuickCam Zoom";
855 type_id = 740; /* CCD sensor */
856 if (my_power_save == -1)
857 my_power_save = 1;
858 break;
859 case 0x08b5:
860 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
861 name = "Logitech QuickCam Orbit";
862 type_id = 740; /* CCD sensor */
863 if (my_power_save == -1)
864 my_power_save = 1;
865 features |= FEATURE_MOTOR_PANTILT;
866 break;
867 case 0x08b6:
868 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
869 name = "Cisco VT Camera";
870 type_id = 740; /* CCD sensor */
871 break;
872 case 0x08b7:
873 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
874 name = "Logitech ViewPort AV 100";
875 type_id = 740; /* CCD sensor */
876 break;
877 case 0x08b8: /* Where this released? */
878 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
879 name = "Logitech QuickCam (res.)";
880 type_id = 730; /* Assuming CMOS */
881 break;
882 default:
883 return -ENODEV;
884 break;
885 }
886 }
887 else if (vendor_id == 0x055d) {
888 /* I don't know the difference between the C10 and the C30;
889 I suppose the difference is the sensor, but both cameras
890 work equally well with a type_id of 675
891 */
892 switch(product_id) {
893 case 0x9000:
894 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
895 name = "Samsung MPC-C10";
896 type_id = 675;
897 break;
898 case 0x9001:
899 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
900 name = "Samsung MPC-C30";
901 type_id = 675;
902 break;
903 case 0x9002:
904 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
905 name = "Samsung MPC-C30";
906 type_id = 740;
907 break;
908 default:
909 return -ENODEV;
910 break;
911 }
912 }
913 else if (vendor_id == 0x041e) {
914 switch(product_id) {
915 case 0x400c:
916 PWC_INFO("Creative Labs Webcam 5 detected.\n");
917 name = "Creative Labs Webcam 5";
918 type_id = 730;
919 if (my_power_save == -1)
920 my_power_save = 1;
921 break;
922 case 0x4011:
923 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
924 name = "Creative Labs Webcam Pro Ex";
925 type_id = 740;
926 break;
927 default:
928 return -ENODEV;
929 break;
930 }
931 }
932 else if (vendor_id == 0x04cc) {
933 switch(product_id) {
934 case 0x8116:
935 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
936 name = "Sotec Afina Eye";
937 type_id = 730;
938 break;
939 default:
940 return -ENODEV;
941 break;
942 }
943 }
944 else if (vendor_id == 0x06be) {
945 switch(product_id) {
946 case 0x8116:
947 /* This is essentially the same cam as the Sotec Afina Eye */
948 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
949 name = "AME Co. Afina Eye";
950 type_id = 750;
951 break;
952 default:
953 return -ENODEV;
954 break;
955 }
956
957 }
958 else if (vendor_id == 0x0d81) {
959 switch(product_id) {
960 case 0x1900:
961 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
962 name = "Visionite VCS-UC300";
963 type_id = 740; /* CCD sensor */
964 break;
965 case 0x1910:
966 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
967 name = "Visionite VCS-UM100";
968 type_id = 730; /* CMOS sensor */
969 break;
970 default:
971 return -ENODEV;
972 break;
973 }
974 }
975 else
976 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
977
978 if (my_power_save == -1)
979 my_power_save = 0;
980
981 memset(serial_number, 0, 30);
982 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
983 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
984
985 if (udev->descriptor.bNumConfigurations > 1)
986 PWC_WARNING("Warning: more than 1 configuration available.\n");
987
988 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
989 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
990 if (pdev == NULL) {
991 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
992 return -ENOMEM;
993 }
994 pdev->type = type_id;
995 pdev->features = features;
996 pwc_construct(pdev); /* set min/max sizes correct */
997
998 mutex_init(&pdev->v4l2_lock);
999 mutex_init(&pdev->vb_queue_lock);
1000 spin_lock_init(&pdev->queued_bufs_lock);
1001 INIT_LIST_HEAD(&pdev->queued_bufs);
1002
1003 pdev->udev = udev;
1004 pdev->power_save = my_power_save;
1005
1006 /* Init videobuf2 queue structure */
1007 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1008 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1009 pdev->vb_queue.drv_priv = pdev;
1010 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1011 pdev->vb_queue.ops = &pwc_vb_queue_ops;
1012 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1013 pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1014 rc = vb2_queue_init(&pdev->vb_queue);
1015 if (rc < 0) {
1016 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1017 goto err_free_mem;
1018 }
1019
1020 /* Init video_device structure */
1021 pdev->vdev = pwc_template;
1022 strcpy(pdev->vdev.name, name);
1023 pdev->vdev.queue = &pdev->vb_queue;
1024 pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1025 video_set_drvdata(&pdev->vdev, pdev);
1026
1027 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1028 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1029
1030 /* Allocate USB command buffers */
1031 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1032 if (!pdev->ctrl_buf) {
1033 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1034 rc = -ENOMEM;
1035 goto err_free_mem;
1036 }
1037
1038 #ifdef CONFIG_USB_PWC_DEBUG
1039 /* Query sensor type */
1040 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1041 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1042 pdev->vdev.name,
1043 pwc_sensor_type_to_string(rc), rc);
1044 }
1045 #endif
1046
1047 /* Set the leds off */
1048 pwc_set_leds(pdev, 0, 0);
1049
1050 /* Setup initial videomode */
1051 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1052 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1053 if (rc)
1054 goto err_free_mem;
1055
1056 /* Register controls (and read default values from camera */
1057 rc = pwc_init_controls(pdev);
1058 if (rc) {
1059 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1060 goto err_free_mem;
1061 }
1062
1063 /* And powerdown the camera until streaming starts */
1064 pwc_camera_power(pdev, 0);
1065
1066 /* Register the v4l2_device structure */
1067 pdev->v4l2_dev.release = pwc_video_release;
1068 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1069 if (rc) {
1070 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1071 goto err_free_controls;
1072 }
1073
1074 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1075 pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1076 pdev->vdev.lock = &pdev->v4l2_lock;
1077
1078 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1079 if (rc < 0) {
1080 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1081 goto err_unregister_v4l2_dev;
1082 }
1083 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1084
1085 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1086 /* register webcam snapshot button input device */
1087 pdev->button_dev = input_allocate_device();
1088 if (!pdev->button_dev) {
1089 rc = -ENOMEM;
1090 goto err_video_unreg;
1091 }
1092
1093 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1094 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1095
1096 pdev->button_dev->name = "PWC snapshot button";
1097 pdev->button_dev->phys = pdev->button_phys;
1098 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1099 pdev->button_dev->dev.parent = &pdev->udev->dev;
1100 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1101 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1102
1103 rc = input_register_device(pdev->button_dev);
1104 if (rc) {
1105 input_free_device(pdev->button_dev);
1106 pdev->button_dev = NULL;
1107 goto err_video_unreg;
1108 }
1109 #endif
1110
1111 return 0;
1112
1113 err_video_unreg:
1114 video_unregister_device(&pdev->vdev);
1115 err_unregister_v4l2_dev:
1116 v4l2_device_unregister(&pdev->v4l2_dev);
1117 err_free_controls:
1118 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1119 err_free_mem:
1120 kfree(pdev->ctrl_buf);
1121 kfree(pdev);
1122 return rc;
1123 }
1124
1125 /* The user yanked out the cable... */
usb_pwc_disconnect(struct usb_interface * intf)1126 static void usb_pwc_disconnect(struct usb_interface *intf)
1127 {
1128 struct v4l2_device *v = usb_get_intfdata(intf);
1129 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1130
1131 mutex_lock(&pdev->vb_queue_lock);
1132 mutex_lock(&pdev->v4l2_lock);
1133 /* No need to keep the urbs around after disconnection */
1134 if (pdev->vb_queue.streaming)
1135 pwc_isoc_cleanup(pdev);
1136 pdev->udev = NULL;
1137
1138 v4l2_device_disconnect(&pdev->v4l2_dev);
1139 video_unregister_device(&pdev->vdev);
1140 mutex_unlock(&pdev->v4l2_lock);
1141 mutex_unlock(&pdev->vb_queue_lock);
1142
1143 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1144 if (pdev->button_dev)
1145 input_unregister_device(pdev->button_dev);
1146 #endif
1147
1148 v4l2_device_put(&pdev->v4l2_dev);
1149 }
1150
1151
1152 /*
1153 * Initialization code & module stuff
1154 */
1155
1156 static unsigned int leds_nargs;
1157
1158 #ifdef CONFIG_USB_PWC_DEBUG
1159 module_param_named(trace, pwc_trace, int, 0644);
1160 #endif
1161 module_param(power_save, int, 0644);
1162 module_param_array(leds, int, &leds_nargs, 0444);
1163
1164 #ifdef CONFIG_USB_PWC_DEBUG
1165 MODULE_PARM_DESC(trace, "For debugging purposes");
1166 #endif
1167 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1168 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1169
1170 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1171 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1172 MODULE_LICENSE("GPL");
1173 MODULE_ALIAS("pwcx");
1174 MODULE_VERSION( PWC_VERSION );
1175
1176 module_usb_driver(pwc_driver);
1177