]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/media/video/vivi.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[mirror_ubuntu-bionic-kernel.git] / drivers / media / video / vivi.c
1 /*
2 * Virtual Video driver - This code emulates a real video device with v4l2 api
3 *
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/
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the BSD Licence, GNU General Public License
12 * as published by the Free Software Foundation; either version 2 of the
13 * License, or (at your option) any later version
14 */
15 #include <linux/module.h>
16 #include <linux/errno.h>
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/sched.h>
20 #include <linux/slab.h>
21 #include <linux/font.h>
22 #include <linux/version.h>
23 #include <linux/mutex.h>
24 #include <linux/videodev2.h>
25 #include <linux/kthread.h>
26 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
27 #include <linux/freezer.h>
28 #endif
29 #include <media/videobuf-vmalloc.h>
30 #include <media/v4l2-device.h>
31 #include <media/v4l2-ioctl.h>
32 #include <media/v4l2-common.h>
33
34 #define VIVI_MODULE_NAME "vivi"
35
36 /* Wake up at about 30 fps */
37 #define WAKE_NUMERATOR 30
38 #define WAKE_DENOMINATOR 1001
39 #define BUFFER_TIMEOUT msecs_to_jiffies(500) /* 0.5 seconds */
40
41 #define MAX_WIDTH 1920
42 #define MAX_HEIGHT 1200
43
44 #define VIVI_MAJOR_VERSION 0
45 #define VIVI_MINOR_VERSION 7
46 #define VIVI_RELEASE 0
47 #define VIVI_VERSION \
48 KERNEL_VERSION(VIVI_MAJOR_VERSION, VIVI_MINOR_VERSION, VIVI_RELEASE)
49
50 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
51 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
52 MODULE_LICENSE("Dual BSD/GPL");
53
54 static unsigned video_nr = -1;
55 module_param(video_nr, uint, 0644);
56 MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect");
57
58 static unsigned n_devs = 1;
59 module_param(n_devs, uint, 0644);
60 MODULE_PARM_DESC(n_devs, "number of video devices to create");
61
62 static unsigned debug;
63 module_param(debug, uint, 0644);
64 MODULE_PARM_DESC(debug, "activates debug info");
65
66 static unsigned int vid_limit = 16;
67 module_param(vid_limit, uint, 0644);
68 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
69
70 /* Global font descriptor */
71 static const u8 *font8x16;
72
73 #define dprintk(dev, level, fmt, arg...) \
74 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
75
76 /* ------------------------------------------------------------------
77 Basic structures
78 ------------------------------------------------------------------*/
79
80 struct vivi_fmt {
81 char *name;
82 u32 fourcc; /* v4l2 format id */
83 int depth;
84 };
85
86 static struct vivi_fmt formats[] = {
87 {
88 .name = "4:2:2, packed, YUYV",
89 .fourcc = V4L2_PIX_FMT_YUYV,
90 .depth = 16,
91 },
92 {
93 .name = "4:2:2, packed, UYVY",
94 .fourcc = V4L2_PIX_FMT_UYVY,
95 .depth = 16,
96 },
97 {
98 .name = "RGB565 (LE)",
99 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
100 .depth = 16,
101 },
102 {
103 .name = "RGB565 (BE)",
104 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
105 .depth = 16,
106 },
107 {
108 .name = "RGB555 (LE)",
109 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
110 .depth = 16,
111 },
112 {
113 .name = "RGB555 (BE)",
114 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
115 .depth = 16,
116 },
117 };
118
119 static struct vivi_fmt *get_format(struct v4l2_format *f)
120 {
121 struct vivi_fmt *fmt;
122 unsigned int k;
123
124 for (k = 0; k < ARRAY_SIZE(formats); k++) {
125 fmt = &formats[k];
126 if (fmt->fourcc == f->fmt.pix.pixelformat)
127 break;
128 }
129
130 if (k == ARRAY_SIZE(formats))
131 return NULL;
132
133 return &formats[k];
134 }
135
136 struct sg_to_addr {
137 int pos;
138 struct scatterlist *sg;
139 };
140
141 /* buffer for one video frame */
142 struct vivi_buffer {
143 /* common v4l buffer stuff -- must be first */
144 struct videobuf_buffer vb;
145
146 struct vivi_fmt *fmt;
147 };
148
149 struct vivi_dmaqueue {
150 struct list_head active;
151
152 /* thread for generating video stream*/
153 struct task_struct *kthread;
154 wait_queue_head_t wq;
155 /* Counters to control fps rate */
156 int frame;
157 int ini_jiffies;
158 };
159
160 static LIST_HEAD(vivi_devlist);
161
162 struct vivi_dev {
163 struct list_head vivi_devlist;
164 struct v4l2_device v4l2_dev;
165
166 /* controls */
167 int brightness;
168 int contrast;
169 int saturation;
170 int hue;
171 int volume;
172
173 spinlock_t slock;
174 struct mutex mutex;
175
176 /* various device info */
177 struct video_device *vfd;
178
179 struct vivi_dmaqueue vidq;
180
181 /* Several counters */
182 unsigned ms;
183 unsigned long jiffies;
184
185 int mv_count; /* Controls bars movement */
186
187 /* Input Number */
188 int input;
189
190 /* video capture */
191 struct vivi_fmt *fmt;
192 unsigned int width, height;
193 struct videobuf_queue vb_vidq;
194
195 unsigned long generating;
196 u8 bars[9][3];
197 u8 line[MAX_WIDTH * 4];
198 };
199
200 /* ------------------------------------------------------------------
201 DMA and thread functions
202 ------------------------------------------------------------------*/
203
204 /* Bars and Colors should match positions */
205
206 enum colors {
207 WHITE,
208 AMBER,
209 CYAN,
210 GREEN,
211 MAGENTA,
212 RED,
213 BLUE,
214 BLACK,
215 TEXT_BLACK,
216 };
217
218 /* R G B */
219 #define COLOR_WHITE {204, 204, 204}
220 #define COLOR_AMBER {208, 208, 0}
221 #define COLOR_CYAN { 0, 206, 206}
222 #define COLOR_GREEN { 0, 239, 0}
223 #define COLOR_MAGENTA {239, 0, 239}
224 #define COLOR_RED {205, 0, 0}
225 #define COLOR_BLUE { 0, 0, 255}
226 #define COLOR_BLACK { 0, 0, 0}
227
228 struct bar_std {
229 u8 bar[9][3];
230 };
231
232 /* Maximum number of bars are 10 - otherwise, the input print code
233 should be modified */
234 static struct bar_std bars[] = {
235 { /* Standard ITU-R color bar sequence */
236 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
237 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
238 }, {
239 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
240 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
241 }, {
242 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
243 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
244 }, {
245 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
246 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
247 },
248 };
249
250 #define NUM_INPUTS ARRAY_SIZE(bars)
251
252 #define TO_Y(r, g, b) \
253 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
254 /* RGB to V(Cr) Color transform */
255 #define TO_V(r, g, b) \
256 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
257 /* RGB to U(Cb) Color transform */
258 #define TO_U(r, g, b) \
259 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
260
261 /* precalculate color bar values to speed up rendering */
262 static void precalculate_bars(struct vivi_dev *dev)
263 {
264 u8 r, g, b;
265 int k, is_yuv;
266
267 for (k = 0; k < 9; k++) {
268 r = bars[dev->input].bar[k][0];
269 g = bars[dev->input].bar[k][1];
270 b = bars[dev->input].bar[k][2];
271 is_yuv = 0;
272
273 switch (dev->fmt->fourcc) {
274 case V4L2_PIX_FMT_YUYV:
275 case V4L2_PIX_FMT_UYVY:
276 is_yuv = 1;
277 break;
278 case V4L2_PIX_FMT_RGB565:
279 case V4L2_PIX_FMT_RGB565X:
280 r >>= 3;
281 g >>= 2;
282 b >>= 3;
283 break;
284 case V4L2_PIX_FMT_RGB555:
285 case V4L2_PIX_FMT_RGB555X:
286 r >>= 3;
287 g >>= 3;
288 b >>= 3;
289 break;
290 }
291
292 if (is_yuv) {
293 dev->bars[k][0] = TO_Y(r, g, b); /* Luma */
294 dev->bars[k][1] = TO_U(r, g, b); /* Cb */
295 dev->bars[k][2] = TO_V(r, g, b); /* Cr */
296 } else {
297 dev->bars[k][0] = r;
298 dev->bars[k][1] = g;
299 dev->bars[k][2] = b;
300 }
301 }
302 }
303
304 #define TSTAMP_MIN_Y 24
305 #define TSTAMP_MAX_Y (TSTAMP_MIN_Y + 15)
306 #define TSTAMP_INPUT_X 10
307 #define TSTAMP_MIN_X (54 + TSTAMP_INPUT_X)
308
309 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos)
310 {
311 u8 r_y, g_u, b_v;
312 int color;
313 u8 *p;
314
315 r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
316 g_u = dev->bars[colorpos][1]; /* G or precalculated U */
317 b_v = dev->bars[colorpos][2]; /* B or precalculated V */
318
319 for (color = 0; color < 4; color++) {
320 p = buf + color;
321
322 switch (dev->fmt->fourcc) {
323 case V4L2_PIX_FMT_YUYV:
324 switch (color) {
325 case 0:
326 case 2:
327 *p = r_y;
328 break;
329 case 1:
330 *p = g_u;
331 break;
332 case 3:
333 *p = b_v;
334 break;
335 }
336 break;
337 case V4L2_PIX_FMT_UYVY:
338 switch (color) {
339 case 1:
340 case 3:
341 *p = r_y;
342 break;
343 case 0:
344 *p = g_u;
345 break;
346 case 2:
347 *p = b_v;
348 break;
349 }
350 break;
351 case V4L2_PIX_FMT_RGB565:
352 switch (color) {
353 case 0:
354 case 2:
355 *p = (g_u << 5) | b_v;
356 break;
357 case 1:
358 case 3:
359 *p = (r_y << 3) | (g_u >> 3);
360 break;
361 }
362 break;
363 case V4L2_PIX_FMT_RGB565X:
364 switch (color) {
365 case 0:
366 case 2:
367 *p = (r_y << 3) | (g_u >> 3);
368 break;
369 case 1:
370 case 3:
371 *p = (g_u << 5) | b_v;
372 break;
373 }
374 break;
375 case V4L2_PIX_FMT_RGB555:
376 switch (color) {
377 case 0:
378 case 2:
379 *p = (g_u << 5) | b_v;
380 break;
381 case 1:
382 case 3:
383 *p = (r_y << 2) | (g_u >> 3);
384 break;
385 }
386 break;
387 case V4L2_PIX_FMT_RGB555X:
388 switch (color) {
389 case 0:
390 case 2:
391 *p = (r_y << 2) | (g_u >> 3);
392 break;
393 case 1:
394 case 3:
395 *p = (g_u << 5) | b_v;
396 break;
397 }
398 break;
399 }
400 }
401 }
402
403 static void precalculate_line(struct vivi_dev *dev)
404 {
405 int w;
406
407 for (w = 0; w < dev->width * 2; w += 2) {
408 int colorpos = (w / (dev->width / 8) % 8);
409
410 gen_twopix(dev, dev->line + w * 2, colorpos);
411 }
412 }
413
414 static void gen_text(struct vivi_dev *dev, char *basep,
415 int y, int x, char *text)
416 {
417 int line;
418
419 /* Checks if it is possible to show string */
420 if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
421 return;
422
423 /* Print stream time */
424 for (line = y; line < y + 16; line++) {
425 int j = 0;
426 char *pos = basep + line * dev->width * 2 + x * 2;
427 char *s;
428
429 for (s = text; *s; s++) {
430 u8 chr = font8x16[*s * 16 + line - y];
431 int i;
432
433 for (i = 0; i < 7; i++, j++) {
434 /* Draw white font on black background */
435 if (chr & (1 << (7 - i)))
436 gen_twopix(dev, pos + j * 2, WHITE);
437 else
438 gen_twopix(dev, pos + j * 2, TEXT_BLACK);
439 }
440 }
441 }
442 }
443
444 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
445 {
446 int hmax = buf->vb.height;
447 int wmax = buf->vb.width;
448 struct timeval ts;
449 void *vbuf = videobuf_to_vmalloc(&buf->vb);
450 unsigned ms;
451 char str[100];
452 int h, line = 1;
453
454 if (!vbuf)
455 return;
456
457 for (h = 0; h < hmax; h++)
458 memcpy(vbuf + h * wmax * 2, dev->line + (dev->mv_count % wmax) * 2, wmax * 2);
459
460 /* Updates stream time */
461
462 dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
463 dev->jiffies = jiffies;
464 ms = dev->ms;
465 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
466 (ms / (60 * 60 * 1000)) % 24,
467 (ms / (60 * 1000)) % 60,
468 (ms / 1000) % 60,
469 ms % 1000);
470 gen_text(dev, vbuf, line++ * 16, 16, str);
471 snprintf(str, sizeof(str), " %dx%d, input %d ",
472 dev->width, dev->height, dev->input);
473 gen_text(dev, vbuf, line++ * 16, 16, str);
474
475 snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
476 dev->brightness,
477 dev->contrast,
478 dev->saturation,
479 dev->hue);
480 gen_text(dev, vbuf, line++ * 16, 16, str);
481 snprintf(str, sizeof(str), " volume %3d ", dev->volume);
482 gen_text(dev, vbuf, line++ * 16, 16, str);
483
484 dev->mv_count += 2;
485
486 /* Advice that buffer was filled */
487 buf->vb.field_count++;
488 do_gettimeofday(&ts);
489 buf->vb.ts = ts;
490 buf->vb.state = VIDEOBUF_DONE;
491 }
492
493 static void vivi_thread_tick(struct vivi_dev *dev)
494 {
495 struct vivi_dmaqueue *dma_q = &dev->vidq;
496 struct vivi_buffer *buf;
497 unsigned long flags = 0;
498
499 dprintk(dev, 1, "Thread tick\n");
500
501 spin_lock_irqsave(&dev->slock, flags);
502 if (list_empty(&dma_q->active)) {
503 dprintk(dev, 1, "No active queue to serve\n");
504 goto unlock;
505 }
506
507 buf = list_entry(dma_q->active.next,
508 struct vivi_buffer, vb.queue);
509
510 /* Nobody is waiting on this buffer, return */
511 if (!waitqueue_active(&buf->vb.done))
512 goto unlock;
513
514 list_del(&buf->vb.queue);
515
516 do_gettimeofday(&buf->vb.ts);
517
518 /* Fill buffer */
519 vivi_fillbuff(dev, buf);
520 dprintk(dev, 1, "filled buffer %p\n", buf);
521
522 wake_up(&buf->vb.done);
523 dprintk(dev, 2, "[%p/%d] wakeup\n", buf, buf->vb. i);
524 unlock:
525 spin_unlock_irqrestore(&dev->slock, flags);
526 }
527
528 #define frames_to_ms(frames) \
529 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
530
531 static void vivi_sleep(struct vivi_dev *dev)
532 {
533 struct vivi_dmaqueue *dma_q = &dev->vidq;
534 int timeout;
535 DECLARE_WAITQUEUE(wait, current);
536
537 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
538 (unsigned long)dma_q);
539
540 add_wait_queue(&dma_q->wq, &wait);
541 if (kthread_should_stop())
542 goto stop_task;
543
544 /* Calculate time to wake up */
545 timeout = msecs_to_jiffies(frames_to_ms(1));
546
547 vivi_thread_tick(dev);
548
549 schedule_timeout_interruptible(timeout);
550
551 stop_task:
552 remove_wait_queue(&dma_q->wq, &wait);
553 try_to_freeze();
554 }
555
556 static int vivi_thread(void *data)
557 {
558 struct vivi_dev *dev = data;
559
560 dprintk(dev, 1, "thread started\n");
561
562 set_freezable();
563
564 for (;;) {
565 vivi_sleep(dev);
566
567 if (kthread_should_stop())
568 break;
569 }
570 dprintk(dev, 1, "thread: exit\n");
571 return 0;
572 }
573
574 static void vivi_start_generating(struct file *file)
575 {
576 struct vivi_dev *dev = video_drvdata(file);
577 struct vivi_dmaqueue *dma_q = &dev->vidq;
578
579 dprintk(dev, 1, "%s\n", __func__);
580
581 if (test_and_set_bit(0, &dev->generating))
582 return;
583 file->private_data = dev;
584
585 /* Resets frame counters */
586 dev->ms = 0;
587 dev->mv_count = 0;
588 dev->jiffies = jiffies;
589
590 dma_q->frame = 0;
591 dma_q->ini_jiffies = jiffies;
592 dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
593
594 if (IS_ERR(dma_q->kthread)) {
595 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
596 clear_bit(0, &dev->generating);
597 return;
598 }
599 /* Wakes thread */
600 wake_up_interruptible(&dma_q->wq);
601
602 dprintk(dev, 1, "returning from %s\n", __func__);
603 }
604
605 static void vivi_stop_generating(struct file *file)
606 {
607 struct vivi_dev *dev = video_drvdata(file);
608 struct vivi_dmaqueue *dma_q = &dev->vidq;
609
610 dprintk(dev, 1, "%s\n", __func__);
611
612 if (!file->private_data)
613 return;
614 if (!test_and_clear_bit(0, &dev->generating))
615 return;
616
617 /* shutdown control thread */
618 if (dma_q->kthread) {
619 kthread_stop(dma_q->kthread);
620 dma_q->kthread = NULL;
621 }
622 videobuf_stop(&dev->vb_vidq);
623 videobuf_mmap_free(&dev->vb_vidq);
624 }
625
626 static int vivi_is_generating(struct vivi_dev *dev)
627 {
628 return test_bit(0, &dev->generating);
629 }
630
631 /* ------------------------------------------------------------------
632 Videobuf operations
633 ------------------------------------------------------------------*/
634 static int
635 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
636 {
637 struct vivi_dev *dev = vq->priv_data;
638
639 *size = dev->width * dev->height * 2;
640
641 if (0 == *count)
642 *count = 32;
643
644 while (*size * *count > vid_limit * 1024 * 1024)
645 (*count)--;
646
647 dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__,
648 *count, *size);
649
650 return 0;
651 }
652
653 static void free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
654 {
655 struct vivi_dev *dev = vq->priv_data;
656
657 dprintk(dev, 1, "%s, state: %i\n", __func__, buf->vb.state);
658
659 videobuf_vmalloc_free(&buf->vb);
660 dprintk(dev, 1, "free_buffer: freed\n");
661 buf->vb.state = VIDEOBUF_NEEDS_INIT;
662 }
663
664 static int
665 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
666 enum v4l2_field field)
667 {
668 struct vivi_dev *dev = vq->priv_data;
669 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
670 int rc;
671
672 dprintk(dev, 1, "%s, field=%d\n", __func__, field);
673
674 BUG_ON(NULL == dev->fmt);
675
676 if (dev->width < 48 || dev->width > MAX_WIDTH ||
677 dev->height < 32 || dev->height > MAX_HEIGHT)
678 return -EINVAL;
679
680 buf->vb.size = dev->width * dev->height * 2;
681 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
682 return -EINVAL;
683
684 /* These properties only change when queue is idle, see s_fmt */
685 buf->fmt = dev->fmt;
686 buf->vb.width = dev->width;
687 buf->vb.height = dev->height;
688 buf->vb.field = field;
689
690 precalculate_bars(dev);
691 precalculate_line(dev);
692
693 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
694 rc = videobuf_iolock(vq, &buf->vb, NULL);
695 if (rc < 0)
696 goto fail;
697 }
698
699 buf->vb.state = VIDEOBUF_PREPARED;
700 return 0;
701
702 fail:
703 free_buffer(vq, buf);
704 return rc;
705 }
706
707 static void
708 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
709 {
710 struct vivi_dev *dev = vq->priv_data;
711 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
712 struct vivi_dmaqueue *vidq = &dev->vidq;
713
714 dprintk(dev, 1, "%s\n", __func__);
715
716 buf->vb.state = VIDEOBUF_QUEUED;
717 list_add_tail(&buf->vb.queue, &vidq->active);
718 }
719
720 static void buffer_release(struct videobuf_queue *vq,
721 struct videobuf_buffer *vb)
722 {
723 struct vivi_dev *dev = vq->priv_data;
724 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
725
726 dprintk(dev, 1, "%s\n", __func__);
727
728 free_buffer(vq, buf);
729 }
730
731 static struct videobuf_queue_ops vivi_video_qops = {
732 .buf_setup = buffer_setup,
733 .buf_prepare = buffer_prepare,
734 .buf_queue = buffer_queue,
735 .buf_release = buffer_release,
736 };
737
738 /* ------------------------------------------------------------------
739 IOCTL vidioc handling
740 ------------------------------------------------------------------*/
741 static int vidioc_querycap(struct file *file, void *priv,
742 struct v4l2_capability *cap)
743 {
744 struct vivi_dev *dev = video_drvdata(file);
745
746 strcpy(cap->driver, "vivi");
747 strcpy(cap->card, "vivi");
748 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
749 cap->version = VIVI_VERSION;
750 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | \
751 V4L2_CAP_READWRITE;
752 return 0;
753 }
754
755 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
756 struct v4l2_fmtdesc *f)
757 {
758 struct vivi_fmt *fmt;
759
760 if (f->index >= ARRAY_SIZE(formats))
761 return -EINVAL;
762
763 fmt = &formats[f->index];
764
765 strlcpy(f->description, fmt->name, sizeof(f->description));
766 f->pixelformat = fmt->fourcc;
767 return 0;
768 }
769
770 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
771 struct v4l2_format *f)
772 {
773 struct vivi_dev *dev = video_drvdata(file);
774
775 f->fmt.pix.width = dev->width;
776 f->fmt.pix.height = dev->height;
777 f->fmt.pix.field = dev->vb_vidq.field;
778 f->fmt.pix.pixelformat = dev->fmt->fourcc;
779 f->fmt.pix.bytesperline =
780 (f->fmt.pix.width * dev->fmt->depth) >> 3;
781 f->fmt.pix.sizeimage =
782 f->fmt.pix.height * f->fmt.pix.bytesperline;
783 return 0;
784 }
785
786 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
787 struct v4l2_format *f)
788 {
789 struct vivi_dev *dev = video_drvdata(file);
790 struct vivi_fmt *fmt;
791 enum v4l2_field field;
792
793 fmt = get_format(f);
794 if (!fmt) {
795 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
796 f->fmt.pix.pixelformat);
797 return -EINVAL;
798 }
799
800 field = f->fmt.pix.field;
801
802 if (field == V4L2_FIELD_ANY) {
803 field = V4L2_FIELD_INTERLACED;
804 } else if (V4L2_FIELD_INTERLACED != field) {
805 dprintk(dev, 1, "Field type invalid.\n");
806 return -EINVAL;
807 }
808
809 f->fmt.pix.field = field;
810 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
811 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
812 f->fmt.pix.bytesperline =
813 (f->fmt.pix.width * fmt->depth) >> 3;
814 f->fmt.pix.sizeimage =
815 f->fmt.pix.height * f->fmt.pix.bytesperline;
816 return 0;
817 }
818
819 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
820 struct v4l2_format *f)
821 {
822 struct vivi_dev *dev = video_drvdata(file);
823
824 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
825 if (ret < 0)
826 return ret;
827
828 if (vivi_is_generating(dev)) {
829 dprintk(dev, 1, "%s device busy\n", __func__);
830 ret = -EBUSY;
831 goto out;
832 }
833
834 dev->fmt = get_format(f);
835 dev->width = f->fmt.pix.width;
836 dev->height = f->fmt.pix.height;
837 dev->vb_vidq.field = f->fmt.pix.field;
838 ret = 0;
839 out:
840 return ret;
841 }
842
843 static int vidioc_reqbufs(struct file *file, void *priv,
844 struct v4l2_requestbuffers *p)
845 {
846 struct vivi_dev *dev = video_drvdata(file);
847
848 return videobuf_reqbufs(&dev->vb_vidq, p);
849 }
850
851 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
852 {
853 struct vivi_dev *dev = video_drvdata(file);
854
855 return videobuf_querybuf(&dev->vb_vidq, p);
856 }
857
858 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
859 {
860 struct vivi_dev *dev = video_drvdata(file);
861
862 return videobuf_qbuf(&dev->vb_vidq, p);
863 }
864
865 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
866 {
867 struct vivi_dev *dev = video_drvdata(file);
868
869 return videobuf_dqbuf(&dev->vb_vidq, p,
870 file->f_flags & O_NONBLOCK);
871 }
872
873 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
874 {
875 struct vivi_dev *dev = video_drvdata(file);
876 int ret;
877
878 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
879 return -EINVAL;
880 ret = videobuf_streamon(&dev->vb_vidq);
881 if (ret)
882 return ret;
883
884 vivi_start_generating(file);
885 return 0;
886 }
887
888 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
889 {
890 struct vivi_dev *dev = video_drvdata(file);
891 int ret;
892
893 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
894 return -EINVAL;
895 ret = videobuf_streamoff(&dev->vb_vidq);
896 if (!ret)
897 vivi_stop_generating(file);
898 return ret;
899 }
900
901 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
902 {
903 return 0;
904 }
905
906 /* only one input in this sample driver */
907 static int vidioc_enum_input(struct file *file, void *priv,
908 struct v4l2_input *inp)
909 {
910 if (inp->index >= NUM_INPUTS)
911 return -EINVAL;
912
913 inp->type = V4L2_INPUT_TYPE_CAMERA;
914 inp->std = V4L2_STD_525_60;
915 sprintf(inp->name, "Camera %u", inp->index);
916 return 0;
917 }
918
919 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
920 {
921 struct vivi_dev *dev = video_drvdata(file);
922
923 *i = dev->input;
924 return 0;
925 }
926
927 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
928 {
929 struct vivi_dev *dev = video_drvdata(file);
930
931 if (i >= NUM_INPUTS)
932 return -EINVAL;
933
934 dev->input = i;
935 precalculate_bars(dev);
936 precalculate_line(dev);
937 return 0;
938 }
939
940 /* --- controls ---------------------------------------------- */
941 static int vidioc_queryctrl(struct file *file, void *priv,
942 struct v4l2_queryctrl *qc)
943 {
944 switch (qc->id) {
945 case V4L2_CID_AUDIO_VOLUME:
946 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 200);
947 case V4L2_CID_BRIGHTNESS:
948 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 127);
949 case V4L2_CID_CONTRAST:
950 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 16);
951 case V4L2_CID_SATURATION:
952 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 127);
953 case V4L2_CID_HUE:
954 return v4l2_ctrl_query_fill(qc, -128, 127, 1, 0);
955 }
956 return -EINVAL;
957 }
958
959 static int vidioc_g_ctrl(struct file *file, void *priv,
960 struct v4l2_control *ctrl)
961 {
962 struct vivi_dev *dev = video_drvdata(file);
963
964 switch (ctrl->id) {
965 case V4L2_CID_AUDIO_VOLUME:
966 ctrl->value = dev->volume;
967 return 0;
968 case V4L2_CID_BRIGHTNESS:
969 ctrl->value = dev->brightness;
970 return 0;
971 case V4L2_CID_CONTRAST:
972 ctrl->value = dev->contrast;
973 return 0;
974 case V4L2_CID_SATURATION:
975 ctrl->value = dev->saturation;
976 return 0;
977 case V4L2_CID_HUE:
978 ctrl->value = dev->hue;
979 return 0;
980 }
981 return -EINVAL;
982 }
983
984 static int vidioc_s_ctrl(struct file *file, void *priv,
985 struct v4l2_control *ctrl)
986 {
987 struct vivi_dev *dev = video_drvdata(file);
988 struct v4l2_queryctrl qc;
989 int err;
990
991 qc.id = ctrl->id;
992 err = vidioc_queryctrl(file, priv, &qc);
993 if (err < 0)
994 return err;
995 if (ctrl->value < qc.minimum || ctrl->value > qc.maximum)
996 return -ERANGE;
997 switch (ctrl->id) {
998 case V4L2_CID_AUDIO_VOLUME:
999 dev->volume = ctrl->value;
1000 return 0;
1001 case V4L2_CID_BRIGHTNESS:
1002 dev->brightness = ctrl->value;
1003 return 0;
1004 case V4L2_CID_CONTRAST:
1005 dev->contrast = ctrl->value;
1006 return 0;
1007 case V4L2_CID_SATURATION:
1008 dev->saturation = ctrl->value;
1009 return 0;
1010 case V4L2_CID_HUE:
1011 dev->hue = ctrl->value;
1012 return 0;
1013 }
1014 return -EINVAL;
1015 }
1016
1017 /* ------------------------------------------------------------------
1018 File operations for the device
1019 ------------------------------------------------------------------*/
1020
1021 static ssize_t
1022 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1023 {
1024 struct vivi_dev *dev = video_drvdata(file);
1025
1026 vivi_start_generating(file);
1027 return videobuf_read_stream(&dev->vb_vidq, data, count, ppos, 0,
1028 file->f_flags & O_NONBLOCK);
1029 }
1030
1031 static unsigned int
1032 vivi_poll(struct file *file, struct poll_table_struct *wait)
1033 {
1034 struct vivi_dev *dev = video_drvdata(file);
1035 struct videobuf_queue *q = &dev->vb_vidq;
1036
1037 dprintk(dev, 1, "%s\n", __func__);
1038
1039 vivi_start_generating(file);
1040 return videobuf_poll_stream(file, q, wait);
1041 }
1042
1043 static int vivi_close(struct file *file)
1044 {
1045 struct video_device *vdev = video_devdata(file);
1046 struct vivi_dev *dev = video_drvdata(file);
1047
1048 vivi_stop_generating(file);
1049
1050 dprintk(dev, 1, "close called (dev=%s)\n",
1051 video_device_node_name(vdev));
1052 return 0;
1053 }
1054
1055 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1056 {
1057 struct vivi_dev *dev = video_drvdata(file);
1058 int ret;
1059
1060 dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1061
1062 ret = videobuf_mmap_mapper(&dev->vb_vidq, vma);
1063
1064 dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1065 (unsigned long)vma->vm_start,
1066 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
1067 ret);
1068 return ret;
1069 }
1070
1071 static const struct v4l2_file_operations vivi_fops = {
1072 .owner = THIS_MODULE,
1073 .release = vivi_close,
1074 .read = vivi_read,
1075 .poll = vivi_poll,
1076 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1077 .mmap = vivi_mmap,
1078 };
1079
1080 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1081 .vidioc_querycap = vidioc_querycap,
1082 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1083 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1084 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1085 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1086 .vidioc_reqbufs = vidioc_reqbufs,
1087 .vidioc_querybuf = vidioc_querybuf,
1088 .vidioc_qbuf = vidioc_qbuf,
1089 .vidioc_dqbuf = vidioc_dqbuf,
1090 .vidioc_s_std = vidioc_s_std,
1091 .vidioc_enum_input = vidioc_enum_input,
1092 .vidioc_g_input = vidioc_g_input,
1093 .vidioc_s_input = vidioc_s_input,
1094 .vidioc_streamon = vidioc_streamon,
1095 .vidioc_streamoff = vidioc_streamoff,
1096 .vidioc_queryctrl = vidioc_queryctrl,
1097 .vidioc_g_ctrl = vidioc_g_ctrl,
1098 .vidioc_s_ctrl = vidioc_s_ctrl,
1099 };
1100
1101 static struct video_device vivi_template = {
1102 .name = "vivi",
1103 .fops = &vivi_fops,
1104 .ioctl_ops = &vivi_ioctl_ops,
1105 .release = video_device_release,
1106
1107 .tvnorms = V4L2_STD_525_60,
1108 .current_norm = V4L2_STD_NTSC_M,
1109 };
1110
1111 /* -----------------------------------------------------------------
1112 Initialization and module stuff
1113 ------------------------------------------------------------------*/
1114
1115 static int vivi_release(void)
1116 {
1117 struct vivi_dev *dev;
1118 struct list_head *list;
1119
1120 while (!list_empty(&vivi_devlist)) {
1121 list = vivi_devlist.next;
1122 list_del(list);
1123 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1124
1125 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1126 video_device_node_name(dev->vfd));
1127 video_unregister_device(dev->vfd);
1128 v4l2_device_unregister(&dev->v4l2_dev);
1129 kfree(dev);
1130 }
1131
1132 return 0;
1133 }
1134
1135 static int __init vivi_create_instance(int inst)
1136 {
1137 struct vivi_dev *dev;
1138 struct video_device *vfd;
1139 int ret;
1140
1141 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1142 if (!dev)
1143 return -ENOMEM;
1144
1145 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1146 "%s-%03d", VIVI_MODULE_NAME, inst);
1147 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1148 if (ret)
1149 goto free_dev;
1150
1151 dev->fmt = &formats[0];
1152 dev->width = 640;
1153 dev->height = 480;
1154 dev->volume = 200;
1155 dev->brightness = 127;
1156 dev->contrast = 16;
1157 dev->saturation = 127;
1158 dev->hue = 0;
1159
1160 /* initialize locks */
1161 spin_lock_init(&dev->slock);
1162 mutex_init(&dev->mutex);
1163
1164 videobuf_queue_vmalloc_init(&dev->vb_vidq, &vivi_video_qops,
1165 NULL, &dev->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
1166 V4L2_FIELD_INTERLACED,
1167 sizeof(struct vivi_buffer), dev, &dev->mutex);
1168
1169 /* init video dma queues */
1170 INIT_LIST_HEAD(&dev->vidq.active);
1171 init_waitqueue_head(&dev->vidq.wq);
1172
1173 ret = -ENOMEM;
1174 vfd = video_device_alloc();
1175 if (!vfd)
1176 goto unreg_dev;
1177
1178 *vfd = vivi_template;
1179 vfd->debug = debug;
1180 vfd->v4l2_dev = &dev->v4l2_dev;
1181 vfd->lock = &dev->mutex;
1182
1183 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1184 if (ret < 0)
1185 goto rel_vdev;
1186
1187 video_set_drvdata(vfd, dev);
1188
1189 /* Now that everything is fine, let's add it to device list */
1190 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1191
1192 if (video_nr != -1)
1193 video_nr++;
1194
1195 dev->vfd = vfd;
1196 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1197 video_device_node_name(vfd));
1198 return 0;
1199
1200 rel_vdev:
1201 video_device_release(vfd);
1202 unreg_dev:
1203 v4l2_device_unregister(&dev->v4l2_dev);
1204 free_dev:
1205 kfree(dev);
1206 return ret;
1207 }
1208
1209 /* This routine allocates from 1 to n_devs virtual drivers.
1210
1211 The real maximum number of virtual drivers will depend on how many drivers
1212 will succeed. This is limited to the maximum number of devices that
1213 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1214 */
1215 static int __init vivi_init(void)
1216 {
1217 const struct font_desc *font = find_font("VGA8x16");
1218 int ret = 0, i;
1219
1220 if (font == NULL) {
1221 printk(KERN_ERR "vivi: could not find font\n");
1222 return -ENODEV;
1223 }
1224 font8x16 = font->data;
1225
1226 if (n_devs <= 0)
1227 n_devs = 1;
1228
1229 for (i = 0; i < n_devs; i++) {
1230 ret = vivi_create_instance(i);
1231 if (ret) {
1232 /* If some instantiations succeeded, keep driver */
1233 if (i)
1234 ret = 0;
1235 break;
1236 }
1237 }
1238
1239 if (ret < 0) {
1240 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1241 return ret;
1242 }
1243
1244 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1245 "Capture Board ver %u.%u.%u successfully loaded.\n",
1246 (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1247 VIVI_VERSION & 0xFF);
1248
1249 /* n_devs will reflect the actual number of allocated devices */
1250 n_devs = i;
1251
1252 return ret;
1253 }
1254
1255 static void __exit vivi_exit(void)
1256 {
1257 vivi_release();
1258 }
1259
1260 module_init(vivi_init);
1261 module_exit(vivi_exit);
ubuntu-bionic-kernel mirror