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