?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'x86-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[cris-mirror.git] / drivers / media / usb / pwc / pwc-if.c
blob54b036d39c5b973eaec5c8be428050023109fdb9
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 const 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
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
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
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); discarded.\n",
242 fbuf->filled);
243 } else {
244 fbuf->vb.field = V4L2_FIELD_NONE;
245 fbuf->vb.sequence = pdev->vframe_count;
246 vb2_buffer_done(&fbuf->vb.vb2_buf, 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 */
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 %ssynchronously.\n",
266 urb, urb->status == -ENOENT ? "" : "a");
267 return;
268 }
269
270 if (pdev->fill_buf == NULL)
271 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
272
273 if (urb->status != 0) {
274 const char *errmsg;
275
276 errmsg = "Unknown";
277 switch(urb->status) {
278 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
279 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
280 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
281 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
282 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
283 case -ETIME: errmsg = "Device does not respond"; break;
284 }
285 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
286 urb->status, errmsg);
287 /* Give up after a number of contiguous errors */
288 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
289 {
290 PWC_ERROR("Too many ISOC errors, bailing out.\n");
291 if (pdev->fill_buf) {
292 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
293 VB2_BUF_STATE_ERROR);
294 pdev->fill_buf = NULL;
295 }
296 }
297 pdev->vsync = 0; /* Drop the current frame */
298 goto handler_end;
299 }
300
301 /* Reset ISOC error counter. We did get here, after all. */
302 pdev->visoc_errors = 0;
303
304 /* vsync: 0 = don't copy data
305 1 = sync-hunt
306 2 = synched
307 */
308 /* Compact data */
309 for (i = 0; i < urb->number_of_packets; i++) {
310 fst = urb->iso_frame_desc[i].status;
311 flen = urb->iso_frame_desc[i].actual_length;
312 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
313 if (fst != 0) {
314 PWC_ERROR("Iso frame %d has error %d\n", i, fst);
315 continue;
316 }
317 if (flen > 0 && pdev->vsync) {
318 struct pwc_frame_buf *fbuf = pdev->fill_buf;
319
320 if (pdev->vsync == 1) {
321 fbuf->vb.vb2_buf.timestamp = ktime_get_ns();
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 */
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_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 enum vb2_buffer_state state)
513 {
514 unsigned long flags = 0;
515
516 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
517 while (!list_empty(&pdev->queued_bufs)) {
518 struct pwc_frame_buf *buf;
519
520 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
521 list);
522 list_del(&buf->list);
523 vb2_buffer_done(&buf->vb.vb2_buf, state);
524 }
525 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
526 }
527
528 #ifdef CONFIG_USB_PWC_DEBUG
529 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
530 {
531 switch(sensor_type) {
532 case 0x00:
533 return "Hyundai CMOS sensor";
534 case 0x20:
535 return "Sony CCD sensor + TDA8787";
536 case 0x2E:
537 return "Sony CCD sensor + Exas 98L59";
538 case 0x2F:
539 return "Sony CCD sensor + ADI 9804";
540 case 0x30:
541 return "Sharp CCD sensor + TDA8787";
542 case 0x3E:
543 return "Sharp CCD sensor + Exas 98L59";
544 case 0x3F:
545 return "Sharp CCD sensor + ADI 9804";
546 case 0x40:
547 return "UPA 1021 sensor";
548 case 0x100:
549 return "VGA sensor";
550 case 0x101:
551 return "PAL MR sensor";
552 default:
553 return "unknown type of sensor";
554 }
555 }
556 #endif
557
558 /***************************************************************************/
559 /* Video4Linux functions */
560
561 static void pwc_video_release(struct v4l2_device *v)
562 {
563 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
564
565 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
566 v4l2_device_unregister(&pdev->v4l2_dev);
567 kfree(pdev->ctrl_buf);
568 kfree(pdev);
569 }
570
571 /***************************************************************************/
572 /* Videobuf2 operations */
573
574 static int queue_setup(struct vb2_queue *vq,
575 unsigned int *nbuffers, unsigned int *nplanes,
576 unsigned int sizes[], struct device *alloc_devs[])
577 {
578 struct pwc_device *pdev = vb2_get_drv_priv(vq);
579 int size;
580
581 if (*nbuffers < MIN_FRAMES)
582 *nbuffers = MIN_FRAMES;
583 else if (*nbuffers > MAX_FRAMES)
584 *nbuffers = MAX_FRAMES;
585
586 *nplanes = 1;
587
588 size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
589 sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
590 pwc_image_sizes[size][1] * 3 / 2);
591
592 return 0;
593 }
594
595 static int buffer_init(struct vb2_buffer *vb)
596 {
597 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
598 struct pwc_frame_buf *buf =
599 container_of(vbuf, struct pwc_frame_buf, vb);
600
601 /* need vmalloc since frame buffer > 128K */
602 buf->data = vzalloc(PWC_FRAME_SIZE);
603 if (buf->data == NULL)
604 return -ENOMEM;
605
606 return 0;
607 }
608
609 static int buffer_prepare(struct vb2_buffer *vb)
610 {
611 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
612
613 /* Don't allow queing new buffers after device disconnection */
614 if (!pdev->udev)
615 return -ENODEV;
616
617 return 0;
618 }
619
620 static void buffer_finish(struct vb2_buffer *vb)
621 {
622 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
623 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
624 struct pwc_frame_buf *buf =
625 container_of(vbuf, struct pwc_frame_buf, vb);
626
627 if (vb->state == VB2_BUF_STATE_DONE) {
628 /*
629 * Application has called dqbuf and is getting back a buffer
630 * we've filled, take the pwc data we've stored in buf->data
631 * and decompress it into a usable format, storing the result
632 * in the vb2_buffer.
633 */
634 pwc_decompress(pdev, buf);
635 }
636 }
637
638 static void buffer_cleanup(struct vb2_buffer *vb)
639 {
640 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
641 struct pwc_frame_buf *buf =
642 container_of(vbuf, struct pwc_frame_buf, vb);
643
644 vfree(buf->data);
645 }
646
647 static void buffer_queue(struct vb2_buffer *vb)
648 {
649 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
650 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
651 struct pwc_frame_buf *buf =
652 container_of(vbuf, struct pwc_frame_buf, vb);
653 unsigned long flags = 0;
654
655 /* Check the device has not disconnected between prep and queuing */
656 if (!pdev->udev) {
657 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
658 return;
659 }
660
661 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
662 list_add_tail(&buf->list, &pdev->queued_bufs);
663 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
664 }
665
666 static int start_streaming(struct vb2_queue *vq, unsigned int count)
667 {
668 struct pwc_device *pdev = vb2_get_drv_priv(vq);
669 int r;
670
671 if (!pdev->udev)
672 return -ENODEV;
673
674 if (mutex_lock_interruptible(&pdev->v4l2_lock))
675 return -ERESTARTSYS;
676 /* Turn on camera and set LEDS on */
677 pwc_camera_power(pdev, 1);
678 pwc_set_leds(pdev, leds[0], leds[1]);
679
680 r = pwc_isoc_init(pdev);
681 if (r) {
682 /* If we failed turn camera and LEDS back off */
683 pwc_set_leds(pdev, 0, 0);
684 pwc_camera_power(pdev, 0);
685 /* And cleanup any queued bufs!! */
686 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED);
687 }
688 mutex_unlock(&pdev->v4l2_lock);
689
690 return r;
691 }
692
693 static void stop_streaming(struct vb2_queue *vq)
694 {
695 struct pwc_device *pdev = vb2_get_drv_priv(vq);
696
697 mutex_lock(&pdev->v4l2_lock);
698 if (pdev->udev) {
699 pwc_set_leds(pdev, 0, 0);
700 pwc_camera_power(pdev, 0);
701 pwc_isoc_cleanup(pdev);
702 }
703
704 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR);
705 if (pdev->fill_buf)
706 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
707 VB2_BUF_STATE_ERROR);
708 mutex_unlock(&pdev->v4l2_lock);
709 }
710
711 static const struct vb2_ops pwc_vb_queue_ops = {
712 .queue_setup = queue_setup,
713 .buf_init = buffer_init,
714 .buf_prepare = buffer_prepare,
715 .buf_finish = buffer_finish,
716 .buf_cleanup = buffer_cleanup,
717 .buf_queue = buffer_queue,
718 .start_streaming = start_streaming,
719 .stop_streaming = stop_streaming,
720 .wait_prepare = vb2_ops_wait_prepare,
721 .wait_finish = vb2_ops_wait_finish,
722 };
723
724 /***************************************************************************/
725 /* USB functions */
726
727 /* This function gets called when a new device is plugged in or the usb core
728 * is loaded.
729 */
730
731 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
732 {
733 struct usb_device *udev = interface_to_usbdev(intf);
734 struct pwc_device *pdev = NULL;
735 int vendor_id, product_id, type_id;
736 int rc;
737 int features = 0;
738 int compression = 0;
739 int my_power_save = power_save;
740 char serial_number[30], *name;
741
742 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
743 product_id = le16_to_cpu(udev->descriptor.idProduct);
744
745 /* Check if we can handle this device */
746 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
747 vendor_id, product_id,
748 intf->altsetting->desc.bInterfaceNumber);
749
750 /* the interfaces are probed one by one. We are only interested in the
751 video interface (0) now.
752 Interface 1 is the Audio Control, and interface 2 Audio itself.
753 */
754 if (intf->altsetting->desc.bInterfaceNumber > 0)
755 return -ENODEV;
756
757 if (vendor_id == 0x0471) {
758 switch (product_id) {
759 case 0x0302:
760 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
761 name = "Philips 645 webcam";
762 type_id = 645;
763 break;
764 case 0x0303:
765 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
766 name = "Philips 646 webcam";
767 type_id = 646;
768 break;
769 case 0x0304:
770 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
771 name = "Askey VC010 webcam";
772 type_id = 646;
773 break;
774 case 0x0307:
775 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
776 name = "Philips 675 webcam";
777 type_id = 675;
778 break;
779 case 0x0308:
780 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
781 name = "Philips 680 webcam";
782 type_id = 680;
783 break;
784 case 0x030C:
785 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
786 name = "Philips 690 webcam";
787 type_id = 690;
788 break;
789 case 0x0310:
790 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
791 name = "Philips 730 webcam";
792 type_id = 730;
793 break;
794 case 0x0311:
795 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
796 name = "Philips 740 webcam";
797 type_id = 740;
798 break;
799 case 0x0312:
800 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
801 name = "Philips 750 webcam";
802 type_id = 750;
803 break;
804 case 0x0313:
805 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
806 name = "Philips 720K/40 webcam";
807 type_id = 720;
808 break;
809 case 0x0329:
810 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
811 name = "Philips SPC 900NC webcam";
812 type_id = 740;
813 break;
814 case 0x032C:
815 PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
816 name = "Philips SPC 880NC webcam";
817 type_id = 740;
818 break;
819 default:
820 return -ENODEV;
821 break;
822 }
823 }
824 else if (vendor_id == 0x069A) {
825 switch(product_id) {
826 case 0x0001:
827 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
828 name = "Askey VC010 webcam";
829 type_id = 645;
830 break;
831 default:
832 return -ENODEV;
833 break;
834 }
835 }
836 else if (vendor_id == 0x046d) {
837 switch(product_id) {
838 case 0x08b0:
839 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
840 name = "Logitech QuickCam Pro 3000";
841 type_id = 740; /* CCD sensor */
842 break;
843 case 0x08b1:
844 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
845 name = "Logitech QuickCam Notebook Pro";
846 type_id = 740; /* CCD sensor */
847 break;
848 case 0x08b2:
849 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
850 name = "Logitech QuickCam Pro 4000";
851 type_id = 740; /* CCD sensor */
852 if (my_power_save == -1)
853 my_power_save = 1;
854 break;
855 case 0x08b3:
856 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
857 name = "Logitech QuickCam Zoom";
858 type_id = 740; /* CCD sensor */
859 break;
860 case 0x08B4:
861 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
862 name = "Logitech QuickCam Zoom";
863 type_id = 740; /* CCD sensor */
864 if (my_power_save == -1)
865 my_power_save = 1;
866 break;
867 case 0x08b5:
868 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
869 name = "Logitech QuickCam Orbit";
870 type_id = 740; /* CCD sensor */
871 if (my_power_save == -1)
872 my_power_save = 1;
873 features |= FEATURE_MOTOR_PANTILT;
874 break;
875 case 0x08b6:
876 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
877 name = "Cisco VT Camera";
878 type_id = 740; /* CCD sensor */
879 break;
880 case 0x08b7:
881 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
882 name = "Logitech ViewPort AV 100";
883 type_id = 740; /* CCD sensor */
884 break;
885 case 0x08b8: /* Where this released? */
886 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
887 name = "Logitech QuickCam (res.)";
888 type_id = 730; /* Assuming CMOS */
889 break;
890 default:
891 return -ENODEV;
892 break;
893 }
894 }
895 else if (vendor_id == 0x055d) {
896 /* I don't know the difference between the C10 and the C30;
897 I suppose the difference is the sensor, but both cameras
898 work equally well with a type_id of 675
899 */
900 switch(product_id) {
901 case 0x9000:
902 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
903 name = "Samsung MPC-C10";
904 type_id = 675;
905 break;
906 case 0x9001:
907 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
908 name = "Samsung MPC-C30";
909 type_id = 675;
910 break;
911 case 0x9002:
912 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
913 name = "Samsung MPC-C30";
914 type_id = 740;
915 break;
916 default:
917 return -ENODEV;
918 break;
919 }
920 }
921 else if (vendor_id == 0x041e) {
922 switch(product_id) {
923 case 0x400c:
924 PWC_INFO("Creative Labs Webcam 5 detected.\n");
925 name = "Creative Labs Webcam 5";
926 type_id = 730;
927 if (my_power_save == -1)
928 my_power_save = 1;
929 break;
930 case 0x4011:
931 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
932 name = "Creative Labs Webcam Pro Ex";
933 type_id = 740;
934 break;
935 default:
936 return -ENODEV;
937 break;
938 }
939 }
940 else if (vendor_id == 0x04cc) {
941 switch(product_id) {
942 case 0x8116:
943 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
944 name = "Sotec Afina Eye";
945 type_id = 730;
946 break;
947 default:
948 return -ENODEV;
949 break;
950 }
951 }
952 else if (vendor_id == 0x06be) {
953 switch(product_id) {
954 case 0x8116:
955 /* This is essentially the same cam as the Sotec Afina Eye */
956 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
957 name = "AME Co. Afina Eye";
958 type_id = 750;
959 break;
960 default:
961 return -ENODEV;
962 break;
963 }
964
965 }
966 else if (vendor_id == 0x0d81) {
967 switch(product_id) {
968 case 0x1900:
969 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
970 name = "Visionite VCS-UC300";
971 type_id = 740; /* CCD sensor */
972 break;
973 case 0x1910:
974 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
975 name = "Visionite VCS-UM100";
976 type_id = 730; /* CMOS sensor */
977 break;
978 default:
979 return -ENODEV;
980 break;
981 }
982 }
983 else
984 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
985
986 if (my_power_save == -1)
987 my_power_save = 0;
988
989 memset(serial_number, 0, 30);
990 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
991 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
992
993 if (udev->descriptor.bNumConfigurations > 1)
994 PWC_WARNING("Warning: more than 1 configuration available.\n");
995
996 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
997 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
998 if (pdev == NULL) {
999 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1000 return -ENOMEM;
1001 }
1002 pdev->type = type_id;
1003 pdev->features = features;
1004 pwc_construct(pdev); /* set min/max sizes correct */
1005
1006 mutex_init(&pdev->v4l2_lock);
1007 mutex_init(&pdev->vb_queue_lock);
1008 spin_lock_init(&pdev->queued_bufs_lock);
1009 INIT_LIST_HEAD(&pdev->queued_bufs);
1010
1011 pdev->udev = udev;
1012 pdev->power_save = my_power_save;
1013
1014 /* Init videobuf2 queue structure */
1015 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1016 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1017 pdev->vb_queue.drv_priv = pdev;
1018 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1019 pdev->vb_queue.ops = &pwc_vb_queue_ops;
1020 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1021 pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1022 rc = vb2_queue_init(&pdev->vb_queue);
1023 if (rc < 0) {
1024 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1025 goto err_free_mem;
1026 }
1027
1028 /* Init video_device structure */
1029 pdev->vdev = pwc_template;
1030 strcpy(pdev->vdev.name, name);
1031 pdev->vdev.queue = &pdev->vb_queue;
1032 pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1033 video_set_drvdata(&pdev->vdev, pdev);
1034
1035 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1036 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1037
1038 /* Allocate USB command buffers */
1039 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1040 if (!pdev->ctrl_buf) {
1041 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1042 rc = -ENOMEM;
1043 goto err_free_mem;
1044 }
1045
1046 #ifdef CONFIG_USB_PWC_DEBUG
1047 /* Query sensor type */
1048 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1049 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1050 pdev->vdev.name,
1051 pwc_sensor_type_to_string(rc), rc);
1052 }
1053 #endif
1054
1055 /* Set the leds off */
1056 pwc_set_leds(pdev, 0, 0);
1057
1058 /* Setup initial videomode */
1059 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1060 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1061 if (rc)
1062 goto err_free_mem;
1063
1064 /* Register controls (and read default values from camera */
1065 rc = pwc_init_controls(pdev);
1066 if (rc) {
1067 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1068 goto err_free_mem;
1069 }
1070
1071 /* And powerdown the camera until streaming starts */
1072 pwc_camera_power(pdev, 0);
1073
1074 /* Register the v4l2_device structure */
1075 pdev->v4l2_dev.release = pwc_video_release;
1076 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1077 if (rc) {
1078 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1079 goto err_free_controls;
1080 }
1081
1082 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1083 pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1084 pdev->vdev.lock = &pdev->v4l2_lock;
1085
1086 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1087 if (rc < 0) {
1088 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1089 goto err_unregister_v4l2_dev;
1090 }
1091 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1092
1093 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1094 /* register webcam snapshot button input device */
1095 pdev->button_dev = input_allocate_device();
1096 if (!pdev->button_dev) {
1097 rc = -ENOMEM;
1098 goto err_video_unreg;
1099 }
1100
1101 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1102 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1103
1104 pdev->button_dev->name = "PWC snapshot button";
1105 pdev->button_dev->phys = pdev->button_phys;
1106 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1107 pdev->button_dev->dev.parent = &pdev->udev->dev;
1108 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1109 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1110
1111 rc = input_register_device(pdev->button_dev);
1112 if (rc) {
1113 input_free_device(pdev->button_dev);
1114 pdev->button_dev = NULL;
1115 goto err_video_unreg;
1116 }
1117 #endif
1118
1119 return 0;
1120
1121 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1122 err_video_unreg:
1123 video_unregister_device(&pdev->vdev);
1124 #endif
1125 err_unregister_v4l2_dev:
1126 v4l2_device_unregister(&pdev->v4l2_dev);
1127 err_free_controls:
1128 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1129 err_free_mem:
1130 kfree(pdev->ctrl_buf);
1131 kfree(pdev);
1132 return rc;
1133 }
1134
1135 /* The user yanked out the cable... */
1136 static void usb_pwc_disconnect(struct usb_interface *intf)
1137 {
1138 struct v4l2_device *v = usb_get_intfdata(intf);
1139 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1140
1141 mutex_lock(&pdev->vb_queue_lock);
1142 mutex_lock(&pdev->v4l2_lock);
1143 /* No need to keep the urbs around after disconnection */
1144 if (pdev->vb_queue.streaming)
1145 pwc_isoc_cleanup(pdev);
1146 pdev->udev = NULL;
1147
1148 v4l2_device_disconnect(&pdev->v4l2_dev);
1149 video_unregister_device(&pdev->vdev);
1150 mutex_unlock(&pdev->v4l2_lock);
1151 mutex_unlock(&pdev->vb_queue_lock);
1152
1153 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1154 if (pdev->button_dev)
1155 input_unregister_device(pdev->button_dev);
1156 #endif
1157
1158 v4l2_device_put(&pdev->v4l2_dev);
1159 }
1160
1161
1162 /*
1163 * Initialization code & module stuff
1164 */
1165
1166 static unsigned int leds_nargs;
1167
1168 #ifdef CONFIG_USB_PWC_DEBUG
1169 module_param_named(trace, pwc_trace, int, 0644);
1170 #endif
1171 module_param(power_save, int, 0644);
1172 module_param_array(leds, int, &leds_nargs, 0444);
1173
1174 #ifdef CONFIG_USB_PWC_DEBUG
1175 MODULE_PARM_DESC(trace, "For debugging purposes");
1176 #endif
1177 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1178 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1179
1180 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1181 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1182 MODULE_LICENSE("GPL");
1183 MODULE_ALIAS("pwcx");
1184 MODULE_VERSION( PWC_VERSION );
1185
1186 module_usb_driver(pwc_driver);
CRIS linux kernel tree