sfc: Don't use enums as a bitmask.
[zen-stable.git] / drivers / media / video / vivi.c
blob2238a613d664b7b9edebdaef4b0a58195888955c
1 /*
2 * Virtual Video driver - This code emulates a real video device with v4l2 api
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/
10 * Conversion to videobuf2 by Pawel Osciak & Marek Szyprowski
11 * Copyright (c) 2010 Samsung Electronics
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
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>
37 #define VIVI_MODULE_NAME "vivi"
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 */
44 #define MAX_WIDTH 1920
45 #define MAX_HEIGHT 1200
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)
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");
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");
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");
65 static unsigned debug;
66 module_param(debug, uint, 0644);
67 MODULE_PARM_DESC(debug, "activates debug info");
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");
73 /* Global font descriptor */
74 static const u8 *font8x16;
76 #define dprintk(dev, level, fmt, arg...) \
77 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
79 /* ------------------------------------------------------------------
80 Basic structures
81 ------------------------------------------------------------------*/
83 struct vivi_fmt {
84 char *name;
85 u32 fourcc; /* v4l2 format id */
86 int depth;
89 static struct vivi_fmt formats[] = {
91 .name = "4:2:2, packed, YUYV",
92 .fourcc = V4L2_PIX_FMT_YUYV,
93 .depth = 16,
96 .name = "4:2:2, packed, UYVY",
97 .fourcc = V4L2_PIX_FMT_UYVY,
98 .depth = 16,
101 .name = "RGB565 (LE)",
102 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
103 .depth = 16,
106 .name = "RGB565 (BE)",
107 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
108 .depth = 16,
111 .name = "RGB555 (LE)",
112 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
113 .depth = 16,
116 .name = "RGB555 (BE)",
117 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
118 .depth = 16,
122 static struct vivi_fmt *get_format(struct v4l2_format *f)
124 struct vivi_fmt *fmt;
125 unsigned int k;
127 for (k = 0; k < ARRAY_SIZE(formats); k++) {
128 fmt = &formats[k];
129 if (fmt->fourcc == f->fmt.pix.pixelformat)
130 break;
133 if (k == ARRAY_SIZE(formats))
134 return NULL;
136 return &formats[k];
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;
147 struct vivi_dmaqueue {
148 struct list_head active;
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;
158 static LIST_HEAD(vivi_devlist);
160 struct vivi_dev {
161 struct list_head vivi_devlist;
162 struct v4l2_device v4l2_dev;
163 struct v4l2_ctrl_handler ctrl_handler;
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;
178 spinlock_t slock;
179 struct mutex mutex;
181 /* various device info */
182 struct video_device *vfd;
184 struct vivi_dmaqueue vidq;
186 /* Several counters */
187 unsigned ms;
188 unsigned long jiffies;
189 unsigned button_pressed;
191 int mv_count; /* Controls bars movement */
193 /* Input Number */
194 int input;
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;
203 u8 bars[9][3];
204 u8 line[MAX_WIDTH * 4];
207 /* ------------------------------------------------------------------
208 DMA and thread functions
209 ------------------------------------------------------------------*/
211 /* Bars and Colors should match positions */
213 enum colors {
214 WHITE,
215 AMBER,
216 CYAN,
217 GREEN,
218 MAGENTA,
219 RED,
220 BLUE,
221 BLACK,
222 TEXT_BLACK,
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}
235 struct bar_std {
236 u8 bar[9][3];
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 }
257 #define NUM_INPUTS ARRAY_SIZE(bars)
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)
268 /* precalculate color bar values to speed up rendering */
269 static void precalculate_bars(struct vivi_dev *dev)
271 u8 r, g, b;
272 int k, is_yuv;
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;
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;
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;
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)
316 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos)
318 u8 r_y, g_u, b_v;
319 int color;
320 u8 *p;
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 */
326 for (color = 0; color < 4; color++) {
327 p = buf + color;
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;
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;
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;
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;
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;
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;
405 break;
410 static void precalculate_line(struct vivi_dev *dev)
412 int w;
414 for (w = 0; w < dev->width * 2; w += 2) {
415 int colorpos = (w / (dev->width / 8) % 8);
417 gen_twopix(dev, dev->line + w * 2, colorpos);
421 static void gen_text(struct vivi_dev *dev, char *basep,
422 int y, int x, char *text)
424 int line;
426 /* Checks if it is possible to show string */
427 if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
428 return;
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;
436 for (s = text; *s; s++) {
437 u8 chr = font8x16[*s * 16 + line - y];
438 int i;
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);
451 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
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;
461 if (!vbuf)
462 return;
464 for (h = 0; h < hmax; h++)
465 memcpy(vbuf + h * wmax * 2, dev->line + (dev->mv_count % wmax) * 2, wmax * 2);
467 /* Updates stream time */
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);
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);
507 dev->mv_count += 2;
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;
516 static void vivi_thread_tick(struct vivi_dev *dev)
518 struct vivi_dmaqueue *dma_q = &dev->vidq;
519 struct vivi_buffer *buf;
520 unsigned long flags = 0;
522 dprintk(dev, 1, "Thread tick\n");
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;
530 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
531 list_del(&buf->list);
533 do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
535 /* Fill buffer */
536 vivi_fillbuff(dev, buf);
537 dprintk(dev, 1, "filled buffer %p\n", buf);
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);
545 #define frames_to_ms(frames) \
546 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
548 static void vivi_sleep(struct vivi_dev *dev)
550 struct vivi_dmaqueue *dma_q = &dev->vidq;
551 int timeout;
552 DECLARE_WAITQUEUE(wait, current);
554 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
555 (unsigned long)dma_q);
557 add_wait_queue(&dma_q->wq, &wait);
558 if (kthread_should_stop())
559 goto stop_task;
561 /* Calculate time to wake up */
562 timeout = msecs_to_jiffies(frames_to_ms(1));
564 vivi_thread_tick(dev);
566 schedule_timeout_interruptible(timeout);
568 stop_task:
569 remove_wait_queue(&dma_q->wq, &wait);
570 try_to_freeze();
573 static int vivi_thread(void *data)
575 struct vivi_dev *dev = data;
577 dprintk(dev, 1, "thread started\n");
579 set_freezable();
581 for (;;) {
582 vivi_sleep(dev);
584 if (kthread_should_stop())
585 break;
587 dprintk(dev, 1, "thread: exit\n");
588 return 0;
591 static int vivi_start_generating(struct vivi_dev *dev)
593 struct vivi_dmaqueue *dma_q = &dev->vidq;
595 dprintk(dev, 1, "%s\n", __func__);
597 /* Resets frame counters */
598 dev->ms = 0;
599 dev->mv_count = 0;
600 dev->jiffies = jiffies;
602 dma_q->frame = 0;
603 dma_q->ini_jiffies = jiffies;
604 dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
606 if (IS_ERR(dma_q->kthread)) {
607 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
608 return PTR_ERR(dma_q->kthread);
610 /* Wakes thread */
611 wake_up_interruptible(&dma_q->wq);
613 dprintk(dev, 1, "returning from %s\n", __func__);
614 return 0;
617 static void vivi_stop_generating(struct vivi_dev *dev)
619 struct vivi_dmaqueue *dma_q = &dev->vidq;
621 dprintk(dev, 1, "%s\n", __func__);
623 /* shutdown control thread */
624 if (dma_q->kthread) {
625 kthread_stop(dma_q->kthread);
626 dma_q->kthread = NULL;
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.
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);
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[])
650 struct vivi_dev *dev = vb2_get_drv_priv(vq);
651 unsigned long size;
653 size = dev->width * dev->height * 2;
655 if (0 == *nbuffers)
656 *nbuffers = 32;
658 while (size * *nbuffers > vid_limit * 1024 * 1024)
659 (*nbuffers)--;
661 *nplanes = 1;
663 sizes[0] = size;
666 * videobuf2-vmalloc allocator is context-less so no need to set
667 * alloc_ctxs array.
670 dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
671 *nbuffers, size);
673 return 0;
676 static int buffer_init(struct vb2_buffer *vb)
678 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
680 BUG_ON(NULL == dev->fmt);
683 * This callback is called once per buffer, after its allocation.
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.
694 return 0;
697 static int buffer_prepare(struct vb2_buffer *vb)
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;
703 dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
705 BUG_ON(NULL == dev->fmt);
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.
713 if (dev->width < 48 || dev->width > MAX_WIDTH ||
714 dev->height < 32 || dev->height > MAX_HEIGHT)
715 return -EINVAL;
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;
724 vb2_set_plane_payload(&buf->vb, 0, size);
726 buf->fmt = dev->fmt;
728 precalculate_bars(dev);
729 precalculate_line(dev);
731 return 0;
734 static int buffer_finish(struct vb2_buffer *vb)
736 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
737 dprintk(dev, 1, "%s\n", __func__);
738 return 0;
741 static void buffer_cleanup(struct vb2_buffer *vb)
743 struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
744 dprintk(dev, 1, "%s\n", __func__);
748 static void buffer_queue(struct vb2_buffer *vb)
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;
755 dprintk(dev, 1, "%s\n", __func__);
757 spin_lock_irqsave(&dev->slock, flags);
758 list_add_tail(&buf->list, &vidq->active);
759 spin_unlock_irqrestore(&dev->slock, flags);
762 static int start_streaming(struct vb2_queue *vq)
764 struct vivi_dev *dev = vb2_get_drv_priv(vq);
765 dprintk(dev, 1, "%s\n", __func__);
766 return vivi_start_generating(dev);
769 /* abort streaming and wait for last buffer */
770 static int stop_streaming(struct vb2_queue *vq)
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;
778 static void vivi_lock(struct vb2_queue *vq)
780 struct vivi_dev *dev = vb2_get_drv_priv(vq);
781 mutex_lock(&dev->mutex);
784 static void vivi_unlock(struct vb2_queue *vq)
786 struct vivi_dev *dev = vb2_get_drv_priv(vq);
787 mutex_unlock(&dev->mutex);
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,
804 /* ------------------------------------------------------------------
805 IOCTL vidioc handling
806 ------------------------------------------------------------------*/
807 static int vidioc_querycap(struct file *file, void *priv,
808 struct v4l2_capability *cap)
810 struct vivi_dev *dev = video_drvdata(file);
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;
821 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
822 struct v4l2_fmtdesc *f)
824 struct vivi_fmt *fmt;
826 if (f->index >= ARRAY_SIZE(formats))
827 return -EINVAL;
829 fmt = &formats[f->index];
831 strlcpy(f->description, fmt->name, sizeof(f->description));
832 f->pixelformat = fmt->fourcc;
833 return 0;
836 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
837 struct v4l2_format *f)
839 struct vivi_dev *dev = video_drvdata(file);
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;
852 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
853 struct v4l2_format *f)
855 struct vivi_dev *dev = video_drvdata(file);
856 struct vivi_fmt *fmt;
857 enum v4l2_field field;
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;
866 field = f->fmt.pix.field;
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;
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;
885 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
886 struct v4l2_format *f)
888 struct vivi_dev *dev = video_drvdata(file);
889 struct vb2_queue *q = &dev->vb_vidq;
891 int ret = vidioc_try_fmt_vid_cap(file, priv, f);
892 if (ret < 0)
893 return ret;
895 if (vb2_is_streaming(q)) {
896 dprintk(dev, 1, "%s device busy\n", __func__);
897 return -EBUSY;
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;
905 return 0;
908 static int vidioc_reqbufs(struct file *file, void *priv,
909 struct v4l2_requestbuffers *p)
911 struct vivi_dev *dev = video_drvdata(file);
912 return vb2_reqbufs(&dev->vb_vidq, p);
915 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
917 struct vivi_dev *dev = video_drvdata(file);
918 return vb2_querybuf(&dev->vb_vidq, p);
921 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
923 struct vivi_dev *dev = video_drvdata(file);
924 return vb2_qbuf(&dev->vb_vidq, p);
927 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
929 struct vivi_dev *dev = video_drvdata(file);
930 return vb2_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK);
933 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
935 struct vivi_dev *dev = video_drvdata(file);
936 return vb2_streamon(&dev->vb_vidq, i);
939 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
941 struct vivi_dev *dev = video_drvdata(file);
942 return vb2_streamoff(&dev->vb_vidq, i);
945 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
947 return 0;
950 /* only one input in this sample driver */
951 static int vidioc_enum_input(struct file *file, void *priv,
952 struct v4l2_input *inp)
954 if (inp->index >= NUM_INPUTS)
955 return -EINVAL;
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;
963 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
965 struct vivi_dev *dev = video_drvdata(file);
967 *i = dev->input;
968 return 0;
971 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
973 struct vivi_dev *dev = video_drvdata(file);
975 if (i >= NUM_INPUTS)
976 return -EINVAL;
978 dev->input = i;
979 precalculate_bars(dev);
980 precalculate_line(dev);
981 return 0;
984 /* --- controls ---------------------------------------------- */
986 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
988 struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
990 if (ctrl == dev->button)
991 dev->button_pressed = 30;
992 return 0;
995 /* ------------------------------------------------------------------
996 File operations for the device
997 ------------------------------------------------------------------*/
999 static ssize_t
1000 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1002 struct vivi_dev *dev = video_drvdata(file);
1004 dprintk(dev, 1, "read called\n");
1005 return vb2_read(&dev->vb_vidq, data, count, ppos,
1006 file->f_flags & O_NONBLOCK);
1009 static unsigned int
1010 vivi_poll(struct file *file, struct poll_table_struct *wait)
1012 struct vivi_dev *dev = video_drvdata(file);
1013 struct vb2_queue *q = &dev->vb_vidq;
1015 dprintk(dev, 1, "%s\n", __func__);
1016 return vb2_poll(q, file, wait);
1019 static int vivi_close(struct file *file)
1021 struct video_device *vdev = video_devdata(file);
1022 struct vivi_dev *dev = video_drvdata(file);
1024 dprintk(dev, 1, "close called (dev=%s), file %p\n",
1025 video_device_node_name(vdev), file);
1027 if (v4l2_fh_is_singular_file(file))
1028 vb2_queue_release(&dev->vb_vidq);
1029 return v4l2_fh_release(file);
1032 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1034 struct vivi_dev *dev = video_drvdata(file);
1035 int ret;
1037 dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
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;
1047 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1048 .s_ctrl = vivi_s_ctrl,
1051 #define VIVI_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
1154 .tvnorms = V4L2_STD_525_60,
1155 .current_norm = V4L2_STD_NTSC_M,
1158 /* -----------------------------------------------------------------
1159 Initialization and module stuff
1160 ------------------------------------------------------------------*/
1162 static int vivi_release(void)
1164 struct vivi_dev *dev;
1165 struct list_head *list;
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);
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);
1180 return 0;
1183 static int __init vivi_create_instance(int inst)
1185 struct vivi_dev *dev;
1186 struct video_device *vfd;
1187 struct v4l2_ctrl_handler *hdl;
1188 struct vb2_queue *q;
1189 int ret;
1191 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1192 if (!dev)
1193 return -ENOMEM;
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;
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;
1226 dev->v4l2_dev.ctrl_handler = hdl;
1228 /* initialize locks */
1229 spin_lock_init(&dev->slock);
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;
1241 vb2_queue_init(q);
1243 mutex_init(&dev->mutex);
1245 /* init video dma queues */
1246 INIT_LIST_HEAD(&dev->vidq.active);
1247 init_waitqueue_head(&dev->vidq.wq);
1249 ret = -ENOMEM;
1250 vfd = video_device_alloc();
1251 if (!vfd)
1252 goto unreg_dev;
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);
1260 * Provide a mutex to v4l2 core. It will be used to protect
1261 * all fops and v4l2 ioctls.
1263 vfd->lock = &dev->mutex;
1265 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1266 if (ret < 0)
1267 goto rel_vdev;
1269 video_set_drvdata(vfd, dev);
1271 /* Now that everything is fine, let's add it to device list */
1272 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1274 if (video_nr != -1)
1275 video_nr++;
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;
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;
1292 /* This routine allocates from 1 to n_devs virtual drivers.
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.
1298 static int __init vivi_init(void)
1300 const struct font_desc *font = find_font("VGA8x16");
1301 int ret = 0, i;
1303 if (font == NULL) {
1304 printk(KERN_ERR "vivi: could not find font\n");
1305 return -ENODEV;
1307 font8x16 = font->data;
1309 if (n_devs <= 0)
1310 n_devs = 1;
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;
1322 if (ret < 0) {
1323 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1324 return ret;
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);
1332 /* n_devs will reflect the actual number of allocated devices */
1333 n_devs = i;
1335 return ret;
1338 static void __exit vivi_exit(void)
1340 vivi_release();
1343 module_init(vivi_init);
1344 module_exit(vivi_exit);