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
49
50
51
52
53
54
55
56
57
58
59#include <linux/errno.h>
60#include <linux/init.h>
61#include <linux/mm.h>
62#include <linux/module.h>
63#include <linux/poll.h>
64#include <linux/slab.h>
65#ifdef CONFIG_USB_PWC_INPUT_EVDEV
66#include <linux/usb/input.h>
67#endif
68#include <linux/vmalloc.h>
69#include <asm/io.h>
70#include <linux/kernel.h>
71
72#include "pwc.h"
73#include "pwc-kiara.h"
74#include "pwc-timon.h"
75#include "pwc-dec23.h"
76#include "pwc-dec1.h"
77#include "pwc-uncompress.h"
78
79
80
81
82static const struct usb_device_id pwc_device_table [] = {
83 { USB_DEVICE(0x0471, 0x0302) },
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) },
91 { USB_DEVICE(0x0471, 0x0312) },
92 { USB_DEVICE(0x0471, 0x0313) },
93 { USB_DEVICE(0x0471, 0x0329) },
94 { USB_DEVICE(0x069A, 0x0001) },
95 { USB_DEVICE(0x046D, 0x08B0) },
96 { USB_DEVICE(0x046D, 0x08B1) },
97 { USB_DEVICE(0x046D, 0x08B2) },
98 { USB_DEVICE(0x046D, 0x08B3) },
99 { USB_DEVICE(0x046D, 0x08B4) },
100 { USB_DEVICE(0x046D, 0x08B5) },
101 { USB_DEVICE(0x046D, 0x08B6) },
102 { USB_DEVICE(0x046D, 0x08B7) },
103 { USB_DEVICE(0x046D, 0x08B8) },
104 { USB_DEVICE(0x055D, 0x9000) },
105 { USB_DEVICE(0x055D, 0x9001) },
106 { USB_DEVICE(0x055D, 0x9002) },
107 { USB_DEVICE(0x041E, 0x400C) },
108 { USB_DEVICE(0x041E, 0x4011) },
109 { USB_DEVICE(0x04CC, 0x8116) },
110 { USB_DEVICE(0x06BE, 0x8116) },
111 { USB_DEVICE(0x0d81, 0x1910) },
112 { USB_DEVICE(0x0d81, 0x1900) },
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);
119
120static struct usb_driver pwc_driver = {
121 .name = "Philips webcam",
122 .id_table = pwc_device_table,
123 .probe = usb_pwc_probe,
124 .disconnect = usb_pwc_disconnect,
125};
126
127#define MAX_DEV_HINTS 20
128#define MAX_ISOC_ERRORS 20
129
130static int default_size = PSZ_QCIF;
131static int default_fps = 10;
132static int default_fbufs = 3;
133 int pwc_mbufs = 2;
134#ifdef CONFIG_USB_PWC_DEBUG
135 int pwc_trace = PWC_DEBUG_LEVEL;
136#endif
137static int power_save;
138static int led_on = 100, led_off;
139static int pwc_preferred_compression = 1;
140static struct {
141 int type;
142 char serial_number[30];
143 int device_node;
144 struct pwc_device *pdev;
145} device_hint[MAX_DEV_HINTS];
146
147
148
149static int pwc_video_open(struct file *file);
150static int pwc_video_close(struct file *file);
151static ssize_t pwc_video_read(struct file *file, char __user *buf,
152 size_t count, loff_t *ppos);
153static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
154static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
155static void pwc_video_release(struct video_device *vfd);
156
157static const struct v4l2_file_operations pwc_fops = {
158 .owner = THIS_MODULE,
159 .open = pwc_video_open,
160 .release = pwc_video_close,
161 .read = pwc_video_read,
162 .poll = pwc_video_poll,
163 .mmap = pwc_video_mmap,
164 .unlocked_ioctl = video_ioctl2,
165};
166static struct video_device pwc_template = {
167 .name = "Philips Webcam",
168 .release = pwc_video_release,
169 .fops = &pwc_fops,
170 .ioctl_ops = &pwc_ioctl_ops,
171};
172
173
174
175
176
177
178
179
180
181
182static void *pwc_rvmalloc(unsigned long size)
183{
184 void * mem;
185 unsigned long adr;
186
187 mem=vmalloc_32(size);
188 if (!mem)
189 return NULL;
190
191 memset(mem, 0, size);
192 adr=(unsigned long) mem;
193 while (size > 0)
194 {
195 SetPageReserved(vmalloc_to_page((void *)adr));
196 adr += PAGE_SIZE;
197 size -= PAGE_SIZE;
198 }
199 return mem;
200}
201
202static void pwc_rvfree(void * mem, unsigned long size)
203{
204 unsigned long adr;
205
206 if (!mem)
207 return;
208
209 adr=(unsigned long) mem;
210 while ((long) size > 0)
211 {
212 ClearPageReserved(vmalloc_to_page((void *)adr));
213 adr += PAGE_SIZE;
214 size -= PAGE_SIZE;
215 }
216 vfree(mem);
217}
218
219
220
221
222static int pwc_allocate_buffers(struct pwc_device *pdev)
223{
224 int i, err;
225 void *kbuf;
226
227 PWC_DEBUG_MEMORY(">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev);
228
229 if (pdev == NULL)
230 return -ENXIO;
231
232
233 for (i = 0; i < MAX_ISO_BUFS; i++) {
234 if (pdev->sbuf[i].data == NULL) {
235 kbuf = kzalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
236 if (kbuf == NULL) {
237 PWC_ERROR("Failed to allocate iso buffer %d.\n", i);
238 return -ENOMEM;
239 }
240 PWC_DEBUG_MEMORY("Allocated iso buffer at %p.\n", kbuf);
241 pdev->sbuf[i].data = kbuf;
242 }
243 }
244
245
246 if (pdev->fbuf == NULL) {
247 kbuf = kzalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);
248 if (kbuf == NULL) {
249 PWC_ERROR("Failed to allocate frame buffer structure.\n");
250 return -ENOMEM;
251 }
252 PWC_DEBUG_MEMORY("Allocated frame buffer structure at %p.\n", kbuf);
253 pdev->fbuf = kbuf;
254 }
255
256
257 for (i = 0; i < default_fbufs; i++) {
258 if (pdev->fbuf[i].data == NULL) {
259 kbuf = vzalloc(PWC_FRAME_SIZE);
260 if (kbuf == NULL) {
261 PWC_ERROR("Failed to allocate frame buffer %d.\n", i);
262 return -ENOMEM;
263 }
264 PWC_DEBUG_MEMORY("Allocated frame buffer %d at %p.\n", i, kbuf);
265 pdev->fbuf[i].data = kbuf;
266 }
267 }
268
269
270 if (DEVICE_USE_CODEC1(pdev->type))
271 err = pwc_dec1_alloc(pdev);
272 else
273 err = pwc_dec23_alloc(pdev);
274
275 if (err) {
276 PWC_ERROR("Failed to allocate decompress table.\n");
277 return err;
278 }
279
280
281 kbuf = pwc_rvmalloc(pwc_mbufs * pdev->len_per_image);
282 if (kbuf == NULL) {
283 PWC_ERROR("Failed to allocate image buffer(s). needed (%d)\n",
284 pwc_mbufs * pdev->len_per_image);
285 return -ENOMEM;
286 }
287 PWC_DEBUG_MEMORY("Allocated image buffer at %p.\n", kbuf);
288 pdev->image_data = kbuf;
289 for (i = 0; i < pwc_mbufs; i++) {
290 pdev->images[i].offset = i * pdev->len_per_image;
291 pdev->images[i].vma_use_count = 0;
292 }
293 for (; i < MAX_IMAGES; i++) {
294 pdev->images[i].offset = 0;
295 }
296
297 kbuf = NULL;
298
299 PWC_DEBUG_MEMORY("<< pwc_allocate_buffers()\n");
300 return 0;
301}
302
303static void pwc_free_buffers(struct pwc_device *pdev)
304{
305 int i;
306
307 PWC_DEBUG_MEMORY("Entering free_buffers(%p).\n", pdev);
308
309 if (pdev == NULL)
310 return;
311
312 for (i = 0; i < MAX_ISO_BUFS; i++)
313 if (pdev->sbuf[i].data != NULL) {
314 PWC_DEBUG_MEMORY("Freeing ISO buffer at %p.\n", pdev->sbuf[i].data);
315 kfree(pdev->sbuf[i].data);
316 pdev->sbuf[i].data = NULL;
317 }
318
319
320 if (pdev->fbuf != NULL) {
321 for (i = 0; i < default_fbufs; i++) {
322 if (pdev->fbuf[i].data != NULL) {
323 PWC_DEBUG_MEMORY("Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data);
324 vfree(pdev->fbuf[i].data);
325 pdev->fbuf[i].data = NULL;
326 }
327 }
328 kfree(pdev->fbuf);
329 pdev->fbuf = NULL;
330 }
331
332
333 if (pdev->decompress_data != NULL) {
334 PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n", pdev->decompress_data);
335 kfree(pdev->decompress_data);
336 pdev->decompress_data = NULL;
337 }
338
339
340 if (pdev->image_data != NULL) {
341 PWC_DEBUG_MEMORY("Freeing image buffer at %p.\n", pdev->image_data);
342 pwc_rvfree(pdev->image_data, pwc_mbufs * pdev->len_per_image);
343 }
344 pdev->image_data = NULL;
345
346 PWC_DEBUG_MEMORY("Leaving free_buffers().\n");
347}
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406static int pwc_next_fill_frame(struct pwc_device *pdev)
407{
408 int ret;
409 unsigned long flags;
410
411 ret = 0;
412 spin_lock_irqsave(&pdev->ptrlock, flags);
413 if (pdev->fill_frame != NULL) {
414
415 if (pdev->full_frames == NULL) {
416 pdev->full_frames = pdev->fill_frame;
417 pdev->full_frames_tail = pdev->full_frames;
418 }
419 else {
420 pdev->full_frames_tail->next = pdev->fill_frame;
421 pdev->full_frames_tail = pdev->fill_frame;
422 }
423 }
424 if (pdev->empty_frames != NULL) {
425
426 pdev->fill_frame = pdev->empty_frames;
427 pdev->empty_frames = pdev->empty_frames->next;
428 }
429 else {
430
431
432 if (pdev->full_frames == NULL) {
433 PWC_ERROR("Neither empty or full frames available!\n");
434 spin_unlock_irqrestore(&pdev->ptrlock, flags);
435 return -EINVAL;
436 }
437 pdev->fill_frame = pdev->full_frames;
438 pdev->full_frames = pdev->full_frames->next;
439 ret = 1;
440 }
441 pdev->fill_frame->next = NULL;
442 spin_unlock_irqrestore(&pdev->ptrlock, flags);
443 return ret;
444}
445
446
447
448
449
450
451
452static void pwc_reset_buffers(struct pwc_device *pdev)
453{
454 int i;
455 unsigned long flags;
456
457 PWC_DEBUG_MEMORY(">> %s __enter__\n", __func__);
458
459 spin_lock_irqsave(&pdev->ptrlock, flags);
460 pdev->full_frames = NULL;
461 pdev->full_frames_tail = NULL;
462 for (i = 0; i < default_fbufs; i++) {
463 pdev->fbuf[i].filled = 0;
464 if (i > 0)
465 pdev->fbuf[i].next = &pdev->fbuf[i - 1];
466 else
467 pdev->fbuf->next = NULL;
468 }
469 pdev->empty_frames = &pdev->fbuf[default_fbufs - 1];
470 pdev->empty_frames_tail = pdev->fbuf;
471 pdev->read_frame = NULL;
472 pdev->fill_frame = pdev->empty_frames;
473 pdev->empty_frames = pdev->empty_frames->next;
474
475 pdev->image_read_pos = 0;
476 pdev->fill_image = 0;
477 spin_unlock_irqrestore(&pdev->ptrlock, flags);
478
479 PWC_DEBUG_MEMORY("<< %s __leaving__\n", __func__);
480}
481
482
483
484
485
486int pwc_handle_frame(struct pwc_device *pdev)
487{
488 int ret = 0;
489 unsigned long flags;
490
491 spin_lock_irqsave(&pdev->ptrlock, flags);
492
493
494 if (pdev->read_frame != NULL) {
495
496 PWC_ERROR("Huh? Read frame still in use?\n");
497 spin_unlock_irqrestore(&pdev->ptrlock, flags);
498 return ret;
499 }
500
501
502 if (pdev->full_frames == NULL) {
503 PWC_ERROR("Woops. No frames ready.\n");
504 }
505 else {
506 pdev->read_frame = pdev->full_frames;
507 pdev->full_frames = pdev->full_frames->next;
508 pdev->read_frame->next = NULL;
509 }
510
511 if (pdev->read_frame != NULL) {
512
513
514
515
516 spin_unlock_irqrestore(&pdev->ptrlock, flags);
517 ret = pwc_decompress(pdev);
518 spin_lock_irqsave(&pdev->ptrlock, flags);
519
520
521 if (pdev->empty_frames == NULL) {
522 pdev->empty_frames = pdev->read_frame;
523 pdev->empty_frames_tail = pdev->empty_frames;
524 }
525 else {
526 pdev->empty_frames_tail->next = pdev->read_frame;
527 pdev->empty_frames_tail = pdev->read_frame;
528 }
529 pdev->read_frame = NULL;
530 }
531 spin_unlock_irqrestore(&pdev->ptrlock, flags);
532 return ret;
533}
534
535
536
537
538void pwc_next_image(struct pwc_device *pdev)
539{
540 pdev->image_used[pdev->fill_image] = 0;
541 pdev->fill_image = (pdev->fill_image + 1) % pwc_mbufs;
542}
543
544
545
546
547
548static void pwc_frame_dumped(struct pwc_device *pdev)
549{
550 pdev->vframes_dumped++;
551 if (pdev->vframe_count < FRAME_LOWMARK)
552 return;
553
554 if (pdev->vframes_dumped < 20)
555 PWC_DEBUG_FLOW("Dumping frame %d\n", pdev->vframe_count);
556 else if (pdev->vframes_dumped == 20)
557 PWC_DEBUG_FLOW("Dumping frame %d (last message)\n",
558 pdev->vframe_count);
559}
560
561static void pwc_snapshot_button(struct pwc_device *pdev, int down)
562{
563 if (down) {
564 PWC_TRACE("Snapshot button pressed.\n");
565 pdev->snapshot_button_status = 1;
566 } else {
567 PWC_TRACE("Snapshot button released.\n");
568 }
569
570#ifdef CONFIG_USB_PWC_INPUT_EVDEV
571 if (pdev->button_dev) {
572 input_report_key(pdev->button_dev, KEY_CAMERA, down);
573 input_sync(pdev->button_dev);
574 }
575#endif
576}
577
578static int pwc_rcv_short_packet(struct pwc_device *pdev, const struct pwc_frame_buf *fbuf)
579{
580 int awake = 0;
581
582
583
584
585
586 if (pdev->type == 730) {
587 unsigned char *ptr = (unsigned char *)fbuf->data;
588
589 if (ptr[1] == 1 && ptr[0] & 0x10) {
590 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
591 pdev->drop_frames += 2;
592 pdev->vframes_error++;
593 }
594 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
595 pwc_snapshot_button(pdev, ptr[0] & 0x01);
596 }
597 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
598 if (ptr[0] & 0x02)
599 PWC_TRACE("Image is mirrored.\n");
600 else
601 PWC_TRACE("Image is normal.\n");
602 }
603 pdev->vmirror = ptr[0] & 0x03;
604
605
606
607
608
609
610
611
612
613 if (fbuf->filled == 4)
614 pdev->drop_frames++;
615 }
616 else if (pdev->type == 740 || pdev->type == 720) {
617 unsigned char *ptr = (unsigned char *)fbuf->data;
618 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
619 pwc_snapshot_button(pdev, ptr[0] & 0x01);
620 }
621 pdev->vmirror = ptr[0] & 0x03;
622 }
623
624
625
626
627 if (pdev->drop_frames > 0)
628 pdev->drop_frames--;
629 else {
630
631 if (fbuf->filled < pdev->frame_total_size) {
632 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
633 " discarded.\n", fbuf->filled);
634 pdev->vframes_error++;
635 }
636 else {
637
638 awake = 1;
639
640
641
642
643
644 if (pwc_next_fill_frame(pdev))
645 pwc_frame_dumped(pdev);
646
647 }
648 }
649 pdev->vframe_count++;
650 return awake;
651}
652
653
654
655
656static void pwc_isoc_handler(struct urb *urb)
657{
658 struct pwc_device *pdev;
659 int i, fst, flen;
660 int awake;
661 struct pwc_frame_buf *fbuf;
662 unsigned char *fillptr = NULL, *iso_buf = NULL;
663
664 awake = 0;
665 pdev = (struct pwc_device *)urb->context;
666 if (pdev == NULL) {
667 PWC_ERROR("isoc_handler() called with NULL device?!\n");
668 return;
669 }
670
671 if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
672 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
673 return;
674 }
675 if (urb->status != -EINPROGRESS && urb->status != 0) {
676 const char *errmsg;
677
678 errmsg = "Unknown";
679 switch(urb->status) {
680 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
681 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
682 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
683 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
684 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
685 case -ETIME: errmsg = "Device does not respond"; break;
686 }
687 PWC_DEBUG_FLOW("pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
688
689
690
691 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
692 {
693 PWC_INFO("Too many ISOC errors, bailing out.\n");
694 pdev->error_status = EIO;
695 awake = 1;
696 wake_up_interruptible(&pdev->frameq);
697 }
698 goto handler_end;
699 }
700
701 fbuf = pdev->fill_frame;
702 if (fbuf == NULL) {
703 PWC_ERROR("pwc_isoc_handler without valid fill frame.\n");
704 awake = 1;
705 goto handler_end;
706 }
707 else {
708 fillptr = fbuf->data + fbuf->filled;
709 }
710
711
712 pdev->visoc_errors = 0;
713
714
715
716
717
718
719 for (i = 0; i < urb->number_of_packets; i++) {
720 fst = urb->iso_frame_desc[i].status;
721 flen = urb->iso_frame_desc[i].actual_length;
722 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
723 if (fst == 0) {
724 if (flen > 0) {
725 if (pdev->vsync > 0) {
726 pdev->vsync = 2;
727
728
729 if (flen + fbuf->filled > pdev->frame_total_size) {
730 PWC_DEBUG_FLOW("Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen, pdev->frame_total_size);
731 pdev->vsync = 0;
732 pdev->vframes_error++;
733 }
734 else {
735 memmove(fillptr, iso_buf, flen);
736 fillptr += flen;
737 }
738 }
739 fbuf->filled += flen;
740 }
741
742 if (flen < pdev->vlast_packet_size) {
743
744
745
746
747 if (pdev->vsync == 2) {
748 if (pwc_rcv_short_packet(pdev, fbuf)) {
749 awake = 1;
750 fbuf = pdev->fill_frame;
751 }
752 }
753 fbuf->filled = 0;
754 fillptr = fbuf->data;
755 pdev->vsync = 1;
756 }
757
758 pdev->vlast_packet_size = flen;
759 }
760 else {
761
762
763 static int iso_error;
764 iso_error++;
765 if (iso_error < 20)
766 PWC_DEBUG_FLOW("Iso frame %d of USB has error %d\n", i, fst);
767 }
768 }
769
770handler_end:
771 if (awake)
772 wake_up_interruptible(&pdev->frameq);
773
774 urb->dev = pdev->udev;
775 i = usb_submit_urb(urb, GFP_ATOMIC);
776 if (i != 0)
777 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
778}
779
780
781int pwc_isoc_init(struct pwc_device *pdev)
782{
783 struct usb_device *udev;
784 struct urb *urb;
785 int i, j, ret;
786
787 struct usb_interface *intf;
788 struct usb_host_interface *idesc = NULL;
789
790 if (pdev == NULL)
791 return -EFAULT;
792 if (pdev->iso_init)
793 return 0;
794 pdev->vsync = 0;
795 udev = pdev->udev;
796
797
798 if (!udev->actconfig)
799 return -EFAULT;
800 intf = usb_ifnum_to_if(udev, 0);
801 if (intf)
802 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
803
804 if (!idesc)
805 return -EFAULT;
806
807
808 pdev->vmax_packet_size = -1;
809 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
810 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
811 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
812 break;
813 }
814 }
815
816 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
817 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
818 return -ENFILE;
819 }
820
821
822 ret = 0;
823 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
824 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
825 if (ret < 0)
826 return ret;
827
828 for (i = 0; i < MAX_ISO_BUFS; i++) {
829 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
830 if (urb == NULL) {
831 PWC_ERROR("Failed to allocate urb %d\n", i);
832 ret = -ENOMEM;
833 break;
834 }
835 pdev->sbuf[i].urb = urb;
836 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
837 }
838 if (ret) {
839
840 while (i--) {
841 usb_free_urb(pdev->sbuf[i].urb);
842 pdev->sbuf[i].urb = NULL;
843 }
844 return ret;
845 }
846
847
848 for (i = 0; i < MAX_ISO_BUFS; i++) {
849 urb = pdev->sbuf[i].urb;
850
851 urb->interval = 1;
852 urb->dev = udev;
853 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
854 urb->transfer_flags = URB_ISO_ASAP;
855 urb->transfer_buffer = pdev->sbuf[i].data;
856 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
857 urb->complete = pwc_isoc_handler;
858 urb->context = pdev;
859 urb->start_frame = 0;
860 urb->number_of_packets = ISO_FRAMES_PER_DESC;
861 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
862 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
863 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
864 }
865 }
866
867
868 for (i = 0; i < MAX_ISO_BUFS; i++) {
869 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL);
870 if (ret) {
871 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
872 pdev->iso_init = 1;
873 pwc_isoc_cleanup(pdev);
874 return ret;
875 }
876 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->sbuf[i].urb);
877 }
878
879
880 pdev->iso_init = 1;
881 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
882 return 0;
883}
884
885static void pwc_iso_stop(struct pwc_device *pdev)
886{
887 int i;
888
889
890 for (i = 0; i < MAX_ISO_BUFS; i++) {
891 struct urb *urb;
892
893 urb = pdev->sbuf[i].urb;
894 if (urb) {
895 PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb);
896 usb_kill_urb(urb);
897 }
898 }
899}
900
901static void pwc_iso_free(struct pwc_device *pdev)
902{
903 int i;
904
905
906 for (i = 0; i < MAX_ISO_BUFS; i++) {
907 struct urb *urb;
908
909 urb = pdev->sbuf[i].urb;
910 if (urb) {
911 PWC_DEBUG_MEMORY("Freeing URB\n");
912 usb_free_urb(urb);
913 pdev->sbuf[i].urb = NULL;
914 }
915 }
916}
917
918void pwc_isoc_cleanup(struct pwc_device *pdev)
919{
920 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
921 if (pdev == NULL)
922 return;
923 if (pdev->iso_init == 0)
924 return;
925
926 pwc_iso_stop(pdev);
927 pwc_iso_free(pdev);
928
929
930
931
932 if (pdev->error_status != EPIPE) {
933 PWC_DEBUG_OPEN("Setting alternate interface 0.\n");
934 usb_set_interface(pdev->udev, 0, 0);
935 }
936
937 pdev->iso_init = 0;
938 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
939}
940
941
942
943
944static struct pwc_device *cd_to_pwc(struct device *cd)
945{
946 struct video_device *vdev = to_video_device(cd);
947 return video_get_drvdata(vdev);
948}
949
950static ssize_t show_pan_tilt(struct device *class_dev,
951 struct device_attribute *attr, char *buf)
952{
953 struct pwc_device *pdev = cd_to_pwc(class_dev);
954 return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
955}
956
957static ssize_t store_pan_tilt(struct device *class_dev,
958 struct device_attribute *attr,
959 const char *buf, size_t count)
960{
961 struct pwc_device *pdev = cd_to_pwc(class_dev);
962 int pan, tilt;
963 int ret = -EINVAL;
964
965 if (strncmp(buf, "reset", 5) == 0)
966 ret = pwc_mpt_reset(pdev, 0x3);
967
968 else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
969 ret = pwc_mpt_set_angle(pdev, pan, tilt);
970
971 if (ret < 0)
972 return ret;
973 return strlen(buf);
974}
975static DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
976 store_pan_tilt);
977
978static ssize_t show_snapshot_button_status(struct device *class_dev,
979 struct device_attribute *attr, char *buf)
980{
981 struct pwc_device *pdev = cd_to_pwc(class_dev);
982 int status = pdev->snapshot_button_status;
983 pdev->snapshot_button_status = 0;
984 return sprintf(buf, "%d\n", status);
985}
986
987static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
988 NULL);
989
990static int pwc_create_sysfs_files(struct pwc_device *pdev)
991{
992 int rc;
993
994 rc = device_create_file(&pdev->vdev.dev, &dev_attr_button);
995 if (rc)
996 goto err;
997 if (pdev->features & FEATURE_MOTOR_PANTILT) {
998 rc = device_create_file(&pdev->vdev.dev, &dev_attr_pan_tilt);
999 if (rc)
1000 goto err_button;
1001 }
1002
1003 return 0;
1004
1005err_button:
1006 device_remove_file(&pdev->vdev.dev, &dev_attr_button);
1007err:
1008 PWC_ERROR("Could not create sysfs files.\n");
1009 return rc;
1010}
1011
1012static void pwc_remove_sysfs_files(struct pwc_device *pdev)
1013{
1014 if (pdev->features & FEATURE_MOTOR_PANTILT)
1015 device_remove_file(&pdev->vdev.dev, &dev_attr_pan_tilt);
1016 device_remove_file(&pdev->vdev.dev, &dev_attr_button);
1017}
1018
1019#ifdef CONFIG_USB_PWC_DEBUG
1020static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
1021{
1022 switch(sensor_type) {
1023 case 0x00:
1024 return "Hyundai CMOS sensor";
1025 case 0x20:
1026 return "Sony CCD sensor + TDA8787";
1027 case 0x2E:
1028 return "Sony CCD sensor + Exas 98L59";
1029 case 0x2F:
1030 return "Sony CCD sensor + ADI 9804";
1031 case 0x30:
1032 return "Sharp CCD sensor + TDA8787";
1033 case 0x3E:
1034 return "Sharp CCD sensor + Exas 98L59";
1035 case 0x3F:
1036 return "Sharp CCD sensor + ADI 9804";
1037 case 0x40:
1038 return "UPA 1021 sensor";
1039 case 0x100:
1040 return "VGA sensor";
1041 case 0x101:
1042 return "PAL MR sensor";
1043 default:
1044 return "unknown type of sensor";
1045 }
1046}
1047#endif
1048
1049
1050
1051
1052static int pwc_video_open(struct file *file)
1053{
1054 int i, ret;
1055 struct video_device *vdev = video_devdata(file);
1056 struct pwc_device *pdev;
1057
1058 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
1059
1060 pdev = video_get_drvdata(vdev);
1061 BUG_ON(!pdev);
1062 if (pdev->vopen) {
1063 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1064 return -EBUSY;
1065 }
1066
1067 pwc_construct(pdev);
1068 if (!pdev->usb_init) {
1069 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1070 pdev->usb_init = 1;
1071
1072
1073 ret = pwc_get_cmos_sensor(pdev, &i);
1074 if (ret >= 0)
1075 {
1076 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1077 pdev->vdev.name,
1078 pwc_sensor_type_to_string(i), i);
1079 }
1080 }
1081
1082
1083 if (power_save) {
1084 i = pwc_camera_power(pdev, 1);
1085 if (i < 0)
1086 PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
1087 }
1088
1089 if (pwc_set_leds(pdev, led_on, led_off) < 0)
1090 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1091
1092
1093
1094 i = pwc_allocate_buffers(pdev);
1095 if (i < 0) {
1096 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1097 pwc_free_buffers(pdev);
1098 return i;
1099 }
1100
1101
1102 pwc_reset_buffers(pdev);
1103 for (i = 0; i < pwc_mbufs; i++)
1104 pdev->image_used[i] = 0;
1105 pdev->vframe_count = 0;
1106 pdev->vframes_dumped = 0;
1107 pdev->vframes_error = 0;
1108 pdev->visoc_errors = 0;
1109 pdev->error_status = 0;
1110 pwc_construct(pdev);
1111
1112
1113 pdev->vsnapshot = 0;
1114
1115
1116
1117
1118
1119 i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1120 if (i) {
1121 unsigned int default_resolution;
1122 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1123 if (pdev->type>= 730)
1124 default_resolution = PSZ_QSIF;
1125 else
1126 default_resolution = PSZ_QCIF;
1127
1128 i = pwc_set_video_mode(pdev,
1129 pwc_image_sizes[default_resolution].x,
1130 pwc_image_sizes[default_resolution].y,
1131 10,
1132 pdev->vcompression,
1133 0);
1134 }
1135 if (i) {
1136 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1137 pwc_free_buffers(pdev);
1138 return i;
1139 }
1140
1141
1142 pwc_set_brightness(pdev, 0x7fff);
1143 pwc_set_agc(pdev, 1, 0);
1144
1145 pdev->vopen++;
1146 file->private_data = vdev;
1147 PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1148 return 0;
1149}
1150
1151static void pwc_video_release(struct video_device *vfd)
1152{
1153 struct pwc_device *pdev = container_of(vfd, struct pwc_device, vdev);
1154 int hint;
1155
1156
1157 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1158 if (device_hint[hint].pdev == pdev)
1159 device_hint[hint].pdev = NULL;
1160
1161 kfree(pdev);
1162}
1163
1164
1165static int pwc_video_close(struct file *file)
1166{
1167 struct video_device *vdev = file->private_data;
1168 struct pwc_device *pdev;
1169 int i;
1170
1171 PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
1172
1173 pdev = video_get_drvdata(vdev);
1174 if (pdev->vopen == 0)
1175 PWC_DEBUG_MODULE("video_close() called on closed device?\n");
1176
1177
1178
1179
1180
1181 if (pdev->vframe_count > 20)
1182 PWC_DEBUG_MODULE("Closing video device: %d frames received, dumped %d frames, %d frames with errors.\n", pdev->vframe_count, pdev->vframes_dumped, pdev->vframes_error);
1183
1184 if (DEVICE_USE_CODEC1(pdev->type))
1185 pwc_dec1_exit();
1186 else
1187 pwc_dec23_exit();
1188
1189 pwc_isoc_cleanup(pdev);
1190 pwc_free_buffers(pdev);
1191
1192
1193 if (!pdev->unplugged) {
1194
1195 if (pwc_set_leds(pdev, 0, 0) < 0)
1196 PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
1197 if (power_save) {
1198 i = pwc_camera_power(pdev, 0);
1199 if (i < 0)
1200 PWC_ERROR("Failed to power down camera (%d)\n", i);
1201 }
1202 pdev->vopen--;
1203 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
1204 }
1205
1206 return 0;
1207}
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221static ssize_t pwc_video_read(struct file *file, char __user *buf,
1222 size_t count, loff_t *ppos)
1223{
1224 struct video_device *vdev = file->private_data;
1225 struct pwc_device *pdev;
1226 int noblock = file->f_flags & O_NONBLOCK;
1227 DECLARE_WAITQUEUE(wait, current);
1228 int bytes_to_read, rv = 0;
1229 void *image_buffer_addr;
1230
1231 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1232 vdev, buf, count);
1233 if (vdev == NULL)
1234 return -EFAULT;
1235 pdev = video_get_drvdata(vdev);
1236 if (pdev == NULL)
1237 return -EFAULT;
1238
1239 if (pdev->error_status) {
1240 rv = -pdev->error_status;
1241 goto err_out;
1242 }
1243
1244
1245 rv = pwc_isoc_init(pdev);
1246 if (rv)
1247 goto err_out;
1248
1249
1250 if (pdev->image_read_pos == 0) {
1251
1252 add_wait_queue(&pdev->frameq, &wait);
1253 while (pdev->full_frames == NULL) {
1254
1255 if (pdev->error_status) {
1256 remove_wait_queue(&pdev->frameq, &wait);
1257 set_current_state(TASK_RUNNING);
1258 rv = -pdev->error_status ;
1259 goto err_out;
1260 }
1261 if (noblock) {
1262 remove_wait_queue(&pdev->frameq, &wait);
1263 set_current_state(TASK_RUNNING);
1264 rv = -EWOULDBLOCK;
1265 goto err_out;
1266 }
1267 if (signal_pending(current)) {
1268 remove_wait_queue(&pdev->frameq, &wait);
1269 set_current_state(TASK_RUNNING);
1270 rv = -ERESTARTSYS;
1271 goto err_out;
1272 }
1273 mutex_unlock(&pdev->modlock);
1274 schedule();
1275 set_current_state(TASK_INTERRUPTIBLE);
1276 mutex_lock(&pdev->modlock);
1277 }
1278 remove_wait_queue(&pdev->frameq, &wait);
1279 set_current_state(TASK_RUNNING);
1280
1281
1282 if (pwc_handle_frame(pdev)) {
1283 rv = -EFAULT;
1284 goto err_out;
1285 }
1286 }
1287
1288 PWC_DEBUG_READ("Copying data to user space.\n");
1289 if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
1290 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1291 else
1292 bytes_to_read = pdev->view.size;
1293
1294
1295 if (count + pdev->image_read_pos > bytes_to_read)
1296 count = bytes_to_read - pdev->image_read_pos;
1297 image_buffer_addr = pdev->image_data;
1298 image_buffer_addr += pdev->images[pdev->fill_image].offset;
1299 image_buffer_addr += pdev->image_read_pos;
1300 if (copy_to_user(buf, image_buffer_addr, count)) {
1301 rv = -EFAULT;
1302 goto err_out;
1303 }
1304 pdev->image_read_pos += count;
1305 if (pdev->image_read_pos >= bytes_to_read) {
1306 pdev->image_read_pos = 0;
1307 pwc_next_image(pdev);
1308 }
1309 return count;
1310err_out:
1311 return rv;
1312}
1313
1314static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1315{
1316 struct video_device *vdev = file->private_data;
1317 struct pwc_device *pdev;
1318 int ret;
1319
1320 if (vdev == NULL)
1321 return -EFAULT;
1322 pdev = video_get_drvdata(vdev);
1323 if (pdev == NULL)
1324 return -EFAULT;
1325
1326
1327 ret = pwc_isoc_init(pdev);
1328 if (ret)
1329 return ret;
1330
1331 poll_wait(file, &pdev->frameq, wait);
1332 if (pdev->error_status)
1333 return POLLERR;
1334 if (pdev->full_frames != NULL)
1335 return (POLLIN | POLLRDNORM);
1336
1337 return 0;
1338}
1339
1340static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1341{
1342 struct video_device *vdev = file->private_data;
1343 struct pwc_device *pdev;
1344 unsigned long start;
1345 unsigned long size;
1346 unsigned long page, pos = 0;
1347 int index;
1348
1349 PWC_DEBUG_MEMORY(">> %s\n", __func__);
1350 pdev = video_get_drvdata(vdev);
1351 size = vma->vm_end - vma->vm_start;
1352 start = vma->vm_start;
1353
1354
1355 for (index = 0; index < pwc_mbufs; index++) {
1356 pos = pdev->images[index].offset;
1357 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1358 break;
1359 }
1360 if (index == MAX_IMAGES)
1361 return -EINVAL;
1362 if (index == 0) {
1363
1364
1365
1366
1367 unsigned long total_size;
1368 total_size = pwc_mbufs * pdev->len_per_image;
1369 if (size != pdev->len_per_image && size != total_size) {
1370 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1371 size, pdev->len_per_image, total_size);
1372 return -EINVAL;
1373 }
1374 } else if (size > pdev->len_per_image)
1375 return -EINVAL;
1376
1377 vma->vm_flags |= VM_IO;
1378
1379 pos += (unsigned long)pdev->image_data;
1380 while (size > 0) {
1381 page = vmalloc_to_pfn((void *)pos);
1382 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1383 return -EAGAIN;
1384 start += PAGE_SIZE;
1385 pos += PAGE_SIZE;
1386 if (size > PAGE_SIZE)
1387 size -= PAGE_SIZE;
1388 else
1389 size = 0;
1390 }
1391 return 0;
1392}
1393
1394
1395
1396
1397
1398
1399
1400
1401static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1402{
1403 struct usb_device *udev = interface_to_usbdev(intf);
1404 struct pwc_device *pdev = NULL;
1405 int vendor_id, product_id, type_id;
1406 int hint, rc;
1407 int features = 0;
1408 int video_nr = -1;
1409 char serial_number[30], *name;
1410
1411 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1412 product_id = le16_to_cpu(udev->descriptor.idProduct);
1413
1414
1415 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1416 vendor_id, product_id,
1417 intf->altsetting->desc.bInterfaceNumber);
1418
1419
1420
1421
1422
1423 if (intf->altsetting->desc.bInterfaceNumber > 0)
1424 return -ENODEV;
1425
1426 if (vendor_id == 0x0471) {
1427 switch (product_id) {
1428 case 0x0302:
1429 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1430 name = "Philips 645 webcam";
1431 type_id = 645;
1432 break;
1433 case 0x0303:
1434 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1435 name = "Philips 646 webcam";
1436 type_id = 646;
1437 break;
1438 case 0x0304:
1439 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1440 name = "Askey VC010 webcam";
1441 type_id = 646;
1442 break;
1443 case 0x0307:
1444 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1445 name = "Philips 675 webcam";
1446 type_id = 675;
1447 break;
1448 case 0x0308:
1449 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1450 name = "Philips 680 webcam";
1451 type_id = 680;
1452 break;
1453 case 0x030C:
1454 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1455 name = "Philips 690 webcam";
1456 type_id = 690;
1457 break;
1458 case 0x0310:
1459 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1460 name = "Philips 730 webcam";
1461 type_id = 730;
1462 break;
1463 case 0x0311:
1464 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1465 name = "Philips 740 webcam";
1466 type_id = 740;
1467 break;
1468 case 0x0312:
1469 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1470 name = "Philips 750 webcam";
1471 type_id = 750;
1472 break;
1473 case 0x0313:
1474 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1475 name = "Philips 720K/40 webcam";
1476 type_id = 720;
1477 break;
1478 case 0x0329:
1479 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1480 name = "Philips SPC 900NC webcam";
1481 type_id = 740;
1482 break;
1483 default:
1484 return -ENODEV;
1485 break;
1486 }
1487 }
1488 else if (vendor_id == 0x069A) {
1489 switch(product_id) {
1490 case 0x0001:
1491 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1492 name = "Askey VC010 webcam";
1493 type_id = 645;
1494 break;
1495 default:
1496 return -ENODEV;
1497 break;
1498 }
1499 }
1500 else if (vendor_id == 0x046d) {
1501 switch(product_id) {
1502 case 0x08b0:
1503 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1504 name = "Logitech QuickCam Pro 3000";
1505 type_id = 740;
1506 break;
1507 case 0x08b1:
1508 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1509 name = "Logitech QuickCam Notebook Pro";
1510 type_id = 740;
1511 break;
1512 case 0x08b2:
1513 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1514 name = "Logitech QuickCam Pro 4000";
1515 type_id = 740;
1516 break;
1517 case 0x08b3:
1518 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1519 name = "Logitech QuickCam Zoom";
1520 type_id = 740;
1521 break;
1522 case 0x08B4:
1523 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1524 name = "Logitech QuickCam Zoom";
1525 type_id = 740;
1526 power_save = 1;
1527 break;
1528 case 0x08b5:
1529 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1530 name = "Logitech QuickCam Orbit";
1531 type_id = 740;
1532 features |= FEATURE_MOTOR_PANTILT;
1533 break;
1534 case 0x08b6:
1535 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1536 name = "Cisco VT Camera";
1537 type_id = 740;
1538 break;
1539 case 0x08b7:
1540 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1541 name = "Logitech ViewPort AV 100";
1542 type_id = 740;
1543 break;
1544 case 0x08b8:
1545 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1546 name = "Logitech QuickCam (res.)";
1547 type_id = 730;
1548 break;
1549 default:
1550 return -ENODEV;
1551 break;
1552 }
1553 }
1554 else if (vendor_id == 0x055d) {
1555
1556
1557
1558
1559 switch(product_id) {
1560 case 0x9000:
1561 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1562 name = "Samsung MPC-C10";
1563 type_id = 675;
1564 break;
1565 case 0x9001:
1566 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1567 name = "Samsung MPC-C30";
1568 type_id = 675;
1569 break;
1570 case 0x9002:
1571 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1572 name = "Samsung MPC-C30";
1573 type_id = 740;
1574 break;
1575 default:
1576 return -ENODEV;
1577 break;
1578 }
1579 }
1580 else if (vendor_id == 0x041e) {
1581 switch(product_id) {
1582 case 0x400c:
1583 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1584 name = "Creative Labs Webcam 5";
1585 type_id = 730;
1586 break;
1587 case 0x4011:
1588 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1589 name = "Creative Labs Webcam Pro Ex";
1590 type_id = 740;
1591 break;
1592 default:
1593 return -ENODEV;
1594 break;
1595 }
1596 }
1597 else if (vendor_id == 0x04cc) {
1598 switch(product_id) {
1599 case 0x8116:
1600 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1601 name = "Sotec Afina Eye";
1602 type_id = 730;
1603 break;
1604 default:
1605 return -ENODEV;
1606 break;
1607 }
1608 }
1609 else if (vendor_id == 0x06be) {
1610 switch(product_id) {
1611 case 0x8116:
1612
1613 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1614 name = "AME Co. Afina Eye";
1615 type_id = 750;
1616 break;
1617 default:
1618 return -ENODEV;
1619 break;
1620 }
1621
1622 }
1623 else if (vendor_id == 0x0d81) {
1624 switch(product_id) {
1625 case 0x1900:
1626 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1627 name = "Visionite VCS-UC300";
1628 type_id = 740;
1629 break;
1630 case 0x1910:
1631 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1632 name = "Visionite VCS-UM100";
1633 type_id = 730;
1634 break;
1635 default:
1636 return -ENODEV;
1637 break;
1638 }
1639 }
1640 else
1641 return -ENODEV;
1642
1643 memset(serial_number, 0, 30);
1644 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1645 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1646
1647 if (udev->descriptor.bNumConfigurations > 1)
1648 PWC_WARNING("Warning: more than 1 configuration available.\n");
1649
1650
1651 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1652 if (pdev == NULL) {
1653 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1654 return -ENOMEM;
1655 }
1656 pdev->type = type_id;
1657 pdev->vsize = default_size;
1658 pdev->vframes = default_fps;
1659 strcpy(pdev->serial, serial_number);
1660 pdev->features = features;
1661 if (vendor_id == 0x046D && product_id == 0x08B5) {
1662
1663
1664
1665
1666 pdev->angle_range.pan_min = -7000;
1667 pdev->angle_range.pan_max = 7000;
1668 pdev->angle_range.tilt_min = -3000;
1669 pdev->angle_range.tilt_max = 2500;
1670 }
1671
1672 mutex_init(&pdev->modlock);
1673 spin_lock_init(&pdev->ptrlock);
1674
1675 pdev->udev = udev;
1676 init_waitqueue_head(&pdev->frameq);
1677 pdev->vcompression = pwc_preferred_compression;
1678
1679
1680 memcpy(&pdev->vdev, &pwc_template, sizeof(pwc_template));
1681 pdev->vdev.parent = &intf->dev;
1682 pdev->vdev.lock = &pdev->modlock;
1683 strcpy(pdev->vdev.name, name);
1684 video_set_drvdata(&pdev->vdev, pdev);
1685
1686 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1687 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1688
1689
1690 for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1691 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1692 (device_hint[hint].pdev == NULL)) {
1693
1694 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1695
1696 video_nr = device_hint[hint].device_node;
1697 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1698 break;
1699 }
1700 }
1701 }
1702
1703
1704 if (hint < MAX_DEV_HINTS)
1705 device_hint[hint].pdev = pdev;
1706
1707 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1708 usb_set_intfdata(intf, pdev);
1709
1710
1711 pwc_set_leds(pdev, 0, 0);
1712 pwc_camera_power(pdev, 0);
1713
1714 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1715 if (rc < 0) {
1716 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1717 goto err_free_mem;
1718 }
1719 rc = pwc_create_sysfs_files(pdev);
1720 if (rc)
1721 goto err_video_unreg;
1722
1723 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1724
1725#ifdef CONFIG_USB_PWC_INPUT_EVDEV
1726
1727 pdev->button_dev = input_allocate_device();
1728 if (!pdev->button_dev) {
1729 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1730 rc = -ENOMEM;
1731 pwc_remove_sysfs_files(pdev);
1732 goto err_video_unreg;
1733 }
1734
1735 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1736 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1737
1738 pdev->button_dev->name = "PWC snapshot button";
1739 pdev->button_dev->phys = pdev->button_phys;
1740 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1741 pdev->button_dev->dev.parent = &pdev->udev->dev;
1742 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1743 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1744
1745 rc = input_register_device(pdev->button_dev);
1746 if (rc) {
1747 input_free_device(pdev->button_dev);
1748 pdev->button_dev = NULL;
1749 pwc_remove_sysfs_files(pdev);
1750 goto err_video_unreg;
1751 }
1752#endif
1753
1754 return 0;
1755
1756err_video_unreg:
1757 if (hint < MAX_DEV_HINTS)
1758 device_hint[hint].pdev = NULL;
1759 video_unregister_device(&pdev->vdev);
1760err_free_mem:
1761 kfree(pdev);
1762 return rc;
1763}
1764
1765
1766static void usb_pwc_disconnect(struct usb_interface *intf)
1767{
1768 struct pwc_device *pdev = usb_get_intfdata(intf);
1769
1770 mutex_lock(&pdev->modlock);
1771 usb_set_intfdata (intf, NULL);
1772 if (pdev == NULL) {
1773 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1774 goto disconnect_out;
1775 }
1776 if (pdev->udev == NULL) {
1777 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1778 goto disconnect_out;
1779 }
1780 if (pdev->udev != interface_to_usbdev(intf)) {
1781 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1782 goto disconnect_out;
1783 }
1784
1785
1786 pdev->error_status = EPIPE;
1787 pdev->unplugged = 1;
1788
1789
1790 wake_up_interruptible(&pdev->frameq);
1791
1792
1793 pwc_isoc_cleanup(pdev);
1794
1795disconnect_out:
1796 mutex_unlock(&pdev->modlock);
1797
1798 pwc_remove_sysfs_files(pdev);
1799 video_unregister_device(&pdev->vdev);
1800
1801#ifdef CONFIG_USB_PWC_INPUT_EVDEV
1802 if (pdev->button_dev)
1803 input_unregister_device(pdev->button_dev);
1804#endif
1805}
1806
1807
1808
1809
1810
1811
1812static char *size;
1813static int fps;
1814static int fbufs;
1815static int mbufs;
1816static int compression = -1;
1817static int leds[2] = { -1, -1 };
1818static unsigned int leds_nargs;
1819static char *dev_hint[MAX_DEV_HINTS];
1820static unsigned int dev_hint_nargs;
1821
1822module_param(size, charp, 0444);
1823module_param(fps, int, 0444);
1824module_param(fbufs, int, 0444);
1825module_param(mbufs, int, 0444);
1826#ifdef CONFIG_USB_PWC_DEBUG
1827module_param_named(trace, pwc_trace, int, 0644);
1828#endif
1829module_param(power_save, int, 0444);
1830module_param(compression, int, 0444);
1831module_param_array(leds, int, &leds_nargs, 0444);
1832module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1833
1834MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1835MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1836MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1837MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1838#ifdef CONFIG_USB_PWC_DEBUG
1839MODULE_PARM_DESC(trace, "For debugging purposes");
1840#endif
1841MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1842MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1843MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1844MODULE_PARM_DESC(dev_hint, "Device node hints");
1845
1846MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1847MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1848MODULE_LICENSE("GPL");
1849MODULE_ALIAS("pwcx");
1850MODULE_VERSION( PWC_VERSION );
1851
1852static int __init usb_pwc_init(void)
1853{
1854 int i, sz;
1855 char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1856
1857 PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1858 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1859 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1860 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1861
1862 if (fps) {
1863 if (fps < 4 || fps > 30) {
1864 PWC_ERROR("Framerate out of bounds (4-30).\n");
1865 return -EINVAL;
1866 }
1867 default_fps = fps;
1868 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1869 }
1870
1871 if (size) {
1872
1873 for (sz = 0; sz < PSZ_MAX; sz++) {
1874 if (!strcmp(sizenames[sz], size)) {
1875 default_size = sz;
1876 break;
1877 }
1878 }
1879 if (sz == PSZ_MAX) {
1880 PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
1881 return -EINVAL;
1882 }
1883 PWC_DEBUG_MODULE("Default image size set to %s [%dx%d].\n", sizenames[default_size], pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y);
1884 }
1885 if (mbufs) {
1886 if (mbufs < 1 || mbufs > MAX_IMAGES) {
1887 PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
1888 return -EINVAL;
1889 }
1890 pwc_mbufs = mbufs;
1891 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
1892 }
1893 if (fbufs) {
1894 if (fbufs < 2 || fbufs > MAX_FRAMES) {
1895 PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
1896 return -EINVAL;
1897 }
1898 default_fbufs = fbufs;
1899 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
1900 }
1901#ifdef CONFIG_USB_PWC_DEBUG
1902 if (pwc_trace >= 0) {
1903 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1904 }
1905#endif
1906 if (compression >= 0) {
1907 if (compression > 3) {
1908 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1909 return -EINVAL;
1910 }
1911 pwc_preferred_compression = compression;
1912 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
1913 }
1914 if (power_save)
1915 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
1916 if (leds[0] >= 0)
1917 led_on = leds[0];
1918 if (leds[1] >= 0)
1919 led_off = leds[1];
1920
1921
1922
1923
1924
1925
1926
1927
1928 for (i = 0; i < MAX_DEV_HINTS; i++) {
1929 char *s, *colon, *dot;
1930
1931
1932 device_hint[i].pdev = NULL;
1933 s = dev_hint[i];
1934 if (s != NULL && *s != '\0') {
1935 device_hint[i].type = -1;
1936 strcpy(device_hint[i].serial_number, "*");
1937
1938
1939 colon = dot = s;
1940 while (*colon != '\0' && *colon != ':')
1941 colon++;
1942 while (*dot != '\0' && *dot != '.')
1943 dot++;
1944
1945 if (*dot != '\0' && dot > colon) {
1946 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
1947 return -EINVAL;
1948 }
1949
1950 if (*colon == '\0') {
1951
1952 if (*dot != '\0') {
1953 PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
1954 return -EINVAL;
1955 }
1956 else {
1957
1958 device_hint[i].device_node =
1959 simple_strtol(s, NULL, 10);
1960 }
1961 }
1962 else {
1963
1964 device_hint[i].type =
1965 simple_strtol(s, NULL, 10);
1966 device_hint[i].device_node =
1967 simple_strtol(colon + 1, NULL, 10);
1968 if (*dot != '\0') {
1969
1970 int k;
1971
1972 dot++;
1973 k = 0;
1974 while (*dot != ':' && k < 29) {
1975 device_hint[i].serial_number[k++] = *dot;
1976 dot++;
1977 }
1978 device_hint[i].serial_number[k] = '\0';
1979 }
1980 }
1981 PWC_TRACE("device_hint[%d]:\n", i);
1982 PWC_TRACE(" type : %d\n", device_hint[i].type);
1983 PWC_TRACE(" serial# : %s\n", device_hint[i].serial_number);
1984 PWC_TRACE(" node : %d\n", device_hint[i].device_node);
1985 }
1986 else
1987 device_hint[i].type = 0;
1988 }
1989
1990 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
1991 return usb_register(&pwc_driver);
1992}
1993
1994static void __exit usb_pwc_exit(void)
1995{
1996 PWC_DEBUG_MODULE("Deregistering driver.\n");
1997 usb_deregister(&pwc_driver);
1998 PWC_INFO("Philips webcam module removed.\n");
1999}
2000
2001module_init(usb_pwc_init);
2002module_exit(usb_pwc_exit);
2003
2004
2005