?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.infradead.org/users/sameo/mfd-2.6
[linux-btrfs-devel.git] / drivers / media / video / vivi.c
bloba848bd2af97f0b704fbdf49216da85109ee874c2
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 = "RGB565 (LE)",
99 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
100 .depth = 16,
101 },
102 {
103 .name = "RGB565 (BE)",
104 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
105 .depth = 16,
106 },
107 {
108 .name = "RGB555 (LE)",
109 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
110 .depth = 16,
111 },
112 {
113 .name = "RGB555 (BE)",
114 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
115 .depth = 16,
116 },
117 };
118
119 static struct vivi_fmt *get_format(struct v4l2_format *f)
120 {
121 struct vivi_fmt *fmt;
122 unsigned int k;
123
124 for (k = 0; k < ARRAY_SIZE(formats); k++) {
125 fmt = &formats[k];
126 if (fmt->fourcc == f->fmt.pix.pixelformat)
127 break;
128 }
129
130 if (k == ARRAY_SIZE(formats))
131 return NULL;
132
133 return &formats[k];
134 }
135
136 /* buffer for one video frame */
137 struct vivi_buffer {
138 /* common v4l buffer stuff -- must be first */
139 struct vb2_buffer vb;
140 struct list_head list;
141 struct vivi_fmt *fmt;
142 };
143
144 struct vivi_dmaqueue {
145 struct list_head active;
146
147 /* thread for generating video stream*/
148 struct task_struct *kthread;
149 wait_queue_head_t wq;
150 /* Counters to control fps rate */
151 int frame;
152 int ini_jiffies;
153 };
154
155 static LIST_HEAD(vivi_devlist);
156
157 struct vivi_dev {
158 struct list_head vivi_devlist;
159 struct v4l2_device v4l2_dev;
160 struct v4l2_ctrl_handler ctrl_handler;
161
162 /* controls */
163 struct v4l2_ctrl *brightness;
164 struct v4l2_ctrl *contrast;
165 struct v4l2_ctrl *saturation;
166 struct v4l2_ctrl *hue;
167 struct {
168 /* autogain/gain cluster */
169 struct v4l2_ctrl *autogain;
170 struct v4l2_ctrl *gain;
171 };
172 struct v4l2_ctrl *volume;
173 struct v4l2_ctrl *button;
174 struct v4l2_ctrl *boolean;
175 struct v4l2_ctrl *int32;
176 struct v4l2_ctrl *int64;
177 struct v4l2_ctrl *menu;
178 struct v4l2_ctrl *string;
179 struct v4l2_ctrl *bitmask;
180
181 spinlock_t slock;
182 struct mutex mutex;
183
184 /* various device info */
185 struct video_device *vfd;
186
187 struct vivi_dmaqueue vidq;
188
189 /* Several counters */
190 unsigned ms;
191 unsigned long jiffies;
192 unsigned button_pressed;
193
194 int mv_count; /* Controls bars movement */
195
196 /* Input Number */
197 int input;
198
199 /* video capture */
200 struct vivi_fmt *fmt;
201 unsigned int width, height;
202 struct vb2_queue vb_vidq;
203 enum v4l2_field field;
204 unsigned int field_count;
205
206 u8 bars[9][3];
207 u8 line[MAX_WIDTH * 4];
208 };
209
210 /* ------------------------------------------------------------------
211 DMA and thread functions
212 ------------------------------------------------------------------*/
213
214 /* Bars and Colors should match positions */
215
216 enum colors {
217 WHITE,
218 AMBER,
219 CYAN,
220 GREEN,
221 MAGENTA,
222 RED,
223 BLUE,
224 BLACK,
225 TEXT_BLACK,
226 };
227
228 /* R G B */
229 #define COLOR_WHITE {204, 204, 204}
230 #define COLOR_AMBER {208, 208, 0}
231 #define COLOR_CYAN { 0, 206, 206}
232 #define COLOR_GREEN { 0, 239, 0}
233 #define COLOR_MAGENTA {239, 0, 239}
234 #define COLOR_RED {205, 0, 0}
235 #define COLOR_BLUE { 0, 0, 255}
236 #define COLOR_BLACK { 0, 0, 0}
237
238 struct bar_std {
239 u8 bar[9][3];
240 };
241
242 /* Maximum number of bars are 10 - otherwise, the input print code
243 should be modified */
244 static struct bar_std bars[] = {
245 { /* Standard ITU-R color bar sequence */
246 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
247 COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
248 }, {
249 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
250 COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
251 }, {
252 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
253 COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
254 }, {
255 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
256 COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
257 },
258 };
259
260 #define NUM_INPUTS ARRAY_SIZE(bars)
261
262 #define TO_Y(r, g, b) \
263 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
264 /* RGB to V(Cr) Color transform */
265 #define TO_V(r, g, b) \
266 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
267 /* RGB to U(Cb) Color transform */
268 #define TO_U(r, g, b) \
269 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
270
271 /* precalculate color bar values to speed up rendering */
272 static void precalculate_bars(struct vivi_dev *dev)
273 {
274 u8 r, g, b;
275 int k, is_yuv;
276
277 for (k = 0; k < 9; k++) {
278 r = bars[dev->input].bar[k][0];
279 g = bars[dev->input].bar[k][1];
280 b = bars[dev->input].bar[k][2];
281 is_yuv = 0;
282
283 switch (dev->fmt->fourcc) {
284 case V4L2_PIX_FMT_YUYV:
285 case V4L2_PIX_FMT_UYVY:
286 is_yuv = 1;
287 break;
288 case V4L2_PIX_FMT_RGB565:
289 case V4L2_PIX_FMT_RGB565X:
290 r >>= 3;
291 g >>= 2;
292 b >>= 3;
293 break;
294 case V4L2_PIX_FMT_RGB555:
295 case V4L2_PIX_FMT_RGB555X:
296 r >>= 3;
297 g >>= 3;
298 b >>= 3;
299 break;
300 }
301
302 if (is_yuv) {
303 dev->bars[k][0] = TO_Y(r, g, b); /* Luma */
304 dev->bars[k][1] = TO_U(r, g, b); /* Cb */
305 dev->bars[k][2] = TO_V(r, g, b); /* Cr */
306 } else {
307 dev->bars[k][0] = r;
308 dev->bars[k][1] = g;
309 dev->bars[k][2] = b;
310 }
311 }
312 }
313
314 #define TSTAMP_MIN_Y 24
315 #define TSTAMP_MAX_Y (TSTAMP_MIN_Y + 15)
316 #define TSTAMP_INPUT_X 10
317 #define TSTAMP_MIN_X (54 + TSTAMP_INPUT_X)
318
319 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos)
320 {
321 u8 r_y, g_u, b_v;
322 int color;
323 u8 *p;
324
325 r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
326 g_u = dev->bars[colorpos][1]; /* G or precalculated U */
327 b_v = dev->bars[colorpos][2]; /* B or precalculated V */
328
329 for (color = 0; color < 4; color++) {
330 p = buf + color;
331
332 switch (dev->fmt->fourcc) {
333 case V4L2_PIX_FMT_YUYV:
334 switch (color) {
335 case 0:
336 case 2:
337 *p = r_y;
338 break;
339 case 1:
340 *p = g_u;
341 break;
342 case 3:
343 *p = b_v;
344 break;
345 }
346 break;
347 case V4L2_PIX_FMT_UYVY:
348 switch (color) {
349 case 1:
350 case 3:
351 *p = r_y;
352 break;
353 case 0:
354 *p = g_u;
355 break;
356 case 2:
357 *p = b_v;
358 break;
359 }
360 break;
361 case V4L2_PIX_FMT_RGB565:
362 switch (color) {
363 case 0:
364 case 2:
365 *p = (g_u << 5) | b_v;
366 break;
367 case 1:
368 case 3:
369 *p = (r_y << 3) | (g_u >> 3);
370 break;
371 }
372 break;
373 case V4L2_PIX_FMT_RGB565X:
374 switch (color) {
375 case 0:
376 case 2:
377 *p = (r_y << 3) | (g_u >> 3);
378 break;
379 case 1:
380 case 3:
381 *p = (g_u << 5) | b_v;
382 break;
383 }
384 break;
385 case V4L2_PIX_FMT_RGB555:
386 switch (color) {
387 case 0:
388 case 2:
389 *p = (g_u << 5) | b_v;
390 break;
391 case 1:
392 case 3:
393 *p = (r_y << 2) | (g_u >> 3);
394 break;
395 }
396 break;
397 case V4L2_PIX_FMT_RGB555X:
398 switch (color) {
399 case 0:
400 case 2:
401 *p = (r_y << 2) | (g_u >> 3);
402 break;
403 case 1:
404 case 3:
405 *p = (g_u << 5) | b_v;
406 break;
407 }
408 break;
409 }
410 }
411 }
412
413 static void precalculate_line(struct vivi_dev *dev)
414 {
415 int w;
416
417 for (w = 0; w < dev->width * 2; w += 2) {
418 int colorpos = (w / (dev->width / 8) % 8);
419
420 gen_twopix(dev, dev->line + w * 2, colorpos);
421 }
422 }
423
424 static void gen_text(struct vivi_dev *dev, char *basep,
425 int y, int x, char *text)
426 {
427 int line;
428
429 /* Checks if it is possible to show string */
430 if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
431 return;
432
433 /* Print stream time */
434 for (line = y; line < y + 16; line++) {
435 int j = 0;
436 char *pos = basep + line * dev->width * 2 + x * 2;
437 char *s;
438
439 for (s = text; *s; s++) {
440 u8 chr = font8x16[*s * 16 + line - y];
441 int i;
442
443 for (i = 0; i < 7; i++, j++) {
444 /* Draw white font on black background */
445 if (chr & (1 << (7 - i)))
446 gen_twopix(dev, pos + j * 2, WHITE);
447 else
448 gen_twopix(dev, pos + j * 2, TEXT_BLACK);
449 }
450 }
451 }
452 }
453
454 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
455 {
456 int wmax = dev->width;
457 int hmax = dev->height;
458 struct timeval ts;
459 void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
460 unsigned ms;
461 char str[100];
462 int h, line = 1;
463 s32 gain;
464
465 if (!vbuf)
466 return;
467
468 for (h = 0; h < hmax; h++)
469 memcpy(vbuf + h * wmax * 2, dev->line + (dev->mv_count % wmax) * 2, wmax * 2);
470
471 /* Updates stream time */
472
473 dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
474 dev->jiffies = jiffies;
475 ms = dev->ms;
476 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
477 (ms / (60 * 60 * 1000)) % 24,
478 (ms / (60 * 1000)) % 60,
479 (ms / 1000) % 60,
480 ms % 1000);
481 gen_text(dev, vbuf, line++ * 16, 16, str);
482 snprintf(str, sizeof(str), " %dx%d, input %d ",
483 dev->width, dev->height, dev->input);
484 gen_text(dev, vbuf, line++ * 16, 16, str);
485
486 gain = v4l2_ctrl_g_ctrl(dev->gain);
487 mutex_lock(&dev->ctrl_handler.lock);
488 snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
489 dev->brightness->cur.val,
490 dev->contrast->cur.val,
491 dev->saturation->cur.val,
492 dev->hue->cur.val);
493 gen_text(dev, vbuf, line++ * 16, 16, str);
494 snprintf(str, sizeof(str), " autogain %d, gain %3d, volume %3d ",
495 dev->autogain->cur.val, gain, dev->volume->cur.val);
496 gen_text(dev, vbuf, line++ * 16, 16, str);
497 snprintf(str, sizeof(str), " int32 %d, int64 %lld, bitmask %08x ",
498 dev->int32->cur.val,
499 dev->int64->cur.val64,
500 dev->bitmask->cur.val);
501 gen_text(dev, vbuf, line++ * 16, 16, str);
502 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
503 dev->boolean->cur.val,
504 dev->menu->qmenu[dev->menu->cur.val],
505 dev->string->cur.string);
506 mutex_unlock(&dev->ctrl_handler.lock);
507 gen_text(dev, vbuf, line++ * 16, 16, str);
508 if (dev->button_pressed) {
509 dev->button_pressed--;
510 snprintf(str, sizeof(str), " button pressed!");
511 gen_text(dev, vbuf, line++ * 16, 16, str);
512 }
513
514 dev->mv_count += 2;
515
516 buf->vb.v4l2_buf.field = dev->field;
517 dev->field_count++;
518 buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
519 do_gettimeofday(&ts);
520 buf->vb.v4l2_buf.timestamp = ts;
521 }
522
523 static void vivi_thread_tick(struct vivi_dev *dev)
524 {
525 struct vivi_dmaqueue *dma_q = &dev->vidq;
526 struct vivi_buffer *buf;
527 unsigned long flags = 0;
528
529 dprintk(dev, 1, "Thread tick\n");
530
531 spin_lock_irqsave(&dev->slock, flags);
532 if (list_empty(&dma_q->active)) {
533 dprintk(dev, 1, "No active queue to serve\n");
534 spin_unlock_irqrestore(&dev->slock, flags);
535 return;
536 }
537
538 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
539 list_del(&buf->list);
540 spin_unlock_irqrestore(&dev->slock, flags);
541
542 do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
543
544 /* Fill buffer */
545 vivi_fillbuff(dev, buf);
546 dprintk(dev, 1, "filled buffer %p\n", buf);
547
548 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
549 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
550 }
551
552 #define frames_to_ms(frames) \
553 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
554
555 static void vivi_sleep(struct vivi_dev *dev)
556 {
557 struct vivi_dmaqueue *dma_q = &dev->vidq;
558 int timeout;
559 DECLARE_WAITQUEUE(wait, current);
560
561 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
562 (unsigned long)dma_q);
563
564 add_wait_queue(&dma_q->wq, &wait);
565 if (kthread_should_stop())
566 goto stop_task;
567
568 /* Calculate time to wake up */
569 timeout = msecs_to_jiffies(frames_to_ms(1));
570
571 vivi_thread_tick(dev);
572
573 schedule_timeout_interruptible(timeout);
574
575 stop_task:
576 remove_wait_queue(&dma_q->wq, &wait);
577 try_to_freeze();
578 }
579
580 static int vivi_thread(void *data)
581 {
582 struct vivi_dev *dev = data;
583
584 dprintk(dev, 1, "thread started\n");
585
586 set_freezable();
587
588 for (;;) {
589 vivi_sleep(dev);
590
591 if (kthread_should_stop())
592 break;
593 }
594 dprintk(dev, 1, "thread: exit\n");
595 return 0;
596 }
597
598 static int vivi_start_generating(struct vivi_dev *dev)
599 {
600 struct vivi_dmaqueue *dma_q = &dev->vidq;
601
602 dprintk(dev, 1, "%s\n", __func__);
603
604 /* Resets frame counters */
605 dev->ms = 0;
606 dev->mv_count = 0;
607 dev->jiffies = jiffies;
608
609 dma_q->frame = 0;
610 dma_q->ini_jiffies = jiffies;
611 dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
612
613 if (IS_ERR(dma_q->kthread)) {
614 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
615 return PTR_ERR(dma_q->kthread);
616 }
617 /* Wakes thread */
618 wake_up_interruptible(&dma_q->wq);
619
620 dprintk(dev, 1, "returning from %s\n", __func__);
621 return 0;
622 }
623
624 static void vivi_stop_generating(struct vivi_dev *dev)
625 {
626 struct vivi_dmaqueue *dma_q = &dev->vidq;
627
628 dprintk(dev, 1, "%s\n", __func__);
629
630 /* shutdown control thread */
631 if (dma_q->kthread) {
632 kthread_stop(dma_q->kthread);
633 dma_q->kthread = NULL;
634 }
635
636 /*
637 * Typical driver might need to wait here until dma engine stops.
638 * In this case we can abort imiedetly, so it's just a noop.
639 */
640
641 /* Release all active buffers */
642 while (!list_empty(&dma_q->active)) {
643 struct vivi_buffer *buf;
644 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
645 list_del(&buf->list);
646 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
647 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
648 }
649 }
650 /* ------------------------------------------------------------------
651 Videobuf operations
652 ------------------------------------------------------------------*/
653 static int queue_setup(struct vb2_queue *vq, unsigned int *nbuffers,
654 unsigned int *nplanes, unsigned long sizes[],
655 void *alloc_ctxs[])
656 {
657 struct vivi_dev *dev = vb2_get_drv_priv(vq);
658 unsigned long size;
659
660 size = dev->width * dev->height * 2;
661
662 if (0 == *nbuffers)
663 *nbuffers = 32;
664
665 while (size * *nbuffers > vid_limit * 1024 * 1024)
666 (*nbuffers)--;
667
668 *nplanes = 1;
669
670 sizes[0] = size;
671
672 /*
673 * videobuf2-vmalloc allocator is context-less so no need to set
674 * alloc_ctxs array.
675 */
676
677 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
678 *nbuffers, size);
679
680 return 0;
681 }
682
683 static int buffer_init(struct vb2_buffer *vb)
684 {
685 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
686
687 BUG_ON(NULL == dev->fmt);
688
689 /*
690 * This callback is called once per buffer, after its allocation.
691 *
692 * Vivi does not allow changing format during streaming, but it is
693 * possible to do so when streaming is paused (i.e. in streamoff state).
694 * Buffers however are not freed when going into streamoff and so
695 * buffer size verification has to be done in buffer_prepare, on each
696 * qbuf.
697 * It would be best to move verification code here to buf_init and
698 * s_fmt though.
699 */
700
701 return 0;
702 }
703
704 static int buffer_prepare(struct vb2_buffer *vb)
705 {
706 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
707 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
708 unsigned long size;
709
710 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
711
712 BUG_ON(NULL == dev->fmt);
713
714 /*
715 * Theses properties only change when queue is idle, see s_fmt.
716 * The below checks should not be performed here, on each
717 * buffer_prepare (i.e. on each qbuf). Most of the code in this function
718 * should thus be moved to buffer_init and s_fmt.
719 */
720 if (dev->width < 48 || dev->width > MAX_WIDTH ||
721 dev->height < 32 || dev->height > MAX_HEIGHT)
722 return -EINVAL;
723
724 size = dev->width * dev->height * 2;
725 if (vb2_plane_size(vb, 0) < size) {
726 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
727 __func__, vb2_plane_size(vb, 0), size);
728 return -EINVAL;
729 }
730
731 vb2_set_plane_payload(&buf->vb, 0, size);
732
733 buf->fmt = dev->fmt;
734
735 precalculate_bars(dev);
736 precalculate_line(dev);
737
738 return 0;
739 }
740
741 static int buffer_finish(struct vb2_buffer *vb)
742 {
743 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
744 dprintk(dev, 1, "%s\n", __func__);
745 return 0;
746 }
747
748 static void buffer_cleanup(struct vb2_buffer *vb)
749 {
750 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
751 dprintk(dev, 1, "%s\n", __func__);
752
753 }
754
755 static void buffer_queue(struct vb2_buffer *vb)
756 {
757 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
758 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
759 struct vivi_dmaqueue *vidq = &dev->vidq;
760 unsigned long flags = 0;
761
762 dprintk(dev, 1, "%s\n", __func__);
763
764 spin_lock_irqsave(&dev->slock, flags);
765 list_add_tail(&buf->list, &vidq->active);
766 spin_unlock_irqrestore(&dev->slock, flags);
767 }
768
769 static int start_streaming(struct vb2_queue *vq)
770 {
771 struct vivi_dev *dev = vb2_get_drv_priv(vq);
772 dprintk(dev, 1, "%s\n", __func__);
773 return vivi_start_generating(dev);
774 }
775
776 /* abort streaming and wait for last buffer */
777 static int stop_streaming(struct vb2_queue *vq)
778 {
779 struct vivi_dev *dev = vb2_get_drv_priv(vq);
780 dprintk(dev, 1, "%s\n", __func__);
781 vivi_stop_generating(dev);
782 return 0;
783 }
784
785 static void vivi_lock(struct vb2_queue *vq)
786 {
787 struct vivi_dev *dev = vb2_get_drv_priv(vq);
788 mutex_lock(&dev->mutex);
789 }
790
791 static void vivi_unlock(struct vb2_queue *vq)
792 {
793 struct vivi_dev *dev = vb2_get_drv_priv(vq);
794 mutex_unlock(&dev->mutex);
795 }
796
797
798 static struct vb2_ops vivi_video_qops = {
799 .queue_setup = queue_setup,
800 .buf_init = buffer_init,
801 .buf_prepare = buffer_prepare,
802 .buf_finish = buffer_finish,
803 .buf_cleanup = buffer_cleanup,
804 .buf_queue = buffer_queue,
805 .start_streaming = start_streaming,
806 .stop_streaming = stop_streaming,
807 .wait_prepare = vivi_unlock,
808 .wait_finish = vivi_lock,
809 };
810
811 /* ------------------------------------------------------------------
812 IOCTL vidioc handling
813 ------------------------------------------------------------------*/
814 static int vidioc_querycap(struct file *file, void *priv,
815 struct v4l2_capability *cap)
816 {
817 struct vivi_dev *dev = video_drvdata(file);
818
819 strcpy(cap->driver, "vivi");
820 strcpy(cap->card, "vivi");
821 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
822 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | \
823 V4L2_CAP_READWRITE;
824 return 0;
825 }
826
827 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
828 struct v4l2_fmtdesc *f)
829 {
830 struct vivi_fmt *fmt;
831
832 if (f->index >= ARRAY_SIZE(formats))
833 return -EINVAL;
834
835 fmt = &formats[f->index];
836
837 strlcpy(f->description, fmt->name, sizeof(f->description));
838 f->pixelformat = fmt->fourcc;
839 return 0;
840 }
841
842 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
843 struct v4l2_format *f)
844 {
845 struct vivi_dev *dev = video_drvdata(file);
846
847 f->fmt.pix.width = dev->width;
848 f->fmt.pix.height = dev->height;
849 f->fmt.pix.field = dev->field;
850 f->fmt.pix.pixelformat = dev->fmt->fourcc;
851 f->fmt.pix.bytesperline =
852 (f->fmt.pix.width * dev->fmt->depth) >> 3;
853 f->fmt.pix.sizeimage =
854 f->fmt.pix.height * f->fmt.pix.bytesperline;
855 return 0;
856 }
857
858 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
859 struct v4l2_format *f)
860 {
861 struct vivi_dev *dev = video_drvdata(file);
862 struct vivi_fmt *fmt;
863 enum v4l2_field field;
864
865 fmt = get_format(f);
866 if (!fmt) {
867 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
868 f->fmt.pix.pixelformat);
869 return -EINVAL;
870 }
871
872 field = f->fmt.pix.field;
873
874 if (field == V4L2_FIELD_ANY) {
875 field = V4L2_FIELD_INTERLACED;
876 } else if (V4L2_FIELD_INTERLACED != field) {
877 dprintk(dev, 1, "Field type invalid.\n");
878 return -EINVAL;
879 }
880
881 f->fmt.pix.field = field;
882 v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
883 &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
884 f->fmt.pix.bytesperline =
885 (f->fmt.pix.width * fmt->depth) >> 3;
886 f->fmt.pix.sizeimage =
887 f->fmt.pix.height * f->fmt.pix.bytesperline;
888 return 0;
889 }
890
891 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
892 struct v4l2_format *f)
893 {
894 struct vivi_dev *dev = video_drvdata(file);
895 struct vb2_queue *q = &dev->vb_vidq;
896
897 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
898 if (ret < 0)
899 return ret;
900
901 if (vb2_is_streaming(q)) {
902 dprintk(dev, 1, "%s device busy\n", __func__);
903 return -EBUSY;
904 }
905
906 dev->fmt = get_format(f);
907 dev->width = f->fmt.pix.width;
908 dev->height = f->fmt.pix.height;
909 dev->field = f->fmt.pix.field;
910
911 return 0;
912 }
913
914 static int vidioc_reqbufs(struct file *file, void *priv,
915 struct v4l2_requestbuffers *p)
916 {
917 struct vivi_dev *dev = video_drvdata(file);
918 return vb2_reqbufs(&dev->vb_vidq, p);
919 }
920
921 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
922 {
923 struct vivi_dev *dev = video_drvdata(file);
924 return vb2_querybuf(&dev->vb_vidq, p);
925 }
926
927 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
928 {
929 struct vivi_dev *dev = video_drvdata(file);
930 return vb2_qbuf(&dev->vb_vidq, p);
931 }
932
933 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
934 {
935 struct vivi_dev *dev = video_drvdata(file);
936 return vb2_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK);
937 }
938
939 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
940 {
941 struct vivi_dev *dev = video_drvdata(file);
942 return vb2_streamon(&dev->vb_vidq, i);
943 }
944
945 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
946 {
947 struct vivi_dev *dev = video_drvdata(file);
948 return vb2_streamoff(&dev->vb_vidq, i);
949 }
950
951 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
952 {
953 return 0;
954 }
955
956 /* only one input in this sample driver */
957 static int vidioc_enum_input(struct file *file, void *priv,
958 struct v4l2_input *inp)
959 {
960 if (inp->index >= NUM_INPUTS)
961 return -EINVAL;
962
963 inp->type = V4L2_INPUT_TYPE_CAMERA;
964 inp->std = V4L2_STD_525_60;
965 sprintf(inp->name, "Camera %u", inp->index);
966 return 0;
967 }
968
969 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
970 {
971 struct vivi_dev *dev = video_drvdata(file);
972
973 *i = dev->input;
974 return 0;
975 }
976
977 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
978 {
979 struct vivi_dev *dev = video_drvdata(file);
980
981 if (i >= NUM_INPUTS)
982 return -EINVAL;
983
984 if (i == dev->input)
985 return 0;
986
987 dev->input = i;
988 precalculate_bars(dev);
989 precalculate_line(dev);
990 return 0;
991 }
992
993 static int vidioc_subscribe_event(struct v4l2_fh *fh,
994 struct v4l2_event_subscription *sub)
995 {
996 switch (sub->type) {
997 case V4L2_EVENT_CTRL:
998 return v4l2_event_subscribe(fh, sub, 0);
999 default:
1000 return -EINVAL;
1001 }
1002 }
1003
1004 /* --- controls ---------------------------------------------- */
1005
1006 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1007 {
1008 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1009
1010 if (ctrl == dev->autogain)
1011 dev->gain->val = jiffies & 0xff;
1012 return 0;
1013 }
1014
1015 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1016 {
1017 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1018
1019 if (ctrl == dev->button)
1020 dev->button_pressed = 30;
1021 return 0;
1022 }
1023
1024 /* ------------------------------------------------------------------
1025 File operations for the device
1026 ------------------------------------------------------------------*/
1027
1028 static ssize_t
1029 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1030 {
1031 struct vivi_dev *dev = video_drvdata(file);
1032
1033 dprintk(dev, 1, "read called\n");
1034 return vb2_read(&dev->vb_vidq, data, count, ppos,
1035 file->f_flags & O_NONBLOCK);
1036 }
1037
1038 static unsigned int
1039 vivi_poll(struct file *file, struct poll_table_struct *wait)
1040 {
1041 struct vivi_dev *dev = video_drvdata(file);
1042 struct v4l2_fh *fh = file->private_data;
1043 struct vb2_queue *q = &dev->vb_vidq;
1044 unsigned int res;
1045
1046 dprintk(dev, 1, "%s\n", __func__);
1047 res = vb2_poll(q, file, wait);
1048 if (v4l2_event_pending(fh))
1049 res |= POLLPRI;
1050 else
1051 poll_wait(file, &fh->wait, wait);
1052 return res;
1053 }
1054
1055 static int vivi_close(struct file *file)
1056 {
1057 struct video_device *vdev = video_devdata(file);
1058 struct vivi_dev *dev = video_drvdata(file);
1059
1060 dprintk(dev, 1, "close called (dev=%s), file %p\n",
1061 video_device_node_name(vdev), file);
1062
1063 if (v4l2_fh_is_singular_file(file))
1064 vb2_queue_release(&dev->vb_vidq);
1065 return v4l2_fh_release(file);
1066 }
1067
1068 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1069 {
1070 struct vivi_dev *dev = video_drvdata(file);
1071 int ret;
1072
1073 dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1074
1075 ret = vb2_mmap(&dev->vb_vidq, vma);
1076 dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1077 (unsigned long)vma->vm_start,
1078 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
1079 ret);
1080 return ret;
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 struct v4l2_file_operations vivi_fops = {
1169 .owner = THIS_MODULE,
1170 .open = v4l2_fh_open,
1171 .release = vivi_close,
1172 .read = vivi_read,
1173 .poll = vivi_poll,
1174 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1175 .mmap = vivi_mmap,
1176 };
1177
1178 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1179 .vidioc_querycap = vidioc_querycap,
1180 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1181 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1182 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1183 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1184 .vidioc_reqbufs = vidioc_reqbufs,
1185 .vidioc_querybuf = vidioc_querybuf,
1186 .vidioc_qbuf = vidioc_qbuf,
1187 .vidioc_dqbuf = vidioc_dqbuf,
1188 .vidioc_s_std = vidioc_s_std,
1189 .vidioc_enum_input = vidioc_enum_input,
1190 .vidioc_g_input = vidioc_g_input,
1191 .vidioc_s_input = vidioc_s_input,
1192 .vidioc_streamon = vidioc_streamon,
1193 .vidioc_streamoff = vidioc_streamoff,
1194 .vidioc_subscribe_event = vidioc_subscribe_event,
1195 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1196 };
1197
1198 static struct video_device vivi_template = {
1199 .name = "vivi",
1200 .fops = &vivi_fops,
1201 .ioctl_ops = &vivi_ioctl_ops,
1202 .release = video_device_release,
1203
1204 .tvnorms = V4L2_STD_525_60,
1205 .current_norm = V4L2_STD_NTSC_M,
1206 };
1207
1208 /* -----------------------------------------------------------------
1209 Initialization and module stuff
1210 ------------------------------------------------------------------*/
1211
1212 static int vivi_release(void)
1213 {
1214 struct vivi_dev *dev;
1215 struct list_head *list;
1216
1217 while (!list_empty(&vivi_devlist)) {
1218 list = vivi_devlist.next;
1219 list_del(list);
1220 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1221
1222 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1223 video_device_node_name(dev->vfd));
1224 video_unregister_device(dev->vfd);
1225 v4l2_device_unregister(&dev->v4l2_dev);
1226 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1227 kfree(dev);
1228 }
1229
1230 return 0;
1231 }
1232
1233 static int __init vivi_create_instance(int inst)
1234 {
1235 struct vivi_dev *dev;
1236 struct video_device *vfd;
1237 struct v4l2_ctrl_handler *hdl;
1238 struct vb2_queue *q;
1239 int ret;
1240
1241 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1242 if (!dev)
1243 return -ENOMEM;
1244
1245 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1246 "%s-%03d", VIVI_MODULE_NAME, inst);
1247 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1248 if (ret)
1249 goto free_dev;
1250
1251 dev->fmt = &formats[0];
1252 dev->width = 640;
1253 dev->height = 480;
1254 hdl = &dev->ctrl_handler;
1255 v4l2_ctrl_handler_init(hdl, 11);
1256 dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1257 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1258 dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1259 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1260 dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1261 V4L2_CID_CONTRAST, 0, 255, 1, 16);
1262 dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1263 V4L2_CID_SATURATION, 0, 255, 1, 127);
1264 dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1265 V4L2_CID_HUE, -128, 127, 1, 0);
1266 dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1267 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1268 dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1269 V4L2_CID_GAIN, 0, 255, 1, 100);
1270 dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1271 dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1272 dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1273 dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1274 dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1275 dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1276 dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1277 if (hdl->error) {
1278 ret = hdl->error;
1279 goto unreg_dev;
1280 }
1281 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1282 dev->v4l2_dev.ctrl_handler = hdl;
1283
1284 /* initialize locks */
1285 spin_lock_init(&dev->slock);
1286
1287 /* initialize queue */
1288 q = &dev->vb_vidq;
1289 memset(q, 0, sizeof(dev->vb_vidq));
1290 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1291 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1292 q->drv_priv = dev;
1293 q->buf_struct_size = sizeof(struct vivi_buffer);
1294 q->ops = &vivi_video_qops;
1295 q->mem_ops = &vb2_vmalloc_memops;
1296
1297 vb2_queue_init(q);
1298
1299 mutex_init(&dev->mutex);
1300
1301 /* init video dma queues */
1302 INIT_LIST_HEAD(&dev->vidq.active);
1303 init_waitqueue_head(&dev->vidq.wq);
1304
1305 ret = -ENOMEM;
1306 vfd = video_device_alloc();
1307 if (!vfd)
1308 goto unreg_dev;
1309
1310 *vfd = vivi_template;
1311 vfd->debug = debug;
1312 vfd->v4l2_dev = &dev->v4l2_dev;
1313 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1314
1315 /*
1316 * Provide a mutex to v4l2 core. It will be used to protect
1317 * all fops and v4l2 ioctls.
1318 */
1319 vfd->lock = &dev->mutex;
1320
1321 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1322 if (ret < 0)
1323 goto rel_vdev;
1324
1325 video_set_drvdata(vfd, dev);
1326
1327 /* Now that everything is fine, let's add it to device list */
1328 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1329
1330 if (video_nr != -1)
1331 video_nr++;
1332
1333 dev->vfd = vfd;
1334 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1335 video_device_node_name(vfd));
1336 return 0;
1337
1338 rel_vdev:
1339 video_device_release(vfd);
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 Btrfs Development