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 */
87 static struct vivi_fmt formats[] = {
89 .name = "4:2:2, packed, YUYV",
90 .fourcc = V4L2_PIX_FMT_YUYV,
95 .name = "4:2:2, packed, UYVY",
96 .fourcc = V4L2_PIX_FMT_UYVY,
101 .name = "4:2:2, packed, YVYU",
102 .fourcc = V4L2_PIX_FMT_YVYU,
107 .name = "4:2:2, packed, VYUY",
108 .fourcc = V4L2_PIX_FMT_VYUY,
113 .name = "RGB565 (LE)",
114 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
118 .name = "RGB565 (BE)",
119 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
123 .name = "RGB555 (LE)",
124 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
128 .name = "RGB555 (BE)",
129 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
133 .name = "RGB24 (LE)",
134 .fourcc = V4L2_PIX_FMT_RGB24, /* rgb */
138 .name = "RGB24 (BE)",
139 .fourcc = V4L2_PIX_FMT_BGR24, /* bgr */
143 .name = "RGB32 (LE)",
144 .fourcc = V4L2_PIX_FMT_RGB32, /* argb */
148 .name = "RGB32 (BE)",
149 .fourcc = V4L2_PIX_FMT_BGR32, /* bgra */
154 static struct vivi_fmt *get_format(struct v4l2_format *f)
156 struct vivi_fmt *fmt;
159 for (k = 0; k < ARRAY_SIZE(formats); k++) {
161 if (fmt->fourcc == f->fmt.pix.pixelformat)
165 if (k == ARRAY_SIZE(formats))
171 /* buffer for one video frame */
173 /* common v4l buffer stuff -- must be first */
174 struct vb2_buffer vb;
175 struct list_head list;
176 struct vivi_fmt *fmt;
179 struct vivi_dmaqueue {
180 struct list_head active;
182 /* thread for generating video stream*/
183 struct task_struct *kthread;
184 wait_queue_head_t wq;
185 /* Counters to control fps rate */
190 static LIST_HEAD(vivi_devlist);
193 struct list_head vivi_devlist;
194 struct v4l2_device v4l2_dev;
195 struct v4l2_ctrl_handler ctrl_handler;
196 struct video_device vdev;
199 struct v4l2_ctrl *brightness;
200 struct v4l2_ctrl *contrast;
201 struct v4l2_ctrl *saturation;
202 struct v4l2_ctrl *hue;
204 /* autogain/gain cluster */
205 struct v4l2_ctrl *autogain;
206 struct v4l2_ctrl *gain;
208 struct v4l2_ctrl *volume;
209 struct v4l2_ctrl *alpha;
210 struct v4l2_ctrl *button;
211 struct v4l2_ctrl *boolean;
212 struct v4l2_ctrl *int32;
213 struct v4l2_ctrl *int64;
214 struct v4l2_ctrl *menu;
215 struct v4l2_ctrl *string;
216 struct v4l2_ctrl *bitmask;
217 struct v4l2_ctrl *int_menu;
222 struct vivi_dmaqueue vidq;
224 /* Several counters */
226 unsigned long jiffies;
227 unsigned button_pressed;
229 int mv_count; /* Controls bars movement */
235 struct vivi_fmt *fmt;
236 unsigned int width, height;
237 struct vb2_queue vb_vidq;
238 unsigned int field_count;
241 u8 line[MAX_WIDTH * 8];
242 unsigned int pixelsize;
246 /* ------------------------------------------------------------------
247 DMA and thread functions
248 ------------------------------------------------------------------*/
250 /* Bars and Colors should match positions */
265 #define COLOR_WHITE {204, 204, 204}
266 #define COLOR_AMBER {208, 208, 0}
267 #define COLOR_CYAN { 0, 206, 206}
268 #define COLOR_GREEN { 0, 239, 0}
269 #define COLOR_MAGENTA {239, 0, 239}
270 #define COLOR_RED {205, 0, 0}
271 #define COLOR_BLUE { 0, 0, 255}
272 #define COLOR_BLACK { 0, 0, 0}
278 /* Maximum number of bars are 10 - otherwise, the input print code
279 should be modified */
280 static struct bar_std bars[] = {
281 { /* Standard ITU-R color bar sequence */
282 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
283 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
285 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
286 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
288 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
289 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
291 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
292 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
296 #define NUM_INPUTS ARRAY_SIZE(bars)
298 #define TO_Y(r, g, b) \
299 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
300 /* RGB to V(Cr) Color transform */
301 #define TO_V(r, g, b) \
302 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
303 /* RGB to U(Cb) Color transform */
304 #define TO_U(r, g, b) \
305 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
307 /* precalculate color bar values to speed up rendering */
308 static void precalculate_bars(struct vivi_dev *dev)
313 for (k = 0; k < 9; k++) {
314 r = bars[dev->input].bar[k][0];
315 g = bars[dev->input].bar[k][1];
316 b = bars[dev->input].bar[k][2];
317 is_yuv = dev->fmt->is_yuv;
319 switch (dev->fmt->fourcc) {
320 case V4L2_PIX_FMT_RGB565:
321 case V4L2_PIX_FMT_RGB565X:
326 case V4L2_PIX_FMT_RGB555:
327 case V4L2_PIX_FMT_RGB555X:
332 case V4L2_PIX_FMT_YUYV:
333 case V4L2_PIX_FMT_UYVY:
334 case V4L2_PIX_FMT_YVYU:
335 case V4L2_PIX_FMT_VYUY:
336 case V4L2_PIX_FMT_RGB24:
337 case V4L2_PIX_FMT_BGR24:
338 case V4L2_PIX_FMT_RGB32:
339 case V4L2_PIX_FMT_BGR32:
344 dev->bars[k][0] = TO_Y(r, g, b); /* Luma */
345 dev->bars[k][1] = TO_U(r, g, b); /* Cb */
346 dev->bars[k][2] = TO_V(r, g, b); /* Cr */
355 #define TSTAMP_MIN_Y 24
356 #define TSTAMP_MAX_Y (TSTAMP_MIN_Y + 15)
357 #define TSTAMP_INPUT_X 10
358 #define TSTAMP_MIN_X (54 + TSTAMP_INPUT_X)
360 /* 'odd' is true for pixels 1, 3, 5, etc. and false for pixels 0, 2, 4, etc. */
361 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos, bool odd)
364 u8 alpha = dev->alpha_component;
368 r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
369 g_u = dev->bars[colorpos][1]; /* G or precalculated U */
370 b_v = dev->bars[colorpos][2]; /* B or precalculated V */
372 for (color = 0; color < dev->pixelsize; color++) {
375 switch (dev->fmt->fourcc) {
376 case V4L2_PIX_FMT_YUYV:
382 *p = odd ? b_v : g_u;
386 case V4L2_PIX_FMT_UYVY:
389 *p = odd ? b_v : g_u;
396 case V4L2_PIX_FMT_YVYU:
402 *p = odd ? g_u : b_v;
406 case V4L2_PIX_FMT_VYUY:
409 *p = odd ? g_u : b_v;
416 case V4L2_PIX_FMT_RGB565:
419 *p = (g_u << 5) | b_v;
422 *p = (r_y << 3) | (g_u >> 3);
426 case V4L2_PIX_FMT_RGB565X:
429 *p = (r_y << 3) | (g_u >> 3);
432 *p = (g_u << 5) | b_v;
436 case V4L2_PIX_FMT_RGB555:
439 *p = (g_u << 5) | b_v;
442 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
446 case V4L2_PIX_FMT_RGB555X:
449 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
452 *p = (g_u << 5) | b_v;
456 case V4L2_PIX_FMT_RGB24:
469 case V4L2_PIX_FMT_BGR24:
482 case V4L2_PIX_FMT_RGB32:
498 case V4L2_PIX_FMT_BGR32:
518 static void precalculate_line(struct vivi_dev *dev)
522 for (w = 0; w < dev->width * 2; w++) {
523 int colorpos = w / (dev->width / 8) % 8;
525 gen_twopix(dev, dev->line + w * dev->pixelsize, colorpos, w & 1);
529 static void gen_text(struct vivi_dev *dev, char *basep,
530 int y, int x, char *text)
534 /* Checks if it is possible to show string */
535 if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
538 /* Print stream time */
539 for (line = y; line < y + 16; line++) {
541 char *pos = basep + line * dev->width * dev->pixelsize + x * dev->pixelsize;
544 for (s = text; *s; s++) {
545 u8 chr = font8x16[*s * 16 + line - y];
548 for (i = 0; i < 7; i++, j++) {
549 /* Draw white font on black background */
550 if (chr & (1 << (7 - i)))
551 gen_twopix(dev, pos + j * dev->pixelsize, WHITE, (x+y) & 1);
553 gen_twopix(dev, pos + j * dev->pixelsize, TEXT_BLACK, (x+y) & 1);
559 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
561 int wmax = dev->width;
562 int hmax = dev->height;
564 void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
573 for (h = 0; h < hmax; h++)
574 memcpy(vbuf + h * wmax * dev->pixelsize,
575 dev->line + (dev->mv_count % wmax) * dev->pixelsize,
576 wmax * dev->pixelsize);
578 /* Updates stream time */
580 dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
581 dev->jiffies = jiffies;
583 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
584 (ms / (60 * 60 * 1000)) % 24,
585 (ms / (60 * 1000)) % 60,
588 gen_text(dev, vbuf, line++ * 16, 16, str);
589 snprintf(str, sizeof(str), " %dx%d, input %d ",
590 dev->width, dev->height, dev->input);
591 gen_text(dev, vbuf, line++ * 16, 16, str);
593 gain = v4l2_ctrl_g_ctrl(dev->gain);
594 mutex_lock(dev->ctrl_handler.lock);
595 snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
596 dev->brightness->cur.val,
597 dev->contrast->cur.val,
598 dev->saturation->cur.val,
600 gen_text(dev, vbuf, line++ * 16, 16, str);
601 snprintf(str, sizeof(str), " autogain %d, gain %3d, volume %3d, alpha 0x%02x ",
602 dev->autogain->cur.val, gain, dev->volume->cur.val,
603 dev->alpha->cur.val);
604 gen_text(dev, vbuf, line++ * 16, 16, str);
605 snprintf(str, sizeof(str), " int32 %d, int64 %lld, bitmask %08x ",
607 dev->int64->cur.val64,
608 dev->bitmask->cur.val);
609 gen_text(dev, vbuf, line++ * 16, 16, str);
610 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
611 dev->boolean->cur.val,
612 dev->menu->qmenu[dev->menu->cur.val],
613 dev->string->cur.string);
614 gen_text(dev, vbuf, line++ * 16, 16, str);
615 snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
616 dev->int_menu->qmenu_int[dev->int_menu->cur.val],
617 dev->int_menu->cur.val);
618 gen_text(dev, vbuf, line++ * 16, 16, str);
619 mutex_unlock(dev->ctrl_handler.lock);
620 if (dev->button_pressed) {
621 dev->button_pressed--;
622 snprintf(str, sizeof(str), " button pressed!");
623 gen_text(dev, vbuf, line++ * 16, 16, str);
628 buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
630 buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
631 do_gettimeofday(&ts);
632 buf->vb.v4l2_buf.timestamp = ts;
635 static void vivi_thread_tick(struct vivi_dev *dev)
637 struct vivi_dmaqueue *dma_q = &dev->vidq;
638 struct vivi_buffer *buf;
639 unsigned long flags = 0;
641 dprintk(dev, 1, "Thread tick\n");
643 spin_lock_irqsave(&dev->slock, flags);
644 if (list_empty(&dma_q->active)) {
645 dprintk(dev, 1, "No active queue to serve\n");
646 spin_unlock_irqrestore(&dev->slock, flags);
650 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
651 list_del(&buf->list);
652 spin_unlock_irqrestore(&dev->slock, flags);
654 do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
657 vivi_fillbuff(dev, buf);
658 dprintk(dev, 1, "filled buffer %p\n", buf);
660 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
661 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
664 #define frames_to_ms(frames) \
665 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
667 static void vivi_sleep(struct vivi_dev *dev)
669 struct vivi_dmaqueue *dma_q = &dev->vidq;
671 DECLARE_WAITQUEUE(wait, current);
673 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
674 (unsigned long)dma_q);
676 add_wait_queue(&dma_q->wq, &wait);
677 if (kthread_should_stop())
680 /* Calculate time to wake up */
681 timeout = msecs_to_jiffies(frames_to_ms(1));
683 vivi_thread_tick(dev);
685 schedule_timeout_interruptible(timeout);
688 remove_wait_queue(&dma_q->wq, &wait);
692 static int vivi_thread(void *data)
694 struct vivi_dev *dev = data;
696 dprintk(dev, 1, "thread started\n");
703 if (kthread_should_stop())
706 dprintk(dev, 1, "thread: exit\n");
710 static int vivi_start_generating(struct vivi_dev *dev)
712 struct vivi_dmaqueue *dma_q = &dev->vidq;
714 dprintk(dev, 1, "%s\n", __func__);
716 /* Resets frame counters */
719 dev->jiffies = jiffies;
722 dma_q->ini_jiffies = jiffies;
723 dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
725 if (IS_ERR(dma_q->kthread)) {
726 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
727 return PTR_ERR(dma_q->kthread);
730 wake_up_interruptible(&dma_q->wq);
732 dprintk(dev, 1, "returning from %s\n", __func__);
736 static void vivi_stop_generating(struct vivi_dev *dev)
738 struct vivi_dmaqueue *dma_q = &dev->vidq;
740 dprintk(dev, 1, "%s\n", __func__);
742 /* shutdown control thread */
743 if (dma_q->kthread) {
744 kthread_stop(dma_q->kthread);
745 dma_q->kthread = NULL;
749 * Typical driver might need to wait here until dma engine stops.
750 * In this case we can abort imiedetly, so it's just a noop.
753 /* Release all active buffers */
754 while (!list_empty(&dma_q->active)) {
755 struct vivi_buffer *buf;
756 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
757 list_del(&buf->list);
758 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
759 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
762 /* ------------------------------------------------------------------
764 ------------------------------------------------------------------*/
765 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
766 unsigned int *nbuffers, unsigned int *nplanes,
767 unsigned int sizes[], void *alloc_ctxs[])
769 struct vivi_dev *dev = vb2_get_drv_priv(vq);
773 size = fmt->fmt.pix.sizeimage;
775 size = dev->width * dev->height * dev->pixelsize;
783 while (size * *nbuffers > vid_limit * 1024 * 1024)
791 * videobuf2-vmalloc allocator is context-less so no need to set
795 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
801 static int buffer_prepare(struct vb2_buffer *vb)
803 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
804 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
807 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
809 BUG_ON(NULL == dev->fmt);
812 * Theses properties only change when queue is idle, see s_fmt.
813 * The below checks should not be performed here, on each
814 * buffer_prepare (i.e. on each qbuf). Most of the code in this function
815 * should thus be moved to buffer_init and s_fmt.
817 if (dev->width < 48 || dev->width > MAX_WIDTH ||
818 dev->height < 32 || dev->height > MAX_HEIGHT)
821 size = dev->width * dev->height * dev->pixelsize;
822 if (vb2_plane_size(vb, 0) < size) {
823 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
824 __func__, vb2_plane_size(vb, 0), size);
828 vb2_set_plane_payload(&buf->vb, 0, size);
832 precalculate_bars(dev);
833 precalculate_line(dev);
838 static void buffer_queue(struct vb2_buffer *vb)
840 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
841 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
842 struct vivi_dmaqueue *vidq = &dev->vidq;
843 unsigned long flags = 0;
845 dprintk(dev, 1, "%s\n", __func__);
847 spin_lock_irqsave(&dev->slock, flags);
848 list_add_tail(&buf->list, &vidq->active);
849 spin_unlock_irqrestore(&dev->slock, flags);
852 static int start_streaming(struct vb2_queue *vq, unsigned int count)
854 struct vivi_dev *dev = vb2_get_drv_priv(vq);
855 dprintk(dev, 1, "%s\n", __func__);
856 return vivi_start_generating(dev);
859 /* abort streaming and wait for last buffer */
860 static int stop_streaming(struct vb2_queue *vq)
862 struct vivi_dev *dev = vb2_get_drv_priv(vq);
863 dprintk(dev, 1, "%s\n", __func__);
864 vivi_stop_generating(dev);
868 static void vivi_lock(struct vb2_queue *vq)
870 struct vivi_dev *dev = vb2_get_drv_priv(vq);
871 mutex_lock(&dev->mutex);
874 static void vivi_unlock(struct vb2_queue *vq)
876 struct vivi_dev *dev = vb2_get_drv_priv(vq);
877 mutex_unlock(&dev->mutex);
881 static struct vb2_ops vivi_video_qops = {
882 .queue_setup = queue_setup,
883 .buf_prepare = buffer_prepare,
884 .buf_queue = buffer_queue,
885 .start_streaming = start_streaming,
886 .stop_streaming = stop_streaming,
887 .wait_prepare = vivi_unlock,
888 .wait_finish = vivi_lock,
891 /* ------------------------------------------------------------------
892 IOCTL vidioc handling
893 ------------------------------------------------------------------*/
894 static int vidioc_querycap(struct file *file, void *priv,
895 struct v4l2_capability *cap)
897 struct vivi_dev *dev = video_drvdata(file);
899 strcpy(cap->driver, "vivi");
900 strcpy(cap->card, "vivi");
901 snprintf(cap->bus_info, sizeof(cap->bus_info),
902 "platform:%s", dev->v4l2_dev.name);
903 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
905 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
909 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
910 struct v4l2_fmtdesc *f)
912 struct vivi_fmt *fmt;
914 if (f->index >= ARRAY_SIZE(formats))
917 fmt = &formats[f->index];
919 strlcpy(f->description, fmt->name, sizeof(f->description));
920 f->pixelformat = fmt->fourcc;
924 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
925 struct v4l2_format *f)
927 struct vivi_dev *dev = video_drvdata(file);
929 f->fmt.pix.width = dev->width;
930 f->fmt.pix.height = dev->height;
931 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
932 f->fmt.pix.pixelformat = dev->fmt->fourcc;
933 f->fmt.pix.bytesperline =
934 (f->fmt.pix.width * dev->fmt->depth) >> 3;
935 f->fmt.pix.sizeimage =
936 f->fmt.pix.height * f->fmt.pix.bytesperline;
937 if (dev->fmt->is_yuv)
938 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
940 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
944 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
945 struct v4l2_format *f)
947 struct vivi_dev *dev = video_drvdata(file);
948 struct vivi_fmt *fmt;
952 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
953 f->fmt.pix.pixelformat);
954 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
958 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
959 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
960 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
961 f->fmt.pix.bytesperline =
962 (f->fmt.pix.width * fmt->depth) >> 3;
963 f->fmt.pix.sizeimage =
964 f->fmt.pix.height * f->fmt.pix.bytesperline;
966 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
968 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
973 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
974 struct v4l2_format *f)
976 struct vivi_dev *dev = video_drvdata(file);
977 struct vb2_queue *q = &dev->vb_vidq;
979 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
983 if (vb2_is_busy(q)) {
984 dprintk(dev, 1, "%s device busy\n", __func__);
988 dev->fmt = get_format(f);
989 dev->pixelsize = dev->fmt->depth / 8;
990 dev->width = f->fmt.pix.width;
991 dev->height = f->fmt.pix.height;
996 static int vidioc_enum_framesizes(struct file *file, void *fh,
997 struct v4l2_frmsizeenum *fsize)
999 static const struct v4l2_frmsize_stepwise sizes = {
1007 for (i = 0; i < ARRAY_SIZE(formats); i++)
1008 if (formats[i].fourcc == fsize->pixel_format)
1010 if (i == ARRAY_SIZE(formats))
1012 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1013 fsize->stepwise = sizes;
1017 /* only one input in this sample driver */
1018 static int vidioc_enum_input(struct file *file, void *priv,
1019 struct v4l2_input *inp)
1021 if (inp->index >= NUM_INPUTS)
1024 inp->type = V4L2_INPUT_TYPE_CAMERA;
1025 sprintf(inp->name, "Camera %u", inp->index);
1029 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1031 struct vivi_dev *dev = video_drvdata(file);
1037 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1039 struct vivi_dev *dev = video_drvdata(file);
1041 if (i >= NUM_INPUTS)
1044 if (i == dev->input)
1048 precalculate_bars(dev);
1049 precalculate_line(dev);
1053 /* --- controls ---------------------------------------------- */
1055 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1057 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1059 if (ctrl == dev->autogain)
1060 dev->gain->val = jiffies & 0xff;
1064 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1066 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1069 case V4L2_CID_ALPHA_COMPONENT:
1070 dev->alpha_component = ctrl->val;
1073 if (ctrl == dev->button)
1074 dev->button_pressed = 30;
1080 /* ------------------------------------------------------------------
1081 File operations for the device
1082 ------------------------------------------------------------------*/
1084 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1085 .g_volatile_ctrl = vivi_g_volatile_ctrl,
1086 .s_ctrl = vivi_s_ctrl,
1089 #define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1091 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1092 .ops = &vivi_ctrl_ops,
1093 .id = VIVI_CID_CUSTOM_BASE + 0,
1095 .type = V4L2_CTRL_TYPE_BUTTON,
1098 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1099 .ops = &vivi_ctrl_ops,
1100 .id = VIVI_CID_CUSTOM_BASE + 1,
1102 .type = V4L2_CTRL_TYPE_BOOLEAN,
1109 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1110 .ops = &vivi_ctrl_ops,
1111 .id = VIVI_CID_CUSTOM_BASE + 2,
1112 .name = "Integer 32 Bits",
1113 .type = V4L2_CTRL_TYPE_INTEGER,
1119 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1120 .ops = &vivi_ctrl_ops,
1121 .id = VIVI_CID_CUSTOM_BASE + 3,
1122 .name = "Integer 64 Bits",
1123 .type = V4L2_CTRL_TYPE_INTEGER64,
1126 static const char * const vivi_ctrl_menu_strings[] = {
1127 "Menu Item 0 (Skipped)",
1129 "Menu Item 2 (Skipped)",
1132 "Menu Item 5 (Skipped)",
1136 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1137 .ops = &vivi_ctrl_ops,
1138 .id = VIVI_CID_CUSTOM_BASE + 4,
1140 .type = V4L2_CTRL_TYPE_MENU,
1144 .menu_skip_mask = 0x04,
1145 .qmenu = vivi_ctrl_menu_strings,
1148 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1149 .ops = &vivi_ctrl_ops,
1150 .id = VIVI_CID_CUSTOM_BASE + 5,
1152 .type = V4L2_CTRL_TYPE_STRING,
1158 static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1159 .ops = &vivi_ctrl_ops,
1160 .id = VIVI_CID_CUSTOM_BASE + 6,
1162 .type = V4L2_CTRL_TYPE_BITMASK,
1169 static const s64 vivi_ctrl_int_menu_values[] = {
1170 1, 1, 2, 3, 5, 8, 13, 21, 42,
1173 static const struct v4l2_ctrl_config vivi_ctrl_int_menu = {
1174 .ops = &vivi_ctrl_ops,
1175 .id = VIVI_CID_CUSTOM_BASE + 7,
1176 .name = "Integer menu",
1177 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
1181 .menu_skip_mask = 0x02,
1182 .qmenu_int = vivi_ctrl_int_menu_values,
1185 static const struct v4l2_file_operations vivi_fops = {
1186 .owner = THIS_MODULE,
1187 .open = v4l2_fh_open,
1188 .release = vb2_fop_release,
1189 .read = vb2_fop_read,
1190 .poll = vb2_fop_poll,
1191 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1192 .mmap = vb2_fop_mmap,
1195 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1196 .vidioc_querycap = vidioc_querycap,
1197 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1198 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1199 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1200 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1201 .vidioc_enum_framesizes = vidioc_enum_framesizes,
1202 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1203 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1204 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1205 .vidioc_querybuf = vb2_ioctl_querybuf,
1206 .vidioc_qbuf = vb2_ioctl_qbuf,
1207 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1208 .vidioc_enum_input = vidioc_enum_input,
1209 .vidioc_g_input = vidioc_g_input,
1210 .vidioc_s_input = vidioc_s_input,
1211 .vidioc_streamon = vb2_ioctl_streamon,
1212 .vidioc_streamoff = vb2_ioctl_streamoff,
1213 .vidioc_log_status = v4l2_ctrl_log_status,
1214 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1215 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1218 static struct video_device vivi_template = {
1221 .ioctl_ops = &vivi_ioctl_ops,
1222 .release = video_device_release_empty,
1225 /* -----------------------------------------------------------------
1226 Initialization and module stuff
1227 ------------------------------------------------------------------*/
1229 static int vivi_release(void)
1231 struct vivi_dev *dev;
1232 struct list_head *list;
1234 while (!list_empty(&vivi_devlist)) {
1235 list = vivi_devlist.next;
1237 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1239 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1240 video_device_node_name(&dev->vdev));
1241 video_unregister_device(&dev->vdev);
1242 v4l2_device_unregister(&dev->v4l2_dev);
1243 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1250 static int __init vivi_create_instance(int inst)
1252 struct vivi_dev *dev;
1253 struct video_device *vfd;
1254 struct v4l2_ctrl_handler *hdl;
1255 struct vb2_queue *q;
1258 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1262 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1263 "%s-%03d", VIVI_MODULE_NAME, inst);
1264 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1268 dev->fmt = &formats[0];
1271 dev->pixelsize = dev->fmt->depth / 8;
1272 hdl = &dev->ctrl_handler;
1273 v4l2_ctrl_handler_init(hdl, 11);
1274 dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1275 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1276 dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1277 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1278 dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1279 V4L2_CID_CONTRAST, 0, 255, 1, 16);
1280 dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1281 V4L2_CID_SATURATION, 0, 255, 1, 127);
1282 dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1283 V4L2_CID_HUE, -128, 127, 1, 0);
1284 dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1285 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1286 dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1287 V4L2_CID_GAIN, 0, 255, 1, 100);
1288 dev->alpha = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1289 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1290 dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1291 dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1292 dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1293 dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1294 dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1295 dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1296 dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1297 dev->int_menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int_menu, NULL);
1302 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1303 dev->v4l2_dev.ctrl_handler = hdl;
1305 /* initialize locks */
1306 spin_lock_init(&dev->slock);
1308 /* initialize queue */
1310 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1311 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1313 q->buf_struct_size = sizeof(struct vivi_buffer);
1314 q->ops = &vivi_video_qops;
1315 q->mem_ops = &vb2_vmalloc_memops;
1317 ret = vb2_queue_init(q);
1321 mutex_init(&dev->mutex);
1323 /* init video dma queues */
1324 INIT_LIST_HEAD(&dev->vidq.active);
1325 init_waitqueue_head(&dev->vidq.wq);
1328 *vfd = vivi_template;
1330 vfd->v4l2_dev = &dev->v4l2_dev;
1332 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1335 * Provide a mutex to v4l2 core. It will be used to protect
1336 * all fops and v4l2 ioctls.
1338 vfd->lock = &dev->mutex;
1339 video_set_drvdata(vfd, dev);
1341 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1345 /* Now that everything is fine, let's add it to device list */
1346 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1348 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1349 video_device_node_name(vfd));
1353 v4l2_ctrl_handler_free(hdl);
1354 v4l2_device_unregister(&dev->v4l2_dev);
1360 /* This routine allocates from 1 to n_devs virtual drivers.
1362 The real maximum number of virtual drivers will depend on how many drivers
1363 will succeed. This is limited to the maximum number of devices that
1364 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1366 static int __init vivi_init(void)
1368 const struct font_desc *font = find_font("VGA8x16");
1372 printk(KERN_ERR "vivi: could not find font\n");
1375 font8x16 = font->data;
1380 for (i = 0; i < n_devs; i++) {
1381 ret = vivi_create_instance(i);
1383 /* If some instantiations succeeded, keep driver */
1391 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1395 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1396 "Capture Board ver %s successfully loaded.\n",
1399 /* n_devs will reflect the actual number of allocated devices */
1405 static void __exit vivi_exit(void)
1410 module_init(vivi_init);
1411 module_exit(vivi_exit);