projects / deliverable / linux.git / blob
? search:


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