projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[media] s5p-fimc: Use correct fourcc code for 32-bit RGB format
[deliverable/linux.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 #ifdef CONFIG_VIDEO_V4L1_COMPAT
874 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
875 {
876 struct vivi_dev *dev = video_drvdata(file);
877
878 return videobuf_cgmbuf(&dev->vb_vidq, mbuf, 8);
879 }
880 #endif
881
882 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
883 {
884 struct vivi_dev *dev = video_drvdata(file);
885 int ret;
886
887 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
888 return -EINVAL;
889 ret = videobuf_streamon(&dev->vb_vidq);
890 if (ret)
891 return ret;
892
893 vivi_start_generating(file);
894 return 0;
895 }
896
897 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
898 {
899 struct vivi_dev *dev = video_drvdata(file);
900 int ret;
901
902 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
903 return -EINVAL;
904 ret = videobuf_streamoff(&dev->vb_vidq);
905 if (!ret)
906 vivi_stop_generating(file);
907 return ret;
908 }
909
910 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
911 {
912 return 0;
913 }
914
915 /* only one input in this sample driver */
916 static int vidioc_enum_input(struct file *file, void *priv,
917 struct v4l2_input *inp)
918 {
919 if (inp->index >= NUM_INPUTS)
920 return -EINVAL;
921
922 inp->type = V4L2_INPUT_TYPE_CAMERA;
923 inp->std = V4L2_STD_525_60;
924 sprintf(inp->name, "Camera %u", inp->index);
925 return 0;
926 }
927
928 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
929 {
930 struct vivi_dev *dev = video_drvdata(file);
931
932 *i = dev->input;
933 return 0;
934 }
935
936 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
937 {
938 struct vivi_dev *dev = video_drvdata(file);
939
940 if (i >= NUM_INPUTS)
941 return -EINVAL;
942
943 dev->input = i;
944 precalculate_bars(dev);
945 precalculate_line(dev);
946 return 0;
947 }
948
949 /* --- controls ---------------------------------------------- */
950 static int vidioc_queryctrl(struct file *file, void *priv,
951 struct v4l2_queryctrl *qc)
952 {
953 switch (qc->id) {
954 case V4L2_CID_AUDIO_VOLUME:
955 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 200);
956 case V4L2_CID_BRIGHTNESS:
957 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 127);
958 case V4L2_CID_CONTRAST:
959 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 16);
960 case V4L2_CID_SATURATION:
961 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 127);
962 case V4L2_CID_HUE:
963 return v4l2_ctrl_query_fill(qc, -128, 127, 1, 0);
964 }
965 return -EINVAL;
966 }
967
968 static int vidioc_g_ctrl(struct file *file, void *priv,
969 struct v4l2_control *ctrl)
970 {
971 struct vivi_dev *dev = video_drvdata(file);
972
973 switch (ctrl->id) {
974 case V4L2_CID_AUDIO_VOLUME:
975 ctrl->value = dev->volume;
976 return 0;
977 case V4L2_CID_BRIGHTNESS:
978 ctrl->value = dev->brightness;
979 return 0;
980 case V4L2_CID_CONTRAST:
981 ctrl->value = dev->contrast;
982 return 0;
983 case V4L2_CID_SATURATION:
984 ctrl->value = dev->saturation;
985 return 0;
986 case V4L2_CID_HUE:
987 ctrl->value = dev->hue;
988 return 0;
989 }
990 return -EINVAL;
991 }
992
993 static int vidioc_s_ctrl(struct file *file, void *priv,
994 struct v4l2_control *ctrl)
995 {
996 struct vivi_dev *dev = video_drvdata(file);
997 struct v4l2_queryctrl qc;
998 int err;
999
1000 qc.id = ctrl->id;
1001 err = vidioc_queryctrl(file, priv, &qc);
1002 if (err < 0)
1003 return err;
1004 if (ctrl->value < qc.minimum || ctrl->value > qc.maximum)
1005 return -ERANGE;
1006 switch (ctrl->id) {
1007 case V4L2_CID_AUDIO_VOLUME:
1008 dev->volume = ctrl->value;
1009 return 0;
1010 case V4L2_CID_BRIGHTNESS:
1011 dev->brightness = ctrl->value;
1012 return 0;
1013 case V4L2_CID_CONTRAST:
1014 dev->contrast = ctrl->value;
1015 return 0;
1016 case V4L2_CID_SATURATION:
1017 dev->saturation = ctrl->value;
1018 return 0;
1019 case V4L2_CID_HUE:
1020 dev->hue = ctrl->value;
1021 return 0;
1022 }
1023 return -EINVAL;
1024 }
1025
1026 /* ------------------------------------------------------------------
1027 File operations for the device
1028 ------------------------------------------------------------------*/
1029
1030 static ssize_t
1031 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1032 {
1033 struct vivi_dev *dev = video_drvdata(file);
1034
1035 vivi_start_generating(file);
1036 return videobuf_read_stream(&dev->vb_vidq, data, count, ppos, 0,
1037 file->f_flags & O_NONBLOCK);
1038 }
1039
1040 static unsigned int
1041 vivi_poll(struct file *file, struct poll_table_struct *wait)
1042 {
1043 struct vivi_dev *dev = video_drvdata(file);
1044 struct videobuf_queue *q = &dev->vb_vidq;
1045
1046 dprintk(dev, 1, "%s\n", __func__);
1047
1048 vivi_start_generating(file);
1049 return videobuf_poll_stream(file, q, wait);
1050 }
1051
1052 static int vivi_close(struct file *file)
1053 {
1054 struct video_device *vdev = video_devdata(file);
1055 struct vivi_dev *dev = video_drvdata(file);
1056
1057 vivi_stop_generating(file);
1058
1059 dprintk(dev, 1, "close called (dev=%s)\n",
1060 video_device_node_name(vdev));
1061 return 0;
1062 }
1063
1064 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1065 {
1066 struct vivi_dev *dev = video_drvdata(file);
1067 int ret;
1068
1069 dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1070
1071 ret = videobuf_mmap_mapper(&dev->vb_vidq, vma);
1072
1073 dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1074 (unsigned long)vma->vm_start,
1075 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
1076 ret);
1077 return ret;
1078 }
1079
1080 static const struct v4l2_file_operations vivi_fops = {
1081 .owner = THIS_MODULE,
1082 .release = vivi_close,
1083 .read = vivi_read,
1084 .poll = vivi_poll,
1085 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1086 .mmap = vivi_mmap,
1087 };
1088
1089 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1090 .vidioc_querycap = vidioc_querycap,
1091 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1092 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1093 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1094 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1095 .vidioc_reqbufs = vidioc_reqbufs,
1096 .vidioc_querybuf = vidioc_querybuf,
1097 .vidioc_qbuf = vidioc_qbuf,
1098 .vidioc_dqbuf = vidioc_dqbuf,
1099 .vidioc_s_std = vidioc_s_std,
1100 .vidioc_enum_input = vidioc_enum_input,
1101 .vidioc_g_input = vidioc_g_input,
1102 .vidioc_s_input = vidioc_s_input,
1103 .vidioc_streamon = vidioc_streamon,
1104 .vidioc_streamoff = vidioc_streamoff,
1105 .vidioc_queryctrl = vidioc_queryctrl,
1106 .vidioc_g_ctrl = vidioc_g_ctrl,
1107 .vidioc_s_ctrl = vidioc_s_ctrl,
1108 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1109 .vidiocgmbuf = vidiocgmbuf,
1110 #endif
1111 };
1112
1113 static struct video_device vivi_template = {
1114 .name = "vivi",
1115 .fops = &vivi_fops,
1116 .ioctl_ops = &vivi_ioctl_ops,
1117 .release = video_device_release,
1118
1119 .tvnorms = V4L2_STD_525_60,
1120 .current_norm = V4L2_STD_NTSC_M,
1121 };
1122
1123 /* -----------------------------------------------------------------
1124 Initialization and module stuff
1125 ------------------------------------------------------------------*/
1126
1127 static int vivi_release(void)
1128 {
1129 struct vivi_dev *dev;
1130 struct list_head *list;
1131
1132 while (!list_empty(&vivi_devlist)) {
1133 list = vivi_devlist.next;
1134 list_del(list);
1135 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1136
1137 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1138 video_device_node_name(dev->vfd));
1139 video_unregister_device(dev->vfd);
1140 v4l2_device_unregister(&dev->v4l2_dev);
1141 kfree(dev);
1142 }
1143
1144 return 0;
1145 }
1146
1147 static int __init vivi_create_instance(int inst)
1148 {
1149 struct vivi_dev *dev;
1150 struct video_device *vfd;
1151 int ret;
1152
1153 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1154 if (!dev)
1155 return -ENOMEM;
1156
1157 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1158 "%s-%03d", VIVI_MODULE_NAME, inst);
1159 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1160 if (ret)
1161 goto free_dev;
1162
1163 dev->fmt = &formats[0];
1164 dev->width = 640;
1165 dev->height = 480;
1166 dev->volume = 200;
1167 dev->brightness = 127;
1168 dev->contrast = 16;
1169 dev->saturation = 127;
1170 dev->hue = 0;
1171
1172 /* initialize locks */
1173 spin_lock_init(&dev->slock);
1174 mutex_init(&dev->mutex);
1175
1176 videobuf_queue_vmalloc_init(&dev->vb_vidq, &vivi_video_qops,
1177 NULL, &dev->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
1178 V4L2_FIELD_INTERLACED,
1179 sizeof(struct vivi_buffer), dev, &dev->mutex);
1180
1181 /* init video dma queues */
1182 INIT_LIST_HEAD(&dev->vidq.active);
1183 init_waitqueue_head(&dev->vidq.wq);
1184
1185 ret = -ENOMEM;
1186 vfd = video_device_alloc();
1187 if (!vfd)
1188 goto unreg_dev;
1189
1190 *vfd = vivi_template;
1191 vfd->debug = debug;
1192 vfd->v4l2_dev = &dev->v4l2_dev;
1193 vfd->lock = &dev->mutex;
1194
1195 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1196 if (ret < 0)
1197 goto rel_vdev;
1198
1199 video_set_drvdata(vfd, dev);
1200
1201 /* Now that everything is fine, let's add it to device list */
1202 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1203
1204 if (video_nr != -1)
1205 video_nr++;
1206
1207 dev->vfd = vfd;
1208 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1209 video_device_node_name(vfd));
1210 return 0;
1211
1212 rel_vdev:
1213 video_device_release(vfd);
1214 unreg_dev:
1215 v4l2_device_unregister(&dev->v4l2_dev);
1216 free_dev:
1217 kfree(dev);
1218 return ret;
1219 }
1220
1221 /* This routine allocates from 1 to n_devs virtual drivers.
1222
1223 The real maximum number of virtual drivers will depend on how many drivers
1224 will succeed. This is limited to the maximum number of devices that
1225 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1226 */
1227 static int __init vivi_init(void)
1228 {
1229 const struct font_desc *font = find_font("VGA8x16");
1230 int ret = 0, i;
1231
1232 if (font == NULL) {
1233 printk(KERN_ERR "vivi: could not find font\n");
1234 return -ENODEV;
1235 }
1236 font8x16 = font->data;
1237
1238 if (n_devs <= 0)
1239 n_devs = 1;
1240
1241 for (i = 0; i < n_devs; i++) {
1242 ret = vivi_create_instance(i);
1243 if (ret) {
1244 /* If some instantiations succeeded, keep driver */
1245 if (i)
1246 ret = 0;
1247 break;
1248 }
1249 }
1250
1251 if (ret < 0) {
1252 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1253 return ret;
1254 }
1255
1256 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1257 "Capture Board ver %u.%u.%u successfully loaded.\n",
1258 (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1259 VIVI_VERSION & 0xFF);
1260
1261 /* n_devs will reflect the actual number of allocated devices */
1262 n_devs = i;
1263
1264 return ret;
1265 }
1266
1267 static void __exit vivi_exit(void)
1268 {
1269 vivi_release();
1270 }
1271
1272 module_init(vivi_init);
1273 module_exit(vivi_exit);
Linux kernel - Deliverables
This page took 0.077134 seconds and 5 git commands to generate.