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