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 * Conversion to videobuf2 by Pawel Osciak & Marek Szyprowski
11 * Copyright (c) 2010 Samsung Electronics
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the BSD Licence, GNU General Public License
15 * as published by the Free Software Foundation; either version 2 of the
16 * License, or (at your option) any later version
18 #include <linux/module.h>
19 #include <linux/errno.h>
20 #include <linux/kernel.h>
21 #include <linux/init.h>
22 #include <linux/sched.h>
23 #include <linux/slab.h>
24 #include <linux/font.h>
25 #include <linux/mutex.h>
26 #include <linux/videodev2.h>
27 #include <linux/kthread.h>
28 #include <linux/freezer.h>
29 #include <media/videobuf2-vmalloc.h>
30 #include <media/v4l2-device.h>
31 #include <media/v4l2-ioctl.h>
32 #include <media/v4l2-ctrls.h>
33 #include <media/v4l2-fh.h>
34 #include <media/v4l2-event.h>
35 #include <media/v4l2-common.h>
37 #define VIVI_MODULE_NAME "vivi"
39 /* Wake up at about 30 fps */
40 #define WAKE_NUMERATOR 30
41 #define WAKE_DENOMINATOR 1001
42 #define BUFFER_TIMEOUT msecs_to_jiffies(500) /* 0.5 seconds */
44 #define MAX_WIDTH 1920
45 #define MAX_HEIGHT 1200
47 #define VIVI_VERSION "0.8.1"
49 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
50 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
51 MODULE_LICENSE("Dual BSD/GPL");
52 MODULE_VERSION(VIVI_VERSION);
54 static unsigned video_nr = -1;
55 module_param(video_nr, uint, 0644);
56 MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect");
58 static unsigned n_devs = 1;
59 module_param(n_devs, uint, 0644);
60 MODULE_PARM_DESC(n_devs, "number of video devices to create");
62 static unsigned debug;
63 module_param(debug, uint, 0644);
64 MODULE_PARM_DESC(debug, "activates debug info");
66 static unsigned int vid_limit = 16;
67 module_param(vid_limit, uint, 0644);
68 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
70 /* Global font descriptor */
71 static const u8 *font8x16;
73 #define dprintk(dev, level, fmt, arg...) \
74 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
76 /* ------------------------------------------------------------------
78 ------------------------------------------------------------------*/
82 u32 fourcc; /* v4l2 format id */
86 static struct vivi_fmt formats[] = {
88 .name = "4:2:2, packed, YUYV",
89 .fourcc = V4L2_PIX_FMT_YUYV,
93 .name = "4:2:2, packed, UYVY",
94 .fourcc = V4L2_PIX_FMT_UYVY,
98 .name = "RGB565 (LE)",
99 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
103 .name = "RGB565 (BE)",
104 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
108 .name = "RGB555 (LE)",
109 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
113 .name = "RGB555 (BE)",
114 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
119 static struct vivi_fmt *get_format(struct v4l2_format *f)
121 struct vivi_fmt *fmt;
124 for (k = 0; k < ARRAY_SIZE(formats); k++) {
126 if (fmt->fourcc == f->fmt.pix.pixelformat)
130 if (k == ARRAY_SIZE(formats))
136 /* buffer for one video frame */
138 /* common v4l buffer stuff -- must be first */
139 struct vb2_buffer vb;
140 struct list_head list;
141 struct vivi_fmt *fmt;
144 struct vivi_dmaqueue {
145 struct list_head active;
147 /* thread for generating video stream*/
148 struct task_struct *kthread;
149 wait_queue_head_t wq;
150 /* Counters to control fps rate */
155 static LIST_HEAD(vivi_devlist);
158 struct list_head vivi_devlist;
159 struct v4l2_device v4l2_dev;
160 struct v4l2_ctrl_handler ctrl_handler;
163 struct v4l2_ctrl *brightness;
164 struct v4l2_ctrl *contrast;
165 struct v4l2_ctrl *saturation;
166 struct v4l2_ctrl *hue;
168 /* autogain/gain cluster */
169 struct v4l2_ctrl *autogain;
170 struct v4l2_ctrl *gain;
172 struct v4l2_ctrl *volume;
173 struct v4l2_ctrl *button;
174 struct v4l2_ctrl *boolean;
175 struct v4l2_ctrl *int32;
176 struct v4l2_ctrl *int64;
177 struct v4l2_ctrl *menu;
178 struct v4l2_ctrl *string;
183 /* various device info */
184 struct video_device *vfd;
186 struct vivi_dmaqueue vidq;
188 /* Several counters */
190 unsigned long jiffies;
191 unsigned button_pressed;
193 int mv_count; /* Controls bars movement */
199 struct vivi_fmt *fmt;
200 unsigned int width, height;
201 struct vb2_queue vb_vidq;
202 enum v4l2_field field;
203 unsigned int field_count;
206 u8 line[MAX_WIDTH * 4];
209 /* ------------------------------------------------------------------
210 DMA and thread functions
211 ------------------------------------------------------------------*/
213 /* Bars and Colors should match positions */
228 #define COLOR_WHITE {204, 204, 204}
229 #define COLOR_AMBER {208, 208, 0}
230 #define COLOR_CYAN { 0, 206, 206}
231 #define COLOR_GREEN { 0, 239, 0}
232 #define COLOR_MAGENTA {239, 0, 239}
233 #define COLOR_RED {205, 0, 0}
234 #define COLOR_BLUE { 0, 0, 255}
235 #define COLOR_BLACK { 0, 0, 0}
241 /* Maximum number of bars are 10 - otherwise, the input print code
242 should be modified */
243 static struct bar_std bars[] = {
244 { /* Standard ITU-R color bar sequence */
245 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
246 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
248 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
249 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
251 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
252 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
254 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
255 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
259 #define NUM_INPUTS ARRAY_SIZE(bars)
261 #define TO_Y(r, g, b) \
262 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
263 /* RGB to V(Cr) Color transform */
264 #define TO_V(r, g, b) \
265 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
266 /* RGB to U(Cb) Color transform */
267 #define TO_U(r, g, b) \
268 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
270 /* precalculate color bar values to speed up rendering */
271 static void precalculate_bars(struct vivi_dev *dev)
276 for (k = 0; k < 9; k++) {
277 r = bars[dev->input].bar[k][0];
278 g = bars[dev->input].bar[k][1];
279 b = bars[dev->input].bar[k][2];
282 switch (dev->fmt->fourcc) {
283 case V4L2_PIX_FMT_YUYV:
284 case V4L2_PIX_FMT_UYVY:
287 case V4L2_PIX_FMT_RGB565:
288 case V4L2_PIX_FMT_RGB565X:
293 case V4L2_PIX_FMT_RGB555:
294 case V4L2_PIX_FMT_RGB555X:
302 dev->bars[k][0] = TO_Y(r, g, b); /* Luma */
303 dev->bars[k][1] = TO_U(r, g, b); /* Cb */
304 dev->bars[k][2] = TO_V(r, g, b); /* Cr */
313 #define TSTAMP_MIN_Y 24
314 #define TSTAMP_MAX_Y (TSTAMP_MIN_Y + 15)
315 #define TSTAMP_INPUT_X 10
316 #define TSTAMP_MIN_X (54 + TSTAMP_INPUT_X)
318 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos)
324 r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
325 g_u = dev->bars[colorpos][1]; /* G or precalculated U */
326 b_v = dev->bars[colorpos][2]; /* B or precalculated V */
328 for (color = 0; color < 4; color++) {
331 switch (dev->fmt->fourcc) {
332 case V4L2_PIX_FMT_YUYV:
346 case V4L2_PIX_FMT_UYVY:
360 case V4L2_PIX_FMT_RGB565:
364 *p = (g_u << 5) | b_v;
368 *p = (r_y << 3) | (g_u >> 3);
372 case V4L2_PIX_FMT_RGB565X:
376 *p = (r_y << 3) | (g_u >> 3);
380 *p = (g_u << 5) | b_v;
384 case V4L2_PIX_FMT_RGB555:
388 *p = (g_u << 5) | b_v;
392 *p = (r_y << 2) | (g_u >> 3);
396 case V4L2_PIX_FMT_RGB555X:
400 *p = (r_y << 2) | (g_u >> 3);
404 *p = (g_u << 5) | b_v;
412 static void precalculate_line(struct vivi_dev *dev)
416 for (w = 0; w < dev->width * 2; w += 2) {
417 int colorpos = (w / (dev->width / 8) % 8);
419 gen_twopix(dev, dev->line + w * 2, colorpos);
423 static void gen_text(struct vivi_dev *dev, char *basep,
424 int y, int x, char *text)
428 /* Checks if it is possible to show string */
429 if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
432 /* Print stream time */
433 for (line = y; line < y + 16; line++) {
435 char *pos = basep + line * dev->width * 2 + x * 2;
438 for (s = text; *s; s++) {
439 u8 chr = font8x16[*s * 16 + line - y];
442 for (i = 0; i < 7; i++, j++) {
443 /* Draw white font on black background */
444 if (chr & (1 << (7 - i)))
445 gen_twopix(dev, pos + j * 2, WHITE);
447 gen_twopix(dev, pos + j * 2, TEXT_BLACK);
453 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
455 int wmax = dev->width;
456 int hmax = dev->height;
458 void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
467 for (h = 0; h < hmax; h++)
468 memcpy(vbuf + h * wmax * 2, dev->line + (dev->mv_count % wmax) * 2, wmax * 2);
470 /* Updates stream time */
472 dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
473 dev->jiffies = jiffies;
475 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
476 (ms / (60 * 60 * 1000)) % 24,
477 (ms / (60 * 1000)) % 60,
480 gen_text(dev, vbuf, line++ * 16, 16, str);
481 snprintf(str, sizeof(str), " %dx%d, input %d ",
482 dev->width, dev->height, dev->input);
483 gen_text(dev, vbuf, line++ * 16, 16, str);
485 gain = v4l2_ctrl_g_ctrl(dev->gain);
486 mutex_lock(&dev->ctrl_handler.lock);
487 snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
488 dev->brightness->cur.val,
489 dev->contrast->cur.val,
490 dev->saturation->cur.val,
492 gen_text(dev, vbuf, line++ * 16, 16, str);
493 snprintf(str, sizeof(str), " autogain %d, gain %3d, volume %3d ",
494 dev->autogain->cur.val, gain, dev->volume->cur.val);
495 gen_text(dev, vbuf, line++ * 16, 16, str);
496 snprintf(str, sizeof(str), " int32 %d, int64 %lld ",
498 dev->int64->cur.val64);
499 gen_text(dev, vbuf, line++ * 16, 16, str);
500 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
501 dev->boolean->cur.val,
502 dev->menu->qmenu[dev->menu->cur.val],
503 dev->string->cur.string);
504 mutex_unlock(&dev->ctrl_handler.lock);
505 gen_text(dev, vbuf, line++ * 16, 16, str);
506 if (dev->button_pressed) {
507 dev->button_pressed--;
508 snprintf(str, sizeof(str), " button pressed!");
509 gen_text(dev, vbuf, line++ * 16, 16, str);
514 buf->vb.v4l2_buf.field = dev->field;
516 buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
517 do_gettimeofday(&ts);
518 buf->vb.v4l2_buf.timestamp = ts;
521 static void vivi_thread_tick(struct vivi_dev *dev)
523 struct vivi_dmaqueue *dma_q = &dev->vidq;
524 struct vivi_buffer *buf;
525 unsigned long flags = 0;
527 dprintk(dev, 1, "Thread tick\n");
529 spin_lock_irqsave(&dev->slock, flags);
530 if (list_empty(&dma_q->active)) {
531 dprintk(dev, 1, "No active queue to serve\n");
535 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
536 list_del(&buf->list);
538 do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
541 vivi_fillbuff(dev, buf);
542 dprintk(dev, 1, "filled buffer %p\n", buf);
544 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
545 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
547 spin_unlock_irqrestore(&dev->slock, flags);
550 #define frames_to_ms(frames) \
551 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
553 static void vivi_sleep(struct vivi_dev *dev)
555 struct vivi_dmaqueue *dma_q = &dev->vidq;
557 DECLARE_WAITQUEUE(wait, current);
559 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
560 (unsigned long)dma_q);
562 add_wait_queue(&dma_q->wq, &wait);
563 if (kthread_should_stop())
566 /* Calculate time to wake up */
567 timeout = msecs_to_jiffies(frames_to_ms(1));
569 vivi_thread_tick(dev);
571 schedule_timeout_interruptible(timeout);
574 remove_wait_queue(&dma_q->wq, &wait);
578 static int vivi_thread(void *data)
580 struct vivi_dev *dev = data;
582 dprintk(dev, 1, "thread started\n");
589 if (kthread_should_stop())
592 dprintk(dev, 1, "thread: exit\n");
596 static int vivi_start_generating(struct vivi_dev *dev)
598 struct vivi_dmaqueue *dma_q = &dev->vidq;
600 dprintk(dev, 1, "%s\n", __func__);
602 /* Resets frame counters */
605 dev->jiffies = jiffies;
608 dma_q->ini_jiffies = jiffies;
609 dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
611 if (IS_ERR(dma_q->kthread)) {
612 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
613 return PTR_ERR(dma_q->kthread);
616 wake_up_interruptible(&dma_q->wq);
618 dprintk(dev, 1, "returning from %s\n", __func__);
622 static void vivi_stop_generating(struct vivi_dev *dev)
624 struct vivi_dmaqueue *dma_q = &dev->vidq;
626 dprintk(dev, 1, "%s\n", __func__);
628 /* shutdown control thread */
629 if (dma_q->kthread) {
630 kthread_stop(dma_q->kthread);
631 dma_q->kthread = NULL;
635 * Typical driver might need to wait here until dma engine stops.
636 * In this case we can abort imiedetly, so it's just a noop.
639 /* Release all active buffers */
640 while (!list_empty(&dma_q->active)) {
641 struct vivi_buffer *buf;
642 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
643 list_del(&buf->list);
644 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
645 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
648 /* ------------------------------------------------------------------
650 ------------------------------------------------------------------*/
651 static int queue_setup(struct vb2_queue *vq, unsigned int *nbuffers,
652 unsigned int *nplanes, unsigned long sizes[],
655 struct vivi_dev *dev = vb2_get_drv_priv(vq);
658 size = dev->width * dev->height * 2;
663 while (size * *nbuffers > vid_limit * 1024 * 1024)
671 * videobuf2-vmalloc allocator is context-less so no need to set
675 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
681 static int buffer_init(struct vb2_buffer *vb)
683 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
685 BUG_ON(NULL == dev->fmt);
688 * This callback is called once per buffer, after its allocation.
690 * Vivi does not allow changing format during streaming, but it is
691 * possible to do so when streaming is paused (i.e. in streamoff state).
692 * Buffers however are not freed when going into streamoff and so
693 * buffer size verification has to be done in buffer_prepare, on each
695 * It would be best to move verification code here to buf_init and
702 static int buffer_prepare(struct vb2_buffer *vb)
704 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
705 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
708 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
710 BUG_ON(NULL == dev->fmt);
713 * Theses properties only change when queue is idle, see s_fmt.
714 * The below checks should not be performed here, on each
715 * buffer_prepare (i.e. on each qbuf). Most of the code in this function
716 * should thus be moved to buffer_init and s_fmt.
718 if (dev->width < 48 || dev->width > MAX_WIDTH ||
719 dev->height < 32 || dev->height > MAX_HEIGHT)
722 size = dev->width * dev->height * 2;
723 if (vb2_plane_size(vb, 0) < size) {
724 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
725 __func__, vb2_plane_size(vb, 0), size);
729 vb2_set_plane_payload(&buf->vb, 0, size);
733 precalculate_bars(dev);
734 precalculate_line(dev);
739 static int buffer_finish(struct vb2_buffer *vb)
741 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
742 dprintk(dev, 1, "%s\n", __func__);
746 static void buffer_cleanup(struct vb2_buffer *vb)
748 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
749 dprintk(dev, 1, "%s\n", __func__);
753 static void buffer_queue(struct vb2_buffer *vb)
755 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
756 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
757 struct vivi_dmaqueue *vidq = &dev->vidq;
758 unsigned long flags = 0;
760 dprintk(dev, 1, "%s\n", __func__);
762 spin_lock_irqsave(&dev->slock, flags);
763 list_add_tail(&buf->list, &vidq->active);
764 spin_unlock_irqrestore(&dev->slock, flags);
767 static int start_streaming(struct vb2_queue *vq)
769 struct vivi_dev *dev = vb2_get_drv_priv(vq);
770 dprintk(dev, 1, "%s\n", __func__);
771 return vivi_start_generating(dev);
774 /* abort streaming and wait for last buffer */
775 static int stop_streaming(struct vb2_queue *vq)
777 struct vivi_dev *dev = vb2_get_drv_priv(vq);
778 dprintk(dev, 1, "%s\n", __func__);
779 vivi_stop_generating(dev);
783 static void vivi_lock(struct vb2_queue *vq)
785 struct vivi_dev *dev = vb2_get_drv_priv(vq);
786 mutex_lock(&dev->mutex);
789 static void vivi_unlock(struct vb2_queue *vq)
791 struct vivi_dev *dev = vb2_get_drv_priv(vq);
792 mutex_unlock(&dev->mutex);
796 static struct vb2_ops vivi_video_qops = {
797 .queue_setup = queue_setup,
798 .buf_init = buffer_init,
799 .buf_prepare = buffer_prepare,
800 .buf_finish = buffer_finish,
801 .buf_cleanup = buffer_cleanup,
802 .buf_queue = buffer_queue,
803 .start_streaming = start_streaming,
804 .stop_streaming = stop_streaming,
805 .wait_prepare = vivi_unlock,
806 .wait_finish = vivi_lock,
809 /* ------------------------------------------------------------------
810 IOCTL vidioc handling
811 ------------------------------------------------------------------*/
812 static int vidioc_querycap(struct file *file, void *priv,
813 struct v4l2_capability *cap)
815 struct vivi_dev *dev = video_drvdata(file);
817 strcpy(cap->driver, "vivi");
818 strcpy(cap->card, "vivi");
819 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
820 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | \
825 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
826 struct v4l2_fmtdesc *f)
828 struct vivi_fmt *fmt;
830 if (f->index >= ARRAY_SIZE(formats))
833 fmt = &formats[f->index];
835 strlcpy(f->description, fmt->name, sizeof(f->description));
836 f->pixelformat = fmt->fourcc;
840 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
841 struct v4l2_format *f)
843 struct vivi_dev *dev = video_drvdata(file);
845 f->fmt.pix.width = dev->width;
846 f->fmt.pix.height = dev->height;
847 f->fmt.pix.field = dev->field;
848 f->fmt.pix.pixelformat = dev->fmt->fourcc;
849 f->fmt.pix.bytesperline =
850 (f->fmt.pix.width * dev->fmt->depth) >> 3;
851 f->fmt.pix.sizeimage =
852 f->fmt.pix.height * f->fmt.pix.bytesperline;
856 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
857 struct v4l2_format *f)
859 struct vivi_dev *dev = video_drvdata(file);
860 struct vivi_fmt *fmt;
861 enum v4l2_field field;
865 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
866 f->fmt.pix.pixelformat);
870 field = f->fmt.pix.field;
872 if (field == V4L2_FIELD_ANY) {
873 field = V4L2_FIELD_INTERLACED;
874 } else if (V4L2_FIELD_INTERLACED != field) {
875 dprintk(dev, 1, "Field type invalid.\n");
879 f->fmt.pix.field = field;
880 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
881 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
882 f->fmt.pix.bytesperline =
883 (f->fmt.pix.width * fmt->depth) >> 3;
884 f->fmt.pix.sizeimage =
885 f->fmt.pix.height * f->fmt.pix.bytesperline;
889 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
890 struct v4l2_format *f)
892 struct vivi_dev *dev = video_drvdata(file);
893 struct vb2_queue *q = &dev->vb_vidq;
895 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
899 if (vb2_is_streaming(q)) {
900 dprintk(dev, 1, "%s device busy\n", __func__);
904 dev->fmt = get_format(f);
905 dev->width = f->fmt.pix.width;
906 dev->height = f->fmt.pix.height;
907 dev->field = f->fmt.pix.field;
912 static int vidioc_reqbufs(struct file *file, void *priv,
913 struct v4l2_requestbuffers *p)
915 struct vivi_dev *dev = video_drvdata(file);
916 return vb2_reqbufs(&dev->vb_vidq, p);
919 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
921 struct vivi_dev *dev = video_drvdata(file);
922 return vb2_querybuf(&dev->vb_vidq, p);
925 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
927 struct vivi_dev *dev = video_drvdata(file);
928 return vb2_qbuf(&dev->vb_vidq, p);
931 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
933 struct vivi_dev *dev = video_drvdata(file);
934 return vb2_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK);
937 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
939 struct vivi_dev *dev = video_drvdata(file);
940 return vb2_streamon(&dev->vb_vidq, i);
943 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
945 struct vivi_dev *dev = video_drvdata(file);
946 return vb2_streamoff(&dev->vb_vidq, i);
949 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
954 /* only one input in this sample driver */
955 static int vidioc_enum_input(struct file *file, void *priv,
956 struct v4l2_input *inp)
958 if (inp->index >= NUM_INPUTS)
961 inp->type = V4L2_INPUT_TYPE_CAMERA;
962 inp->std = V4L2_STD_525_60;
963 sprintf(inp->name, "Camera %u", inp->index);
967 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
969 struct vivi_dev *dev = video_drvdata(file);
975 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
977 struct vivi_dev *dev = video_drvdata(file);
986 precalculate_bars(dev);
987 precalculate_line(dev);
991 static int vidioc_subscribe_event(struct v4l2_fh *fh,
992 struct v4l2_event_subscription *sub)
995 case V4L2_EVENT_CTRL:
996 return v4l2_event_subscribe(fh, sub, 0);
1002 /* --- controls ---------------------------------------------- */
1004 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1006 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1008 if (ctrl == dev->autogain)
1009 dev->gain->val = jiffies & 0xff;
1013 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1015 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1017 if (ctrl == dev->button)
1018 dev->button_pressed = 30;
1022 /* ------------------------------------------------------------------
1023 File operations for the device
1024 ------------------------------------------------------------------*/
1027 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1029 struct vivi_dev *dev = video_drvdata(file);
1031 dprintk(dev, 1, "read called\n");
1032 return vb2_read(&dev->vb_vidq, data, count, ppos,
1033 file->f_flags & O_NONBLOCK);
1037 vivi_poll(struct file *file, struct poll_table_struct *wait)
1039 struct vivi_dev *dev = video_drvdata(file);
1040 struct v4l2_fh *fh = file->private_data;
1041 struct vb2_queue *q = &dev->vb_vidq;
1044 dprintk(dev, 1, "%s\n", __func__);
1045 res = vb2_poll(q, file, wait);
1046 if (v4l2_event_pending(fh))
1049 poll_wait(file, &fh->wait, wait);
1053 static int vivi_close(struct file *file)
1055 struct video_device *vdev = video_devdata(file);
1056 struct vivi_dev *dev = video_drvdata(file);
1058 dprintk(dev, 1, "close called (dev=%s), file %p\n",
1059 video_device_node_name(vdev), file);
1061 if (v4l2_fh_is_singular_file(file))
1062 vb2_queue_release(&dev->vb_vidq);
1063 return v4l2_fh_release(file);
1066 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1068 struct vivi_dev *dev = video_drvdata(file);
1071 dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1073 ret = vb2_mmap(&dev->vb_vidq, vma);
1074 dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1075 (unsigned long)vma->vm_start,
1076 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
1081 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1082 .g_volatile_ctrl = vivi_g_volatile_ctrl,
1083 .s_ctrl = vivi_s_ctrl,
1086 #define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1088 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1089 .ops = &vivi_ctrl_ops,
1090 .id = VIVI_CID_CUSTOM_BASE + 0,
1092 .type = V4L2_CTRL_TYPE_BUTTON,
1095 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1096 .ops = &vivi_ctrl_ops,
1097 .id = VIVI_CID_CUSTOM_BASE + 1,
1099 .type = V4L2_CTRL_TYPE_BOOLEAN,
1106 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1107 .ops = &vivi_ctrl_ops,
1108 .id = VIVI_CID_CUSTOM_BASE + 2,
1109 .name = "Integer 32 Bits",
1110 .type = V4L2_CTRL_TYPE_INTEGER,
1116 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1117 .ops = &vivi_ctrl_ops,
1118 .id = VIVI_CID_CUSTOM_BASE + 3,
1119 .name = "Integer 64 Bits",
1120 .type = V4L2_CTRL_TYPE_INTEGER64,
1123 static const char * const vivi_ctrl_menu_strings[] = {
1124 "Menu Item 0 (Skipped)",
1126 "Menu Item 2 (Skipped)",
1129 "Menu Item 5 (Skipped)",
1133 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1134 .ops = &vivi_ctrl_ops,
1135 .id = VIVI_CID_CUSTOM_BASE + 4,
1137 .type = V4L2_CTRL_TYPE_MENU,
1141 .menu_skip_mask = 0x04,
1142 .qmenu = vivi_ctrl_menu_strings,
1145 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1146 .ops = &vivi_ctrl_ops,
1147 .id = VIVI_CID_CUSTOM_BASE + 5,
1149 .type = V4L2_CTRL_TYPE_STRING,
1155 static const struct v4l2_file_operations vivi_fops = {
1156 .owner = THIS_MODULE,
1157 .open = v4l2_fh_open,
1158 .release = vivi_close,
1161 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1165 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1166 .vidioc_querycap = vidioc_querycap,
1167 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1168 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1169 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1170 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1171 .vidioc_reqbufs = vidioc_reqbufs,
1172 .vidioc_querybuf = vidioc_querybuf,
1173 .vidioc_qbuf = vidioc_qbuf,
1174 .vidioc_dqbuf = vidioc_dqbuf,
1175 .vidioc_s_std = vidioc_s_std,
1176 .vidioc_enum_input = vidioc_enum_input,
1177 .vidioc_g_input = vidioc_g_input,
1178 .vidioc_s_input = vidioc_s_input,
1179 .vidioc_streamon = vidioc_streamon,
1180 .vidioc_streamoff = vidioc_streamoff,
1181 .vidioc_subscribe_event = vidioc_subscribe_event,
1182 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1185 static struct video_device vivi_template = {
1188 .ioctl_ops = &vivi_ioctl_ops,
1189 .release = video_device_release,
1191 .tvnorms = V4L2_STD_525_60,
1192 .current_norm = V4L2_STD_NTSC_M,
1195 /* -----------------------------------------------------------------
1196 Initialization and module stuff
1197 ------------------------------------------------------------------*/
1199 static int vivi_release(void)
1201 struct vivi_dev *dev;
1202 struct list_head *list;
1204 while (!list_empty(&vivi_devlist)) {
1205 list = vivi_devlist.next;
1207 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1209 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1210 video_device_node_name(dev->vfd));
1211 video_unregister_device(dev->vfd);
1212 v4l2_device_unregister(&dev->v4l2_dev);
1213 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1220 static int __init vivi_create_instance(int inst)
1222 struct vivi_dev *dev;
1223 struct video_device *vfd;
1224 struct v4l2_ctrl_handler *hdl;
1225 struct vb2_queue *q;
1228 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1232 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1233 "%s-%03d", VIVI_MODULE_NAME, inst);
1234 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1238 dev->fmt = &formats[0];
1241 hdl = &dev->ctrl_handler;
1242 v4l2_ctrl_handler_init(hdl, 11);
1243 dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1244 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1245 dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1246 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1247 dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1248 V4L2_CID_CONTRAST, 0, 255, 1, 16);
1249 dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1250 V4L2_CID_SATURATION, 0, 255, 1, 127);
1251 dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1252 V4L2_CID_HUE, -128, 127, 1, 0);
1253 dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1254 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1255 dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1256 V4L2_CID_GAIN, 0, 255, 1, 100);
1257 dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1258 dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1259 dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1260 dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1261 dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1262 dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1267 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1268 dev->v4l2_dev.ctrl_handler = hdl;
1270 /* initialize locks */
1271 spin_lock_init(&dev->slock);
1273 /* initialize queue */
1275 memset(q, 0, sizeof(dev->vb_vidq));
1276 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1277 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1279 q->buf_struct_size = sizeof(struct vivi_buffer);
1280 q->ops = &vivi_video_qops;
1281 q->mem_ops = &vb2_vmalloc_memops;
1285 mutex_init(&dev->mutex);
1287 /* init video dma queues */
1288 INIT_LIST_HEAD(&dev->vidq.active);
1289 init_waitqueue_head(&dev->vidq.wq);
1292 vfd = video_device_alloc();
1296 *vfd = vivi_template;
1298 vfd->v4l2_dev = &dev->v4l2_dev;
1299 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1302 * Provide a mutex to v4l2 core. It will be used to protect
1303 * all fops and v4l2 ioctls.
1305 vfd->lock = &dev->mutex;
1307 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1311 video_set_drvdata(vfd, dev);
1313 /* Now that everything is fine, let's add it to device list */
1314 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1320 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1321 video_device_node_name(vfd));
1325 video_device_release(vfd);
1327 v4l2_ctrl_handler_free(hdl);
1328 v4l2_device_unregister(&dev->v4l2_dev);
1334 /* This routine allocates from 1 to n_devs virtual drivers.
1336 The real maximum number of virtual drivers will depend on how many drivers
1337 will succeed. This is limited to the maximum number of devices that
1338 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1340 static int __init vivi_init(void)
1342 const struct font_desc *font = find_font("VGA8x16");
1346 printk(KERN_ERR "vivi: could not find font\n");
1349 font8x16 = font->data;
1354 for (i = 0; i < n_devs; i++) {
1355 ret = vivi_create_instance(i);
1357 /* If some instantiations succeeded, keep driver */
1365 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1369 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1370 "Capture Board ver %s successfully loaded.\n",
1373 /* n_devs will reflect the actual number of allocated devices */
1379 static void __exit vivi_exit(void)
1384 module_init(vivi_init);
1385 module_exit(vivi_exit);