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 = "4:2:2, packed, YVYU",
99 .fourcc = V4L2_PIX_FMT_YVYU,
103 .name = "4:2:2, packed, VYUY",
104 .fourcc = V4L2_PIX_FMT_VYUY,
108 .name = "RGB565 (LE)",
109 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
113 .name = "RGB565 (BE)",
114 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
118 .name = "RGB555 (LE)",
119 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
123 .name = "RGB555 (BE)",
124 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
128 .name = "RGB24 (LE)",
129 .fourcc = V4L2_PIX_FMT_RGB24, /* rgb */
133 .name = "RGB24 (BE)",
134 .fourcc = V4L2_PIX_FMT_BGR24, /* bgr */
138 .name = "RGB32 (LE)",
139 .fourcc = V4L2_PIX_FMT_RGB32, /* argb */
143 .name = "RGB32 (BE)",
144 .fourcc = V4L2_PIX_FMT_BGR32, /* bgra */
149 static struct vivi_fmt *get_format(struct v4l2_format *f)
151 struct vivi_fmt *fmt;
154 for (k = 0; k < ARRAY_SIZE(formats); k++) {
156 if (fmt->fourcc == f->fmt.pix.pixelformat)
160 if (k == ARRAY_SIZE(formats))
166 /* buffer for one video frame */
168 /* common v4l buffer stuff -- must be first */
169 struct vb2_buffer vb;
170 struct list_head list;
171 struct vivi_fmt *fmt;
174 struct vivi_dmaqueue {
175 struct list_head active;
177 /* thread for generating video stream*/
178 struct task_struct *kthread;
179 wait_queue_head_t wq;
180 /* Counters to control fps rate */
185 static LIST_HEAD(vivi_devlist);
188 struct list_head vivi_devlist;
189 struct v4l2_device v4l2_dev;
190 struct v4l2_ctrl_handler ctrl_handler;
191 struct video_device vdev;
194 struct v4l2_ctrl *brightness;
195 struct v4l2_ctrl *contrast;
196 struct v4l2_ctrl *saturation;
197 struct v4l2_ctrl *hue;
199 /* autogain/gain cluster */
200 struct v4l2_ctrl *autogain;
201 struct v4l2_ctrl *gain;
203 struct v4l2_ctrl *volume;
204 struct v4l2_ctrl *alpha;
205 struct v4l2_ctrl *button;
206 struct v4l2_ctrl *boolean;
207 struct v4l2_ctrl *int32;
208 struct v4l2_ctrl *int64;
209 struct v4l2_ctrl *menu;
210 struct v4l2_ctrl *string;
211 struct v4l2_ctrl *bitmask;
212 struct v4l2_ctrl *int_menu;
217 struct vivi_dmaqueue vidq;
219 /* Several counters */
221 unsigned long jiffies;
222 unsigned button_pressed;
224 int mv_count; /* Controls bars movement */
230 struct vivi_fmt *fmt;
231 unsigned int width, height;
232 struct vb2_queue vb_vidq;
233 unsigned int field_count;
236 u8 line[MAX_WIDTH * 8];
237 unsigned int pixelsize;
241 /* ------------------------------------------------------------------
242 DMA and thread functions
243 ------------------------------------------------------------------*/
245 /* Bars and Colors should match positions */
260 #define COLOR_WHITE {204, 204, 204}
261 #define COLOR_AMBER {208, 208, 0}
262 #define COLOR_CYAN { 0, 206, 206}
263 #define COLOR_GREEN { 0, 239, 0}
264 #define COLOR_MAGENTA {239, 0, 239}
265 #define COLOR_RED {205, 0, 0}
266 #define COLOR_BLUE { 0, 0, 255}
267 #define COLOR_BLACK { 0, 0, 0}
273 /* Maximum number of bars are 10 - otherwise, the input print code
274 should be modified */
275 static struct bar_std bars[] = {
276 { /* Standard ITU-R color bar sequence */
277 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
278 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
280 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
281 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
283 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
284 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
286 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
287 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
291 #define NUM_INPUTS ARRAY_SIZE(bars)
293 #define TO_Y(r, g, b) \
294 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
295 /* RGB to V(Cr) Color transform */
296 #define TO_V(r, g, b) \
297 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
298 /* RGB to U(Cb) Color transform */
299 #define TO_U(r, g, b) \
300 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
302 /* precalculate color bar values to speed up rendering */
303 static void precalculate_bars(struct vivi_dev *dev)
308 for (k = 0; k < 9; k++) {
309 r = bars[dev->input].bar[k][0];
310 g = bars[dev->input].bar[k][1];
311 b = bars[dev->input].bar[k][2];
314 switch (dev->fmt->fourcc) {
315 case V4L2_PIX_FMT_YUYV:
316 case V4L2_PIX_FMT_UYVY:
317 case V4L2_PIX_FMT_YVYU:
318 case V4L2_PIX_FMT_VYUY:
321 case V4L2_PIX_FMT_RGB565:
322 case V4L2_PIX_FMT_RGB565X:
327 case V4L2_PIX_FMT_RGB555:
328 case V4L2_PIX_FMT_RGB555X:
333 case V4L2_PIX_FMT_RGB24:
334 case V4L2_PIX_FMT_BGR24:
335 case V4L2_PIX_FMT_RGB32:
336 case V4L2_PIX_FMT_BGR32:
341 dev->bars[k][0] = TO_Y(r, g, b); /* Luma */
342 dev->bars[k][1] = TO_U(r, g, b); /* Cb */
343 dev->bars[k][2] = TO_V(r, g, b); /* Cr */
352 #define TSTAMP_MIN_Y 24
353 #define TSTAMP_MAX_Y (TSTAMP_MIN_Y + 15)
354 #define TSTAMP_INPUT_X 10
355 #define TSTAMP_MIN_X (54 + TSTAMP_INPUT_X)
357 /* 'odd' is true for pixels 1, 3, 5, etc. and false for pixels 0, 2, 4, etc. */
358 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos, bool odd)
361 u8 alpha = dev->alpha_component;
365 r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
366 g_u = dev->bars[colorpos][1]; /* G or precalculated U */
367 b_v = dev->bars[colorpos][2]; /* B or precalculated V */
369 for (color = 0; color < dev->pixelsize; color++) {
372 switch (dev->fmt->fourcc) {
373 case V4L2_PIX_FMT_YUYV:
379 *p = odd ? b_v : g_u;
383 case V4L2_PIX_FMT_UYVY:
386 *p = odd ? b_v : g_u;
393 case V4L2_PIX_FMT_YVYU:
399 *p = odd ? g_u : b_v;
403 case V4L2_PIX_FMT_VYUY:
406 *p = odd ? g_u : b_v;
413 case V4L2_PIX_FMT_RGB565:
416 *p = (g_u << 5) | b_v;
419 *p = (r_y << 3) | (g_u >> 3);
423 case V4L2_PIX_FMT_RGB565X:
426 *p = (r_y << 3) | (g_u >> 3);
429 *p = (g_u << 5) | b_v;
433 case V4L2_PIX_FMT_RGB555:
436 *p = (g_u << 5) | b_v;
439 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
443 case V4L2_PIX_FMT_RGB555X:
446 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
449 *p = (g_u << 5) | b_v;
453 case V4L2_PIX_FMT_RGB24:
466 case V4L2_PIX_FMT_BGR24:
479 case V4L2_PIX_FMT_RGB32:
495 case V4L2_PIX_FMT_BGR32:
515 static void precalculate_line(struct vivi_dev *dev)
519 for (w = 0; w < dev->width * 2; w++) {
520 int colorpos = w / (dev->width / 8) % 8;
522 gen_twopix(dev, dev->line + w * dev->pixelsize, colorpos, w & 1);
526 static void gen_text(struct vivi_dev *dev, char *basep,
527 int y, int x, char *text)
531 /* Checks if it is possible to show string */
532 if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
535 /* Print stream time */
536 for (line = y; line < y + 16; line++) {
538 char *pos = basep + line * dev->width * dev->pixelsize + x * dev->pixelsize;
541 for (s = text; *s; s++) {
542 u8 chr = font8x16[*s * 16 + line - y];
545 for (i = 0; i < 7; i++, j++) {
546 /* Draw white font on black background */
547 if (chr & (1 << (7 - i)))
548 gen_twopix(dev, pos + j * dev->pixelsize, WHITE, (x+y) & 1);
550 gen_twopix(dev, pos + j * dev->pixelsize, TEXT_BLACK, (x+y) & 1);
556 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
558 int wmax = dev->width;
559 int hmax = dev->height;
561 void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
570 for (h = 0; h < hmax; h++)
571 memcpy(vbuf + h * wmax * dev->pixelsize,
572 dev->line + (dev->mv_count % wmax) * dev->pixelsize,
573 wmax * dev->pixelsize);
575 /* Updates stream time */
577 dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
578 dev->jiffies = jiffies;
580 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
581 (ms / (60 * 60 * 1000)) % 24,
582 (ms / (60 * 1000)) % 60,
585 gen_text(dev, vbuf, line++ * 16, 16, str);
586 snprintf(str, sizeof(str), " %dx%d, input %d ",
587 dev->width, dev->height, dev->input);
588 gen_text(dev, vbuf, line++ * 16, 16, str);
590 gain = v4l2_ctrl_g_ctrl(dev->gain);
591 mutex_lock(dev->ctrl_handler.lock);
592 snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
593 dev->brightness->cur.val,
594 dev->contrast->cur.val,
595 dev->saturation->cur.val,
597 gen_text(dev, vbuf, line++ * 16, 16, str);
598 snprintf(str, sizeof(str), " autogain %d, gain %3d, volume %3d, alpha 0x%02x ",
599 dev->autogain->cur.val, gain, dev->volume->cur.val,
600 dev->alpha->cur.val);
601 gen_text(dev, vbuf, line++ * 16, 16, str);
602 snprintf(str, sizeof(str), " int32 %d, int64 %lld, bitmask %08x ",
604 dev->int64->cur.val64,
605 dev->bitmask->cur.val);
606 gen_text(dev, vbuf, line++ * 16, 16, str);
607 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
608 dev->boolean->cur.val,
609 dev->menu->qmenu[dev->menu->cur.val],
610 dev->string->cur.string);
611 gen_text(dev, vbuf, line++ * 16, 16, str);
612 snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
613 dev->int_menu->qmenu_int[dev->int_menu->cur.val],
614 dev->int_menu->cur.val);
615 gen_text(dev, vbuf, line++ * 16, 16, str);
616 mutex_unlock(dev->ctrl_handler.lock);
617 if (dev->button_pressed) {
618 dev->button_pressed--;
619 snprintf(str, sizeof(str), " button pressed!");
620 gen_text(dev, vbuf, line++ * 16, 16, str);
625 buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
627 buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
628 do_gettimeofday(&ts);
629 buf->vb.v4l2_buf.timestamp = ts;
632 static void vivi_thread_tick(struct vivi_dev *dev)
634 struct vivi_dmaqueue *dma_q = &dev->vidq;
635 struct vivi_buffer *buf;
636 unsigned long flags = 0;
638 dprintk(dev, 1, "Thread tick\n");
640 spin_lock_irqsave(&dev->slock, flags);
641 if (list_empty(&dma_q->active)) {
642 dprintk(dev, 1, "No active queue to serve\n");
643 spin_unlock_irqrestore(&dev->slock, flags);
647 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
648 list_del(&buf->list);
649 spin_unlock_irqrestore(&dev->slock, flags);
651 do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
654 vivi_fillbuff(dev, buf);
655 dprintk(dev, 1, "filled buffer %p\n", buf);
657 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
658 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
661 #define frames_to_ms(frames) \
662 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
664 static void vivi_sleep(struct vivi_dev *dev)
666 struct vivi_dmaqueue *dma_q = &dev->vidq;
668 DECLARE_WAITQUEUE(wait, current);
670 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
671 (unsigned long)dma_q);
673 add_wait_queue(&dma_q->wq, &wait);
674 if (kthread_should_stop())
677 /* Calculate time to wake up */
678 timeout = msecs_to_jiffies(frames_to_ms(1));
680 vivi_thread_tick(dev);
682 schedule_timeout_interruptible(timeout);
685 remove_wait_queue(&dma_q->wq, &wait);
689 static int vivi_thread(void *data)
691 struct vivi_dev *dev = data;
693 dprintk(dev, 1, "thread started\n");
700 if (kthread_should_stop())
703 dprintk(dev, 1, "thread: exit\n");
707 static int vivi_start_generating(struct vivi_dev *dev)
709 struct vivi_dmaqueue *dma_q = &dev->vidq;
711 dprintk(dev, 1, "%s\n", __func__);
713 /* Resets frame counters */
716 dev->jiffies = jiffies;
719 dma_q->ini_jiffies = jiffies;
720 dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
722 if (IS_ERR(dma_q->kthread)) {
723 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
724 return PTR_ERR(dma_q->kthread);
727 wake_up_interruptible(&dma_q->wq);
729 dprintk(dev, 1, "returning from %s\n", __func__);
733 static void vivi_stop_generating(struct vivi_dev *dev)
735 struct vivi_dmaqueue *dma_q = &dev->vidq;
737 dprintk(dev, 1, "%s\n", __func__);
739 /* shutdown control thread */
740 if (dma_q->kthread) {
741 kthread_stop(dma_q->kthread);
742 dma_q->kthread = NULL;
746 * Typical driver might need to wait here until dma engine stops.
747 * In this case we can abort imiedetly, so it's just a noop.
750 /* Release all active buffers */
751 while (!list_empty(&dma_q->active)) {
752 struct vivi_buffer *buf;
753 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
754 list_del(&buf->list);
755 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
756 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
759 /* ------------------------------------------------------------------
761 ------------------------------------------------------------------*/
762 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
763 unsigned int *nbuffers, unsigned int *nplanes,
764 unsigned int sizes[], void *alloc_ctxs[])
766 struct vivi_dev *dev = vb2_get_drv_priv(vq);
770 size = fmt->fmt.pix.sizeimage;
772 size = dev->width * dev->height * dev->pixelsize;
780 while (size * *nbuffers > vid_limit * 1024 * 1024)
788 * videobuf2-vmalloc allocator is context-less so no need to set
792 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
798 static int buffer_prepare(struct vb2_buffer *vb)
800 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
801 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
804 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
806 BUG_ON(NULL == dev->fmt);
809 * Theses properties only change when queue is idle, see s_fmt.
810 * The below checks should not be performed here, on each
811 * buffer_prepare (i.e. on each qbuf). Most of the code in this function
812 * should thus be moved to buffer_init and s_fmt.
814 if (dev->width < 48 || dev->width > MAX_WIDTH ||
815 dev->height < 32 || dev->height > MAX_HEIGHT)
818 size = dev->width * dev->height * dev->pixelsize;
819 if (vb2_plane_size(vb, 0) < size) {
820 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
821 __func__, vb2_plane_size(vb, 0), size);
825 vb2_set_plane_payload(&buf->vb, 0, size);
829 precalculate_bars(dev);
830 precalculate_line(dev);
835 static void buffer_queue(struct vb2_buffer *vb)
837 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
838 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
839 struct vivi_dmaqueue *vidq = &dev->vidq;
840 unsigned long flags = 0;
842 dprintk(dev, 1, "%s\n", __func__);
844 spin_lock_irqsave(&dev->slock, flags);
845 list_add_tail(&buf->list, &vidq->active);
846 spin_unlock_irqrestore(&dev->slock, flags);
849 static int start_streaming(struct vb2_queue *vq, unsigned int count)
851 struct vivi_dev *dev = vb2_get_drv_priv(vq);
852 dprintk(dev, 1, "%s\n", __func__);
853 return vivi_start_generating(dev);
856 /* abort streaming and wait for last buffer */
857 static int stop_streaming(struct vb2_queue *vq)
859 struct vivi_dev *dev = vb2_get_drv_priv(vq);
860 dprintk(dev, 1, "%s\n", __func__);
861 vivi_stop_generating(dev);
865 static void vivi_lock(struct vb2_queue *vq)
867 struct vivi_dev *dev = vb2_get_drv_priv(vq);
868 mutex_lock(&dev->mutex);
871 static void vivi_unlock(struct vb2_queue *vq)
873 struct vivi_dev *dev = vb2_get_drv_priv(vq);
874 mutex_unlock(&dev->mutex);
878 static struct vb2_ops vivi_video_qops = {
879 .queue_setup = queue_setup,
880 .buf_prepare = buffer_prepare,
881 .buf_queue = buffer_queue,
882 .start_streaming = start_streaming,
883 .stop_streaming = stop_streaming,
884 .wait_prepare = vivi_unlock,
885 .wait_finish = vivi_lock,
888 /* ------------------------------------------------------------------
889 IOCTL vidioc handling
890 ------------------------------------------------------------------*/
891 static int vidioc_querycap(struct file *file, void *priv,
892 struct v4l2_capability *cap)
894 struct vivi_dev *dev = video_drvdata(file);
896 strcpy(cap->driver, "vivi");
897 strcpy(cap->card, "vivi");
898 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
899 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
901 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
905 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
906 struct v4l2_fmtdesc *f)
908 struct vivi_fmt *fmt;
910 if (f->index >= ARRAY_SIZE(formats))
913 fmt = &formats[f->index];
915 strlcpy(f->description, fmt->name, sizeof(f->description));
916 f->pixelformat = fmt->fourcc;
920 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
921 struct v4l2_format *f)
923 struct vivi_dev *dev = video_drvdata(file);
925 f->fmt.pix.width = dev->width;
926 f->fmt.pix.height = dev->height;
927 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
928 f->fmt.pix.pixelformat = dev->fmt->fourcc;
929 f->fmt.pix.bytesperline =
930 (f->fmt.pix.width * dev->fmt->depth) >> 3;
931 f->fmt.pix.sizeimage =
932 f->fmt.pix.height * f->fmt.pix.bytesperline;
933 if (dev->fmt->fourcc == V4L2_PIX_FMT_YUYV ||
934 dev->fmt->fourcc == V4L2_PIX_FMT_UYVY)
935 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
937 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
941 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
942 struct v4l2_format *f)
944 struct vivi_dev *dev = video_drvdata(file);
945 struct vivi_fmt *fmt;
949 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
950 f->fmt.pix.pixelformat);
951 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
955 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
956 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
957 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
958 f->fmt.pix.bytesperline =
959 (f->fmt.pix.width * fmt->depth) >> 3;
960 f->fmt.pix.sizeimage =
961 f->fmt.pix.height * f->fmt.pix.bytesperline;
962 if (fmt->fourcc == V4L2_PIX_FMT_YUYV ||
963 fmt->fourcc == V4L2_PIX_FMT_UYVY)
964 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
966 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
970 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
971 struct v4l2_format *f)
973 struct vivi_dev *dev = video_drvdata(file);
974 struct vb2_queue *q = &dev->vb_vidq;
976 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
980 if (vb2_is_busy(q)) {
981 dprintk(dev, 1, "%s device busy\n", __func__);
985 dev->fmt = get_format(f);
986 dev->pixelsize = dev->fmt->depth / 8;
987 dev->width = f->fmt.pix.width;
988 dev->height = f->fmt.pix.height;
993 /* only one input in this sample driver */
994 static int vidioc_enum_input(struct file *file, void *priv,
995 struct v4l2_input *inp)
997 if (inp->index >= NUM_INPUTS)
1000 inp->type = V4L2_INPUT_TYPE_CAMERA;
1001 sprintf(inp->name, "Camera %u", inp->index);
1005 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1007 struct vivi_dev *dev = video_drvdata(file);
1013 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1015 struct vivi_dev *dev = video_drvdata(file);
1017 if (i >= NUM_INPUTS)
1020 if (i == dev->input)
1024 precalculate_bars(dev);
1025 precalculate_line(dev);
1029 /* --- controls ---------------------------------------------- */
1031 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1033 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1035 if (ctrl == dev->autogain)
1036 dev->gain->val = jiffies & 0xff;
1040 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1042 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1045 case V4L2_CID_ALPHA_COMPONENT:
1046 dev->alpha_component = ctrl->val;
1049 if (ctrl == dev->button)
1050 dev->button_pressed = 30;
1056 /* ------------------------------------------------------------------
1057 File operations for the device
1058 ------------------------------------------------------------------*/
1060 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1061 .g_volatile_ctrl = vivi_g_volatile_ctrl,
1062 .s_ctrl = vivi_s_ctrl,
1065 #define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1067 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1068 .ops = &vivi_ctrl_ops,
1069 .id = VIVI_CID_CUSTOM_BASE + 0,
1071 .type = V4L2_CTRL_TYPE_BUTTON,
1074 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1075 .ops = &vivi_ctrl_ops,
1076 .id = VIVI_CID_CUSTOM_BASE + 1,
1078 .type = V4L2_CTRL_TYPE_BOOLEAN,
1085 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1086 .ops = &vivi_ctrl_ops,
1087 .id = VIVI_CID_CUSTOM_BASE + 2,
1088 .name = "Integer 32 Bits",
1089 .type = V4L2_CTRL_TYPE_INTEGER,
1095 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1096 .ops = &vivi_ctrl_ops,
1097 .id = VIVI_CID_CUSTOM_BASE + 3,
1098 .name = "Integer 64 Bits",
1099 .type = V4L2_CTRL_TYPE_INTEGER64,
1102 static const char * const vivi_ctrl_menu_strings[] = {
1103 "Menu Item 0 (Skipped)",
1105 "Menu Item 2 (Skipped)",
1108 "Menu Item 5 (Skipped)",
1112 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1113 .ops = &vivi_ctrl_ops,
1114 .id = VIVI_CID_CUSTOM_BASE + 4,
1116 .type = V4L2_CTRL_TYPE_MENU,
1120 .menu_skip_mask = 0x04,
1121 .qmenu = vivi_ctrl_menu_strings,
1124 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1125 .ops = &vivi_ctrl_ops,
1126 .id = VIVI_CID_CUSTOM_BASE + 5,
1128 .type = V4L2_CTRL_TYPE_STRING,
1134 static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1135 .ops = &vivi_ctrl_ops,
1136 .id = VIVI_CID_CUSTOM_BASE + 6,
1138 .type = V4L2_CTRL_TYPE_BITMASK,
1145 static const s64 vivi_ctrl_int_menu_values[] = {
1146 1, 1, 2, 3, 5, 8, 13, 21, 42,
1149 static const struct v4l2_ctrl_config vivi_ctrl_int_menu = {
1150 .ops = &vivi_ctrl_ops,
1151 .id = VIVI_CID_CUSTOM_BASE + 7,
1152 .name = "Integer menu",
1153 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
1157 .menu_skip_mask = 0x02,
1158 .qmenu_int = vivi_ctrl_int_menu_values,
1161 static const struct v4l2_file_operations vivi_fops = {
1162 .owner = THIS_MODULE,
1163 .open = v4l2_fh_open,
1164 .release = vb2_fop_release,
1165 .read = vb2_fop_read,
1166 .poll = vb2_fop_poll,
1167 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1168 .mmap = vb2_fop_mmap,
1171 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1172 .vidioc_querycap = vidioc_querycap,
1173 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1174 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1175 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1176 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1177 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1178 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1179 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1180 .vidioc_querybuf = vb2_ioctl_querybuf,
1181 .vidioc_qbuf = vb2_ioctl_qbuf,
1182 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1183 .vidioc_enum_input = vidioc_enum_input,
1184 .vidioc_g_input = vidioc_g_input,
1185 .vidioc_s_input = vidioc_s_input,
1186 .vidioc_streamon = vb2_ioctl_streamon,
1187 .vidioc_streamoff = vb2_ioctl_streamoff,
1188 .vidioc_log_status = v4l2_ctrl_log_status,
1189 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1190 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1193 static struct video_device vivi_template = {
1196 .ioctl_ops = &vivi_ioctl_ops,
1197 .release = video_device_release_empty,
1200 /* -----------------------------------------------------------------
1201 Initialization and module stuff
1202 ------------------------------------------------------------------*/
1204 static int vivi_release(void)
1206 struct vivi_dev *dev;
1207 struct list_head *list;
1209 while (!list_empty(&vivi_devlist)) {
1210 list = vivi_devlist.next;
1212 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1214 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1215 video_device_node_name(&dev->vdev));
1216 video_unregister_device(&dev->vdev);
1217 v4l2_device_unregister(&dev->v4l2_dev);
1218 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1225 static int __init vivi_create_instance(int inst)
1227 struct vivi_dev *dev;
1228 struct video_device *vfd;
1229 struct v4l2_ctrl_handler *hdl;
1230 struct vb2_queue *q;
1233 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1237 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1238 "%s-%03d", VIVI_MODULE_NAME, inst);
1239 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1243 dev->fmt = &formats[0];
1246 dev->pixelsize = dev->fmt->depth / 8;
1247 hdl = &dev->ctrl_handler;
1248 v4l2_ctrl_handler_init(hdl, 11);
1249 dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1250 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1251 dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1252 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1253 dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1254 V4L2_CID_CONTRAST, 0, 255, 1, 16);
1255 dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1256 V4L2_CID_SATURATION, 0, 255, 1, 127);
1257 dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1258 V4L2_CID_HUE, -128, 127, 1, 0);
1259 dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1260 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1261 dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1262 V4L2_CID_GAIN, 0, 255, 1, 100);
1263 dev->alpha = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1264 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1265 dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1266 dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1267 dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1268 dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1269 dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1270 dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1271 dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1272 dev->int_menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int_menu, NULL);
1277 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1278 dev->v4l2_dev.ctrl_handler = hdl;
1280 /* initialize locks */
1281 spin_lock_init(&dev->slock);
1283 /* initialize queue */
1285 memset(q, 0, sizeof(dev->vb_vidq));
1286 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1287 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1289 q->buf_struct_size = sizeof(struct vivi_buffer);
1290 q->ops = &vivi_video_qops;
1291 q->mem_ops = &vb2_vmalloc_memops;
1295 mutex_init(&dev->mutex);
1297 /* init video dma queues */
1298 INIT_LIST_HEAD(&dev->vidq.active);
1299 init_waitqueue_head(&dev->vidq.wq);
1302 *vfd = vivi_template;
1304 vfd->v4l2_dev = &dev->v4l2_dev;
1306 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1309 * Provide a mutex to v4l2 core. It will be used to protect
1310 * all fops and v4l2 ioctls.
1312 vfd->lock = &dev->mutex;
1313 video_set_drvdata(vfd, dev);
1315 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1319 /* Now that everything is fine, let's add it to device list */
1320 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1322 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1323 video_device_node_name(vfd));
1327 v4l2_ctrl_handler_free(hdl);
1328 v4l2_device_unregister(&dev->v4l2_dev);
1334 /* This routine allocates from 1 to n_devs virtual drivers.
1336 The real maximum number of virtual drivers will depend on how many drivers
1337 will succeed. This is limited to the maximum number of devices that
1338 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1340 static int __init vivi_init(void)
1342 const struct font_desc *font = find_font("VGA8x16");
1346 printk(KERN_ERR "vivi: could not find font\n");
1349 font8x16 = font->data;
1354 for (i = 0; i < n_devs; i++) {
1355 ret = vivi_create_instance(i);
1357 /* If some instantiations succeeded, keep driver */
1365 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1369 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1370 "Capture Board ver %s successfully loaded.\n",
1373 /* n_devs will reflect the actual number of allocated devices */
1379 static void __exit vivi_exit(void)
1384 module_init(vivi_init);
1385 module_exit(vivi_exit);