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