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