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