projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[media] rename drivers/media/video as .../platform
[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 /* 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 u8 depth;
84 bool is_yuv;
85 };
86
87 static struct vivi_fmt formats[] = {
88 {
89 .name = "4:2:2, packed, YUYV",
90 .fourcc = V4L2_PIX_FMT_YUYV,
91 .depth = 16,
92 .is_yuv = true,
93 },
94 {
95 .name = "4:2:2, packed, UYVY",
96 .fourcc = V4L2_PIX_FMT_UYVY,
97 .depth = 16,
98 .is_yuv = true,
99 },
100 {
101 .name = "4:2:2, packed, YVYU",
102 .fourcc = V4L2_PIX_FMT_YVYU,
103 .depth = 16,
104 .is_yuv = true,
105 },
106 {
107 .name = "4:2:2, packed, VYUY",
108 .fourcc = V4L2_PIX_FMT_VYUY,
109 .depth = 16,
110 .is_yuv = true,
111 },
112 {
113 .name = "RGB565 (LE)",
114 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
115 .depth = 16,
116 },
117 {
118 .name = "RGB565 (BE)",
119 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
120 .depth = 16,
121 },
122 {
123 .name = "RGB555 (LE)",
124 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
125 .depth = 16,
126 },
127 {
128 .name = "RGB555 (BE)",
129 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
130 .depth = 16,
131 },
132 {
133 .name = "RGB24 (LE)",
134 .fourcc = V4L2_PIX_FMT_RGB24, /* rgb */
135 .depth = 24,
136 },
137 {
138 .name = "RGB24 (BE)",
139 .fourcc = V4L2_PIX_FMT_BGR24, /* bgr */
140 .depth = 24,
141 },
142 {
143 .name = "RGB32 (LE)",
144 .fourcc = V4L2_PIX_FMT_RGB32, /* argb */
145 .depth = 32,
146 },
147 {
148 .name = "RGB32 (BE)",
149 .fourcc = V4L2_PIX_FMT_BGR32, /* bgra */
150 .depth = 32,
151 },
152 };
153
154 static struct vivi_fmt *get_format(struct v4l2_format *f)
155 {
156 struct vivi_fmt *fmt;
157 unsigned int k;
158
159 for (k = 0; k < ARRAY_SIZE(formats); k++) {
160 fmt = &formats[k];
161 if (fmt->fourcc == f->fmt.pix.pixelformat)
162 break;
163 }
164
165 if (k == ARRAY_SIZE(formats))
166 return NULL;
167
168 return &formats[k];
169 }
170
171 /* buffer for one video frame */
172 struct vivi_buffer {
173 /* common v4l buffer stuff -- must be first */
174 struct vb2_buffer vb;
175 struct list_head list;
176 struct vivi_fmt *fmt;
177 };
178
179 struct vivi_dmaqueue {
180 struct list_head active;
181
182 /* thread for generating video stream*/
183 struct task_struct *kthread;
184 wait_queue_head_t wq;
185 /* Counters to control fps rate */
186 int frame;
187 int ini_jiffies;
188 };
189
190 static LIST_HEAD(vivi_devlist);
191
192 struct vivi_dev {
193 struct list_head vivi_devlist;
194 struct v4l2_device v4l2_dev;
195 struct v4l2_ctrl_handler ctrl_handler;
196 struct video_device vdev;
197
198 /* controls */
199 struct v4l2_ctrl *brightness;
200 struct v4l2_ctrl *contrast;
201 struct v4l2_ctrl *saturation;
202 struct v4l2_ctrl *hue;
203 struct {
204 /* autogain/gain cluster */
205 struct v4l2_ctrl *autogain;
206 struct v4l2_ctrl *gain;
207 };
208 struct v4l2_ctrl *volume;
209 struct v4l2_ctrl *alpha;
210 struct v4l2_ctrl *button;
211 struct v4l2_ctrl *boolean;
212 struct v4l2_ctrl *int32;
213 struct v4l2_ctrl *int64;
214 struct v4l2_ctrl *menu;
215 struct v4l2_ctrl *string;
216 struct v4l2_ctrl *bitmask;
217 struct v4l2_ctrl *int_menu;
218
219 spinlock_t slock;
220 struct mutex mutex;
221
222 struct vivi_dmaqueue vidq;
223
224 /* Several counters */
225 unsigned ms;
226 unsigned long jiffies;
227 unsigned button_pressed;
228
229 int mv_count; /* Controls bars movement */
230
231 /* Input Number */
232 int input;
233
234 /* video capture */
235 struct vivi_fmt *fmt;
236 unsigned int width, height;
237 struct vb2_queue vb_vidq;
238 unsigned int field_count;
239
240 u8 bars[9][3];
241 u8 line[MAX_WIDTH * 8];
242 unsigned int pixelsize;
243 u8 alpha_component;
244 };
245
246 /* ------------------------------------------------------------------
247 DMA and thread functions
248 ------------------------------------------------------------------*/
249
250 /* Bars and Colors should match positions */
251
252 enum colors {
253 WHITE,
254 AMBER,
255 CYAN,
256 GREEN,
257 MAGENTA,
258 RED,
259 BLUE,
260 BLACK,
261 TEXT_BLACK,
262 };
263
264 /* R G B */
265 #define COLOR_WHITE {204, 204, 204}
266 #define COLOR_AMBER {208, 208, 0}
267 #define COLOR_CYAN { 0, 206, 206}
268 #define COLOR_GREEN { 0, 239, 0}
269 #define COLOR_MAGENTA {239, 0, 239}
270 #define COLOR_RED {205, 0, 0}
271 #define COLOR_BLUE { 0, 0, 255}
272 #define COLOR_BLACK { 0, 0, 0}
273
274 struct bar_std {
275 u8 bar[9][3];
276 };
277
278 /* Maximum number of bars are 10 - otherwise, the input print code
279 should be modified */
280 static struct bar_std bars[] = {
281 { /* Standard ITU-R color bar sequence */
282 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
283 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
284 }, {
285 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
286 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
287 }, {
288 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
289 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
290 }, {
291 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
292 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
293 },
294 };
295
296 #define NUM_INPUTS ARRAY_SIZE(bars)
297
298 #define TO_Y(r, g, b) \
299 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
300 /* RGB to V(Cr) Color transform */
301 #define TO_V(r, g, b) \
302 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
303 /* RGB to U(Cb) Color transform */
304 #define TO_U(r, g, b) \
305 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
306
307 /* precalculate color bar values to speed up rendering */
308 static void precalculate_bars(struct vivi_dev *dev)
309 {
310 u8 r, g, b;
311 int k, is_yuv;
312
313 for (k = 0; k < 9; k++) {
314 r = bars[dev->input].bar[k][0];
315 g = bars[dev->input].bar[k][1];
316 b = bars[dev->input].bar[k][2];
317 is_yuv = dev->fmt->is_yuv;
318
319 switch (dev->fmt->fourcc) {
320 case V4L2_PIX_FMT_RGB565:
321 case V4L2_PIX_FMT_RGB565X:
322 r >>= 3;
323 g >>= 2;
324 b >>= 3;
325 break;
326 case V4L2_PIX_FMT_RGB555:
327 case V4L2_PIX_FMT_RGB555X:
328 r >>= 3;
329 g >>= 3;
330 b >>= 3;
331 break;
332 case V4L2_PIX_FMT_YUYV:
333 case V4L2_PIX_FMT_UYVY:
334 case V4L2_PIX_FMT_YVYU:
335 case V4L2_PIX_FMT_VYUY:
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 = V4L2_FIELD_INTERLACED;
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 if (fmt)
773 size = fmt->fmt.pix.sizeimage;
774 else
775 size = dev->width * dev->height * dev->pixelsize;
776
777 if (size == 0)
778 return -EINVAL;
779
780 if (0 == *nbuffers)
781 *nbuffers = 32;
782
783 while (size * *nbuffers > vid_limit * 1024 * 1024)
784 (*nbuffers)--;
785
786 *nplanes = 1;
787
788 sizes[0] = size;
789
790 /*
791 * videobuf2-vmalloc allocator is context-less so no need to set
792 * alloc_ctxs array.
793 */
794
795 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
796 *nbuffers, size);
797
798 return 0;
799 }
800
801 static int buffer_prepare(struct vb2_buffer *vb)
802 {
803 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
804 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
805 unsigned long size;
806
807 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
808
809 BUG_ON(NULL == dev->fmt);
810
811 /*
812 * Theses properties only change when queue is idle, see s_fmt.
813 * The below checks should not be performed here, on each
814 * buffer_prepare (i.e. on each qbuf). Most of the code in this function
815 * should thus be moved to buffer_init and s_fmt.
816 */
817 if (dev->width < 48 || dev->width > MAX_WIDTH ||
818 dev->height < 32 || dev->height > MAX_HEIGHT)
819 return -EINVAL;
820
821 size = dev->width * dev->height * dev->pixelsize;
822 if (vb2_plane_size(vb, 0) < size) {
823 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
824 __func__, vb2_plane_size(vb, 0), size);
825 return -EINVAL;
826 }
827
828 vb2_set_plane_payload(&buf->vb, 0, size);
829
830 buf->fmt = dev->fmt;
831
832 precalculate_bars(dev);
833 precalculate_line(dev);
834
835 return 0;
836 }
837
838 static void buffer_queue(struct vb2_buffer *vb)
839 {
840 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
841 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
842 struct vivi_dmaqueue *vidq = &dev->vidq;
843 unsigned long flags = 0;
844
845 dprintk(dev, 1, "%s\n", __func__);
846
847 spin_lock_irqsave(&dev->slock, flags);
848 list_add_tail(&buf->list, &vidq->active);
849 spin_unlock_irqrestore(&dev->slock, flags);
850 }
851
852 static int start_streaming(struct vb2_queue *vq, unsigned int count)
853 {
854 struct vivi_dev *dev = vb2_get_drv_priv(vq);
855 dprintk(dev, 1, "%s\n", __func__);
856 return vivi_start_generating(dev);
857 }
858
859 /* abort streaming and wait for last buffer */
860 static int stop_streaming(struct vb2_queue *vq)
861 {
862 struct vivi_dev *dev = vb2_get_drv_priv(vq);
863 dprintk(dev, 1, "%s\n", __func__);
864 vivi_stop_generating(dev);
865 return 0;
866 }
867
868 static void vivi_lock(struct vb2_queue *vq)
869 {
870 struct vivi_dev *dev = vb2_get_drv_priv(vq);
871 mutex_lock(&dev->mutex);
872 }
873
874 static void vivi_unlock(struct vb2_queue *vq)
875 {
876 struct vivi_dev *dev = vb2_get_drv_priv(vq);
877 mutex_unlock(&dev->mutex);
878 }
879
880
881 static struct vb2_ops vivi_video_qops = {
882 .queue_setup = queue_setup,
883 .buf_prepare = buffer_prepare,
884 .buf_queue = buffer_queue,
885 .start_streaming = start_streaming,
886 .stop_streaming = stop_streaming,
887 .wait_prepare = vivi_unlock,
888 .wait_finish = vivi_lock,
889 };
890
891 /* ------------------------------------------------------------------
892 IOCTL vidioc handling
893 ------------------------------------------------------------------*/
894 static int vidioc_querycap(struct file *file, void *priv,
895 struct v4l2_capability *cap)
896 {
897 struct vivi_dev *dev = video_drvdata(file);
898
899 strcpy(cap->driver, "vivi");
900 strcpy(cap->card, "vivi");
901 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
902 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
903 V4L2_CAP_READWRITE;
904 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
905 return 0;
906 }
907
908 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
909 struct v4l2_fmtdesc *f)
910 {
911 struct vivi_fmt *fmt;
912
913 if (f->index >= ARRAY_SIZE(formats))
914 return -EINVAL;
915
916 fmt = &formats[f->index];
917
918 strlcpy(f->description, fmt->name, sizeof(f->description));
919 f->pixelformat = fmt->fourcc;
920 return 0;
921 }
922
923 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
924 struct v4l2_format *f)
925 {
926 struct vivi_dev *dev = video_drvdata(file);
927
928 f->fmt.pix.width = dev->width;
929 f->fmt.pix.height = dev->height;
930 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
931 f->fmt.pix.pixelformat = dev->fmt->fourcc;
932 f->fmt.pix.bytesperline =
933 (f->fmt.pix.width * dev->fmt->depth) >> 3;
934 f->fmt.pix.sizeimage =
935 f->fmt.pix.height * f->fmt.pix.bytesperline;
936 if (dev->fmt->is_yuv)
937 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
938 else
939 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
940 return 0;
941 }
942
943 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
944 struct v4l2_format *f)
945 {
946 struct vivi_dev *dev = video_drvdata(file);
947 struct vivi_fmt *fmt;
948
949 fmt = get_format(f);
950 if (!fmt) {
951 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
952 f->fmt.pix.pixelformat);
953 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
954 fmt = get_format(f);
955 }
956
957 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
958 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
959 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
960 f->fmt.pix.bytesperline =
961 (f->fmt.pix.width * fmt->depth) >> 3;
962 f->fmt.pix.sizeimage =
963 f->fmt.pix.height * f->fmt.pix.bytesperline;
964 if (fmt->is_yuv)
965 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
966 else
967 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
968 f->fmt.pix.priv = 0;
969 return 0;
970 }
971
972 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
973 struct v4l2_format *f)
974 {
975 struct vivi_dev *dev = video_drvdata(file);
976 struct vb2_queue *q = &dev->vb_vidq;
977
978 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
979 if (ret < 0)
980 return ret;
981
982 if (vb2_is_busy(q)) {
983 dprintk(dev, 1, "%s device busy\n", __func__);
984 return -EBUSY;
985 }
986
987 dev->fmt = get_format(f);
988 dev->pixelsize = dev->fmt->depth / 8;
989 dev->width = f->fmt.pix.width;
990 dev->height = f->fmt.pix.height;
991
992 return 0;
993 }
994
995 static int vidioc_enum_framesizes(struct file *file, void *fh,
996 struct v4l2_frmsizeenum *fsize)
997 {
998 static const struct v4l2_frmsize_stepwise sizes = {
999 48, MAX_WIDTH, 4,
1000 32, MAX_HEIGHT, 1
1001 };
1002 int i;
1003
1004 if (fsize->index)
1005 return -EINVAL;
1006 for (i = 0; i < ARRAY_SIZE(formats); i++)
1007 if (formats[i].fourcc == fsize->pixel_format)
1008 break;
1009 if (i == ARRAY_SIZE(formats))
1010 return -EINVAL;
1011 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1012 fsize->stepwise = sizes;
1013 return 0;
1014 }
1015
1016 /* only one input in this sample driver */
1017 static int vidioc_enum_input(struct file *file, void *priv,
1018 struct v4l2_input *inp)
1019 {
1020 if (inp->index >= NUM_INPUTS)
1021 return -EINVAL;
1022
1023 inp->type = V4L2_INPUT_TYPE_CAMERA;
1024 sprintf(inp->name, "Camera %u", inp->index);
1025 return 0;
1026 }
1027
1028 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1029 {
1030 struct vivi_dev *dev = video_drvdata(file);
1031
1032 *i = dev->input;
1033 return 0;
1034 }
1035
1036 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1037 {
1038 struct vivi_dev *dev = video_drvdata(file);
1039
1040 if (i >= NUM_INPUTS)
1041 return -EINVAL;
1042
1043 if (i == dev->input)
1044 return 0;
1045
1046 dev->input = i;
1047 precalculate_bars(dev);
1048 precalculate_line(dev);
1049 return 0;
1050 }
1051
1052 /* --- controls ---------------------------------------------- */
1053
1054 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1055 {
1056 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1057
1058 if (ctrl == dev->autogain)
1059 dev->gain->val = jiffies & 0xff;
1060 return 0;
1061 }
1062
1063 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1064 {
1065 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1066
1067 switch (ctrl->id) {
1068 case V4L2_CID_ALPHA_COMPONENT:
1069 dev->alpha_component = ctrl->val;
1070 break;
1071 default:
1072 if (ctrl == dev->button)
1073 dev->button_pressed = 30;
1074 break;
1075 }
1076 return 0;
1077 }
1078
1079 /* ------------------------------------------------------------------
1080 File operations for the device
1081 ------------------------------------------------------------------*/
1082
1083 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1084 .g_volatile_ctrl = vivi_g_volatile_ctrl,
1085 .s_ctrl = vivi_s_ctrl,
1086 };
1087
1088 #define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
1089
1090 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1091 .ops = &vivi_ctrl_ops,
1092 .id = VIVI_CID_CUSTOM_BASE + 0,
1093 .name = "Button",
1094 .type = V4L2_CTRL_TYPE_BUTTON,
1095 };
1096
1097 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1098 .ops = &vivi_ctrl_ops,
1099 .id = VIVI_CID_CUSTOM_BASE + 1,
1100 .name = "Boolean",
1101 .type = V4L2_CTRL_TYPE_BOOLEAN,
1102 .min = 0,
1103 .max = 1,
1104 .step = 1,
1105 .def = 1,
1106 };
1107
1108 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1109 .ops = &vivi_ctrl_ops,
1110 .id = VIVI_CID_CUSTOM_BASE + 2,
1111 .name = "Integer 32 Bits",
1112 .type = V4L2_CTRL_TYPE_INTEGER,
1113 .min = 0x80000000,
1114 .max = 0x7fffffff,
1115 .step = 1,
1116 };
1117
1118 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1119 .ops = &vivi_ctrl_ops,
1120 .id = VIVI_CID_CUSTOM_BASE + 3,
1121 .name = "Integer 64 Bits",
1122 .type = V4L2_CTRL_TYPE_INTEGER64,
1123 };
1124
1125 static const char * const vivi_ctrl_menu_strings[] = {
1126 "Menu Item 0 (Skipped)",
1127 "Menu Item 1",
1128 "Menu Item 2 (Skipped)",
1129 "Menu Item 3",
1130 "Menu Item 4",
1131 "Menu Item 5 (Skipped)",
1132 NULL,
1133 };
1134
1135 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1136 .ops = &vivi_ctrl_ops,
1137 .id = VIVI_CID_CUSTOM_BASE + 4,
1138 .name = "Menu",
1139 .type = V4L2_CTRL_TYPE_MENU,
1140 .min = 1,
1141 .max = 4,
1142 .def = 3,
1143 .menu_skip_mask = 0x04,
1144 .qmenu = vivi_ctrl_menu_strings,
1145 };
1146
1147 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1148 .ops = &vivi_ctrl_ops,
1149 .id = VIVI_CID_CUSTOM_BASE + 5,
1150 .name = "String",
1151 .type = V4L2_CTRL_TYPE_STRING,
1152 .min = 2,
1153 .max = 4,
1154 .step = 1,
1155 };
1156
1157 static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1158 .ops = &vivi_ctrl_ops,
1159 .id = VIVI_CID_CUSTOM_BASE + 6,
1160 .name = "Bitmask",
1161 .type = V4L2_CTRL_TYPE_BITMASK,
1162 .def = 0x80002000,
1163 .min = 0,
1164 .max = 0x80402010,
1165 .step = 0,
1166 };
1167
1168 static const s64 vivi_ctrl_int_menu_values[] = {
1169 1, 1, 2, 3, 5, 8, 13, 21, 42,
1170 };
1171
1172 static const struct v4l2_ctrl_config vivi_ctrl_int_menu = {
1173 .ops = &vivi_ctrl_ops,
1174 .id = VIVI_CID_CUSTOM_BASE + 7,
1175 .name = "Integer menu",
1176 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
1177 .min = 1,
1178 .max = 8,
1179 .def = 4,
1180 .menu_skip_mask = 0x02,
1181 .qmenu_int = vivi_ctrl_int_menu_values,
1182 };
1183
1184 static const struct v4l2_file_operations vivi_fops = {
1185 .owner = THIS_MODULE,
1186 .open = v4l2_fh_open,
1187 .release = vb2_fop_release,
1188 .read = vb2_fop_read,
1189 .poll = vb2_fop_poll,
1190 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1191 .mmap = vb2_fop_mmap,
1192 };
1193
1194 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1195 .vidioc_querycap = vidioc_querycap,
1196 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1197 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1198 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1199 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1200 .vidioc_enum_framesizes = vidioc_enum_framesizes,
1201 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1202 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1203 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1204 .vidioc_querybuf = vb2_ioctl_querybuf,
1205 .vidioc_qbuf = vb2_ioctl_qbuf,
1206 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1207 .vidioc_enum_input = vidioc_enum_input,
1208 .vidioc_g_input = vidioc_g_input,
1209 .vidioc_s_input = vidioc_s_input,
1210 .vidioc_streamon = vb2_ioctl_streamon,
1211 .vidioc_streamoff = vb2_ioctl_streamoff,
1212 .vidioc_log_status = v4l2_ctrl_log_status,
1213 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1214 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1215 };
1216
1217 static struct video_device vivi_template = {
1218 .name = "vivi",
1219 .fops = &vivi_fops,
1220 .ioctl_ops = &vivi_ioctl_ops,
1221 .release = video_device_release_empty,
1222 };
1223
1224 /* -----------------------------------------------------------------
1225 Initialization and module stuff
1226 ------------------------------------------------------------------*/
1227
1228 static int vivi_release(void)
1229 {
1230 struct vivi_dev *dev;
1231 struct list_head *list;
1232
1233 while (!list_empty(&vivi_devlist)) {
1234 list = vivi_devlist.next;
1235 list_del(list);
1236 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1237
1238 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1239 video_device_node_name(&dev->vdev));
1240 video_unregister_device(&dev->vdev);
1241 v4l2_device_unregister(&dev->v4l2_dev);
1242 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1243 kfree(dev);
1244 }
1245
1246 return 0;
1247 }
1248
1249 static int __init vivi_create_instance(int inst)
1250 {
1251 struct vivi_dev *dev;
1252 struct video_device *vfd;
1253 struct v4l2_ctrl_handler *hdl;
1254 struct vb2_queue *q;
1255 int ret;
1256
1257 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1258 if (!dev)
1259 return -ENOMEM;
1260
1261 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1262 "%s-%03d", VIVI_MODULE_NAME, inst);
1263 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1264 if (ret)
1265 goto free_dev;
1266
1267 dev->fmt = &formats[0];
1268 dev->width = 640;
1269 dev->height = 480;
1270 dev->pixelsize = dev->fmt->depth / 8;
1271 hdl = &dev->ctrl_handler;
1272 v4l2_ctrl_handler_init(hdl, 11);
1273 dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1274 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1275 dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1276 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1277 dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1278 V4L2_CID_CONTRAST, 0, 255, 1, 16);
1279 dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1280 V4L2_CID_SATURATION, 0, 255, 1, 127);
1281 dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1282 V4L2_CID_HUE, -128, 127, 1, 0);
1283 dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1284 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1285 dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1286 V4L2_CID_GAIN, 0, 255, 1, 100);
1287 dev->alpha = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1288 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1289 dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1290 dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1291 dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1292 dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1293 dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1294 dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1295 dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1296 dev->int_menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int_menu, NULL);
1297 if (hdl->error) {
1298 ret = hdl->error;
1299 goto unreg_dev;
1300 }
1301 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1302 dev->v4l2_dev.ctrl_handler = hdl;
1303
1304 /* initialize locks */
1305 spin_lock_init(&dev->slock);
1306
1307 /* initialize queue */
1308 q = &dev->vb_vidq;
1309 memset(q, 0, sizeof(dev->vb_vidq));
1310 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1311 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1312 q->drv_priv = dev;
1313 q->buf_struct_size = sizeof(struct vivi_buffer);
1314 q->ops = &vivi_video_qops;
1315 q->mem_ops = &vb2_vmalloc_memops;
1316
1317 vb2_queue_init(q);
1318
1319 mutex_init(&dev->mutex);
1320
1321 /* init video dma queues */
1322 INIT_LIST_HEAD(&dev->vidq.active);
1323 init_waitqueue_head(&dev->vidq.wq);
1324
1325 vfd = &dev->vdev;
1326 *vfd = vivi_template;
1327 vfd->debug = debug;
1328 vfd->v4l2_dev = &dev->v4l2_dev;
1329 vfd->queue = q;
1330 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1331
1332 /*
1333 * Provide a mutex to v4l2 core. It will be used to protect
1334 * all fops and v4l2 ioctls.
1335 */
1336 vfd->lock = &dev->mutex;
1337 video_set_drvdata(vfd, dev);
1338
1339 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1340 if (ret < 0)
1341 goto unreg_dev;
1342
1343 /* Now that everything is fine, let's add it to device list */
1344 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1345
1346 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1347 video_device_node_name(vfd));
1348 return 0;
1349
1350 unreg_dev:
1351 v4l2_ctrl_handler_free(hdl);
1352 v4l2_device_unregister(&dev->v4l2_dev);
1353 free_dev:
1354 kfree(dev);
1355 return ret;
1356 }
1357
1358 /* This routine allocates from 1 to n_devs virtual drivers.
1359
1360 The real maximum number of virtual drivers will depend on how many drivers
1361 will succeed. This is limited to the maximum number of devices that
1362 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1363 */
1364 static int __init vivi_init(void)
1365 {
1366 const struct font_desc *font = find_font("VGA8x16");
1367 int ret = 0, i;
1368
1369 if (font == NULL) {
1370 printk(KERN_ERR "vivi: could not find font\n");
1371 return -ENODEV;
1372 }
1373 font8x16 = font->data;
1374
1375 if (n_devs <= 0)
1376 n_devs = 1;
1377
1378 for (i = 0; i < n_devs; i++) {
1379 ret = vivi_create_instance(i);
1380 if (ret) {
1381 /* If some instantiations succeeded, keep driver */
1382 if (i)
1383 ret = 0;
1384 break;
1385 }
1386 }
1387
1388 if (ret < 0) {
1389 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1390 return ret;
1391 }
1392
1393 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1394 "Capture Board ver %s successfully loaded.\n",
1395 VIVI_VERSION);
1396
1397 /* n_devs will reflect the actual number of allocated devices */
1398 n_devs = i;
1399
1400 return ret;
1401 }
1402
1403 static void __exit vivi_exit(void)
1404 {
1405 vivi_release();
1406 }
1407
1408 module_init(vivi_init);
1409 module_exit(vivi_exit);
Linux kernel - Deliverables
This page took 0.12961 seconds and 5 git commands to generate.