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;
179 struct v4l2_ctrl *bitmask;
184 /* various device info */
185 struct video_device *vfd;
187 struct vivi_dmaqueue vidq;
189 /* Several counters */
191 unsigned long jiffies;
192 unsigned button_pressed;
194 int mv_count; /* Controls bars movement */
200 struct vivi_fmt *fmt;
201 unsigned int width, height;
202 struct vb2_queue vb_vidq;
203 enum v4l2_field field;
204 unsigned int field_count;
207 u8 line[MAX_WIDTH * 4];
210 /* ------------------------------------------------------------------
211 DMA and thread functions
212 ------------------------------------------------------------------*/
214 /* Bars and Colors should match positions */
229 #define COLOR_WHITE {204, 204, 204}
230 #define COLOR_AMBER {208, 208, 0}
231 #define COLOR_CYAN { 0, 206, 206}
232 #define COLOR_GREEN { 0, 239, 0}
233 #define COLOR_MAGENTA {239, 0, 239}
234 #define COLOR_RED {205, 0, 0}
235 #define COLOR_BLUE { 0, 0, 255}
236 #define COLOR_BLACK { 0, 0, 0}
242 /* Maximum number of bars are 10 - otherwise, the input print code
243 should be modified */
244 static struct bar_std bars[] = {
245 { /* Standard ITU-R color bar sequence */
246 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
247 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
249 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
250 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
252 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
253 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
255 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
256 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
260 #define NUM_INPUTS ARRAY_SIZE(bars)
262 #define TO_Y(r, g, b) \
263 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
264 /* RGB to V(Cr) Color transform */
265 #define TO_V(r, g, b) \
266 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
267 /* RGB to U(Cb) Color transform */
268 #define TO_U(r, g, b) \
269 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
271 /* precalculate color bar values to speed up rendering */
272 static void precalculate_bars(struct vivi_dev *dev)
277 for (k = 0; k < 9; k++) {
278 r = bars[dev->input].bar[k][0];
279 g = bars[dev->input].bar[k][1];
280 b = bars[dev->input].bar[k][2];
283 switch (dev->fmt->fourcc) {
284 case V4L2_PIX_FMT_YUYV:
285 case V4L2_PIX_FMT_UYVY:
288 case V4L2_PIX_FMT_RGB565:
289 case V4L2_PIX_FMT_RGB565X:
294 case V4L2_PIX_FMT_RGB555:
295 case V4L2_PIX_FMT_RGB555X:
303 dev->bars[k][0] = TO_Y(r, g, b); /* Luma */
304 dev->bars[k][1] = TO_U(r, g, b); /* Cb */
305 dev->bars[k][2] = TO_V(r, g, b); /* Cr */
314 #define TSTAMP_MIN_Y 24
315 #define TSTAMP_MAX_Y (TSTAMP_MIN_Y + 15)
316 #define TSTAMP_INPUT_X 10
317 #define TSTAMP_MIN_X (54 + TSTAMP_INPUT_X)
319 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos)
325 r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
326 g_u = dev->bars[colorpos][1]; /* G or precalculated U */
327 b_v = dev->bars[colorpos][2]; /* B or precalculated V */
329 for (color = 0; color < 4; color++) {
332 switch (dev->fmt->fourcc) {
333 case V4L2_PIX_FMT_YUYV:
347 case V4L2_PIX_FMT_UYVY:
361 case V4L2_PIX_FMT_RGB565:
365 *p = (g_u << 5) | b_v;
369 *p = (r_y << 3) | (g_u >> 3);
373 case V4L2_PIX_FMT_RGB565X:
377 *p = (r_y << 3) | (g_u >> 3);
381 *p = (g_u << 5) | b_v;
385 case V4L2_PIX_FMT_RGB555:
389 *p = (g_u << 5) | b_v;
393 *p = (r_y << 2) | (g_u >> 3);
397 case V4L2_PIX_FMT_RGB555X:
401 *p = (r_y << 2) | (g_u >> 3);
405 *p = (g_u << 5) | b_v;
413 static void precalculate_line(struct vivi_dev *dev)
417 for (w = 0; w < dev->width * 2; w += 2) {
418 int colorpos = (w / (dev->width / 8) % 8);
420 gen_twopix(dev, dev->line + w * 2, colorpos);
424 static void gen_text(struct vivi_dev *dev, char *basep,
425 int y, int x, char *text)
429 /* Checks if it is possible to show string */
430 if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
433 /* Print stream time */
434 for (line = y; line < y + 16; line++) {
436 char *pos = basep + line * dev->width * 2 + x * 2;
439 for (s = text; *s; s++) {
440 u8 chr = font8x16[*s * 16 + line - y];
443 for (i = 0; i < 7; i++, j++) {
444 /* Draw white font on black background */
445 if (chr & (1 << (7 - i)))
446 gen_twopix(dev, pos + j * 2, WHITE);
448 gen_twopix(dev, pos + j * 2, TEXT_BLACK);
454 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
456 int wmax = dev->width;
457 int hmax = dev->height;
459 void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
468 for (h = 0; h < hmax; h++)
469 memcpy(vbuf + h * wmax * 2, dev->line + (dev->mv_count % wmax) * 2, wmax * 2);
471 /* Updates stream time */
473 dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
474 dev->jiffies = jiffies;
476 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
477 (ms / (60 * 60 * 1000)) % 24,
478 (ms / (60 * 1000)) % 60,
481 gen_text(dev, vbuf, line++ * 16, 16, str);
482 snprintf(str, sizeof(str), " %dx%d, input %d ",
483 dev->width, dev->height, dev->input);
484 gen_text(dev, vbuf, line++ * 16, 16, str);
486 gain = v4l2_ctrl_g_ctrl(dev->gain);
487 mutex_lock(&dev->ctrl_handler.lock);
488 snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
489 dev->brightness->cur.val,
490 dev->contrast->cur.val,
491 dev->saturation->cur.val,
493 gen_text(dev, vbuf, line++ * 16, 16, str);
494 snprintf(str, sizeof(str), " autogain %d, gain %3d, volume %3d ",
495 dev->autogain->cur.val, gain, dev->volume->cur.val);
496 gen_text(dev, vbuf, line++ * 16, 16, str);
497 snprintf(str, sizeof(str), " int32 %d, int64 %lld, bitmask %08x ",
499 dev->int64->cur.val64,
500 dev->bitmask->cur.val);
501 gen_text(dev, vbuf, line++ * 16, 16, str);
502 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
503 dev->boolean->cur.val,
504 dev->menu->qmenu[dev->menu->cur.val],
505 dev->string->cur.string);
506 mutex_unlock(&dev->ctrl_handler.lock);
507 gen_text(dev, vbuf, line++ * 16, 16, str);
508 if (dev->button_pressed) {
509 dev->button_pressed--;
510 snprintf(str, sizeof(str), " button pressed!");
511 gen_text(dev, vbuf, line++ * 16, 16, str);
516 buf->vb.v4l2_buf.field = dev->field;
518 buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
519 do_gettimeofday(&ts);
520 buf->vb.v4l2_buf.timestamp = ts;
523 static void vivi_thread_tick(struct vivi_dev *dev)
525 struct vivi_dmaqueue *dma_q = &dev->vidq;
526 struct vivi_buffer *buf;
527 unsigned long flags = 0;
529 dprintk(dev, 1, "Thread tick\n");
531 spin_lock_irqsave(&dev->slock, flags);
532 if (list_empty(&dma_q->active)) {
533 dprintk(dev, 1, "No active queue to serve\n");
534 spin_unlock_irqrestore(&dev->slock, flags);
538 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
539 list_del(&buf->list);
540 spin_unlock_irqrestore(&dev->slock, flags);
542 do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
545 vivi_fillbuff(dev, buf);
546 dprintk(dev, 1, "filled buffer %p\n", buf);
548 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
549 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
552 #define frames_to_ms(frames) \
553 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
555 static void vivi_sleep(struct vivi_dev *dev)
557 struct vivi_dmaqueue *dma_q = &dev->vidq;
559 DECLARE_WAITQUEUE(wait, current);
561 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
562 (unsigned long)dma_q);
564 add_wait_queue(&dma_q->wq, &wait);
565 if (kthread_should_stop())
568 /* Calculate time to wake up */
569 timeout = msecs_to_jiffies(frames_to_ms(1));
571 vivi_thread_tick(dev);
573 schedule_timeout_interruptible(timeout);
576 remove_wait_queue(&dma_q->wq, &wait);
580 static int vivi_thread(void *data)
582 struct vivi_dev *dev = data;
584 dprintk(dev, 1, "thread started\n");
591 if (kthread_should_stop())
594 dprintk(dev, 1, "thread: exit\n");
598 static int vivi_start_generating(struct vivi_dev *dev)
600 struct vivi_dmaqueue *dma_q = &dev->vidq;
602 dprintk(dev, 1, "%s\n", __func__);
604 /* Resets frame counters */
607 dev->jiffies = jiffies;
610 dma_q->ini_jiffies = jiffies;
611 dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
613 if (IS_ERR(dma_q->kthread)) {
614 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
615 return PTR_ERR(dma_q->kthread);
618 wake_up_interruptible(&dma_q->wq);
620 dprintk(dev, 1, "returning from %s\n", __func__);
624 static void vivi_stop_generating(struct vivi_dev *dev)
626 struct vivi_dmaqueue *dma_q = &dev->vidq;
628 dprintk(dev, 1, "%s\n", __func__);
630 /* shutdown control thread */
631 if (dma_q->kthread) {
632 kthread_stop(dma_q->kthread);
633 dma_q->kthread = NULL;
637 * Typical driver might need to wait here until dma engine stops.
638 * In this case we can abort imiedetly, so it's just a noop.
641 /* Release all active buffers */
642 while (!list_empty(&dma_q->active)) {
643 struct vivi_buffer *buf;
644 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
645 list_del(&buf->list);
646 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
647 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
650 /* ------------------------------------------------------------------
652 ------------------------------------------------------------------*/
653 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
654 unsigned int *nbuffers, unsigned int *nplanes,
655 unsigned int sizes[], void *alloc_ctxs[])
657 struct vivi_dev *dev = vb2_get_drv_priv(vq);
660 size = dev->width * dev->height * 2;
665 while (size * *nbuffers > vid_limit * 1024 * 1024)
673 * videobuf2-vmalloc allocator is context-less so no need to set
677 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
683 static int buffer_init(struct vb2_buffer *vb)
685 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
687 BUG_ON(NULL == dev->fmt);
690 * This callback is called once per buffer, after its allocation.
692 * Vivi does not allow changing format during streaming, but it is
693 * possible to do so when streaming is paused (i.e. in streamoff state).
694 * Buffers however are not freed when going into streamoff and so
695 * buffer size verification has to be done in buffer_prepare, on each
697 * It would be best to move verification code here to buf_init and
704 static int buffer_prepare(struct vb2_buffer *vb)
706 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
707 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
710 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
712 BUG_ON(NULL == dev->fmt);
715 * Theses properties only change when queue is idle, see s_fmt.
716 * The below checks should not be performed here, on each
717 * buffer_prepare (i.e. on each qbuf). Most of the code in this function
718 * should thus be moved to buffer_init and s_fmt.
720 if (dev->width < 48 || dev->width > MAX_WIDTH ||
721 dev->height < 32 || dev->height > MAX_HEIGHT)
724 size = dev->width * dev->height * 2;
725 if (vb2_plane_size(vb, 0) < size) {
726 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
727 __func__, vb2_plane_size(vb, 0), size);
731 vb2_set_plane_payload(&buf->vb, 0, size);
735 precalculate_bars(dev);
736 precalculate_line(dev);
741 static int buffer_finish(struct vb2_buffer *vb)
743 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
744 dprintk(dev, 1, "%s\n", __func__);
748 static void buffer_cleanup(struct vb2_buffer *vb)
750 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
751 dprintk(dev, 1, "%s\n", __func__);
755 static void buffer_queue(struct vb2_buffer *vb)
757 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
758 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
759 struct vivi_dmaqueue *vidq = &dev->vidq;
760 unsigned long flags = 0;
762 dprintk(dev, 1, "%s\n", __func__);
764 spin_lock_irqsave(&dev->slock, flags);
765 list_add_tail(&buf->list, &vidq->active);
766 spin_unlock_irqrestore(&dev->slock, flags);
769 static int start_streaming(struct vb2_queue *vq, unsigned int count)
771 struct vivi_dev *dev = vb2_get_drv_priv(vq);
772 dprintk(dev, 1, "%s\n", __func__);
773 return vivi_start_generating(dev);
776 /* abort streaming and wait for last buffer */
777 static int stop_streaming(struct vb2_queue *vq)
779 struct vivi_dev *dev = vb2_get_drv_priv(vq);
780 dprintk(dev, 1, "%s\n", __func__);
781 vivi_stop_generating(dev);
785 static void vivi_lock(struct vb2_queue *vq)
787 struct vivi_dev *dev = vb2_get_drv_priv(vq);
788 mutex_lock(&dev->mutex);
791 static void vivi_unlock(struct vb2_queue *vq)
793 struct vivi_dev *dev = vb2_get_drv_priv(vq);
794 mutex_unlock(&dev->mutex);
798 static struct vb2_ops vivi_video_qops = {
799 .queue_setup = queue_setup,
800 .buf_init = buffer_init,
801 .buf_prepare = buffer_prepare,
802 .buf_finish = buffer_finish,
803 .buf_cleanup = buffer_cleanup,
804 .buf_queue = buffer_queue,
805 .start_streaming = start_streaming,
806 .stop_streaming = stop_streaming,
807 .wait_prepare = vivi_unlock,
808 .wait_finish = vivi_lock,
811 /* ------------------------------------------------------------------
812 IOCTL vidioc handling
813 ------------------------------------------------------------------*/
814 static int vidioc_querycap(struct file *file, void *priv,
815 struct v4l2_capability *cap)
817 struct vivi_dev *dev = video_drvdata(file);
819 strcpy(cap->driver, "vivi");
820 strcpy(cap->card, "vivi");
821 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
822 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
824 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
828 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
829 struct v4l2_fmtdesc *f)
831 struct vivi_fmt *fmt;
833 if (f->index >= ARRAY_SIZE(formats))
836 fmt = &formats[f->index];
838 strlcpy(f->description, fmt->name, sizeof(f->description));
839 f->pixelformat = fmt->fourcc;
843 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
844 struct v4l2_format *f)
846 struct vivi_dev *dev = video_drvdata(file);
848 f->fmt.pix.width = dev->width;
849 f->fmt.pix.height = dev->height;
850 f->fmt.pix.field = dev->field;
851 f->fmt.pix.pixelformat = dev->fmt->fourcc;
852 f->fmt.pix.bytesperline =
853 (f->fmt.pix.width * dev->fmt->depth) >> 3;
854 f->fmt.pix.sizeimage =
855 f->fmt.pix.height * f->fmt.pix.bytesperline;
856 if (dev->fmt->fourcc == V4L2_PIX_FMT_YUYV ||
857 dev->fmt->fourcc == V4L2_PIX_FMT_UYVY)
858 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
860 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
864 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
865 struct v4l2_format *f)
867 struct vivi_dev *dev = video_drvdata(file);
868 struct vivi_fmt *fmt;
869 enum v4l2_field field;
873 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
874 f->fmt.pix.pixelformat);
878 field = f->fmt.pix.field;
880 if (field == V4L2_FIELD_ANY) {
881 field = V4L2_FIELD_INTERLACED;
882 } else if (V4L2_FIELD_INTERLACED != field) {
883 dprintk(dev, 1, "Field type invalid.\n");
887 f->fmt.pix.field = field;
888 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
889 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
890 f->fmt.pix.bytesperline =
891 (f->fmt.pix.width * fmt->depth) >> 3;
892 f->fmt.pix.sizeimage =
893 f->fmt.pix.height * f->fmt.pix.bytesperline;
894 if (fmt->fourcc == V4L2_PIX_FMT_YUYV ||
895 fmt->fourcc == V4L2_PIX_FMT_UYVY)
896 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
898 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
902 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
903 struct v4l2_format *f)
905 struct vivi_dev *dev = video_drvdata(file);
906 struct vb2_queue *q = &dev->vb_vidq;
908 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
912 if (vb2_is_streaming(q)) {
913 dprintk(dev, 1, "%s device busy\n", __func__);
917 dev->fmt = get_format(f);
918 dev->width = f->fmt.pix.width;
919 dev->height = f->fmt.pix.height;
920 dev->field = f->fmt.pix.field;
925 static int vidioc_reqbufs(struct file *file, void *priv,
926 struct v4l2_requestbuffers *p)
928 struct vivi_dev *dev = video_drvdata(file);
929 return vb2_reqbufs(&dev->vb_vidq, p);
932 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
934 struct vivi_dev *dev = video_drvdata(file);
935 return vb2_querybuf(&dev->vb_vidq, p);
938 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
940 struct vivi_dev *dev = video_drvdata(file);
941 return vb2_qbuf(&dev->vb_vidq, p);
944 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
946 struct vivi_dev *dev = video_drvdata(file);
947 return vb2_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK);
950 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
952 struct vivi_dev *dev = video_drvdata(file);
953 return vb2_streamon(&dev->vb_vidq, i);
956 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
958 struct vivi_dev *dev = video_drvdata(file);
959 return vb2_streamoff(&dev->vb_vidq, i);
962 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
967 /* only one input in this sample driver */
968 static int vidioc_enum_input(struct file *file, void *priv,
969 struct v4l2_input *inp)
971 if (inp->index >= NUM_INPUTS)
974 inp->type = V4L2_INPUT_TYPE_CAMERA;
975 inp->std = V4L2_STD_525_60;
976 sprintf(inp->name, "Camera %u", inp->index);
980 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
982 struct vivi_dev *dev = video_drvdata(file);
988 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
990 struct vivi_dev *dev = video_drvdata(file);
999 precalculate_bars(dev);
1000 precalculate_line(dev);
1004 /* --- controls ---------------------------------------------- */
1006 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1008 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1010 if (ctrl == dev->autogain)
1011 dev->gain->val = jiffies & 0xff;
1015 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1017 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1019 if (ctrl == dev->button)
1020 dev->button_pressed = 30;
1024 /* ------------------------------------------------------------------
1025 File operations for the device
1026 ------------------------------------------------------------------*/
1029 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1031 struct vivi_dev *dev = video_drvdata(file);
1033 dprintk(dev, 1, "read called\n");
1034 return vb2_read(&dev->vb_vidq, data, count, ppos,
1035 file->f_flags & O_NONBLOCK);
1039 vivi_poll(struct file *file, struct poll_table_struct *wait)
1041 struct vivi_dev *dev = video_drvdata(file);
1042 struct v4l2_fh *fh = file->private_data;
1043 struct vb2_queue *q = &dev->vb_vidq;
1046 dprintk(dev, 1, "%s\n", __func__);
1047 res = vb2_poll(q, file, wait);
1048 if (v4l2_event_pending(fh))
1051 poll_wait(file, &fh->wait, wait);
1055 static int vivi_close(struct file *file)
1057 struct video_device *vdev = video_devdata(file);
1058 struct vivi_dev *dev = video_drvdata(file);
1060 dprintk(dev, 1, "close called (dev=%s), file %p\n",
1061 video_device_node_name(vdev), file);
1063 if (v4l2_fh_is_singular_file(file))
1064 vb2_queue_release(&dev->vb_vidq);
1065 return v4l2_fh_release(file);
1068 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1070 struct vivi_dev *dev = video_drvdata(file);
1073 dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1075 ret = vb2_mmap(&dev->vb_vidq, vma);
1076 dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1077 (unsigned long)vma->vm_start,
1078 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
1083 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1084 .g_volatile_ctrl = vivi_g_volatile_ctrl,
1085 .s_ctrl = vivi_s_ctrl,
1088 #define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1090 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1091 .ops = &vivi_ctrl_ops,
1092 .id = VIVI_CID_CUSTOM_BASE + 0,
1094 .type = V4L2_CTRL_TYPE_BUTTON,
1097 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1098 .ops = &vivi_ctrl_ops,
1099 .id = VIVI_CID_CUSTOM_BASE + 1,
1101 .type = V4L2_CTRL_TYPE_BOOLEAN,
1108 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1109 .ops = &vivi_ctrl_ops,
1110 .id = VIVI_CID_CUSTOM_BASE + 2,
1111 .name = "Integer 32 Bits",
1112 .type = V4L2_CTRL_TYPE_INTEGER,
1118 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1119 .ops = &vivi_ctrl_ops,
1120 .id = VIVI_CID_CUSTOM_BASE + 3,
1121 .name = "Integer 64 Bits",
1122 .type = V4L2_CTRL_TYPE_INTEGER64,
1125 static const char * const vivi_ctrl_menu_strings[] = {
1126 "Menu Item 0 (Skipped)",
1128 "Menu Item 2 (Skipped)",
1131 "Menu Item 5 (Skipped)",
1135 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1136 .ops = &vivi_ctrl_ops,
1137 .id = VIVI_CID_CUSTOM_BASE + 4,
1139 .type = V4L2_CTRL_TYPE_MENU,
1143 .menu_skip_mask = 0x04,
1144 .qmenu = vivi_ctrl_menu_strings,
1147 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1148 .ops = &vivi_ctrl_ops,
1149 .id = VIVI_CID_CUSTOM_BASE + 5,
1151 .type = V4L2_CTRL_TYPE_STRING,
1157 static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1158 .ops = &vivi_ctrl_ops,
1159 .id = VIVI_CID_CUSTOM_BASE + 6,
1161 .type = V4L2_CTRL_TYPE_BITMASK,
1168 static const struct v4l2_file_operations vivi_fops = {
1169 .owner = THIS_MODULE,
1170 .open = v4l2_fh_open,
1171 .release = vivi_close,
1174 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1178 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1179 .vidioc_querycap = vidioc_querycap,
1180 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1181 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1182 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1183 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1184 .vidioc_reqbufs = vidioc_reqbufs,
1185 .vidioc_querybuf = vidioc_querybuf,
1186 .vidioc_qbuf = vidioc_qbuf,
1187 .vidioc_dqbuf = vidioc_dqbuf,
1188 .vidioc_s_std = vidioc_s_std,
1189 .vidioc_enum_input = vidioc_enum_input,
1190 .vidioc_g_input = vidioc_g_input,
1191 .vidioc_s_input = vidioc_s_input,
1192 .vidioc_streamon = vidioc_streamon,
1193 .vidioc_streamoff = vidioc_streamoff,
1194 .vidioc_log_status = v4l2_ctrl_log_status,
1195 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1196 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1199 static struct video_device vivi_template = {
1202 .ioctl_ops = &vivi_ioctl_ops,
1203 .release = video_device_release,
1205 .tvnorms = V4L2_STD_525_60,
1206 .current_norm = V4L2_STD_NTSC_M,
1209 /* -----------------------------------------------------------------
1210 Initialization and module stuff
1211 ------------------------------------------------------------------*/
1213 static int vivi_release(void)
1215 struct vivi_dev *dev;
1216 struct list_head *list;
1218 while (!list_empty(&vivi_devlist)) {
1219 list = vivi_devlist.next;
1221 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1223 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1224 video_device_node_name(dev->vfd));
1225 video_unregister_device(dev->vfd);
1226 v4l2_device_unregister(&dev->v4l2_dev);
1227 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1234 static int __init vivi_create_instance(int inst)
1236 struct vivi_dev *dev;
1237 struct video_device *vfd;
1238 struct v4l2_ctrl_handler *hdl;
1239 struct vb2_queue *q;
1242 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1246 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1247 "%s-%03d", VIVI_MODULE_NAME, inst);
1248 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1252 dev->fmt = &formats[0];
1255 hdl = &dev->ctrl_handler;
1256 v4l2_ctrl_handler_init(hdl, 11);
1257 dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1258 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1259 dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1260 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1261 dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1262 V4L2_CID_CONTRAST, 0, 255, 1, 16);
1263 dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1264 V4L2_CID_SATURATION, 0, 255, 1, 127);
1265 dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1266 V4L2_CID_HUE, -128, 127, 1, 0);
1267 dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1268 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1269 dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1270 V4L2_CID_GAIN, 0, 255, 1, 100);
1271 dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1272 dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1273 dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1274 dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1275 dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1276 dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1277 dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1282 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1283 dev->v4l2_dev.ctrl_handler = hdl;
1285 /* initialize locks */
1286 spin_lock_init(&dev->slock);
1288 /* initialize queue */
1290 memset(q, 0, sizeof(dev->vb_vidq));
1291 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1292 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1294 q->buf_struct_size = sizeof(struct vivi_buffer);
1295 q->ops = &vivi_video_qops;
1296 q->mem_ops = &vb2_vmalloc_memops;
1300 mutex_init(&dev->mutex);
1302 /* init video dma queues */
1303 INIT_LIST_HEAD(&dev->vidq.active);
1304 init_waitqueue_head(&dev->vidq.wq);
1307 vfd = video_device_alloc();
1311 *vfd = vivi_template;
1313 vfd->v4l2_dev = &dev->v4l2_dev;
1314 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1317 * Provide a mutex to v4l2 core. It will be used to protect
1318 * all fops and v4l2 ioctls.
1320 vfd->lock = &dev->mutex;
1322 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1326 video_set_drvdata(vfd, dev);
1328 /* Now that everything is fine, let's add it to device list */
1329 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1335 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1336 video_device_node_name(vfd));
1340 video_device_release(vfd);
1342 v4l2_ctrl_handler_free(hdl);
1343 v4l2_device_unregister(&dev->v4l2_dev);
1349 /* This routine allocates from 1 to n_devs virtual drivers.
1351 The real maximum number of virtual drivers will depend on how many drivers
1352 will succeed. This is limited to the maximum number of devices that
1353 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1355 static int __init vivi_init(void)
1357 const struct font_desc *font = find_font("VGA8x16");
1361 printk(KERN_ERR "vivi: could not find font\n");
1364 font8x16 = font->data;
1369 for (i = 0; i < n_devs; i++) {
1370 ret = vivi_create_instance(i);
1372 /* If some instantiations succeeded, keep driver */
1380 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1384 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1385 "Capture Board ver %s successfully loaded.\n",
1388 /* n_devs will reflect the actual number of allocated devices */
1394 static void __exit vivi_exit(void)
1399 module_init(vivi_init);
1400 module_exit(vivi_exit);