aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/media/usbvideo.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/usb/media/usbvideo.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'drivers/usb/media/usbvideo.c')
-rw-r--r--drivers/usb/media/usbvideo.c2192
1 files changed, 2192 insertions, 0 deletions
diff --git a/drivers/usb/media/usbvideo.c b/drivers/usb/media/usbvideo.c
new file mode 100644
index 000000000000..298484aa27d2
--- /dev/null
+++ b/drivers/usb/media/usbvideo.c
@@ -0,0 +1,2192 @@
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2, or (at your option)
5 * any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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/smp_lock.h>
24#include <linux/vmalloc.h>
25#include <linux/init.h>
26#include <linux/spinlock.h>
27
28#include <asm/io.h>
29
30#include "usbvideo.h"
31
32#if defined(MAP_NR)
33#define virt_to_page(v) MAP_NR(v) /* Kernels 2.2.x */
34#endif
35
36static int video_nr = -1;
37module_param(video_nr, int, 0);
38
39/*
40 * Local prototypes.
41 */
42static void usbvideo_Disconnect(struct usb_interface *intf);
43static void usbvideo_CameraRelease(struct uvd *uvd);
44
45static int usbvideo_v4l_ioctl(struct inode *inode, struct file *file,
46 unsigned int cmd, unsigned long arg);
47static int usbvideo_v4l_mmap(struct file *file, struct vm_area_struct *vma);
48static int usbvideo_v4l_open(struct inode *inode, struct file *file);
49static ssize_t usbvideo_v4l_read(struct file *file, char __user *buf,
50 size_t count, loff_t *ppos);
51static int usbvideo_v4l_close(struct inode *inode, struct file *file);
52
53static int usbvideo_StartDataPump(struct uvd *uvd);
54static void usbvideo_StopDataPump(struct uvd *uvd);
55static int usbvideo_GetFrame(struct uvd *uvd, int frameNum);
56static int usbvideo_NewFrame(struct uvd *uvd, int framenum);
57static void usbvideo_SoftwareContrastAdjustment(struct uvd *uvd,
58 struct usbvideo_frame *frame);
59
60/*******************************/
61/* Memory management functions */
62/*******************************/
63static void *usbvideo_rvmalloc(unsigned long size)
64{
65 void *mem;
66 unsigned long adr;
67
68 size = PAGE_ALIGN(size);
69 mem = vmalloc_32(size);
70 if (!mem)
71 return NULL;
72
73 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
74 adr = (unsigned long) mem;
75 while (size > 0) {
76 SetPageReserved(vmalloc_to_page((void *)adr));
77 adr += PAGE_SIZE;
78 size -= PAGE_SIZE;
79 }
80
81 return mem;
82}
83
84static void usbvideo_rvfree(void *mem, unsigned long size)
85{
86 unsigned long adr;
87
88 if (!mem)
89 return;
90
91 adr = (unsigned long) mem;
92 while ((long) size > 0) {
93 ClearPageReserved(vmalloc_to_page((void *)adr));
94 adr += PAGE_SIZE;
95 size -= PAGE_SIZE;
96 }
97 vfree(mem);
98}
99
100static void RingQueue_Initialize(struct RingQueue *rq)
101{
102 assert(rq != NULL);
103 init_waitqueue_head(&rq->wqh);
104}
105
106static void RingQueue_Allocate(struct RingQueue *rq, int rqLen)
107{
108 /* Make sure the requested size is a power of 2 and
109 round up if necessary. This allows index wrapping
110 using masks rather than modulo */
111
112 int i = 1;
113 assert(rq != NULL);
114 assert(rqLen > 0);
115
116 while(rqLen >> i)
117 i++;
118 if(rqLen != 1 << (i-1))
119 rqLen = 1 << i;
120
121 rq->length = rqLen;
122 rq->ri = rq->wi = 0;
123 rq->queue = usbvideo_rvmalloc(rq->length);
124 assert(rq->queue != NULL);
125}
126
127static int RingQueue_IsAllocated(const struct RingQueue *rq)
128{
129 if (rq == NULL)
130 return 0;
131 return (rq->queue != NULL) && (rq->length > 0);
132}
133
134static void RingQueue_Free(struct RingQueue *rq)
135{
136 assert(rq != NULL);
137 if (RingQueue_IsAllocated(rq)) {
138 usbvideo_rvfree(rq->queue, rq->length);
139 rq->queue = NULL;
140 rq->length = 0;
141 }
142}
143
144int RingQueue_Dequeue(struct RingQueue *rq, unsigned char *dst, int len)
145{
146 int rql, toread;
147
148 assert(rq != NULL);
149 assert(dst != NULL);
150
151 rql = RingQueue_GetLength(rq);
152 if(!rql)
153 return 0;
154
155 /* Clip requested length to available data */
156 if(len > rql)
157 len = rql;
158
159 toread = len;
160 if(rq->ri > rq->wi) {
161 /* Read data from tail */
162 int read = (toread < (rq->length - rq->ri)) ? toread : rq->length - rq->ri;
163 memcpy(dst, rq->queue + rq->ri, read);
164 toread -= read;
165 dst += read;
166 rq->ri = (rq->ri + read) & (rq->length-1);
167 }
168 if(toread) {
169 /* Read data from head */
170 memcpy(dst, rq->queue + rq->ri, toread);
171 rq->ri = (rq->ri + toread) & (rq->length-1);
172 }
173 return len;
174}
175
176EXPORT_SYMBOL(RingQueue_Dequeue);
177
178int RingQueue_Enqueue(struct RingQueue *rq, const unsigned char *cdata, int n)
179{
180 int enqueued = 0;
181
182 assert(rq != NULL);
183 assert(cdata != NULL);
184 assert(rq->length > 0);
185 while (n > 0) {
186 int m, q_avail;
187
188 /* Calculate the largest chunk that fits the tail of the ring */
189 q_avail = rq->length - rq->wi;
190 if (q_avail <= 0) {
191 rq->wi = 0;
192 q_avail = rq->length;
193 }
194 m = n;
195 assert(q_avail > 0);
196 if (m > q_avail)
197 m = q_avail;
198
199 memcpy(rq->queue + rq->wi, cdata, m);
200 RING_QUEUE_ADVANCE_INDEX(rq, wi, m);
201 cdata += m;
202 enqueued += m;
203 n -= m;
204 }
205 return enqueued;
206}
207
208EXPORT_SYMBOL(RingQueue_Enqueue);
209
210static void RingQueue_InterruptibleSleepOn(struct RingQueue *rq)
211{
212 assert(rq != NULL);
213 interruptible_sleep_on(&rq->wqh);
214}
215
216void RingQueue_WakeUpInterruptible(struct RingQueue *rq)
217{
218 assert(rq != NULL);
219 if (waitqueue_active(&rq->wqh))
220 wake_up_interruptible(&rq->wqh);
221}
222
223EXPORT_SYMBOL(RingQueue_WakeUpInterruptible);
224
225void RingQueue_Flush(struct RingQueue *rq)
226{
227 assert(rq != NULL);
228 rq->ri = 0;
229 rq->wi = 0;
230}
231
232EXPORT_SYMBOL(RingQueue_Flush);
233
234
235/*
236 * usbvideo_VideosizeToString()
237 *
238 * This procedure converts given videosize value to readable string.
239 *
240 * History:
241 * 07-Aug-2000 Created.
242 * 19-Oct-2000 Reworked for usbvideo module.
243 */
244static void usbvideo_VideosizeToString(char *buf, int bufLen, videosize_t vs)
245{
246 char tmp[40];
247 int n;
248
249 n = 1 + sprintf(tmp, "%ldx%ld", VIDEOSIZE_X(vs), VIDEOSIZE_Y(vs));
250 assert(n < sizeof(tmp));
251 if ((buf == NULL) || (bufLen < n))
252 err("usbvideo_VideosizeToString: buffer is too small.");
253 else
254 memmove(buf, tmp, n);
255}
256
257/*
258 * usbvideo_OverlayChar()
259 *
260 * History:
261 * 01-Feb-2000 Created.
262 */
263static void usbvideo_OverlayChar(struct uvd *uvd, struct usbvideo_frame *frame,
264 int x, int y, int ch)
265{
266 static const unsigned short digits[16] = {
267 0xF6DE, /* 0 */
268 0x2492, /* 1 */
269 0xE7CE, /* 2 */
270 0xE79E, /* 3 */
271 0xB792, /* 4 */
272 0xF39E, /* 5 */
273 0xF3DE, /* 6 */
274 0xF492, /* 7 */
275 0xF7DE, /* 8 */
276 0xF79E, /* 9 */
277 0x77DA, /* a */
278 0xD75C, /* b */
279 0xF24E, /* c */
280 0xD6DC, /* d */
281 0xF34E, /* e */
282 0xF348 /* f */
283 };
284 unsigned short digit;
285 int ix, iy;
286
287 if ((uvd == NULL) || (frame == NULL))
288 return;
289
290 if (ch >= '0' && ch <= '9')
291 ch -= '0';
292 else if (ch >= 'A' && ch <= 'F')
293 ch = 10 + (ch - 'A');
294 else if (ch >= 'a' && ch <= 'f')
295 ch = 10 + (ch - 'a');
296 else
297 return;
298 digit = digits[ch];
299
300 for (iy=0; iy < 5; iy++) {
301 for (ix=0; ix < 3; ix++) {
302 if (digit & 0x8000) {
303 if (uvd->paletteBits & (1L << VIDEO_PALETTE_RGB24)) {
304/* TODO */ RGB24_PUTPIXEL(frame, x+ix, y+iy, 0xFF, 0xFF, 0xFF);
305 }
306 }
307 digit = digit << 1;
308 }
309 }
310}
311
312/*
313 * usbvideo_OverlayString()
314 *
315 * History:
316 * 01-Feb-2000 Created.
317 */
318static void usbvideo_OverlayString(struct uvd *uvd, struct usbvideo_frame *frame,
319 int x, int y, const char *str)
320{
321 while (*str) {
322 usbvideo_OverlayChar(uvd, frame, x, y, *str);
323 str++;
324 x += 4; /* 3 pixels character + 1 space */
325 }
326}
327
328/*
329 * usbvideo_OverlayStats()
330 *
331 * Overlays important debugging information.
332 *
333 * History:
334 * 01-Feb-2000 Created.
335 */
336static void usbvideo_OverlayStats(struct uvd *uvd, struct usbvideo_frame *frame)
337{
338 const int y_diff = 8;
339 char tmp[16];
340 int x = 10, y=10;
341 long i, j, barLength;
342 const int qi_x1 = 60, qi_y1 = 10;
343 const int qi_x2 = VIDEOSIZE_X(frame->request) - 10, qi_h = 10;
344
345 /* Call the user callback, see if we may proceed after that */
346 if (VALID_CALLBACK(uvd, overlayHook)) {
347 if (GET_CALLBACK(uvd, overlayHook)(uvd, frame) < 0)
348 return;
349 }
350
351 /*
352 * We draw a (mostly) hollow rectangle with qi_xxx coordinates.
353 * Left edge symbolizes the queue index 0; right edge symbolizes
354 * the full capacity of the queue.
355 */
356 barLength = qi_x2 - qi_x1 - 2;
357 if ((barLength > 10) && (uvd->paletteBits & (1L << VIDEO_PALETTE_RGB24))) {
358/* TODO */ long u_lo, u_hi, q_used;
359 long m_ri, m_wi, m_lo, m_hi;
360
361 /*
362 * Determine fill zones (used areas of the queue):
363 * 0 xxxxxxx u_lo ...... uvd->dp.ri xxxxxxxx u_hi ..... uvd->dp.length
364 *
365 * if u_lo < 0 then there is no first filler.
366 */
367
368 q_used = RingQueue_GetLength(&uvd->dp);
369 if ((uvd->dp.ri + q_used) >= uvd->dp.length) {
370 u_hi = uvd->dp.length;
371 u_lo = (q_used + uvd->dp.ri) & (uvd->dp.length-1);
372 } else {
373 u_hi = (q_used + uvd->dp.ri);
374 u_lo = -1;
375 }
376
377 /* Convert byte indices into screen units */
378 m_ri = qi_x1 + ((barLength * uvd->dp.ri) / uvd->dp.length);
379 m_wi = qi_x1 + ((barLength * uvd->dp.wi) / uvd->dp.length);
380 m_lo = (u_lo > 0) ? (qi_x1 + ((barLength * u_lo) / uvd->dp.length)) : -1;
381 m_hi = qi_x1 + ((barLength * u_hi) / uvd->dp.length);
382
383 for (j=qi_y1; j < (qi_y1 + qi_h); j++) {
384 for (i=qi_x1; i < qi_x2; i++) {
385 /* Draw border lines */
386 if ((j == qi_y1) || (j == (qi_y1 + qi_h - 1)) ||
387 (i == qi_x1) || (i == (qi_x2 - 1))) {
388 RGB24_PUTPIXEL(frame, i, j, 0xFF, 0xFF, 0xFF);
389 continue;
390 }
391 /* For all other points the Y coordinate does not matter */
392 if ((i >= m_ri) && (i <= (m_ri + 3))) {
393 RGB24_PUTPIXEL(frame, i, j, 0x00, 0xFF, 0x00);
394 } else if ((i >= m_wi) && (i <= (m_wi + 3))) {
395 RGB24_PUTPIXEL(frame, i, j, 0xFF, 0x00, 0x00);
396 } else if ((i < m_lo) || ((i > m_ri) && (i < m_hi)))
397 RGB24_PUTPIXEL(frame, i, j, 0x00, 0x00, 0xFF);
398 }
399 }
400 }
401
402 sprintf(tmp, "%8lx", uvd->stats.frame_num);
403 usbvideo_OverlayString(uvd, frame, x, y, tmp);
404 y += y_diff;
405
406 sprintf(tmp, "%8lx", uvd->stats.urb_count);
407 usbvideo_OverlayString(uvd, frame, x, y, tmp);
408 y += y_diff;
409
410 sprintf(tmp, "%8lx", uvd->stats.urb_length);
411 usbvideo_OverlayString(uvd, frame, x, y, tmp);
412 y += y_diff;
413
414 sprintf(tmp, "%8lx", uvd->stats.data_count);
415 usbvideo_OverlayString(uvd, frame, x, y, tmp);
416 y += y_diff;
417
418 sprintf(tmp, "%8lx", uvd->stats.header_count);
419 usbvideo_OverlayString(uvd, frame, x, y, tmp);
420 y += y_diff;
421
422 sprintf(tmp, "%8lx", uvd->stats.iso_skip_count);
423 usbvideo_OverlayString(uvd, frame, x, y, tmp);
424 y += y_diff;
425
426 sprintf(tmp, "%8lx", uvd->stats.iso_err_count);
427 usbvideo_OverlayString(uvd, frame, x, y, tmp);
428 y += y_diff;
429
430 sprintf(tmp, "%8x", uvd->vpic.colour);
431 usbvideo_OverlayString(uvd, frame, x, y, tmp);
432 y += y_diff;
433
434 sprintf(tmp, "%8x", uvd->vpic.hue);
435 usbvideo_OverlayString(uvd, frame, x, y, tmp);
436 y += y_diff;
437
438 sprintf(tmp, "%8x", uvd->vpic.brightness >> 8);
439 usbvideo_OverlayString(uvd, frame, x, y, tmp);
440 y += y_diff;
441
442 sprintf(tmp, "%8x", uvd->vpic.contrast >> 12);
443 usbvideo_OverlayString(uvd, frame, x, y, tmp);
444 y += y_diff;
445
446 sprintf(tmp, "%8d", uvd->vpic.whiteness >> 8);
447 usbvideo_OverlayString(uvd, frame, x, y, tmp);
448 y += y_diff;
449}
450
451/*
452 * usbvideo_ReportStatistics()
453 *
454 * This procedure prints packet and transfer statistics.
455 *
456 * History:
457 * 14-Jan-2000 Corrected default multiplier.
458 */
459static void usbvideo_ReportStatistics(const struct uvd *uvd)
460{
461 if ((uvd != NULL) && (uvd->stats.urb_count > 0)) {
462 unsigned long allPackets, badPackets, goodPackets, percent;
463 allPackets = uvd->stats.urb_count * CAMERA_URB_FRAMES;
464 badPackets = uvd->stats.iso_skip_count + uvd->stats.iso_err_count;
465 goodPackets = allPackets - badPackets;
466 /* Calculate percentage wisely, remember integer limits */
467 assert(allPackets != 0);
468 if (goodPackets < (((unsigned long)-1)/100))
469 percent = (100 * goodPackets) / allPackets;
470 else
471 percent = goodPackets / (allPackets / 100);
472 info("Packet Statistics: Total=%lu. Empty=%lu. Usage=%lu%%",
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 /* Scale xferBytes for easy reading */
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 info("Transfer Statistics: Transferred=%lu%cB Usage=%lu%%",
502 xferBytes, multiplier, percent);
503 }
504 }
505}
506
507/*
508 * usbvideo_TestPattern()
509 *
510 * Procedure forms a test pattern (yellow grid on blue background).
511 *
512 * Parameters:
513 * fullframe: if TRUE then entire frame is filled, otherwise the procedure
514 * continues from the current scanline.
515 * pmode 0: fill the frame with solid blue color (like on VCR or TV)
516 * 1: Draw a colored grid
517 *
518 * History:
519 * 01-Feb-2000 Created.
520 */
521void usbvideo_TestPattern(struct uvd *uvd, int fullframe, int pmode)
522{
523 struct usbvideo_frame *frame;
524 int num_cell = 0;
525 int scan_length = 0;
526 static int num_pass = 0;
527
528 if (uvd == NULL) {
529 err("%s: uvd == NULL", __FUNCTION__);
530 return;
531 }
532 if ((uvd->curframe < 0) || (uvd->curframe >= USBVIDEO_NUMFRAMES)) {
533 err("%s: uvd->curframe=%d.", __FUNCTION__, uvd->curframe);
534 return;
535 }
536
537 /* Grab the current frame */
538 frame = &uvd->frame[uvd->curframe];
539
540 /* Optionally start at the beginning */
541 if (fullframe) {
542 frame->curline = 0;
543 frame->seqRead_Length = 0;
544 }
545#if 0
546 { /* For debugging purposes only */
547 char tmp[20];
548 usbvideo_VideosizeToString(tmp, sizeof(tmp), frame->request);
549 info("testpattern: frame=%s", tmp);
550 }
551#endif
552 /* Form every scan line */
553 for (; frame->curline < VIDEOSIZE_Y(frame->request); frame->curline++) {
554 int i;
555 unsigned char *f = frame->data +
556 (VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL * frame->curline);
557 for (i=0; i < VIDEOSIZE_X(frame->request); i++) {
558 unsigned char cb=0x80;
559 unsigned char cg = 0;
560 unsigned char cr = 0;
561
562 if (pmode == 1) {
563 if (frame->curline % 32 == 0)
564 cb = 0, cg = cr = 0xFF;
565 else if (i % 32 == 0) {
566 if (frame->curline % 32 == 1)
567 num_cell++;
568 cb = 0, cg = cr = 0xFF;
569 } else {
570 cb = ((num_cell*7) + num_pass) & 0xFF;
571 cg = ((num_cell*5) + num_pass*2) & 0xFF;
572 cr = ((num_cell*3) + num_pass*3) & 0xFF;
573 }
574 } else {
575 /* Just the blue screen */
576 }
577
578 *f++ = cb;
579 *f++ = cg;
580 *f++ = cr;
581 scan_length += 3;
582 }
583 }
584
585 frame->frameState = FrameState_Done;
586 frame->seqRead_Length += scan_length;
587 ++num_pass;
588
589 /* We do this unconditionally, regardless of FLAGS_OVERLAY_STATS */
590 usbvideo_OverlayStats(uvd, frame);
591}
592
593EXPORT_SYMBOL(usbvideo_TestPattern);
594
595
596#ifdef DEBUG
597/*
598 * usbvideo_HexDump()
599 *
600 * A debugging tool. Prints hex dumps.
601 *
602 * History:
603 * 29-Jul-2000 Added printing of offsets.
604 */
605void usbvideo_HexDump(const unsigned char *data, int len)
606{
607 const int bytes_per_line = 32;
608 char tmp[128]; /* 32*3 + 5 */
609 int i, k;
610
611 for (i=k=0; len > 0; i++, len--) {
612 if (i > 0 && ((i % bytes_per_line) == 0)) {
613 printk("%s\n", tmp);
614 k=0;
615 }
616 if ((i % bytes_per_line) == 0)
617 k += sprintf(&tmp[k], "%04x: ", i);
618 k += sprintf(&tmp[k], "%02x ", data[i]);
619 }
620 if (k > 0)
621 printk("%s\n", tmp);
622}
623
624EXPORT_SYMBOL(usbvideo_HexDump);
625
626#endif
627
628/* ******************************************************************** */
629
630/* XXX: this piece of crap really wants some error handling.. */
631static void usbvideo_ClientIncModCount(struct uvd *uvd)
632{
633 if (uvd == NULL) {
634 err("%s: uvd == NULL", __FUNCTION__);
635 return;
636 }
637 if (uvd->handle == NULL) {
638 err("%s: uvd->handle == NULL", __FUNCTION__);
639 return;
640 }
641 if (uvd->handle->md_module == NULL) {
642 err("%s: uvd->handle->md_module == NULL", __FUNCTION__);
643 return;
644 }
645 if (!try_module_get(uvd->handle->md_module)) {
646 err("%s: try_module_get() == 0", __FUNCTION__);
647 return;
648 }
649}
650
651static void usbvideo_ClientDecModCount(struct uvd *uvd)
652{
653 if (uvd == NULL) {
654 err("%s: uvd == NULL", __FUNCTION__);
655 return;
656 }
657 if (uvd->handle == NULL) {
658 err("%s: uvd->handle == NULL", __FUNCTION__);
659 return;
660 }
661 if (uvd->handle->md_module == NULL) {
662 err("%s: uvd->handle->md_module == NULL", __FUNCTION__);
663 return;
664 }
665 module_put(uvd->handle->md_module);
666}
667
668int usbvideo_register(
669 struct usbvideo **pCams,
670 const int num_cams,
671 const int num_extra,
672 const char *driverName,
673 const struct usbvideo_cb *cbTbl,
674 struct module *md,
675 const struct usb_device_id *id_table)
676{
677 struct usbvideo *cams;
678 int i, base_size, result;
679
680 /* Check parameters for sanity */
681 if ((num_cams <= 0) || (pCams == NULL) || (cbTbl == NULL)) {
682 err("%s: Illegal call", __FUNCTION__);
683 return -EINVAL;
684 }
685
686 /* Check registration callback - must be set! */
687 if (cbTbl->probe == NULL) {
688 err("%s: probe() is required!", __FUNCTION__);
689 return -EINVAL;
690 }
691
692 base_size = num_cams * sizeof(struct uvd) + sizeof(struct usbvideo);
693 cams = (struct usbvideo *) kmalloc(base_size, GFP_KERNEL);
694 if (cams == NULL) {
695 err("Failed to allocate %d. bytes for usbvideo struct", base_size);
696 return -ENOMEM;
697 }
698 dbg("%s: Allocated $%p (%d. bytes) for %d. cameras",
699 __FUNCTION__, cams, base_size, num_cams);
700 memset(cams, 0, base_size);
701
702 /* Copy callbacks, apply defaults for those that are not set */
703 memmove(&cams->cb, cbTbl, sizeof(cams->cb));
704 if (cams->cb.getFrame == NULL)
705 cams->cb.getFrame = usbvideo_GetFrame;
706 if (cams->cb.disconnect == NULL)
707 cams->cb.disconnect = usbvideo_Disconnect;
708 if (cams->cb.startDataPump == NULL)
709 cams->cb.startDataPump = usbvideo_StartDataPump;
710 if (cams->cb.stopDataPump == NULL)
711 cams->cb.stopDataPump = usbvideo_StopDataPump;
712
713 cams->num_cameras = num_cams;
714 cams->cam = (struct uvd *) &cams[1];
715 cams->md_module = md;
716 if (cams->md_module == NULL)
717 warn("%s: module == NULL!", __FUNCTION__);
718 init_MUTEX(&cams->lock); /* to 1 == available */
719
720 for (i = 0; i < num_cams; i++) {
721 struct uvd *up = &cams->cam[i];
722
723 up->handle = cams;
724
725 /* Allocate user_data separately because of kmalloc's limits */
726 if (num_extra > 0) {
727 up->user_size = num_cams * num_extra;
728 up->user_data = (char *) kmalloc(up->user_size, GFP_KERNEL);
729 if (up->user_data == NULL) {
730 err("%s: Failed to allocate user_data (%d. bytes)",
731 __FUNCTION__, up->user_size);
732 while (i) {
733 up = &cams->cam[--i];
734 kfree(up->user_data);
735 }
736 kfree(cams);
737 return -ENOMEM;
738 }
739 dbg("%s: Allocated cams[%d].user_data=$%p (%d. bytes)",
740 __FUNCTION__, i, up->user_data, up->user_size);
741 }
742 }
743
744 /*
745 * Register ourselves with USB stack.
746 */
747 strcpy(cams->drvName, (driverName != NULL) ? driverName : "Unknown");
748 cams->usbdrv.name = cams->drvName;
749 cams->usbdrv.probe = cams->cb.probe;
750 cams->usbdrv.disconnect = cams->cb.disconnect;
751 cams->usbdrv.id_table = id_table;
752
753 /*
754 * Update global handle to usbvideo. This is very important
755 * because probe() can be called before usb_register() returns.
756 * If the handle is not yet updated then the probe() will fail.
757 */
758 *pCams = cams;
759 result = usb_register(&cams->usbdrv);
760 if (result) {
761 for (i = 0; i < num_cams; i++) {
762 struct uvd *up = &cams->cam[i];
763 kfree(up->user_data);
764 }
765 kfree(cams);
766 }
767
768 return result;
769}
770
771EXPORT_SYMBOL(usbvideo_register);
772
773/*
774 * usbvideo_Deregister()
775 *
776 * Procedure frees all usbvideo and user data structures. Be warned that
777 * if you had some dynamically allocated components in ->user field then
778 * you should free them before calling here.
779 */
780void usbvideo_Deregister(struct usbvideo **pCams)
781{
782 struct usbvideo *cams;
783 int i;
784
785 if (pCams == NULL) {
786 err("%s: pCams == NULL", __FUNCTION__);
787 return;
788 }
789 cams = *pCams;
790 if (cams == NULL) {
791 err("%s: cams == NULL", __FUNCTION__);
792 return;
793 }
794
795 dbg("%s: Deregistering %s driver.", __FUNCTION__, cams->drvName);
796 usb_deregister(&cams->usbdrv);
797
798 dbg("%s: Deallocating cams=$%p (%d. cameras)", __FUNCTION__, cams, cams->num_cameras);
799 for (i=0; i < cams->num_cameras; i++) {
800 struct uvd *up = &cams->cam[i];
801 int warning = 0;
802
803 if (up->user_data != NULL) {
804 if (up->user_size <= 0)
805 ++warning;
806 } else {
807 if (up->user_size > 0)
808 ++warning;
809 }
810 if (warning) {
811 err("%s: Warning: user_data=$%p user_size=%d.",
812 __FUNCTION__, up->user_data, up->user_size);
813 } else {
814 dbg("%s: Freeing %d. $%p->user_data=$%p",
815 __FUNCTION__, i, up, up->user_data);
816 kfree(up->user_data);
817 }
818 }
819 /* Whole array was allocated in one chunk */
820 dbg("%s: Freed %d uvd structures",
821 __FUNCTION__, cams->num_cameras);
822 kfree(cams);
823 *pCams = NULL;
824}
825
826EXPORT_SYMBOL(usbvideo_Deregister);
827
828/*
829 * usbvideo_Disconnect()
830 *
831 * This procedure stops all driver activity. Deallocation of
832 * the interface-private structure (pointed by 'ptr') is done now
833 * (if we don't have any open files) or later, when those files
834 * are closed. After that driver should be removable.
835 *
836 * This code handles surprise removal. The uvd->user is a counter which
837 * increments on open() and decrements on close(). If we see here that
838 * this counter is not 0 then we have a client who still has us opened.
839 * We set uvd->remove_pending flag as early as possible, and after that
840 * all access to the camera will gracefully fail. These failures should
841 * prompt client to (eventually) close the video device, and then - in
842 * usbvideo_v4l_close() - we decrement uvd->uvd_used and usage counter.
843 *
844 * History:
845 * 22-Jan-2000 Added polling of MOD_IN_USE to delay removal until all users gone.
846 * 27-Jan-2000 Reworked to allow pending disconnects; see xxx_close()
847 * 24-May-2000 Corrected to prevent race condition (MOD_xxx_USE_COUNT).
848 * 19-Oct-2000 Moved to usbvideo module.
849 */
850static void usbvideo_Disconnect(struct usb_interface *intf)
851{
852 struct uvd *uvd = usb_get_intfdata (intf);
853 int i;
854
855 if (uvd == NULL) {
856 err("%s($%p): Illegal call.", __FUNCTION__, intf);
857 return;
858 }
859
860 usb_set_intfdata (intf, NULL);
861
862 usbvideo_ClientIncModCount(uvd);
863 if (uvd->debug > 0)
864 info("%s(%p.)", __FUNCTION__, intf);
865
866 down(&uvd->lock);
867 uvd->remove_pending = 1; /* Now all ISO data will be ignored */
868
869 /* At this time we ask to cancel outstanding URBs */
870 GET_CALLBACK(uvd, stopDataPump)(uvd);
871
872 for (i=0; i < USBVIDEO_NUMSBUF; i++)
873 usb_free_urb(uvd->sbuf[i].urb);
874
875 usb_put_dev(uvd->dev);
876 uvd->dev = NULL; /* USB device is no more */
877
878 video_unregister_device(&uvd->vdev);
879 if (uvd->debug > 0)
880 info("%s: Video unregistered.", __FUNCTION__);
881
882 if (uvd->user)
883 info("%s: In use, disconnect pending.", __FUNCTION__);
884 else
885 usbvideo_CameraRelease(uvd);
886 up(&uvd->lock);
887 info("USB camera disconnected.");
888
889 usbvideo_ClientDecModCount(uvd);
890}
891
892/*
893 * usbvideo_CameraRelease()
894 *
895 * This code does final release of uvd. This happens
896 * after the device is disconnected -and- all clients
897 * closed their files.
898 *
899 * History:
900 * 27-Jan-2000 Created.
901 */
902static void usbvideo_CameraRelease(struct uvd *uvd)
903{
904 if (uvd == NULL) {
905 err("%s: Illegal call", __FUNCTION__);
906 return;
907 }
908
909 RingQueue_Free(&uvd->dp);
910 if (VALID_CALLBACK(uvd, userFree))
911 GET_CALLBACK(uvd, userFree)(uvd);
912 uvd->uvd_used = 0; /* This is atomic, no need to take mutex */
913}
914
915/*
916 * usbvideo_find_struct()
917 *
918 * This code searches the array of preallocated (static) structures
919 * and returns index of the first one that isn't in use. Returns -1
920 * if there are no free structures.
921 *
922 * History:
923 * 27-Jan-2000 Created.
924 */
925static int usbvideo_find_struct(struct usbvideo *cams)
926{
927 int u, rv = -1;
928
929 if (cams == NULL) {
930 err("No usbvideo handle?");
931 return -1;
932 }
933 down(&cams->lock);
934 for (u = 0; u < cams->num_cameras; u++) {
935 struct uvd *uvd = &cams->cam[u];
936 if (!uvd->uvd_used) /* This one is free */
937 {
938 uvd->uvd_used = 1; /* In use now */
939 init_MUTEX(&uvd->lock); /* to 1 == available */
940 uvd->dev = NULL;
941 rv = u;
942 break;
943 }
944 }
945 up(&cams->lock);
946 return rv;
947}
948
949static struct file_operations usbvideo_fops = {
950 .owner = THIS_MODULE,
951 .open = usbvideo_v4l_open,
952 .release =usbvideo_v4l_close,
953 .read = usbvideo_v4l_read,
954 .mmap = usbvideo_v4l_mmap,
955 .ioctl = usbvideo_v4l_ioctl,
956 .llseek = no_llseek,
957};
958static struct video_device usbvideo_template = {
959 .owner = THIS_MODULE,
960 .type = VID_TYPE_CAPTURE,
961 .hardware = VID_HARDWARE_CPIA,
962 .fops = &usbvideo_fops,
963};
964
965struct uvd *usbvideo_AllocateDevice(struct usbvideo *cams)
966{
967 int i, devnum;
968 struct uvd *uvd = NULL;
969
970 if (cams == NULL) {
971 err("No usbvideo handle?");
972 return NULL;
973 }
974
975 devnum = usbvideo_find_struct(cams);
976 if (devnum == -1) {
977 err("IBM USB camera driver: Too many devices!");
978 return NULL;
979 }
980 uvd = &cams->cam[devnum];
981 dbg("Device entry #%d. at $%p", devnum, uvd);
982
983 /* Not relying upon caller we increase module counter ourselves */
984 usbvideo_ClientIncModCount(uvd);
985
986 down(&uvd->lock);
987 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
988 uvd->sbuf[i].urb = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);
989 if (uvd->sbuf[i].urb == NULL) {
990 err("usb_alloc_urb(%d.) failed.", FRAMES_PER_DESC);
991 uvd->uvd_used = 0;
992 uvd = NULL;
993 goto allocate_done;
994 }
995 }
996 uvd->user=0;
997 uvd->remove_pending = 0;
998 uvd->last_error = 0;
999 RingQueue_Initialize(&uvd->dp);
1000
1001 /* Initialize video device structure */
1002 uvd->vdev = usbvideo_template;
1003 sprintf(uvd->vdev.name, "%.20s USB Camera", cams->drvName);
1004 /*
1005 * The client is free to overwrite those because we
1006 * return control to the client's probe function right now.
1007 */
1008allocate_done:
1009 up (&uvd->lock);
1010 usbvideo_ClientDecModCount(uvd);
1011 return uvd;
1012}
1013
1014EXPORT_SYMBOL(usbvideo_AllocateDevice);
1015
1016int usbvideo_RegisterVideoDevice(struct uvd *uvd)
1017{
1018 char tmp1[20], tmp2[20]; /* Buffers for printing */
1019
1020 if (uvd == NULL) {
1021 err("%s: Illegal call.", __FUNCTION__);
1022 return -EINVAL;
1023 }
1024 if (uvd->video_endp == 0) {
1025 info("%s: No video endpoint specified; data pump disabled.", __FUNCTION__);
1026 }
1027 if (uvd->paletteBits == 0) {
1028 err("%s: No palettes specified!", __FUNCTION__);
1029 return -EINVAL;
1030 }
1031 if (uvd->defaultPalette == 0) {
1032 info("%s: No default palette!", __FUNCTION__);
1033 }
1034
1035 uvd->max_frame_size = VIDEOSIZE_X(uvd->canvas) *
1036 VIDEOSIZE_Y(uvd->canvas) * V4L_BYTES_PER_PIXEL;
1037 usbvideo_VideosizeToString(tmp1, sizeof(tmp1), uvd->videosize);
1038 usbvideo_VideosizeToString(tmp2, sizeof(tmp2), uvd->canvas);
1039
1040 if (uvd->debug > 0) {
1041 info("%s: iface=%d. endpoint=$%02x paletteBits=$%08lx",
1042 __FUNCTION__, uvd->iface, uvd->video_endp, uvd->paletteBits);
1043 }
1044 if (video_register_device(&uvd->vdev, VFL_TYPE_GRABBER, video_nr) == -1) {
1045 err("%s: video_register_device failed", __FUNCTION__);
1046 return -EPIPE;
1047 }
1048 if (uvd->debug > 1) {
1049 info("%s: video_register_device() successful", __FUNCTION__);
1050 }
1051 if (uvd->dev == NULL) {
1052 err("%s: uvd->dev == NULL", __FUNCTION__);
1053 return -EINVAL;
1054 }
1055
1056 info("%s on /dev/video%d: canvas=%s videosize=%s",
1057 (uvd->handle != NULL) ? uvd->handle->drvName : "???",
1058 uvd->vdev.minor, 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 * usbvideo_v4l_open()
1100 *
1101 * This is part of Video 4 Linux API. The driver can be opened by one
1102 * client only (checks internal counter 'uvdser'). The procedure
1103 * then allocates buffers needed for video processing.
1104 *
1105 * History:
1106 * 22-Jan-2000 Rewrote, moved scratch buffer allocation here. Now the
1107 * camera is also initialized here (once per connect), at
1108 * expense of V4L client (it waits on open() call).
1109 * 27-Jan-2000 Used USBVIDEO_NUMSBUF as number of URB buffers.
1110 * 24-May-2000 Corrected to prevent race condition (MOD_xxx_USE_COUNT).
1111 */
1112static int usbvideo_v4l_open(struct inode *inode, 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 info("%s($%p)", __FUNCTION__, dev);
1121
1122 usbvideo_ClientIncModCount(uvd);
1123 down(&uvd->lock);
1124
1125 if (uvd->user) {
1126 err("%s: Someone tried to open an already opened device!", __FUNCTION__);
1127 errCode = -EBUSY;
1128 } else {
1129 /* Clear statistics */
1130 memset(&uvd->stats, 0, sizeof(uvd->stats));
1131
1132 /* Clean pointers so we know if we allocated something */
1133 for (i=0; i < USBVIDEO_NUMSBUF; i++)
1134 uvd->sbuf[i].data = NULL;
1135
1136 /* Allocate memory for the frame buffers */
1137 uvd->fbuf_size = USBVIDEO_NUMFRAMES * uvd->max_frame_size;
1138 uvd->fbuf = usbvideo_rvmalloc(uvd->fbuf_size);
1139 RingQueue_Allocate(&uvd->dp, RING_QUEUE_SIZE);
1140 if ((uvd->fbuf == NULL) ||
1141 (!RingQueue_IsAllocated(&uvd->dp))) {
1142 err("%s: Failed to allocate fbuf or dp", __FUNCTION__);
1143 errCode = -ENOMEM;
1144 } else {
1145 /* Allocate all buffers */
1146 for (i=0; i < USBVIDEO_NUMFRAMES; i++) {
1147 uvd->frame[i].frameState = FrameState_Unused;
1148 uvd->frame[i].data = uvd->fbuf + i*(uvd->max_frame_size);
1149 /*
1150 * Set default sizes in case IOCTL (VIDIOCMCAPTURE)
1151 * is not used (using read() instead).
1152 */
1153 uvd->frame[i].canvas = uvd->canvas;
1154 uvd->frame[i].seqRead_Index = 0;
1155 }
1156 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1157 uvd->sbuf[i].data = kmalloc(sb_size, GFP_KERNEL);
1158 if (uvd->sbuf[i].data == NULL) {
1159 errCode = -ENOMEM;
1160 break;
1161 }
1162 }
1163 }
1164 if (errCode != 0) {
1165 /* Have to free all that memory */
1166 if (uvd->fbuf != NULL) {
1167 usbvideo_rvfree(uvd->fbuf, uvd->fbuf_size);
1168 uvd->fbuf = NULL;
1169 }
1170 RingQueue_Free(&uvd->dp);
1171 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1172 if (uvd->sbuf[i].data != NULL) {
1173 kfree (uvd->sbuf[i].data);
1174 uvd->sbuf[i].data = NULL;
1175 }
1176 }
1177 }
1178 }
1179
1180 /* If so far no errors then we shall start the camera */
1181 if (errCode == 0) {
1182 /* Start data pump if we have valid endpoint */
1183 if (uvd->video_endp != 0)
1184 errCode = GET_CALLBACK(uvd, startDataPump)(uvd);
1185 if (errCode == 0) {
1186 if (VALID_CALLBACK(uvd, setupOnOpen)) {
1187 if (uvd->debug > 1)
1188 info("%s: setupOnOpen callback", __FUNCTION__);
1189 errCode = GET_CALLBACK(uvd, setupOnOpen)(uvd);
1190 if (errCode < 0) {
1191 err("%s: setupOnOpen callback failed (%d.).",
1192 __FUNCTION__, errCode);
1193 } else if (uvd->debug > 1) {
1194 info("%s: setupOnOpen callback successful", __FUNCTION__);
1195 }
1196 }
1197 if (errCode == 0) {
1198 uvd->settingsAdjusted = 0;
1199 if (uvd->debug > 1)
1200 info("%s: Open succeeded.", __FUNCTION__);
1201 uvd->user++;
1202 file->private_data = uvd;
1203 }
1204 }
1205 }
1206 up(&uvd->lock);
1207 if (errCode != 0)
1208 usbvideo_ClientDecModCount(uvd);
1209 if (uvd->debug > 0)
1210 info("%s: Returning %d.", __FUNCTION__, errCode);
1211 return errCode;
1212}
1213
1214/*
1215 * usbvideo_v4l_close()
1216 *
1217 * This is part of Video 4 Linux API. The procedure
1218 * stops streaming and deallocates all buffers that were earlier
1219 * allocated in usbvideo_v4l_open().
1220 *
1221 * History:
1222 * 22-Jan-2000 Moved scratch buffer deallocation here.
1223 * 27-Jan-2000 Used USBVIDEO_NUMSBUF as number of URB buffers.
1224 * 24-May-2000 Moved MOD_DEC_USE_COUNT outside of code that can sleep.
1225 */
1226static int usbvideo_v4l_close(struct inode *inode, struct file *file)
1227{
1228 struct video_device *dev = file->private_data;
1229 struct uvd *uvd = (struct uvd *) dev;
1230 int i;
1231
1232 if (uvd->debug > 1)
1233 info("%s($%p)", __FUNCTION__, dev);
1234
1235 down(&uvd->lock);
1236 GET_CALLBACK(uvd, stopDataPump)(uvd);
1237 usbvideo_rvfree(uvd->fbuf, uvd->fbuf_size);
1238 uvd->fbuf = NULL;
1239 RingQueue_Free(&uvd->dp);
1240
1241 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1242 kfree(uvd->sbuf[i].data);
1243 uvd->sbuf[i].data = NULL;
1244 }
1245
1246#if USBVIDEO_REPORT_STATS
1247 usbvideo_ReportStatistics(uvd);
1248#endif
1249
1250 uvd->user--;
1251 if (uvd->remove_pending) {
1252 if (uvd->debug > 0)
1253 info("usbvideo_v4l_close: Final disconnect.");
1254 usbvideo_CameraRelease(uvd);
1255 }
1256 up(&uvd->lock);
1257 usbvideo_ClientDecModCount(uvd);
1258
1259 if (uvd->debug > 1)
1260 info("%s: Completed.", __FUNCTION__);
1261 file->private_data = NULL;
1262 return 0;
1263}
1264
1265/*
1266 * usbvideo_v4l_ioctl()
1267 *
1268 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
1269 *
1270 * History:
1271 * 22-Jan-2000 Corrected VIDIOCSPICT to reject unsupported settings.
1272 */
1273static int usbvideo_v4l_do_ioctl(struct inode *inode, struct file *file,
1274 unsigned int cmd, void *arg)
1275{
1276 struct uvd *uvd = file->private_data;
1277
1278 if (!CAMERA_IS_OPERATIONAL(uvd))
1279 return -EIO;
1280
1281 switch (cmd) {
1282 case VIDIOCGCAP:
1283 {
1284 struct video_capability *b = arg;
1285 *b = uvd->vcap;
1286 return 0;
1287 }
1288 case VIDIOCGCHAN:
1289 {
1290 struct video_channel *v = arg;
1291 *v = uvd->vchan;
1292 return 0;
1293 }
1294 case VIDIOCSCHAN:
1295 {
1296 struct video_channel *v = arg;
1297 if (v->channel != 0)
1298 return -EINVAL;
1299 return 0;
1300 }
1301 case VIDIOCGPICT:
1302 {
1303 struct video_picture *pic = arg;
1304 *pic = uvd->vpic;
1305 return 0;
1306 }
1307 case VIDIOCSPICT:
1308 {
1309 struct video_picture *pic = arg;
1310 /*
1311 * Use temporary 'video_picture' structure to preserve our
1312 * own settings (such as color depth, palette) that we
1313 * aren't allowing everyone (V4L client) to change.
1314 */
1315 uvd->vpic.brightness = pic->brightness;
1316 uvd->vpic.hue = pic->hue;
1317 uvd->vpic.colour = pic->colour;
1318 uvd->vpic.contrast = pic->contrast;
1319 uvd->settingsAdjusted = 0; /* Will force new settings */
1320 return 0;
1321 }
1322 case VIDIOCSWIN:
1323 {
1324 struct video_window *vw = arg;
1325
1326 if(VALID_CALLBACK(uvd, setVideoMode)) {
1327 return GET_CALLBACK(uvd, setVideoMode)(uvd, vw);
1328 }
1329
1330 if (vw->flags)
1331 return -EINVAL;
1332 if (vw->clipcount)
1333 return -EINVAL;
1334 if (vw->width != VIDEOSIZE_X(uvd->canvas))
1335 return -EINVAL;
1336 if (vw->height != VIDEOSIZE_Y(uvd->canvas))
1337 return -EINVAL;
1338
1339 return 0;
1340 }
1341 case VIDIOCGWIN:
1342 {
1343 struct video_window *vw = arg;
1344
1345 vw->x = 0;
1346 vw->y = 0;
1347 vw->width = VIDEOSIZE_X(uvd->videosize);
1348 vw->height = VIDEOSIZE_Y(uvd->videosize);
1349 vw->chromakey = 0;
1350 if (VALID_CALLBACK(uvd, getFPS))
1351 vw->flags = GET_CALLBACK(uvd, getFPS)(uvd);
1352 else
1353 vw->flags = 10; /* FIXME: do better! */
1354 return 0;
1355 }
1356 case VIDIOCGMBUF:
1357 {
1358 struct video_mbuf *vm = arg;
1359 int i;
1360
1361 memset(vm, 0, sizeof(*vm));
1362 vm->size = uvd->max_frame_size * USBVIDEO_NUMFRAMES;
1363 vm->frames = USBVIDEO_NUMFRAMES;
1364 for(i = 0; i < USBVIDEO_NUMFRAMES; i++)
1365 vm->offsets[i] = i * uvd->max_frame_size;
1366
1367 return 0;
1368 }
1369 case VIDIOCMCAPTURE:
1370 {
1371 struct video_mmap *vm = arg;
1372
1373 if (uvd->debug >= 1) {
1374 info("VIDIOCMCAPTURE: frame=%d. size=%dx%d, format=%d.",
1375 vm->frame, vm->width, vm->height, vm->format);
1376 }
1377 /*
1378 * Check if the requested size is supported. If the requestor
1379 * requests too big a frame then we may be tricked into accessing
1380 * outside of own preallocated frame buffer (in uvd->frame).
1381 * This will cause oops or a security hole. Theoretically, we
1382 * could only clamp the size down to acceptable bounds, but then
1383 * we'd need to figure out how to insert our smaller buffer into
1384 * larger caller's buffer... this is not an easy question. So we
1385 * here just flatly reject too large requests, assuming that the
1386 * caller will resubmit with smaller size. Callers should know
1387 * what size we support (returned by VIDIOCGCAP). However vidcat,
1388 * for one, does not care and allows to ask for any size.
1389 */
1390 if ((vm->width > VIDEOSIZE_X(uvd->canvas)) ||
1391 (vm->height > VIDEOSIZE_Y(uvd->canvas))) {
1392 if (uvd->debug > 0) {
1393 info("VIDIOCMCAPTURE: Size=%dx%d too large; "
1394 "allowed only up to %ldx%ld", vm->width, vm->height,
1395 VIDEOSIZE_X(uvd->canvas), VIDEOSIZE_Y(uvd->canvas));
1396 }
1397 return -EINVAL;
1398 }
1399 /* Check if the palette is supported */
1400 if (((1L << vm->format) & uvd->paletteBits) == 0) {
1401 if (uvd->debug > 0) {
1402 info("VIDIOCMCAPTURE: format=%d. not supported"
1403 " (paletteBits=$%08lx)",
1404 vm->format, uvd->paletteBits);
1405 }
1406 return -EINVAL;
1407 }
1408 if ((vm->frame < 0) || (vm->frame >= USBVIDEO_NUMFRAMES)) {
1409 err("VIDIOCMCAPTURE: vm.frame=%d. !E [0-%d]", vm->frame, USBVIDEO_NUMFRAMES-1);
1410 return -EINVAL;
1411 }
1412 if (uvd->frame[vm->frame].frameState == FrameState_Grabbing) {
1413 /* Not an error - can happen */
1414 }
1415 uvd->frame[vm->frame].request = VIDEOSIZE(vm->width, vm->height);
1416 uvd->frame[vm->frame].palette = vm->format;
1417
1418 /* Mark it as ready */
1419 uvd->frame[vm->frame].frameState = FrameState_Ready;
1420
1421 return usbvideo_NewFrame(uvd, vm->frame);
1422 }
1423 case VIDIOCSYNC:
1424 {
1425 int *frameNum = arg;
1426 int ret;
1427
1428 if (*frameNum < 0 || *frameNum >= USBVIDEO_NUMFRAMES)
1429 return -EINVAL;
1430
1431 if (uvd->debug >= 1)
1432 info("VIDIOCSYNC: syncing to frame %d.", *frameNum);
1433 if (uvd->flags & FLAGS_NO_DECODING)
1434 ret = usbvideo_GetFrame(uvd, *frameNum);
1435 else if (VALID_CALLBACK(uvd, getFrame)) {
1436 ret = GET_CALLBACK(uvd, getFrame)(uvd, *frameNum);
1437 if ((ret < 0) && (uvd->debug >= 1)) {
1438 err("VIDIOCSYNC: getFrame() returned %d.", ret);
1439 }
1440 } else {
1441 err("VIDIOCSYNC: getFrame is not set");
1442 ret = -EFAULT;
1443 }
1444
1445 /*
1446 * The frame is in FrameState_Done_Hold state. Release it
1447 * right now because its data is already mapped into
1448 * the user space and it's up to the application to
1449 * make use of it until it asks for another frame.
1450 */
1451 uvd->frame[*frameNum].frameState = FrameState_Unused;
1452 return ret;
1453 }
1454 case VIDIOCGFBUF:
1455 {
1456 struct video_buffer *vb = arg;
1457
1458 memset(vb, 0, sizeof(*vb));
1459 return 0;
1460 }
1461 case VIDIOCKEY:
1462 return 0;
1463
1464 case VIDIOCCAPTURE:
1465 return -EINVAL;
1466
1467 case VIDIOCSFBUF:
1468
1469 case VIDIOCGTUNER:
1470 case VIDIOCSTUNER:
1471
1472 case VIDIOCGFREQ:
1473 case VIDIOCSFREQ:
1474
1475 case VIDIOCGAUDIO:
1476 case VIDIOCSAUDIO:
1477 return -EINVAL;
1478
1479 default:
1480 return -ENOIOCTLCMD;
1481 }
1482 return 0;
1483}
1484
1485static int usbvideo_v4l_ioctl(struct inode *inode, struct file *file,
1486 unsigned int cmd, unsigned long arg)
1487{
1488 return video_usercopy(inode, file, cmd, arg, usbvideo_v4l_do_ioctl);
1489}
1490
1491/*
1492 * usbvideo_v4l_read()
1493 *
1494 * This is mostly boring stuff. We simply ask for a frame and when it
1495 * arrives copy all the video data from it into user space. There is
1496 * no obvious need to override this method.
1497 *
1498 * History:
1499 * 20-Oct-2000 Created.
1500 * 01-Nov-2000 Added mutex (uvd->lock).
1501 */
1502static ssize_t usbvideo_v4l_read(struct file *file, char __user *buf,
1503 size_t count, loff_t *ppos)
1504{
1505 struct uvd *uvd = file->private_data;
1506 int noblock = file->f_flags & O_NONBLOCK;
1507 int frmx = -1, i;
1508 struct usbvideo_frame *frame;
1509
1510 if (!CAMERA_IS_OPERATIONAL(uvd) || (buf == NULL))
1511 return -EFAULT;
1512
1513 if (uvd->debug >= 1)
1514 info("%s: %Zd. bytes, noblock=%d.", __FUNCTION__, count, noblock);
1515
1516 down(&uvd->lock);
1517
1518 /* See if a frame is completed, then use it. */
1519 for(i = 0; i < USBVIDEO_NUMFRAMES; i++) {
1520 if ((uvd->frame[i].frameState == FrameState_Done) ||
1521 (uvd->frame[i].frameState == FrameState_Done_Hold) ||
1522 (uvd->frame[i].frameState == FrameState_Error)) {
1523 frmx = i;
1524 break;
1525 }
1526 }
1527
1528 /* FIXME: If we don't start a frame here then who ever does? */
1529 if (noblock && (frmx == -1)) {
1530 count = -EAGAIN;
1531 goto read_done;
1532 }
1533
1534 /*
1535 * If no FrameState_Done, look for a FrameState_Grabbing state.
1536 * See if a frame is in process (grabbing), then use it.
1537 * We will need to wait until it becomes cooked, of course.
1538 */
1539 if (frmx == -1) {
1540 for(i = 0; i < USBVIDEO_NUMFRAMES; i++) {
1541 if (uvd->frame[i].frameState == FrameState_Grabbing) {
1542 frmx = i;
1543 break;
1544 }
1545 }
1546 }
1547
1548 /*
1549 * If no frame is active, start one. We don't care which one
1550 * it will be, so #0 is as good as any.
1551 * In read access mode we don't have convenience of VIDIOCMCAPTURE
1552 * to specify the requested palette (video format) on per-frame
1553 * basis. This means that we have to return data in -some- format
1554 * and just hope that the client knows what to do with it.
1555 * The default format is configured in uvd->defaultPalette field
1556 * as one of VIDEO_PALETTE_xxx values. We stuff it into the new
1557 * frame and initiate the frame filling process.
1558 */
1559 if (frmx == -1) {
1560 if (uvd->defaultPalette == 0) {
1561 err("%s: No default palette; don't know what to do!", __FUNCTION__);
1562 count = -EFAULT;
1563 goto read_done;
1564 }
1565 frmx = 0;
1566 /*
1567 * We have no per-frame control over video size.
1568 * Therefore we only can use whatever size was
1569 * specified as default.
1570 */
1571 uvd->frame[frmx].request = uvd->videosize;
1572 uvd->frame[frmx].palette = uvd->defaultPalette;
1573 uvd->frame[frmx].frameState = FrameState_Ready;
1574 usbvideo_NewFrame(uvd, frmx);
1575 /* Now frame 0 is supposed to start filling... */
1576 }
1577
1578 /*
1579 * Get a pointer to the active frame. It is either previously
1580 * completed frame or frame in progress but not completed yet.
1581 */
1582 frame = &uvd->frame[frmx];
1583
1584 /*
1585 * Sit back & wait until the frame gets filled and postprocessed.
1586 * If we fail to get the picture [in time] then return the error.
1587 * In this call we specify that we want the frame to be waited for,
1588 * postprocessed and switched into FrameState_Done_Hold state. This
1589 * state is used to hold the frame as "fully completed" between
1590 * subsequent partial reads of the same frame.
1591 */
1592 if (frame->frameState != FrameState_Done_Hold) {
1593 long rv = -EFAULT;
1594 if (uvd->flags & FLAGS_NO_DECODING)
1595 rv = usbvideo_GetFrame(uvd, frmx);
1596 else if (VALID_CALLBACK(uvd, getFrame))
1597 rv = GET_CALLBACK(uvd, getFrame)(uvd, frmx);
1598 else
1599 err("getFrame is not set");
1600 if ((rv != 0) || (frame->frameState != FrameState_Done_Hold)) {
1601 count = rv;
1602 goto read_done;
1603 }
1604 }
1605
1606 /*
1607 * Copy bytes to user space. We allow for partial reads, which
1608 * means that the user application can request read less than
1609 * the full frame size. It is up to the application to issue
1610 * subsequent calls until entire frame is read.
1611 *
1612 * First things first, make sure we don't copy more than we
1613 * have - even if the application wants more. That would be
1614 * a big security embarassment!
1615 */
1616 if ((count + frame->seqRead_Index) > frame->seqRead_Length)
1617 count = frame->seqRead_Length - frame->seqRead_Index;
1618
1619 /*
1620 * Copy requested amount of data to user space. We start
1621 * copying from the position where we last left it, which
1622 * will be zero for a new frame (not read before).
1623 */
1624 if (copy_to_user(buf, frame->data + frame->seqRead_Index, count)) {
1625 count = -EFAULT;
1626 goto read_done;
1627 }
1628
1629 /* Update last read position */
1630 frame->seqRead_Index += count;
1631 if (uvd->debug >= 1) {
1632 err("%s: {copy} count used=%Zd, new seqRead_Index=%ld",
1633 __FUNCTION__, count, frame->seqRead_Index);
1634 }
1635
1636 /* Finally check if the frame is done with and "release" it */
1637 if (frame->seqRead_Index >= frame->seqRead_Length) {
1638 /* All data has been read */
1639 frame->seqRead_Index = 0;
1640
1641 /* Mark it as available to be used again. */
1642 uvd->frame[frmx].frameState = FrameState_Unused;
1643 if (usbvideo_NewFrame(uvd, (frmx + 1) % USBVIDEO_NUMFRAMES)) {
1644 err("%s: usbvideo_NewFrame failed.", __FUNCTION__);
1645 }
1646 }
1647read_done:
1648 up(&uvd->lock);
1649 return count;
1650}
1651
1652/*
1653 * Make all of the blocks of data contiguous
1654 */
1655static int usbvideo_CompressIsochronous(struct uvd *uvd, struct urb *urb)
1656{
1657 char *cdata;
1658 int i, totlen = 0;
1659
1660 for (i = 0; i < urb->number_of_packets; i++) {
1661 int n = urb->iso_frame_desc[i].actual_length;
1662 int st = urb->iso_frame_desc[i].status;
1663
1664 cdata = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
1665
1666 /* Detect and ignore errored packets */
1667 if (st < 0) {
1668 if (uvd->debug >= 1)
1669 err("Data error: packet=%d. len=%d. status=%d.", i, n, st);
1670 uvd->stats.iso_err_count++;
1671 continue;
1672 }
1673
1674 /* Detect and ignore empty packets */
1675 if (n <= 0) {
1676 uvd->stats.iso_skip_count++;
1677 continue;
1678 }
1679 totlen += n; /* Little local accounting */
1680 RingQueue_Enqueue(&uvd->dp, cdata, n);
1681 }
1682 return totlen;
1683}
1684
1685static void usbvideo_IsocIrq(struct urb *urb, struct pt_regs *regs)
1686{
1687 int i, ret, len;
1688 struct uvd *uvd = urb->context;
1689
1690 /* We don't want to do anything if we are about to be removed! */
1691 if (!CAMERA_IS_OPERATIONAL(uvd))
1692 return;
1693#if 0
1694 if (urb->actual_length > 0) {
1695 info("urb=$%p status=%d. errcount=%d. length=%d.",
1696 urb, urb->status, urb->error_count, urb->actual_length);
1697 } else {
1698 static int c = 0;
1699 if (c++ % 100 == 0)
1700 info("No Isoc data");
1701 }
1702#endif
1703
1704 if (!uvd->streaming) {
1705 if (uvd->debug >= 1)
1706 info("Not streaming, but interrupt!");
1707 return;
1708 }
1709
1710 uvd->stats.urb_count++;
1711 if (urb->actual_length <= 0)
1712 goto urb_done_with;
1713
1714 /* Copy the data received into ring queue */
1715 len = usbvideo_CompressIsochronous(uvd, urb);
1716 uvd->stats.urb_length = len;
1717 if (len <= 0)
1718 goto urb_done_with;
1719
1720 /* Here we got some data */
1721 uvd->stats.data_count += len;
1722 RingQueue_WakeUpInterruptible(&uvd->dp);
1723
1724urb_done_with:
1725 for (i = 0; i < FRAMES_PER_DESC; i++) {
1726 urb->iso_frame_desc[i].status = 0;
1727 urb->iso_frame_desc[i].actual_length = 0;
1728 }
1729 urb->status = 0;
1730 urb->dev = uvd->dev;
1731 ret = usb_submit_urb (urb, GFP_KERNEL);
1732 if(ret)
1733 err("usb_submit_urb error (%d)", ret);
1734 return;
1735}
1736
1737/*
1738 * usbvideo_StartDataPump()
1739 *
1740 * History:
1741 * 27-Jan-2000 Used ibmcam->iface, ibmcam->ifaceAltActive instead
1742 * of hardcoded values. Simplified by using for loop,
1743 * allowed any number of URBs.
1744 */
1745static int usbvideo_StartDataPump(struct uvd *uvd)
1746{
1747 struct usb_device *dev = uvd->dev;
1748 int i, errFlag;
1749
1750 if (uvd->debug > 1)
1751 info("%s($%p)", __FUNCTION__, uvd);
1752
1753 if (!CAMERA_IS_OPERATIONAL(uvd)) {
1754 err("%s: Camera is not operational", __FUNCTION__);
1755 return -EFAULT;
1756 }
1757 uvd->curframe = -1;
1758
1759 /* Alternate interface 1 is is the biggest frame size */
1760 i = usb_set_interface(dev, uvd->iface, uvd->ifaceAltActive);
1761 if (i < 0) {
1762 err("%s: usb_set_interface error", __FUNCTION__);
1763 uvd->last_error = i;
1764 return -EBUSY;
1765 }
1766 if (VALID_CALLBACK(uvd, videoStart))
1767 GET_CALLBACK(uvd, videoStart)(uvd);
1768 else
1769 err("%s: videoStart not set", __FUNCTION__);
1770
1771 /* We double buffer the Iso lists */
1772 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1773 int j, k;
1774 struct urb *urb = uvd->sbuf[i].urb;
1775 urb->dev = dev;
1776 urb->context = uvd;
1777 urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp);
1778 urb->interval = 1;
1779 urb->transfer_flags = URB_ISO_ASAP;
1780 urb->transfer_buffer = uvd->sbuf[i].data;
1781 urb->complete = usbvideo_IsocIrq;
1782 urb->number_of_packets = FRAMES_PER_DESC;
1783 urb->transfer_buffer_length = uvd->iso_packet_len * FRAMES_PER_DESC;
1784 for (j=k=0; j < FRAMES_PER_DESC; j++, k += uvd->iso_packet_len) {
1785 urb->iso_frame_desc[j].offset = k;
1786 urb->iso_frame_desc[j].length = uvd->iso_packet_len;
1787 }
1788 }
1789
1790 /* Submit all URBs */
1791 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1792 errFlag = usb_submit_urb(uvd->sbuf[i].urb, GFP_KERNEL);
1793 if (errFlag)
1794 err("%s: usb_submit_isoc(%d) ret %d", __FUNCTION__, i, errFlag);
1795 }
1796
1797 uvd->streaming = 1;
1798 if (uvd->debug > 1)
1799 info("%s: streaming=1 video_endp=$%02x", __FUNCTION__, uvd->video_endp);
1800 return 0;
1801}
1802
1803/*
1804 * usbvideo_StopDataPump()
1805 *
1806 * This procedure stops streaming and deallocates URBs. Then it
1807 * activates zero-bandwidth alt. setting of the video interface.
1808 *
1809 * History:
1810 * 22-Jan-2000 Corrected order of actions to work after surprise removal.
1811 * 27-Jan-2000 Used uvd->iface, uvd->ifaceAltInactive instead of hardcoded values.
1812 */
1813static void usbvideo_StopDataPump(struct uvd *uvd)
1814{
1815 int i, j;
1816
1817 if ((uvd == NULL) || (!uvd->streaming) || (uvd->dev == NULL))
1818 return;
1819
1820 if (uvd->debug > 1)
1821 info("%s($%p)", __FUNCTION__, uvd);
1822
1823 /* Unschedule all of the iso td's */
1824 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
1825 usb_kill_urb(uvd->sbuf[i].urb);
1826 }
1827 if (uvd->debug > 1)
1828 info("%s: streaming=0", __FUNCTION__);
1829 uvd->streaming = 0;
1830
1831 if (!uvd->remove_pending) {
1832 /* Invoke minidriver's magic to stop the camera */
1833 if (VALID_CALLBACK(uvd, videoStop))
1834 GET_CALLBACK(uvd, videoStop)(uvd);
1835 else
1836 err("%s: videoStop not set", __FUNCTION__);
1837
1838 /* Set packet size to 0 */
1839 j = usb_set_interface(uvd->dev, uvd->iface, uvd->ifaceAltInactive);
1840 if (j < 0) {
1841 err("%s: usb_set_interface() error %d.", __FUNCTION__, j);
1842 uvd->last_error = j;
1843 }
1844 }
1845}
1846
1847/*
1848 * usbvideo_NewFrame()
1849 *
1850 * History:
1851 * 29-Mar-00 Added copying of previous frame into the current one.
1852 * 6-Aug-00 Added model 3 video sizes, removed redundant width, height.
1853 */
1854static int usbvideo_NewFrame(struct uvd *uvd, int framenum)
1855{
1856 struct usbvideo_frame *frame;
1857 int n;
1858
1859 if (uvd->debug > 1)
1860 info("usbvideo_NewFrame($%p,%d.)", uvd, framenum);
1861
1862 /* If we're not grabbing a frame right now and the other frame is */
1863 /* ready to be grabbed into, then use it instead */
1864 if (uvd->curframe != -1)
1865 return 0;
1866
1867 /* If necessary we adjust picture settings between frames */
1868 if (!uvd->settingsAdjusted) {
1869 if (VALID_CALLBACK(uvd, adjustPicture))
1870 GET_CALLBACK(uvd, adjustPicture)(uvd);
1871 uvd->settingsAdjusted = 1;
1872 }
1873
1874 n = (framenum + 1) % USBVIDEO_NUMFRAMES;
1875 if (uvd->frame[n].frameState == FrameState_Ready)
1876 framenum = n;
1877
1878 frame = &uvd->frame[framenum];
1879
1880 frame->frameState = FrameState_Grabbing;
1881 frame->scanstate = ScanState_Scanning;
1882 frame->seqRead_Length = 0; /* Accumulated in xxx_parse_data() */
1883 frame->deinterlace = Deinterlace_None;
1884 frame->flags = 0; /* No flags yet, up to minidriver (or us) to set them */
1885 uvd->curframe = framenum;
1886
1887 /*
1888 * Normally we would want to copy previous frame into the current one
1889 * before we even start filling it with data; this allows us to stop
1890 * filling at any moment; top portion of the frame will be new and
1891 * bottom portion will stay as it was in previous frame. If we don't
1892 * do that then missing chunks of video stream will result in flickering
1893 * portions of old data whatever it was before.
1894 *
1895 * If we choose not to copy previous frame (to, for example, save few
1896 * bus cycles - the frame can be pretty large!) then we have an option
1897 * to clear the frame before using. If we experience losses in this
1898 * mode then missing picture will be black (no flickering).
1899 *
1900 * Finally, if user chooses not to clean the current frame before
1901 * filling it with data then the old data will be visible if we fail
1902 * to refill entire frame with new data.
1903 */
1904 if (!(uvd->flags & FLAGS_SEPARATE_FRAMES)) {
1905 /* This copies previous frame into this one to mask losses */
1906 int prev = (framenum - 1 + USBVIDEO_NUMFRAMES) % USBVIDEO_NUMFRAMES;
1907 memmove(frame->data, uvd->frame[prev].data, uvd->max_frame_size);
1908 } else {
1909 if (uvd->flags & FLAGS_CLEAN_FRAMES) {
1910 /* This provides a "clean" frame but slows things down */
1911 memset(frame->data, 0, uvd->max_frame_size);
1912 }
1913 }
1914 return 0;
1915}
1916
1917/*
1918 * usbvideo_CollectRawData()
1919 *
1920 * This procedure can be used instead of 'processData' callback if you
1921 * only want to dump the raw data from the camera into the output
1922 * device (frame buffer). You can look at it with V4L client, but the
1923 * image will be unwatchable. The main purpose of this code and of the
1924 * mode FLAGS_NO_DECODING is debugging and capturing of datastreams from
1925 * new, unknown cameras. This procedure will be automatically invoked
1926 * instead of the specified callback handler when uvd->flags has bit
1927 * FLAGS_NO_DECODING set. Therefore, any regular build of any driver
1928 * based on usbvideo can use this feature at any time.
1929 */
1930static void usbvideo_CollectRawData(struct uvd *uvd, struct usbvideo_frame *frame)
1931{
1932 int n;
1933
1934 assert(uvd != NULL);
1935 assert(frame != NULL);
1936
1937 /* Try to move data from queue into frame buffer */
1938 n = RingQueue_GetLength(&uvd->dp);
1939 if (n > 0) {
1940 int m;
1941 /* See how much space we have left */
1942 m = uvd->max_frame_size - frame->seqRead_Length;
1943 if (n > m)
1944 n = m;
1945 /* Now move that much data into frame buffer */
1946 RingQueue_Dequeue(
1947 &uvd->dp,
1948 frame->data + frame->seqRead_Length,
1949 m);
1950 frame->seqRead_Length += m;
1951 }
1952 /* See if we filled the frame */
1953 if (frame->seqRead_Length >= uvd->max_frame_size) {
1954 frame->frameState = FrameState_Done;
1955 uvd->curframe = -1;
1956 uvd->stats.frame_num++;
1957 }
1958}
1959
1960static int usbvideo_GetFrame(struct uvd *uvd, int frameNum)
1961{
1962 struct usbvideo_frame *frame = &uvd->frame[frameNum];
1963
1964 if (uvd->debug >= 2)
1965 info("%s($%p,%d.)", __FUNCTION__, uvd, frameNum);
1966
1967 switch (frame->frameState) {
1968 case FrameState_Unused:
1969 if (uvd->debug >= 2)
1970 info("%s: FrameState_Unused", __FUNCTION__);
1971 return -EINVAL;
1972 case FrameState_Ready:
1973 case FrameState_Grabbing:
1974 case FrameState_Error:
1975 {
1976 int ntries, signalPending;
1977 redo:
1978 if (!CAMERA_IS_OPERATIONAL(uvd)) {
1979 if (uvd->debug >= 2)
1980 info("%s: Camera is not operational (1)", __FUNCTION__);
1981 return -EIO;
1982 }
1983 ntries = 0;
1984 do {
1985 RingQueue_InterruptibleSleepOn(&uvd->dp);
1986 signalPending = signal_pending(current);
1987 if (!CAMERA_IS_OPERATIONAL(uvd)) {
1988 if (uvd->debug >= 2)
1989 info("%s: Camera is not operational (2)", __FUNCTION__);
1990 return -EIO;
1991 }
1992 assert(uvd->fbuf != NULL);
1993 if (signalPending) {
1994 if (uvd->debug >= 2)
1995 info("%s: Signal=$%08x", __FUNCTION__, signalPending);
1996 if (uvd->flags & FLAGS_RETRY_VIDIOCSYNC) {
1997 usbvideo_TestPattern(uvd, 1, 0);
1998 uvd->curframe = -1;
1999 uvd->stats.frame_num++;
2000 if (uvd->debug >= 2)
2001 info("%s: Forced test pattern screen", __FUNCTION__);
2002 return 0;
2003 } else {
2004 /* Standard answer: Interrupted! */
2005 if (uvd->debug >= 2)
2006 info("%s: Interrupted!", __FUNCTION__);
2007 return -EINTR;
2008 }
2009 } else {
2010 /* No signals - we just got new data in dp queue */
2011 if (uvd->flags & FLAGS_NO_DECODING)
2012 usbvideo_CollectRawData(uvd, frame);
2013 else if (VALID_CALLBACK(uvd, processData))
2014 GET_CALLBACK(uvd, processData)(uvd, frame);
2015 else
2016 err("%s: processData not set", __FUNCTION__);
2017 }
2018 } while (frame->frameState == FrameState_Grabbing);
2019 if (uvd->debug >= 2) {
2020 info("%s: Grabbing done; state=%d. (%lu. bytes)",
2021 __FUNCTION__, frame->frameState, frame->seqRead_Length);
2022 }
2023 if (frame->frameState == FrameState_Error) {
2024 int ret = usbvideo_NewFrame(uvd, frameNum);
2025 if (ret < 0) {
2026 err("%s: usbvideo_NewFrame() failed (%d.)", __FUNCTION__, ret);
2027 return ret;
2028 }
2029 goto redo;
2030 }
2031 /* Note that we fall through to meet our destiny below */
2032 }
2033 case FrameState_Done:
2034 /*
2035 * Do all necessary postprocessing of data prepared in
2036 * "interrupt" code and the collecting code above. The
2037 * frame gets marked as FrameState_Done by queue parsing code.
2038 * This status means that we collected enough data and
2039 * most likely processed it as we went through. However
2040 * the data may need postprocessing, such as deinterlacing
2041 * or picture adjustments implemented in software (horror!)
2042 *
2043 * As soon as the frame becomes "final" it gets promoted to
2044 * FrameState_Done_Hold status where it will remain until the
2045 * caller consumed all the video data from the frame. Then
2046 * the empty shell of ex-frame is thrown out for dogs to eat.
2047 * But we, worried about pets, will recycle the frame!
2048 */
2049 uvd->stats.frame_num++;
2050 if ((uvd->flags & FLAGS_NO_DECODING) == 0) {
2051 if (VALID_CALLBACK(uvd, postProcess))
2052 GET_CALLBACK(uvd, postProcess)(uvd, frame);
2053 if (frame->flags & USBVIDEO_FRAME_FLAG_SOFTWARE_CONTRAST)
2054 usbvideo_SoftwareContrastAdjustment(uvd, frame);
2055 }
2056 frame->frameState = FrameState_Done_Hold;
2057 if (uvd->debug >= 2)
2058 info("%s: Entered FrameState_Done_Hold state.", __FUNCTION__);
2059 return 0;
2060
2061 case FrameState_Done_Hold:
2062 /*
2063 * We stay in this state indefinitely until someone external,
2064 * like ioctl() or read() call finishes digesting the frame
2065 * data. Then it will mark the frame as FrameState_Unused and
2066 * it will be released back into the wild to roam freely.
2067 */
2068 if (uvd->debug >= 2)
2069 info("%s: FrameState_Done_Hold state.", __FUNCTION__);
2070 return 0;
2071 }
2072
2073 /* Catch-all for other cases. We shall not be here. */
2074 err("%s: Invalid state %d.", __FUNCTION__, frame->frameState);
2075 frame->frameState = FrameState_Unused;
2076 return 0;
2077}
2078
2079/*
2080 * usbvideo_DeinterlaceFrame()
2081 *
2082 * This procedure deinterlaces the given frame. Some cameras produce
2083 * only half of scanlines - sometimes only even lines, sometimes only
2084 * odd lines. The deinterlacing method is stored in frame->deinterlace
2085 * variable.
2086 *
2087 * Here we scan the frame vertically and replace missing scanlines with
2088 * average between surrounding ones - before and after. If we have no
2089 * line above then we just copy next line. Similarly, if we need to
2090 * create a last line then preceding line is used.
2091 */
2092void usbvideo_DeinterlaceFrame(struct uvd *uvd, struct usbvideo_frame *frame)
2093{
2094 if ((uvd == NULL) || (frame == NULL))
2095 return;
2096
2097 if ((frame->deinterlace == Deinterlace_FillEvenLines) ||
2098 (frame->deinterlace == Deinterlace_FillOddLines))
2099 {
2100 const int v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL;
2101 int i = (frame->deinterlace == Deinterlace_FillEvenLines) ? 0 : 1;
2102
2103 for (; i < VIDEOSIZE_Y(frame->request); i += 2) {
2104 const unsigned char *fs1, *fs2;
2105 unsigned char *fd;
2106 int ip, in, j; /* Previous and next lines */
2107
2108 /*
2109 * Need to average lines before and after 'i'.
2110 * If we go out of bounds seeking those lines then
2111 * we point back to existing line.
2112 */
2113 ip = i - 1; /* First, get rough numbers */
2114 in = i + 1;
2115
2116 /* Now validate */
2117 if (ip < 0)
2118 ip = in;
2119 if (in >= VIDEOSIZE_Y(frame->request))
2120 in = ip;
2121
2122 /* Sanity check */
2123 if ((ip < 0) || (in < 0) ||
2124 (ip >= VIDEOSIZE_Y(frame->request)) ||
2125 (in >= VIDEOSIZE_Y(frame->request)))
2126 {
2127 err("Error: ip=%d. in=%d. req.height=%ld.",
2128 ip, in, VIDEOSIZE_Y(frame->request));
2129 break;
2130 }
2131
2132 /* Now we need to average lines 'ip' and 'in' to produce line 'i' */
2133 fs1 = frame->data + (v4l_linesize * ip);
2134 fs2 = frame->data + (v4l_linesize * in);
2135 fd = frame->data + (v4l_linesize * i);
2136
2137 /* Average lines around destination */
2138 for (j=0; j < v4l_linesize; j++) {
2139 fd[j] = (unsigned char)((((unsigned) fs1[j]) +
2140 ((unsigned)fs2[j])) >> 1);
2141 }
2142 }
2143 }
2144
2145 /* Optionally display statistics on the screen */
2146 if (uvd->flags & FLAGS_OVERLAY_STATS)
2147 usbvideo_OverlayStats(uvd, frame);
2148}
2149
2150EXPORT_SYMBOL(usbvideo_DeinterlaceFrame);
2151
2152/*
2153 * usbvideo_SoftwareContrastAdjustment()
2154 *
2155 * This code adjusts the contrast of the frame, assuming RGB24 format.
2156 * As most software image processing, this job is CPU-intensive.
2157 * Get a camera that supports hardware adjustment!
2158 *
2159 * History:
2160 * 09-Feb-2001 Created.
2161 */
2162static void usbvideo_SoftwareContrastAdjustment(struct uvd *uvd,
2163 struct usbvideo_frame *frame)
2164{
2165 int i, j, v4l_linesize;
2166 signed long adj;
2167 const int ccm = 128; /* Color correction median - see below */
2168
2169 if ((uvd == NULL) || (frame == NULL)) {
2170 err("%s: Illegal call.", __FUNCTION__);
2171 return;
2172 }
2173 adj = (uvd->vpic.contrast - 0x8000) >> 8; /* -128..+127 = -ccm..+(ccm-1)*/
2174 RESTRICT_TO_RANGE(adj, -ccm, ccm+1);
2175 if (adj == 0) {
2176 /* In rare case of no adjustment */
2177 return;
2178 }
2179 v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL;
2180 for (i=0; i < VIDEOSIZE_Y(frame->request); i++) {
2181 unsigned char *fd = frame->data + (v4l_linesize * i);
2182 for (j=0; j < v4l_linesize; j++) {
2183 signed long v = (signed long) fd[j];
2184 /* Magnify up to 2 times, reduce down to zero */
2185 v = 128 + ((ccm + adj) * (v - 128)) / ccm;
2186 RESTRICT_TO_RANGE(v, 0, 0xFF); /* Must flatten tails */
2187 fd[j] = (unsigned char) v;
2188 }
2189 }
2190}
2191
2192MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-17 20:37:41 -0500