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