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