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