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