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