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