1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/kernel.h>
18#include <linux/sched.h>
19#include <linux/list.h>
20#include <linux/slab.h>
21#include <linux/module.h>
22#include <linux/mm.h>
23#include <linux/vmalloc.h>
24#include <linux/init.h>
25#include <linux/spinlock.h>
26
27#include <asm/io.h>
28
29#include "usbvideo.h"
30
31#if defined(MAP_NR)
32#define virt_to_page(v) MAP_NR(v)
33#endif
34
35static int video_nr = -1;
36module_param(video_nr, int, 0);
37
38
39
40
41static void usbvideo_Disconnect(struct usb_interface *intf);
42static void usbvideo_CameraRelease(struct uvd *uvd);
43
44static long usbvideo_v4l_ioctl(struct file *file,
45 unsigned int cmd, unsigned long arg);
46static int usbvideo_v4l_mmap(struct file *file, struct vm_area_struct *vma);
47static int usbvideo_v4l_open(struct file *file);
48static ssize_t usbvideo_v4l_read(struct file *file, char __user *buf,
49 size_t count, loff_t *ppos);
50static int usbvideo_v4l_close(struct file *file);
51
52static int usbvideo_StartDataPump(struct uvd *uvd);
53static void usbvideo_StopDataPump(struct uvd *uvd);
54static int usbvideo_GetFrame(struct uvd *uvd, int frameNum);
55static int usbvideo_NewFrame(struct uvd *uvd, int framenum);
56static void usbvideo_SoftwareContrastAdjustment(struct uvd *uvd,
57 struct usbvideo_frame *frame);
58
59
60
61
62static void *usbvideo_rvmalloc(unsigned long size)
63{
64 void *mem;
65 unsigned long adr;
66
67 size = PAGE_ALIGN(size);
68 mem = vmalloc_32(size);
69 if (!mem)
70 return NULL;
71
72 memset(mem, 0, size);
73 adr = (unsigned long) mem;
74 while (size > 0) {
75 SetPageReserved(vmalloc_to_page((void *)adr));
76 adr += PAGE_SIZE;
77 size -= PAGE_SIZE;
78 }
79
80 return mem;
81}
82
83static void usbvideo_rvfree(void *mem, unsigned long size)
84{
85 unsigned long adr;
86
87 if (!mem)
88 return;
89
90 adr = (unsigned long) mem;
91 while ((long) size > 0) {
92 ClearPageReserved(vmalloc_to_page((void *)adr));
93 adr += PAGE_SIZE;
94 size -= PAGE_SIZE;
95 }
96 vfree(mem);
97}
98
99static void RingQueue_Initialize(struct RingQueue *rq)
100{
101 assert(rq != NULL);
102 init_waitqueue_head(&rq->wqh);
103}
104
105static void RingQueue_Allocate(struct RingQueue *rq, int rqLen)
106{
107
108
109
110
111 int i = 1;
112 assert(rq != NULL);
113 assert(rqLen > 0);
114
115 while(rqLen >> i)
116 i++;
117 if(rqLen != 1 << (i-1))
118 rqLen = 1 << i;
119
120 rq->length = rqLen;
121 rq->ri = rq->wi = 0;
122 rq->queue = usbvideo_rvmalloc(rq->length);
123 assert(rq->queue != NULL);
124}
125
126static int RingQueue_IsAllocated(const struct RingQueue *rq)
127{
128 if (rq == NULL)
129 return 0;
130 return (rq->queue != NULL) && (rq->length > 0);
131}
132
133static void RingQueue_Free(struct RingQueue *rq)
134{
135 assert(rq != NULL);
136 if (RingQueue_IsAllocated(rq)) {
137 usbvideo_rvfree(rq->queue, rq->length);
138 rq->queue = NULL;
139 rq->length = 0;
140 }
141}
142
143int RingQueue_Dequeue(struct RingQueue *rq, unsigned char *dst, int len)
144{
145 int rql, toread;
146
147 assert(rq != NULL);
148 assert(dst != NULL);
149
150 rql = RingQueue_GetLength(rq);
151 if(!rql)
152 return 0;
153
154
155 if(len > rql)
156 len = rql;
157
158 toread = len;
159 if(rq->ri > rq->wi) {
160
161 int read = (toread < (rq->length - rq->ri)) ? toread : rq->length - rq->ri;
162 memcpy(dst, rq->queue + rq->ri, read);
163 toread -= read;
164 dst += read;
165 rq->ri = (rq->ri + read) & (rq->length-1);
166 }
167 if(toread) {
168
169 memcpy(dst, rq->queue + rq->ri, toread);
170 rq->ri = (rq->ri + toread) & (rq->length-1);
171 }
172 return len;
173}
174
175EXPORT_SYMBOL(RingQueue_Dequeue);
176
177int RingQueue_Enqueue(struct RingQueue *rq, const unsigned char *cdata, int n)
178{
179 int enqueued = 0;
180
181 assert(rq != NULL);
182 assert(cdata != NULL);
183 assert(rq->length > 0);
184 while (n > 0) {
185 int m, q_avail;
186
187
188 q_avail = rq->length - rq->wi;
189 if (q_avail <= 0) {
190 rq->wi = 0;
191 q_avail = rq->length;
192 }
193 m = n;
194 assert(q_avail > 0);
195 if (m > q_avail)
196 m = q_avail;
197
198 memcpy(rq->queue + rq->wi, cdata, m);
199 RING_QUEUE_ADVANCE_INDEX(rq, wi, m);
200 cdata += m;
201 enqueued += m;
202 n -= m;
203 }
204 return enqueued;
205}
206
207EXPORT_SYMBOL(RingQueue_Enqueue);
208
209static void RingQueue_InterruptibleSleepOn(struct RingQueue *rq)
210{
211 assert(rq != NULL);
212 interruptible_sleep_on(&rq->wqh);
213}
214
215void RingQueue_WakeUpInterruptible(struct RingQueue *rq)
216{
217 assert(rq != NULL);
218 if (waitqueue_active(&rq->wqh))
219 wake_up_interruptible(&rq->wqh);
220}
221
222EXPORT_SYMBOL(RingQueue_WakeUpInterruptible);
223
224void RingQueue_Flush(struct RingQueue *rq)
225{
226 assert(rq != NULL);
227 rq->ri = 0;
228 rq->wi = 0;
229}
230
231EXPORT_SYMBOL(RingQueue_Flush);
232
233
234
235
236
237
238
239
240
241
242
243static void usbvideo_VideosizeToString(char *buf, int bufLen, videosize_t vs)
244{
245 char tmp[40];
246 int n;
247
248 n = 1 + sprintf(tmp, "%ldx%ld", VIDEOSIZE_X(vs), VIDEOSIZE_Y(vs));
249 assert(n < sizeof(tmp));
250 if ((buf == NULL) || (bufLen < n))
251 err("usbvideo_VideosizeToString: buffer is too small.");
252 else
253 memmove(buf, tmp, n);
254}
255
256
257
258
259
260
261
262static void usbvideo_OverlayChar(struct uvd *uvd, struct usbvideo_frame *frame,
263 int x, int y, int ch)
264{
265 static const unsigned short digits[16] = {
266 0xF6DE,
267 0x2492,
268 0xE7CE,
269 0xE79E,
270 0xB792,
271 0xF39E,
272 0xF3DE,
273 0xF492,
274 0xF7DE,
275 0xF79E,
276 0x77DA,
277 0xD75C,
278 0xF24E,
279 0xD6DC,
280 0xF34E,
281 0xF348
282 };
283 unsigned short digit;
284 int ix, iy;
285
286 if ((uvd == NULL) || (frame == NULL))
287 return;
288
289 if (ch >= '0' && ch <= '9')
290 ch -= '0';
291 else if (ch >= 'A' && ch <= 'F')
292 ch = 10 + (ch - 'A');
293 else if (ch >= 'a' && ch <= 'f')
294 ch = 10 + (ch - 'a');
295 else
296 return;
297 digit = digits[ch];
298
299 for (iy=0; iy < 5; iy++) {
300 for (ix=0; ix < 3; ix++) {
301 if (digit & 0x8000) {
302 if (uvd->paletteBits & (1L << VIDEO_PALETTE_RGB24)) {
303 RGB24_PUTPIXEL(frame, x+ix, y+iy, 0xFF, 0xFF, 0xFF);
304 }
305 }
306 digit = digit << 1;
307 }
308 }
309}
310
311
312
313
314
315
316
317static void usbvideo_OverlayString(struct uvd *uvd, struct usbvideo_frame *frame,
318 int x, int y, const char *str)
319{
320 while (*str) {
321 usbvideo_OverlayChar(uvd, frame, x, y, *str);
322 str++;
323 x += 4;
324 }
325}
326
327
328
329
330
331
332
333
334
335static void usbvideo_OverlayStats(struct uvd *uvd, struct usbvideo_frame *frame)
336{
337 const int y_diff = 8;
338 char tmp[16];
339 int x = 10, y=10;
340 long i, j, barLength;
341 const int qi_x1 = 60, qi_y1 = 10;
342 const int qi_x2 = VIDEOSIZE_X(frame->request) - 10, qi_h = 10;
343
344
345 if (VALID_CALLBACK(uvd, overlayHook)) {
346 if (GET_CALLBACK(uvd, overlayHook)(uvd, frame) < 0)
347 return;
348 }
349
350
351
352
353
354
355 barLength = qi_x2 - qi_x1 - 2;
356 if ((barLength > 10) && (uvd->paletteBits & (1L << VIDEO_PALETTE_RGB24))) {
357 long u_lo, u_hi, q_used;
358 long m_ri, m_wi, m_lo, m_hi;
359
360
361
362
363
364
365
366
367 q_used = RingQueue_GetLength(&uvd->dp);
368 if ((uvd->dp.ri + q_used) >= uvd->dp.length) {
369 u_hi = uvd->dp.length;
370 u_lo = (q_used + uvd->dp.ri) & (uvd->dp.length-1);
371 } else {
372 u_hi = (q_used + uvd->dp.ri);
373 u_lo = -1;
374 }
375
376
377 m_ri = qi_x1 + ((barLength * uvd->dp.ri) / uvd->dp.length);
378 m_wi = qi_x1 + ((barLength * uvd->dp.wi) / uvd->dp.length);
379 m_lo = (u_lo > 0) ? (qi_x1 + ((barLength * u_lo) / uvd->dp.length)) : -1;
380 m_hi = qi_x1 + ((barLength * u_hi) / uvd->dp.length);
381
382 for (j=qi_y1; j < (qi_y1 + qi_h); j++) {
383 for (i=qi_x1; i < qi_x2; i++) {
384
385 if ((j == qi_y1) || (j == (qi_y1 + qi_h - 1)) ||
386 (i == qi_x1) || (i == (qi_x2 - 1))) {
387 RGB24_PUTPIXEL(frame, i, j, 0xFF, 0xFF, 0xFF);
388 continue;
389 }
390
391 if ((i >= m_ri) && (i <= (m_ri + 3))) {
392 RGB24_PUTPIXEL(frame, i, j, 0x00, 0xFF, 0x00);
393 } else if ((i >= m_wi) && (i <= (m_wi + 3))) {
394 RGB24_PUTPIXEL(frame, i, j, 0xFF, 0x00, 0x00);
395 } else if ((i < m_lo) || ((i > m_ri) && (i < m_hi)))
396 RGB24_PUTPIXEL(frame, i, j, 0x00, 0x00, 0xFF);
397 }
398 }
399 }
400
401 sprintf(tmp, "%8lx", uvd->stats.frame_num);
402 usbvideo_OverlayString(uvd, frame, x, y, tmp);
403 y += y_diff;
404
405 sprintf(tmp, "%8lx", uvd->stats.urb_count);
406 usbvideo_OverlayString(uvd, frame, x, y, tmp);
407 y += y_diff;
408
409 sprintf(tmp, "%8lx", uvd->stats.urb_length);
410 usbvideo_OverlayString(uvd, frame, x, y, tmp);
411 y += y_diff;
412
413 sprintf(tmp, "%8lx", uvd->stats.data_count);
414 usbvideo_OverlayString(uvd, frame, x, y, tmp);
415 y += y_diff;
416
417 sprintf(tmp, "%8lx", uvd->stats.header_count);
418 usbvideo_OverlayString(uvd, frame, x, y, tmp);
419 y += y_diff;
420
421 sprintf(tmp, "%8lx", uvd->stats.iso_skip_count);
422 usbvideo_OverlayString(uvd, frame, x, y, tmp);
423 y += y_diff;
424
425 sprintf(tmp, "%8lx", uvd->stats.iso_err_count);
426 usbvideo_OverlayString(uvd, frame, x, y, tmp);
427 y += y_diff;
428
429 sprintf(tmp, "%8x", uvd->vpic.colour);
430 usbvideo_OverlayString(uvd, frame, x, y, tmp);
431 y += y_diff;
432
433 sprintf(tmp, "%8x", uvd->vpic.hue);
434 usbvideo_OverlayString(uvd, frame, x, y, tmp);
435 y += y_diff;
436
437 sprintf(tmp, "%8x", uvd->vpic.brightness >> 8);
438 usbvideo_OverlayString(uvd, frame, x, y, tmp);
439 y += y_diff;
440
441 sprintf(tmp, "%8x", uvd->vpic.contrast >> 12);
442 usbvideo_OverlayString(uvd, frame, x, y, tmp);
443 y += y_diff;
444
445 sprintf(tmp, "%8d", uvd->vpic.whiteness >> 8);
446 usbvideo_OverlayString(uvd, frame, x, y, tmp);
447 y += y_diff;
448}
449
450
451
452
453
454
455
456
457
458static void usbvideo_ReportStatistics(const struct uvd *uvd)
459{
460 if ((uvd != NULL) && (uvd->stats.urb_count > 0)) {
461 unsigned long allPackets, badPackets, goodPackets, percent;
462 allPackets = uvd->stats.urb_count * CAMERA_URB_FRAMES;
463 badPackets = uvd->stats.iso_skip_count + uvd->stats.iso_err_count;
464 goodPackets = allPackets - badPackets;
465
466 assert(allPackets != 0);
467 if (goodPackets < (((unsigned long)-1)/100))
468 percent = (100 * goodPackets) / allPackets;
469 else
470 percent = goodPackets / (allPackets / 100);
471 dev_info(&uvd->dev->dev,
472 "Packet Statistics: Total=%lu. Empty=%lu. Usage=%lu%%\n",
473 allPackets, badPackets, percent);
474 if (uvd->iso_packet_len > 0) {
475 unsigned long allBytes, xferBytes;
476 char multiplier = ' ';
477 allBytes = allPackets * uvd->iso_packet_len;
478 xferBytes = uvd->stats.data_count;
479 assert(allBytes != 0);
480 if (xferBytes < (((unsigned long)-1)/100))
481 percent = (100 * xferBytes) / allBytes;
482 else
483 percent = xferBytes / (allBytes / 100);
484
485 if (xferBytes > 10*1024) {
486 xferBytes /= 1024;
487 multiplier = 'K';
488 if (xferBytes > 10*1024) {
489 xferBytes /= 1024;
490 multiplier = 'M';
491 if (xferBytes > 10*1024) {
492 xferBytes /= 1024;
493 multiplier = 'G';
494 if (xferBytes > 10*1024) {
495 xferBytes /= 1024;
496 multiplier = 'T';
497 }
498 }
499 }
500 }
501 dev_info(&uvd->dev->dev,
502 "Transfer Statistics: Transferred=%lu%cB Usage=%lu%%\n",
503 xferBytes, multiplier, percent);
504 }
505 }
506}
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522void usbvideo_TestPattern(struct uvd *uvd, int fullframe, int pmode)
523{
524 struct usbvideo_frame *frame;
525 int num_cell = 0;
526 int scan_length = 0;
527 static int num_pass;
528
529 if (uvd == NULL) {
530 err("%s: uvd == NULL", __func__);
531 return;
532 }
533 if ((uvd->curframe < 0) || (uvd->curframe >= USBVIDEO_NUMFRAMES)) {
534 err("%s: uvd->curframe=%d.", __func__, uvd->curframe);
535 return;
536 }
537
538
539 frame = &uvd->frame[uvd->curframe];
540
541
542 if (fullframe) {
543 frame->curline = 0;
544 frame->seqRead_Length = 0;
545 }
546#if 0
547 {
548 char tmp[20];
549 usbvideo_VideosizeToString(tmp, sizeof(tmp), frame->request);
550 dev_info(&uvd->dev->dev, "testpattern: frame=%s\n", tmp);
551 }
552#endif
553
554 for (; frame->curline < VIDEOSIZE_Y(frame->request); frame->curline++) {
555 int i;
556 unsigned char *f = frame->data +
557 (VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL * frame->curline);
558 for (i=0; i < VIDEOSIZE_X(frame->request); i++) {
559 unsigned char cb=0x80;
560 unsigned char cg = 0;
561 unsigned char cr = 0;
562
563 if (pmode == 1) {
564 if (frame->curline % 32 == 0)
565 cb = 0, cg = cr = 0xFF;
566 else if (i % 32 == 0) {
567 if (frame->curline % 32 == 1)
568 num_cell++;
569 cb = 0, cg = cr = 0xFF;
570 } else {
571 cb = ((num_cell*7) + num_pass) & 0xFF;
572 cg = ((num_cell*5) + num_pass*2) & 0xFF;
573 cr = ((num_cell*3) + num_pass*3) & 0xFF;
574 }
575 } else {
576
577 }
578
579 *f++ = cb;
580 *f++ = cg;
581 *f++ = cr;
582 scan_length += 3;
583 }
584 }
585
586 frame->frameState = FrameState_Done;
587 frame->seqRead_Length += scan_length;
588 ++num_pass;
589
590
591 usbvideo_OverlayStats(uvd, frame);
592}
593
594EXPORT_SYMBOL(usbvideo_TestPattern);
595
596
597#ifdef DEBUG
598
599
600
601
602
603
604
605
606void usbvideo_HexDump(const unsigned char *data, int len)
607{
608 const int bytes_per_line = 32;
609 char tmp[128];
610 int i, k;
611
612 for (i=k=0; len > 0; i++, len--) {
613 if (i > 0 && ((i % bytes_per_line) == 0)) {
614 printk("%s\n", tmp);
615 k=0;
616 }
617 if ((i % bytes_per_line) == 0)
618 k += sprintf(&tmp[k], "%04x: ", i);
619 k += sprintf(&tmp[k], "%02x ", data[i]);
620 }
621 if (k > 0)
622 printk("%s\n", tmp);
623}
624
625EXPORT_SYMBOL(usbvideo_HexDump);
626
627#endif
628
629
630
631
632static int usbvideo_ClientIncModCount(struct uvd *uvd)
633{
634 if (uvd == NULL) {
635 err("%s: uvd == NULL", __func__);
636 return -EINVAL;
637 }
638 if (uvd->handle == NULL) {
639 err("%s: uvd->handle == NULL", __func__);
640 return -EINVAL;
641 }
642 if (!try_module_get(uvd->handle->md_module)) {
643 err("%s: try_module_get() == 0", __func__);
644 return -ENODEV;
645 }
646 return 0;
647}
648
649static void usbvideo_ClientDecModCount(struct uvd *uvd)
650{
651 if (uvd == NULL) {
652 err("%s: uvd == NULL", __func__);
653 return;
654 }
655 if (uvd->handle == NULL) {
656 err("%s: uvd->handle == NULL", __func__);
657 return;
658 }
659 if (uvd->handle->md_module == NULL) {
660 err("%s: uvd->handle->md_module == NULL", __func__);
661 return;
662 }
663 module_put(uvd->handle->md_module);
664}
665
666int usbvideo_register(
667 struct usbvideo **pCams,
668 const int num_cams,
669 const int num_extra,
670 const char *driverName,
671 const struct usbvideo_cb *cbTbl,
672 struct module *md,
673 const struct usb_device_id *id_table)
674{
675 struct usbvideo *cams;
676 int i, base_size, result;
677
678
679 if ((num_cams <= 0) || (pCams == NULL) || (cbTbl == NULL)) {
680 err("%s: Illegal call", __func__);
681 return -EINVAL;
682 }
683
684
685 if (cbTbl->probe == NULL) {
686 err("%s: probe() is required!", __func__);
687 return -EINVAL;
688 }
689
690 base_size = num_cams * sizeof(struct uvd) + sizeof(struct usbvideo);
691 cams = kzalloc(base_size, GFP_KERNEL);
692 if (cams == NULL) {
693 err("Failed to allocate %d. bytes for usbvideo struct", base_size);
694 return -ENOMEM;
695 }
696 dbg("%s: Allocated $%p (%d. bytes) for %d. cameras",
697 __func__, cams, base_size, num_cams);
698
699
700 memmove(&cams->cb, cbTbl, sizeof(cams->cb));
701 if (cams->cb.getFrame == NULL)
702 cams->cb.getFrame = usbvideo_GetFrame;
703 if (cams->cb.disconnect == NULL)
704 cams->cb.disconnect = usbvideo_Disconnect;
705 if (cams->cb.startDataPump == NULL)
706 cams->cb.startDataPump = usbvideo_StartDataPump;
707 if (cams->cb.stopDataPump == NULL)
708 cams->cb.stopDataPump = usbvideo_StopDataPump;
709
710 cams->num_cameras = num_cams;
711 cams->cam = (struct uvd *) &cams[1];
712 cams->md_module = md;
713 mutex_init(&cams->lock);
714
715 for (i = 0; i < num_cams; i++) {
716 struct uvd *up = &cams->cam[i];
717
718 up->handle = cams;
719
720
721 if (num_extra > 0) {
722 up->user_size = num_cams * num_extra;
723 up->user_data = kmalloc(up->user_size, GFP_KERNEL);
724 if (up->user_data == NULL) {
725 err("%s: Failed to allocate user_data (%d. bytes)",
726 __func__, up->user_size);
727 while (i) {
728 up = &cams->cam[--i];
729 kfree(up->user_data);
730 }
731 kfree(cams);
732 return -ENOMEM;
733 }
734 dbg("%s: Allocated cams[%d].user_data=$%p (%d. bytes)",
735 __func__, i, up->user_data, up->user_size);
736 }
737 }
738
739
740
741
742 strcpy(cams->drvName, (driverName != NULL) ? driverName : "Unknown");
743 cams->usbdrv.name = cams->drvName;
744 cams->usbdrv.probe = cams->cb.probe;
745 cams->usbdrv.disconnect = cams->cb.disconnect;
746 cams->usbdrv.id_table = id_table;
747
748
749
750
751
752
753 *pCams = cams;
754 result = usb_register(&cams->usbdrv);
755 if (result) {
756 for (i = 0; i < num_cams; i++) {
757 struct uvd *up = &cams->cam[i];
758 kfree(up->user_data);
759 }
760 kfree(cams);
761 }
762
763 return result;
764}
765
766EXPORT_SYMBOL(usbvideo_register);
767
768
769
770
771
772
773
774
775void usbvideo_Deregister(struct usbvideo **pCams)
776{
777 struct usbvideo *cams;
778 int i;
779
780 if (pCams == NULL) {
781 err("%s: pCams == NULL", __func__);
782 return;
783 }
784 cams = *pCams;
785 if (cams == NULL) {
786 err("%s: cams == NULL", __func__);
787 return;
788 }
789
790 dbg("%s: Deregistering %s driver.", __func__, cams->drvName);
791 usb_deregister(&cams->usbdrv);
792
793 dbg("%s: Deallocating cams=$%p (%d. cameras)", __func__, cams, cams->num_cameras);
794 for (i=0; i < cams->num_cameras; i++) {
795 struct uvd *up = &cams->cam[i];
796 int warning = 0;
797
798 if (up->user_data != NULL) {
799 if (up->user_size <= 0)
800 ++warning;
801 } else {
802 if (up->user_size > 0)
803 ++warning;
804 }
805 if (warning) {
806 err("%s: Warning: user_data=$%p user_size=%d.",
807 __func__, up->user_data, up->user_size);
808 } else {
809 dbg("%s: Freeing %d. $%p->user_data=$%p",
810 __func__, i, up, up->user_data);
811 kfree(up->user_data);
812 }
813 }
814
815 dbg("%s: Freed %d uvd structures",
816 __func__, cams->num_cameras);
817 kfree(cams);
818 *pCams = NULL;
819}
820
821EXPORT_SYMBOL(usbvideo_Deregister);
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845static void usbvideo_Disconnect(struct usb_interface *intf)
846{
847 struct uvd *uvd = usb_get_intfdata (intf);
848 int i;
849
850 if (uvd == NULL) {
851 err("%s($%p): Illegal call.", __func__, intf);
852 return;
853 }
854
855 usb_set_intfdata (intf, NULL);
856
857 usbvideo_ClientIncModCount(uvd);
858 if (uvd->debug > 0)
859 dev_info(&intf->dev, "%s(%p.)\n", __func__, intf);
860
861 mutex_lock(&uvd->lock);
862 uvd->remove_pending = 1;
863
864
865 GET_CALLBACK(uvd, stopDataPump)(uvd);
866
867 for (i=0; i < USBVIDEO_NUMSBUF; i++)
868 usb_free_urb(uvd->sbuf[i].urb);
869
870 usb_put_dev(uvd->dev);
871 uvd->dev = NULL;
872
873 video_unregister_device(&uvd->vdev);
874 if (uvd->debug > 0)
875 dev_info(&intf->dev, "%s: Video unregistered.\n", __func__);
876
877 if (uvd->user)
878 dev_info(&intf->dev, "%s: In use, disconnect pending.\n",
879 __func__);
880 else
881 usbvideo_CameraRelease(uvd);
882 mutex_unlock(&uvd->lock);
883 dev_info(&intf->dev, "USB camera disconnected.\n");
884
885 usbvideo_ClientDecModCount(uvd);
886}
887
888
889
890
891
892
893
894
895
896
897
898static void usbvideo_CameraRelease(struct uvd *uvd)
899{
900 if (uvd == NULL) {
901 err("%s: Illegal call", __func__);
902 return;
903 }
904
905 RingQueue_Free(&uvd->dp);
906 if (VALID_CALLBACK(uvd, userFree))
907 GET_CALLBACK(uvd, userFree)(uvd);
908 uvd->uvd_used = 0;
909}
910
911
912
913
914
915
916
917
918
919
920
921static int usbvideo_find_struct(struct usbvideo *cams)
922{
923 int u, rv = -1;
924
925 if (cams == NULL) {
926 err("No usbvideo handle?");
927 return -1;
928 }
929 mutex_lock(&cams->lock);
930 for (u = 0; u < cams->num_cameras; u++) {
931 struct uvd *uvd = &cams->cam[u];
932 if (!uvd->uvd_used)
933 {
934 uvd->uvd_used = 1;
935 mutex_init(&uvd->lock);
936 uvd->dev = NULL;
937 rv = u;
938 break;
939 }
940 }
941 mutex_unlock(&cams->lock);
942 return rv;
943}
944
945static const struct v4l2_file_operations usbvideo_fops = {
946 .owner = THIS_MODULE,
947 .open = usbvideo_v4l_open,
948 .release =usbvideo_v4l_close,
949 .read = usbvideo_v4l_read,
950 .mmap = usbvideo_v4l_mmap,
951 .ioctl = usbvideo_v4l_ioctl,
952};
953static const struct video_device usbvideo_template = {
954 .fops = &usbvideo_fops,
955};
956
957struct uvd *usbvideo_AllocateDevice(struct usbvideo *cams)
958{
959 int i, devnum;
960 struct uvd *uvd = NULL;
961
962 if (cams == NULL) {
963 err("No usbvideo handle?");
964 return NULL;
965 }
966
967 devnum = usbvideo_find_struct(cams);
968 if (devnum == -1) {
969 err("IBM USB camera driver: Too many devices!");
970 return NULL;
971 }
972 uvd = &cams->cam[devnum];
973 dbg("Device entry #%d. at $%p", devnum, uvd);
974
975
976 usbvideo_ClientIncModCount(uvd);
977
978 mutex_lock(&uvd->lock);
979 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
980 uvd->sbuf[i].urb = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);
981 if (uvd->sbuf[i].urb == NULL) {
982 err("usb_alloc_urb(%d.) failed.", FRAMES_PER_DESC);
983 uvd->uvd_used = 0;
984 uvd = NULL;
985 goto allocate_done;
986 }
987 }
988 uvd->user=0;
989 uvd->remove_pending = 0;
990 uvd->last_error = 0;
991 RingQueue_Initialize(&uvd->dp);
992
993
994 uvd->vdev = usbvideo_template;
995 sprintf(uvd->vdev.name, "%.20s USB Camera", cams->drvName);
996
997
998
999
1000allocate_done:
1001 mutex_unlock(&uvd->lock);
1002 usbvideo_ClientDecModCount(uvd);
1003 return uvd;
1004}
1005
1006EXPORT_SYMBOL(usbvideo_AllocateDevice);
1007
1008int usbvideo_RegisterVideoDevice(struct uvd *uvd)
1009{
1010 char tmp1[20], tmp2[20];
1011
1012 if (uvd == NULL) {
1013 err("%s: Illegal call.", __func__);
1014 return -EINVAL;
1015 }
1016 if (uvd->video_endp == 0) {
1017 dev_info(&uvd->dev->dev,
1018 "%s: No video endpoint specified; data pump disabled.\n",
1019 __func__);
1020 }
1021 if (uvd->paletteBits == 0) {
1022 err("%s: No palettes specified!", __func__);
1023 return -EINVAL;
1024 }
1025 if (uvd->defaultPalette == 0) {
1026 dev_info(&uvd->dev->dev, "%s: No default palette!\n",
1027 __func__);
1028 }
1029
1030 uvd->max_frame_size = VIDEOSIZE_X(uvd->canvas) *
1031 VIDEOSIZE_Y(uvd->canvas) * V4L_BYTES_PER_PIXEL;
1032 usbvideo_VideosizeToString(tmp1, sizeof(tmp1), uvd->videosize);
1033 usbvideo_VideosizeToString(tmp2, sizeof(tmp2), uvd->canvas);
1034
1035 if (uvd->debug > 0) {
1036 dev_info(&uvd->dev->dev,
1037 "%s: iface=%d. endpoint=$%02x paletteBits=$%08lx\n",
1038 __func__, uvd->iface, uvd->video_endp,
1039 uvd->paletteBits);
1040 }
1041 if (uvd->dev == NULL) {
1042 err("%s: uvd->dev == NULL", __func__);
1043 return -EINVAL;
1044 }
1045 uvd->vdev.parent = &uvd->dev->dev;
1046 uvd->vdev.release = video_device_release_empty;
1047 if (video_register_device(&uvd->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
1048 err("%s: video_register_device failed", __func__);
1049 return -EPIPE;
1050 }
1051 if (uvd->debug > 1) {
1052 dev_info(&uvd->dev->dev,
1053 "%s: video_register_device() successful\n", __func__);
1054 }
1055
1056 dev_info(&uvd->dev->dev, "%s on /dev/video%d: canvas=%s videosize=%s\n",
1057 (uvd->handle != NULL) ? uvd->handle->drvName : "???",
1058 uvd->vdev.num, tmp2, tmp1);
1059
1060 usb_get_dev(uvd->dev);
1061 return 0;
1062}
1063
1064EXPORT_SYMBOL(usbvideo_RegisterVideoDevice);
1065
1066
1067
1068static int usbvideo_v4l_mmap(struct file *file, struct vm_area_struct *vma)
1069{
1070 struct uvd *uvd = file->private_data;
1071 unsigned long start = vma->vm_start;
1072 unsigned long size = vma->vm_end-vma->vm_start;
1073 unsigned long page, pos;
1074
1075 if (!CAMERA_IS_OPERATIONAL(uvd))
1076 return -EFAULT;
1077
1078 if (size > (((USBVIDEO_NUMFRAMES * uvd->max_frame_size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)))
1079 return -EINVAL;
1080
1081 pos = (unsigned long) uvd->fbuf;
1082 while (size > 0) {
1083 page = vmalloc_to_pfn((void *)pos);
1084 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1085 return -EAGAIN;
1086
1087 start += PAGE_SIZE;
1088 pos += PAGE_SIZE;
1089 if (size > PAGE_SIZE)
1090 size -= PAGE_SIZE;
1091 else
1092 size = 0;
1093 }
1094
1095 return 0;
1096}
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112static int usbvideo_v4l_open(struct file *file)
1113{
1114 struct video_device *dev = video_devdata(file);
1115 struct uvd *uvd = (struct uvd *) dev;
1116 const int sb_size = FRAMES_PER_DESC * uvd->iso_packet_len;
1117 int i, errCode = 0;
1118
1119 if (uvd->debug > 1)
1120 dev_info(&uvd->dev->dev, "%s($%p)\n", __func__, dev);
1121
1122 if (usbvideo_ClientIncModCount(uvd) < 0)
1123 return -ENODEV;
1124 mutex_lock(&uvd->lock);
1125
1126 if (uvd->user) {
1127 err("%s: Someone tried to open an already opened device!", __func__);
1128 errCode = -EBUSY;
1129 } else {
1130
1131 memset(&uvd->stats, 0, sizeof(uvd->stats));
1132
1133
1134 for (i=0; i < USBVIDEO_NUMSBUF; i++)
1135 uvd->sbuf[i].data = NULL;
1136
1137
1138 uvd->fbuf_size = USBVIDEO_NUMFRAMES * uvd->max_frame_size;
1139 uvd->fbuf = usbvideo_rvmalloc(uvd->fbuf_size);
1140 RingQueue_Allocate(&uvd->dp, RING_QUEUE_SIZE);
1141 if ((uvd->fbuf == NULL) ||
1142 (!RingQueue_IsAllocated(&uvd->dp))) {
1143 err("%s: Failed to allocate fbuf or dp", __func__);
1144 errCode = -ENOMEM;
1145 } else {
1146
1147 for (i=0; i < USBVIDEO_NUMFRAMES; i++) {
1148 uvd->frame[i].frameState = FrameState_Unused;
1149 uvd->frame[i].data = uvd->fbuf + i*(uvd->max_frame_size);
1150
1151
1152
1153
1154 uvd->frame[i].canvas = uvd->canvas;
1155 uvd->frame[i].seqRead_Index = 0;
1156 }
1157 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1158 uvd->sbuf[i].data = kmalloc(sb_size, GFP_KERNEL);
1159 if (uvd->sbuf[i].data == NULL) {
1160 errCode = -ENOMEM;
1161 break;
1162 }
1163 }
1164 }
1165 if (errCode != 0) {
1166
1167 if (uvd->fbuf != NULL) {
1168 usbvideo_rvfree(uvd->fbuf, uvd->fbuf_size);
1169 uvd->fbuf = NULL;
1170 }
1171 RingQueue_Free(&uvd->dp);
1172 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1173 kfree(uvd->sbuf[i].data);
1174 uvd->sbuf[i].data = NULL;
1175 }
1176 }
1177 }
1178
1179
1180 if (errCode == 0) {
1181
1182 if (uvd->video_endp != 0)
1183 errCode = GET_CALLBACK(uvd, startDataPump)(uvd);
1184 if (errCode == 0) {
1185 if (VALID_CALLBACK(uvd, setupOnOpen)) {
1186 if (uvd->debug > 1)
1187 dev_info(&uvd->dev->dev,
1188 "%s: setupOnOpen callback\n",
1189 __func__);
1190 errCode = GET_CALLBACK(uvd, setupOnOpen)(uvd);
1191 if (errCode < 0) {
1192 err("%s: setupOnOpen callback failed (%d.).",
1193 __func__, errCode);
1194 } else if (uvd->debug > 1) {
1195 dev_info(&uvd->dev->dev,
1196 "%s: setupOnOpen callback successful\n",
1197 __func__);
1198 }
1199 }
1200 if (errCode == 0) {
1201 uvd->settingsAdjusted = 0;
1202 if (uvd->debug > 1)
1203 dev_info(&uvd->dev->dev,
1204 "%s: Open succeeded.\n",
1205 __func__);
1206 uvd->user++;
1207 file->private_data = uvd;
1208 }
1209 }
1210 }
1211 mutex_unlock(&uvd->lock);
1212 if (errCode != 0)
1213 usbvideo_ClientDecModCount(uvd);
1214 if (uvd->debug > 0)
1215 dev_info(&uvd->dev->dev, "%s: Returning %d.\n", __func__,
1216 errCode);
1217 return errCode;
1218}
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232static int usbvideo_v4l_close(struct file *file)
1233{
1234 struct video_device *dev = file->private_data;
1235 struct uvd *uvd = (struct uvd *) dev;
1236 int i;
1237
1238 if (uvd->debug > 1)
1239 dev_info(&uvd->dev->dev, "%s($%p)\n", __func__, dev);
1240
1241 mutex_lock(&uvd->lock);
1242 GET_CALLBACK(uvd, stopDataPump)(uvd);
1243 usbvideo_rvfree(uvd->fbuf, uvd->fbuf_size);
1244 uvd->fbuf = NULL;
1245 RingQueue_Free(&uvd->dp);
1246
1247 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1248 kfree(uvd->sbuf[i].data);
1249 uvd->sbuf[i].data = NULL;
1250 }
1251
1252#if USBVIDEO_REPORT_STATS
1253 usbvideo_ReportStatistics(uvd);
1254#endif
1255
1256 uvd->user--;
1257 if (uvd->remove_pending) {
1258 if (uvd->debug > 0)
1259 dev_info(&uvd->dev->dev, "%s: Final disconnect.\n",
1260 __func__);
1261 usbvideo_CameraRelease(uvd);
1262 }
1263 mutex_unlock(&uvd->lock);
1264 usbvideo_ClientDecModCount(uvd);
1265
1266 if (uvd->debug > 1)
1267 dev_info(&uvd->dev->dev, "%s: Completed.\n", __func__);
1268 file->private_data = NULL;
1269 return 0;
1270}
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280static long usbvideo_v4l_do_ioctl(struct file *file, unsigned int cmd, void *arg)
1281{
1282 struct uvd *uvd = file->private_data;
1283
1284 if (!CAMERA_IS_OPERATIONAL(uvd))
1285 return -EIO;
1286
1287 switch (cmd) {
1288 case VIDIOCGCAP:
1289 {
1290 struct video_capability *b = arg;
1291 *b = uvd->vcap;
1292 return 0;
1293 }
1294 case VIDIOCGCHAN:
1295 {
1296 struct video_channel *v = arg;
1297 *v = uvd->vchan;
1298 return 0;
1299 }
1300 case VIDIOCSCHAN:
1301 {
1302 struct video_channel *v = arg;
1303 if (v->channel != 0)
1304 return -EINVAL;
1305 return 0;
1306 }
1307 case VIDIOCGPICT:
1308 {
1309 struct video_picture *pic = arg;
1310 *pic = uvd->vpic;
1311 return 0;
1312 }
1313 case VIDIOCSPICT:
1314 {
1315 struct video_picture *pic = arg;
1316
1317
1318
1319
1320
1321 uvd->vpic.brightness = pic->brightness;
1322 uvd->vpic.hue = pic->hue;
1323 uvd->vpic.colour = pic->colour;
1324 uvd->vpic.contrast = pic->contrast;
1325 uvd->settingsAdjusted = 0;
1326 return 0;
1327 }
1328 case VIDIOCSWIN:
1329 {
1330 struct video_window *vw = arg;
1331
1332 if(VALID_CALLBACK(uvd, setVideoMode)) {
1333 return GET_CALLBACK(uvd, setVideoMode)(uvd, vw);
1334 }
1335
1336 if (vw->flags)
1337 return -EINVAL;
1338 if (vw->clipcount)
1339 return -EINVAL;
1340 if (vw->width != VIDEOSIZE_X(uvd->canvas))
1341 return -EINVAL;
1342 if (vw->height != VIDEOSIZE_Y(uvd->canvas))
1343 return -EINVAL;
1344
1345 return 0;
1346 }
1347 case VIDIOCGWIN:
1348 {
1349 struct video_window *vw = arg;
1350
1351 vw->x = 0;
1352 vw->y = 0;
1353 vw->width = VIDEOSIZE_X(uvd->videosize);
1354 vw->height = VIDEOSIZE_Y(uvd->videosize);
1355 vw->chromakey = 0;
1356 if (VALID_CALLBACK(uvd, getFPS))
1357 vw->flags = GET_CALLBACK(uvd, getFPS)(uvd);
1358 else
1359 vw->flags = 10;
1360 return 0;
1361 }
1362 case VIDIOCGMBUF:
1363 {
1364 struct video_mbuf *vm = arg;
1365 int i;
1366
1367 memset(vm, 0, sizeof(*vm));
1368 vm->size = uvd->max_frame_size * USBVIDEO_NUMFRAMES;
1369 vm->frames = USBVIDEO_NUMFRAMES;
1370 for(i = 0; i < USBVIDEO_NUMFRAMES; i++)
1371 vm->offsets[i] = i * uvd->max_frame_size;
1372
1373 return 0;
1374 }
1375 case VIDIOCMCAPTURE:
1376 {
1377 struct video_mmap *vm = arg;
1378
1379 if (uvd->debug >= 1) {
1380 dev_info(&uvd->dev->dev,
1381 "VIDIOCMCAPTURE: frame=%d. size=%dx%d, format=%d.\n",
1382 vm->frame, vm->width, vm->height, vm->format);
1383 }
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397 if ((vm->width > VIDEOSIZE_X(uvd->canvas)) ||
1398 (vm->height > VIDEOSIZE_Y(uvd->canvas))) {
1399 if (uvd->debug > 0) {
1400 dev_info(&uvd->dev->dev,
1401 "VIDIOCMCAPTURE: Size=%dx%d "
1402 "too large; allowed only up "
1403 "to %ldx%ld\n", vm->width,
1404 vm->height,
1405 VIDEOSIZE_X(uvd->canvas),
1406 VIDEOSIZE_Y(uvd->canvas));
1407 }
1408 return -EINVAL;
1409 }
1410
1411 if (((1L << vm->format) & uvd->paletteBits) == 0) {
1412 if (uvd->debug > 0) {
1413 dev_info(&uvd->dev->dev,
1414 "VIDIOCMCAPTURE: format=%d. "
1415 "not supported "
1416 "(paletteBits=$%08lx)\n",
1417 vm->format, uvd->paletteBits);
1418 }
1419 return -EINVAL;
1420 }
1421 if ((vm->frame < 0) || (vm->frame >= USBVIDEO_NUMFRAMES)) {
1422 err("VIDIOCMCAPTURE: vm.frame=%d. !E [0-%d]", vm->frame, USBVIDEO_NUMFRAMES-1);
1423 return -EINVAL;
1424 }
1425 if (uvd->frame[vm->frame].frameState == FrameState_Grabbing) {
1426
1427 }
1428 uvd->frame[vm->frame].request = VIDEOSIZE(vm->width, vm->height);
1429 uvd->frame[vm->frame].palette = vm->format;
1430
1431
1432 uvd->frame[vm->frame].frameState = FrameState_Ready;
1433
1434 return usbvideo_NewFrame(uvd, vm->frame);
1435 }
1436 case VIDIOCSYNC:
1437 {
1438 int *frameNum = arg;
1439 int ret;
1440
1441 if (*frameNum < 0 || *frameNum >= USBVIDEO_NUMFRAMES)
1442 return -EINVAL;
1443
1444 if (uvd->debug >= 1)
1445 dev_info(&uvd->dev->dev,
1446 "VIDIOCSYNC: syncing to frame %d.\n",
1447 *frameNum);
1448 if (uvd->flags & FLAGS_NO_DECODING)
1449 ret = usbvideo_GetFrame(uvd, *frameNum);
1450 else if (VALID_CALLBACK(uvd, getFrame)) {
1451 ret = GET_CALLBACK(uvd, getFrame)(uvd, *frameNum);
1452 if ((ret < 0) && (uvd->debug >= 1)) {
1453 err("VIDIOCSYNC: getFrame() returned %d.", ret);
1454 }
1455 } else {
1456 err("VIDIOCSYNC: getFrame is not set");
1457 ret = -EFAULT;
1458 }
1459
1460
1461
1462
1463
1464
1465
1466 uvd->frame[*frameNum].frameState = FrameState_Unused;
1467 return ret;
1468 }
1469 case VIDIOCGFBUF:
1470 {
1471 struct video_buffer *vb = arg;
1472
1473 memset(vb, 0, sizeof(*vb));
1474 return 0;
1475 }
1476 case VIDIOCKEY:
1477 return 0;
1478
1479 case VIDIOCCAPTURE:
1480 return -EINVAL;
1481
1482 case VIDIOCSFBUF:
1483
1484 case VIDIOCGTUNER:
1485 case VIDIOCSTUNER:
1486
1487 case VIDIOCGFREQ:
1488 case VIDIOCSFREQ:
1489
1490 case VIDIOCGAUDIO:
1491 case VIDIOCSAUDIO:
1492 return -EINVAL;
1493
1494 default:
1495 return -ENOIOCTLCMD;
1496 }
1497 return 0;
1498}
1499
1500static long usbvideo_v4l_ioctl(struct file *file,
1501 unsigned int cmd, unsigned long arg)
1502{
1503 return video_usercopy(file, cmd, arg, usbvideo_v4l_do_ioctl);
1504}
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517static ssize_t usbvideo_v4l_read(struct file *file, char __user *buf,
1518 size_t count, loff_t *ppos)
1519{
1520 struct uvd *uvd = file->private_data;
1521 int noblock = file->f_flags & O_NONBLOCK;
1522 int frmx = -1, i;
1523 struct usbvideo_frame *frame;
1524
1525 if (!CAMERA_IS_OPERATIONAL(uvd) || (buf == NULL))
1526 return -EFAULT;
1527
1528 if (uvd->debug >= 1)
1529 dev_info(&uvd->dev->dev,
1530 "%s: %Zd. bytes, noblock=%d.\n",
1531 __func__, count, noblock);
1532
1533 mutex_lock(&uvd->lock);
1534
1535
1536 for(i = 0; i < USBVIDEO_NUMFRAMES; i++) {
1537 if ((uvd->frame[i].frameState == FrameState_Done) ||
1538 (uvd->frame[i].frameState == FrameState_Done_Hold) ||
1539 (uvd->frame[i].frameState == FrameState_Error)) {
1540 frmx = i;
1541 break;
1542 }
1543 }
1544
1545
1546 if (noblock && (frmx == -1)) {
1547 count = -EAGAIN;
1548 goto read_done;
1549 }
1550
1551
1552
1553
1554
1555
1556 if (frmx == -1) {
1557 for(i = 0; i < USBVIDEO_NUMFRAMES; i++) {
1558 if (uvd->frame[i].frameState == FrameState_Grabbing) {
1559 frmx = i;
1560 break;
1561 }
1562 }
1563 }
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576 if (frmx == -1) {
1577 if (uvd->defaultPalette == 0) {
1578 err("%s: No default palette; don't know what to do!", __func__);
1579 count = -EFAULT;
1580 goto read_done;
1581 }
1582 frmx = 0;
1583
1584
1585
1586
1587
1588 uvd->frame[frmx].request = uvd->videosize;
1589 uvd->frame[frmx].palette = uvd->defaultPalette;
1590 uvd->frame[frmx].frameState = FrameState_Ready;
1591 usbvideo_NewFrame(uvd, frmx);
1592
1593 }
1594
1595
1596
1597
1598
1599 frame = &uvd->frame[frmx];
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609 if (frame->frameState != FrameState_Done_Hold) {
1610 long rv = -EFAULT;
1611 if (uvd->flags & FLAGS_NO_DECODING)
1612 rv = usbvideo_GetFrame(uvd, frmx);
1613 else if (VALID_CALLBACK(uvd, getFrame))
1614 rv = GET_CALLBACK(uvd, getFrame)(uvd, frmx);
1615 else
1616 err("getFrame is not set");
1617 if ((rv != 0) || (frame->frameState != FrameState_Done_Hold)) {
1618 count = rv;
1619 goto read_done;
1620 }
1621 }
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633 if ((count + frame->seqRead_Index) > frame->seqRead_Length)
1634 count = frame->seqRead_Length - frame->seqRead_Index;
1635
1636
1637
1638
1639
1640
1641 if (copy_to_user(buf, frame->data + frame->seqRead_Index, count)) {
1642 count = -EFAULT;
1643 goto read_done;
1644 }
1645
1646
1647 frame->seqRead_Index += count;
1648 if (uvd->debug >= 1) {
1649 err("%s: {copy} count used=%Zd, new seqRead_Index=%ld",
1650 __func__, count, frame->seqRead_Index);
1651 }
1652
1653
1654 if (frame->seqRead_Index >= frame->seqRead_Length) {
1655
1656 frame->seqRead_Index = 0;
1657
1658
1659 uvd->frame[frmx].frameState = FrameState_Unused;
1660 if (usbvideo_NewFrame(uvd, (frmx + 1) % USBVIDEO_NUMFRAMES)) {
1661 err("%s: usbvideo_NewFrame failed.", __func__);
1662 }
1663 }
1664read_done:
1665 mutex_unlock(&uvd->lock);
1666 return count;
1667}
1668
1669
1670
1671
1672static int usbvideo_CompressIsochronous(struct uvd *uvd, struct urb *urb)
1673{
1674 char *cdata;
1675 int i, totlen = 0;
1676
1677 for (i = 0; i < urb->number_of_packets; i++) {
1678 int n = urb->iso_frame_desc[i].actual_length;
1679 int st = urb->iso_frame_desc[i].status;
1680
1681 cdata = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
1682
1683
1684 if (st < 0) {
1685 if (uvd->debug >= 1)
1686 err("Data error: packet=%d. len=%d. status=%d.", i, n, st);
1687 uvd->stats.iso_err_count++;
1688 continue;
1689 }
1690
1691
1692 if (n <= 0) {
1693 uvd->stats.iso_skip_count++;
1694 continue;
1695 }
1696 totlen += n;
1697 RingQueue_Enqueue(&uvd->dp, cdata, n);
1698 }
1699 return totlen;
1700}
1701
1702static void usbvideo_IsocIrq(struct urb *urb)
1703{
1704 int i, ret, len;
1705 struct uvd *uvd = urb->context;
1706
1707
1708 if (!CAMERA_IS_OPERATIONAL(uvd))
1709 return;
1710#if 0
1711 if (urb->actual_length > 0) {
1712 dev_info(&uvd->dev->dev,
1713 "urb=$%p status=%d. errcount=%d. length=%d.\n",
1714 urb, urb->status, urb->error_count,
1715 urb->actual_length);
1716 } else {
1717 static int c = 0;
1718 if (c++ % 100 == 0)
1719 dev_info(&uvd->dev->dev, "No Isoc data\n");
1720 }
1721#endif
1722
1723 if (!uvd->streaming) {
1724 if (uvd->debug >= 1)
1725 dev_info(&uvd->dev->dev,
1726 "Not streaming, but interrupt!\n");
1727 return;
1728 }
1729
1730 uvd->stats.urb_count++;
1731 if (urb->actual_length <= 0)
1732 goto urb_done_with;
1733
1734
1735 len = usbvideo_CompressIsochronous(uvd, urb);
1736 uvd->stats.urb_length = len;
1737 if (len <= 0)
1738 goto urb_done_with;
1739
1740
1741 uvd->stats.data_count += len;
1742 RingQueue_WakeUpInterruptible(&uvd->dp);
1743
1744urb_done_with:
1745 for (i = 0; i < FRAMES_PER_DESC; i++) {
1746 urb->iso_frame_desc[i].status = 0;
1747 urb->iso_frame_desc[i].actual_length = 0;
1748 }
1749 urb->status = 0;
1750 urb->dev = uvd->dev;
1751 ret = usb_submit_urb (urb, GFP_KERNEL);
1752 if(ret)
1753 err("usb_submit_urb error (%d)", ret);
1754 return;
1755}
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765static int usbvideo_StartDataPump(struct uvd *uvd)
1766{
1767 struct usb_device *dev = uvd->dev;
1768 int i, errFlag;
1769
1770 if (uvd->debug > 1)
1771 dev_info(&uvd->dev->dev, "%s($%p)\n", __func__, uvd);
1772
1773 if (!CAMERA_IS_OPERATIONAL(uvd)) {
1774 err("%s: Camera is not operational", __func__);
1775 return -EFAULT;
1776 }
1777 uvd->curframe = -1;
1778
1779
1780 i = usb_set_interface(dev, uvd->iface, uvd->ifaceAltActive);
1781 if (i < 0) {
1782 err("%s: usb_set_interface error", __func__);
1783 uvd->last_error = i;
1784 return -EBUSY;
1785 }
1786 if (VALID_CALLBACK(uvd, videoStart))
1787 GET_CALLBACK(uvd, videoStart)(uvd);
1788 else
1789 err("%s: videoStart not set", __func__);
1790
1791
1792 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1793 int j, k;
1794 struct urb *urb = uvd->sbuf[i].urb;
1795 urb->dev = dev;
1796 urb->context = uvd;
1797 urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp);
1798 urb->interval = 1;
1799 urb->transfer_flags = URB_ISO_ASAP;
1800 urb->transfer_buffer = uvd->sbuf[i].data;
1801 urb->complete = usbvideo_IsocIrq;
1802 urb->number_of_packets = FRAMES_PER_DESC;
1803 urb->transfer_buffer_length = uvd->iso_packet_len * FRAMES_PER_DESC;
1804 for (j=k=0; j < FRAMES_PER_DESC; j++, k += uvd->iso_packet_len) {
1805 urb->iso_frame_desc[j].offset = k;
1806 urb->iso_frame_desc[j].length = uvd->iso_packet_len;
1807 }
1808 }
1809
1810
1811 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1812 errFlag = usb_submit_urb(uvd->sbuf[i].urb, GFP_KERNEL);
1813 if (errFlag)
1814 err("%s: usb_submit_isoc(%d) ret %d", __func__, i, errFlag);
1815 }
1816
1817 uvd->streaming = 1;
1818 if (uvd->debug > 1)
1819 dev_info(&uvd->dev->dev,
1820 "%s: streaming=1 video_endp=$%02x\n", __func__,
1821 uvd->video_endp);
1822 return 0;
1823}
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835static void usbvideo_StopDataPump(struct uvd *uvd)
1836{
1837 int i, j;
1838
1839 if ((uvd == NULL) || (!uvd->streaming) || (uvd->dev == NULL))
1840 return;
1841
1842 if (uvd->debug > 1)
1843 dev_info(&uvd->dev->dev, "%s($%p)\n", __func__, uvd);
1844
1845
1846 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1847 usb_kill_urb(uvd->sbuf[i].urb);
1848 }
1849 if (uvd->debug > 1)
1850 dev_info(&uvd->dev->dev, "%s: streaming=0\n", __func__);
1851 uvd->streaming = 0;
1852
1853 if (!uvd->remove_pending) {
1854
1855 if (VALID_CALLBACK(uvd, videoStop))
1856 GET_CALLBACK(uvd, videoStop)(uvd);
1857 else
1858 err("%s: videoStop not set", __func__);
1859
1860
1861 j = usb_set_interface(uvd->dev, uvd->iface, uvd->ifaceAltInactive);
1862 if (j < 0) {
1863 err("%s: usb_set_interface() error %d.", __func__, j);
1864 uvd->last_error = j;
1865 }
1866 }
1867}
1868
1869
1870
1871
1872
1873
1874
1875
1876static int usbvideo_NewFrame(struct uvd *uvd, int framenum)
1877{
1878 struct usbvideo_frame *frame;
1879 int n;
1880
1881 if (uvd->debug > 1)
1882 dev_info(&uvd->dev->dev, "usbvideo_NewFrame($%p,%d.)\n", uvd,
1883 framenum);
1884
1885
1886
1887 if (uvd->curframe != -1)
1888 return 0;
1889
1890
1891 if (!uvd->settingsAdjusted) {
1892 if (VALID_CALLBACK(uvd, adjustPicture))
1893 GET_CALLBACK(uvd, adjustPicture)(uvd);
1894 uvd->settingsAdjusted = 1;
1895 }
1896
1897 n = (framenum + 1) % USBVIDEO_NUMFRAMES;
1898 if (uvd->frame[n].frameState == FrameState_Ready)
1899 framenum = n;
1900
1901 frame = &uvd->frame[framenum];
1902
1903 frame->frameState = FrameState_Grabbing;
1904 frame->scanstate = ScanState_Scanning;
1905 frame->seqRead_Length = 0;
1906 frame->deinterlace = Deinterlace_None;
1907 frame->flags = 0;
1908 uvd->curframe = framenum;
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927 if (!(uvd->flags & FLAGS_SEPARATE_FRAMES)) {
1928
1929 int prev = (framenum - 1 + USBVIDEO_NUMFRAMES) % USBVIDEO_NUMFRAMES;
1930 memmove(frame->data, uvd->frame[prev].data, uvd->max_frame_size);
1931 } else {
1932 if (uvd->flags & FLAGS_CLEAN_FRAMES) {
1933
1934 memset(frame->data, 0, uvd->max_frame_size);
1935 }
1936 }
1937 return 0;
1938}
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953static void usbvideo_CollectRawData(struct uvd *uvd, struct usbvideo_frame *frame)
1954{
1955 int n;
1956
1957 assert(uvd != NULL);
1958 assert(frame != NULL);
1959
1960
1961 n = RingQueue_GetLength(&uvd->dp);
1962 if (n > 0) {
1963 int m;
1964
1965 m = uvd->max_frame_size - frame->seqRead_Length;
1966 if (n > m)
1967 n = m;
1968
1969 RingQueue_Dequeue(
1970 &uvd->dp,
1971 frame->data + frame->seqRead_Length,
1972 m);
1973 frame->seqRead_Length += m;
1974 }
1975
1976 if (frame->seqRead_Length >= uvd->max_frame_size) {
1977 frame->frameState = FrameState_Done;
1978 uvd->curframe = -1;
1979 uvd->stats.frame_num++;
1980 }
1981}
1982
1983static int usbvideo_GetFrame(struct uvd *uvd, int frameNum)
1984{
1985 struct usbvideo_frame *frame = &uvd->frame[frameNum];
1986
1987 if (uvd->debug >= 2)
1988 dev_info(&uvd->dev->dev, "%s($%p,%d.)\n", __func__, uvd,
1989 frameNum);
1990
1991 switch (frame->frameState) {
1992 case FrameState_Unused:
1993 if (uvd->debug >= 2)
1994 dev_info(&uvd->dev->dev, "%s: FrameState_Unused\n",
1995 __func__);
1996 return -EINVAL;
1997 case FrameState_Ready:
1998 case FrameState_Grabbing:
1999 case FrameState_Error:
2000 {
2001 int ntries, signalPending;
2002 redo:
2003 if (!CAMERA_IS_OPERATIONAL(uvd)) {
2004 if (uvd->debug >= 2)
2005 dev_info(&uvd->dev->dev,
2006 "%s: Camera is not operational (1)\n",
2007 __func__);
2008 return -EIO;
2009 }
2010 ntries = 0;
2011 do {
2012 RingQueue_InterruptibleSleepOn(&uvd->dp);
2013 signalPending = signal_pending(current);
2014 if (!CAMERA_IS_OPERATIONAL(uvd)) {
2015 if (uvd->debug >= 2)
2016 dev_info(&uvd->dev->dev,
2017 "%s: Camera is not "
2018 "operational (2)\n", __func__);
2019 return -EIO;
2020 }
2021 assert(uvd->fbuf != NULL);
2022 if (signalPending) {
2023 if (uvd->debug >= 2)
2024 dev_info(&uvd->dev->dev,
2025 "%s: Signal=$%08x\n", __func__,
2026 signalPending);
2027 if (uvd->flags & FLAGS_RETRY_VIDIOCSYNC) {
2028 usbvideo_TestPattern(uvd, 1, 0);
2029 uvd->curframe = -1;
2030 uvd->stats.frame_num++;
2031 if (uvd->debug >= 2)
2032 dev_info(&uvd->dev->dev,
2033 "%s: Forced test "
2034 "pattern screen\n",
2035 __func__);
2036 return 0;
2037 } else {
2038
2039 if (uvd->debug >= 2)
2040 dev_info(&uvd->dev->dev,
2041 "%s: Interrupted!\n",
2042 __func__);
2043 return -EINTR;
2044 }
2045 } else {
2046
2047 if (uvd->flags & FLAGS_NO_DECODING)
2048 usbvideo_CollectRawData(uvd, frame);
2049 else if (VALID_CALLBACK(uvd, processData))
2050 GET_CALLBACK(uvd, processData)(uvd, frame);
2051 else
2052 err("%s: processData not set", __func__);
2053 }
2054 } while (frame->frameState == FrameState_Grabbing);
2055 if (uvd->debug >= 2) {
2056 dev_info(&uvd->dev->dev,
2057 "%s: Grabbing done; state=%d. (%lu. bytes)\n",
2058 __func__, frame->frameState,
2059 frame->seqRead_Length);
2060 }
2061 if (frame->frameState == FrameState_Error) {
2062 int ret = usbvideo_NewFrame(uvd, frameNum);
2063 if (ret < 0) {
2064 err("%s: usbvideo_NewFrame() failed (%d.)", __func__, ret);
2065 return ret;
2066 }
2067 goto redo;
2068 }
2069
2070 }
2071 case FrameState_Done:
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087 uvd->stats.frame_num++;
2088 if ((uvd->flags & FLAGS_NO_DECODING) == 0) {
2089 if (VALID_CALLBACK(uvd, postProcess))
2090 GET_CALLBACK(uvd, postProcess)(uvd, frame);
2091 if (frame->flags & USBVIDEO_FRAME_FLAG_SOFTWARE_CONTRAST)
2092 usbvideo_SoftwareContrastAdjustment(uvd, frame);
2093 }
2094 frame->frameState = FrameState_Done_Hold;
2095 if (uvd->debug >= 2)
2096 dev_info(&uvd->dev->dev,
2097 "%s: Entered FrameState_Done_Hold state.\n",
2098 __func__);
2099 return 0;
2100
2101 case FrameState_Done_Hold:
2102
2103
2104
2105
2106
2107
2108 if (uvd->debug >= 2)
2109 dev_info(&uvd->dev->dev,
2110 "%s: FrameState_Done_Hold state.\n",
2111 __func__);
2112 return 0;
2113 }
2114
2115
2116 err("%s: Invalid state %d.", __func__, frame->frameState);
2117 frame->frameState = FrameState_Unused;
2118 return 0;
2119}
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134void usbvideo_DeinterlaceFrame(struct uvd *uvd, struct usbvideo_frame *frame)
2135{
2136 if ((uvd == NULL) || (frame == NULL))
2137 return;
2138
2139 if ((frame->deinterlace == Deinterlace_FillEvenLines) ||
2140 (frame->deinterlace == Deinterlace_FillOddLines))
2141 {
2142 const int v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL;
2143 int i = (frame->deinterlace == Deinterlace_FillEvenLines) ? 0 : 1;
2144
2145 for (; i < VIDEOSIZE_Y(frame->request); i += 2) {
2146 const unsigned char *fs1, *fs2;
2147 unsigned char *fd;
2148 int ip, in, j;
2149
2150
2151
2152
2153
2154
2155 ip = i - 1;
2156 in = i + 1;
2157
2158
2159 if (ip < 0)
2160 ip = in;
2161 if (in >= VIDEOSIZE_Y(frame->request))
2162 in = ip;
2163
2164
2165 if ((ip < 0) || (in < 0) ||
2166 (ip >= VIDEOSIZE_Y(frame->request)) ||
2167 (in >= VIDEOSIZE_Y(frame->request)))
2168 {
2169 err("Error: ip=%d. in=%d. req.height=%ld.",
2170 ip, in, VIDEOSIZE_Y(frame->request));
2171 break;
2172 }
2173
2174
2175 fs1 = frame->data + (v4l_linesize * ip);
2176 fs2 = frame->data + (v4l_linesize * in);
2177 fd = frame->data + (v4l_linesize * i);
2178
2179
2180 for (j=0; j < v4l_linesize; j++) {
2181 fd[j] = (unsigned char)((((unsigned) fs1[j]) +
2182 ((unsigned)fs2[j])) >> 1);
2183 }
2184 }
2185 }
2186
2187
2188 if (uvd->flags & FLAGS_OVERLAY_STATS)
2189 usbvideo_OverlayStats(uvd, frame);
2190}
2191
2192EXPORT_SYMBOL(usbvideo_DeinterlaceFrame);
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204static void usbvideo_SoftwareContrastAdjustment(struct uvd *uvd,
2205 struct usbvideo_frame *frame)
2206{
2207 int i, j, v4l_linesize;
2208 signed long adj;
2209 const int ccm = 128;
2210
2211 if ((uvd == NULL) || (frame == NULL)) {
2212 err("%s: Illegal call.", __func__);
2213 return;
2214 }
2215 adj = (uvd->vpic.contrast - 0x8000) >> 8;
2216 RESTRICT_TO_RANGE(adj, -ccm, ccm+1);
2217 if (adj == 0) {
2218
2219 return;
2220 }
2221 v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL;
2222 for (i=0; i < VIDEOSIZE_Y(frame->request); i++) {
2223 unsigned char *fd = frame->data + (v4l_linesize * i);
2224 for (j=0; j < v4l_linesize; j++) {
2225 signed long v = (signed long) fd[j];
2226
2227 v = 128 + ((ccm + adj) * (v - 128)) / ccm;
2228 RESTRICT_TO_RANGE(v, 0, 0xFF);
2229 fd[j] = (unsigned char) v;
2230 }
2231 }
2232}
2233
2234MODULE_LICENSE("GPL");
2235