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 /* Maximum allowed frame rate
41 * Vivi will allow setting timeperframe in [1/FPS_MAX - FPS_MAX/1] range.
43 * Ideally FPS_MAX should be infinity, i.e. practically UINT_MAX, but that
44 * might hit application errors when they manipulate these values.
46 * Besides, for tpf < 1ms image-generation logic should be changed, to avoid
47 * producing frames with equal content.
51 #define MAX_WIDTH 1920
52 #define MAX_HEIGHT 1200
54 #define VIVI_VERSION "0.8.1"
56 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
57 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
58 MODULE_LICENSE("Dual BSD/GPL");
59 MODULE_VERSION(VIVI_VERSION);
61 static unsigned video_nr = -1;
62 module_param(video_nr, uint, 0644);
63 MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect");
65 static unsigned n_devs = 1;
66 module_param(n_devs, uint, 0644);
67 MODULE_PARM_DESC(n_devs, "number of video devices to create");
69 static unsigned debug;
70 module_param(debug, uint, 0644);
71 MODULE_PARM_DESC(debug, "activates debug info");
73 static unsigned int vid_limit = 16;
74 module_param(vid_limit, uint, 0644);
75 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
77 /* Global font descriptor */
78 static const u8 *font8x16;
80 /* timeperframe: min/max and default */
81 static const struct v4l2_fract
82 tpf_min = {.numerator = 1, .denominator = FPS_MAX},
83 tpf_max = {.numerator = FPS_MAX, .denominator = 1},
84 tpf_default = {.numerator = 1001, .denominator = 30000}; /* NTSC */
86 #define dprintk(dev, level, fmt, arg...) \
87 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
89 /* ------------------------------------------------------------------
91 ------------------------------------------------------------------*/
95 u32 fourcc; /* v4l2 format id */
100 static const struct vivi_fmt formats[] = {
102 .name = "4:2:2, packed, YUYV",
103 .fourcc = V4L2_PIX_FMT_YUYV,
108 .name = "4:2:2, packed, UYVY",
109 .fourcc = V4L2_PIX_FMT_UYVY,
114 .name = "4:2:2, packed, YVYU",
115 .fourcc = V4L2_PIX_FMT_YVYU,
120 .name = "4:2:2, packed, VYUY",
121 .fourcc = V4L2_PIX_FMT_VYUY,
126 .name = "RGB565 (LE)",
127 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
131 .name = "RGB565 (BE)",
132 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
136 .name = "RGB555 (LE)",
137 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
141 .name = "RGB555 (BE)",
142 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
146 .name = "RGB24 (LE)",
147 .fourcc = V4L2_PIX_FMT_RGB24, /* rgb */
151 .name = "RGB24 (BE)",
152 .fourcc = V4L2_PIX_FMT_BGR24, /* bgr */
156 .name = "RGB32 (LE)",
157 .fourcc = V4L2_PIX_FMT_RGB32, /* argb */
161 .name = "RGB32 (BE)",
162 .fourcc = V4L2_PIX_FMT_BGR32, /* bgra */
167 static const struct vivi_fmt *__get_format(u32 pixelformat)
169 const struct vivi_fmt *fmt;
172 for (k = 0; k < ARRAY_SIZE(formats); k++) {
174 if (fmt->fourcc == pixelformat)
178 if (k == ARRAY_SIZE(formats))
184 static const struct vivi_fmt *get_format(struct v4l2_format *f)
186 return __get_format(f->fmt.pix.pixelformat);
189 /* buffer for one video frame */
191 /* common v4l buffer stuff -- must be first */
192 struct vb2_buffer vb;
193 struct list_head list;
194 const struct vivi_fmt *fmt;
197 struct vivi_dmaqueue {
198 struct list_head active;
200 /* thread for generating video stream*/
201 struct task_struct *kthread;
202 wait_queue_head_t wq;
203 /* Counters to control fps rate */
208 static LIST_HEAD(vivi_devlist);
211 struct list_head vivi_devlist;
212 struct v4l2_device v4l2_dev;
213 struct v4l2_ctrl_handler ctrl_handler;
214 struct video_device vdev;
217 struct v4l2_ctrl *brightness;
218 struct v4l2_ctrl *contrast;
219 struct v4l2_ctrl *saturation;
220 struct v4l2_ctrl *hue;
222 /* autogain/gain cluster */
223 struct v4l2_ctrl *autogain;
224 struct v4l2_ctrl *gain;
226 struct v4l2_ctrl *volume;
227 struct v4l2_ctrl *alpha;
228 struct v4l2_ctrl *button;
229 struct v4l2_ctrl *boolean;
230 struct v4l2_ctrl *int32;
231 struct v4l2_ctrl *int64;
232 struct v4l2_ctrl *menu;
233 struct v4l2_ctrl *string;
234 struct v4l2_ctrl *bitmask;
235 struct v4l2_ctrl *int_menu;
240 struct vivi_dmaqueue vidq;
242 /* Several counters */
244 unsigned long jiffies;
245 unsigned button_pressed;
247 int mv_count; /* Controls bars movement */
253 const struct vivi_fmt *fmt;
254 struct v4l2_fract timeperframe;
255 unsigned int width, height;
256 struct vb2_queue vb_vidq;
257 unsigned int field_count;
260 u8 line[MAX_WIDTH * 8] __attribute__((__aligned__(4)));
261 unsigned int pixelsize;
266 /* ------------------------------------------------------------------
267 DMA and thread functions
268 ------------------------------------------------------------------*/
270 /* Bars and Colors should match positions */
285 #define COLOR_WHITE {204, 204, 204}
286 #define COLOR_AMBER {208, 208, 0}
287 #define COLOR_CYAN { 0, 206, 206}
288 #define COLOR_GREEN { 0, 239, 0}
289 #define COLOR_MAGENTA {239, 0, 239}
290 #define COLOR_RED {205, 0, 0}
291 #define COLOR_BLUE { 0, 0, 255}
292 #define COLOR_BLACK { 0, 0, 0}
298 /* Maximum number of bars are 10 - otherwise, the input print code
299 should be modified */
300 static const struct bar_std bars[] = {
301 { /* Standard ITU-R color bar sequence */
302 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
303 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
305 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
306 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
308 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
309 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
311 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
312 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
316 #define NUM_INPUTS ARRAY_SIZE(bars)
318 #define TO_Y(r, g, b) \
319 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
320 /* RGB to V(Cr) Color transform */
321 #define TO_V(r, g, b) \
322 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
323 /* RGB to U(Cb) Color transform */
324 #define TO_U(r, g, b) \
325 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
327 /* precalculate color bar values to speed up rendering */
328 static void precalculate_bars(struct vivi_dev *dev)
333 for (k = 0; k < 9; k++) {
334 r = bars[dev->input].bar[k][0];
335 g = bars[dev->input].bar[k][1];
336 b = bars[dev->input].bar[k][2];
337 is_yuv = dev->fmt->is_yuv;
339 switch (dev->fmt->fourcc) {
340 case V4L2_PIX_FMT_RGB565:
341 case V4L2_PIX_FMT_RGB565X:
346 case V4L2_PIX_FMT_RGB555:
347 case V4L2_PIX_FMT_RGB555X:
352 case V4L2_PIX_FMT_YUYV:
353 case V4L2_PIX_FMT_UYVY:
354 case V4L2_PIX_FMT_YVYU:
355 case V4L2_PIX_FMT_VYUY:
356 case V4L2_PIX_FMT_RGB24:
357 case V4L2_PIX_FMT_BGR24:
358 case V4L2_PIX_FMT_RGB32:
359 case V4L2_PIX_FMT_BGR32:
364 dev->bars[k][0] = TO_Y(r, g, b); /* Luma */
365 dev->bars[k][1] = TO_U(r, g, b); /* Cb */
366 dev->bars[k][2] = TO_V(r, g, b); /* Cr */
375 /* 'odd' is true for pixels 1, 3, 5, etc. and false for pixels 0, 2, 4, etc. */
376 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos, bool odd)
379 u8 alpha = dev->alpha_component;
383 r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
384 g_u = dev->bars[colorpos][1]; /* G or precalculated U */
385 b_v = dev->bars[colorpos][2]; /* B or precalculated V */
387 for (color = 0; color < dev->pixelsize; color++) {
390 switch (dev->fmt->fourcc) {
391 case V4L2_PIX_FMT_YUYV:
397 *p = odd ? b_v : g_u;
401 case V4L2_PIX_FMT_UYVY:
404 *p = odd ? b_v : g_u;
411 case V4L2_PIX_FMT_YVYU:
417 *p = odd ? g_u : b_v;
421 case V4L2_PIX_FMT_VYUY:
424 *p = odd ? g_u : b_v;
431 case V4L2_PIX_FMT_RGB565:
434 *p = (g_u << 5) | b_v;
437 *p = (r_y << 3) | (g_u >> 3);
441 case V4L2_PIX_FMT_RGB565X:
444 *p = (r_y << 3) | (g_u >> 3);
447 *p = (g_u << 5) | b_v;
451 case V4L2_PIX_FMT_RGB555:
454 *p = (g_u << 5) | b_v;
457 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
461 case V4L2_PIX_FMT_RGB555X:
464 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
467 *p = (g_u << 5) | b_v;
471 case V4L2_PIX_FMT_RGB24:
484 case V4L2_PIX_FMT_BGR24:
497 case V4L2_PIX_FMT_RGB32:
513 case V4L2_PIX_FMT_BGR32:
533 static void precalculate_line(struct vivi_dev *dev)
535 unsigned pixsize = dev->pixelsize;
536 unsigned pixsize2 = 2*pixsize;
540 for (colorpos = 0; colorpos < 16; ++colorpos) {
542 int wstart = colorpos * dev->width / 8;
543 int wend = (colorpos+1) * dev->width / 8;
546 gen_twopix(dev, &pix[0], colorpos % 8, 0);
547 gen_twopix(dev, &pix[pixsize], colorpos % 8, 1);
549 for (w = wstart/2*2, pos = dev->line + w*pixsize; w < wend; w += 2, pos += pixsize2)
550 memcpy(pos, pix, pixsize2);
554 /* need this to do rgb24 rendering */
555 typedef struct { u16 __; u8 _; } __attribute__((packed)) x24;
557 static void gen_text(struct vivi_dev *dev, char *basep,
558 int y, int x, char *text)
561 unsigned int width = dev->width;
563 /* Checks if it is possible to show string */
564 if (y + 16 >= dev->height || x + strlen(text) * 8 >= width)
567 /* Print stream time */
568 #define PRINTSTR(PIXTYPE) do { \
571 memcpy(&fg, &dev->textfg, sizeof(PIXTYPE)); \
572 memcpy(&bg, &dev->textbg, sizeof(PIXTYPE)); \
574 for (line = 0; line < 16; line++) { \
575 PIXTYPE *pos = (PIXTYPE *)( basep + ((y + line) * width + x) * sizeof(PIXTYPE) ); \
578 for (s = text; *s; s++) { \
579 u8 chr = font8x16[*s * 16 + line]; \
581 pos[0] = (chr & (0x01 << 7) ? fg : bg); \
582 pos[1] = (chr & (0x01 << 6) ? fg : bg); \
583 pos[2] = (chr & (0x01 << 5) ? fg : bg); \
584 pos[3] = (chr & (0x01 << 4) ? fg : bg); \
585 pos[4] = (chr & (0x01 << 3) ? fg : bg); \
586 pos[5] = (chr & (0x01 << 2) ? fg : bg); \
587 pos[6] = (chr & (0x01 << 1) ? fg : bg); \
588 pos[7] = (chr & (0x01 << 0) ? fg : bg); \
595 switch (dev->pixelsize) {
597 PRINTSTR(u16); break;
599 PRINTSTR(u32); break;
601 PRINTSTR(x24); break;
605 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
607 int stride = dev->width * dev->pixelsize;
608 int hmax = dev->height;
609 void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
619 linestart = dev->line + (dev->mv_count % dev->width) * dev->pixelsize;
621 for (h = 0; h < hmax; h++)
622 memcpy(vbuf + h * stride, linestart, stride);
624 /* Updates stream time */
626 gen_twopix(dev, (u8 *)&dev->textbg, TEXT_BLACK, /*odd=*/ 0);
627 gen_twopix(dev, (u8 *)&dev->textfg, WHITE, /*odd=*/ 0);
629 dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
630 dev->jiffies = jiffies;
632 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
633 (ms / (60 * 60 * 1000)) % 24,
634 (ms / (60 * 1000)) % 60,
637 gen_text(dev, vbuf, line++ * 16, 16, str);
638 snprintf(str, sizeof(str), " %dx%d, input %d ",
639 dev->width, dev->height, dev->input);
640 gen_text(dev, vbuf, line++ * 16, 16, str);
642 gain = v4l2_ctrl_g_ctrl(dev->gain);
643 mutex_lock(dev->ctrl_handler.lock);
644 snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
645 dev->brightness->cur.val,
646 dev->contrast->cur.val,
647 dev->saturation->cur.val,
649 gen_text(dev, vbuf, line++ * 16, 16, str);
650 snprintf(str, sizeof(str), " autogain %d, gain %3d, volume %3d, alpha 0x%02x ",
651 dev->autogain->cur.val, gain, dev->volume->cur.val,
652 dev->alpha->cur.val);
653 gen_text(dev, vbuf, line++ * 16, 16, str);
654 snprintf(str, sizeof(str), " int32 %d, int64 %lld, bitmask %08x ",
656 dev->int64->cur.val64,
657 dev->bitmask->cur.val);
658 gen_text(dev, vbuf, line++ * 16, 16, str);
659 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
660 dev->boolean->cur.val,
661 dev->menu->qmenu[dev->menu->cur.val],
662 dev->string->cur.string);
663 gen_text(dev, vbuf, line++ * 16, 16, str);
664 snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
665 dev->int_menu->qmenu_int[dev->int_menu->cur.val],
666 dev->int_menu->cur.val);
667 gen_text(dev, vbuf, line++ * 16, 16, str);
668 mutex_unlock(dev->ctrl_handler.lock);
669 if (dev->button_pressed) {
670 dev->button_pressed--;
671 snprintf(str, sizeof(str), " button pressed!");
672 gen_text(dev, vbuf, line++ * 16, 16, str);
677 buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
679 buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
680 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
683 static void vivi_thread_tick(struct vivi_dev *dev)
685 struct vivi_dmaqueue *dma_q = &dev->vidq;
686 struct vivi_buffer *buf;
687 unsigned long flags = 0;
689 dprintk(dev, 1, "Thread tick\n");
691 spin_lock_irqsave(&dev->slock, flags);
692 if (list_empty(&dma_q->active)) {
693 dprintk(dev, 1, "No active queue to serve\n");
694 spin_unlock_irqrestore(&dev->slock, flags);
698 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
699 list_del(&buf->list);
700 spin_unlock_irqrestore(&dev->slock, flags);
702 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
705 vivi_fillbuff(dev, buf);
706 dprintk(dev, 1, "filled buffer %p\n", buf);
708 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
709 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
712 #define frames_to_ms(dev, frames) \
713 ((frames * dev->timeperframe.numerator * 1000) / dev->timeperframe.denominator)
715 static void vivi_sleep(struct vivi_dev *dev)
717 struct vivi_dmaqueue *dma_q = &dev->vidq;
719 DECLARE_WAITQUEUE(wait, current);
721 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
722 (unsigned long)dma_q);
724 add_wait_queue(&dma_q->wq, &wait);
725 if (kthread_should_stop())
728 /* Calculate time to wake up */
729 timeout = msecs_to_jiffies(frames_to_ms(dev, 1));
731 vivi_thread_tick(dev);
733 schedule_timeout_interruptible(timeout);
736 remove_wait_queue(&dma_q->wq, &wait);
740 static int vivi_thread(void *data)
742 struct vivi_dev *dev = data;
744 dprintk(dev, 1, "thread started\n");
751 if (kthread_should_stop())
754 dprintk(dev, 1, "thread: exit\n");
758 static int vivi_start_generating(struct vivi_dev *dev)
760 struct vivi_dmaqueue *dma_q = &dev->vidq;
762 dprintk(dev, 1, "%s\n", __func__);
764 /* Resets frame counters */
767 dev->jiffies = jiffies;
770 dma_q->ini_jiffies = jiffies;
771 dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
773 if (IS_ERR(dma_q->kthread)) {
774 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
775 return PTR_ERR(dma_q->kthread);
778 wake_up_interruptible(&dma_q->wq);
780 dprintk(dev, 1, "returning from %s\n", __func__);
784 static void vivi_stop_generating(struct vivi_dev *dev)
786 struct vivi_dmaqueue *dma_q = &dev->vidq;
788 dprintk(dev, 1, "%s\n", __func__);
790 /* shutdown control thread */
791 if (dma_q->kthread) {
792 kthread_stop(dma_q->kthread);
793 dma_q->kthread = NULL;
797 * Typical driver might need to wait here until dma engine stops.
798 * In this case we can abort imiedetly, so it's just a noop.
801 /* Release all active buffers */
802 while (!list_empty(&dma_q->active)) {
803 struct vivi_buffer *buf;
804 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
805 list_del(&buf->list);
806 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
807 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
810 /* ------------------------------------------------------------------
812 ------------------------------------------------------------------*/
813 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
814 unsigned int *nbuffers, unsigned int *nplanes,
815 unsigned int sizes[], void *alloc_ctxs[])
817 struct vivi_dev *dev = vb2_get_drv_priv(vq);
821 size = fmt->fmt.pix.sizeimage;
823 size = dev->width * dev->height * dev->pixelsize;
831 while (size * *nbuffers > vid_limit * 1024 * 1024)
839 * videobuf2-vmalloc allocator is context-less so no need to set
843 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
849 static int buffer_prepare(struct vb2_buffer *vb)
851 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
852 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
855 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
857 BUG_ON(NULL == dev->fmt);
860 * Theses properties only change when queue is idle, see s_fmt.
861 * The below checks should not be performed here, on each
862 * buffer_prepare (i.e. on each qbuf). Most of the code in this function
863 * should thus be moved to buffer_init and s_fmt.
865 if (dev->width < 48 || dev->width > MAX_WIDTH ||
866 dev->height < 32 || dev->height > MAX_HEIGHT)
869 size = dev->width * dev->height * dev->pixelsize;
870 if (vb2_plane_size(vb, 0) < size) {
871 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
872 __func__, vb2_plane_size(vb, 0), size);
876 vb2_set_plane_payload(&buf->vb, 0, size);
880 precalculate_bars(dev);
881 precalculate_line(dev);
886 static void buffer_queue(struct vb2_buffer *vb)
888 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
889 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
890 struct vivi_dmaqueue *vidq = &dev->vidq;
891 unsigned long flags = 0;
893 dprintk(dev, 1, "%s\n", __func__);
895 spin_lock_irqsave(&dev->slock, flags);
896 list_add_tail(&buf->list, &vidq->active);
897 spin_unlock_irqrestore(&dev->slock, flags);
900 static int start_streaming(struct vb2_queue *vq, unsigned int count)
902 struct vivi_dev *dev = vb2_get_drv_priv(vq);
903 dprintk(dev, 1, "%s\n", __func__);
904 return vivi_start_generating(dev);
907 /* abort streaming and wait for last buffer */
908 static int stop_streaming(struct vb2_queue *vq)
910 struct vivi_dev *dev = vb2_get_drv_priv(vq);
911 dprintk(dev, 1, "%s\n", __func__);
912 vivi_stop_generating(dev);
916 static void vivi_lock(struct vb2_queue *vq)
918 struct vivi_dev *dev = vb2_get_drv_priv(vq);
919 mutex_lock(&dev->mutex);
922 static void vivi_unlock(struct vb2_queue *vq)
924 struct vivi_dev *dev = vb2_get_drv_priv(vq);
925 mutex_unlock(&dev->mutex);
929 static const struct vb2_ops vivi_video_qops = {
930 .queue_setup = queue_setup,
931 .buf_prepare = buffer_prepare,
932 .buf_queue = buffer_queue,
933 .start_streaming = start_streaming,
934 .stop_streaming = stop_streaming,
935 .wait_prepare = vivi_unlock,
936 .wait_finish = vivi_lock,
939 /* ------------------------------------------------------------------
940 IOCTL vidioc handling
941 ------------------------------------------------------------------*/
942 static int vidioc_querycap(struct file *file, void *priv,
943 struct v4l2_capability *cap)
945 struct vivi_dev *dev = video_drvdata(file);
947 strcpy(cap->driver, "vivi");
948 strcpy(cap->card, "vivi");
949 snprintf(cap->bus_info, sizeof(cap->bus_info),
950 "platform:%s", dev->v4l2_dev.name);
951 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
953 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
957 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
958 struct v4l2_fmtdesc *f)
960 const struct vivi_fmt *fmt;
962 if (f->index >= ARRAY_SIZE(formats))
965 fmt = &formats[f->index];
967 strlcpy(f->description, fmt->name, sizeof(f->description));
968 f->pixelformat = fmt->fourcc;
972 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
973 struct v4l2_format *f)
975 struct vivi_dev *dev = video_drvdata(file);
977 f->fmt.pix.width = dev->width;
978 f->fmt.pix.height = dev->height;
979 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
980 f->fmt.pix.pixelformat = dev->fmt->fourcc;
981 f->fmt.pix.bytesperline =
982 (f->fmt.pix.width * dev->fmt->depth) >> 3;
983 f->fmt.pix.sizeimage =
984 f->fmt.pix.height * f->fmt.pix.bytesperline;
985 if (dev->fmt->is_yuv)
986 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
988 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
992 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
993 struct v4l2_format *f)
995 struct vivi_dev *dev = video_drvdata(file);
996 const struct vivi_fmt *fmt;
1000 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
1001 f->fmt.pix.pixelformat);
1002 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1003 fmt = get_format(f);
1006 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1007 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
1008 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
1009 f->fmt.pix.bytesperline =
1010 (f->fmt.pix.width * fmt->depth) >> 3;
1011 f->fmt.pix.sizeimage =
1012 f->fmt.pix.height * f->fmt.pix.bytesperline;
1014 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1016 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
1017 f->fmt.pix.priv = 0;
1021 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1022 struct v4l2_format *f)
1024 struct vivi_dev *dev = video_drvdata(file);
1025 struct vb2_queue *q = &dev->vb_vidq;
1027 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
1031 if (vb2_is_busy(q)) {
1032 dprintk(dev, 1, "%s device busy\n", __func__);
1036 dev->fmt = get_format(f);
1037 dev->pixelsize = dev->fmt->depth / 8;
1038 dev->width = f->fmt.pix.width;
1039 dev->height = f->fmt.pix.height;
1044 static int vidioc_enum_framesizes(struct file *file, void *fh,
1045 struct v4l2_frmsizeenum *fsize)
1047 static const struct v4l2_frmsize_stepwise sizes = {
1055 for (i = 0; i < ARRAY_SIZE(formats); i++)
1056 if (formats[i].fourcc == fsize->pixel_format)
1058 if (i == ARRAY_SIZE(formats))
1060 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1061 fsize->stepwise = sizes;
1065 /* only one input in this sample driver */
1066 static int vidioc_enum_input(struct file *file, void *priv,
1067 struct v4l2_input *inp)
1069 if (inp->index >= NUM_INPUTS)
1072 inp->type = V4L2_INPUT_TYPE_CAMERA;
1073 sprintf(inp->name, "Camera %u", inp->index);
1077 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1079 struct vivi_dev *dev = video_drvdata(file);
1085 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1087 struct vivi_dev *dev = video_drvdata(file);
1089 if (i >= NUM_INPUTS)
1092 if (i == dev->input)
1096 precalculate_bars(dev);
1097 precalculate_line(dev);
1101 /* timeperframe is arbitrary and continous */
1102 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1103 struct v4l2_frmivalenum *fival)
1105 const struct vivi_fmt *fmt;
1110 fmt = __get_format(fival->pixel_format);
1114 /* regarding width & height - we support any */
1116 fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
1118 /* fill in stepwise (step=1.0 is requred by V4L2 spec) */
1119 fival->stepwise.min = tpf_min;
1120 fival->stepwise.max = tpf_max;
1121 fival->stepwise.step = (struct v4l2_fract) {1, 1};
1126 static int vidioc_g_parm(struct file *file, void *priv,
1127 struct v4l2_streamparm *parm)
1129 struct vivi_dev *dev = video_drvdata(file);
1131 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1134 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1135 parm->parm.capture.timeperframe = dev->timeperframe;
1136 parm->parm.capture.readbuffers = 1;
1140 #define FRACT_CMP(a, OP, b) \
1141 ((u64)(a).numerator * (b).denominator OP (u64)(b).numerator * (a).denominator)
1143 static int vidioc_s_parm(struct file *file, void *priv,
1144 struct v4l2_streamparm *parm)
1146 struct vivi_dev *dev = video_drvdata(file);
1147 struct v4l2_fract tpf;
1149 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1152 tpf = parm->parm.capture.timeperframe;
1154 /* tpf: {*, 0} resets timing; clip to [min, max]*/
1155 tpf = tpf.denominator ? tpf : tpf_default;
1156 tpf = FRACT_CMP(tpf, <, tpf_min) ? tpf_min : tpf;
1157 tpf = FRACT_CMP(tpf, >, tpf_max) ? tpf_max : tpf;
1159 dev->timeperframe = tpf;
1160 parm->parm.capture.timeperframe = tpf;
1161 parm->parm.capture.readbuffers = 1;
1165 /* --- controls ---------------------------------------------- */
1167 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1169 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1171 if (ctrl == dev->autogain)
1172 dev->gain->val = jiffies & 0xff;
1176 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1178 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1181 case V4L2_CID_ALPHA_COMPONENT:
1182 dev->alpha_component = ctrl->val;
1185 if (ctrl == dev->button)
1186 dev->button_pressed = 30;
1192 /* ------------------------------------------------------------------
1193 File operations for the device
1194 ------------------------------------------------------------------*/
1196 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1197 .g_volatile_ctrl = vivi_g_volatile_ctrl,
1198 .s_ctrl = vivi_s_ctrl,
1201 #define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1203 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1204 .ops = &vivi_ctrl_ops,
1205 .id = VIVI_CID_CUSTOM_BASE + 0,
1207 .type = V4L2_CTRL_TYPE_BUTTON,
1210 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1211 .ops = &vivi_ctrl_ops,
1212 .id = VIVI_CID_CUSTOM_BASE + 1,
1214 .type = V4L2_CTRL_TYPE_BOOLEAN,
1221 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1222 .ops = &vivi_ctrl_ops,
1223 .id = VIVI_CID_CUSTOM_BASE + 2,
1224 .name = "Integer 32 Bits",
1225 .type = V4L2_CTRL_TYPE_INTEGER,
1231 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1232 .ops = &vivi_ctrl_ops,
1233 .id = VIVI_CID_CUSTOM_BASE + 3,
1234 .name = "Integer 64 Bits",
1235 .type = V4L2_CTRL_TYPE_INTEGER64,
1238 static const char * const vivi_ctrl_menu_strings[] = {
1239 "Menu Item 0 (Skipped)",
1241 "Menu Item 2 (Skipped)",
1244 "Menu Item 5 (Skipped)",
1248 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1249 .ops = &vivi_ctrl_ops,
1250 .id = VIVI_CID_CUSTOM_BASE + 4,
1252 .type = V4L2_CTRL_TYPE_MENU,
1256 .menu_skip_mask = 0x04,
1257 .qmenu = vivi_ctrl_menu_strings,
1260 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1261 .ops = &vivi_ctrl_ops,
1262 .id = VIVI_CID_CUSTOM_BASE + 5,
1264 .type = V4L2_CTRL_TYPE_STRING,
1270 static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1271 .ops = &vivi_ctrl_ops,
1272 .id = VIVI_CID_CUSTOM_BASE + 6,
1274 .type = V4L2_CTRL_TYPE_BITMASK,
1281 static const s64 vivi_ctrl_int_menu_values[] = {
1282 1, 1, 2, 3, 5, 8, 13, 21, 42,
1285 static const struct v4l2_ctrl_config vivi_ctrl_int_menu = {
1286 .ops = &vivi_ctrl_ops,
1287 .id = VIVI_CID_CUSTOM_BASE + 7,
1288 .name = "Integer menu",
1289 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
1293 .menu_skip_mask = 0x02,
1294 .qmenu_int = vivi_ctrl_int_menu_values,
1297 static const struct v4l2_file_operations vivi_fops = {
1298 .owner = THIS_MODULE,
1299 .open = v4l2_fh_open,
1300 .release = vb2_fop_release,
1301 .read = vb2_fop_read,
1302 .poll = vb2_fop_poll,
1303 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1304 .mmap = vb2_fop_mmap,
1307 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1308 .vidioc_querycap = vidioc_querycap,
1309 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1310 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1311 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1312 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1313 .vidioc_enum_framesizes = vidioc_enum_framesizes,
1314 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1315 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1316 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1317 .vidioc_querybuf = vb2_ioctl_querybuf,
1318 .vidioc_qbuf = vb2_ioctl_qbuf,
1319 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1320 .vidioc_enum_input = vidioc_enum_input,
1321 .vidioc_g_input = vidioc_g_input,
1322 .vidioc_s_input = vidioc_s_input,
1323 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1324 .vidioc_g_parm = vidioc_g_parm,
1325 .vidioc_s_parm = vidioc_s_parm,
1326 .vidioc_streamon = vb2_ioctl_streamon,
1327 .vidioc_streamoff = vb2_ioctl_streamoff,
1328 .vidioc_log_status = v4l2_ctrl_log_status,
1329 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1330 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1333 static const struct video_device vivi_template = {
1336 .ioctl_ops = &vivi_ioctl_ops,
1337 .release = video_device_release_empty,
1340 /* -----------------------------------------------------------------
1341 Initialization and module stuff
1342 ------------------------------------------------------------------*/
1344 static int vivi_release(void)
1346 struct vivi_dev *dev;
1347 struct list_head *list;
1349 while (!list_empty(&vivi_devlist)) {
1350 list = vivi_devlist.next;
1352 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1354 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1355 video_device_node_name(&dev->vdev));
1356 video_unregister_device(&dev->vdev);
1357 v4l2_device_unregister(&dev->v4l2_dev);
1358 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1365 static int __init vivi_create_instance(int inst)
1367 struct vivi_dev *dev;
1368 struct video_device *vfd;
1369 struct v4l2_ctrl_handler *hdl;
1370 struct vb2_queue *q;
1373 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1377 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1378 "%s-%03d", VIVI_MODULE_NAME, inst);
1379 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1383 dev->fmt = &formats[0];
1384 dev->timeperframe = tpf_default;
1387 dev->pixelsize = dev->fmt->depth / 8;
1388 hdl = &dev->ctrl_handler;
1389 v4l2_ctrl_handler_init(hdl, 11);
1390 dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1391 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1392 dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1393 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1394 dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1395 V4L2_CID_CONTRAST, 0, 255, 1, 16);
1396 dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1397 V4L2_CID_SATURATION, 0, 255, 1, 127);
1398 dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1399 V4L2_CID_HUE, -128, 127, 1, 0);
1400 dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1401 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1402 dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1403 V4L2_CID_GAIN, 0, 255, 1, 100);
1404 dev->alpha = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1405 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1406 dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1407 dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1408 dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1409 dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1410 dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1411 dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1412 dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1413 dev->int_menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int_menu, NULL);
1418 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1419 dev->v4l2_dev.ctrl_handler = hdl;
1421 /* initialize locks */
1422 spin_lock_init(&dev->slock);
1424 /* initialize queue */
1426 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1427 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1429 q->buf_struct_size = sizeof(struct vivi_buffer);
1430 q->ops = &vivi_video_qops;
1431 q->mem_ops = &vb2_vmalloc_memops;
1433 ret = vb2_queue_init(q);
1437 mutex_init(&dev->mutex);
1439 /* init video dma queues */
1440 INIT_LIST_HEAD(&dev->vidq.active);
1441 init_waitqueue_head(&dev->vidq.wq);
1444 *vfd = vivi_template;
1446 vfd->v4l2_dev = &dev->v4l2_dev;
1448 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1451 * Provide a mutex to v4l2 core. It will be used to protect
1452 * all fops and v4l2 ioctls.
1454 vfd->lock = &dev->mutex;
1455 video_set_drvdata(vfd, dev);
1457 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1461 /* Now that everything is fine, let's add it to device list */
1462 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1464 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1465 video_device_node_name(vfd));
1469 v4l2_ctrl_handler_free(hdl);
1470 v4l2_device_unregister(&dev->v4l2_dev);
1476 /* This routine allocates from 1 to n_devs virtual drivers.
1478 The real maximum number of virtual drivers will depend on how many drivers
1479 will succeed. This is limited to the maximum number of devices that
1480 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1482 static int __init vivi_init(void)
1484 const struct font_desc *font = find_font("VGA8x16");
1488 printk(KERN_ERR "vivi: could not find font\n");
1491 font8x16 = font->data;
1496 for (i = 0; i < n_devs; i++) {
1497 ret = vivi_create_instance(i);
1499 /* If some instantiations succeeded, keep driver */
1507 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1511 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1512 "Capture Board ver %s successfully loaded.\n",
1515 /* n_devs will reflect the actual number of allocated devices */
1521 static void __exit vivi_exit(void)
1526 module_init(vivi_init);
1527 module_exit(vivi_exit);