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 /* Global font descriptor */
74 static const u8
*font8x16
;
76 /* timeperframe: min/max and default */
77 static const struct v4l2_fract
78 tpf_min
= {.numerator
= 1, .denominator
= FPS_MAX
},
79 tpf_max
= {.numerator
= FPS_MAX
, .denominator
= 1},
80 tpf_default
= {.numerator
= 1001, .denominator
= 30000}; /* NTSC */
82 #define dprintk(dev, level, fmt, arg...) \
83 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
85 /* ------------------------------------------------------------------
87 ------------------------------------------------------------------*/
91 u32 fourcc
; /* v4l2 format id */
96 static const struct vivi_fmt formats
[] = {
98 .name
= "4:2:2, packed, YUYV",
99 .fourcc
= V4L2_PIX_FMT_YUYV
,
104 .name
= "4:2:2, packed, UYVY",
105 .fourcc
= V4L2_PIX_FMT_UYVY
,
110 .name
= "4:2:2, packed, YVYU",
111 .fourcc
= V4L2_PIX_FMT_YVYU
,
116 .name
= "4:2:2, packed, VYUY",
117 .fourcc
= V4L2_PIX_FMT_VYUY
,
122 .name
= "RGB565 (LE)",
123 .fourcc
= V4L2_PIX_FMT_RGB565
, /* gggbbbbb rrrrrggg */
127 .name
= "RGB565 (BE)",
128 .fourcc
= V4L2_PIX_FMT_RGB565X
, /* rrrrrggg gggbbbbb */
132 .name
= "RGB555 (LE)",
133 .fourcc
= V4L2_PIX_FMT_RGB555
, /* gggbbbbb arrrrrgg */
137 .name
= "RGB555 (BE)",
138 .fourcc
= V4L2_PIX_FMT_RGB555X
, /* arrrrrgg gggbbbbb */
142 .name
= "RGB24 (LE)",
143 .fourcc
= V4L2_PIX_FMT_RGB24
, /* rgb */
147 .name
= "RGB24 (BE)",
148 .fourcc
= V4L2_PIX_FMT_BGR24
, /* bgr */
152 .name
= "RGB32 (LE)",
153 .fourcc
= V4L2_PIX_FMT_RGB32
, /* argb */
157 .name
= "RGB32 (BE)",
158 .fourcc
= V4L2_PIX_FMT_BGR32
, /* bgra */
163 static const struct vivi_fmt
*__get_format(u32 pixelformat
)
165 const struct vivi_fmt
*fmt
;
168 for (k
= 0; k
< ARRAY_SIZE(formats
); k
++) {
170 if (fmt
->fourcc
== pixelformat
)
174 if (k
== ARRAY_SIZE(formats
))
180 static const struct vivi_fmt
*get_format(struct v4l2_format
*f
)
182 return __get_format(f
->fmt
.pix
.pixelformat
);
185 /* buffer for one video frame */
187 /* common v4l buffer stuff -- must be first */
188 struct vb2_buffer vb
;
189 struct list_head list
;
192 struct vivi_dmaqueue
{
193 struct list_head active
;
195 /* thread for generating video stream*/
196 struct task_struct
*kthread
;
197 wait_queue_head_t wq
;
198 /* Counters to control fps rate */
203 static LIST_HEAD(vivi_devlist
);
206 struct list_head vivi_devlist
;
207 struct v4l2_device v4l2_dev
;
208 struct v4l2_ctrl_handler ctrl_handler
;
209 struct video_device vdev
;
212 struct v4l2_ctrl
*brightness
;
213 struct v4l2_ctrl
*contrast
;
214 struct v4l2_ctrl
*saturation
;
215 struct v4l2_ctrl
*hue
;
217 /* autogain/gain cluster */
218 struct v4l2_ctrl
*autogain
;
219 struct v4l2_ctrl
*gain
;
221 struct v4l2_ctrl
*volume
;
222 struct v4l2_ctrl
*alpha
;
223 struct v4l2_ctrl
*button
;
224 struct v4l2_ctrl
*boolean
;
225 struct v4l2_ctrl
*int32
;
226 struct v4l2_ctrl
*int64
;
227 struct v4l2_ctrl
*menu
;
228 struct v4l2_ctrl
*string
;
229 struct v4l2_ctrl
*bitmask
;
230 struct v4l2_ctrl
*int_menu
;
235 struct vivi_dmaqueue vidq
;
237 /* Several counters */
239 unsigned long jiffies
;
240 unsigned button_pressed
;
242 int mv_count
; /* Controls bars movement */
248 const struct vivi_fmt
*fmt
;
249 struct v4l2_fract timeperframe
;
250 unsigned int width
, height
;
251 struct vb2_queue vb_vidq
;
252 unsigned int seq_count
;
255 u8 line
[MAX_WIDTH
* 8] __attribute__((__aligned__(4)));
256 unsigned int pixelsize
;
261 /* ------------------------------------------------------------------
262 DMA and thread functions
263 ------------------------------------------------------------------*/
265 /* Bars and Colors should match positions */
280 #define COLOR_WHITE {204, 204, 204}
281 #define COLOR_AMBER {208, 208, 0}
282 #define COLOR_CYAN { 0, 206, 206}
283 #define COLOR_GREEN { 0, 239, 0}
284 #define COLOR_MAGENTA {239, 0, 239}
285 #define COLOR_RED {205, 0, 0}
286 #define COLOR_BLUE { 0, 0, 255}
287 #define COLOR_BLACK { 0, 0, 0}
293 /* Maximum number of bars are 10 - otherwise, the input print code
294 should be modified */
295 static const struct bar_std bars
[] = {
296 { /* Standard ITU-R color bar sequence */
297 { COLOR_WHITE
, COLOR_AMBER
, COLOR_CYAN
, COLOR_GREEN
,
298 COLOR_MAGENTA
, COLOR_RED
, COLOR_BLUE
, COLOR_BLACK
, COLOR_BLACK
}
300 { COLOR_WHITE
, COLOR_AMBER
, COLOR_BLACK
, COLOR_WHITE
,
301 COLOR_AMBER
, COLOR_BLACK
, COLOR_WHITE
, COLOR_AMBER
, COLOR_BLACK
}
303 { COLOR_WHITE
, COLOR_CYAN
, COLOR_BLACK
, COLOR_WHITE
,
304 COLOR_CYAN
, COLOR_BLACK
, COLOR_WHITE
, COLOR_CYAN
, COLOR_BLACK
}
306 { COLOR_WHITE
, COLOR_GREEN
, COLOR_BLACK
, COLOR_WHITE
,
307 COLOR_GREEN
, COLOR_BLACK
, COLOR_WHITE
, COLOR_GREEN
, COLOR_BLACK
}
311 #define NUM_INPUTS ARRAY_SIZE(bars)
313 #define TO_Y(r, g, b) \
314 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
315 /* RGB to V(Cr) Color transform */
316 #define TO_V(r, g, b) \
317 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
318 /* RGB to U(Cb) Color transform */
319 #define TO_U(r, g, b) \
320 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
322 /* precalculate color bar values to speed up rendering */
323 static void precalculate_bars(struct vivi_dev
*dev
)
328 for (k
= 0; k
< 9; k
++) {
329 r
= bars
[dev
->input
].bar
[k
][0];
330 g
= bars
[dev
->input
].bar
[k
][1];
331 b
= bars
[dev
->input
].bar
[k
][2];
332 is_yuv
= dev
->fmt
->is_yuv
;
334 switch (dev
->fmt
->fourcc
) {
335 case V4L2_PIX_FMT_RGB565
:
336 case V4L2_PIX_FMT_RGB565X
:
341 case V4L2_PIX_FMT_RGB555
:
342 case V4L2_PIX_FMT_RGB555X
:
347 case V4L2_PIX_FMT_YUYV
:
348 case V4L2_PIX_FMT_UYVY
:
349 case V4L2_PIX_FMT_YVYU
:
350 case V4L2_PIX_FMT_VYUY
:
351 case V4L2_PIX_FMT_RGB24
:
352 case V4L2_PIX_FMT_BGR24
:
353 case V4L2_PIX_FMT_RGB32
:
354 case V4L2_PIX_FMT_BGR32
:
359 dev
->bars
[k
][0] = TO_Y(r
, g
, b
); /* Luma */
360 dev
->bars
[k
][1] = TO_U(r
, g
, b
); /* Cb */
361 dev
->bars
[k
][2] = TO_V(r
, g
, b
); /* Cr */
370 /* 'odd' is true for pixels 1, 3, 5, etc. and false for pixels 0, 2, 4, etc. */
371 static void gen_twopix(struct vivi_dev
*dev
, u8
*buf
, int colorpos
, bool odd
)
374 u8 alpha
= dev
->alpha_component
;
378 r_y
= dev
->bars
[colorpos
][0]; /* R or precalculated Y */
379 g_u
= dev
->bars
[colorpos
][1]; /* G or precalculated U */
380 b_v
= dev
->bars
[colorpos
][2]; /* B or precalculated V */
382 for (color
= 0; color
< dev
->pixelsize
; color
++) {
385 switch (dev
->fmt
->fourcc
) {
386 case V4L2_PIX_FMT_YUYV
:
392 *p
= odd
? b_v
: g_u
;
396 case V4L2_PIX_FMT_UYVY
:
399 *p
= odd
? b_v
: g_u
;
406 case V4L2_PIX_FMT_YVYU
:
412 *p
= odd
? g_u
: b_v
;
416 case V4L2_PIX_FMT_VYUY
:
419 *p
= odd
? g_u
: b_v
;
426 case V4L2_PIX_FMT_RGB565
:
429 *p
= (g_u
<< 5) | b_v
;
432 *p
= (r_y
<< 3) | (g_u
>> 3);
436 case V4L2_PIX_FMT_RGB565X
:
439 *p
= (r_y
<< 3) | (g_u
>> 3);
442 *p
= (g_u
<< 5) | b_v
;
446 case V4L2_PIX_FMT_RGB555
:
449 *p
= (g_u
<< 5) | b_v
;
452 *p
= (alpha
& 0x80) | (r_y
<< 2) | (g_u
>> 3);
456 case V4L2_PIX_FMT_RGB555X
:
459 *p
= (alpha
& 0x80) | (r_y
<< 2) | (g_u
>> 3);
462 *p
= (g_u
<< 5) | b_v
;
466 case V4L2_PIX_FMT_RGB24
:
479 case V4L2_PIX_FMT_BGR24
:
492 case V4L2_PIX_FMT_RGB32
:
508 case V4L2_PIX_FMT_BGR32
:
528 static void precalculate_line(struct vivi_dev
*dev
)
530 unsigned pixsize
= dev
->pixelsize
;
531 unsigned pixsize2
= 2*pixsize
;
535 for (colorpos
= 0; colorpos
< 16; ++colorpos
) {
537 int wstart
= colorpos
* dev
->width
/ 8;
538 int wend
= (colorpos
+1) * dev
->width
/ 8;
541 gen_twopix(dev
, &pix
[0], colorpos
% 8, 0);
542 gen_twopix(dev
, &pix
[pixsize
], colorpos
% 8, 1);
544 for (w
= wstart
/2*2, pos
= dev
->line
+ w
*pixsize
; w
< wend
; w
+= 2, pos
+= pixsize2
)
545 memcpy(pos
, pix
, pixsize2
);
549 /* need this to do rgb24 rendering */
550 typedef struct { u16 __
; u8 _
; } __attribute__((packed
)) x24
;
552 static void gen_text(struct vivi_dev
*dev
, char *basep
,
553 int y
, int x
, char *text
)
556 unsigned int width
= dev
->width
;
558 /* Checks if it is possible to show string */
559 if (y
+ 16 >= dev
->height
|| x
+ strlen(text
) * 8 >= width
)
562 /* Print stream time */
563 #define PRINTSTR(PIXTYPE) do { \
566 memcpy(&fg, &dev->textfg, sizeof(PIXTYPE)); \
567 memcpy(&bg, &dev->textbg, sizeof(PIXTYPE)); \
569 for (line = 0; line < 16; line++) { \
570 PIXTYPE *pos = (PIXTYPE *)( basep + ((y + line) * width + x) * sizeof(PIXTYPE) ); \
573 for (s = text; *s; s++) { \
574 u8 chr = font8x16[*s * 16 + line]; \
576 pos[0] = (chr & (0x01 << 7) ? fg : bg); \
577 pos[1] = (chr & (0x01 << 6) ? fg : bg); \
578 pos[2] = (chr & (0x01 << 5) ? fg : bg); \
579 pos[3] = (chr & (0x01 << 4) ? fg : bg); \
580 pos[4] = (chr & (0x01 << 3) ? fg : bg); \
581 pos[5] = (chr & (0x01 << 2) ? fg : bg); \
582 pos[6] = (chr & (0x01 << 1) ? fg : bg); \
583 pos[7] = (chr & (0x01 << 0) ? fg : bg); \
590 switch (dev
->pixelsize
) {
592 PRINTSTR(u16
); break;
594 PRINTSTR(u32
); break;
596 PRINTSTR(x24
); break;
600 static void vivi_fillbuff(struct vivi_dev
*dev
, struct vivi_buffer
*buf
)
602 int stride
= dev
->width
* dev
->pixelsize
;
603 int hmax
= dev
->height
;
604 void *vbuf
= vb2_plane_vaddr(&buf
->vb
, 0);
614 linestart
= dev
->line
+ (dev
->mv_count
% dev
->width
) * dev
->pixelsize
;
616 for (h
= 0; h
< hmax
; h
++)
617 memcpy(vbuf
+ h
* stride
, linestart
, stride
);
619 /* Updates stream time */
621 gen_twopix(dev
, (u8
*)&dev
->textbg
, TEXT_BLACK
, /*odd=*/ 0);
622 gen_twopix(dev
, (u8
*)&dev
->textfg
, WHITE
, /*odd=*/ 0);
624 dev
->ms
+= jiffies_to_msecs(jiffies
- dev
->jiffies
);
625 dev
->jiffies
= jiffies
;
627 snprintf(str
, sizeof(str
), " %02d:%02d:%02d:%03d ",
628 (ms
/ (60 * 60 * 1000)) % 24,
629 (ms
/ (60 * 1000)) % 60,
632 gen_text(dev
, vbuf
, line
++ * 16, 16, str
);
633 snprintf(str
, sizeof(str
), " %dx%d, input %d ",
634 dev
->width
, dev
->height
, dev
->input
);
635 gen_text(dev
, vbuf
, line
++ * 16, 16, str
);
637 gain
= v4l2_ctrl_g_ctrl(dev
->gain
);
638 mutex_lock(dev
->ctrl_handler
.lock
);
639 snprintf(str
, sizeof(str
), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
640 dev
->brightness
->cur
.val
,
641 dev
->contrast
->cur
.val
,
642 dev
->saturation
->cur
.val
,
644 gen_text(dev
, vbuf
, line
++ * 16, 16, str
);
645 snprintf(str
, sizeof(str
), " autogain %d, gain %3d, volume %3d, alpha 0x%02x ",
646 dev
->autogain
->cur
.val
, gain
, dev
->volume
->cur
.val
,
647 dev
->alpha
->cur
.val
);
648 gen_text(dev
, vbuf
, line
++ * 16, 16, str
);
649 snprintf(str
, sizeof(str
), " int32 %d, int64 %lld, bitmask %08x ",
651 dev
->int64
->cur
.val64
,
652 dev
->bitmask
->cur
.val
);
653 gen_text(dev
, vbuf
, line
++ * 16, 16, str
);
654 snprintf(str
, sizeof(str
), " boolean %d, menu %s, string \"%s\" ",
655 dev
->boolean
->cur
.val
,
656 dev
->menu
->qmenu
[dev
->menu
->cur
.val
],
657 dev
->string
->cur
.string
);
658 gen_text(dev
, vbuf
, line
++ * 16, 16, str
);
659 snprintf(str
, sizeof(str
), " integer_menu %lld, value %d ",
660 dev
->int_menu
->qmenu_int
[dev
->int_menu
->cur
.val
],
661 dev
->int_menu
->cur
.val
);
662 gen_text(dev
, vbuf
, line
++ * 16, 16, str
);
663 mutex_unlock(dev
->ctrl_handler
.lock
);
664 if (dev
->button_pressed
) {
665 dev
->button_pressed
--;
666 snprintf(str
, sizeof(str
), " button pressed!");
667 gen_text(dev
, vbuf
, line
++ * 16, 16, str
);
672 buf
->vb
.v4l2_buf
.field
= V4L2_FIELD_INTERLACED
;
673 buf
->vb
.v4l2_buf
.sequence
= dev
->seq_count
++;
674 v4l2_get_timestamp(&buf
->vb
.v4l2_buf
.timestamp
);
677 static void vivi_thread_tick(struct vivi_dev
*dev
)
679 struct vivi_dmaqueue
*dma_q
= &dev
->vidq
;
680 struct vivi_buffer
*buf
;
681 unsigned long flags
= 0;
683 dprintk(dev
, 1, "Thread tick\n");
685 spin_lock_irqsave(&dev
->slock
, flags
);
686 if (list_empty(&dma_q
->active
)) {
687 dprintk(dev
, 1, "No active queue to serve\n");
688 spin_unlock_irqrestore(&dev
->slock
, flags
);
692 buf
= list_entry(dma_q
->active
.next
, struct vivi_buffer
, list
);
693 list_del(&buf
->list
);
694 spin_unlock_irqrestore(&dev
->slock
, flags
);
696 v4l2_get_timestamp(&buf
->vb
.v4l2_buf
.timestamp
);
699 vivi_fillbuff(dev
, buf
);
700 dprintk(dev
, 1, "filled buffer %p\n", buf
);
702 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_DONE
);
703 dprintk(dev
, 2, "[%p/%d] done\n", buf
, buf
->vb
.v4l2_buf
.index
);
706 #define frames_to_ms(dev, frames) \
707 ((frames * dev->timeperframe.numerator * 1000) / dev->timeperframe.denominator)
709 static void vivi_sleep(struct vivi_dev
*dev
)
711 struct vivi_dmaqueue
*dma_q
= &dev
->vidq
;
713 DECLARE_WAITQUEUE(wait
, current
);
715 dprintk(dev
, 1, "%s dma_q=0x%08lx\n", __func__
,
716 (unsigned long)dma_q
);
718 add_wait_queue(&dma_q
->wq
, &wait
);
719 if (kthread_should_stop())
722 /* Calculate time to wake up */
723 timeout
= msecs_to_jiffies(frames_to_ms(dev
, 1));
725 vivi_thread_tick(dev
);
727 schedule_timeout_interruptible(timeout
);
730 remove_wait_queue(&dma_q
->wq
, &wait
);
734 static int vivi_thread(void *data
)
736 struct vivi_dev
*dev
= data
;
738 dprintk(dev
, 1, "thread started\n");
745 if (kthread_should_stop())
748 dprintk(dev
, 1, "thread: exit\n");
752 static int vivi_start_generating(struct vivi_dev
*dev
)
754 struct vivi_dmaqueue
*dma_q
= &dev
->vidq
;
756 dprintk(dev
, 1, "%s\n", __func__
);
758 /* Resets frame counters */
761 dev
->jiffies
= jiffies
;
764 dma_q
->ini_jiffies
= jiffies
;
765 dma_q
->kthread
= kthread_run(vivi_thread
, dev
, "%s",
768 if (IS_ERR(dma_q
->kthread
)) {
769 v4l2_err(&dev
->v4l2_dev
, "kernel_thread() failed\n");
770 return PTR_ERR(dma_q
->kthread
);
773 wake_up_interruptible(&dma_q
->wq
);
775 dprintk(dev
, 1, "returning from %s\n", __func__
);
779 static void vivi_stop_generating(struct vivi_dev
*dev
)
781 struct vivi_dmaqueue
*dma_q
= &dev
->vidq
;
783 dprintk(dev
, 1, "%s\n", __func__
);
785 /* shutdown control thread */
786 if (dma_q
->kthread
) {
787 kthread_stop(dma_q
->kthread
);
788 dma_q
->kthread
= NULL
;
792 * Typical driver might need to wait here until dma engine stops.
793 * In this case we can abort imiedetly, so it's just a noop.
796 /* Release all active buffers */
797 while (!list_empty(&dma_q
->active
)) {
798 struct vivi_buffer
*buf
;
799 buf
= list_entry(dma_q
->active
.next
, struct vivi_buffer
, list
);
800 list_del(&buf
->list
);
801 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
802 dprintk(dev
, 2, "[%p/%d] done\n", buf
, buf
->vb
.v4l2_buf
.index
);
805 /* ------------------------------------------------------------------
807 ------------------------------------------------------------------*/
808 static int queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*fmt
,
809 unsigned int *nbuffers
, unsigned int *nplanes
,
810 unsigned int sizes
[], void *alloc_ctxs
[])
812 struct vivi_dev
*dev
= vb2_get_drv_priv(vq
);
815 size
= dev
->width
* dev
->height
* dev
->pixelsize
;
817 if (fmt
->fmt
.pix
.sizeimage
< size
)
819 size
= fmt
->fmt
.pix
.sizeimage
;
820 /* check against insane over 8K resolution buffers */
821 if (size
> 7680 * 4320 * dev
->pixelsize
)
830 * videobuf2-vmalloc allocator is context-less so no need to set
834 dprintk(dev
, 1, "%s, count=%d, size=%ld\n", __func__
,
840 static int buffer_prepare(struct vb2_buffer
*vb
)
842 struct vivi_dev
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
843 struct vivi_buffer
*buf
= container_of(vb
, struct vivi_buffer
, vb
);
846 dprintk(dev
, 1, "%s, field=%d\n", __func__
, vb
->v4l2_buf
.field
);
848 BUG_ON(NULL
== dev
->fmt
);
851 * Theses properties only change when queue is idle, see s_fmt.
852 * The below checks should not be performed here, on each
853 * buffer_prepare (i.e. on each qbuf). Most of the code in this function
854 * should thus be moved to buffer_init and s_fmt.
856 if (dev
->width
< 48 || dev
->width
> MAX_WIDTH
||
857 dev
->height
< 32 || dev
->height
> MAX_HEIGHT
)
860 size
= dev
->width
* dev
->height
* dev
->pixelsize
;
861 if (vb2_plane_size(vb
, 0) < size
) {
862 dprintk(dev
, 1, "%s data will not fit into plane (%lu < %lu)\n",
863 __func__
, vb2_plane_size(vb
, 0), size
);
867 vb2_set_plane_payload(&buf
->vb
, 0, size
);
869 precalculate_bars(dev
);
870 precalculate_line(dev
);
875 static void buffer_queue(struct vb2_buffer
*vb
)
877 struct vivi_dev
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
878 struct vivi_buffer
*buf
= container_of(vb
, struct vivi_buffer
, vb
);
879 struct vivi_dmaqueue
*vidq
= &dev
->vidq
;
880 unsigned long flags
= 0;
882 dprintk(dev
, 1, "%s\n", __func__
);
884 spin_lock_irqsave(&dev
->slock
, flags
);
885 list_add_tail(&buf
->list
, &vidq
->active
);
886 spin_unlock_irqrestore(&dev
->slock
, flags
);
889 static int start_streaming(struct vb2_queue
*vq
, unsigned int count
)
891 struct vivi_dev
*dev
= vb2_get_drv_priv(vq
);
894 dprintk(dev
, 1, "%s\n", __func__
);
896 err
= vivi_start_generating(dev
);
898 struct vivi_buffer
*buf
, *tmp
;
900 list_for_each_entry_safe(buf
, tmp
, &dev
->vidq
.active
, list
) {
901 list_del(&buf
->list
);
902 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_QUEUED
);
908 /* abort streaming and wait for last buffer */
909 static void stop_streaming(struct vb2_queue
*vq
)
911 struct vivi_dev
*dev
= vb2_get_drv_priv(vq
);
912 dprintk(dev
, 1, "%s\n", __func__
);
913 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
)
1097 * Modify the brightness range depending on the input.
1098 * This makes it easy to use vivi to test if applications can
1099 * handle control range modifications and is also how this is
1100 * typically used in practice as different inputs may be hooked
1101 * up to different receivers with different control ranges.
1103 v4l2_ctrl_modify_range(dev
->brightness
,
1104 128 * i
, 255 + 128 * i
, 1, 127 + 128 * i
);
1105 precalculate_bars(dev
);
1106 precalculate_line(dev
);
1110 /* timeperframe is arbitrary and continuous */
1111 static int vidioc_enum_frameintervals(struct file
*file
, void *priv
,
1112 struct v4l2_frmivalenum
*fival
)
1114 const struct vivi_fmt
*fmt
;
1119 fmt
= __get_format(fival
->pixel_format
);
1123 /* check for valid width/height */
1124 if (fival
->width
< 48 || fival
->width
> MAX_WIDTH
|| (fival
->width
& 3))
1126 if (fival
->height
< 32 || fival
->height
> MAX_HEIGHT
)
1129 fival
->type
= V4L2_FRMIVAL_TYPE_CONTINUOUS
;
1131 /* fill in stepwise (step=1.0 is required by V4L2 spec) */
1132 fival
->stepwise
.min
= tpf_min
;
1133 fival
->stepwise
.max
= tpf_max
;
1134 fival
->stepwise
.step
= (struct v4l2_fract
) {1, 1};
1139 static int vidioc_g_parm(struct file
*file
, void *priv
,
1140 struct v4l2_streamparm
*parm
)
1142 struct vivi_dev
*dev
= video_drvdata(file
);
1144 if (parm
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1147 parm
->parm
.capture
.capability
= V4L2_CAP_TIMEPERFRAME
;
1148 parm
->parm
.capture
.timeperframe
= dev
->timeperframe
;
1149 parm
->parm
.capture
.readbuffers
= 1;
1153 #define FRACT_CMP(a, OP, b) \
1154 ((u64)(a).numerator * (b).denominator OP (u64)(b).numerator * (a).denominator)
1156 static int vidioc_s_parm(struct file
*file
, void *priv
,
1157 struct v4l2_streamparm
*parm
)
1159 struct vivi_dev
*dev
= video_drvdata(file
);
1160 struct v4l2_fract tpf
;
1162 if (parm
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1165 tpf
= parm
->parm
.capture
.timeperframe
;
1167 /* tpf: {*, 0} resets timing; clip to [min, max]*/
1168 tpf
= tpf
.denominator
? tpf
: tpf_default
;
1169 tpf
= FRACT_CMP(tpf
, <, tpf_min
) ? tpf_min
: tpf
;
1170 tpf
= FRACT_CMP(tpf
, >, tpf_max
) ? tpf_max
: tpf
;
1172 dev
->timeperframe
= tpf
;
1173 parm
->parm
.capture
.timeperframe
= tpf
;
1174 parm
->parm
.capture
.readbuffers
= 1;
1178 /* --- controls ---------------------------------------------- */
1180 static int vivi_g_volatile_ctrl(struct v4l2_ctrl
*ctrl
)
1182 struct vivi_dev
*dev
= container_of(ctrl
->handler
, struct vivi_dev
, ctrl_handler
);
1184 if (ctrl
== dev
->autogain
)
1185 dev
->gain
->val
= jiffies
& 0xff;
1189 static int vivi_s_ctrl(struct v4l2_ctrl
*ctrl
)
1191 struct vivi_dev
*dev
= container_of(ctrl
->handler
, struct vivi_dev
, ctrl_handler
);
1194 case V4L2_CID_ALPHA_COMPONENT
:
1195 dev
->alpha_component
= ctrl
->val
;
1198 if (ctrl
== dev
->button
)
1199 dev
->button_pressed
= 30;
1205 /* ------------------------------------------------------------------
1206 File operations for the device
1207 ------------------------------------------------------------------*/
1209 static const struct v4l2_ctrl_ops vivi_ctrl_ops
= {
1210 .g_volatile_ctrl
= vivi_g_volatile_ctrl
,
1211 .s_ctrl
= vivi_s_ctrl
,
1214 #define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1216 static const struct v4l2_ctrl_config vivi_ctrl_button
= {
1217 .ops
= &vivi_ctrl_ops
,
1218 .id
= VIVI_CID_CUSTOM_BASE
+ 0,
1220 .type
= V4L2_CTRL_TYPE_BUTTON
,
1223 static const struct v4l2_ctrl_config vivi_ctrl_boolean
= {
1224 .ops
= &vivi_ctrl_ops
,
1225 .id
= VIVI_CID_CUSTOM_BASE
+ 1,
1227 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
1234 static const struct v4l2_ctrl_config vivi_ctrl_int32
= {
1235 .ops
= &vivi_ctrl_ops
,
1236 .id
= VIVI_CID_CUSTOM_BASE
+ 2,
1237 .name
= "Integer 32 Bits",
1238 .type
= V4L2_CTRL_TYPE_INTEGER
,
1244 static const struct v4l2_ctrl_config vivi_ctrl_int64
= {
1245 .ops
= &vivi_ctrl_ops
,
1246 .id
= VIVI_CID_CUSTOM_BASE
+ 3,
1247 .name
= "Integer 64 Bits",
1248 .type
= V4L2_CTRL_TYPE_INTEGER64
,
1251 static const char * const vivi_ctrl_menu_strings
[] = {
1252 "Menu Item 0 (Skipped)",
1254 "Menu Item 2 (Skipped)",
1257 "Menu Item 5 (Skipped)",
1261 static const struct v4l2_ctrl_config vivi_ctrl_menu
= {
1262 .ops
= &vivi_ctrl_ops
,
1263 .id
= VIVI_CID_CUSTOM_BASE
+ 4,
1265 .type
= V4L2_CTRL_TYPE_MENU
,
1269 .menu_skip_mask
= 0x04,
1270 .qmenu
= vivi_ctrl_menu_strings
,
1273 static const struct v4l2_ctrl_config vivi_ctrl_string
= {
1274 .ops
= &vivi_ctrl_ops
,
1275 .id
= VIVI_CID_CUSTOM_BASE
+ 5,
1277 .type
= V4L2_CTRL_TYPE_STRING
,
1283 static const struct v4l2_ctrl_config vivi_ctrl_bitmask
= {
1284 .ops
= &vivi_ctrl_ops
,
1285 .id
= VIVI_CID_CUSTOM_BASE
+ 6,
1287 .type
= V4L2_CTRL_TYPE_BITMASK
,
1294 static const s64 vivi_ctrl_int_menu_values
[] = {
1295 1, 1, 2, 3, 5, 8, 13, 21, 42,
1298 static const struct v4l2_ctrl_config vivi_ctrl_int_menu
= {
1299 .ops
= &vivi_ctrl_ops
,
1300 .id
= VIVI_CID_CUSTOM_BASE
+ 7,
1301 .name
= "Integer menu",
1302 .type
= V4L2_CTRL_TYPE_INTEGER_MENU
,
1306 .menu_skip_mask
= 0x02,
1307 .qmenu_int
= vivi_ctrl_int_menu_values
,
1310 static const struct v4l2_file_operations vivi_fops
= {
1311 .owner
= THIS_MODULE
,
1312 .open
= v4l2_fh_open
,
1313 .release
= vb2_fop_release
,
1314 .read
= vb2_fop_read
,
1315 .poll
= vb2_fop_poll
,
1316 .unlocked_ioctl
= video_ioctl2
, /* V4L2 ioctl handler */
1317 .mmap
= vb2_fop_mmap
,
1320 static const struct v4l2_ioctl_ops vivi_ioctl_ops
= {
1321 .vidioc_querycap
= vidioc_querycap
,
1322 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1323 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1324 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1325 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1326 .vidioc_enum_framesizes
= vidioc_enum_framesizes
,
1327 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
1328 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
1329 .vidioc_prepare_buf
= vb2_ioctl_prepare_buf
,
1330 .vidioc_querybuf
= vb2_ioctl_querybuf
,
1331 .vidioc_qbuf
= vb2_ioctl_qbuf
,
1332 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
1333 .vidioc_enum_input
= vidioc_enum_input
,
1334 .vidioc_g_input
= vidioc_g_input
,
1335 .vidioc_s_input
= vidioc_s_input
,
1336 .vidioc_enum_frameintervals
= vidioc_enum_frameintervals
,
1337 .vidioc_g_parm
= vidioc_g_parm
,
1338 .vidioc_s_parm
= vidioc_s_parm
,
1339 .vidioc_streamon
= vb2_ioctl_streamon
,
1340 .vidioc_streamoff
= vb2_ioctl_streamoff
,
1341 .vidioc_log_status
= v4l2_ctrl_log_status
,
1342 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1343 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1346 static const struct video_device vivi_template
= {
1349 .ioctl_ops
= &vivi_ioctl_ops
,
1350 .release
= video_device_release_empty
,
1353 /* -----------------------------------------------------------------
1354 Initialization and module stuff
1355 ------------------------------------------------------------------*/
1357 static int vivi_release(void)
1359 struct vivi_dev
*dev
;
1360 struct list_head
*list
;
1362 while (!list_empty(&vivi_devlist
)) {
1363 list
= vivi_devlist
.next
;
1365 dev
= list_entry(list
, struct vivi_dev
, vivi_devlist
);
1367 v4l2_info(&dev
->v4l2_dev
, "unregistering %s\n",
1368 video_device_node_name(&dev
->vdev
));
1369 video_unregister_device(&dev
->vdev
);
1370 v4l2_device_unregister(&dev
->v4l2_dev
);
1371 v4l2_ctrl_handler_free(&dev
->ctrl_handler
);
1378 static int __init
vivi_create_instance(int inst
)
1380 struct vivi_dev
*dev
;
1381 struct video_device
*vfd
;
1382 struct v4l2_ctrl_handler
*hdl
;
1383 struct vb2_queue
*q
;
1386 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1390 snprintf(dev
->v4l2_dev
.name
, sizeof(dev
->v4l2_dev
.name
),
1391 "%s-%03d", VIVI_MODULE_NAME
, inst
);
1392 ret
= v4l2_device_register(NULL
, &dev
->v4l2_dev
);
1396 dev
->fmt
= &formats
[0];
1397 dev
->timeperframe
= tpf_default
;
1400 dev
->pixelsize
= dev
->fmt
->depth
/ 8;
1401 hdl
= &dev
->ctrl_handler
;
1402 v4l2_ctrl_handler_init(hdl
, 11);
1403 dev
->volume
= v4l2_ctrl_new_std(hdl
, &vivi_ctrl_ops
,
1404 V4L2_CID_AUDIO_VOLUME
, 0, 255, 1, 200);
1405 dev
->brightness
= v4l2_ctrl_new_std(hdl
, &vivi_ctrl_ops
,
1406 V4L2_CID_BRIGHTNESS
, 0, 255, 1, 127);
1407 dev
->contrast
= v4l2_ctrl_new_std(hdl
, &vivi_ctrl_ops
,
1408 V4L2_CID_CONTRAST
, 0, 255, 1, 16);
1409 dev
->saturation
= v4l2_ctrl_new_std(hdl
, &vivi_ctrl_ops
,
1410 V4L2_CID_SATURATION
, 0, 255, 1, 127);
1411 dev
->hue
= v4l2_ctrl_new_std(hdl
, &vivi_ctrl_ops
,
1412 V4L2_CID_HUE
, -128, 127, 1, 0);
1413 dev
->autogain
= v4l2_ctrl_new_std(hdl
, &vivi_ctrl_ops
,
1414 V4L2_CID_AUTOGAIN
, 0, 1, 1, 1);
1415 dev
->gain
= v4l2_ctrl_new_std(hdl
, &vivi_ctrl_ops
,
1416 V4L2_CID_GAIN
, 0, 255, 1, 100);
1417 dev
->alpha
= v4l2_ctrl_new_std(hdl
, &vivi_ctrl_ops
,
1418 V4L2_CID_ALPHA_COMPONENT
, 0, 255, 1, 0);
1419 dev
->button
= v4l2_ctrl_new_custom(hdl
, &vivi_ctrl_button
, NULL
);
1420 dev
->int32
= v4l2_ctrl_new_custom(hdl
, &vivi_ctrl_int32
, NULL
);
1421 dev
->int64
= v4l2_ctrl_new_custom(hdl
, &vivi_ctrl_int64
, NULL
);
1422 dev
->boolean
= v4l2_ctrl_new_custom(hdl
, &vivi_ctrl_boolean
, NULL
);
1423 dev
->menu
= v4l2_ctrl_new_custom(hdl
, &vivi_ctrl_menu
, NULL
);
1424 dev
->string
= v4l2_ctrl_new_custom(hdl
, &vivi_ctrl_string
, NULL
);
1425 dev
->bitmask
= v4l2_ctrl_new_custom(hdl
, &vivi_ctrl_bitmask
, NULL
);
1426 dev
->int_menu
= v4l2_ctrl_new_custom(hdl
, &vivi_ctrl_int_menu
, NULL
);
1431 v4l2_ctrl_auto_cluster(2, &dev
->autogain
, 0, true);
1432 dev
->v4l2_dev
.ctrl_handler
= hdl
;
1434 /* initialize locks */
1435 spin_lock_init(&dev
->slock
);
1437 /* initialize queue */
1439 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1440 q
->io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
| VB2_READ
;
1442 q
->buf_struct_size
= sizeof(struct vivi_buffer
);
1443 q
->ops
= &vivi_video_qops
;
1444 q
->mem_ops
= &vb2_vmalloc_memops
;
1445 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1447 ret
= vb2_queue_init(q
);
1451 mutex_init(&dev
->mutex
);
1453 /* init video dma queues */
1454 INIT_LIST_HEAD(&dev
->vidq
.active
);
1455 init_waitqueue_head(&dev
->vidq
.wq
);
1458 *vfd
= vivi_template
;
1460 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
1462 set_bit(V4L2_FL_USE_FH_PRIO
, &vfd
->flags
);
1465 * Provide a mutex to v4l2 core. It will be used to protect
1466 * all fops and v4l2 ioctls.
1468 vfd
->lock
= &dev
->mutex
;
1469 video_set_drvdata(vfd
, dev
);
1471 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, video_nr
);
1475 /* Now that everything is fine, let's add it to device list */
1476 list_add_tail(&dev
->vivi_devlist
, &vivi_devlist
);
1478 v4l2_info(&dev
->v4l2_dev
, "V4L2 device registered as %s\n",
1479 video_device_node_name(vfd
));
1483 v4l2_ctrl_handler_free(hdl
);
1484 v4l2_device_unregister(&dev
->v4l2_dev
);
1490 /* This routine allocates from 1 to n_devs virtual drivers.
1492 The real maximum number of virtual drivers will depend on how many drivers
1493 will succeed. This is limited to the maximum number of devices that
1494 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1496 static int __init
vivi_init(void)
1498 const struct font_desc
*font
= find_font("VGA8x16");
1502 printk(KERN_ERR
"vivi: could not find font\n");
1505 font8x16
= font
->data
;
1510 for (i
= 0; i
< n_devs
; i
++) {
1511 ret
= vivi_create_instance(i
);
1513 /* If some instantiations succeeded, keep driver */
1521 printk(KERN_ERR
"vivi: error %d while loading driver\n", ret
);
1525 printk(KERN_INFO
"Video Technology Magazine Virtual Video "
1526 "Capture Board ver %s successfully loaded.\n",
1529 /* n_devs will reflect the actual number of allocated devices */
1535 static void __exit
vivi_exit(void)
1540 module_init(vivi_init
);
1541 module_exit(vivi_exit
);