V4L/DVB (8842): vivi_release(): fix use-after-free
[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 };
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         list_for_each_entry(dev, &vivi_devlist, vivi_devlist)
902                 if (dev->vfd->minor == minor)
903                         goto found;
904         return -ENODEV;
905
906 found:
907         mutex_lock(&dev->mutex);
908         dev->users++;
909
910         if (dev->users > 1) {
911                 dev->users--;
912                 retval = -EBUSY;
913                 goto unlock;
914         }
915
916         dprintk(dev, 1, "open minor=%d type=%s users=%d\n", minor,
917                 v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
918
919         /* allocate + initialize per filehandle data */
920         fh = kzalloc(sizeof(*fh), GFP_KERNEL);
921         if (NULL == fh) {
922                 dev->users--;
923                 retval = -ENOMEM;
924                 goto unlock;
925         }
926 unlock:
927         mutex_unlock(&dev->mutex);
928         if (retval)
929                 return retval;
930
931         file->private_data = fh;
932         fh->dev      = dev;
933
934         fh->type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;
935         fh->fmt      = &format;
936         fh->width    = 640;
937         fh->height   = 480;
938
939         /* Put all controls at a sane state */
940         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
941                 qctl_regs[i] = vivi_qctrl[i].default_value;
942
943         /* Resets frame counters */
944         dev->h = 0;
945         dev->m = 0;
946         dev->s = 0;
947         dev->ms = 0;
948         dev->mv_count = 0;
949         dev->jiffies = jiffies;
950         sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
951                         dev->h, dev->m, dev->s, dev->ms);
952
953         videobuf_queue_vmalloc_init(&fh->vb_vidq, &vivi_video_qops,
954                         NULL, &dev->slock, fh->type, V4L2_FIELD_INTERLACED,
955                         sizeof(struct vivi_buffer), fh);
956
957         vivi_start_thread(fh);
958
959         return 0;
960 }
961
962 static ssize_t
963 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
964 {
965         struct vivi_fh *fh = file->private_data;
966
967         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
968                 return videobuf_read_stream(&fh->vb_vidq, data, count, ppos, 0,
969                                         file->f_flags & O_NONBLOCK);
970         }
971         return 0;
972 }
973
974 static unsigned int
975 vivi_poll(struct file *file, struct poll_table_struct *wait)
976 {
977         struct vivi_fh        *fh = file->private_data;
978         struct vivi_dev       *dev = fh->dev;
979         struct videobuf_queue *q = &fh->vb_vidq;
980
981         dprintk(dev, 1, "%s\n", __func__);
982
983         if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
984                 return POLLERR;
985
986         return videobuf_poll_stream(file, q, wait);
987 }
988
989 static int vivi_close(struct inode *inode, struct file *file)
990 {
991         struct vivi_fh         *fh = file->private_data;
992         struct vivi_dev *dev       = fh->dev;
993         struct vivi_dmaqueue *vidq = &dev->vidq;
994
995         int minor = iminor(inode);
996
997         vivi_stop_thread(vidq);
998         videobuf_stop(&fh->vb_vidq);
999         videobuf_mmap_free(&fh->vb_vidq);
1000
1001         kfree(fh);
1002
1003         mutex_lock(&dev->mutex);
1004         dev->users--;
1005         mutex_unlock(&dev->mutex);
1006
1007         dprintk(dev, 1, "close called (minor=%d, users=%d)\n",
1008                 minor, dev->users);
1009
1010         return 0;
1011 }
1012
1013 static int vivi_release(void)
1014 {
1015         struct vivi_dev *dev;
1016         struct list_head *list;
1017
1018         while (!list_empty(&vivi_devlist)) {
1019                 list = vivi_devlist.next;
1020                 list_del(list);
1021                 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1022
1023                 if (-1 != dev->vfd->minor) {
1024                         printk(KERN_INFO "%s: unregistering /dev/video%d\n",
1025                                 VIVI_MODULE_NAME, dev->vfd->minor);
1026                         video_unregister_device(dev->vfd);
1027                 } else {
1028                         printk(KERN_INFO "%s: releasing /dev/video%d\n",
1029                                 VIVI_MODULE_NAME, dev->vfd->minor);
1030                         video_device_release(dev->vfd);
1031                 }
1032
1033                 kfree(dev);
1034         }
1035
1036         return 0;
1037 }
1038
1039 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1040 {
1041         struct vivi_fh  *fh = file->private_data;
1042         struct vivi_dev *dev = fh->dev;
1043         int ret;
1044
1045         dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1046
1047         ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1048
1049         dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1050                 (unsigned long)vma->vm_start,
1051                 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1052                 ret);
1053
1054         return ret;
1055 }
1056
1057 static const struct file_operations vivi_fops = {
1058         .owner          = THIS_MODULE,
1059         .open           = vivi_open,
1060         .release        = vivi_close,
1061         .read           = vivi_read,
1062         .poll           = vivi_poll,
1063         .ioctl          = video_ioctl2, /* V4L2 ioctl handler */
1064         .compat_ioctl   = v4l_compat_ioctl32,
1065         .mmap           = vivi_mmap,
1066         .llseek         = no_llseek,
1067 };
1068
1069 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1070         .vidioc_querycap      = vidioc_querycap,
1071         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1072         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1073         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1074         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1075         .vidioc_reqbufs       = vidioc_reqbufs,
1076         .vidioc_querybuf      = vidioc_querybuf,
1077         .vidioc_qbuf          = vidioc_qbuf,
1078         .vidioc_dqbuf         = vidioc_dqbuf,
1079         .vidioc_s_std         = vidioc_s_std,
1080         .vidioc_enum_input    = vidioc_enum_input,
1081         .vidioc_g_input       = vidioc_g_input,
1082         .vidioc_s_input       = vidioc_s_input,
1083         .vidioc_queryctrl     = vidioc_queryctrl,
1084         .vidioc_g_ctrl        = vidioc_g_ctrl,
1085         .vidioc_s_ctrl        = vidioc_s_ctrl,
1086         .vidioc_streamon      = vidioc_streamon,
1087         .vidioc_streamoff     = vidioc_streamoff,
1088 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1089         .vidiocgmbuf          = vidiocgmbuf,
1090 #endif
1091 };
1092
1093 static struct video_device vivi_template = {
1094         .name           = "vivi",
1095         .fops           = &vivi_fops,
1096         .ioctl_ops      = &vivi_ioctl_ops,
1097         .minor          = -1,
1098         .release        = video_device_release,
1099
1100         .tvnorms              = V4L2_STD_525_60,
1101         .current_norm         = V4L2_STD_NTSC_M,
1102 };
1103 /* -----------------------------------------------------------------
1104         Initialization and module stuff
1105    ------------------------------------------------------------------*/
1106
1107 /* This routine allocates from 1 to n_devs virtual drivers.
1108
1109    The real maximum number of virtual drivers will depend on how many drivers
1110    will succeed. This is limited to the maximum number of devices that
1111    videodev supports. Since there are 64 minors for video grabbers, this is
1112    currently the theoretical maximum limit. However, a further limit does
1113    exist at videodev that forbids any driver to register more than 32 video
1114    grabbers.
1115  */
1116 static int __init vivi_init(void)
1117 {
1118         int ret = -ENOMEM, i;
1119         struct vivi_dev *dev;
1120         struct video_device *vfd;
1121
1122         if (n_devs <= 0)
1123                 n_devs = 1;
1124
1125         for (i = 0; i < n_devs; i++) {
1126                 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1127                 if (!dev)
1128                         break;
1129
1130                 /* init video dma queues */
1131                 INIT_LIST_HEAD(&dev->vidq.active);
1132                 init_waitqueue_head(&dev->vidq.wq);
1133
1134                 /* initialize locks */
1135                 spin_lock_init(&dev->slock);
1136                 mutex_init(&dev->mutex);
1137
1138                 vfd = video_device_alloc();
1139                 if (!vfd) {
1140                         kfree(dev);
1141                         break;
1142                 }
1143
1144                 *vfd = vivi_template;
1145
1146                 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1147                 if (ret < 0) {
1148                         video_device_release(vfd);
1149                         kfree(dev);
1150
1151                         /* If some registers succeeded, keep driver */
1152                         if (i)
1153                                 ret = 0;
1154
1155                         break;
1156                 }
1157
1158                 /* Now that everything is fine, let's add it to device list */
1159                 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1160
1161                 snprintf(vfd->name, sizeof(vfd->name), "%s (%i)",
1162                          vivi_template.name, vfd->minor);
1163
1164                 if (video_nr >= 0)
1165                         video_nr++;
1166
1167                 dev->vfd = vfd;
1168                 printk(KERN_INFO "%s: V4L2 device registered as /dev/video%d\n",
1169                         VIVI_MODULE_NAME, vfd->minor);
1170         }
1171
1172         if (ret < 0) {
1173                 vivi_release();
1174                 printk(KERN_INFO "Error %d while loading vivi driver\n", ret);
1175         } else {
1176                 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1177                         "Capture Board ver %u.%u.%u successfully loaded.\n",
1178                         (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1179                         VIVI_VERSION & 0xFF);
1180
1181                 /* n_devs will reflect the actual number of allocated devices */
1182                 n_devs = i;
1183         }
1184
1185         return ret;
1186 }
1187
1188 static void __exit vivi_exit(void)
1189 {
1190         vivi_release();
1191 }
1192
1193 module_init(vivi_init);
1194 module_exit(vivi_exit);
1195
1196 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
1197 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
1198 MODULE_LICENSE("Dual BSD/GPL");
1199
1200 module_param(video_nr, uint, 0444);
1201 MODULE_PARM_DESC(video_nr, "video iminor start number");
1202
1203 module_param(n_devs, uint, 0444);
1204 MODULE_PARM_DESC(n_devs, "number of video devices to create");
1205
1206 module_param_named(debug, vivi_template.debug, int, 0444);
1207 MODULE_PARM_DESC(debug, "activates debug info");
1208
1209 module_param(vid_limit, int, 0644);
1210 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");