1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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>
36
37#define VIVI_MODULE_NAME "vivi"
38
39
40
41
42
43
44
45
46
47
48
49#define FPS_MAX 1000
50
51#define MAX_WIDTH 1920
52#define MAX_HEIGHT 1200
53
54#define VIVI_VERSION "0.8.1"
55
56MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
57MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
58MODULE_LICENSE("Dual BSD/GPL");
59MODULE_VERSION(VIVI_VERSION);
60
61static unsigned video_nr = -1;
62module_param(video_nr, uint, 0644);
63MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect");
64
65static unsigned n_devs = 1;
66module_param(n_devs, uint, 0644);
67MODULE_PARM_DESC(n_devs, "number of video devices to create");
68
69static unsigned debug;
70module_param(debug, uint, 0644);
71MODULE_PARM_DESC(debug, "activates debug info");
72
73static unsigned int vid_limit = 16;
74module_param(vid_limit, uint, 0644);
75MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
76
77
78static const u8 *font8x16;
79
80
81static const struct v4l2_fract
82 tpf_min = {.numerator = 1, .denominator = FPS_MAX},
83 tpf_max = {.numerator = FPS_MAX, .denominator = 1},
84 tpf_default = {.numerator = 1001, .denominator = 30000};
85
86#define dprintk(dev, level, fmt, arg...) \
87 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
88
89
90
91
92
93struct vivi_fmt {
94 const char *name;
95 u32 fourcc;
96 u8 depth;
97 bool is_yuv;
98};
99
100static const struct vivi_fmt formats[] = {
101 {
102 .name = "4:2:2, packed, YUYV",
103 .fourcc = V4L2_PIX_FMT_YUYV,
104 .depth = 16,
105 .is_yuv = true,
106 },
107 {
108 .name = "4:2:2, packed, UYVY",
109 .fourcc = V4L2_PIX_FMT_UYVY,
110 .depth = 16,
111 .is_yuv = true,
112 },
113 {
114 .name = "4:2:2, packed, YVYU",
115 .fourcc = V4L2_PIX_FMT_YVYU,
116 .depth = 16,
117 .is_yuv = true,
118 },
119 {
120 .name = "4:2:2, packed, VYUY",
121 .fourcc = V4L2_PIX_FMT_VYUY,
122 .depth = 16,
123 .is_yuv = true,
124 },
125 {
126 .name = "RGB565 (LE)",
127 .fourcc = V4L2_PIX_FMT_RGB565,
128 .depth = 16,
129 },
130 {
131 .name = "RGB565 (BE)",
132 .fourcc = V4L2_PIX_FMT_RGB565X,
133 .depth = 16,
134 },
135 {
136 .name = "RGB555 (LE)",
137 .fourcc = V4L2_PIX_FMT_RGB555,
138 .depth = 16,
139 },
140 {
141 .name = "RGB555 (BE)",
142 .fourcc = V4L2_PIX_FMT_RGB555X,
143 .depth = 16,
144 },
145 {
146 .name = "RGB24 (LE)",
147 .fourcc = V4L2_PIX_FMT_RGB24,
148 .depth = 24,
149 },
150 {
151 .name = "RGB24 (BE)",
152 .fourcc = V4L2_PIX_FMT_BGR24,
153 .depth = 24,
154 },
155 {
156 .name = "RGB32 (LE)",
157 .fourcc = V4L2_PIX_FMT_RGB32,
158 .depth = 32,
159 },
160 {
161 .name = "RGB32 (BE)",
162 .fourcc = V4L2_PIX_FMT_BGR32,
163 .depth = 32,
164 },
165};
166
167static const struct vivi_fmt *__get_format(u32 pixelformat)
168{
169 const struct vivi_fmt *fmt;
170 unsigned int k;
171
172 for (k = 0; k < ARRAY_SIZE(formats); k++) {
173 fmt = &formats[k];
174 if (fmt->fourcc == pixelformat)
175 break;
176 }
177
178 if (k == ARRAY_SIZE(formats))
179 return NULL;
180
181 return &formats[k];
182}
183
184static const struct vivi_fmt *get_format(struct v4l2_format *f)
185{
186 return __get_format(f->fmt.pix.pixelformat);
187}
188
189
190struct vivi_buffer {
191
192 struct vb2_buffer vb;
193 struct list_head list;
194 const struct vivi_fmt *fmt;
195};
196
197struct vivi_dmaqueue {
198 struct list_head active;
199
200
201 struct task_struct *kthread;
202 wait_queue_head_t wq;
203
204 int frame;
205 int ini_jiffies;
206};
207
208static LIST_HEAD(vivi_devlist);
209
210struct vivi_dev {
211 struct list_head vivi_devlist;
212 struct v4l2_device v4l2_dev;
213 struct v4l2_ctrl_handler ctrl_handler;
214 struct video_device vdev;
215
216
217 struct v4l2_ctrl *brightness;
218 struct v4l2_ctrl *contrast;
219 struct v4l2_ctrl *saturation;
220 struct v4l2_ctrl *hue;
221 struct {
222
223 struct v4l2_ctrl *autogain;
224 struct v4l2_ctrl *gain;
225 };
226 struct v4l2_ctrl *volume;
227 struct v4l2_ctrl *alpha;
228 struct v4l2_ctrl *button;
229 struct v4l2_ctrl *boolean;
230 struct v4l2_ctrl *int32;
231 struct v4l2_ctrl *int64;
232 struct v4l2_ctrl *menu;
233 struct v4l2_ctrl *string;
234 struct v4l2_ctrl *bitmask;
235 struct v4l2_ctrl *int_menu;
236
237 spinlock_t slock;
238 struct mutex mutex;
239
240 struct vivi_dmaqueue vidq;
241
242
243 unsigned ms;
244 unsigned long jiffies;
245 unsigned button_pressed;
246
247 int mv_count;
248
249
250 int input;
251
252
253 const struct vivi_fmt *fmt;
254 struct v4l2_fract timeperframe;
255 unsigned int width, height;
256 struct vb2_queue vb_vidq;
257 unsigned int field_count;
258
259 u8 bars[9][3];
260 u8 line[MAX_WIDTH * 8] __attribute__((__aligned__(4)));
261 unsigned int pixelsize;
262 u8 alpha_component;
263 u32 textfg, textbg;
264};
265
266
267
268
269
270
271
272enum colors {
273 WHITE,
274 AMBER,
275 CYAN,
276 GREEN,
277 MAGENTA,
278 RED,
279 BLUE,
280 BLACK,
281 TEXT_BLACK,
282};
283
284
285#define COLOR_WHITE {204, 204, 204}
286#define COLOR_AMBER {208, 208, 0}
287#define COLOR_CYAN { 0, 206, 206}
288#define COLOR_GREEN { 0, 239, 0}
289#define COLOR_MAGENTA {239, 0, 239}
290#define COLOR_RED {205, 0, 0}
291#define COLOR_BLUE { 0, 0, 255}
292#define COLOR_BLACK { 0, 0, 0}
293
294struct bar_std {
295 u8 bar[9][3];
296};
297
298
299
300static const struct bar_std bars[] = {
301 {
302 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
303 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
304 }, {
305 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
306 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
307 }, {
308 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
309 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
310 }, {
311 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
312 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
313 },
314};
315
316#define NUM_INPUTS ARRAY_SIZE(bars)
317
318#define TO_Y(r, g, b) \
319 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
320
321#define TO_V(r, g, b) \
322 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
323
324#define TO_U(r, g, b) \
325 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
326
327
328static void precalculate_bars(struct vivi_dev *dev)
329{
330 u8 r, g, b;
331 int k, is_yuv;
332
333 for (k = 0; k < 9; k++) {
334 r = bars[dev->input].bar[k][0];
335 g = bars[dev->input].bar[k][1];
336 b = bars[dev->input].bar[k][2];
337 is_yuv = dev->fmt->is_yuv;
338
339 switch (dev->fmt->fourcc) {
340 case V4L2_PIX_FMT_RGB565:
341 case V4L2_PIX_FMT_RGB565X:
342 r >>= 3;
343 g >>= 2;
344 b >>= 3;
345 break;
346 case V4L2_PIX_FMT_RGB555:
347 case V4L2_PIX_FMT_RGB555X:
348 r >>= 3;
349 g >>= 3;
350 b >>= 3;
351 break;
352 case V4L2_PIX_FMT_YUYV:
353 case V4L2_PIX_FMT_UYVY:
354 case V4L2_PIX_FMT_YVYU:
355 case V4L2_PIX_FMT_VYUY:
356 case V4L2_PIX_FMT_RGB24:
357 case V4L2_PIX_FMT_BGR24:
358 case V4L2_PIX_FMT_RGB32:
359 case V4L2_PIX_FMT_BGR32:
360 break;
361 }
362
363 if (is_yuv) {
364 dev->bars[k][0] = TO_Y(r, g, b);
365 dev->bars[k][1] = TO_U(r, g, b);
366 dev->bars[k][2] = TO_V(r, g, b);
367 } else {
368 dev->bars[k][0] = r;
369 dev->bars[k][1] = g;
370 dev->bars[k][2] = b;
371 }
372 }
373}
374
375
376static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos, bool odd)
377{
378 u8 r_y, g_u, b_v;
379 u8 alpha = dev->alpha_component;
380 int color;
381 u8 *p;
382
383 r_y = dev->bars[colorpos][0];
384 g_u = dev->bars[colorpos][1];
385 b_v = dev->bars[colorpos][2];
386
387 for (color = 0; color < dev->pixelsize; color++) {
388 p = buf + color;
389
390 switch (dev->fmt->fourcc) {
391 case V4L2_PIX_FMT_YUYV:
392 switch (color) {
393 case 0:
394 *p = r_y;
395 break;
396 case 1:
397 *p = odd ? b_v : g_u;
398 break;
399 }
400 break;
401 case V4L2_PIX_FMT_UYVY:
402 switch (color) {
403 case 0:
404 *p = odd ? b_v : g_u;
405 break;
406 case 1:
407 *p = r_y;
408 break;
409 }
410 break;
411 case V4L2_PIX_FMT_YVYU:
412 switch (color) {
413 case 0:
414 *p = r_y;
415 break;
416 case 1:
417 *p = odd ? g_u : b_v;
418 break;
419 }
420 break;
421 case V4L2_PIX_FMT_VYUY:
422 switch (color) {
423 case 0:
424 *p = odd ? g_u : b_v;
425 break;
426 case 1:
427 *p = r_y;
428 break;
429 }
430 break;
431 case V4L2_PIX_FMT_RGB565:
432 switch (color) {
433 case 0:
434 *p = (g_u << 5) | b_v;
435 break;
436 case 1:
437 *p = (r_y << 3) | (g_u >> 3);
438 break;
439 }
440 break;
441 case V4L2_PIX_FMT_RGB565X:
442 switch (color) {
443 case 0:
444 *p = (r_y << 3) | (g_u >> 3);
445 break;
446 case 1:
447 *p = (g_u << 5) | b_v;
448 break;
449 }
450 break;
451 case V4L2_PIX_FMT_RGB555:
452 switch (color) {
453 case 0:
454 *p = (g_u << 5) | b_v;
455 break;
456 case 1:
457 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
458 break;
459 }
460 break;
461 case V4L2_PIX_FMT_RGB555X:
462 switch (color) {
463 case 0:
464 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
465 break;
466 case 1:
467 *p = (g_u << 5) | b_v;
468 break;
469 }
470 break;
471 case V4L2_PIX_FMT_RGB24:
472 switch (color) {
473 case 0:
474 *p = r_y;
475 break;
476 case 1:
477 *p = g_u;
478 break;
479 case 2:
480 *p = b_v;
481 break;
482 }
483 break;
484 case V4L2_PIX_FMT_BGR24:
485 switch (color) {
486 case 0:
487 *p = b_v;
488 break;
489 case 1:
490 *p = g_u;
491 break;
492 case 2:
493 *p = r_y;
494 break;
495 }
496 break;
497 case V4L2_PIX_FMT_RGB32:
498 switch (color) {
499 case 0:
500 *p = alpha;
501 break;
502 case 1:
503 *p = r_y;
504 break;
505 case 2:
506 *p = g_u;
507 break;
508 case 3:
509 *p = b_v;
510 break;
511 }
512 break;
513 case V4L2_PIX_FMT_BGR32:
514 switch (color) {
515 case 0:
516 *p = b_v;
517 break;
518 case 1:
519 *p = g_u;
520 break;
521 case 2:
522 *p = r_y;
523 break;
524 case 3:
525 *p = alpha;
526 break;
527 }
528 break;
529 }
530 }
531}
532
533static void precalculate_line(struct vivi_dev *dev)
534{
535 unsigned pixsize = dev->pixelsize;
536 unsigned pixsize2 = 2*pixsize;
537 int colorpos;
538 u8 *pos;
539
540 for (colorpos = 0; colorpos < 16; ++colorpos) {
541 u8 pix[8];
542 int wstart = colorpos * dev->width / 8;
543 int wend = (colorpos+1) * dev->width / 8;
544 int w;
545
546 gen_twopix(dev, &pix[0], colorpos % 8, 0);
547 gen_twopix(dev, &pix[pixsize], colorpos % 8, 1);
548
549 for (w = wstart/2*2, pos = dev->line + w*pixsize; w < wend; w += 2, pos += pixsize2)
550 memcpy(pos, pix, pixsize2);
551 }
552}
553
554
555typedef struct { u16 __; u8 _; } __attribute__((packed)) x24;
556
557static void gen_text(struct vivi_dev *dev, char *basep,
558 int y, int x, char *text)
559{
560 int line;
561 unsigned int width = dev->width;
562
563
564 if (y + 16 >= dev->height || x + strlen(text) * 8 >= width)
565 return;
566
567
568#define PRINTSTR(PIXTYPE) do { \
569 PIXTYPE fg; \
570 PIXTYPE bg; \
571 memcpy(&fg, &dev->textfg, sizeof(PIXTYPE)); \
572 memcpy(&bg, &dev->textbg, sizeof(PIXTYPE)); \
573 \
574 for (line = 0; line < 16; line++) { \
575 PIXTYPE *pos = (PIXTYPE *)( basep + ((y + line) * width + x) * sizeof(PIXTYPE) ); \
576 u8 *s; \
577 \
578 for (s = text; *s; s++) { \
579 u8 chr = font8x16[*s * 16 + line]; \
580 \
581 pos[0] = (chr & (0x01 << 7) ? fg : bg); \
582 pos[1] = (chr & (0x01 << 6) ? fg : bg); \
583 pos[2] = (chr & (0x01 << 5) ? fg : bg); \
584 pos[3] = (chr & (0x01 << 4) ? fg : bg); \
585 pos[4] = (chr & (0x01 << 3) ? fg : bg); \
586 pos[5] = (chr & (0x01 << 2) ? fg : bg); \
587 pos[6] = (chr & (0x01 << 1) ? fg : bg); \
588 pos[7] = (chr & (0x01 << 0) ? fg : bg); \
589 \
590 pos += 8; \
591 } \
592 } \
593} while (0)
594
595 switch (dev->pixelsize) {
596 case 2:
597 PRINTSTR(u16); break;
598 case 4:
599 PRINTSTR(u32); break;
600 case 3:
601 PRINTSTR(x24); break;
602 }
603}
604
605static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
606{
607 int stride = dev->width * dev->pixelsize;
608 int hmax = dev->height;
609 void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
610 unsigned ms;
611 char str[100];
612 int h, line = 1;
613 u8 *linestart;
614 s32 gain;
615
616 if (!vbuf)
617 return;
618
619 linestart = dev->line + (dev->mv_count % dev->width) * dev->pixelsize;
620
621 for (h = 0; h < hmax; h++)
622 memcpy(vbuf + h * stride, linestart, stride);
623
624
625
626 gen_twopix(dev, (u8 *)&dev->textbg, TEXT_BLACK, 0);
627 gen_twopix(dev, (u8 *)&dev->textfg, WHITE, 0);
628
629 dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
630 dev->jiffies = jiffies;
631 ms = dev->ms;
632 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
633 (ms / (60 * 60 * 1000)) % 24,
634 (ms / (60 * 1000)) % 60,
635 (ms / 1000) % 60,
636 ms % 1000);
637 gen_text(dev, vbuf, line++ * 16, 16, str);
638 snprintf(str, sizeof(str), " %dx%d, input %d ",
639 dev->width, dev->height, dev->input);
640 gen_text(dev, vbuf, line++ * 16, 16, str);
641
642 gain = v4l2_ctrl_g_ctrl(dev->gain);
643 mutex_lock(dev->ctrl_handler.lock);
644 snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
645 dev->brightness->cur.val,
646 dev->contrast->cur.val,
647 dev->saturation->cur.val,
648 dev->hue->cur.val);
649 gen_text(dev, vbuf, line++ * 16, 16, str);
650 snprintf(str, sizeof(str), " autogain %d, gain %3d, volume %3d, alpha 0x%02x ",
651 dev->autogain->cur.val, gain, dev->volume->cur.val,
652 dev->alpha->cur.val);
653 gen_text(dev, vbuf, line++ * 16, 16, str);
654 snprintf(str, sizeof(str), " int32 %d, int64 %lld, bitmask %08x ",
655 dev->int32->cur.val,
656 dev->int64->cur.val64,
657 dev->bitmask->cur.val);
658 gen_text(dev, vbuf, line++ * 16, 16, str);
659 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
660 dev->boolean->cur.val,
661 dev->menu->qmenu[dev->menu->cur.val],
662 dev->string->cur.string);
663 gen_text(dev, vbuf, line++ * 16, 16, str);
664 snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
665 dev->int_menu->qmenu_int[dev->int_menu->cur.val],
666 dev->int_menu->cur.val);
667 gen_text(dev, vbuf, line++ * 16, 16, str);
668 mutex_unlock(dev->ctrl_handler.lock);
669 if (dev->button_pressed) {
670 dev->button_pressed--;
671 snprintf(str, sizeof(str), " button pressed!");
672 gen_text(dev, vbuf, line++ * 16, 16, str);
673 }
674
675 dev->mv_count += 2;
676
677 buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
678 dev->field_count++;
679 buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
680 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
681}
682
683static void vivi_thread_tick(struct vivi_dev *dev)
684{
685 struct vivi_dmaqueue *dma_q = &dev->vidq;
686 struct vivi_buffer *buf;
687 unsigned long flags = 0;
688
689 dprintk(dev, 1, "Thread tick\n");
690
691 spin_lock_irqsave(&dev->slock, flags);
692 if (list_empty(&dma_q->active)) {
693 dprintk(dev, 1, "No active queue to serve\n");
694 spin_unlock_irqrestore(&dev->slock, flags);
695 return;
696 }
697
698 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
699 list_del(&buf->list);
700 spin_unlock_irqrestore(&dev->slock, flags);
701
702 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
703
704
705 vivi_fillbuff(dev, buf);
706 dprintk(dev, 1, "filled buffer %p\n", buf);
707
708 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
709 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
710}
711
712#define frames_to_ms(dev, frames) \
713 ((frames * dev->timeperframe.numerator * 1000) / dev->timeperframe.denominator)
714
715static void vivi_sleep(struct vivi_dev *dev)
716{
717 struct vivi_dmaqueue *dma_q = &dev->vidq;
718 int timeout;
719 DECLARE_WAITQUEUE(wait, current);
720
721 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
722 (unsigned long)dma_q);
723
724 add_wait_queue(&dma_q->wq, &wait);
725 if (kthread_should_stop())
726 goto stop_task;
727
728
729 timeout = msecs_to_jiffies(frames_to_ms(dev, 1));
730
731 vivi_thread_tick(dev);
732
733 schedule_timeout_interruptible(timeout);
734
735stop_task:
736 remove_wait_queue(&dma_q->wq, &wait);
737 try_to_freeze();
738}
739
740static int vivi_thread(void *data)
741{
742 struct vivi_dev *dev = data;
743
744 dprintk(dev, 1, "thread started\n");
745
746 set_freezable();
747
748 for (;;) {
749 vivi_sleep(dev);
750
751 if (kthread_should_stop())
752 break;
753 }
754 dprintk(dev, 1, "thread: exit\n");
755 return 0;
756}
757
758static int vivi_start_generating(struct vivi_dev *dev)
759{
760 struct vivi_dmaqueue *dma_q = &dev->vidq;
761
762 dprintk(dev, 1, "%s\n", __func__);
763
764
765 dev->ms = 0;
766 dev->mv_count = 0;
767 dev->jiffies = jiffies;
768
769 dma_q->frame = 0;
770 dma_q->ini_jiffies = jiffies;
771 dma_q->kthread = kthread_run(vivi_thread, dev, "%s",
772 dev->v4l2_dev.name);
773
774 if (IS_ERR(dma_q->kthread)) {
775 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
776 return PTR_ERR(dma_q->kthread);
777 }
778
779 wake_up_interruptible(&dma_q->wq);
780
781 dprintk(dev, 1, "returning from %s\n", __func__);
782 return 0;
783}
784
785static void vivi_stop_generating(struct vivi_dev *dev)
786{
787 struct vivi_dmaqueue *dma_q = &dev->vidq;
788
789 dprintk(dev, 1, "%s\n", __func__);
790
791
792 if (dma_q->kthread) {
793 kthread_stop(dma_q->kthread);
794 dma_q->kthread = NULL;
795 }
796
797
798
799
800
801
802
803 while (!list_empty(&dma_q->active)) {
804 struct vivi_buffer *buf;
805 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
806 list_del(&buf->list);
807 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
808 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
809 }
810}
811
812
813
814static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
815 unsigned int *nbuffers, unsigned int *nplanes,
816 unsigned int sizes[], void *alloc_ctxs[])
817{
818 struct vivi_dev *dev = vb2_get_drv_priv(vq);
819 unsigned long size;
820
821 if (fmt)
822 size = fmt->fmt.pix.sizeimage;
823 else
824 size = dev->width * dev->height * dev->pixelsize;
825
826 if (size == 0)
827 return -EINVAL;
828
829 if (0 == *nbuffers)
830 *nbuffers = 32;
831
832 while (size * *nbuffers > vid_limit * 1024 * 1024)
833 (*nbuffers)--;
834
835 *nplanes = 1;
836
837 sizes[0] = size;
838
839
840
841
842
843
844 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
845 *nbuffers, size);
846
847 return 0;
848}
849
850static int buffer_prepare(struct vb2_buffer *vb)
851{
852 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
853 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
854 unsigned long size;
855
856 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
857
858 BUG_ON(NULL == dev->fmt);
859
860
861
862
863
864
865
866 if (dev->width < 48 || dev->width > MAX_WIDTH ||
867 dev->height < 32 || dev->height > MAX_HEIGHT)
868 return -EINVAL;
869
870 size = dev->width * dev->height * dev->pixelsize;
871 if (vb2_plane_size(vb, 0) < size) {
872 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
873 __func__, vb2_plane_size(vb, 0), size);
874 return -EINVAL;
875 }
876
877 vb2_set_plane_payload(&buf->vb, 0, size);
878
879 buf->fmt = dev->fmt;
880
881 precalculate_bars(dev);
882 precalculate_line(dev);
883
884 return 0;
885}
886
887static void buffer_queue(struct vb2_buffer *vb)
888{
889 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
890 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
891 struct vivi_dmaqueue *vidq = &dev->vidq;
892 unsigned long flags = 0;
893
894 dprintk(dev, 1, "%s\n", __func__);
895
896 spin_lock_irqsave(&dev->slock, flags);
897 list_add_tail(&buf->list, &vidq->active);
898 spin_unlock_irqrestore(&dev->slock, flags);
899}
900
901static int start_streaming(struct vb2_queue *vq, unsigned int count)
902{
903 struct vivi_dev *dev = vb2_get_drv_priv(vq);
904 dprintk(dev, 1, "%s\n", __func__);
905 return vivi_start_generating(dev);
906}
907
908
909static int stop_streaming(struct vb2_queue *vq)
910{
911 struct vivi_dev *dev = vb2_get_drv_priv(vq);
912 dprintk(dev, 1, "%s\n", __func__);
913 vivi_stop_generating(dev);
914 return 0;
915}
916
917static void vivi_lock(struct vb2_queue *vq)
918{
919 struct vivi_dev *dev = vb2_get_drv_priv(vq);
920 mutex_lock(&dev->mutex);
921}
922
923static void vivi_unlock(struct vb2_queue *vq)
924{
925 struct vivi_dev *dev = vb2_get_drv_priv(vq);
926 mutex_unlock(&dev->mutex);
927}
928
929
930static const struct vb2_ops vivi_video_qops = {
931 .queue_setup = queue_setup,
932 .buf_prepare = buffer_prepare,
933 .buf_queue = buffer_queue,
934 .start_streaming = start_streaming,
935 .stop_streaming = stop_streaming,
936 .wait_prepare = vivi_unlock,
937 .wait_finish = vivi_lock,
938};
939
940
941
942
943static int vidioc_querycap(struct file *file, void *priv,
944 struct v4l2_capability *cap)
945{
946 struct vivi_dev *dev = video_drvdata(file);
947
948 strcpy(cap->driver, "vivi");
949 strcpy(cap->card, "vivi");
950 snprintf(cap->bus_info, sizeof(cap->bus_info),
951 "platform:%s", dev->v4l2_dev.name);
952 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
953 V4L2_CAP_READWRITE;
954 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
955 return 0;
956}
957
958static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
959 struct v4l2_fmtdesc *f)
960{
961 const struct vivi_fmt *fmt;
962
963 if (f->index >= ARRAY_SIZE(formats))
964 return -EINVAL;
965
966 fmt = &formats[f->index];
967
968 strlcpy(f->description, fmt->name, sizeof(f->description));
969 f->pixelformat = fmt->fourcc;
970 return 0;
971}
972
973static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
974 struct v4l2_format *f)
975{
976 struct vivi_dev *dev = video_drvdata(file);
977
978 f->fmt.pix.width = dev->width;
979 f->fmt.pix.height = dev->height;
980 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
981 f->fmt.pix.pixelformat = dev->fmt->fourcc;
982 f->fmt.pix.bytesperline =
983 (f->fmt.pix.width * dev->fmt->depth) >> 3;
984 f->fmt.pix.sizeimage =
985 f->fmt.pix.height * f->fmt.pix.bytesperline;
986 if (dev->fmt->is_yuv)
987 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
988 else
989 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
990 return 0;
991}
992
993static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
994 struct v4l2_format *f)
995{
996 struct vivi_dev *dev = video_drvdata(file);
997 const struct vivi_fmt *fmt;
998
999 fmt = get_format(f);
1000 if (!fmt) {
1001 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
1002 f->fmt.pix.pixelformat);
1003 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1004 fmt = get_format(f);
1005 }
1006
1007 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1008 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
1009 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
1010 f->fmt.pix.bytesperline =
1011 (f->fmt.pix.width * fmt->depth) >> 3;
1012 f->fmt.pix.sizeimage =
1013 f->fmt.pix.height * f->fmt.pix.bytesperline;
1014 if (fmt->is_yuv)
1015 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1016 else
1017 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
1018 f->fmt.pix.priv = 0;
1019 return 0;
1020}
1021
1022static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1023 struct v4l2_format *f)
1024{
1025 struct vivi_dev *dev = video_drvdata(file);
1026 struct vb2_queue *q = &dev->vb_vidq;
1027
1028 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
1029 if (ret < 0)
1030 return ret;
1031
1032 if (vb2_is_busy(q)) {
1033 dprintk(dev, 1, "%s device busy\n", __func__);
1034 return -EBUSY;
1035 }
1036
1037 dev->fmt = get_format(f);
1038 dev->pixelsize = dev->fmt->depth / 8;
1039 dev->width = f->fmt.pix.width;
1040 dev->height = f->fmt.pix.height;
1041
1042 return 0;
1043}
1044
1045static int vidioc_enum_framesizes(struct file *file, void *fh,
1046 struct v4l2_frmsizeenum *fsize)
1047{
1048 static const struct v4l2_frmsize_stepwise sizes = {
1049 48, MAX_WIDTH, 4,
1050 32, MAX_HEIGHT, 1
1051 };
1052 int i;
1053
1054 if (fsize->index)
1055 return -EINVAL;
1056 for (i = 0; i < ARRAY_SIZE(formats); i++)
1057 if (formats[i].fourcc == fsize->pixel_format)
1058 break;
1059 if (i == ARRAY_SIZE(formats))
1060 return -EINVAL;
1061 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1062 fsize->stepwise = sizes;
1063 return 0;
1064}
1065
1066
1067static int vidioc_enum_input(struct file *file, void *priv,
1068 struct v4l2_input *inp)
1069{
1070 if (inp->index >= NUM_INPUTS)
1071 return -EINVAL;
1072
1073 inp->type = V4L2_INPUT_TYPE_CAMERA;
1074 sprintf(inp->name, "Camera %u", inp->index);
1075 return 0;
1076}
1077
1078static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1079{
1080 struct vivi_dev *dev = video_drvdata(file);
1081
1082 *i = dev->input;
1083 return 0;
1084}
1085
1086static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1087{
1088 struct vivi_dev *dev = video_drvdata(file);
1089
1090 if (i >= NUM_INPUTS)
1091 return -EINVAL;
1092
1093 if (i == dev->input)
1094 return 0;
1095
1096 dev->input = i;
1097
1098
1099
1100
1101
1102
1103
1104 v4l2_ctrl_modify_range(dev->brightness,
1105 128 * i, 255 + 128 * i, 1, 127 + 128 * i);
1106 precalculate_bars(dev);
1107 precalculate_line(dev);
1108 return 0;
1109}
1110
1111
1112static int vidioc_enum_frameintervals(struct file *file, void *priv,
1113 struct v4l2_frmivalenum *fival)
1114{
1115 const struct vivi_fmt *fmt;
1116
1117 if (fival->index)
1118 return -EINVAL;
1119
1120 fmt = __get_format(fival->pixel_format);
1121 if (!fmt)
1122 return -EINVAL;
1123
1124
1125
1126 fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
1127
1128
1129 fival->stepwise.min = tpf_min;
1130 fival->stepwise.max = tpf_max;
1131 fival->stepwise.step = (struct v4l2_fract) {1, 1};
1132
1133 return 0;
1134}
1135
1136static int vidioc_g_parm(struct file *file, void *priv,
1137 struct v4l2_streamparm *parm)
1138{
1139 struct vivi_dev *dev = video_drvdata(file);
1140
1141 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1142 return -EINVAL;
1143
1144 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1145 parm->parm.capture.timeperframe = dev->timeperframe;
1146 parm->parm.capture.readbuffers = 1;
1147 return 0;
1148}
1149
1150#define FRACT_CMP(a, OP, b) \
1151 ((u64)(a).numerator * (b).denominator OP (u64)(b).numerator * (a).denominator)
1152
1153static int vidioc_s_parm(struct file *file, void *priv,
1154 struct v4l2_streamparm *parm)
1155{
1156 struct vivi_dev *dev = video_drvdata(file);
1157 struct v4l2_fract tpf;
1158
1159 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1160 return -EINVAL;
1161
1162 tpf = parm->parm.capture.timeperframe;
1163
1164
1165 tpf = tpf.denominator ? tpf : tpf_default;
1166 tpf = FRACT_CMP(tpf, <, tpf_min) ? tpf_min : tpf;
1167 tpf = FRACT_CMP(tpf, >, tpf_max) ? tpf_max : tpf;
1168
1169 dev->timeperframe = tpf;
1170 parm->parm.capture.timeperframe = tpf;
1171 parm->parm.capture.readbuffers = 1;
1172 return 0;
1173}
1174
1175
1176
1177static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1178{
1179 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1180
1181 if (ctrl == dev->autogain)
1182 dev->gain->val = jiffies & 0xff;
1183 return 0;
1184}
1185
1186static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1187{
1188 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1189
1190 switch (ctrl->id) {
1191 case V4L2_CID_ALPHA_COMPONENT:
1192 dev->alpha_component = ctrl->val;
1193 break;
1194 default:
1195 if (ctrl == dev->button)
1196 dev->button_pressed = 30;
1197 break;
1198 }
1199 return 0;
1200}
1201
1202
1203
1204
1205
1206static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1207 .g_volatile_ctrl = vivi_g_volatile_ctrl,
1208 .s_ctrl = vivi_s_ctrl,
1209};
1210
1211#define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1212
1213static const struct v4l2_ctrl_config vivi_ctrl_button = {
1214 .ops = &vivi_ctrl_ops,
1215 .id = VIVI_CID_CUSTOM_BASE + 0,
1216 .name = "Button",
1217 .type = V4L2_CTRL_TYPE_BUTTON,
1218};
1219
1220static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1221 .ops = &vivi_ctrl_ops,
1222 .id = VIVI_CID_CUSTOM_BASE + 1,
1223 .name = "Boolean",
1224 .type = V4L2_CTRL_TYPE_BOOLEAN,
1225 .min = 0,
1226 .max = 1,
1227 .step = 1,
1228 .def = 1,
1229};
1230
1231static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1232 .ops = &vivi_ctrl_ops,
1233 .id = VIVI_CID_CUSTOM_BASE + 2,
1234 .name = "Integer 32 Bits",
1235 .type = V4L2_CTRL_TYPE_INTEGER,
1236 .min = 0x80000000,
1237 .max = 0x7fffffff,
1238 .step = 1,
1239};
1240
1241static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1242 .ops = &vivi_ctrl_ops,
1243 .id = VIVI_CID_CUSTOM_BASE + 3,
1244 .name = "Integer 64 Bits",
1245 .type = V4L2_CTRL_TYPE_INTEGER64,
1246};
1247
1248static const char * const vivi_ctrl_menu_strings[] = {
1249 "Menu Item 0 (Skipped)",
1250 "Menu Item 1",
1251 "Menu Item 2 (Skipped)",
1252 "Menu Item 3",
1253 "Menu Item 4",
1254 "Menu Item 5 (Skipped)",
1255 NULL,
1256};
1257
1258static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1259 .ops = &vivi_ctrl_ops,
1260 .id = VIVI_CID_CUSTOM_BASE + 4,
1261 .name = "Menu",
1262 .type = V4L2_CTRL_TYPE_MENU,
1263 .min = 1,
1264 .max = 4,
1265 .def = 3,
1266 .menu_skip_mask = 0x04,
1267 .qmenu = vivi_ctrl_menu_strings,
1268};
1269
1270static const struct v4l2_ctrl_config vivi_ctrl_string = {
1271 .ops = &vivi_ctrl_ops,
1272 .id = VIVI_CID_CUSTOM_BASE + 5,
1273 .name = "String",
1274 .type = V4L2_CTRL_TYPE_STRING,
1275 .min = 2,
1276 .max = 4,
1277 .step = 1,
1278};
1279
1280static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1281 .ops = &vivi_ctrl_ops,
1282 .id = VIVI_CID_CUSTOM_BASE + 6,
1283 .name = "Bitmask",
1284 .type = V4L2_CTRL_TYPE_BITMASK,
1285 .def = 0x80002000,
1286 .min = 0,
1287 .max = 0x80402010,
1288 .step = 0,
1289};
1290
1291static const s64 vivi_ctrl_int_menu_values[] = {
1292 1, 1, 2, 3, 5, 8, 13, 21, 42,
1293};
1294
1295static const struct v4l2_ctrl_config vivi_ctrl_int_menu = {
1296 .ops = &vivi_ctrl_ops,
1297 .id = VIVI_CID_CUSTOM_BASE + 7,
1298 .name = "Integer menu",
1299 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
1300 .min = 1,
1301 .max = 8,
1302 .def = 4,
1303 .menu_skip_mask = 0x02,
1304 .qmenu_int = vivi_ctrl_int_menu_values,
1305};
1306
1307static const struct v4l2_file_operations vivi_fops = {
1308 .owner = THIS_MODULE,
1309 .open = v4l2_fh_open,
1310 .release = vb2_fop_release,
1311 .read = vb2_fop_read,
1312 .poll = vb2_fop_poll,
1313 .unlocked_ioctl = video_ioctl2,
1314 .mmap = vb2_fop_mmap,
1315};
1316
1317static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1318 .vidioc_querycap = vidioc_querycap,
1319 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1320 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1321 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1322 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1323 .vidioc_enum_framesizes = vidioc_enum_framesizes,
1324 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1325 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1326 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1327 .vidioc_querybuf = vb2_ioctl_querybuf,
1328 .vidioc_qbuf = vb2_ioctl_qbuf,
1329 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1330 .vidioc_enum_input = vidioc_enum_input,
1331 .vidioc_g_input = vidioc_g_input,
1332 .vidioc_s_input = vidioc_s_input,
1333 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1334 .vidioc_g_parm = vidioc_g_parm,
1335 .vidioc_s_parm = vidioc_s_parm,
1336 .vidioc_streamon = vb2_ioctl_streamon,
1337 .vidioc_streamoff = vb2_ioctl_streamoff,
1338 .vidioc_log_status = v4l2_ctrl_log_status,
1339 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1340 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1341};
1342
1343static const struct video_device vivi_template = {
1344 .name = "vivi",
1345 .fops = &vivi_fops,
1346 .ioctl_ops = &vivi_ioctl_ops,
1347 .release = video_device_release_empty,
1348};
1349
1350
1351
1352
1353
1354static int vivi_release(void)
1355{
1356 struct vivi_dev *dev;
1357 struct list_head *list;
1358
1359 while (!list_empty(&vivi_devlist)) {
1360 list = vivi_devlist.next;
1361 list_del(list);
1362 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1363
1364 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1365 video_device_node_name(&dev->vdev));
1366 video_unregister_device(&dev->vdev);
1367 v4l2_device_unregister(&dev->v4l2_dev);
1368 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1369 kfree(dev);
1370 }
1371
1372 return 0;
1373}
1374
1375static int __init vivi_create_instance(int inst)
1376{
1377 struct vivi_dev *dev;
1378 struct video_device *vfd;
1379 struct v4l2_ctrl_handler *hdl;
1380 struct vb2_queue *q;
1381 int ret;
1382
1383 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1384 if (!dev)
1385 return -ENOMEM;
1386
1387 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1388 "%s-%03d", VIVI_MODULE_NAME, inst);
1389 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1390 if (ret)
1391 goto free_dev;
1392
1393 dev->fmt = &formats[0];
1394 dev->timeperframe = tpf_default;
1395 dev->width = 640;
1396 dev->height = 480;
1397 dev->pixelsize = dev->fmt->depth / 8;
1398 hdl = &dev->ctrl_handler;
1399 v4l2_ctrl_handler_init(hdl, 11);
1400 dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1401 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1402 dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1403 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1404 dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1405 V4L2_CID_CONTRAST, 0, 255, 1, 16);
1406 dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1407 V4L2_CID_SATURATION, 0, 255, 1, 127);
1408 dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1409 V4L2_CID_HUE, -128, 127, 1, 0);
1410 dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1411 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1412 dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1413 V4L2_CID_GAIN, 0, 255, 1, 100);
1414 dev->alpha = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1415 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1416 dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1417 dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1418 dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1419 dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1420 dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1421 dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1422 dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1423 dev->int_menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int_menu, NULL);
1424 if (hdl->error) {
1425 ret = hdl->error;
1426 goto unreg_dev;
1427 }
1428 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1429 dev->v4l2_dev.ctrl_handler = hdl;
1430
1431
1432 spin_lock_init(&dev->slock);
1433
1434
1435 q = &dev->vb_vidq;
1436 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1437 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1438 q->drv_priv = dev;
1439 q->buf_struct_size = sizeof(struct vivi_buffer);
1440 q->ops = &vivi_video_qops;
1441 q->mem_ops = &vb2_vmalloc_memops;
1442 q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1443
1444 ret = vb2_queue_init(q);
1445 if (ret)
1446 goto unreg_dev;
1447
1448 mutex_init(&dev->mutex);
1449
1450
1451 INIT_LIST_HEAD(&dev->vidq.active);
1452 init_waitqueue_head(&dev->vidq.wq);
1453
1454 vfd = &dev->vdev;
1455 *vfd = vivi_template;
1456 vfd->debug = debug;
1457 vfd->v4l2_dev = &dev->v4l2_dev;
1458 vfd->queue = q;
1459 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1460
1461
1462
1463
1464
1465 vfd->lock = &dev->mutex;
1466 video_set_drvdata(vfd, dev);
1467
1468 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1469 if (ret < 0)
1470 goto unreg_dev;
1471
1472
1473 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1474
1475 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1476 video_device_node_name(vfd));
1477 return 0;
1478
1479unreg_dev:
1480 v4l2_ctrl_handler_free(hdl);
1481 v4l2_device_unregister(&dev->v4l2_dev);
1482free_dev:
1483 kfree(dev);
1484 return ret;
1485}
1486
1487
1488
1489
1490
1491
1492
1493static int __init vivi_init(void)
1494{
1495 const struct font_desc *font = find_font("VGA8x16");
1496 int ret = 0, i;
1497
1498 if (font == NULL) {
1499 printk(KERN_ERR "vivi: could not find font\n");
1500 return -ENODEV;
1501 }
1502 font8x16 = font->data;
1503
1504 if (n_devs <= 0)
1505 n_devs = 1;
1506
1507 for (i = 0; i < n_devs; i++) {
1508 ret = vivi_create_instance(i);
1509 if (ret) {
1510
1511 if (i)
1512 ret = 0;
1513 break;
1514 }
1515 }
1516
1517 if (ret < 0) {
1518 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1519 return ret;
1520 }
1521
1522 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1523 "Capture Board ver %s successfully loaded.\n",
1524 VIVI_VERSION);
1525
1526
1527 n_devs = i;
1528
1529 return ret;
1530}
1531
1532static void __exit vivi_exit(void)
1533{
1534 vivi_release();
1535}
1536
1537module_init(vivi_init);
1538module_exit(vivi_exit);
1539
