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->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | \
827
static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
828
struct v4l2_fmtdesc *f)
830
struct vivi_fmt *fmt;
832
if (f->index >= ARRAY_SIZE(formats))
835
fmt = &formats[f->index];
837
strlcpy(f->description, fmt->name, sizeof(f->description));
838
f->pixelformat = fmt->fourcc;
842
static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
843
struct v4l2_format *f)
845
struct vivi_dev *dev = video_drvdata(file);
847
f->fmt.pix.width = dev->width;
848
f->fmt.pix.height = dev->height;
849
f->fmt.pix.field = dev->field;
850
f->fmt.pix.pixelformat = dev->fmt->fourcc;
851
f->fmt.pix.bytesperline =
852
(f->fmt.pix.width * dev->fmt->depth) >> 3;
853
f->fmt.pix.sizeimage =
854
f->fmt.pix.height * f->fmt.pix.bytesperline;
855
if (dev->fmt->fourcc == V4L2_PIX_FMT_YUYV ||
856
dev->fmt->fourcc == V4L2_PIX_FMT_UYVY)
857
f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
859
f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
863
static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
864
struct v4l2_format *f)
866
struct vivi_dev *dev = video_drvdata(file);
867
struct vivi_fmt *fmt;
868
enum v4l2_field field;
872
dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
873
f->fmt.pix.pixelformat);
877
field = f->fmt.pix.field;
879
if (field == V4L2_FIELD_ANY) {
880
field = V4L2_FIELD_INTERLACED;
881
} else if (V4L2_FIELD_INTERLACED != field) {
882
dprintk(dev, 1, "Field type invalid.\n");
886
f->fmt.pix.field = field;
887
v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
888
&f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
889
f->fmt.pix.bytesperline =
890
(f->fmt.pix.width * fmt->depth) >> 3;
891
f->fmt.pix.sizeimage =
892
f->fmt.pix.height * f->fmt.pix.bytesperline;
893
if (fmt->fourcc == V4L2_PIX_FMT_YUYV ||
894
fmt->fourcc == V4L2_PIX_FMT_UYVY)
895
f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
897
f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
901
static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
902
struct v4l2_format *f)
904
struct vivi_dev *dev = video_drvdata(file);
905
struct vb2_queue *q = &dev->vb_vidq;
907
int ret = vidioc_try_fmt_vid_cap(file, priv, f);
911
if (vb2_is_streaming(q)) {
912
dprintk(dev, 1, "%s device busy\n", __func__);
916
dev->fmt = get_format(f);
917
dev->width = f->fmt.pix.width;
918
dev->height = f->fmt.pix.height;
919
dev->field = f->fmt.pix.field;
924
static int vidioc_reqbufs(struct file *file, void *priv,
925
struct v4l2_requestbuffers *p)
927
struct vivi_dev *dev = video_drvdata(file);
928
return vb2_reqbufs(&dev->vb_vidq, p);
931
static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
933
struct vivi_dev *dev = video_drvdata(file);
934
return vb2_querybuf(&dev->vb_vidq, p);
937
static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
939
struct vivi_dev *dev = video_drvdata(file);
940
return vb2_qbuf(&dev->vb_vidq, p);
943
static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
945
struct vivi_dev *dev = video_drvdata(file);
946
return vb2_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK);
949
static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
951
struct vivi_dev *dev = video_drvdata(file);
952
return vb2_streamon(&dev->vb_vidq, i);
955
static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
957
struct vivi_dev *dev = video_drvdata(file);
958
return vb2_streamoff(&dev->vb_vidq, i);
961
static int vidioc_log_status(struct file *file, void *priv)
963
struct vivi_dev *dev = video_drvdata(file);
965
v4l2_ctrl_handler_log_status(&dev->ctrl_handler, dev->v4l2_dev.name);
969
static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
974
/* only one input in this sample driver */
975
static int vidioc_enum_input(struct file *file, void *priv,
976
struct v4l2_input *inp)
978
if (inp->index >= NUM_INPUTS)
981
inp->type = V4L2_INPUT_TYPE_CAMERA;
982
inp->std = V4L2_STD_525_60;
983
sprintf(inp->name, "Camera %u", inp->index);
987
static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
989
struct vivi_dev *dev = video_drvdata(file);
995
static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
997
struct vivi_dev *dev = video_drvdata(file);
1002
if (i == dev->input)
1006
precalculate_bars(dev);
1007
precalculate_line(dev);
1011
static int vidioc_subscribe_event(struct v4l2_fh *fh,
1012
struct v4l2_event_subscription *sub)
1014
switch (sub->type) {
1015
case V4L2_EVENT_CTRL:
1016
return v4l2_event_subscribe(fh, sub, 0);
1022
/* --- controls ---------------------------------------------- */
1024
static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1026
struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1028
if (ctrl == dev->autogain)
1029
dev->gain->val = jiffies & 0xff;
1033
static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1035
struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1037
if (ctrl == dev->button)
1038
dev->button_pressed = 30;
1042
/* ------------------------------------------------------------------
1043
File operations for the device
1044
------------------------------------------------------------------*/
1047
vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1049
struct vivi_dev *dev = video_drvdata(file);
1051
dprintk(dev, 1, "read called\n");
1052
return vb2_read(&dev->vb_vidq, data, count, ppos,
1053
file->f_flags & O_NONBLOCK);
1057
vivi_poll(struct file *file, struct poll_table_struct *wait)
1059
struct vivi_dev *dev = video_drvdata(file);
1060
struct v4l2_fh *fh = file->private_data;
1061
struct vb2_queue *q = &dev->vb_vidq;
1064
dprintk(dev, 1, "%s\n", __func__);
1065
res = vb2_poll(q, file, wait);
1066
if (v4l2_event_pending(fh))
1069
poll_wait(file, &fh->wait, wait);
1073
static int vivi_close(struct file *file)
1075
struct video_device *vdev = video_devdata(file);
1076
struct vivi_dev *dev = video_drvdata(file);
1078
dprintk(dev, 1, "close called (dev=%s), file %p\n",
1079
video_device_node_name(vdev), file);
1081
if (v4l2_fh_is_singular_file(file))
1082
vb2_queue_release(&dev->vb_vidq);
1083
return v4l2_fh_release(file);
1086
static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1088
struct vivi_dev *dev = video_drvdata(file);
1091
dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1093
ret = vb2_mmap(&dev->vb_vidq, vma);
1094
dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1095
(unsigned long)vma->vm_start,
1096
(unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
1101
static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1102
.g_volatile_ctrl = vivi_g_volatile_ctrl,
1103
.s_ctrl = vivi_s_ctrl,
1106
#define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1108
static const struct v4l2_ctrl_config vivi_ctrl_button = {
1109
.ops = &vivi_ctrl_ops,
1110
.id = VIVI_CID_CUSTOM_BASE + 0,
1112
.type = V4L2_CTRL_TYPE_BUTTON,
1115
static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1116
.ops = &vivi_ctrl_ops,
1117
.id = VIVI_CID_CUSTOM_BASE + 1,
1119
.type = V4L2_CTRL_TYPE_BOOLEAN,
1126
static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1127
.ops = &vivi_ctrl_ops,
1128
.id = VIVI_CID_CUSTOM_BASE + 2,
1129
.name = "Integer 32 Bits",
1130
.type = V4L2_CTRL_TYPE_INTEGER,
1136
static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1137
.ops = &vivi_ctrl_ops,
1138
.id = VIVI_CID_CUSTOM_BASE + 3,
1139
.name = "Integer 64 Bits",
1140
.type = V4L2_CTRL_TYPE_INTEGER64,
1143
static const char * const vivi_ctrl_menu_strings[] = {
1144
"Menu Item 0 (Skipped)",
1146
"Menu Item 2 (Skipped)",
1149
"Menu Item 5 (Skipped)",
1153
static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1154
.ops = &vivi_ctrl_ops,
1155
.id = VIVI_CID_CUSTOM_BASE + 4,
1157
.type = V4L2_CTRL_TYPE_MENU,
1161
.menu_skip_mask = 0x04,
1162
.qmenu = vivi_ctrl_menu_strings,
1165
static const struct v4l2_ctrl_config vivi_ctrl_string = {
1166
.ops = &vivi_ctrl_ops,
1167
.id = VIVI_CID_CUSTOM_BASE + 5,
1169
.type = V4L2_CTRL_TYPE_STRING,
1175
static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1176
.ops = &vivi_ctrl_ops,
1177
.id = VIVI_CID_CUSTOM_BASE + 6,
1179
.type = V4L2_CTRL_TYPE_BITMASK,
1186
static const struct v4l2_file_operations vivi_fops = {
1187
.owner = THIS_MODULE,
1188
.open = v4l2_fh_open,
1189
.release = vivi_close,
1192
.unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1196
static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1197
.vidioc_querycap = vidioc_querycap,
1198
.vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1199
.vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1200
.vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1201
.vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1202
.vidioc_reqbufs = vidioc_reqbufs,
1203
.vidioc_querybuf = vidioc_querybuf,
1204
.vidioc_qbuf = vidioc_qbuf,
1205
.vidioc_dqbuf = vidioc_dqbuf,
1206
.vidioc_s_std = vidioc_s_std,
1207
.vidioc_enum_input = vidioc_enum_input,
1208
.vidioc_g_input = vidioc_g_input,
1209
.vidioc_s_input = vidioc_s_input,
1210
.vidioc_streamon = vidioc_streamon,
1211
.vidioc_streamoff = vidioc_streamoff,
1212
.vidioc_log_status = vidioc_log_status,
1213
.vidioc_subscribe_event = vidioc_subscribe_event,
1214
.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1217
static struct video_device vivi_template = {
1220
.ioctl_ops = &vivi_ioctl_ops,
1221
.release = video_device_release,
1223
.tvnorms = V4L2_STD_525_60,
1224
.current_norm = V4L2_STD_NTSC_M,
1227
/* -----------------------------------------------------------------
1228
Initialization and module stuff
1229
------------------------------------------------------------------*/
1231
static int vivi_release(void)
1233
struct vivi_dev *dev;
1234
struct list_head *list;
1236
while (!list_empty(&vivi_devlist)) {
1237
list = vivi_devlist.next;
1239
dev = list_entry(list, struct vivi_dev, vivi_devlist);
1241
v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1242
video_device_node_name(dev->vfd));
1243
video_unregister_device(dev->vfd);
1244
v4l2_device_unregister(&dev->v4l2_dev);
1245
v4l2_ctrl_handler_free(&dev->ctrl_handler);
1252
static int __init vivi_create_instance(int inst)
1254
struct vivi_dev *dev;
1255
struct video_device *vfd;
1256
struct v4l2_ctrl_handler *hdl;
1257
struct vb2_queue *q;
1260
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1264
snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1265
"%s-%03d", VIVI_MODULE_NAME, inst);
1266
ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1270
dev->fmt = &formats[0];
1273
hdl = &dev->ctrl_handler;
1274
v4l2_ctrl_handler_init(hdl, 11);
1275
dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1276
V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1277
dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1278
V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1279
dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1280
V4L2_CID_CONTRAST, 0, 255, 1, 16);
1281
dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1282
V4L2_CID_SATURATION, 0, 255, 1, 127);
1283
dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1284
V4L2_CID_HUE, -128, 127, 1, 0);
1285
dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1286
V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1287
dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1288
V4L2_CID_GAIN, 0, 255, 1, 100);
1289
dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1290
dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1291
dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1292
dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1293
dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1294
dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1295
dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1300
v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1301
dev->v4l2_dev.ctrl_handler = hdl;
1303
/* initialize locks */
1304
spin_lock_init(&dev->slock);
1306
/* initialize queue */
1308
memset(q, 0, sizeof(dev->vb_vidq));
1309
q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1310
q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1312
q->buf_struct_size = sizeof(struct vivi_buffer);
1313
q->ops = &vivi_video_qops;
1314
q->mem_ops = &vb2_vmalloc_memops;
1318
mutex_init(&dev->mutex);
1320
/* init video dma queues */
1321
INIT_LIST_HEAD(&dev->vidq.active);
1322
init_waitqueue_head(&dev->vidq.wq);
1325
vfd = video_device_alloc();
1329
*vfd = vivi_template;
1331
vfd->v4l2_dev = &dev->v4l2_dev;
1332
set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1335
* Provide a mutex to v4l2 core. It will be used to protect
1336
* all fops and v4l2 ioctls.
1338
vfd->lock = &dev->mutex;
1340
ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1344
video_set_drvdata(vfd, dev);
1346
/* Now that everything is fine, let's add it to device list */
1347
list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1353
v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1354
video_device_node_name(vfd));
1358
video_device_release(vfd);
1360
v4l2_ctrl_handler_free(hdl);
1361
v4l2_device_unregister(&dev->v4l2_dev);
1367
/* This routine allocates from 1 to n_devs virtual drivers.
1369
The real maximum number of virtual drivers will depend on how many drivers
1370
will succeed. This is limited to the maximum number of devices that
1371
videodev supports, which is equal to VIDEO_NUM_DEVICES.
1373
static int __init vivi_init(void)
1375
const struct font_desc *font = find_font("VGA8x16");
1379
printk(KERN_ERR "vivi: could not find font\n");
1382
font8x16 = font->data;
1387
for (i = 0; i < n_devs; i++) {
1388
ret = vivi_create_instance(i);
1390
/* If some instantiations succeeded, keep driver */
1398
printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1402
printk(KERN_INFO "Video Technology Magazine Virtual Video "
1403
"Capture Board ver %s successfully loaded.\n",
1406
/* n_devs will reflect the actual number of allocated devices */
1412
static void __exit vivi_exit(void)
1417
module_init(vivi_init);
1418
module_exit(vivi_exit);