V4L/DVB (9235): Precalculate vivi yuv values
[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 format = {
132         .name     = "4:2:2, packed, YUYV",
133         .fourcc   = V4L2_PIX_FMT_YUYV,
134         .depth    = 16,
135 };
136
137 struct sg_to_addr {
138         int pos;
139         struct scatterlist *sg;
140 };
141
142 /* buffer for one video frame */
143 struct vivi_buffer {
144         /* common v4l buffer stuff -- must be first */
145         struct videobuf_buffer vb;
146
147         struct vivi_fmt        *fmt;
148 };
149
150 struct vivi_dmaqueue {
151         struct list_head       active;
152
153         /* thread for generating video stream*/
154         struct task_struct         *kthread;
155         wait_queue_head_t          wq;
156         /* Counters to control fps rate */
157         int                        frame;
158         int                        ini_jiffies;
159 };
160
161 static LIST_HEAD(vivi_devlist);
162
163 struct vivi_dev {
164         struct list_head           vivi_devlist;
165
166         spinlock_t                 slock;
167         struct mutex               mutex;
168
169         int                        users;
170
171         /* various device info */
172         struct video_device        *vfd;
173
174         struct vivi_dmaqueue       vidq;
175
176         /* Several counters */
177         int                        h, m, s, ms;
178         unsigned long              jiffies;
179         char                       timestr[13];
180
181         int                        mv_count;    /* Controls bars movement */
182 };
183
184 struct vivi_fh {
185         struct vivi_dev            *dev;
186
187         /* video capture */
188         struct vivi_fmt            *fmt;
189         unsigned int               width, height;
190         struct videobuf_queue      vb_vidq;
191
192         enum v4l2_buf_type         type;
193         unsigned char              bars[8][3];
194 };
195
196 /* ------------------------------------------------------------------
197         DMA and thread functions
198    ------------------------------------------------------------------*/
199
200 /* Bars and Colors should match positions */
201
202 enum colors {
203         WHITE,
204         AMBAR,
205         CYAN,
206         GREEN,
207         MAGENTA,
208         RED,
209         BLUE,
210         BLACK,
211 };
212
213 static u8 bars[8][3] = {
214         /* R   G   B */
215         {204, 204, 204},  /* white */
216         {208, 208,   0},  /* ambar */
217         {  0, 206, 206},  /* cyan */
218         {  0, 239,   0},  /* green */
219         {239,   0, 239},  /* magenta */
220         {205,   0,   0},  /* red */
221         {  0,   0, 255},  /* blue */
222         {  0,   0,   0},  /* black */
223 };
224
225 #define TO_Y(r, g, b) \
226         (((16829 * r + 33039 * g + 6416 * b  + 32768) >> 16) + 16)
227 /* RGB to  V(Cr) Color transform */
228 #define TO_V(r, g, b) \
229         (((28784 * r - 24103 * g - 4681 * b  + 32768) >> 16) + 128)
230 /* RGB to  U(Cb) Color transform */
231 #define TO_U(r, g, b) \
232         (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
233
234 #define TSTAMP_MIN_Y 24
235 #define TSTAMP_MAX_Y TSTAMP_MIN_Y+15
236 #define TSTAMP_MIN_X 64
237
238 static void gen_twopix(struct vivi_fh *fh, unsigned char *buf, int colorpos)
239 {
240         unsigned char r_y, g_u, b_v;
241         unsigned char *p;
242         int color;
243
244         r_y = fh->bars[colorpos][0]; /* R or precalculated Y */
245         g_u = fh->bars[colorpos][1]; /* G or precalculated U */
246         b_v = fh->bars[colorpos][2]; /* B or precalculated V */
247
248         for (color = 0; color < 4; color++) {
249                 p = buf + color;
250
251                 switch (color) {
252                 case 0:
253                 case 2:
254                         *p = r_y;
255                         break;
256                 case 1:
257                         *p = g_u;
258                         break;
259                 case 3:
260                         *p = b_v;
261                         break;
262                 }
263         }
264 }
265
266 static void gen_line(struct vivi_fh *fh, char *basep, int inipos, int wmax,
267                 int hmax, int line, int count, char *timestr)
268 {
269         int  w, i, j;
270         int pos = inipos;
271         char *s;
272         u8 chr;
273
274         /* We will just duplicate the second pixel at the packet */
275         wmax /= 2;
276
277         /* Generate a standard color bar pattern */
278         for (w = 0; w < wmax; w++) {
279                 int colorpos = ((w + count) * 8/(wmax + 1)) % 8;
280
281                 gen_twopix(fh, basep + pos, colorpos);
282                 pos += 4; /* only 16 bpp supported for now */
283         }
284
285         /* Checks if it is possible to show timestamp */
286         if (TSTAMP_MAX_Y >= hmax)
287                 goto end;
288         if (TSTAMP_MIN_X + strlen(timestr) >= wmax)
289                 goto end;
290
291         /* Print stream time */
292         if (line >= TSTAMP_MIN_Y && line <= TSTAMP_MAX_Y) {
293                 j = TSTAMP_MIN_X;
294                 for (s = timestr; *s; s++) {
295                         chr = rom8x16_bits[(*s-0x30)*16+line-TSTAMP_MIN_Y];
296                         for (i = 0; i < 7; i++) {
297                                 pos = inipos + j * 2;
298                                 /* Draw white font on black background */
299                                 if (chr & 1 << (7 - i))
300                                         gen_twopix(fh, basep + pos, WHITE);
301                                 else
302                                         gen_twopix(fh, basep + pos, BLACK);
303                                 j++;
304                         }
305                 }
306         }
307
308 end:
309         return;
310 }
311
312 static void vivi_fillbuff(struct vivi_fh *fh, struct vivi_buffer *buf)
313 {
314         struct vivi_dev *dev = fh->dev;
315         int h , pos = 0;
316         int hmax  = buf->vb.height;
317         int wmax  = buf->vb.width;
318         struct timeval ts;
319         char *tmpbuf;
320         void *vbuf = videobuf_to_vmalloc(&buf->vb);
321
322         if (!vbuf)
323                 return;
324
325         tmpbuf = kmalloc(wmax * 2, GFP_ATOMIC);
326         if (!tmpbuf)
327                 return;
328
329         for (h = 0; h < hmax; h++) {
330                 gen_line(fh, tmpbuf, 0, wmax, hmax, h, dev->mv_count,
331                          dev->timestr);
332                 memcpy(vbuf + pos, tmpbuf, wmax * 2);
333                 pos += wmax*2;
334         }
335
336         dev->mv_count++;
337
338         kfree(tmpbuf);
339
340         /* Updates stream time */
341
342         dev->ms += jiffies_to_msecs(jiffies-dev->jiffies);
343         dev->jiffies = jiffies;
344         if (dev->ms >= 1000) {
345                 dev->ms -= 1000;
346                 dev->s++;
347                 if (dev->s >= 60) {
348                         dev->s -= 60;
349                         dev->m++;
350                         if (dev->m > 60) {
351                                 dev->m -= 60;
352                                 dev->h++;
353                                 if (dev->h > 24)
354                                         dev->h -= 24;
355                         }
356                 }
357         }
358         sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
359                         dev->h, dev->m, dev->s, dev->ms);
360
361         dprintk(dev, 2, "vivifill at %s: Buffer 0x%08lx size= %d\n",
362                         dev->timestr, (unsigned long)tmpbuf, pos);
363
364         /* Advice that buffer was filled */
365         buf->vb.field_count++;
366         do_gettimeofday(&ts);
367         buf->vb.ts = ts;
368         buf->vb.state = VIDEOBUF_DONE;
369 }
370
371 static void vivi_thread_tick(struct vivi_fh *fh)
372 {
373         struct vivi_buffer *buf;
374         struct vivi_dev *dev = fh->dev;
375         struct vivi_dmaqueue *dma_q = &dev->vidq;
376
377         unsigned long flags = 0;
378
379         dprintk(dev, 1, "Thread tick\n");
380
381         spin_lock_irqsave(&dev->slock, flags);
382         if (list_empty(&dma_q->active)) {
383                 dprintk(dev, 1, "No active queue to serve\n");
384                 goto unlock;
385         }
386
387         buf = list_entry(dma_q->active.next,
388                          struct vivi_buffer, vb.queue);
389
390         /* Nobody is waiting on this buffer, return */
391         if (!waitqueue_active(&buf->vb.done))
392                 goto unlock;
393
394         list_del(&buf->vb.queue);
395
396         do_gettimeofday(&buf->vb.ts);
397
398         /* Fill buffer */
399         vivi_fillbuff(fh, buf);
400         dprintk(dev, 1, "filled buffer %p\n", buf);
401
402         wake_up(&buf->vb.done);
403         dprintk(dev, 2, "[%p/%d] wakeup\n", buf, buf->vb. i);
404 unlock:
405         spin_unlock_irqrestore(&dev->slock, flags);
406         return;
407 }
408
409 #define frames_to_ms(frames)                                    \
410         ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
411
412 static void vivi_sleep(struct vivi_fh *fh)
413 {
414         struct vivi_dev *dev = fh->dev;
415         struct vivi_dmaqueue *dma_q = &dev->vidq;
416         int timeout;
417         DECLARE_WAITQUEUE(wait, current);
418
419         dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
420                 (unsigned long)dma_q);
421
422         add_wait_queue(&dma_q->wq, &wait);
423         if (kthread_should_stop())
424                 goto stop_task;
425
426         /* Calculate time to wake up */
427         timeout = msecs_to_jiffies(frames_to_ms(1));
428
429         vivi_thread_tick(fh);
430
431         schedule_timeout_interruptible(timeout);
432
433 stop_task:
434         remove_wait_queue(&dma_q->wq, &wait);
435         try_to_freeze();
436 }
437
438 static int vivi_thread(void *data)
439 {
440         struct vivi_fh  *fh = data;
441         struct vivi_dev *dev = fh->dev;
442
443         dprintk(dev, 1, "thread started\n");
444
445         set_freezable();
446
447         for (;;) {
448                 vivi_sleep(fh);
449
450                 if (kthread_should_stop())
451                         break;
452         }
453         dprintk(dev, 1, "thread: exit\n");
454         return 0;
455 }
456
457 static int vivi_start_thread(struct vivi_fh *fh)
458 {
459         struct vivi_dev *dev = fh->dev;
460         struct vivi_dmaqueue *dma_q = &dev->vidq;
461
462         dma_q->frame = 0;
463         dma_q->ini_jiffies = jiffies;
464
465         dprintk(dev, 1, "%s\n", __func__);
466
467         dma_q->kthread = kthread_run(vivi_thread, fh, "vivi");
468
469         if (IS_ERR(dma_q->kthread)) {
470                 printk(KERN_ERR "vivi: kernel_thread() failed\n");
471                 return PTR_ERR(dma_q->kthread);
472         }
473         /* Wakes thread */
474         wake_up_interruptible(&dma_q->wq);
475
476         dprintk(dev, 1, "returning from %s\n", __func__);
477         return 0;
478 }
479
480 static void vivi_stop_thread(struct vivi_dmaqueue  *dma_q)
481 {
482         struct vivi_dev *dev = container_of(dma_q, struct vivi_dev, vidq);
483
484         dprintk(dev, 1, "%s\n", __func__);
485         /* shutdown control thread */
486         if (dma_q->kthread) {
487                 kthread_stop(dma_q->kthread);
488                 dma_q->kthread = NULL;
489         }
490 }
491
492 /* ------------------------------------------------------------------
493         Videobuf operations
494    ------------------------------------------------------------------*/
495 static int
496 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
497 {
498         struct vivi_fh  *fh = vq->priv_data;
499         struct vivi_dev *dev  = fh->dev;
500
501         *size = fh->width*fh->height*2;
502
503         if (0 == *count)
504                 *count = 32;
505
506         while (*size * *count > vid_limit * 1024 * 1024)
507                 (*count)--;
508
509         dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__,
510                 *count, *size);
511
512         return 0;
513 }
514
515 static void free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
516 {
517         struct vivi_fh  *fh = vq->priv_data;
518         struct vivi_dev *dev  = fh->dev;
519
520         dprintk(dev, 1, "%s, state: %i\n", __func__, buf->vb.state);
521
522         if (in_interrupt())
523                 BUG();
524
525         videobuf_vmalloc_free(&buf->vb);
526         dprintk(dev, 1, "free_buffer: freed\n");
527         buf->vb.state = VIDEOBUF_NEEDS_INIT;
528 }
529
530 #define norm_maxw() 1024
531 #define norm_maxh() 768
532 static int
533 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
534                                                 enum v4l2_field field)
535 {
536         struct vivi_fh     *fh  = vq->priv_data;
537         struct vivi_dev    *dev = fh->dev;
538         struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
539         int rc;
540
541         dprintk(dev, 1, "%s, field=%d\n", __func__, field);
542
543         BUG_ON(NULL == fh->fmt);
544
545         if (fh->width  < 48 || fh->width  > norm_maxw() ||
546             fh->height < 32 || fh->height > norm_maxh())
547                 return -EINVAL;
548
549         buf->vb.size = fh->width*fh->height*2;
550         if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
551                 return -EINVAL;
552
553         /* These properties only change when queue is idle, see s_fmt */
554         buf->fmt       = fh->fmt;
555         buf->vb.width  = fh->width;
556         buf->vb.height = fh->height;
557         buf->vb.field  = field;
558
559         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
560                 rc = videobuf_iolock(vq, &buf->vb, NULL);
561                 if (rc < 0)
562                         goto fail;
563         }
564
565         buf->vb.state = VIDEOBUF_PREPARED;
566
567         return 0;
568
569 fail:
570         free_buffer(vq, buf);
571         return rc;
572 }
573
574 static void
575 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
576 {
577         struct vivi_buffer    *buf  = container_of(vb, struct vivi_buffer, vb);
578         struct vivi_fh        *fh   = vq->priv_data;
579         struct vivi_dev       *dev  = fh->dev;
580         struct vivi_dmaqueue *vidq = &dev->vidq;
581
582         dprintk(dev, 1, "%s\n", __func__);
583
584         buf->vb.state = VIDEOBUF_QUEUED;
585         list_add_tail(&buf->vb.queue, &vidq->active);
586 }
587
588 static void buffer_release(struct videobuf_queue *vq,
589                            struct videobuf_buffer *vb)
590 {
591         struct vivi_buffer   *buf  = container_of(vb, struct vivi_buffer, vb);
592         struct vivi_fh       *fh   = vq->priv_data;
593         struct vivi_dev      *dev  = (struct vivi_dev *)fh->dev;
594
595         dprintk(dev, 1, "%s\n", __func__);
596
597         free_buffer(vq, buf);
598 }
599
600 static struct videobuf_queue_ops vivi_video_qops = {
601         .buf_setup      = buffer_setup,
602         .buf_prepare    = buffer_prepare,
603         .buf_queue      = buffer_queue,
604         .buf_release    = buffer_release,
605 };
606
607 /* ------------------------------------------------------------------
608         IOCTL vidioc handling
609    ------------------------------------------------------------------*/
610 static int vidioc_querycap(struct file *file, void  *priv,
611                                         struct v4l2_capability *cap)
612 {
613         strcpy(cap->driver, "vivi");
614         strcpy(cap->card, "vivi");
615         cap->version = VIVI_VERSION;
616         cap->capabilities =     V4L2_CAP_VIDEO_CAPTURE |
617                                 V4L2_CAP_STREAMING     |
618                                 V4L2_CAP_READWRITE;
619         return 0;
620 }
621
622 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
623                                         struct v4l2_fmtdesc *f)
624 {
625         if (f->index > 0)
626                 return -EINVAL;
627
628         strlcpy(f->description, format.name, sizeof(f->description));
629         f->pixelformat = format.fourcc;
630         return 0;
631 }
632
633 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
634                                         struct v4l2_format *f)
635 {
636         struct vivi_fh *fh = priv;
637
638         f->fmt.pix.width        = fh->width;
639         f->fmt.pix.height       = fh->height;
640         f->fmt.pix.field        = fh->vb_vidq.field;
641         f->fmt.pix.pixelformat  = fh->fmt->fourcc;
642         f->fmt.pix.bytesperline =
643                 (f->fmt.pix.width * fh->fmt->depth) >> 3;
644         f->fmt.pix.sizeimage =
645                 f->fmt.pix.height * f->fmt.pix.bytesperline;
646
647         return (0);
648 }
649
650 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
651                         struct v4l2_format *f)
652 {
653         struct vivi_fh  *fh  = priv;
654         struct vivi_dev *dev = fh->dev;
655         struct vivi_fmt *fmt;
656         enum v4l2_field field;
657         unsigned int maxw, maxh;
658
659         if (format.fourcc != f->fmt.pix.pixelformat) {
660                 dprintk(dev, 1, "Fourcc format (0x%08x) invalid. "
661                         "Driver accepts only 0x%08x\n",
662                         f->fmt.pix.pixelformat, format.fourcc);
663                 return -EINVAL;
664         }
665         fmt = &format;
666
667         field = f->fmt.pix.field;
668
669         if (field == V4L2_FIELD_ANY) {
670                 field = V4L2_FIELD_INTERLACED;
671         } else if (V4L2_FIELD_INTERLACED != field) {
672                 dprintk(dev, 1, "Field type invalid.\n");
673                 return -EINVAL;
674         }
675
676         maxw  = norm_maxw();
677         maxh  = norm_maxh();
678
679         f->fmt.pix.field = field;
680         if (f->fmt.pix.height < 32)
681                 f->fmt.pix.height = 32;
682         if (f->fmt.pix.height > maxh)
683                 f->fmt.pix.height = maxh;
684         if (f->fmt.pix.width < 48)
685                 f->fmt.pix.width = 48;
686         if (f->fmt.pix.width > maxw)
687                 f->fmt.pix.width = maxw;
688         f->fmt.pix.width &= ~0x03;
689         f->fmt.pix.bytesperline =
690                 (f->fmt.pix.width * fmt->depth) >> 3;
691         f->fmt.pix.sizeimage =
692                 f->fmt.pix.height * f->fmt.pix.bytesperline;
693
694         return 0;
695 }
696
697 /*FIXME: This seems to be generic enough to be at videodev2 */
698 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
699                                         struct v4l2_format *f)
700 {
701         struct vivi_fh  *fh = priv;
702         struct videobuf_queue *q = &fh->vb_vidq;
703         unsigned char r, g, b;
704         int k;
705
706         int ret = vidioc_try_fmt_vid_cap(file, fh, f);
707         if (ret < 0)
708                 return (ret);
709
710         mutex_lock(&q->vb_lock);
711
712         if (videobuf_queue_is_busy(&fh->vb_vidq)) {
713                 dprintk(fh->dev, 1, "%s queue busy\n", __func__);
714                 ret = -EBUSY;
715                 goto out;
716         }
717
718         fh->fmt           = &format;
719         fh->width         = f->fmt.pix.width;
720         fh->height        = f->fmt.pix.height;
721         fh->vb_vidq.field = f->fmt.pix.field;
722         fh->type          = f->type;
723
724         /* precalculate color bar values to speed up rendering */
725         for (k = 0; k < 8; k++) {
726                 r = bars[k][0];
727                 g = bars[k][1];
728                 b = bars[k][2];
729
730                 fh->bars[k][0] = TO_Y(r, g, b); /* Luma */
731                 fh->bars[k][1] = TO_U(r, g, b); /* Cb */
732                 fh->bars[k][2] = TO_V(r, g, b); /* Cr */
733         }
734
735         ret = 0;
736 out:
737         mutex_unlock(&q->vb_lock);
738
739         return (ret);
740 }
741
742 static int vidioc_reqbufs(struct file *file, void *priv,
743                           struct v4l2_requestbuffers *p)
744 {
745         struct vivi_fh  *fh = priv;
746
747         return (videobuf_reqbufs(&fh->vb_vidq, p));
748 }
749
750 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
751 {
752         struct vivi_fh  *fh = priv;
753
754         return (videobuf_querybuf(&fh->vb_vidq, p));
755 }
756
757 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
758 {
759         struct vivi_fh *fh = priv;
760
761         return (videobuf_qbuf(&fh->vb_vidq, p));
762 }
763
764 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
765 {
766         struct vivi_fh  *fh = priv;
767
768         return (videobuf_dqbuf(&fh->vb_vidq, p,
769                                 file->f_flags & O_NONBLOCK));
770 }
771
772 #ifdef CONFIG_VIDEO_V4L1_COMPAT
773 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
774 {
775         struct vivi_fh  *fh = priv;
776
777         return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
778 }
779 #endif
780
781 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
782 {
783         struct vivi_fh  *fh = priv;
784
785         if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
786                 return -EINVAL;
787         if (i != fh->type)
788                 return -EINVAL;
789
790         return videobuf_streamon(&fh->vb_vidq);
791 }
792
793 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
794 {
795         struct vivi_fh  *fh = priv;
796
797         if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
798                 return -EINVAL;
799         if (i != fh->type)
800                 return -EINVAL;
801
802         return videobuf_streamoff(&fh->vb_vidq);
803 }
804
805 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
806 {
807         return 0;
808 }
809
810 /* only one input in this sample driver */
811 static int vidioc_enum_input(struct file *file, void *priv,
812                                 struct v4l2_input *inp)
813 {
814         if (inp->index != 0)
815                 return -EINVAL;
816
817         inp->type = V4L2_INPUT_TYPE_CAMERA;
818         inp->std = V4L2_STD_525_60;
819         strcpy(inp->name, "Camera");
820
821         return (0);
822 }
823
824 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
825 {
826         *i = 0;
827
828         return (0);
829 }
830 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
831 {
832         if (i > 0)
833                 return -EINVAL;
834
835         return (0);
836 }
837
838         /* --- controls ---------------------------------------------- */
839 static int vidioc_queryctrl(struct file *file, void *priv,
840                             struct v4l2_queryctrl *qc)
841 {
842         int i;
843
844         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
845                 if (qc->id && qc->id == vivi_qctrl[i].id) {
846                         memcpy(qc, &(vivi_qctrl[i]),
847                                 sizeof(*qc));
848                         return (0);
849                 }
850
851         return -EINVAL;
852 }
853
854 static int vidioc_g_ctrl(struct file *file, void *priv,
855                          struct v4l2_control *ctrl)
856 {
857         int i;
858
859         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
860                 if (ctrl->id == vivi_qctrl[i].id) {
861                         ctrl->value = qctl_regs[i];
862                         return (0);
863                 }
864
865         return -EINVAL;
866 }
867 static int vidioc_s_ctrl(struct file *file, void *priv,
868                                 struct v4l2_control *ctrl)
869 {
870         int i;
871
872         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
873                 if (ctrl->id == vivi_qctrl[i].id) {
874                         if (ctrl->value < vivi_qctrl[i].minimum
875                             || ctrl->value > vivi_qctrl[i].maximum) {
876                                         return (-ERANGE);
877                                 }
878                         qctl_regs[i] = ctrl->value;
879                         return (0);
880                 }
881         return -EINVAL;
882 }
883
884 /* ------------------------------------------------------------------
885         File operations for the device
886    ------------------------------------------------------------------*/
887
888 #define line_buf_size(norm) (norm_maxw(norm)*(format.depth+7)/8)
889
890 static int vivi_open(struct inode *inode, struct file *file)
891 {
892         int minor = iminor(inode);
893         struct vivi_dev *dev;
894         struct vivi_fh *fh = NULL;
895         int i;
896         int retval = 0;
897
898         printk(KERN_DEBUG "vivi: open called (minor=%d)\n", minor);
899
900         lock_kernel();
901         list_for_each_entry(dev, &vivi_devlist, vivi_devlist)
902                 if (dev->vfd->minor == minor)
903                         goto found;
904         unlock_kernel();
905         return -ENODEV;
906
907 found:
908         mutex_lock(&dev->mutex);
909         dev->users++;
910
911         if (dev->users > 1) {
912                 dev->users--;
913                 retval = -EBUSY;
914                 goto unlock;
915         }
916
917         dprintk(dev, 1, "open minor=%d type=%s users=%d\n", minor,
918                 v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
919
920         /* allocate + initialize per filehandle data */
921         fh = kzalloc(sizeof(*fh), GFP_KERNEL);
922         if (NULL == fh) {
923                 dev->users--;
924                 retval = -ENOMEM;
925                 goto unlock;
926         }
927 unlock:
928         mutex_unlock(&dev->mutex);
929         if (retval) {
930                 unlock_kernel();
931                 return retval;
932         }
933
934         file->private_data = fh;
935         fh->dev      = dev;
936
937         fh->type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;
938         fh->fmt      = &format;
939         fh->width    = 640;
940         fh->height   = 480;
941
942         /* Put all controls at a sane state */
943         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
944                 qctl_regs[i] = vivi_qctrl[i].default_value;
945
946         /* Resets frame counters */
947         dev->h = 0;
948         dev->m = 0;
949         dev->s = 0;
950         dev->ms = 0;
951         dev->mv_count = 0;
952         dev->jiffies = jiffies;
953         sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
954                         dev->h, dev->m, dev->s, dev->ms);
955
956         videobuf_queue_vmalloc_init(&fh->vb_vidq, &vivi_video_qops,
957                         NULL, &dev->slock, fh->type, V4L2_FIELD_INTERLACED,
958                         sizeof(struct vivi_buffer), fh);
959
960         vivi_start_thread(fh);
961         unlock_kernel();
962
963         return 0;
964 }
965
966 static ssize_t
967 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
968 {
969         struct vivi_fh *fh = file->private_data;
970
971         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
972                 return videobuf_read_stream(&fh->vb_vidq, data, count, ppos, 0,
973                                         file->f_flags & O_NONBLOCK);
974         }
975         return 0;
976 }
977
978 static unsigned int
979 vivi_poll(struct file *file, struct poll_table_struct *wait)
980 {
981         struct vivi_fh        *fh = file->private_data;
982         struct vivi_dev       *dev = fh->dev;
983         struct videobuf_queue *q = &fh->vb_vidq;
984
985         dprintk(dev, 1, "%s\n", __func__);
986
987         if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
988                 return POLLERR;
989
990         return videobuf_poll_stream(file, q, wait);
991 }
992
993 static int vivi_close(struct inode *inode, struct file *file)
994 {
995         struct vivi_fh         *fh = file->private_data;
996         struct vivi_dev *dev       = fh->dev;
997         struct vivi_dmaqueue *vidq = &dev->vidq;
998
999         int minor = iminor(inode);
1000
1001         vivi_stop_thread(vidq);
1002         videobuf_stop(&fh->vb_vidq);
1003         videobuf_mmap_free(&fh->vb_vidq);
1004
1005         kfree(fh);
1006
1007         mutex_lock(&dev->mutex);
1008         dev->users--;
1009         mutex_unlock(&dev->mutex);
1010
1011         dprintk(dev, 1, "close called (minor=%d, users=%d)\n",
1012                 minor, dev->users);
1013
1014         return 0;
1015 }
1016
1017 static int vivi_release(void)
1018 {
1019         struct vivi_dev *dev;
1020         struct list_head *list;
1021
1022         while (!list_empty(&vivi_devlist)) {
1023                 list = vivi_devlist.next;
1024                 list_del(list);
1025                 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1026
1027                 if (-1 != dev->vfd->minor) {
1028                         printk(KERN_INFO "%s: unregistering /dev/video%d\n",
1029                                 VIVI_MODULE_NAME, dev->vfd->minor);
1030                         video_unregister_device(dev->vfd);
1031                 } else {
1032                         printk(KERN_INFO "%s: releasing /dev/video%d\n",
1033                                 VIVI_MODULE_NAME, dev->vfd->minor);
1034                         video_device_release(dev->vfd);
1035                 }
1036
1037                 kfree(dev);
1038         }
1039
1040         return 0;
1041 }
1042
1043 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1044 {
1045         struct vivi_fh  *fh = file->private_data;
1046         struct vivi_dev *dev = fh->dev;
1047         int ret;
1048
1049         dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1050
1051         ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1052
1053         dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1054                 (unsigned long)vma->vm_start,
1055                 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1056                 ret);
1057
1058         return ret;
1059 }
1060
1061 static const struct file_operations vivi_fops = {
1062         .owner          = THIS_MODULE,
1063         .open           = vivi_open,
1064         .release        = vivi_close,
1065         .read           = vivi_read,
1066         .poll           = vivi_poll,
1067         .ioctl          = video_ioctl2, /* V4L2 ioctl handler */
1068         .compat_ioctl   = v4l_compat_ioctl32,
1069         .mmap           = vivi_mmap,
1070         .llseek         = no_llseek,
1071 };
1072
1073 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1074         .vidioc_querycap      = vidioc_querycap,
1075         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1076         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1077         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1078         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1079         .vidioc_reqbufs       = vidioc_reqbufs,
1080         .vidioc_querybuf      = vidioc_querybuf,
1081         .vidioc_qbuf          = vidioc_qbuf,
1082         .vidioc_dqbuf         = vidioc_dqbuf,
1083         .vidioc_s_std         = vidioc_s_std,
1084         .vidioc_enum_input    = vidioc_enum_input,
1085         .vidioc_g_input       = vidioc_g_input,
1086         .vidioc_s_input       = vidioc_s_input,
1087         .vidioc_queryctrl     = vidioc_queryctrl,
1088         .vidioc_g_ctrl        = vidioc_g_ctrl,
1089         .vidioc_s_ctrl        = vidioc_s_ctrl,
1090         .vidioc_streamon      = vidioc_streamon,
1091         .vidioc_streamoff     = vidioc_streamoff,
1092 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1093         .vidiocgmbuf          = vidiocgmbuf,
1094 #endif
1095 };
1096
1097 static struct video_device vivi_template = {
1098         .name           = "vivi",
1099         .fops           = &vivi_fops,
1100         .ioctl_ops      = &vivi_ioctl_ops,
1101         .minor          = -1,
1102         .release        = video_device_release,
1103
1104         .tvnorms              = V4L2_STD_525_60,
1105         .current_norm         = V4L2_STD_NTSC_M,
1106 };
1107 /* -----------------------------------------------------------------
1108         Initialization and module stuff
1109    ------------------------------------------------------------------*/
1110
1111 /* This routine allocates from 1 to n_devs virtual drivers.
1112
1113    The real maximum number of virtual drivers will depend on how many drivers
1114    will succeed. This is limited to the maximum number of devices that
1115    videodev supports. Since there are 64 minors for video grabbers, this is
1116    currently the theoretical maximum limit. However, a further limit does
1117    exist at videodev that forbids any driver to register more than 32 video
1118    grabbers.
1119  */
1120 static int __init vivi_init(void)
1121 {
1122         int ret = -ENOMEM, i;
1123         struct vivi_dev *dev;
1124         struct video_device *vfd;
1125
1126         if (n_devs <= 0)
1127                 n_devs = 1;
1128
1129         for (i = 0; i < n_devs; i++) {
1130                 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1131                 if (!dev)
1132                         break;
1133
1134                 /* init video dma queues */
1135                 INIT_LIST_HEAD(&dev->vidq.active);
1136                 init_waitqueue_head(&dev->vidq.wq);
1137
1138                 /* initialize locks */
1139                 spin_lock_init(&dev->slock);
1140                 mutex_init(&dev->mutex);
1141
1142                 vfd = video_device_alloc();
1143                 if (!vfd) {
1144                         kfree(dev);
1145                         break;
1146                 }
1147
1148                 *vfd = vivi_template;
1149
1150                 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1151                 if (ret < 0) {
1152                         video_device_release(vfd);
1153                         kfree(dev);
1154
1155                         /* If some registers succeeded, keep driver */
1156                         if (i)
1157                                 ret = 0;
1158
1159                         break;
1160                 }
1161
1162                 /* Now that everything is fine, let's add it to device list */
1163                 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1164
1165                 snprintf(vfd->name, sizeof(vfd->name), "%s (%i)",
1166                          vivi_template.name, vfd->minor);
1167
1168                 if (video_nr >= 0)
1169                         video_nr++;
1170
1171                 dev->vfd = vfd;
1172                 printk(KERN_INFO "%s: V4L2 device registered as /dev/video%d\n",
1173                         VIVI_MODULE_NAME, vfd->minor);
1174         }
1175
1176         if (ret < 0) {
1177                 vivi_release();
1178                 printk(KERN_INFO "Error %d while loading vivi driver\n", ret);
1179         } else {
1180                 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1181                         "Capture Board ver %u.%u.%u successfully loaded.\n",
1182                         (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1183                         VIVI_VERSION & 0xFF);
1184
1185                 /* n_devs will reflect the actual number of allocated devices */
1186                 n_devs = i;
1187         }
1188
1189         return ret;
1190 }
1191
1192 static void __exit vivi_exit(void)
1193 {
1194         vivi_release();
1195 }
1196
1197 module_init(vivi_init);
1198 module_exit(vivi_exit);
1199
1200 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
1201 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
1202 MODULE_LICENSE("Dual BSD/GPL");
1203
1204 module_param(video_nr, uint, 0444);
1205 MODULE_PARM_DESC(video_nr, "video iminor start number");
1206
1207 module_param(n_devs, uint, 0444);
1208 MODULE_PARM_DESC(n_devs, "number of video devices to create");
1209
1210 module_param_named(debug, vivi_template.debug, int, 0444);
1211 MODULE_PARM_DESC(debug, "activates debug info");
1212
1213 module_param(vid_limit, int, 0644);
1214 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");