2 * Virtual Video driver - This code emulates a real video device with v4l2 api
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/
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
15 #include <linux/module.h>
16 #include <linux/delay.h>
17 #include <linux/errno.h>
19 #include <linux/kernel.h>
20 #include <linux/slab.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>
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>
43 #define VIVI_MODULE_NAME "vivi"
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 */
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)
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 */
63 /* supported controls */
64 static struct v4l2_queryctrl vivi_qctrl[] = {
66 .id = V4L2_CID_AUDIO_VOLUME,
71 .default_value = 65535,
73 .type = V4L2_CTRL_TYPE_INTEGER,
75 .id = V4L2_CID_BRIGHTNESS,
76 .type = V4L2_CTRL_TYPE_INTEGER,
84 .id = V4L2_CID_CONTRAST,
85 .type = V4L2_CTRL_TYPE_INTEGER,
90 .default_value = 0x10,
93 .id = V4L2_CID_SATURATION,
94 .type = V4L2_CTRL_TYPE_INTEGER,
103 .type = V4L2_CTRL_TYPE_INTEGER,
113 static int qctl_regs[ARRAY_SIZE(vivi_qctrl)];
115 #define dprintk(dev, level, fmt, arg...) \
117 if (dev->vfd->debug >= (level)) \
118 printk(KERN_DEBUG "vivi: " fmt , ## arg); \
121 /* ------------------------------------------------------------------
123 ------------------------------------------------------------------*/
127 u32 fourcc; /* v4l2 format id */
131 static struct vivi_fmt formats[] = {
133 .name = "4:2:2, packed, YUYV",
134 .fourcc = V4L2_PIX_FMT_YUYV,
139 static struct vivi_fmt *get_format(struct v4l2_format *f)
141 struct vivi_fmt *fmt;
144 for (k = 0; k < ARRAY_SIZE(formats); k++) {
146 if (fmt->fourcc == f->fmt.pix.pixelformat)
150 if (k == ARRAY_SIZE(formats))
158 struct scatterlist *sg;
161 /* buffer for one video frame */
163 /* common v4l buffer stuff -- must be first */
164 struct videobuf_buffer vb;
166 struct vivi_fmt *fmt;
169 struct vivi_dmaqueue {
170 struct list_head active;
172 /* thread for generating video stream*/
173 struct task_struct *kthread;
174 wait_queue_head_t wq;
175 /* Counters to control fps rate */
180 static LIST_HEAD(vivi_devlist);
183 struct list_head vivi_devlist;
190 /* various device info */
191 struct video_device *vfd;
193 struct vivi_dmaqueue vidq;
195 /* Several counters */
197 unsigned long jiffies;
200 int mv_count; /* Controls bars movement */
204 struct vivi_dev *dev;
207 struct vivi_fmt *fmt;
208 unsigned int width, height;
209 struct videobuf_queue vb_vidq;
211 enum v4l2_buf_type type;
212 unsigned char bars[8][3];
215 /* ------------------------------------------------------------------
216 DMA and thread functions
217 ------------------------------------------------------------------*/
219 /* Bars and Colors should match positions */
232 static u8 bars[8][3] = {
234 {204, 204, 204}, /* white */
235 {208, 208, 0}, /* ambar */
236 { 0, 206, 206}, /* cyan */
237 { 0, 239, 0}, /* green */
238 {239, 0, 239}, /* magenta */
239 {205, 0, 0}, /* red */
240 { 0, 0, 255}, /* blue */
241 { 0, 0, 0}, /* black */
244 #define TO_Y(r, g, b) \
245 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
246 /* RGB to V(Cr) Color transform */
247 #define TO_V(r, g, b) \
248 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
249 /* RGB to U(Cb) Color transform */
250 #define TO_U(r, g, b) \
251 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
253 #define TSTAMP_MIN_Y 24
254 #define TSTAMP_MAX_Y TSTAMP_MIN_Y+15
255 #define TSTAMP_MIN_X 64
257 static void gen_twopix(struct vivi_fh *fh, unsigned char *buf, int colorpos)
259 unsigned char r_y, g_u, b_v;
263 r_y = fh->bars[colorpos][0]; /* R or precalculated Y */
264 g_u = fh->bars[colorpos][1]; /* G or precalculated U */
265 b_v = fh->bars[colorpos][2]; /* B or precalculated V */
267 for (color = 0; color < 4; color++) {
270 switch (fh->fmt->fourcc) {
271 case V4L2_PIX_FMT_YUYV:
289 static void gen_line(struct vivi_fh *fh, char *basep, int inipos, int wmax,
290 int hmax, int line, int count, char *timestr)
297 /* We will just duplicate the second pixel at the packet */
300 /* Generate a standard color bar pattern */
301 for (w = 0; w < wmax; w++) {
302 int colorpos = ((w + count) * 8/(wmax + 1)) % 8;
304 gen_twopix(fh, basep + pos, colorpos);
305 pos += 4; /* only 16 bpp supported for now */
308 /* Checks if it is possible to show timestamp */
309 if (TSTAMP_MAX_Y >= hmax)
311 if (TSTAMP_MIN_X + strlen(timestr) >= wmax)
314 /* Print stream time */
315 if (line >= TSTAMP_MIN_Y && line <= TSTAMP_MAX_Y) {
317 for (s = timestr; *s; s++) {
318 chr = rom8x16_bits[(*s-0x30)*16+line-TSTAMP_MIN_Y];
319 for (i = 0; i < 7; i++) {
320 pos = inipos + j * 2;
321 /* Draw white font on black background */
322 if (chr & 1 << (7 - i))
323 gen_twopix(fh, basep + pos, WHITE);
325 gen_twopix(fh, basep + pos, BLACK);
335 static void vivi_fillbuff(struct vivi_fh *fh, struct vivi_buffer *buf)
337 struct vivi_dev *dev = fh->dev;
339 int hmax = buf->vb.height;
340 int wmax = buf->vb.width;
343 void *vbuf = videobuf_to_vmalloc(&buf->vb);
348 tmpbuf = kmalloc(wmax * 2, GFP_ATOMIC);
352 for (h = 0; h < hmax; h++) {
353 gen_line(fh, tmpbuf, 0, wmax, hmax, h, dev->mv_count,
355 memcpy(vbuf + pos, tmpbuf, wmax * 2);
363 /* Updates stream time */
365 dev->ms += jiffies_to_msecs(jiffies-dev->jiffies);
366 dev->jiffies = jiffies;
367 if (dev->ms >= 1000) {
381 sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
382 dev->h, dev->m, dev->s, dev->ms);
384 dprintk(dev, 2, "vivifill at %s: Buffer 0x%08lx size= %d\n",
385 dev->timestr, (unsigned long)tmpbuf, pos);
387 /* Advice that buffer was filled */
388 buf->vb.field_count++;
389 do_gettimeofday(&ts);
391 buf->vb.state = VIDEOBUF_DONE;
394 static void vivi_thread_tick(struct vivi_fh *fh)
396 struct vivi_buffer *buf;
397 struct vivi_dev *dev = fh->dev;
398 struct vivi_dmaqueue *dma_q = &dev->vidq;
400 unsigned long flags = 0;
402 dprintk(dev, 1, "Thread tick\n");
404 spin_lock_irqsave(&dev->slock, flags);
405 if (list_empty(&dma_q->active)) {
406 dprintk(dev, 1, "No active queue to serve\n");
410 buf = list_entry(dma_q->active.next,
411 struct vivi_buffer, vb.queue);
413 /* Nobody is waiting on this buffer, return */
414 if (!waitqueue_active(&buf->vb.done))
417 list_del(&buf->vb.queue);
419 do_gettimeofday(&buf->vb.ts);
422 vivi_fillbuff(fh, buf);
423 dprintk(dev, 1, "filled buffer %p\n", buf);
425 wake_up(&buf->vb.done);
426 dprintk(dev, 2, "[%p/%d] wakeup\n", buf, buf->vb. i);
428 spin_unlock_irqrestore(&dev->slock, flags);
432 #define frames_to_ms(frames) \
433 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
435 static void vivi_sleep(struct vivi_fh *fh)
437 struct vivi_dev *dev = fh->dev;
438 struct vivi_dmaqueue *dma_q = &dev->vidq;
440 DECLARE_WAITQUEUE(wait, current);
442 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
443 (unsigned long)dma_q);
445 add_wait_queue(&dma_q->wq, &wait);
446 if (kthread_should_stop())
449 /* Calculate time to wake up */
450 timeout = msecs_to_jiffies(frames_to_ms(1));
452 vivi_thread_tick(fh);
454 schedule_timeout_interruptible(timeout);
457 remove_wait_queue(&dma_q->wq, &wait);
461 static int vivi_thread(void *data)
463 struct vivi_fh *fh = data;
464 struct vivi_dev *dev = fh->dev;
466 dprintk(dev, 1, "thread started\n");
473 if (kthread_should_stop())
476 dprintk(dev, 1, "thread: exit\n");
480 static int vivi_start_thread(struct vivi_fh *fh)
482 struct vivi_dev *dev = fh->dev;
483 struct vivi_dmaqueue *dma_q = &dev->vidq;
486 dma_q->ini_jiffies = jiffies;
488 dprintk(dev, 1, "%s\n", __func__);
490 dma_q->kthread = kthread_run(vivi_thread, fh, "vivi");
492 if (IS_ERR(dma_q->kthread)) {
493 printk(KERN_ERR "vivi: kernel_thread() failed\n");
494 return PTR_ERR(dma_q->kthread);
497 wake_up_interruptible(&dma_q->wq);
499 dprintk(dev, 1, "returning from %s\n", __func__);
503 static void vivi_stop_thread(struct vivi_dmaqueue *dma_q)
505 struct vivi_dev *dev = container_of(dma_q, struct vivi_dev, vidq);
507 dprintk(dev, 1, "%s\n", __func__);
508 /* shutdown control thread */
509 if (dma_q->kthread) {
510 kthread_stop(dma_q->kthread);
511 dma_q->kthread = NULL;
515 /* ------------------------------------------------------------------
517 ------------------------------------------------------------------*/
519 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
521 struct vivi_fh *fh = vq->priv_data;
522 struct vivi_dev *dev = fh->dev;
524 *size = fh->width*fh->height*2;
529 while (*size * *count > vid_limit * 1024 * 1024)
532 dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__,
538 static void free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
540 struct vivi_fh *fh = vq->priv_data;
541 struct vivi_dev *dev = fh->dev;
543 dprintk(dev, 1, "%s, state: %i\n", __func__, buf->vb.state);
548 videobuf_vmalloc_free(&buf->vb);
549 dprintk(dev, 1, "free_buffer: freed\n");
550 buf->vb.state = VIDEOBUF_NEEDS_INIT;
553 #define norm_maxw() 1024
554 #define norm_maxh() 768
556 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
557 enum v4l2_field field)
559 struct vivi_fh *fh = vq->priv_data;
560 struct vivi_dev *dev = fh->dev;
561 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
564 dprintk(dev, 1, "%s, field=%d\n", __func__, field);
566 BUG_ON(NULL == fh->fmt);
568 if (fh->width < 48 || fh->width > norm_maxw() ||
569 fh->height < 32 || fh->height > norm_maxh())
572 buf->vb.size = fh->width*fh->height*2;
573 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
576 /* These properties only change when queue is idle, see s_fmt */
578 buf->vb.width = fh->width;
579 buf->vb.height = fh->height;
580 buf->vb.field = field;
582 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
583 rc = videobuf_iolock(vq, &buf->vb, NULL);
588 buf->vb.state = VIDEOBUF_PREPARED;
593 free_buffer(vq, buf);
598 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
600 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
601 struct vivi_fh *fh = vq->priv_data;
602 struct vivi_dev *dev = fh->dev;
603 struct vivi_dmaqueue *vidq = &dev->vidq;
605 dprintk(dev, 1, "%s\n", __func__);
607 buf->vb.state = VIDEOBUF_QUEUED;
608 list_add_tail(&buf->vb.queue, &vidq->active);
611 static void buffer_release(struct videobuf_queue *vq,
612 struct videobuf_buffer *vb)
614 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
615 struct vivi_fh *fh = vq->priv_data;
616 struct vivi_dev *dev = (struct vivi_dev *)fh->dev;
618 dprintk(dev, 1, "%s\n", __func__);
620 free_buffer(vq, buf);
623 static struct videobuf_queue_ops vivi_video_qops = {
624 .buf_setup = buffer_setup,
625 .buf_prepare = buffer_prepare,
626 .buf_queue = buffer_queue,
627 .buf_release = buffer_release,
630 /* ------------------------------------------------------------------
631 IOCTL vidioc handling
632 ------------------------------------------------------------------*/
633 static int vidioc_querycap(struct file *file, void *priv,
634 struct v4l2_capability *cap)
636 strcpy(cap->driver, "vivi");
637 strcpy(cap->card, "vivi");
638 cap->version = VIVI_VERSION;
639 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
645 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
646 struct v4l2_fmtdesc *f)
648 struct vivi_fmt *fmt;
650 if (f->index >= ARRAY_SIZE(formats))
653 fmt = &formats[f->index];
655 strlcpy(f->description, fmt->name, sizeof(f->description));
656 f->pixelformat = fmt->fourcc;
660 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
661 struct v4l2_format *f)
663 struct vivi_fh *fh = priv;
665 f->fmt.pix.width = fh->width;
666 f->fmt.pix.height = fh->height;
667 f->fmt.pix.field = fh->vb_vidq.field;
668 f->fmt.pix.pixelformat = fh->fmt->fourcc;
669 f->fmt.pix.bytesperline =
670 (f->fmt.pix.width * fh->fmt->depth) >> 3;
671 f->fmt.pix.sizeimage =
672 f->fmt.pix.height * f->fmt.pix.bytesperline;
677 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
678 struct v4l2_format *f)
680 struct vivi_fh *fh = priv;
681 struct vivi_dev *dev = fh->dev;
682 struct vivi_fmt *fmt;
683 enum v4l2_field field;
684 unsigned int maxw, maxh;
688 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
689 f->fmt.pix.pixelformat);
693 field = f->fmt.pix.field;
695 if (field == V4L2_FIELD_ANY) {
696 field = V4L2_FIELD_INTERLACED;
697 } else if (V4L2_FIELD_INTERLACED != field) {
698 dprintk(dev, 1, "Field type invalid.\n");
705 f->fmt.pix.field = field;
706 if (f->fmt.pix.height < 32)
707 f->fmt.pix.height = 32;
708 if (f->fmt.pix.height > maxh)
709 f->fmt.pix.height = maxh;
710 if (f->fmt.pix.width < 48)
711 f->fmt.pix.width = 48;
712 if (f->fmt.pix.width > maxw)
713 f->fmt.pix.width = maxw;
714 f->fmt.pix.width &= ~0x03;
715 f->fmt.pix.bytesperline =
716 (f->fmt.pix.width * fmt->depth) >> 3;
717 f->fmt.pix.sizeimage =
718 f->fmt.pix.height * f->fmt.pix.bytesperline;
723 /*FIXME: This seems to be generic enough to be at videodev2 */
724 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
725 struct v4l2_format *f)
727 struct vivi_fh *fh = priv;
728 struct videobuf_queue *q = &fh->vb_vidq;
729 unsigned char r, g, b;
732 int ret = vidioc_try_fmt_vid_cap(file, fh, f);
736 mutex_lock(&q->vb_lock);
738 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
739 dprintk(fh->dev, 1, "%s queue busy\n", __func__);
744 fh->fmt = get_format(f);
745 fh->width = f->fmt.pix.width;
746 fh->height = f->fmt.pix.height;
747 fh->vb_vidq.field = f->fmt.pix.field;
750 /* precalculate color bar values to speed up rendering */
751 for (k = 0; k < 8; k++) {
757 switch (fh->fmt->fourcc) {
758 case V4L2_PIX_FMT_YUYV:
764 fh->bars[k][0] = TO_Y(r, g, b); /* Luma */
765 fh->bars[k][1] = TO_U(r, g, b); /* Cb */
766 fh->bars[k][2] = TO_V(r, g, b); /* Cr */
776 mutex_unlock(&q->vb_lock);
781 static int vidioc_reqbufs(struct file *file, void *priv,
782 struct v4l2_requestbuffers *p)
784 struct vivi_fh *fh = priv;
786 return (videobuf_reqbufs(&fh->vb_vidq, p));
789 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
791 struct vivi_fh *fh = priv;
793 return (videobuf_querybuf(&fh->vb_vidq, p));
796 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
798 struct vivi_fh *fh = priv;
800 return (videobuf_qbuf(&fh->vb_vidq, p));
803 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
805 struct vivi_fh *fh = priv;
807 return (videobuf_dqbuf(&fh->vb_vidq, p,
808 file->f_flags & O_NONBLOCK));
811 #ifdef CONFIG_VIDEO_V4L1_COMPAT
812 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
814 struct vivi_fh *fh = priv;
816 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
820 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
822 struct vivi_fh *fh = priv;
824 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
829 return videobuf_streamon(&fh->vb_vidq);
832 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
834 struct vivi_fh *fh = priv;
836 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
841 return videobuf_streamoff(&fh->vb_vidq);
844 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
849 /* only one input in this sample driver */
850 static int vidioc_enum_input(struct file *file, void *priv,
851 struct v4l2_input *inp)
856 inp->type = V4L2_INPUT_TYPE_CAMERA;
857 inp->std = V4L2_STD_525_60;
858 strcpy(inp->name, "Camera");
863 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
869 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
877 /* --- controls ---------------------------------------------- */
878 static int vidioc_queryctrl(struct file *file, void *priv,
879 struct v4l2_queryctrl *qc)
883 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
884 if (qc->id && qc->id == vivi_qctrl[i].id) {
885 memcpy(qc, &(vivi_qctrl[i]),
893 static int vidioc_g_ctrl(struct file *file, void *priv,
894 struct v4l2_control *ctrl)
898 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
899 if (ctrl->id == vivi_qctrl[i].id) {
900 ctrl->value = qctl_regs[i];
906 static int vidioc_s_ctrl(struct file *file, void *priv,
907 struct v4l2_control *ctrl)
911 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
912 if (ctrl->id == vivi_qctrl[i].id) {
913 if (ctrl->value < vivi_qctrl[i].minimum
914 || ctrl->value > vivi_qctrl[i].maximum) {
917 qctl_regs[i] = ctrl->value;
923 /* ------------------------------------------------------------------
924 File operations for the device
925 ------------------------------------------------------------------*/
927 static int vivi_open(struct inode *inode, struct file *file)
929 int minor = iminor(inode);
930 struct vivi_dev *dev;
931 struct vivi_fh *fh = NULL;
935 printk(KERN_DEBUG "vivi: open called (minor=%d)\n", minor);
938 list_for_each_entry(dev, &vivi_devlist, vivi_devlist)
939 if (dev->vfd->minor == minor)
945 mutex_lock(&dev->mutex);
948 if (dev->users > 1) {
954 dprintk(dev, 1, "open minor=%d type=%s users=%d\n", minor,
955 v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
957 /* allocate + initialize per filehandle data */
958 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
965 mutex_unlock(&dev->mutex);
971 file->private_data = fh;
974 fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
975 fh->fmt = &formats[0];
979 /* Put all controls at a sane state */
980 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
981 qctl_regs[i] = vivi_qctrl[i].default_value;
983 /* Resets frame counters */
989 dev->jiffies = jiffies;
990 sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
991 dev->h, dev->m, dev->s, dev->ms);
993 videobuf_queue_vmalloc_init(&fh->vb_vidq, &vivi_video_qops,
994 NULL, &dev->slock, fh->type, V4L2_FIELD_INTERLACED,
995 sizeof(struct vivi_buffer), fh);
997 vivi_start_thread(fh);
1004 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1006 struct vivi_fh *fh = file->private_data;
1008 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1009 return videobuf_read_stream(&fh->vb_vidq, data, count, ppos, 0,
1010 file->f_flags & O_NONBLOCK);
1016 vivi_poll(struct file *file, struct poll_table_struct *wait)
1018 struct vivi_fh *fh = file->private_data;
1019 struct vivi_dev *dev = fh->dev;
1020 struct videobuf_queue *q = &fh->vb_vidq;
1022 dprintk(dev, 1, "%s\n", __func__);
1024 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1027 return videobuf_poll_stream(file, q, wait);
1030 static int vivi_close(struct inode *inode, struct file *file)
1032 struct vivi_fh *fh = file->private_data;
1033 struct vivi_dev *dev = fh->dev;
1034 struct vivi_dmaqueue *vidq = &dev->vidq;
1036 int minor = iminor(inode);
1038 vivi_stop_thread(vidq);
1039 videobuf_stop(&fh->vb_vidq);
1040 videobuf_mmap_free(&fh->vb_vidq);
1044 mutex_lock(&dev->mutex);
1046 mutex_unlock(&dev->mutex);
1048 dprintk(dev, 1, "close called (minor=%d, users=%d)\n",
1054 static int vivi_release(void)
1056 struct vivi_dev *dev;
1057 struct list_head *list;
1059 while (!list_empty(&vivi_devlist)) {
1060 list = vivi_devlist.next;
1062 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1064 if (-1 != dev->vfd->minor) {
1065 printk(KERN_INFO "%s: unregistering /dev/video%d\n",
1066 VIVI_MODULE_NAME, dev->vfd->minor);
1067 video_unregister_device(dev->vfd);
1069 printk(KERN_INFO "%s: releasing /dev/video%d\n",
1070 VIVI_MODULE_NAME, dev->vfd->minor);
1071 video_device_release(dev->vfd);
1080 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1082 struct vivi_fh *fh = file->private_data;
1083 struct vivi_dev *dev = fh->dev;
1086 dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1088 ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1090 dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1091 (unsigned long)vma->vm_start,
1092 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1098 static const struct file_operations vivi_fops = {
1099 .owner = THIS_MODULE,
1101 .release = vivi_close,
1104 .ioctl = video_ioctl2, /* V4L2 ioctl handler */
1105 .compat_ioctl = v4l_compat_ioctl32,
1107 .llseek = no_llseek,
1110 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1111 .vidioc_querycap = vidioc_querycap,
1112 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1113 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1114 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1115 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1116 .vidioc_reqbufs = vidioc_reqbufs,
1117 .vidioc_querybuf = vidioc_querybuf,
1118 .vidioc_qbuf = vidioc_qbuf,
1119 .vidioc_dqbuf = vidioc_dqbuf,
1120 .vidioc_s_std = vidioc_s_std,
1121 .vidioc_enum_input = vidioc_enum_input,
1122 .vidioc_g_input = vidioc_g_input,
1123 .vidioc_s_input = vidioc_s_input,
1124 .vidioc_queryctrl = vidioc_queryctrl,
1125 .vidioc_g_ctrl = vidioc_g_ctrl,
1126 .vidioc_s_ctrl = vidioc_s_ctrl,
1127 .vidioc_streamon = vidioc_streamon,
1128 .vidioc_streamoff = vidioc_streamoff,
1129 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1130 .vidiocgmbuf = vidiocgmbuf,
1134 static struct video_device vivi_template = {
1137 .ioctl_ops = &vivi_ioctl_ops,
1139 .release = video_device_release,
1141 .tvnorms = V4L2_STD_525_60,
1142 .current_norm = V4L2_STD_NTSC_M,
1144 /* -----------------------------------------------------------------
1145 Initialization and module stuff
1146 ------------------------------------------------------------------*/
1148 /* This routine allocates from 1 to n_devs virtual drivers.
1150 The real maximum number of virtual drivers will depend on how many drivers
1151 will succeed. This is limited to the maximum number of devices that
1152 videodev supports. Since there are 64 minors for video grabbers, this is
1153 currently the theoretical maximum limit. However, a further limit does
1154 exist at videodev that forbids any driver to register more than 32 video
1157 static int __init vivi_init(void)
1159 int ret = -ENOMEM, i;
1160 struct vivi_dev *dev;
1161 struct video_device *vfd;
1166 for (i = 0; i < n_devs; i++) {
1167 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1171 /* init video dma queues */
1172 INIT_LIST_HEAD(&dev->vidq.active);
1173 init_waitqueue_head(&dev->vidq.wq);
1175 /* initialize locks */
1176 spin_lock_init(&dev->slock);
1177 mutex_init(&dev->mutex);
1179 vfd = video_device_alloc();
1185 *vfd = vivi_template;
1187 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1189 video_device_release(vfd);
1192 /* If some registers succeeded, keep driver */
1199 /* Now that everything is fine, let's add it to device list */
1200 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1202 snprintf(vfd->name, sizeof(vfd->name), "%s (%i)",
1203 vivi_template.name, vfd->minor);
1209 printk(KERN_INFO "%s: V4L2 device registered as /dev/video%d\n",
1210 VIVI_MODULE_NAME, vfd->minor);
1215 printk(KERN_INFO "Error %d while loading vivi driver\n", ret);
1217 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1218 "Capture Board ver %u.%u.%u successfully loaded.\n",
1219 (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1220 VIVI_VERSION & 0xFF);
1222 /* n_devs will reflect the actual number of allocated devices */
1229 static void __exit vivi_exit(void)
1234 module_init(vivi_init);
1235 module_exit(vivi_exit);
1237 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
1238 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
1239 MODULE_LICENSE("Dual BSD/GPL");
1241 module_param(video_nr, uint, 0444);
1242 MODULE_PARM_DESC(video_nr, "video iminor start number");
1244 module_param(n_devs, uint, 0444);
1245 MODULE_PARM_DESC(n_devs, "number of video devices to create");
1247 module_param_named(debug, vivi_template.debug, int, 0444);
1248 MODULE_PARM_DESC(debug, "activates debug info");
1250 module_param(vid_limit, int, 0644);
1251 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");