projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'boards-for-3.17' of git://git.kernel.org/pub/scm/linux/kernel/git/arm...
[deliverable/linux.git] / drivers / media / platform / 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 * Conversion to videobuf2 by Pawel Osciak & Marek Szyprowski
11 * Copyright (c) 2010 Samsung Electronics
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the BSD Licence, GNU General Public License
15 * as published by the Free Software Foundation; either version 2 of the
16 * License, or (at your option) any later version
17 */
18 #include <linux/module.h>
19 #include <linux/errno.h>
20 #include <linux/kernel.h>
21 #include <linux/init.h>
22 #include <linux/sched.h>
23 #include <linux/slab.h>
24 #include <linux/font.h>
25 #include <linux/mutex.h>
26 #include <linux/videodev2.h>
27 #include <linux/kthread.h>
28 #include <linux/freezer.h>
29 #include <media/videobuf2-vmalloc.h>
30 #include <media/v4l2-device.h>
31 #include <media/v4l2-ioctl.h>
32 #include <media/v4l2-ctrls.h>
33 #include <media/v4l2-fh.h>
34 #include <media/v4l2-event.h>
35 #include <media/v4l2-common.h>
36
37 #define VIVI_MODULE_NAME "vivi"
38
39 /* Maximum allowed frame rate
40 *
41 * Vivi will allow setting timeperframe in [1/FPS_MAX - FPS_MAX/1] range.
42 *
43 * Ideally FPS_MAX should be infinity, i.e. practically UINT_MAX, but that
44 * might hit application errors when they manipulate these values.
45 *
46 * Besides, for tpf < 1ms image-generation logic should be changed, to avoid
47 * producing frames with equal content.
48 */
49 #define FPS_MAX 1000
50
51 #define MAX_WIDTH 1920
52 #define MAX_HEIGHT 1200
53
54 #define VIVI_VERSION "0.8.1"
55
56 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
57 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
58 MODULE_LICENSE("Dual BSD/GPL");
59 MODULE_VERSION(VIVI_VERSION);
60
61 static unsigned video_nr = -1;
62 module_param(video_nr, uint, 0644);
63 MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect");
64
65 static unsigned n_devs = 1;
66 module_param(n_devs, uint, 0644);
67 MODULE_PARM_DESC(n_devs, "number of video devices to create");
68
69 static unsigned debug;
70 module_param(debug, uint, 0644);
71 MODULE_PARM_DESC(debug, "activates debug info");
72
73 /* Global font descriptor */
74 static const u8 *font8x16;
75
76 /* timeperframe: min/max and default */
77 static const struct v4l2_fract
78 tpf_min = {.numerator = 1, .denominator = FPS_MAX},
79 tpf_max = {.numerator = FPS_MAX, .denominator = 1},
80 tpf_default = {.numerator = 1001, .denominator = 30000}; /* NTSC */
81
82 #define dprintk(dev, level, fmt, arg...) \
83 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
84
85 /* ------------------------------------------------------------------
86 Basic structures
87 ------------------------------------------------------------------*/
88
89 struct vivi_fmt {
90 const char *name;
91 u32 fourcc; /* v4l2 format id */
92 u8 depth;
93 bool is_yuv;
94 };
95
96 static const struct vivi_fmt formats[] = {
97 {
98 .name = "4:2:2, packed, YUYV",
99 .fourcc = V4L2_PIX_FMT_YUYV,
100 .depth = 16,
101 .is_yuv = true,
102 },
103 {
104 .name = "4:2:2, packed, UYVY",
105 .fourcc = V4L2_PIX_FMT_UYVY,
106 .depth = 16,
107 .is_yuv = true,
108 },
109 {
110 .name = "4:2:2, packed, YVYU",
111 .fourcc = V4L2_PIX_FMT_YVYU,
112 .depth = 16,
113 .is_yuv = true,
114 },
115 {
116 .name = "4:2:2, packed, VYUY",
117 .fourcc = V4L2_PIX_FMT_VYUY,
118 .depth = 16,
119 .is_yuv = true,
120 },
121 {
122 .name = "RGB565 (LE)",
123 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
124 .depth = 16,
125 },
126 {
127 .name = "RGB565 (BE)",
128 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
129 .depth = 16,
130 },
131 {
132 .name = "RGB555 (LE)",
133 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
134 .depth = 16,
135 },
136 {
137 .name = "RGB555 (BE)",
138 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
139 .depth = 16,
140 },
141 {
142 .name = "RGB24 (LE)",
143 .fourcc = V4L2_PIX_FMT_RGB24, /* rgb */
144 .depth = 24,
145 },
146 {
147 .name = "RGB24 (BE)",
148 .fourcc = V4L2_PIX_FMT_BGR24, /* bgr */
149 .depth = 24,
150 },
151 {
152 .name = "RGB32 (LE)",
153 .fourcc = V4L2_PIX_FMT_RGB32, /* argb */
154 .depth = 32,
155 },
156 {
157 .name = "RGB32 (BE)",
158 .fourcc = V4L2_PIX_FMT_BGR32, /* bgra */
159 .depth = 32,
160 },
161 };
162
163 static const struct vivi_fmt *__get_format(u32 pixelformat)
164 {
165 const struct vivi_fmt *fmt;
166 unsigned int k;
167
168 for (k = 0; k < ARRAY_SIZE(formats); k++) {
169 fmt = &formats[k];
170 if (fmt->fourcc == pixelformat)
171 break;
172 }
173
174 if (k == ARRAY_SIZE(formats))
175 return NULL;
176
177 return &formats[k];
178 }
179
180 static const struct vivi_fmt *get_format(struct v4l2_format *f)
181 {
182 return __get_format(f->fmt.pix.pixelformat);
183 }
184
185 /* buffer for one video frame */
186 struct vivi_buffer {
187 /* common v4l buffer stuff -- must be first */
188 struct vb2_buffer vb;
189 struct list_head list;
190 };
191
192 struct vivi_dmaqueue {
193 struct list_head active;
194
195 /* thread for generating video stream*/
196 struct task_struct *kthread;
197 wait_queue_head_t wq;
198 /* Counters to control fps rate */
199 int frame;
200 int ini_jiffies;
201 };
202
203 static LIST_HEAD(vivi_devlist);
204
205 struct vivi_dev {
206 struct list_head vivi_devlist;
207 struct v4l2_device v4l2_dev;
208 struct v4l2_ctrl_handler ctrl_handler;
209 struct video_device vdev;
210
211 /* controls */
212 struct v4l2_ctrl *brightness;
213 struct v4l2_ctrl *contrast;
214 struct v4l2_ctrl *saturation;
215 struct v4l2_ctrl *hue;
216 struct {
217 /* autogain/gain cluster */
218 struct v4l2_ctrl *autogain;
219 struct v4l2_ctrl *gain;
220 };
221 struct v4l2_ctrl *volume;
222 struct v4l2_ctrl *alpha;
223 struct v4l2_ctrl *button;
224 struct v4l2_ctrl *boolean;
225 struct v4l2_ctrl *int32;
226 struct v4l2_ctrl *int64;
227 struct v4l2_ctrl *menu;
228 struct v4l2_ctrl *string;
229 struct v4l2_ctrl *bitmask;
230 struct v4l2_ctrl *int_menu;
231
232 spinlock_t slock;
233 struct mutex mutex;
234
235 struct vivi_dmaqueue vidq;
236
237 /* Several counters */
238 unsigned ms;
239 unsigned long jiffies;
240 unsigned button_pressed;
241
242 int mv_count; /* Controls bars movement */
243
244 /* Input Number */
245 int input;
246
247 /* video capture */
248 const struct vivi_fmt *fmt;
249 struct v4l2_fract timeperframe;
250 unsigned int width, height;
251 struct vb2_queue vb_vidq;
252 unsigned int seq_count;
253
254 u8 bars[9][3];
255 u8 line[MAX_WIDTH * 8] __attribute__((__aligned__(4)));
256 unsigned int pixelsize;
257 u8 alpha_component;
258 u32 textfg, textbg;
259 };
260
261 /* ------------------------------------------------------------------
262 DMA and thread functions
263 ------------------------------------------------------------------*/
264
265 /* Bars and Colors should match positions */
266
267 enum colors {
268 WHITE,
269 AMBER,
270 CYAN,
271 GREEN,
272 MAGENTA,
273 RED,
274 BLUE,
275 BLACK,
276 TEXT_BLACK,
277 };
278
279 /* R G B */
280 #define COLOR_WHITE {204, 204, 204}
281 #define COLOR_AMBER {208, 208, 0}
282 #define COLOR_CYAN { 0, 206, 206}
283 #define COLOR_GREEN { 0, 239, 0}
284 #define COLOR_MAGENTA {239, 0, 239}
285 #define COLOR_RED {205, 0, 0}
286 #define COLOR_BLUE { 0, 0, 255}
287 #define COLOR_BLACK { 0, 0, 0}
288
289 struct bar_std {
290 u8 bar[9][3];
291 };
292
293 /* Maximum number of bars are 10 - otherwise, the input print code
294 should be modified */
295 static const struct bar_std bars[] = {
296 { /* Standard ITU-R color bar sequence */
297 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
298 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
299 }, {
300 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
301 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
302 }, {
303 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
304 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
305 }, {
306 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
307 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
308 },
309 };
310
311 #define NUM_INPUTS ARRAY_SIZE(bars)
312
313 #define TO_Y(r, g, b) \
314 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
315 /* RGB to V(Cr) Color transform */
316 #define TO_V(r, g, b) \
317 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
318 /* RGB to U(Cb) Color transform */
319 #define TO_U(r, g, b) \
320 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
321
322 /* precalculate color bar values to speed up rendering */
323 static void precalculate_bars(struct vivi_dev *dev)
324 {
325 u8 r, g, b;
326 int k, is_yuv;
327
328 for (k = 0; k < 9; k++) {
329 r = bars[dev->input].bar[k][0];
330 g = bars[dev->input].bar[k][1];
331 b = bars[dev->input].bar[k][2];
332 is_yuv = dev->fmt->is_yuv;
333
334 switch (dev->fmt->fourcc) {
335 case V4L2_PIX_FMT_RGB565:
336 case V4L2_PIX_FMT_RGB565X:
337 r >>= 3;
338 g >>= 2;
339 b >>= 3;
340 break;
341 case V4L2_PIX_FMT_RGB555:
342 case V4L2_PIX_FMT_RGB555X:
343 r >>= 3;
344 g >>= 3;
345 b >>= 3;
346 break;
347 case V4L2_PIX_FMT_YUYV:
348 case V4L2_PIX_FMT_UYVY:
349 case V4L2_PIX_FMT_YVYU:
350 case V4L2_PIX_FMT_VYUY:
351 case V4L2_PIX_FMT_RGB24:
352 case V4L2_PIX_FMT_BGR24:
353 case V4L2_PIX_FMT_RGB32:
354 case V4L2_PIX_FMT_BGR32:
355 break;
356 }
357
358 if (is_yuv) {
359 dev->bars[k][0] = TO_Y(r, g, b); /* Luma */
360 dev->bars[k][1] = TO_U(r, g, b); /* Cb */
361 dev->bars[k][2] = TO_V(r, g, b); /* Cr */
362 } else {
363 dev->bars[k][0] = r;
364 dev->bars[k][1] = g;
365 dev->bars[k][2] = b;
366 }
367 }
368 }
369
370 /* 'odd' is true for pixels 1, 3, 5, etc. and false for pixels 0, 2, 4, etc. */
371 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos, bool odd)
372 {
373 u8 r_y, g_u, b_v;
374 u8 alpha = dev->alpha_component;
375 int color;
376 u8 *p;
377
378 r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
379 g_u = dev->bars[colorpos][1]; /* G or precalculated U */
380 b_v = dev->bars[colorpos][2]; /* B or precalculated V */
381
382 for (color = 0; color < dev->pixelsize; color++) {
383 p = buf + color;
384
385 switch (dev->fmt->fourcc) {
386 case V4L2_PIX_FMT_YUYV:
387 switch (color) {
388 case 0:
389 *p = r_y;
390 break;
391 case 1:
392 *p = odd ? b_v : g_u;
393 break;
394 }
395 break;
396 case V4L2_PIX_FMT_UYVY:
397 switch (color) {
398 case 0:
399 *p = odd ? b_v : g_u;
400 break;
401 case 1:
402 *p = r_y;
403 break;
404 }
405 break;
406 case V4L2_PIX_FMT_YVYU:
407 switch (color) {
408 case 0:
409 *p = r_y;
410 break;
411 case 1:
412 *p = odd ? g_u : b_v;
413 break;
414 }
415 break;
416 case V4L2_PIX_FMT_VYUY:
417 switch (color) {
418 case 0:
419 *p = odd ? g_u : b_v;
420 break;
421 case 1:
422 *p = r_y;
423 break;
424 }
425 break;
426 case V4L2_PIX_FMT_RGB565:
427 switch (color) {
428 case 0:
429 *p = (g_u << 5) | b_v;
430 break;
431 case 1:
432 *p = (r_y << 3) | (g_u >> 3);
433 break;
434 }
435 break;
436 case V4L2_PIX_FMT_RGB565X:
437 switch (color) {
438 case 0:
439 *p = (r_y << 3) | (g_u >> 3);
440 break;
441 case 1:
442 *p = (g_u << 5) | b_v;
443 break;
444 }
445 break;
446 case V4L2_PIX_FMT_RGB555:
447 switch (color) {
448 case 0:
449 *p = (g_u << 5) | b_v;
450 break;
451 case 1:
452 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
453 break;
454 }
455 break;
456 case V4L2_PIX_FMT_RGB555X:
457 switch (color) {
458 case 0:
459 *p = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
460 break;
461 case 1:
462 *p = (g_u << 5) | b_v;
463 break;
464 }
465 break;
466 case V4L2_PIX_FMT_RGB24:
467 switch (color) {
468 case 0:
469 *p = r_y;
470 break;
471 case 1:
472 *p = g_u;
473 break;
474 case 2:
475 *p = b_v;
476 break;
477 }
478 break;
479 case V4L2_PIX_FMT_BGR24:
480 switch (color) {
481 case 0:
482 *p = b_v;
483 break;
484 case 1:
485 *p = g_u;
486 break;
487 case 2:
488 *p = r_y;
489 break;
490 }
491 break;
492 case V4L2_PIX_FMT_RGB32:
493 switch (color) {
494 case 0:
495 *p = alpha;
496 break;
497 case 1:
498 *p = r_y;
499 break;
500 case 2:
501 *p = g_u;
502 break;
503 case 3:
504 *p = b_v;
505 break;
506 }
507 break;
508 case V4L2_PIX_FMT_BGR32:
509 switch (color) {
510 case 0:
511 *p = b_v;
512 break;
513 case 1:
514 *p = g_u;
515 break;
516 case 2:
517 *p = r_y;
518 break;
519 case 3:
520 *p = alpha;
521 break;
522 }
523 break;
524 }
525 }
526 }
527
528 static void precalculate_line(struct vivi_dev *dev)
529 {
530 unsigned pixsize = dev->pixelsize;
531 unsigned pixsize2 = 2*pixsize;
532 int colorpos;
533 u8 *pos;
534
535 for (colorpos = 0; colorpos < 16; ++colorpos) {
536 u8 pix[8];
537 int wstart = colorpos * dev->width / 8;
538 int wend = (colorpos+1) * dev->width / 8;
539 int w;
540
541 gen_twopix(dev, &pix[0], colorpos % 8, 0);
542 gen_twopix(dev, &pix[pixsize], colorpos % 8, 1);
543
544 for (w = wstart/2*2, pos = dev->line + w*pixsize; w < wend; w += 2, pos += pixsize2)
545 memcpy(pos, pix, pixsize2);
546 }
547 }
548
549 /* need this to do rgb24 rendering */
550 typedef struct { u16 __; u8 _; } __attribute__((packed)) x24;
551
552 static void gen_text(struct vivi_dev *dev, char *basep,
553 int y, int x, char *text)
554 {
555 int line;
556 unsigned int width = dev->width;
557
558 /* Checks if it is possible to show string */
559 if (y + 16 >= dev->height || x + strlen(text) * 8 >= width)
560 return;
561
562 /* Print stream time */
563 #define PRINTSTR(PIXTYPE) do { \
564 PIXTYPE fg; \
565 PIXTYPE bg; \
566 memcpy(&fg, &dev->textfg, sizeof(PIXTYPE)); \
567 memcpy(&bg, &dev->textbg, sizeof(PIXTYPE)); \
568 \
569 for (line = 0; line < 16; line++) { \
570 PIXTYPE *pos = (PIXTYPE *)( basep + ((y + line) * width + x) * sizeof(PIXTYPE) ); \
571 u8 *s; \
572 \
573 for (s = text; *s; s++) { \
574 u8 chr = font8x16[*s * 16 + line]; \
575 \
576 pos[0] = (chr & (0x01 << 7) ? fg : bg); \
577 pos[1] = (chr & (0x01 << 6) ? fg : bg); \
578 pos[2] = (chr & (0x01 << 5) ? fg : bg); \
579 pos[3] = (chr & (0x01 << 4) ? fg : bg); \
580 pos[4] = (chr & (0x01 << 3) ? fg : bg); \
581 pos[5] = (chr & (0x01 << 2) ? fg : bg); \
582 pos[6] = (chr & (0x01 << 1) ? fg : bg); \
583 pos[7] = (chr & (0x01 << 0) ? fg : bg); \
584 \
585 pos += 8; \
586 } \
587 } \
588 } while (0)
589
590 switch (dev->pixelsize) {
591 case 2:
592 PRINTSTR(u16); break;
593 case 4:
594 PRINTSTR(u32); break;
595 case 3:
596 PRINTSTR(x24); break;
597 }
598 }
599
600 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
601 {
602 int stride = dev->width * dev->pixelsize;
603 int hmax = dev->height;
604 void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
605 unsigned ms;
606 char str[100];
607 int h, line = 1;
608 u8 *linestart;
609 s32 gain;
610
611 if (!vbuf)
612 return;
613
614 linestart = dev->line + (dev->mv_count % dev->width) * dev->pixelsize;
615
616 for (h = 0; h < hmax; h++)
617 memcpy(vbuf + h * stride, linestart, stride);
618
619 /* Updates stream time */
620
621 gen_twopix(dev, (u8 *)&dev->textbg, TEXT_BLACK, /*odd=*/ 0);
622 gen_twopix(dev, (u8 *)&dev->textfg, WHITE, /*odd=*/ 0);
623
624 dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
625 dev->jiffies = jiffies;
626 ms = dev->ms;
627 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
628 (ms / (60 * 60 * 1000)) % 24,
629 (ms / (60 * 1000)) % 60,
630 (ms / 1000) % 60,
631 ms % 1000);
632 gen_text(dev, vbuf, line++ * 16, 16, str);
633 snprintf(str, sizeof(str), " %dx%d, input %d ",
634 dev->width, dev->height, dev->input);
635 gen_text(dev, vbuf, line++ * 16, 16, str);
636
637 gain = v4l2_ctrl_g_ctrl(dev->gain);
638 mutex_lock(dev->ctrl_handler.lock);
639 snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
640 dev->brightness->cur.val,
641 dev->contrast->cur.val,
642 dev->saturation->cur.val,
643 dev->hue->cur.val);
644 gen_text(dev, vbuf, line++ * 16, 16, str);
645 snprintf(str, sizeof(str), " autogain %d, gain %3d, volume %3d, alpha 0x%02x ",
646 dev->autogain->cur.val, gain, dev->volume->cur.val,
647 dev->alpha->cur.val);
648 gen_text(dev, vbuf, line++ * 16, 16, str);
649 snprintf(str, sizeof(str), " int32 %d, int64 %lld, bitmask %08x ",
650 dev->int32->cur.val,
651 *dev->int64->p_cur.p_s64,
652 dev->bitmask->cur.val);
653 gen_text(dev, vbuf, line++ * 16, 16, str);
654 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
655 dev->boolean->cur.val,
656 dev->menu->qmenu[dev->menu->cur.val],
657 dev->string->p_cur.p_char);
658 gen_text(dev, vbuf, line++ * 16, 16, str);
659 snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
660 dev->int_menu->qmenu_int[dev->int_menu->cur.val],
661 dev->int_menu->cur.val);
662 gen_text(dev, vbuf, line++ * 16, 16, str);
663 mutex_unlock(dev->ctrl_handler.lock);
664 if (dev->button_pressed) {
665 dev->button_pressed--;
666 snprintf(str, sizeof(str), " button pressed!");
667 gen_text(dev, vbuf, line++ * 16, 16, str);
668 }
669
670 dev->mv_count += 2;
671
672 buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
673 buf->vb.v4l2_buf.sequence = dev->seq_count++;
674 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
675 }
676
677 static void vivi_thread_tick(struct vivi_dev *dev)
678 {
679 struct vivi_dmaqueue *dma_q = &dev->vidq;
680 struct vivi_buffer *buf;
681 unsigned long flags = 0;
682
683 dprintk(dev, 1, "Thread tick\n");
684
685 spin_lock_irqsave(&dev->slock, flags);
686 if (list_empty(&dma_q->active)) {
687 dprintk(dev, 1, "No active queue to serve\n");
688 spin_unlock_irqrestore(&dev->slock, flags);
689 return;
690 }
691
692 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
693 list_del(&buf->list);
694 spin_unlock_irqrestore(&dev->slock, flags);
695
696 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
697
698 /* Fill buffer */
699 vivi_fillbuff(dev, buf);
700 dprintk(dev, 1, "filled buffer %p\n", buf);
701
702 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
703 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
704 }
705
706 #define frames_to_ms(dev, frames) \
707 ((frames * dev->timeperframe.numerator * 1000) / dev->timeperframe.denominator)
708
709 static void vivi_sleep(struct vivi_dev *dev)
710 {
711 struct vivi_dmaqueue *dma_q = &dev->vidq;
712 int timeout;
713 DECLARE_WAITQUEUE(wait, current);
714
715 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
716 (unsigned long)dma_q);
717
718 add_wait_queue(&dma_q->wq, &wait);
719 if (kthread_should_stop())
720 goto stop_task;
721
722 /* Calculate time to wake up */
723 timeout = msecs_to_jiffies(frames_to_ms(dev, 1));
724
725 vivi_thread_tick(dev);
726
727 schedule_timeout_interruptible(timeout);
728
729 stop_task:
730 remove_wait_queue(&dma_q->wq, &wait);
731 try_to_freeze();
732 }
733
734 static int vivi_thread(void *data)
735 {
736 struct vivi_dev *dev = data;
737
738 dprintk(dev, 1, "thread started\n");
739
740 set_freezable();
741
742 for (;;) {
743 vivi_sleep(dev);
744
745 if (kthread_should_stop())
746 break;
747 }
748 dprintk(dev, 1, "thread: exit\n");
749 return 0;
750 }
751
752 static int vivi_start_generating(struct vivi_dev *dev)
753 {
754 struct vivi_dmaqueue *dma_q = &dev->vidq;
755
756 dprintk(dev, 1, "%s\n", __func__);
757
758 /* Resets frame counters */
759 dev->ms = 0;
760 dev->mv_count = 0;
761 dev->jiffies = jiffies;
762
763 dma_q->frame = 0;
764 dma_q->ini_jiffies = jiffies;
765 dma_q->kthread = kthread_run(vivi_thread, dev, "%s",
766 dev->v4l2_dev.name);
767
768 if (IS_ERR(dma_q->kthread)) {
769 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
770 return PTR_ERR(dma_q->kthread);
771 }
772 /* Wakes thread */
773 wake_up_interruptible(&dma_q->wq);
774
775 dprintk(dev, 1, "returning from %s\n", __func__);
776 return 0;
777 }
778
779 static void vivi_stop_generating(struct vivi_dev *dev)
780 {
781 struct vivi_dmaqueue *dma_q = &dev->vidq;
782
783 dprintk(dev, 1, "%s\n", __func__);
784
785 /* shutdown control thread */
786 if (dma_q->kthread) {
787 kthread_stop(dma_q->kthread);
788 dma_q->kthread = NULL;
789 }
790
791 /*
792 * Typical driver might need to wait here until dma engine stops.
793 * In this case we can abort imiedetly, so it's just a noop.
794 */
795
796 /* Release all active buffers */
797 while (!list_empty(&dma_q->active)) {
798 struct vivi_buffer *buf;
799 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
800 list_del(&buf->list);
801 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
802 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
803 }
804 }
805 /* ------------------------------------------------------------------
806 Videobuf operations
807 ------------------------------------------------------------------*/
808 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
809 unsigned int *nbuffers, unsigned int *nplanes,
810 unsigned int sizes[], void *alloc_ctxs[])
811 {
812 struct vivi_dev *dev = vb2_get_drv_priv(vq);
813 unsigned long size;
814
815 size = dev->width * dev->height * dev->pixelsize;
816 if (fmt) {
817 if (fmt->fmt.pix.sizeimage < size)
818 return -EINVAL;
819 size = fmt->fmt.pix.sizeimage;
820 /* check against insane over 8K resolution buffers */
821 if (size > 7680 * 4320 * dev->pixelsize)
822 return -EINVAL;
823 }
824
825 *nplanes = 1;
826
827 sizes[0] = size;
828
829 /*
830 * videobuf2-vmalloc allocator is context-less so no need to set
831 * alloc_ctxs array.
832 */
833
834 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
835 *nbuffers, size);
836
837 return 0;
838 }
839
840 static int buffer_prepare(struct vb2_buffer *vb)
841 {
842 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
843 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
844 unsigned long size;
845
846 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
847
848 BUG_ON(NULL == dev->fmt);
849
850 /*
851 * Theses properties only change when queue is idle, see s_fmt.
852 * The below checks should not be performed here, on each
853 * buffer_prepare (i.e. on each qbuf). Most of the code in this function
854 * should thus be moved to buffer_init and s_fmt.
855 */
856 if (dev->width < 48 || dev->width > MAX_WIDTH ||
857 dev->height < 32 || dev->height > MAX_HEIGHT)
858 return -EINVAL;
859
860 size = dev->width * dev->height * dev->pixelsize;
861 if (vb2_plane_size(vb, 0) < size) {
862 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
863 __func__, vb2_plane_size(vb, 0), size);
864 return -EINVAL;
865 }
866
867 vb2_set_plane_payload(&buf->vb, 0, size);
868
869 precalculate_bars(dev);
870 precalculate_line(dev);
871
872 return 0;
873 }
874
875 static void buffer_queue(struct vb2_buffer *vb)
876 {
877 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
878 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
879 struct vivi_dmaqueue *vidq = &dev->vidq;
880 unsigned long flags = 0;
881
882 dprintk(dev, 1, "%s\n", __func__);
883
884 spin_lock_irqsave(&dev->slock, flags);
885 list_add_tail(&buf->list, &vidq->active);
886 spin_unlock_irqrestore(&dev->slock, flags);
887 }
888
889 static int start_streaming(struct vb2_queue *vq, unsigned int count)
890 {
891 struct vivi_dev *dev = vb2_get_drv_priv(vq);
892 int err;
893
894 dprintk(dev, 1, "%s\n", __func__);
895 dev->seq_count = 0;
896 err = vivi_start_generating(dev);
897 if (err) {
898 struct vivi_buffer *buf, *tmp;
899
900 list_for_each_entry_safe(buf, tmp, &dev->vidq.active, list) {
901 list_del(&buf->list);
902 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_QUEUED);
903 }
904 }
905 return err;
906 }
907
908 /* abort streaming and wait for last buffer */
909 static void stop_streaming(struct vb2_queue *vq)
910 {
911 struct vivi_dev *dev = vb2_get_drv_priv(vq);
912 dprintk(dev, 1, "%s\n", __func__);
913 vivi_stop_generating(dev);
914 }
915
916 static void vivi_lock(struct vb2_queue *vq)
917 {
918 struct vivi_dev *dev = vb2_get_drv_priv(vq);
919 mutex_lock(&dev->mutex);
920 }
921
922 static void vivi_unlock(struct vb2_queue *vq)
923 {
924 struct vivi_dev *dev = vb2_get_drv_priv(vq);
925 mutex_unlock(&dev->mutex);
926 }
927
928
929 static const struct vb2_ops vivi_video_qops = {
930 .queue_setup = queue_setup,
931 .buf_prepare = buffer_prepare,
932 .buf_queue = buffer_queue,
933 .start_streaming = start_streaming,
934 .stop_streaming = stop_streaming,
935 .wait_prepare = vivi_unlock,
936 .wait_finish = vivi_lock,
937 };
938
939 /* ------------------------------------------------------------------
940 IOCTL vidioc handling
941 ------------------------------------------------------------------*/
942 static int vidioc_querycap(struct file *file, void *priv,
943 struct v4l2_capability *cap)
944 {
945 struct vivi_dev *dev = video_drvdata(file);
946
947 strcpy(cap->driver, "vivi");
948 strcpy(cap->card, "vivi");
949 snprintf(cap->bus_info, sizeof(cap->bus_info),
950 "platform:%s", dev->v4l2_dev.name);
951 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
952 V4L2_CAP_READWRITE;
953 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
954 return 0;
955 }
956
957 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
958 struct v4l2_fmtdesc *f)
959 {
960 const struct vivi_fmt *fmt;
961
962 if (f->index >= ARRAY_SIZE(formats))
963 return -EINVAL;
964
965 fmt = &formats[f->index];
966
967 strlcpy(f->description, fmt->name, sizeof(f->description));
968 f->pixelformat = fmt->fourcc;
969 return 0;
970 }
971
972 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
973 struct v4l2_format *f)
974 {
975 struct vivi_dev *dev = video_drvdata(file);
976
977 f->fmt.pix.width = dev->width;
978 f->fmt.pix.height = dev->height;
979 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
980 f->fmt.pix.pixelformat = dev->fmt->fourcc;
981 f->fmt.pix.bytesperline =
982 (f->fmt.pix.width * dev->fmt->depth) >> 3;
983 f->fmt.pix.sizeimage =
984 f->fmt.pix.height * f->fmt.pix.bytesperline;
985 if (dev->fmt->is_yuv)
986 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
987 else
988 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
989 return 0;
990 }
991
992 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
993 struct v4l2_format *f)
994 {
995 struct vivi_dev *dev = video_drvdata(file);
996 const struct vivi_fmt *fmt;
997
998 fmt = get_format(f);
999 if (!fmt) {
1000 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
1001 f->fmt.pix.pixelformat);
1002 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1003 fmt = get_format(f);
1004 }
1005
1006 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1007 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
1008 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
1009 f->fmt.pix.bytesperline =
1010 (f->fmt.pix.width * fmt->depth) >> 3;
1011 f->fmt.pix.sizeimage =
1012 f->fmt.pix.height * f->fmt.pix.bytesperline;
1013 if (fmt->is_yuv)
1014 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1015 else
1016 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
1017 return 0;
1018 }
1019
1020 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1021 struct v4l2_format *f)
1022 {
1023 struct vivi_dev *dev = video_drvdata(file);
1024 struct vb2_queue *q = &dev->vb_vidq;
1025
1026 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
1027 if (ret < 0)
1028 return ret;
1029
1030 if (vb2_is_busy(q)) {
1031 dprintk(dev, 1, "%s device busy\n", __func__);
1032 return -EBUSY;
1033 }
1034
1035 dev->fmt = get_format(f);
1036 dev->pixelsize = dev->fmt->depth / 8;
1037 dev->width = f->fmt.pix.width;
1038 dev->height = f->fmt.pix.height;
1039
1040 return 0;
1041 }
1042
1043 static int vidioc_enum_framesizes(struct file *file, void *fh,
1044 struct v4l2_frmsizeenum *fsize)
1045 {
1046 static const struct v4l2_frmsize_stepwise sizes = {
1047 48, MAX_WIDTH, 4,
1048 32, MAX_HEIGHT, 1
1049 };
1050 int i;
1051
1052 if (fsize->index)
1053 return -EINVAL;
1054 for (i = 0; i < ARRAY_SIZE(formats); i++)
1055 if (formats[i].fourcc == fsize->pixel_format)
1056 break;
1057 if (i == ARRAY_SIZE(formats))
1058 return -EINVAL;
1059 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1060 fsize->stepwise = sizes;
1061 return 0;
1062 }
1063
1064 /* only one input in this sample driver */
1065 static int vidioc_enum_input(struct file *file, void *priv,
1066 struct v4l2_input *inp)
1067 {
1068 if (inp->index >= NUM_INPUTS)
1069 return -EINVAL;
1070
1071 inp->type = V4L2_INPUT_TYPE_CAMERA;
1072 sprintf(inp->name, "Camera %u", inp->index);
1073 return 0;
1074 }
1075
1076 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1077 {
1078 struct vivi_dev *dev = video_drvdata(file);
1079
1080 *i = dev->input;
1081 return 0;
1082 }
1083
1084 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1085 {
1086 struct vivi_dev *dev = video_drvdata(file);
1087
1088 if (i >= NUM_INPUTS)
1089 return -EINVAL;
1090
1091 if (i == dev->input)
1092 return 0;
1093
1094 dev->input = i;
1095 /*
1096 * Modify the brightness range depending on the input.
1097 * This makes it easy to use vivi to test if applications can
1098 * handle control range modifications and is also how this is
1099 * typically used in practice as different inputs may be hooked
1100 * up to different receivers with different control ranges.
1101 */
1102 v4l2_ctrl_modify_range(dev->brightness,
1103 128 * i, 255 + 128 * i, 1, 127 + 128 * i);
1104 precalculate_bars(dev);
1105 precalculate_line(dev);
1106 return 0;
1107 }
1108
1109 /* timeperframe is arbitrary and continuous */
1110 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1111 struct v4l2_frmivalenum *fival)
1112 {
1113 const struct vivi_fmt *fmt;
1114
1115 if (fival->index)
1116 return -EINVAL;
1117
1118 fmt = __get_format(fival->pixel_format);
1119 if (!fmt)
1120 return -EINVAL;
1121
1122 /* check for valid width/height */
1123 if (fival->width < 48 || fival->width > MAX_WIDTH || (fival->width & 3))
1124 return -EINVAL;
1125 if (fival->height < 32 || fival->height > MAX_HEIGHT)
1126 return -EINVAL;
1127
1128 fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
1129
1130 /* fill in stepwise (step=1.0 is required by V4L2 spec) */
1131 fival->stepwise.min = tpf_min;
1132 fival->stepwise.max = tpf_max;
1133 fival->stepwise.step = (struct v4l2_fract) {1, 1};
1134
1135 return 0;
1136 }
1137
1138 static int vidioc_g_parm(struct file *file, void *priv,
1139 struct v4l2_streamparm *parm)
1140 {
1141 struct vivi_dev *dev = video_drvdata(file);
1142
1143 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1144 return -EINVAL;
1145
1146 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1147 parm->parm.capture.timeperframe = dev->timeperframe;
1148 parm->parm.capture.readbuffers = 1;
1149 return 0;
1150 }
1151
1152 #define FRACT_CMP(a, OP, b) \
1153 ((u64)(a).numerator * (b).denominator OP (u64)(b).numerator * (a).denominator)
1154
1155 static int vidioc_s_parm(struct file *file, void *priv,
1156 struct v4l2_streamparm *parm)
1157 {
1158 struct vivi_dev *dev = video_drvdata(file);
1159 struct v4l2_fract tpf;
1160
1161 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1162 return -EINVAL;
1163
1164 tpf = parm->parm.capture.timeperframe;
1165
1166 /* tpf: {*, 0} resets timing; clip to [min, max]*/
1167 tpf = tpf.denominator ? tpf : tpf_default;
1168 tpf = FRACT_CMP(tpf, <, tpf_min) ? tpf_min : tpf;
1169 tpf = FRACT_CMP(tpf, >, tpf_max) ? tpf_max : tpf;
1170
1171 dev->timeperframe = tpf;
1172 parm->parm.capture.timeperframe = tpf;
1173 parm->parm.capture.readbuffers = 1;
1174 return 0;
1175 }
1176
1177 /* --- controls ---------------------------------------------- */
1178
1179 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1180 {
1181 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1182
1183 if (ctrl == dev->autogain)
1184 dev->gain->val = jiffies & 0xff;
1185 return 0;
1186 }
1187
1188 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1189 {
1190 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1191
1192 switch (ctrl->id) {
1193 case V4L2_CID_ALPHA_COMPONENT:
1194 dev->alpha_component = ctrl->val;
1195 break;
1196 default:
1197 if (ctrl == dev->button)
1198 dev->button_pressed = 30;
1199 break;
1200 }
1201 return 0;
1202 }
1203
1204 /* ------------------------------------------------------------------
1205 File operations for the device
1206 ------------------------------------------------------------------*/
1207
1208 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1209 .g_volatile_ctrl = vivi_g_volatile_ctrl,
1210 .s_ctrl = vivi_s_ctrl,
1211 };
1212
1213 #define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1214
1215 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1216 .ops = &vivi_ctrl_ops,
1217 .id = VIVI_CID_CUSTOM_BASE + 0,
1218 .name = "Button",
1219 .type = V4L2_CTRL_TYPE_BUTTON,
1220 };
1221
1222 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1223 .ops = &vivi_ctrl_ops,
1224 .id = VIVI_CID_CUSTOM_BASE + 1,
1225 .name = "Boolean",
1226 .type = V4L2_CTRL_TYPE_BOOLEAN,
1227 .min = 0,
1228 .max = 1,
1229 .step = 1,
1230 .def = 1,
1231 };
1232
1233 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1234 .ops = &vivi_ctrl_ops,
1235 .id = VIVI_CID_CUSTOM_BASE + 2,
1236 .name = "Integer 32 Bits",
1237 .type = V4L2_CTRL_TYPE_INTEGER,
1238 .min = -0x80000000LL,
1239 .max = 0x7fffffff,
1240 .step = 1,
1241 };
1242
1243 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1244 .ops = &vivi_ctrl_ops,
1245 .id = VIVI_CID_CUSTOM_BASE + 3,
1246 .name = "Integer 64 Bits",
1247 .type = V4L2_CTRL_TYPE_INTEGER64,
1248 .min = LLONG_MIN,
1249 .max = LLONG_MAX,
1250 .step = 1,
1251 };
1252
1253 static const char * const vivi_ctrl_menu_strings[] = {
1254 "Menu Item 0 (Skipped)",
1255 "Menu Item 1",
1256 "Menu Item 2 (Skipped)",
1257 "Menu Item 3",
1258 "Menu Item 4",
1259 "Menu Item 5 (Skipped)",
1260 NULL,
1261 };
1262
1263 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1264 .ops = &vivi_ctrl_ops,
1265 .id = VIVI_CID_CUSTOM_BASE + 4,
1266 .name = "Menu",
1267 .type = V4L2_CTRL_TYPE_MENU,
1268 .min = 1,
1269 .max = 4,
1270 .def = 3,
1271 .menu_skip_mask = 0x04,
1272 .qmenu = vivi_ctrl_menu_strings,
1273 };
1274
1275 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1276 .ops = &vivi_ctrl_ops,
1277 .id = VIVI_CID_CUSTOM_BASE + 5,
1278 .name = "String",
1279 .type = V4L2_CTRL_TYPE_STRING,
1280 .min = 2,
1281 .max = 4,
1282 .step = 1,
1283 };
1284
1285 static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1286 .ops = &vivi_ctrl_ops,
1287 .id = VIVI_CID_CUSTOM_BASE + 6,
1288 .name = "Bitmask",
1289 .type = V4L2_CTRL_TYPE_BITMASK,
1290 .def = 0x80002000,
1291 .min = 0,
1292 .max = 0x80402010,
1293 .step = 0,
1294 };
1295
1296 static const s64 vivi_ctrl_int_menu_values[] = {
1297 1, 1, 2, 3, 5, 8, 13, 21, 42,
1298 };
1299
1300 static const struct v4l2_ctrl_config vivi_ctrl_int_menu = {
1301 .ops = &vivi_ctrl_ops,
1302 .id = VIVI_CID_CUSTOM_BASE + 7,
1303 .name = "Integer menu",
1304 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
1305 .min = 1,
1306 .max = 8,
1307 .def = 4,
1308 .menu_skip_mask = 0x02,
1309 .qmenu_int = vivi_ctrl_int_menu_values,
1310 };
1311
1312 static const struct v4l2_file_operations vivi_fops = {
1313 .owner = THIS_MODULE,
1314 .open = v4l2_fh_open,
1315 .release = vb2_fop_release,
1316 .read = vb2_fop_read,
1317 .poll = vb2_fop_poll,
1318 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1319 .mmap = vb2_fop_mmap,
1320 };
1321
1322 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1323 .vidioc_querycap = vidioc_querycap,
1324 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1325 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1326 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1327 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1328 .vidioc_enum_framesizes = vidioc_enum_framesizes,
1329 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1330 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1331 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1332 .vidioc_querybuf = vb2_ioctl_querybuf,
1333 .vidioc_qbuf = vb2_ioctl_qbuf,
1334 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1335 .vidioc_enum_input = vidioc_enum_input,
1336 .vidioc_g_input = vidioc_g_input,
1337 .vidioc_s_input = vidioc_s_input,
1338 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1339 .vidioc_g_parm = vidioc_g_parm,
1340 .vidioc_s_parm = vidioc_s_parm,
1341 .vidioc_streamon = vb2_ioctl_streamon,
1342 .vidioc_streamoff = vb2_ioctl_streamoff,
1343 .vidioc_log_status = v4l2_ctrl_log_status,
1344 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1345 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1346 };
1347
1348 static const struct video_device vivi_template = {
1349 .name = "vivi",
1350 .fops = &vivi_fops,
1351 .ioctl_ops = &vivi_ioctl_ops,
1352 .release = video_device_release_empty,
1353 };
1354
1355 /* -----------------------------------------------------------------
1356 Initialization and module stuff
1357 ------------------------------------------------------------------*/
1358
1359 static int vivi_release(void)
1360 {
1361 struct vivi_dev *dev;
1362 struct list_head *list;
1363
1364 while (!list_empty(&vivi_devlist)) {
1365 list = vivi_devlist.next;
1366 list_del(list);
1367 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1368
1369 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1370 video_device_node_name(&dev->vdev));
1371 video_unregister_device(&dev->vdev);
1372 v4l2_device_unregister(&dev->v4l2_dev);
1373 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1374 kfree(dev);
1375 }
1376
1377 return 0;
1378 }
1379
1380 static int __init vivi_create_instance(int inst)
1381 {
1382 struct vivi_dev *dev;
1383 struct video_device *vfd;
1384 struct v4l2_ctrl_handler *hdl;
1385 struct vb2_queue *q;
1386 int ret;
1387
1388 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1389 if (!dev)
1390 return -ENOMEM;
1391
1392 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1393 "%s-%03d", VIVI_MODULE_NAME, inst);
1394 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1395 if (ret)
1396 goto free_dev;
1397
1398 dev->fmt = &formats[0];
1399 dev->timeperframe = tpf_default;
1400 dev->width = 640;
1401 dev->height = 480;
1402 dev->pixelsize = dev->fmt->depth / 8;
1403 hdl = &dev->ctrl_handler;
1404 v4l2_ctrl_handler_init(hdl, 11);
1405 dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1406 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1407 dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1408 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1409 dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1410 V4L2_CID_CONTRAST, 0, 255, 1, 16);
1411 dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1412 V4L2_CID_SATURATION, 0, 255, 1, 127);
1413 dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1414 V4L2_CID_HUE, -128, 127, 1, 0);
1415 dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1416 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1417 dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1418 V4L2_CID_GAIN, 0, 255, 1, 100);
1419 dev->alpha = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1420 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1421 dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1422 dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1423 dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1424 dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1425 dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1426 dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1427 dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1428 dev->int_menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int_menu, NULL);
1429 if (hdl->error) {
1430 ret = hdl->error;
1431 goto unreg_dev;
1432 }
1433 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1434 dev->v4l2_dev.ctrl_handler = hdl;
1435
1436 /* initialize locks */
1437 spin_lock_init(&dev->slock);
1438
1439 /* initialize queue */
1440 q = &dev->vb_vidq;
1441 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1442 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1443 q->drv_priv = dev;
1444 q->buf_struct_size = sizeof(struct vivi_buffer);
1445 q->ops = &vivi_video_qops;
1446 q->mem_ops = &vb2_vmalloc_memops;
1447 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1448
1449 ret = vb2_queue_init(q);
1450 if (ret)
1451 goto unreg_dev;
1452
1453 mutex_init(&dev->mutex);
1454
1455 /* init video dma queues */
1456 INIT_LIST_HEAD(&dev->vidq.active);
1457 init_waitqueue_head(&dev->vidq.wq);
1458
1459 vfd = &dev->vdev;
1460 *vfd = vivi_template;
1461 vfd->debug = debug;
1462 vfd->v4l2_dev = &dev->v4l2_dev;
1463 vfd->queue = q;
1464
1465 /*
1466 * Provide a mutex to v4l2 core. It will be used to protect
1467 * all fops and v4l2 ioctls.
1468 */
1469 vfd->lock = &dev->mutex;
1470 video_set_drvdata(vfd, dev);
1471
1472 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1473 if (ret < 0)
1474 goto unreg_dev;
1475
1476 /* Now that everything is fine, let's add it to device list */
1477 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1478
1479 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1480 video_device_node_name(vfd));
1481 return 0;
1482
1483 unreg_dev:
1484 v4l2_ctrl_handler_free(hdl);
1485 v4l2_device_unregister(&dev->v4l2_dev);
1486 free_dev:
1487 kfree(dev);
1488 return ret;
1489 }
1490
1491 /* This routine allocates from 1 to n_devs virtual drivers.
1492
1493 The real maximum number of virtual drivers will depend on how many drivers
1494 will succeed. This is limited to the maximum number of devices that
1495 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1496 */
1497 static int __init vivi_init(void)
1498 {
1499 const struct font_desc *font = find_font("VGA8x16");
1500 int ret = 0, i;
1501
1502 if (font == NULL) {
1503 printk(KERN_ERR "vivi: could not find font\n");
1504 return -ENODEV;
1505 }
1506 font8x16 = font->data;
1507
1508 if (n_devs <= 0)
1509 n_devs = 1;
1510
1511 for (i = 0; i < n_devs; i++) {
1512 ret = vivi_create_instance(i);
1513 if (ret) {
1514 /* If some instantiations succeeded, keep driver */
1515 if (i)
1516 ret = 0;
1517 break;
1518 }
1519 }
1520
1521 if (ret < 0) {
1522 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1523 return ret;
1524 }
1525
1526 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1527 "Capture Board ver %s successfully loaded.\n",
1528 VIVI_VERSION);
1529
1530 /* n_devs will reflect the actual number of allocated devices */
1531 n_devs = i;
1532
1533 return ret;
1534 }
1535
1536 static void __exit vivi_exit(void)
1537 {
1538 vivi_release();
1539 }
1540
1541 module_init(vivi_init);
1542 module_exit(vivi_exit);
Linux kernel - Deliverables
This page took 0.067959 seconds and 5 git commands to generate.