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