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