V4L/DVB (10642): vivi: update comment to reflect that vivi can now create more than...
[linux-2.6.git] / drivers / media / video / vivi.c
1 /*
2  * Virtual Video driver - This code emulates a real video device with v4l2 api
3  *
4  * Copyright (c) 2006 by:
5  *      Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
6  *      Ted Walther <ted--a.t--enumera.com>
7  *      John Sokol <sokol--a.t--videotechnology.com>
8  *      http://v4l.videotechnology.com/
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the BSD Licence, GNU General Public License
12  * as published by the Free Software Foundation; either version 2 of the
13  * License, or (at your option) any later version
14  */
15 #include <linux/module.h>
16 #include <linux/delay.h>
17 #include <linux/errno.h>
18 #include <linux/fs.h>
19 #include <linux/kernel.h>
20 #include <linux/slab.h>
21 #include <linux/mm.h>
22 #include <linux/ioport.h>
23 #include <linux/init.h>
24 #include <linux/sched.h>
25 #include <linux/pci.h>
26 #include <linux/random.h>
27 #include <linux/version.h>
28 #include <linux/mutex.h>
29 #include <linux/videodev2.h>
30 #include <linux/dma-mapping.h>
31 #ifdef CONFIG_VIDEO_V4L1_COMPAT
32 /* Include V4L1 specific functions. Should be removed soon */
33 #include <linux/videodev.h>
34 #endif
35 #include <linux/interrupt.h>
36 #include <media/videobuf-vmalloc.h>
37 #include <media/v4l2-common.h>
38 #include <media/v4l2-ioctl.h>
39 #include <linux/kthread.h>
40 #include <linux/highmem.h>
41 #include <linux/freezer.h>
42
43 #define VIVI_MODULE_NAME "vivi"
44
45 /* Wake up at about 30 fps */
46 #define WAKE_NUMERATOR 30
47 #define WAKE_DENOMINATOR 1001
48 #define BUFFER_TIMEOUT     msecs_to_jiffies(500)  /* 0.5 seconds */
49
50 #include "font.h"
51
52 #define VIVI_MAJOR_VERSION 0
53 #define VIVI_MINOR_VERSION 5
54 #define VIVI_RELEASE 0
55 #define VIVI_VERSION \
56         KERNEL_VERSION(VIVI_MAJOR_VERSION, VIVI_MINOR_VERSION, VIVI_RELEASE)
57
58 /* Declare static vars that will be used as parameters */
59 static unsigned int vid_limit = 16;     /* Video memory limit, in Mb */
60 static int video_nr = -1;               /* /dev/videoN, -1 for autodetect */
61 static int n_devs = 1;                  /* Number of virtual devices */
62
63 /* supported controls */
64 static struct v4l2_queryctrl vivi_qctrl[] = {
65         {
66                 .id            = V4L2_CID_AUDIO_VOLUME,
67                 .name          = "Volume",
68                 .minimum       = 0,
69                 .maximum       = 65535,
70                 .step          = 65535/100,
71                 .default_value = 65535,
72                 .flags         = 0,
73                 .type          = V4L2_CTRL_TYPE_INTEGER,
74         }, {
75                 .id            = V4L2_CID_BRIGHTNESS,
76                 .type          = V4L2_CTRL_TYPE_INTEGER,
77                 .name          = "Brightness",
78                 .minimum       = 0,
79                 .maximum       = 255,
80                 .step          = 1,
81                 .default_value = 127,
82                 .flags         = 0,
83         }, {
84                 .id            = V4L2_CID_CONTRAST,
85                 .type          = V4L2_CTRL_TYPE_INTEGER,
86                 .name          = "Contrast",
87                 .minimum       = 0,
88                 .maximum       = 255,
89                 .step          = 0x1,
90                 .default_value = 0x10,
91                 .flags         = 0,
92         }, {
93                 .id            = V4L2_CID_SATURATION,
94                 .type          = V4L2_CTRL_TYPE_INTEGER,
95                 .name          = "Saturation",
96                 .minimum       = 0,
97                 .maximum       = 255,
98                 .step          = 0x1,
99                 .default_value = 127,
100                 .flags         = 0,
101         }, {
102                 .id            = V4L2_CID_HUE,
103                 .type          = V4L2_CTRL_TYPE_INTEGER,
104                 .name          = "Hue",
105                 .minimum       = -128,
106                 .maximum       = 127,
107                 .step          = 0x1,
108                 .default_value = 0,
109                 .flags         = 0,
110         }
111 };
112
113 static int qctl_regs[ARRAY_SIZE(vivi_qctrl)];
114
115 #define dprintk(dev, level, fmt, arg...)                                \
116         do {                                                            \
117                 if (dev->vfd->debug >= (level))                         \
118                         printk(KERN_DEBUG "vivi: " fmt , ## arg);       \
119         } while (0)
120
121 /* ------------------------------------------------------------------
122         Basic structures
123    ------------------------------------------------------------------*/
124
125 struct vivi_fmt {
126         char  *name;
127         u32   fourcc;          /* v4l2 format id */
128         int   depth;
129 };
130
131 static struct vivi_fmt formats[] = {
132         {
133                 .name     = "4:2:2, packed, YUYV",
134                 .fourcc   = V4L2_PIX_FMT_YUYV,
135                 .depth    = 16,
136         },
137         {
138                 .name     = "4:2:2, packed, UYVY",
139                 .fourcc   = V4L2_PIX_FMT_UYVY,
140                 .depth    = 16,
141         },
142         {
143                 .name     = "RGB565 (LE)",
144                 .fourcc   = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
145                 .depth    = 16,
146         },
147         {
148                 .name     = "RGB565 (BE)",
149                 .fourcc   = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
150                 .depth    = 16,
151         },
152         {
153                 .name     = "RGB555 (LE)",
154                 .fourcc   = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
155                 .depth    = 16,
156         },
157         {
158                 .name     = "RGB555 (BE)",
159                 .fourcc   = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
160                 .depth    = 16,
161         },
162 };
163
164 static struct vivi_fmt *get_format(struct v4l2_format *f)
165 {
166         struct vivi_fmt *fmt;
167         unsigned int k;
168
169         for (k = 0; k < ARRAY_SIZE(formats); k++) {
170                 fmt = &formats[k];
171                 if (fmt->fourcc == f->fmt.pix.pixelformat)
172                         break;
173         }
174
175         if (k == ARRAY_SIZE(formats))
176                 return NULL;
177
178         return &formats[k];
179 }
180
181 struct sg_to_addr {
182         int pos;
183         struct scatterlist *sg;
184 };
185
186 /* buffer for one video frame */
187 struct vivi_buffer {
188         /* common v4l buffer stuff -- must be first */
189         struct videobuf_buffer vb;
190
191         struct vivi_fmt        *fmt;
192 };
193
194 struct vivi_dmaqueue {
195         struct list_head       active;
196
197         /* thread for generating video stream*/
198         struct task_struct         *kthread;
199         wait_queue_head_t          wq;
200         /* Counters to control fps rate */
201         int                        frame;
202         int                        ini_jiffies;
203 };
204
205 static LIST_HEAD(vivi_devlist);
206
207 struct vivi_dev {
208         struct list_head           vivi_devlist;
209
210         spinlock_t                 slock;
211         struct mutex               mutex;
212
213         int                        users;
214
215         /* various device info */
216         struct video_device        *vfd;
217
218         struct vivi_dmaqueue       vidq;
219
220         /* Several counters */
221         int                        h, m, s, ms;
222         unsigned long              jiffies;
223         char                       timestr[13];
224
225         int                        mv_count;    /* Controls bars movement */
226
227         /* Input Number */
228         int                        input;
229 };
230
231 struct vivi_fh {
232         struct vivi_dev            *dev;
233
234         /* video capture */
235         struct vivi_fmt            *fmt;
236         unsigned int               width, height;
237         struct videobuf_queue      vb_vidq;
238
239         enum v4l2_buf_type         type;
240         unsigned char              bars[8][3];
241         int                        input;       /* Input Number on bars */
242 };
243
244 /* ------------------------------------------------------------------
245         DMA and thread functions
246    ------------------------------------------------------------------*/
247
248 /* Bars and Colors should match positions */
249
250 enum colors {
251         WHITE,
252         AMBAR,
253         CYAN,
254         GREEN,
255         MAGENTA,
256         RED,
257         BLUE,
258         BLACK,
259 };
260
261         /* R   G   B */
262 #define COLOR_WHITE     {204, 204, 204}
263 #define COLOR_AMBAR     {208, 208,   0}
264 #define COLOR_CIAN      {  0, 206, 206}
265 #define COLOR_GREEN     {  0, 239,   0}
266 #define COLOR_MAGENTA   {239,   0, 239}
267 #define COLOR_RED       {205,   0,   0}
268 #define COLOR_BLUE      {  0,   0, 255}
269 #define COLOR_BLACK     {  0,   0,   0}
270
271 struct bar_std {
272         u8 bar[8][3];
273 };
274
275 /* Maximum number of bars are 10 - otherwise, the input print code
276    should be modified */
277 static struct bar_std bars[] = {
278         {       /* Standard ITU-R color bar sequence */
279                 {
280                         COLOR_WHITE,
281                         COLOR_AMBAR,
282                         COLOR_CIAN,
283                         COLOR_GREEN,
284                         COLOR_MAGENTA,
285                         COLOR_RED,
286                         COLOR_BLUE,
287                         COLOR_BLACK,
288                 }
289         }, {
290                 {
291                         COLOR_WHITE,
292                         COLOR_AMBAR,
293                         COLOR_BLACK,
294                         COLOR_WHITE,
295                         COLOR_AMBAR,
296                         COLOR_BLACK,
297                         COLOR_WHITE,
298                         COLOR_AMBAR,
299                 }
300         }, {
301                 {
302                         COLOR_WHITE,
303                         COLOR_CIAN,
304                         COLOR_BLACK,
305                         COLOR_WHITE,
306                         COLOR_CIAN,
307                         COLOR_BLACK,
308                         COLOR_WHITE,
309                         COLOR_CIAN,
310                 }
311         }, {
312                 {
313                         COLOR_WHITE,
314                         COLOR_GREEN,
315                         COLOR_BLACK,
316                         COLOR_WHITE,
317                         COLOR_GREEN,
318                         COLOR_BLACK,
319                         COLOR_WHITE,
320                         COLOR_GREEN,
321                 }
322         },
323 };
324
325 #define NUM_INPUTS ARRAY_SIZE(bars)
326
327 #define TO_Y(r, g, b) \
328         (((16829 * r + 33039 * g + 6416 * b  + 32768) >> 16) + 16)
329 /* RGB to  V(Cr) Color transform */
330 #define TO_V(r, g, b) \
331         (((28784 * r - 24103 * g - 4681 * b  + 32768) >> 16) + 128)
332 /* RGB to  U(Cb) Color transform */
333 #define TO_U(r, g, b) \
334         (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
335
336 #define TSTAMP_MIN_Y    24
337 #define TSTAMP_MAX_Y    (TSTAMP_MIN_Y + 15)
338 #define TSTAMP_INPUT_X  10
339 #define TSTAMP_MIN_X    (54 + TSTAMP_INPUT_X)
340
341 static void gen_twopix(struct vivi_fh *fh, unsigned char *buf, int colorpos)
342 {
343         unsigned char r_y, g_u, b_v;
344         unsigned char *p;
345         int color;
346
347         r_y = fh->bars[colorpos][0]; /* R or precalculated Y */
348         g_u = fh->bars[colorpos][1]; /* G or precalculated U */
349         b_v = fh->bars[colorpos][2]; /* B or precalculated V */
350
351         for (color = 0; color < 4; color++) {
352                 p = buf + color;
353
354                 switch (fh->fmt->fourcc) {
355                 case V4L2_PIX_FMT_YUYV:
356                         switch (color) {
357                         case 0:
358                         case 2:
359                                 *p = r_y;
360                                 break;
361                         case 1:
362                                 *p = g_u;
363                                 break;
364                         case 3:
365                                 *p = b_v;
366                                 break;
367                         }
368                         break;
369                 case V4L2_PIX_FMT_UYVY:
370                         switch (color) {
371                         case 1:
372                         case 3:
373                                 *p = r_y;
374                                 break;
375                         case 0:
376                                 *p = g_u;
377                                 break;
378                         case 2:
379                                 *p = b_v;
380                                 break;
381                         }
382                         break;
383                 case V4L2_PIX_FMT_RGB565:
384                         switch (color) {
385                         case 0:
386                         case 2:
387                                 *p = (g_u << 5) | b_v;
388                                 break;
389                         case 1:
390                         case 3:
391                                 *p = (r_y << 3) | (g_u >> 3);
392                                 break;
393                         }
394                         break;
395                 case V4L2_PIX_FMT_RGB565X:
396                         switch (color) {
397                         case 0:
398                         case 2:
399                                 *p = (r_y << 3) | (g_u >> 3);
400                                 break;
401                         case 1:
402                         case 3:
403                                 *p = (g_u << 5) | b_v;
404                                 break;
405                         }
406                         break;
407                 case V4L2_PIX_FMT_RGB555:
408                         switch (color) {
409                         case 0:
410                         case 2:
411                                 *p = (g_u << 5) | b_v;
412                                 break;
413                         case 1:
414                         case 3:
415                                 *p = (r_y << 2) | (g_u >> 3);
416                                 break;
417                         }
418                         break;
419                 case V4L2_PIX_FMT_RGB555X:
420                         switch (color) {
421                         case 0:
422                         case 2:
423                                 *p = (r_y << 2) | (g_u >> 3);
424                                 break;
425                         case 1:
426                         case 3:
427                                 *p = (g_u << 5) | b_v;
428                                 break;
429                         }
430                         break;
431                 }
432         }
433 }
434
435 static void gen_line(struct vivi_fh *fh, char *basep, int inipos, int wmax,
436                 int hmax, int line, int count, char *timestr)
437 {
438         int  w, i, j;
439         int pos = inipos;
440         char *s;
441         u8 chr;
442
443         /* We will just duplicate the second pixel at the packet */
444         wmax /= 2;
445
446         /* Generate a standard color bar pattern */
447         for (w = 0; w < wmax; w++) {
448                 int colorpos = ((w + count) * 8/(wmax + 1)) % 8;
449
450                 gen_twopix(fh, basep + pos, colorpos);
451                 pos += 4; /* only 16 bpp supported for now */
452         }
453
454         /* Prints input entry number */
455
456         /* Checks if it is possible to input number */
457         if (TSTAMP_MAX_Y >= hmax)
458                 goto end;
459
460         if (TSTAMP_INPUT_X + strlen(timestr) >= wmax)
461                 goto end;
462
463         if (line >= TSTAMP_MIN_Y && line <= TSTAMP_MAX_Y) {
464                 chr = rom8x16_bits[fh->input * 16 + line - TSTAMP_MIN_Y];
465                 pos = TSTAMP_INPUT_X;
466                 for (i = 0; i < 7; i++) {
467                         /* Draw white font on black background */
468                         if (chr & 1 << (7 - i))
469                                 gen_twopix(fh, basep + pos, WHITE);
470                         else
471                                 gen_twopix(fh, basep + pos, BLACK);
472                         pos += 2;
473                 }
474         }
475
476         /* Checks if it is possible to show timestamp */
477         if (TSTAMP_MIN_X + strlen(timestr) >= wmax)
478                 goto end;
479
480         /* Print stream time */
481         if (line >= TSTAMP_MIN_Y && line <= TSTAMP_MAX_Y) {
482                 j = TSTAMP_MIN_X;
483                 for (s = timestr; *s; s++) {
484                         chr = rom8x16_bits[(*s-0x30)*16+line-TSTAMP_MIN_Y];
485                         for (i = 0; i < 7; i++) {
486                                 pos = inipos + j * 2;
487                                 /* Draw white font on black background */
488                                 if (chr & 1 << (7 - i))
489                                         gen_twopix(fh, basep + pos, WHITE);
490                                 else
491                                         gen_twopix(fh, basep + pos, BLACK);
492                                 j++;
493                         }
494                 }
495         }
496
497 end:
498         return;
499 }
500
501 static void vivi_fillbuff(struct vivi_fh *fh, struct vivi_buffer *buf)
502 {
503         struct vivi_dev *dev = fh->dev;
504         int h , pos = 0;
505         int hmax  = buf->vb.height;
506         int wmax  = buf->vb.width;
507         struct timeval ts;
508         char *tmpbuf;
509         void *vbuf = videobuf_to_vmalloc(&buf->vb);
510
511         if (!vbuf)
512                 return;
513
514         tmpbuf = kmalloc(wmax * 2, GFP_ATOMIC);
515         if (!tmpbuf)
516                 return;
517
518         for (h = 0; h < hmax; h++) {
519                 gen_line(fh, tmpbuf, 0, wmax, hmax, h, dev->mv_count,
520                          dev->timestr);
521                 memcpy(vbuf + pos, tmpbuf, wmax * 2);
522                 pos += wmax*2;
523         }
524
525         dev->mv_count++;
526
527         kfree(tmpbuf);
528
529         /* Updates stream time */
530
531         dev->ms += jiffies_to_msecs(jiffies-dev->jiffies);
532         dev->jiffies = jiffies;
533         if (dev->ms >= 1000) {
534                 dev->ms -= 1000;
535                 dev->s++;
536                 if (dev->s >= 60) {
537                         dev->s -= 60;
538                         dev->m++;
539                         if (dev->m > 60) {
540                                 dev->m -= 60;
541                                 dev->h++;
542                                 if (dev->h > 24)
543                                         dev->h -= 24;
544                         }
545                 }
546         }
547         sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
548                         dev->h, dev->m, dev->s, dev->ms);
549
550         dprintk(dev, 2, "vivifill at %s: Buffer 0x%08lx size= %d\n",
551                         dev->timestr, (unsigned long)tmpbuf, pos);
552
553         /* Advice that buffer was filled */
554         buf->vb.field_count++;
555         do_gettimeofday(&ts);
556         buf->vb.ts = ts;
557         buf->vb.state = VIDEOBUF_DONE;
558 }
559
560 static void vivi_thread_tick(struct vivi_fh *fh)
561 {
562         struct vivi_buffer *buf;
563         struct vivi_dev *dev = fh->dev;
564         struct vivi_dmaqueue *dma_q = &dev->vidq;
565
566         unsigned long flags = 0;
567
568         dprintk(dev, 1, "Thread tick\n");
569
570         spin_lock_irqsave(&dev->slock, flags);
571         if (list_empty(&dma_q->active)) {
572                 dprintk(dev, 1, "No active queue to serve\n");
573                 goto unlock;
574         }
575
576         buf = list_entry(dma_q->active.next,
577                          struct vivi_buffer, vb.queue);
578
579         /* Nobody is waiting on this buffer, return */
580         if (!waitqueue_active(&buf->vb.done))
581                 goto unlock;
582
583         list_del(&buf->vb.queue);
584
585         do_gettimeofday(&buf->vb.ts);
586
587         /* Fill buffer */
588         vivi_fillbuff(fh, buf);
589         dprintk(dev, 1, "filled buffer %p\n", buf);
590
591         wake_up(&buf->vb.done);
592         dprintk(dev, 2, "[%p/%d] wakeup\n", buf, buf->vb. i);
593 unlock:
594         spin_unlock_irqrestore(&dev->slock, flags);
595         return;
596 }
597
598 #define frames_to_ms(frames)                                    \
599         ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
600
601 static void vivi_sleep(struct vivi_fh *fh)
602 {
603         struct vivi_dev *dev = fh->dev;
604         struct vivi_dmaqueue *dma_q = &dev->vidq;
605         int timeout;
606         DECLARE_WAITQUEUE(wait, current);
607
608         dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
609                 (unsigned long)dma_q);
610
611         add_wait_queue(&dma_q->wq, &wait);
612         if (kthread_should_stop())
613                 goto stop_task;
614
615         /* Calculate time to wake up */
616         timeout = msecs_to_jiffies(frames_to_ms(1));
617
618         vivi_thread_tick(fh);
619
620         schedule_timeout_interruptible(timeout);
621
622 stop_task:
623         remove_wait_queue(&dma_q->wq, &wait);
624         try_to_freeze();
625 }
626
627 static int vivi_thread(void *data)
628 {
629         struct vivi_fh  *fh = data;
630         struct vivi_dev *dev = fh->dev;
631
632         dprintk(dev, 1, "thread started\n");
633
634         set_freezable();
635
636         for (;;) {
637                 vivi_sleep(fh);
638
639                 if (kthread_should_stop())
640                         break;
641         }
642         dprintk(dev, 1, "thread: exit\n");
643         return 0;
644 }
645
646 static int vivi_start_thread(struct vivi_fh *fh)
647 {
648         struct vivi_dev *dev = fh->dev;
649         struct vivi_dmaqueue *dma_q = &dev->vidq;
650
651         dma_q->frame = 0;
652         dma_q->ini_jiffies = jiffies;
653
654         dprintk(dev, 1, "%s\n", __func__);
655
656         dma_q->kthread = kthread_run(vivi_thread, fh, "vivi");
657
658         if (IS_ERR(dma_q->kthread)) {
659                 printk(KERN_ERR "vivi: kernel_thread() failed\n");
660                 return PTR_ERR(dma_q->kthread);
661         }
662         /* Wakes thread */
663         wake_up_interruptible(&dma_q->wq);
664
665         dprintk(dev, 1, "returning from %s\n", __func__);
666         return 0;
667 }
668
669 static void vivi_stop_thread(struct vivi_dmaqueue  *dma_q)
670 {
671         struct vivi_dev *dev = container_of(dma_q, struct vivi_dev, vidq);
672
673         dprintk(dev, 1, "%s\n", __func__);
674         /* shutdown control thread */
675         if (dma_q->kthread) {
676                 kthread_stop(dma_q->kthread);
677                 dma_q->kthread = NULL;
678         }
679 }
680
681 /* ------------------------------------------------------------------
682         Videobuf operations
683    ------------------------------------------------------------------*/
684 static int
685 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
686 {
687         struct vivi_fh  *fh = vq->priv_data;
688         struct vivi_dev *dev  = fh->dev;
689
690         *size = fh->width*fh->height*2;
691
692         if (0 == *count)
693                 *count = 32;
694
695         while (*size * *count > vid_limit * 1024 * 1024)
696                 (*count)--;
697
698         dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__,
699                 *count, *size);
700
701         return 0;
702 }
703
704 static void free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
705 {
706         struct vivi_fh  *fh = vq->priv_data;
707         struct vivi_dev *dev  = fh->dev;
708
709         dprintk(dev, 1, "%s, state: %i\n", __func__, buf->vb.state);
710
711         if (in_interrupt())
712                 BUG();
713
714         videobuf_vmalloc_free(&buf->vb);
715         dprintk(dev, 1, "free_buffer: freed\n");
716         buf->vb.state = VIDEOBUF_NEEDS_INIT;
717 }
718
719 #define norm_maxw() 1024
720 #define norm_maxh() 768
721 static int
722 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
723                                                 enum v4l2_field field)
724 {
725         struct vivi_fh     *fh  = vq->priv_data;
726         struct vivi_dev    *dev = fh->dev;
727         struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
728         int rc;
729
730         dprintk(dev, 1, "%s, field=%d\n", __func__, field);
731
732         BUG_ON(NULL == fh->fmt);
733
734         if (fh->width  < 48 || fh->width  > norm_maxw() ||
735             fh->height < 32 || fh->height > norm_maxh())
736                 return -EINVAL;
737
738         buf->vb.size = fh->width*fh->height*2;
739         if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
740                 return -EINVAL;
741
742         /* These properties only change when queue is idle, see s_fmt */
743         buf->fmt       = fh->fmt;
744         buf->vb.width  = fh->width;
745         buf->vb.height = fh->height;
746         buf->vb.field  = field;
747
748         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
749                 rc = videobuf_iolock(vq, &buf->vb, NULL);
750                 if (rc < 0)
751                         goto fail;
752         }
753
754         buf->vb.state = VIDEOBUF_PREPARED;
755
756         return 0;
757
758 fail:
759         free_buffer(vq, buf);
760         return rc;
761 }
762
763 static void
764 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
765 {
766         struct vivi_buffer    *buf  = container_of(vb, struct vivi_buffer, vb);
767         struct vivi_fh        *fh   = vq->priv_data;
768         struct vivi_dev       *dev  = fh->dev;
769         struct vivi_dmaqueue *vidq = &dev->vidq;
770
771         dprintk(dev, 1, "%s\n", __func__);
772
773         buf->vb.state = VIDEOBUF_QUEUED;
774         list_add_tail(&buf->vb.queue, &vidq->active);
775 }
776
777 static void buffer_release(struct videobuf_queue *vq,
778                            struct videobuf_buffer *vb)
779 {
780         struct vivi_buffer   *buf  = container_of(vb, struct vivi_buffer, vb);
781         struct vivi_fh       *fh   = vq->priv_data;
782         struct vivi_dev      *dev  = (struct vivi_dev *)fh->dev;
783
784         dprintk(dev, 1, "%s\n", __func__);
785
786         free_buffer(vq, buf);
787 }
788
789 static struct videobuf_queue_ops vivi_video_qops = {
790         .buf_setup      = buffer_setup,
791         .buf_prepare    = buffer_prepare,
792         .buf_queue      = buffer_queue,
793         .buf_release    = buffer_release,
794 };
795
796 /* ------------------------------------------------------------------
797         IOCTL vidioc handling
798    ------------------------------------------------------------------*/
799 static int vidioc_querycap(struct file *file, void  *priv,
800                                         struct v4l2_capability *cap)
801 {
802         strcpy(cap->driver, "vivi");
803         strcpy(cap->card, "vivi");
804         cap->version = VIVI_VERSION;
805         cap->capabilities =     V4L2_CAP_VIDEO_CAPTURE |
806                                 V4L2_CAP_STREAMING     |
807                                 V4L2_CAP_READWRITE;
808         return 0;
809 }
810
811 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
812                                         struct v4l2_fmtdesc *f)
813 {
814         struct vivi_fmt *fmt;
815
816         if (f->index >= ARRAY_SIZE(formats))
817                 return -EINVAL;
818
819         fmt = &formats[f->index];
820
821         strlcpy(f->description, fmt->name, sizeof(f->description));
822         f->pixelformat = fmt->fourcc;
823         return 0;
824 }
825
826 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
827                                         struct v4l2_format *f)
828 {
829         struct vivi_fh *fh = priv;
830
831         f->fmt.pix.width        = fh->width;
832         f->fmt.pix.height       = fh->height;
833         f->fmt.pix.field        = fh->vb_vidq.field;
834         f->fmt.pix.pixelformat  = fh->fmt->fourcc;
835         f->fmt.pix.bytesperline =
836                 (f->fmt.pix.width * fh->fmt->depth) >> 3;
837         f->fmt.pix.sizeimage =
838                 f->fmt.pix.height * f->fmt.pix.bytesperline;
839
840         return (0);
841 }
842
843 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
844                         struct v4l2_format *f)
845 {
846         struct vivi_fh  *fh  = priv;
847         struct vivi_dev *dev = fh->dev;
848         struct vivi_fmt *fmt;
849         enum v4l2_field field;
850         unsigned int maxw, maxh;
851
852         fmt = get_format(f);
853         if (!fmt) {
854                 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
855                         f->fmt.pix.pixelformat);
856                 return -EINVAL;
857         }
858
859         field = f->fmt.pix.field;
860
861         if (field == V4L2_FIELD_ANY) {
862                 field = V4L2_FIELD_INTERLACED;
863         } else if (V4L2_FIELD_INTERLACED != field) {
864                 dprintk(dev, 1, "Field type invalid.\n");
865                 return -EINVAL;
866         }
867
868         maxw  = norm_maxw();
869         maxh  = norm_maxh();
870
871         f->fmt.pix.field = field;
872         if (f->fmt.pix.height < 32)
873                 f->fmt.pix.height = 32;
874         if (f->fmt.pix.height > maxh)
875                 f->fmt.pix.height = maxh;
876         if (f->fmt.pix.width < 48)
877                 f->fmt.pix.width = 48;
878         if (f->fmt.pix.width > maxw)
879                 f->fmt.pix.width = maxw;
880         f->fmt.pix.width &= ~0x03;
881         f->fmt.pix.bytesperline =
882                 (f->fmt.pix.width * fmt->depth) >> 3;
883         f->fmt.pix.sizeimage =
884                 f->fmt.pix.height * f->fmt.pix.bytesperline;
885
886         return 0;
887 }
888
889 /* precalculate color bar values to speed up rendering */
890 static void precalculate_bars(struct vivi_fh *fh)
891 {
892         struct vivi_dev *dev = fh->dev;
893         unsigned char r, g, b;
894         int k, is_yuv;
895
896         fh->input = dev->input;
897
898         for (k = 0; k < 8; k++) {
899                 r = bars[fh->input].bar[k][0];
900                 g = bars[fh->input].bar[k][1];
901                 b = bars[fh->input].bar[k][2];
902                 is_yuv = 0;
903
904                 switch (fh->fmt->fourcc) {
905                 case V4L2_PIX_FMT_YUYV:
906                 case V4L2_PIX_FMT_UYVY:
907                         is_yuv = 1;
908                         break;
909                 case V4L2_PIX_FMT_RGB565:
910                 case V4L2_PIX_FMT_RGB565X:
911                         r >>= 3;
912                         g >>= 2;
913                         b >>= 3;
914                         break;
915                 case V4L2_PIX_FMT_RGB555:
916                 case V4L2_PIX_FMT_RGB555X:
917                         r >>= 3;
918                         g >>= 3;
919                         b >>= 3;
920                         break;
921                 }
922
923                 if (is_yuv) {
924                         fh->bars[k][0] = TO_Y(r, g, b); /* Luma */
925                         fh->bars[k][1] = TO_U(r, g, b); /* Cb */
926                         fh->bars[k][2] = TO_V(r, g, b); /* Cr */
927                 } else {
928                         fh->bars[k][0] = r;
929                         fh->bars[k][1] = g;
930                         fh->bars[k][2] = b;
931                 }
932         }
933
934 }
935
936 /*FIXME: This seems to be generic enough to be at videodev2 */
937 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
938                                         struct v4l2_format *f)
939 {
940         struct vivi_fh *fh = priv;
941         struct videobuf_queue *q = &fh->vb_vidq;
942
943         int ret = vidioc_try_fmt_vid_cap(file, fh, f);
944         if (ret < 0)
945                 return ret;
946
947         mutex_lock(&q->vb_lock);
948
949         if (videobuf_queue_is_busy(&fh->vb_vidq)) {
950                 dprintk(fh->dev, 1, "%s queue busy\n", __func__);
951                 ret = -EBUSY;
952                 goto out;
953         }
954
955         fh->fmt           = get_format(f);
956         fh->width         = f->fmt.pix.width;
957         fh->height        = f->fmt.pix.height;
958         fh->vb_vidq.field = f->fmt.pix.field;
959         fh->type          = f->type;
960
961         precalculate_bars(fh);
962
963         ret = 0;
964 out:
965         mutex_unlock(&q->vb_lock);
966
967         return ret;
968 }
969
970 static int vidioc_reqbufs(struct file *file, void *priv,
971                           struct v4l2_requestbuffers *p)
972 {
973         struct vivi_fh  *fh = priv;
974
975         return (videobuf_reqbufs(&fh->vb_vidq, p));
976 }
977
978 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
979 {
980         struct vivi_fh  *fh = priv;
981
982         return (videobuf_querybuf(&fh->vb_vidq, p));
983 }
984
985 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
986 {
987         struct vivi_fh *fh = priv;
988
989         return (videobuf_qbuf(&fh->vb_vidq, p));
990 }
991
992 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
993 {
994         struct vivi_fh  *fh = priv;
995
996         return (videobuf_dqbuf(&fh->vb_vidq, p,
997                                 file->f_flags & O_NONBLOCK));
998 }
999
1000 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1001 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1002 {
1003         struct vivi_fh  *fh = priv;
1004
1005         return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1006 }
1007 #endif
1008
1009 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1010 {
1011         struct vivi_fh  *fh = priv;
1012
1013         if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1014                 return -EINVAL;
1015         if (i != fh->type)
1016                 return -EINVAL;
1017
1018         return videobuf_streamon(&fh->vb_vidq);
1019 }
1020
1021 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1022 {
1023         struct vivi_fh  *fh = priv;
1024
1025         if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1026                 return -EINVAL;
1027         if (i != fh->type)
1028                 return -EINVAL;
1029
1030         return videobuf_streamoff(&fh->vb_vidq);
1031 }
1032
1033 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1034 {
1035         return 0;
1036 }
1037
1038 /* only one input in this sample driver */
1039 static int vidioc_enum_input(struct file *file, void *priv,
1040                                 struct v4l2_input *inp)
1041 {
1042         if (inp->index >= NUM_INPUTS)
1043                 return -EINVAL;
1044
1045         inp->type = V4L2_INPUT_TYPE_CAMERA;
1046         inp->std = V4L2_STD_525_60;
1047         sprintf(inp->name, "Camera %u", inp->index);
1048
1049         return (0);
1050 }
1051
1052 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1053 {
1054         struct vivi_fh *fh = priv;
1055         struct vivi_dev *dev = fh->dev;
1056
1057         *i = dev->input;
1058
1059         return (0);
1060 }
1061 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1062 {
1063         struct vivi_fh *fh = priv;
1064         struct vivi_dev *dev = fh->dev;
1065
1066         if (i >= NUM_INPUTS)
1067                 return -EINVAL;
1068
1069         dev->input = i;
1070         precalculate_bars(fh);
1071
1072         return (0);
1073 }
1074
1075         /* --- controls ---------------------------------------------- */
1076 static int vidioc_queryctrl(struct file *file, void *priv,
1077                             struct v4l2_queryctrl *qc)
1078 {
1079         int i;
1080
1081         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1082                 if (qc->id && qc->id == vivi_qctrl[i].id) {
1083                         memcpy(qc, &(vivi_qctrl[i]),
1084                                 sizeof(*qc));
1085                         return (0);
1086                 }
1087
1088         return -EINVAL;
1089 }
1090
1091 static int vidioc_g_ctrl(struct file *file, void *priv,
1092                          struct v4l2_control *ctrl)
1093 {
1094         int i;
1095
1096         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1097                 if (ctrl->id == vivi_qctrl[i].id) {
1098                         ctrl->value = qctl_regs[i];
1099                         return (0);
1100                 }
1101
1102         return -EINVAL;
1103 }
1104 static int vidioc_s_ctrl(struct file *file, void *priv,
1105                                 struct v4l2_control *ctrl)
1106 {
1107         int i;
1108
1109         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1110                 if (ctrl->id == vivi_qctrl[i].id) {
1111                         if (ctrl->value < vivi_qctrl[i].minimum
1112                             || ctrl->value > vivi_qctrl[i].maximum) {
1113                                         return (-ERANGE);
1114                                 }
1115                         qctl_regs[i] = ctrl->value;
1116                         return (0);
1117                 }
1118         return -EINVAL;
1119 }
1120
1121 /* ------------------------------------------------------------------
1122         File operations for the device
1123    ------------------------------------------------------------------*/
1124
1125 static int vivi_open(struct file *file)
1126 {
1127         int minor = video_devdata(file)->minor;
1128         struct vivi_dev *dev;
1129         struct vivi_fh *fh = NULL;
1130         int i;
1131         int retval = 0;
1132
1133         printk(KERN_DEBUG "vivi: open called (minor=%d)\n", minor);
1134
1135         lock_kernel();
1136         list_for_each_entry(dev, &vivi_devlist, vivi_devlist)
1137                 if (dev->vfd->minor == minor)
1138                         goto found;
1139         unlock_kernel();
1140         return -ENODEV;
1141
1142 found:
1143         mutex_lock(&dev->mutex);
1144         dev->users++;
1145
1146         if (dev->users > 1) {
1147                 dev->users--;
1148                 retval = -EBUSY;
1149                 goto unlock;
1150         }
1151
1152         dprintk(dev, 1, "open minor=%d type=%s users=%d\n", minor,
1153                 v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
1154
1155         /* allocate + initialize per filehandle data */
1156         fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1157         if (NULL == fh) {
1158                 dev->users--;
1159                 retval = -ENOMEM;
1160                 goto unlock;
1161         }
1162 unlock:
1163         mutex_unlock(&dev->mutex);
1164         if (retval) {
1165                 unlock_kernel();
1166                 return retval;
1167         }
1168
1169         file->private_data = fh;
1170         fh->dev      = dev;
1171
1172         fh->type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1173         fh->fmt      = &formats[0];
1174         fh->width    = 640;
1175         fh->height   = 480;
1176
1177         /* Put all controls at a sane state */
1178         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1179                 qctl_regs[i] = vivi_qctrl[i].default_value;
1180
1181         /* Resets frame counters */
1182         dev->h = 0;
1183         dev->m = 0;
1184         dev->s = 0;
1185         dev->ms = 0;
1186         dev->mv_count = 0;
1187         dev->jiffies = jiffies;
1188         sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
1189                         dev->h, dev->m, dev->s, dev->ms);
1190
1191         videobuf_queue_vmalloc_init(&fh->vb_vidq, &vivi_video_qops,
1192                         NULL, &dev->slock, fh->type, V4L2_FIELD_INTERLACED,
1193                         sizeof(struct vivi_buffer), fh);
1194
1195         vivi_start_thread(fh);
1196         unlock_kernel();
1197
1198         return 0;
1199 }
1200
1201 static ssize_t
1202 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1203 {
1204         struct vivi_fh *fh = file->private_data;
1205
1206         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1207                 return videobuf_read_stream(&fh->vb_vidq, data, count, ppos, 0,
1208                                         file->f_flags & O_NONBLOCK);
1209         }
1210         return 0;
1211 }
1212
1213 static unsigned int
1214 vivi_poll(struct file *file, struct poll_table_struct *wait)
1215 {
1216         struct vivi_fh        *fh = file->private_data;
1217         struct vivi_dev       *dev = fh->dev;
1218         struct videobuf_queue *q = &fh->vb_vidq;
1219
1220         dprintk(dev, 1, "%s\n", __func__);
1221
1222         if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1223                 return POLLERR;
1224
1225         return videobuf_poll_stream(file, q, wait);
1226 }
1227
1228 static int vivi_close(struct file *file)
1229 {
1230         struct vivi_fh         *fh = file->private_data;
1231         struct vivi_dev *dev       = fh->dev;
1232         struct vivi_dmaqueue *vidq = &dev->vidq;
1233
1234         int minor = video_devdata(file)->minor;
1235
1236         vivi_stop_thread(vidq);
1237         videobuf_stop(&fh->vb_vidq);
1238         videobuf_mmap_free(&fh->vb_vidq);
1239
1240         kfree(fh);
1241
1242         mutex_lock(&dev->mutex);
1243         dev->users--;
1244         mutex_unlock(&dev->mutex);
1245
1246         dprintk(dev, 1, "close called (minor=%d, users=%d)\n",
1247                 minor, dev->users);
1248
1249         return 0;
1250 }
1251
1252 static int vivi_release(void)
1253 {
1254         struct vivi_dev *dev;
1255         struct list_head *list;
1256
1257         while (!list_empty(&vivi_devlist)) {
1258                 list = vivi_devlist.next;
1259                 list_del(list);
1260                 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1261
1262                 if (-1 != dev->vfd->minor) {
1263                         printk(KERN_INFO "%s: unregistering /dev/video%d\n",
1264                                 VIVI_MODULE_NAME, dev->vfd->num);
1265                         video_unregister_device(dev->vfd);
1266                 } else {
1267                         printk(KERN_INFO "%s: releasing /dev/video%d\n",
1268                                 VIVI_MODULE_NAME, dev->vfd->num);
1269                         video_device_release(dev->vfd);
1270                 }
1271
1272                 kfree(dev);
1273         }
1274
1275         return 0;
1276 }
1277
1278 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1279 {
1280         struct vivi_fh  *fh = file->private_data;
1281         struct vivi_dev *dev = fh->dev;
1282         int ret;
1283
1284         dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1285
1286         ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1287
1288         dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1289                 (unsigned long)vma->vm_start,
1290                 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1291                 ret);
1292
1293         return ret;
1294 }
1295
1296 static const struct v4l2_file_operations vivi_fops = {
1297         .owner          = THIS_MODULE,
1298         .open           = vivi_open,
1299         .release        = vivi_close,
1300         .read           = vivi_read,
1301         .poll           = vivi_poll,
1302         .ioctl          = video_ioctl2, /* V4L2 ioctl handler */
1303         .mmap           = vivi_mmap,
1304 };
1305
1306 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1307         .vidioc_querycap      = vidioc_querycap,
1308         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1309         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1310         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1311         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1312         .vidioc_reqbufs       = vidioc_reqbufs,
1313         .vidioc_querybuf      = vidioc_querybuf,
1314         .vidioc_qbuf          = vidioc_qbuf,
1315         .vidioc_dqbuf         = vidioc_dqbuf,
1316         .vidioc_s_std         = vidioc_s_std,
1317         .vidioc_enum_input    = vidioc_enum_input,
1318         .vidioc_g_input       = vidioc_g_input,
1319         .vidioc_s_input       = vidioc_s_input,
1320         .vidioc_queryctrl     = vidioc_queryctrl,
1321         .vidioc_g_ctrl        = vidioc_g_ctrl,
1322         .vidioc_s_ctrl        = vidioc_s_ctrl,
1323         .vidioc_streamon      = vidioc_streamon,
1324         .vidioc_streamoff     = vidioc_streamoff,
1325 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1326         .vidiocgmbuf          = vidiocgmbuf,
1327 #endif
1328 };
1329
1330 static struct video_device vivi_template = {
1331         .name           = "vivi",
1332         .fops           = &vivi_fops,
1333         .ioctl_ops      = &vivi_ioctl_ops,
1334         .minor          = -1,
1335         .release        = video_device_release,
1336
1337         .tvnorms              = V4L2_STD_525_60,
1338         .current_norm         = V4L2_STD_NTSC_M,
1339 };
1340 /* -----------------------------------------------------------------
1341         Initialization and module stuff
1342    ------------------------------------------------------------------*/
1343
1344 /* This routine allocates from 1 to n_devs virtual drivers.
1345
1346    The real maximum number of virtual drivers will depend on how many drivers
1347    will succeed. This is limited to the maximum number of devices that
1348    videodev supports, which is equal to VIDEO_NUM_DEVICES.
1349  */
1350 static int __init vivi_init(void)
1351 {
1352         int ret = -ENOMEM, i;
1353         struct vivi_dev *dev;
1354         struct video_device *vfd;
1355
1356         if (n_devs <= 0)
1357                 n_devs = 1;
1358
1359         for (i = 0; i < n_devs; i++) {
1360                 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1361                 if (!dev)
1362                         break;
1363
1364                 /* init video dma queues */
1365                 INIT_LIST_HEAD(&dev->vidq.active);
1366                 init_waitqueue_head(&dev->vidq.wq);
1367
1368                 /* initialize locks */
1369                 spin_lock_init(&dev->slock);
1370                 mutex_init(&dev->mutex);
1371
1372                 vfd = video_device_alloc();
1373                 if (!vfd) {
1374                         kfree(dev);
1375                         break;
1376                 }
1377
1378                 *vfd = vivi_template;
1379
1380                 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1381                 if (ret < 0) {
1382                         video_device_release(vfd);
1383                         kfree(dev);
1384
1385                         /* If some registers succeeded, keep driver */
1386                         if (i)
1387                                 ret = 0;
1388
1389                         break;
1390                 }
1391
1392                 /* Now that everything is fine, let's add it to device list */
1393                 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1394
1395                 snprintf(vfd->name, sizeof(vfd->name), "%s (%i)",
1396                          vivi_template.name, vfd->minor);
1397
1398                 if (video_nr >= 0)
1399                         video_nr++;
1400
1401                 dev->vfd = vfd;
1402                 printk(KERN_INFO "%s: V4L2 device registered as /dev/video%d\n",
1403                         VIVI_MODULE_NAME, vfd->num);
1404         }
1405
1406         if (ret < 0) {
1407                 vivi_release();
1408                 printk(KERN_INFO "Error %d while loading vivi driver\n", ret);
1409         } else {
1410                 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1411                         "Capture Board ver %u.%u.%u successfully loaded.\n",
1412                         (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1413                         VIVI_VERSION & 0xFF);
1414
1415                 /* n_devs will reflect the actual number of allocated devices */
1416                 n_devs = i;
1417         }
1418
1419         return ret;
1420 }
1421
1422 static void __exit vivi_exit(void)
1423 {
1424         vivi_release();
1425 }
1426
1427 module_init(vivi_init);
1428 module_exit(vivi_exit);
1429
1430 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
1431 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
1432 MODULE_LICENSE("Dual BSD/GPL");
1433
1434 module_param(video_nr, uint, 0444);
1435 MODULE_PARM_DESC(video_nr, "video iminor start number");
1436
1437 module_param(n_devs, uint, 0444);
1438 MODULE_PARM_DESC(n_devs, "number of video devices to create");
1439
1440 module_param_named(debug, vivi_template.debug, int, 0444);
1441 MODULE_PARM_DESC(debug, "activates debug info");
1442
1443 module_param(vid_limit, int, 0644);
1444 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");