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