drm/i915: NOMEM->NOSPC
[linux-2.6/mini2440.git] / drivers / media / video / vivi.c
blobfbfefae7886fac4cfc337a9d66b591ed9880fa11
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 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the BSD Licence, GNU General Public License
12 * as published by the Free Software Foundation; either version 2 of the
13 * License, or (at your option) any later version
15 #include <linux/module.h>
16 #include <linux/delay.h>
17 #include <linux/errno.h>
18 #include <linux/fs.h>
19 #include <linux/kernel.h>
20 #include <linux/slab.h>
21 #include <linux/mm.h>
22 #include <linux/ioport.h>
23 #include <linux/init.h>
24 #include <linux/sched.h>
25 #include <linux/pci.h>
26 #include <linux/random.h>
27 #include <linux/version.h>
28 #include <linux/mutex.h>
29 #include <linux/videodev2.h>
30 #include <linux/dma-mapping.h>
31 #include <linux/interrupt.h>
32 #include <linux/kthread.h>
33 #include <linux/highmem.h>
34 #include <linux/freezer.h>
35 #include <media/videobuf-vmalloc.h>
36 #include <media/v4l2-device.h>
37 #include <media/v4l2-ioctl.h>
38 #include "font.h"
40 #define VIVI_MODULE_NAME "vivi"
42 /* Wake up at about 30 fps */
43 #define WAKE_NUMERATOR 30
44 #define WAKE_DENOMINATOR 1001
45 #define BUFFER_TIMEOUT msecs_to_jiffies(500) /* 0.5 seconds */
47 #define VIVI_MAJOR_VERSION 0
48 #define VIVI_MINOR_VERSION 6
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");
74 /* supported controls */
75 static struct v4l2_queryctrl vivi_qctrl[] = {
77 .id = V4L2_CID_AUDIO_VOLUME,
78 .name = "Volume",
79 .minimum = 0,
80 .maximum = 65535,
81 .step = 65535/100,
82 .default_value = 65535,
83 .flags = V4L2_CTRL_FLAG_SLIDER,
84 .type = V4L2_CTRL_TYPE_INTEGER,
85 }, {
86 .id = V4L2_CID_BRIGHTNESS,
87 .type = V4L2_CTRL_TYPE_INTEGER,
88 .name = "Brightness",
89 .minimum = 0,
90 .maximum = 255,
91 .step = 1,
92 .default_value = 127,
93 .flags = V4L2_CTRL_FLAG_SLIDER,
94 }, {
95 .id = V4L2_CID_CONTRAST,
96 .type = V4L2_CTRL_TYPE_INTEGER,
97 .name = "Contrast",
98 .minimum = 0,
99 .maximum = 255,
100 .step = 0x1,
101 .default_value = 0x10,
102 .flags = V4L2_CTRL_FLAG_SLIDER,
103 }, {
104 .id = V4L2_CID_SATURATION,
105 .type = V4L2_CTRL_TYPE_INTEGER,
106 .name = "Saturation",
107 .minimum = 0,
108 .maximum = 255,
109 .step = 0x1,
110 .default_value = 127,
111 .flags = V4L2_CTRL_FLAG_SLIDER,
112 }, {
113 .id = V4L2_CID_HUE,
114 .type = V4L2_CTRL_TYPE_INTEGER,
115 .name = "Hue",
116 .minimum = -128,
117 .maximum = 127,
118 .step = 0x1,
119 .default_value = 0,
120 .flags = V4L2_CTRL_FLAG_SLIDER,
124 #define dprintk(dev, level, fmt, arg...) \
125 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
127 /* ------------------------------------------------------------------
128 Basic structures
129 ------------------------------------------------------------------*/
131 struct vivi_fmt {
132 char *name;
133 u32 fourcc; /* v4l2 format id */
134 int depth;
137 static struct vivi_fmt formats[] = {
139 .name = "4:2:2, packed, YUYV",
140 .fourcc = V4L2_PIX_FMT_YUYV,
141 .depth = 16,
144 .name = "4:2:2, packed, UYVY",
145 .fourcc = V4L2_PIX_FMT_UYVY,
146 .depth = 16,
149 .name = "RGB565 (LE)",
150 .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
151 .depth = 16,
154 .name = "RGB565 (BE)",
155 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
156 .depth = 16,
159 .name = "RGB555 (LE)",
160 .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
161 .depth = 16,
164 .name = "RGB555 (BE)",
165 .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
166 .depth = 16,
170 static struct vivi_fmt *get_format(struct v4l2_format *f)
172 struct vivi_fmt *fmt;
173 unsigned int k;
175 for (k = 0; k < ARRAY_SIZE(formats); k++) {
176 fmt = &formats[k];
177 if (fmt->fourcc == f->fmt.pix.pixelformat)
178 break;
181 if (k == ARRAY_SIZE(formats))
182 return NULL;
184 return &formats[k];
187 struct sg_to_addr {
188 int pos;
189 struct scatterlist *sg;
192 /* buffer for one video frame */
193 struct vivi_buffer {
194 /* common v4l buffer stuff -- must be first */
195 struct videobuf_buffer vb;
197 struct vivi_fmt *fmt;
200 struct vivi_dmaqueue {
201 struct list_head active;
203 /* thread for generating video stream*/
204 struct task_struct *kthread;
205 wait_queue_head_t wq;
206 /* Counters to control fps rate */
207 int frame;
208 int ini_jiffies;
211 static LIST_HEAD(vivi_devlist);
213 struct vivi_dev {
214 struct list_head vivi_devlist;
215 struct v4l2_device v4l2_dev;
217 spinlock_t slock;
218 struct mutex mutex;
220 int users;
222 /* various device info */
223 struct video_device *vfd;
225 struct vivi_dmaqueue vidq;
227 /* Several counters */
228 int h, m, s, ms;
229 unsigned long jiffies;
230 char timestr[13];
232 int mv_count; /* Controls bars movement */
234 /* Input Number */
235 int input;
237 /* Control 'registers' */
238 int qctl_regs[ARRAY_SIZE(vivi_qctrl)];
241 struct vivi_fh {
242 struct vivi_dev *dev;
244 /* video capture */
245 struct vivi_fmt *fmt;
246 unsigned int width, height;
247 struct videobuf_queue vb_vidq;
249 enum v4l2_buf_type type;
250 unsigned char bars[8][3];
251 int input; /* Input Number on bars */
254 /* ------------------------------------------------------------------
255 DMA and thread functions
256 ------------------------------------------------------------------*/
258 /* Bars and Colors should match positions */
260 enum colors {
261 WHITE,
262 AMBAR,
263 CYAN,
264 GREEN,
265 MAGENTA,
266 RED,
267 BLUE,
268 BLACK,
271 /* R G B */
272 #define COLOR_WHITE {204, 204, 204}
273 #define COLOR_AMBAR {208, 208, 0}
274 #define COLOR_CIAN { 0, 206, 206}
275 #define COLOR_GREEN { 0, 239, 0}
276 #define COLOR_MAGENTA {239, 0, 239}
277 #define COLOR_RED {205, 0, 0}
278 #define COLOR_BLUE { 0, 0, 255}
279 #define COLOR_BLACK { 0, 0, 0}
281 struct bar_std {
282 u8 bar[8][3];
285 /* Maximum number of bars are 10 - otherwise, the input print code
286 should be modified */
287 static struct bar_std bars[] = {
288 { /* Standard ITU-R color bar sequence */
290 COLOR_WHITE,
291 COLOR_AMBAR,
292 COLOR_CIAN,
293 COLOR_GREEN,
294 COLOR_MAGENTA,
295 COLOR_RED,
296 COLOR_BLUE,
297 COLOR_BLACK,
299 }, {
301 COLOR_WHITE,
302 COLOR_AMBAR,
303 COLOR_BLACK,
304 COLOR_WHITE,
305 COLOR_AMBAR,
306 COLOR_BLACK,
307 COLOR_WHITE,
308 COLOR_AMBAR,
310 }, {
312 COLOR_WHITE,
313 COLOR_CIAN,
314 COLOR_BLACK,
315 COLOR_WHITE,
316 COLOR_CIAN,
317 COLOR_BLACK,
318 COLOR_WHITE,
319 COLOR_CIAN,
321 }, {
323 COLOR_WHITE,
324 COLOR_GREEN,
325 COLOR_BLACK,
326 COLOR_WHITE,
327 COLOR_GREEN,
328 COLOR_BLACK,
329 COLOR_WHITE,
330 COLOR_GREEN,
335 #define NUM_INPUTS ARRAY_SIZE(bars)
337 #define TO_Y(r, g, b) \
338 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
339 /* RGB to V(Cr) Color transform */
340 #define TO_V(r, g, b) \
341 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
342 /* RGB to U(Cb) Color transform */
343 #define TO_U(r, g, b) \
344 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
346 #define TSTAMP_MIN_Y 24
347 #define TSTAMP_MAX_Y (TSTAMP_MIN_Y + 15)
348 #define TSTAMP_INPUT_X 10
349 #define TSTAMP_MIN_X (54 + TSTAMP_INPUT_X)
351 static void gen_twopix(struct vivi_fh *fh, unsigned char *buf, int colorpos)
353 unsigned char r_y, g_u, b_v;
354 unsigned char *p;
355 int color;
357 r_y = fh->bars[colorpos][0]; /* R or precalculated Y */
358 g_u = fh->bars[colorpos][1]; /* G or precalculated U */
359 b_v = fh->bars[colorpos][2]; /* B or precalculated V */
361 for (color = 0; color < 4; color++) {
362 p = buf + color;
364 switch (fh->fmt->fourcc) {
365 case V4L2_PIX_FMT_YUYV:
366 switch (color) {
367 case 0:
368 case 2:
369 *p = r_y;
370 break;
371 case 1:
372 *p = g_u;
373 break;
374 case 3:
375 *p = b_v;
376 break;
378 break;
379 case V4L2_PIX_FMT_UYVY:
380 switch (color) {
381 case 1:
382 case 3:
383 *p = r_y;
384 break;
385 case 0:
386 *p = g_u;
387 break;
388 case 2:
389 *p = b_v;
390 break;
392 break;
393 case V4L2_PIX_FMT_RGB565:
394 switch (color) {
395 case 0:
396 case 2:
397 *p = (g_u << 5) | b_v;
398 break;
399 case 1:
400 case 3:
401 *p = (r_y << 3) | (g_u >> 3);
402 break;
404 break;
405 case V4L2_PIX_FMT_RGB565X:
406 switch (color) {
407 case 0:
408 case 2:
409 *p = (r_y << 3) | (g_u >> 3);
410 break;
411 case 1:
412 case 3:
413 *p = (g_u << 5) | b_v;
414 break;
416 break;
417 case V4L2_PIX_FMT_RGB555:
418 switch (color) {
419 case 0:
420 case 2:
421 *p = (g_u << 5) | b_v;
422 break;
423 case 1:
424 case 3:
425 *p = (r_y << 2) | (g_u >> 3);
426 break;
428 break;
429 case V4L2_PIX_FMT_RGB555X:
430 switch (color) {
431 case 0:
432 case 2:
433 *p = (r_y << 2) | (g_u >> 3);
434 break;
435 case 1:
436 case 3:
437 *p = (g_u << 5) | b_v;
438 break;
440 break;
445 static void gen_line(struct vivi_fh *fh, char *basep, int inipos, int wmax,
446 int hmax, int line, int count, char *timestr)
448 int w, i, j;
449 int pos = inipos;
450 char *s;
451 u8 chr;
453 /* We will just duplicate the second pixel at the packet */
454 wmax /= 2;
456 /* Generate a standard color bar pattern */
457 for (w = 0; w < wmax; w++) {
458 int colorpos = ((w + count) * 8/(wmax + 1)) % 8;
460 gen_twopix(fh, basep + pos, colorpos);
461 pos += 4; /* only 16 bpp supported for now */
464 /* Prints input entry number */
466 /* Checks if it is possible to input number */
467 if (TSTAMP_MAX_Y >= hmax)
468 goto end;
470 if (TSTAMP_INPUT_X + strlen(timestr) >= wmax)
471 goto end;
473 if (line >= TSTAMP_MIN_Y && line <= TSTAMP_MAX_Y) {
474 chr = rom8x16_bits[fh->input * 16 + line - TSTAMP_MIN_Y];
475 pos = TSTAMP_INPUT_X;
476 for (i = 0; i < 7; i++) {
477 /* Draw white font on black background */
478 if (chr & 1 << (7 - i))
479 gen_twopix(fh, basep + pos, WHITE);
480 else
481 gen_twopix(fh, basep + pos, BLACK);
482 pos += 2;
486 /* Checks if it is possible to show timestamp */
487 if (TSTAMP_MIN_X + strlen(timestr) >= wmax)
488 goto end;
490 /* Print stream time */
491 if (line >= TSTAMP_MIN_Y && line <= TSTAMP_MAX_Y) {
492 j = TSTAMP_MIN_X;
493 for (s = timestr; *s; s++) {
494 chr = rom8x16_bits[(*s-0x30)*16+line-TSTAMP_MIN_Y];
495 for (i = 0; i < 7; i++) {
496 pos = inipos + j * 2;
497 /* Draw white font on black background */
498 if (chr & 1 << (7 - i))
499 gen_twopix(fh, basep + pos, WHITE);
500 else
501 gen_twopix(fh, basep + pos, BLACK);
502 j++;
507 end:
508 return;
511 static void vivi_fillbuff(struct vivi_fh *fh, struct vivi_buffer *buf)
513 struct vivi_dev *dev = fh->dev;
514 int h , pos = 0;
515 int hmax = buf->vb.height;
516 int wmax = buf->vb.width;
517 struct timeval ts;
518 char *tmpbuf;
519 void *vbuf = videobuf_to_vmalloc(&buf->vb);
521 if (!vbuf)
522 return;
524 tmpbuf = kmalloc(wmax * 2, GFP_ATOMIC);
525 if (!tmpbuf)
526 return;
528 for (h = 0; h < hmax; h++) {
529 gen_line(fh, tmpbuf, 0, wmax, hmax, h, dev->mv_count,
530 dev->timestr);
531 memcpy(vbuf + pos, tmpbuf, wmax * 2);
532 pos += wmax*2;
535 dev->mv_count++;
537 kfree(tmpbuf);
539 /* Updates stream time */
541 dev->ms += jiffies_to_msecs(jiffies-dev->jiffies);
542 dev->jiffies = jiffies;
543 if (dev->ms >= 1000) {
544 dev->ms -= 1000;
545 dev->s++;
546 if (dev->s >= 60) {
547 dev->s -= 60;
548 dev->m++;
549 if (dev->m > 60) {
550 dev->m -= 60;
551 dev->h++;
552 if (dev->h > 24)
553 dev->h -= 24;
557 sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
558 dev->h, dev->m, dev->s, dev->ms);
560 dprintk(dev, 2, "vivifill at %s: Buffer 0x%08lx size= %d\n",
561 dev->timestr, (unsigned long)tmpbuf, pos);
563 /* Advice that buffer was filled */
564 buf->vb.field_count++;
565 do_gettimeofday(&ts);
566 buf->vb.ts = ts;
567 buf->vb.state = VIDEOBUF_DONE;
570 static void vivi_thread_tick(struct vivi_fh *fh)
572 struct vivi_buffer *buf;
573 struct vivi_dev *dev = fh->dev;
574 struct vivi_dmaqueue *dma_q = &dev->vidq;
576 unsigned long flags = 0;
578 dprintk(dev, 1, "Thread tick\n");
580 spin_lock_irqsave(&dev->slock, flags);
581 if (list_empty(&dma_q->active)) {
582 dprintk(dev, 1, "No active queue to serve\n");
583 goto unlock;
586 buf = list_entry(dma_q->active.next,
587 struct vivi_buffer, vb.queue);
589 /* Nobody is waiting on this buffer, return */
590 if (!waitqueue_active(&buf->vb.done))
591 goto unlock;
593 list_del(&buf->vb.queue);
595 do_gettimeofday(&buf->vb.ts);
597 /* Fill buffer */
598 vivi_fillbuff(fh, buf);
599 dprintk(dev, 1, "filled buffer %p\n", buf);
601 wake_up(&buf->vb.done);
602 dprintk(dev, 2, "[%p/%d] wakeup\n", buf, buf->vb. i);
603 unlock:
604 spin_unlock_irqrestore(&dev->slock, flags);
605 return;
608 #define frames_to_ms(frames) \
609 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
611 static void vivi_sleep(struct vivi_fh *fh)
613 struct vivi_dev *dev = fh->dev;
614 struct vivi_dmaqueue *dma_q = &dev->vidq;
615 int timeout;
616 DECLARE_WAITQUEUE(wait, current);
618 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
619 (unsigned long)dma_q);
621 add_wait_queue(&dma_q->wq, &wait);
622 if (kthread_should_stop())
623 goto stop_task;
625 /* Calculate time to wake up */
626 timeout = msecs_to_jiffies(frames_to_ms(1));
628 vivi_thread_tick(fh);
630 schedule_timeout_interruptible(timeout);
632 stop_task:
633 remove_wait_queue(&dma_q->wq, &wait);
634 try_to_freeze();
637 static int vivi_thread(void *data)
639 struct vivi_fh *fh = data;
640 struct vivi_dev *dev = fh->dev;
642 dprintk(dev, 1, "thread started\n");
644 set_freezable();
646 for (;;) {
647 vivi_sleep(fh);
649 if (kthread_should_stop())
650 break;
652 dprintk(dev, 1, "thread: exit\n");
653 return 0;
656 static int vivi_start_thread(struct vivi_fh *fh)
658 struct vivi_dev *dev = fh->dev;
659 struct vivi_dmaqueue *dma_q = &dev->vidq;
661 dma_q->frame = 0;
662 dma_q->ini_jiffies = jiffies;
664 dprintk(dev, 1, "%s\n", __func__);
666 dma_q->kthread = kthread_run(vivi_thread, fh, "vivi");
668 if (IS_ERR(dma_q->kthread)) {
669 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
670 return PTR_ERR(dma_q->kthread);
672 /* Wakes thread */
673 wake_up_interruptible(&dma_q->wq);
675 dprintk(dev, 1, "returning from %s\n", __func__);
676 return 0;
679 static void vivi_stop_thread(struct vivi_dmaqueue *dma_q)
681 struct vivi_dev *dev = container_of(dma_q, struct vivi_dev, vidq);
683 dprintk(dev, 1, "%s\n", __func__);
684 /* shutdown control thread */
685 if (dma_q->kthread) {
686 kthread_stop(dma_q->kthread);
687 dma_q->kthread = NULL;
691 /* ------------------------------------------------------------------
692 Videobuf operations
693 ------------------------------------------------------------------*/
694 static int
695 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
697 struct vivi_fh *fh = vq->priv_data;
698 struct vivi_dev *dev = fh->dev;
700 *size = fh->width*fh->height*2;
702 if (0 == *count)
703 *count = 32;
705 while (*size * *count > vid_limit * 1024 * 1024)
706 (*count)--;
708 dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__,
709 *count, *size);
711 return 0;
714 static void free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
716 struct vivi_fh *fh = vq->priv_data;
717 struct vivi_dev *dev = fh->dev;
719 dprintk(dev, 1, "%s, state: %i\n", __func__, buf->vb.state);
721 if (in_interrupt())
722 BUG();
724 videobuf_vmalloc_free(&buf->vb);
725 dprintk(dev, 1, "free_buffer: freed\n");
726 buf->vb.state = VIDEOBUF_NEEDS_INIT;
729 #define norm_maxw() 1024
730 #define norm_maxh() 768
731 static int
732 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
733 enum v4l2_field field)
735 struct vivi_fh *fh = vq->priv_data;
736 struct vivi_dev *dev = fh->dev;
737 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
738 int rc;
740 dprintk(dev, 1, "%s, field=%d\n", __func__, field);
742 BUG_ON(NULL == fh->fmt);
744 if (fh->width < 48 || fh->width > norm_maxw() ||
745 fh->height < 32 || fh->height > norm_maxh())
746 return -EINVAL;
748 buf->vb.size = fh->width*fh->height*2;
749 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
750 return -EINVAL;
752 /* These properties only change when queue is idle, see s_fmt */
753 buf->fmt = fh->fmt;
754 buf->vb.width = fh->width;
755 buf->vb.height = fh->height;
756 buf->vb.field = field;
758 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
759 rc = videobuf_iolock(vq, &buf->vb, NULL);
760 if (rc < 0)
761 goto fail;
764 buf->vb.state = VIDEOBUF_PREPARED;
766 return 0;
768 fail:
769 free_buffer(vq, buf);
770 return rc;
773 static void
774 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
776 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
777 struct vivi_fh *fh = vq->priv_data;
778 struct vivi_dev *dev = fh->dev;
779 struct vivi_dmaqueue *vidq = &dev->vidq;
781 dprintk(dev, 1, "%s\n", __func__);
783 buf->vb.state = VIDEOBUF_QUEUED;
784 list_add_tail(&buf->vb.queue, &vidq->active);
787 static void buffer_release(struct videobuf_queue *vq,
788 struct videobuf_buffer *vb)
790 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
791 struct vivi_fh *fh = vq->priv_data;
792 struct vivi_dev *dev = (struct vivi_dev *)fh->dev;
794 dprintk(dev, 1, "%s\n", __func__);
796 free_buffer(vq, buf);
799 static struct videobuf_queue_ops vivi_video_qops = {
800 .buf_setup = buffer_setup,
801 .buf_prepare = buffer_prepare,
802 .buf_queue = buffer_queue,
803 .buf_release = buffer_release,
806 /* ------------------------------------------------------------------
807 IOCTL vidioc handling
808 ------------------------------------------------------------------*/
809 static int vidioc_querycap(struct file *file, void *priv,
810 struct v4l2_capability *cap)
812 struct vivi_fh *fh = priv;
813 struct vivi_dev *dev = fh->dev;
815 strcpy(cap->driver, "vivi");
816 strcpy(cap->card, "vivi");
817 strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
818 cap->version = VIVI_VERSION;
819 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
820 V4L2_CAP_STREAMING |
821 V4L2_CAP_READWRITE;
822 return 0;
825 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
826 struct v4l2_fmtdesc *f)
828 struct vivi_fmt *fmt;
830 if (f->index >= ARRAY_SIZE(formats))
831 return -EINVAL;
833 fmt = &formats[f->index];
835 strlcpy(f->description, fmt->name, sizeof(f->description));
836 f->pixelformat = fmt->fourcc;
837 return 0;
840 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
841 struct v4l2_format *f)
843 struct vivi_fh *fh = priv;
845 f->fmt.pix.width = fh->width;
846 f->fmt.pix.height = fh->height;
847 f->fmt.pix.field = fh->vb_vidq.field;
848 f->fmt.pix.pixelformat = fh->fmt->fourcc;
849 f->fmt.pix.bytesperline =
850 (f->fmt.pix.width * fh->fmt->depth) >> 3;
851 f->fmt.pix.sizeimage =
852 f->fmt.pix.height * f->fmt.pix.bytesperline;
854 return (0);
857 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
858 struct v4l2_format *f)
860 struct vivi_fh *fh = priv;
861 struct vivi_dev *dev = fh->dev;
862 struct vivi_fmt *fmt;
863 enum v4l2_field field;
864 unsigned int maxw, maxh;
866 fmt = get_format(f);
867 if (!fmt) {
868 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
869 f->fmt.pix.pixelformat);
870 return -EINVAL;
873 field = f->fmt.pix.field;
875 if (field == V4L2_FIELD_ANY) {
876 field = V4L2_FIELD_INTERLACED;
877 } else if (V4L2_FIELD_INTERLACED != field) {
878 dprintk(dev, 1, "Field type invalid.\n");
879 return -EINVAL;
882 maxw = norm_maxw();
883 maxh = norm_maxh();
885 f->fmt.pix.field = field;
886 if (f->fmt.pix.height < 32)
887 f->fmt.pix.height = 32;
888 if (f->fmt.pix.height > maxh)
889 f->fmt.pix.height = maxh;
890 if (f->fmt.pix.width < 48)
891 f->fmt.pix.width = 48;
892 if (f->fmt.pix.width > maxw)
893 f->fmt.pix.width = maxw;
894 f->fmt.pix.width &= ~0x03;
895 f->fmt.pix.bytesperline =
896 (f->fmt.pix.width * fmt->depth) >> 3;
897 f->fmt.pix.sizeimage =
898 f->fmt.pix.height * f->fmt.pix.bytesperline;
900 return 0;
903 /* precalculate color bar values to speed up rendering */
904 static void precalculate_bars(struct vivi_fh *fh)
906 struct vivi_dev *dev = fh->dev;
907 unsigned char r, g, b;
908 int k, is_yuv;
910 fh->input = dev->input;
912 for (k = 0; k < 8; k++) {
913 r = bars[fh->input].bar[k][0];
914 g = bars[fh->input].bar[k][1];
915 b = bars[fh->input].bar[k][2];
916 is_yuv = 0;
918 switch (fh->fmt->fourcc) {
919 case V4L2_PIX_FMT_YUYV:
920 case V4L2_PIX_FMT_UYVY:
921 is_yuv = 1;
922 break;
923 case V4L2_PIX_FMT_RGB565:
924 case V4L2_PIX_FMT_RGB565X:
925 r >>= 3;
926 g >>= 2;
927 b >>= 3;
928 break;
929 case V4L2_PIX_FMT_RGB555:
930 case V4L2_PIX_FMT_RGB555X:
931 r >>= 3;
932 g >>= 3;
933 b >>= 3;
934 break;
937 if (is_yuv) {
938 fh->bars[k][0] = TO_Y(r, g, b); /* Luma */
939 fh->bars[k][1] = TO_U(r, g, b); /* Cb */
940 fh->bars[k][2] = TO_V(r, g, b); /* Cr */
941 } else {
942 fh->bars[k][0] = r;
943 fh->bars[k][1] = g;
944 fh->bars[k][2] = b;
950 /*FIXME: This seems to be generic enough to be at videodev2 */
951 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
952 struct v4l2_format *f)
954 struct vivi_fh *fh = priv;
955 struct videobuf_queue *q = &fh->vb_vidq;
957 int ret = vidioc_try_fmt_vid_cap(file, fh, f);
958 if (ret < 0)
959 return ret;
961 mutex_lock(&q->vb_lock);
963 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
964 dprintk(fh->dev, 1, "%s queue busy\n", __func__);
965 ret = -EBUSY;
966 goto out;
969 fh->fmt = get_format(f);
970 fh->width = f->fmt.pix.width;
971 fh->height = f->fmt.pix.height;
972 fh->vb_vidq.field = f->fmt.pix.field;
973 fh->type = f->type;
975 precalculate_bars(fh);
977 ret = 0;
978 out:
979 mutex_unlock(&q->vb_lock);
981 return ret;
984 static int vidioc_reqbufs(struct file *file, void *priv,
985 struct v4l2_requestbuffers *p)
987 struct vivi_fh *fh = priv;
989 return (videobuf_reqbufs(&fh->vb_vidq, p));
992 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
994 struct vivi_fh *fh = priv;
996 return (videobuf_querybuf(&fh->vb_vidq, p));
999 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1001 struct vivi_fh *fh = priv;
1003 return (videobuf_qbuf(&fh->vb_vidq, p));
1006 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1008 struct vivi_fh *fh = priv;
1010 return (videobuf_dqbuf(&fh->vb_vidq, p,
1011 file->f_flags & O_NONBLOCK));
1014 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1015 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1017 struct vivi_fh *fh = priv;
1019 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1021 #endif
1023 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1025 struct vivi_fh *fh = priv;
1027 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1028 return -EINVAL;
1029 if (i != fh->type)
1030 return -EINVAL;
1032 return videobuf_streamon(&fh->vb_vidq);
1035 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1037 struct vivi_fh *fh = priv;
1039 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1040 return -EINVAL;
1041 if (i != fh->type)
1042 return -EINVAL;
1044 return videobuf_streamoff(&fh->vb_vidq);
1047 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1049 return 0;
1052 /* only one input in this sample driver */
1053 static int vidioc_enum_input(struct file *file, void *priv,
1054 struct v4l2_input *inp)
1056 if (inp->index >= NUM_INPUTS)
1057 return -EINVAL;
1059 inp->type = V4L2_INPUT_TYPE_CAMERA;
1060 inp->std = V4L2_STD_525_60;
1061 sprintf(inp->name, "Camera %u", inp->index);
1063 return (0);
1066 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1068 struct vivi_fh *fh = priv;
1069 struct vivi_dev *dev = fh->dev;
1071 *i = dev->input;
1073 return (0);
1075 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1077 struct vivi_fh *fh = priv;
1078 struct vivi_dev *dev = fh->dev;
1080 if (i >= NUM_INPUTS)
1081 return -EINVAL;
1083 dev->input = i;
1084 precalculate_bars(fh);
1086 return (0);
1089 /* --- controls ---------------------------------------------- */
1090 static int vidioc_queryctrl(struct file *file, void *priv,
1091 struct v4l2_queryctrl *qc)
1093 int i;
1095 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1096 if (qc->id && qc->id == vivi_qctrl[i].id) {
1097 memcpy(qc, &(vivi_qctrl[i]),
1098 sizeof(*qc));
1099 return (0);
1102 return -EINVAL;
1105 static int vidioc_g_ctrl(struct file *file, void *priv,
1106 struct v4l2_control *ctrl)
1108 struct vivi_fh *fh = priv;
1109 struct vivi_dev *dev = fh->dev;
1110 int i;
1112 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1113 if (ctrl->id == vivi_qctrl[i].id) {
1114 ctrl->value = dev->qctl_regs[i];
1115 return 0;
1118 return -EINVAL;
1120 static int vidioc_s_ctrl(struct file *file, void *priv,
1121 struct v4l2_control *ctrl)
1123 struct vivi_fh *fh = priv;
1124 struct vivi_dev *dev = fh->dev;
1125 int i;
1127 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1128 if (ctrl->id == vivi_qctrl[i].id) {
1129 if (ctrl->value < vivi_qctrl[i].minimum ||
1130 ctrl->value > vivi_qctrl[i].maximum) {
1131 return -ERANGE;
1133 dev->qctl_regs[i] = ctrl->value;
1134 return 0;
1136 return -EINVAL;
1139 /* ------------------------------------------------------------------
1140 File operations for the device
1141 ------------------------------------------------------------------*/
1143 static int vivi_open(struct file *file)
1145 struct vivi_dev *dev = video_drvdata(file);
1146 struct vivi_fh *fh = NULL;
1147 int retval = 0;
1149 mutex_lock(&dev->mutex);
1150 dev->users++;
1152 if (dev->users > 1) {
1153 dev->users--;
1154 mutex_unlock(&dev->mutex);
1155 return -EBUSY;
1158 dprintk(dev, 1, "open /dev/video%d type=%s users=%d\n", dev->vfd->num,
1159 v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
1161 /* allocate + initialize per filehandle data */
1162 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1163 if (NULL == fh) {
1164 dev->users--;
1165 retval = -ENOMEM;
1167 mutex_unlock(&dev->mutex);
1169 if (retval)
1170 return retval;
1172 file->private_data = fh;
1173 fh->dev = dev;
1175 fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1176 fh->fmt = &formats[0];
1177 fh->width = 640;
1178 fh->height = 480;
1180 /* Resets frame counters */
1181 dev->h = 0;
1182 dev->m = 0;
1183 dev->s = 0;
1184 dev->ms = 0;
1185 dev->mv_count = 0;
1186 dev->jiffies = jiffies;
1187 sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
1188 dev->h, dev->m, dev->s, dev->ms);
1190 videobuf_queue_vmalloc_init(&fh->vb_vidq, &vivi_video_qops,
1191 NULL, &dev->slock, fh->type, V4L2_FIELD_INTERLACED,
1192 sizeof(struct vivi_buffer), fh);
1194 vivi_start_thread(fh);
1196 return 0;
1199 static ssize_t
1200 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1202 struct vivi_fh *fh = file->private_data;
1204 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1205 return videobuf_read_stream(&fh->vb_vidq, data, count, ppos, 0,
1206 file->f_flags & O_NONBLOCK);
1208 return 0;
1211 static unsigned int
1212 vivi_poll(struct file *file, struct poll_table_struct *wait)
1214 struct vivi_fh *fh = file->private_data;
1215 struct vivi_dev *dev = fh->dev;
1216 struct videobuf_queue *q = &fh->vb_vidq;
1218 dprintk(dev, 1, "%s\n", __func__);
1220 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1221 return POLLERR;
1223 return videobuf_poll_stream(file, q, wait);
1226 static int vivi_close(struct file *file)
1228 struct vivi_fh *fh = file->private_data;
1229 struct vivi_dev *dev = fh->dev;
1230 struct vivi_dmaqueue *vidq = &dev->vidq;
1232 int minor = video_devdata(file)->minor;
1234 vivi_stop_thread(vidq);
1235 videobuf_stop(&fh->vb_vidq);
1236 videobuf_mmap_free(&fh->vb_vidq);
1238 kfree(fh);
1240 mutex_lock(&dev->mutex);
1241 dev->users--;
1242 mutex_unlock(&dev->mutex);
1244 dprintk(dev, 1, "close called (minor=%d, users=%d)\n",
1245 minor, dev->users);
1247 return 0;
1250 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1252 struct vivi_fh *fh = file->private_data;
1253 struct vivi_dev *dev = fh->dev;
1254 int ret;
1256 dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1258 ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1260 dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1261 (unsigned long)vma->vm_start,
1262 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1263 ret);
1265 return ret;
1268 static const struct v4l2_file_operations vivi_fops = {
1269 .owner = THIS_MODULE,
1270 .open = vivi_open,
1271 .release = vivi_close,
1272 .read = vivi_read,
1273 .poll = vivi_poll,
1274 .ioctl = video_ioctl2, /* V4L2 ioctl handler */
1275 .mmap = vivi_mmap,
1278 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1279 .vidioc_querycap = vidioc_querycap,
1280 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1281 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1282 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1283 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1284 .vidioc_reqbufs = vidioc_reqbufs,
1285 .vidioc_querybuf = vidioc_querybuf,
1286 .vidioc_qbuf = vidioc_qbuf,
1287 .vidioc_dqbuf = vidioc_dqbuf,
1288 .vidioc_s_std = vidioc_s_std,
1289 .vidioc_enum_input = vidioc_enum_input,
1290 .vidioc_g_input = vidioc_g_input,
1291 .vidioc_s_input = vidioc_s_input,
1292 .vidioc_queryctrl = vidioc_queryctrl,
1293 .vidioc_g_ctrl = vidioc_g_ctrl,
1294 .vidioc_s_ctrl = vidioc_s_ctrl,
1295 .vidioc_streamon = vidioc_streamon,
1296 .vidioc_streamoff = vidioc_streamoff,
1297 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1298 .vidiocgmbuf = vidiocgmbuf,
1299 #endif
1302 static struct video_device vivi_template = {
1303 .name = "vivi",
1304 .fops = &vivi_fops,
1305 .ioctl_ops = &vivi_ioctl_ops,
1306 .minor = -1,
1307 .release = video_device_release,
1309 .tvnorms = V4L2_STD_525_60,
1310 .current_norm = V4L2_STD_NTSC_M,
1313 /* -----------------------------------------------------------------
1314 Initialization and module stuff
1315 ------------------------------------------------------------------*/
1317 static int vivi_release(void)
1319 struct vivi_dev *dev;
1320 struct list_head *list;
1322 while (!list_empty(&vivi_devlist)) {
1323 list = vivi_devlist.next;
1324 list_del(list);
1325 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1327 v4l2_info(&dev->v4l2_dev, "unregistering /dev/video%d\n",
1328 dev->vfd->num);
1329 video_unregister_device(dev->vfd);
1330 v4l2_device_unregister(&dev->v4l2_dev);
1331 kfree(dev);
1334 return 0;
1337 static int __init vivi_create_instance(int inst)
1339 struct vivi_dev *dev;
1340 struct video_device *vfd;
1341 int ret, i;
1343 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1344 if (!dev)
1345 return -ENOMEM;
1347 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1348 "%s-%03d", VIVI_MODULE_NAME, inst);
1349 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1350 if (ret)
1351 goto free_dev;
1353 /* init video dma queues */
1354 INIT_LIST_HEAD(&dev->vidq.active);
1355 init_waitqueue_head(&dev->vidq.wq);
1357 /* initialize locks */
1358 spin_lock_init(&dev->slock);
1359 mutex_init(&dev->mutex);
1361 ret = -ENOMEM;
1362 vfd = video_device_alloc();
1363 if (!vfd)
1364 goto unreg_dev;
1366 *vfd = vivi_template;
1368 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1369 if (ret < 0)
1370 goto rel_vdev;
1372 video_set_drvdata(vfd, dev);
1374 /* Set all controls to their default value. */
1375 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1376 dev->qctl_regs[i] = vivi_qctrl[i].default_value;
1378 /* Now that everything is fine, let's add it to device list */
1379 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1381 snprintf(vfd->name, sizeof(vfd->name), "%s (%i)",
1382 vivi_template.name, vfd->num);
1384 if (video_nr >= 0)
1385 video_nr++;
1387 dev->vfd = vfd;
1388 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as /dev/video%d\n",
1389 vfd->num);
1390 return 0;
1392 rel_vdev:
1393 video_device_release(vfd);
1394 unreg_dev:
1395 v4l2_device_unregister(&dev->v4l2_dev);
1396 free_dev:
1397 kfree(dev);
1398 return ret;
1401 /* This routine allocates from 1 to n_devs virtual drivers.
1403 The real maximum number of virtual drivers will depend on how many drivers
1404 will succeed. This is limited to the maximum number of devices that
1405 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1407 static int __init vivi_init(void)
1409 int ret = 0, i;
1411 if (n_devs <= 0)
1412 n_devs = 1;
1414 for (i = 0; i < n_devs; i++) {
1415 ret = vivi_create_instance(i);
1416 if (ret) {
1417 /* If some instantiations succeeded, keep driver */
1418 if (i)
1419 ret = 0;
1420 break;
1424 if (ret < 0) {
1425 printk(KERN_INFO "Error %d while loading vivi driver\n", ret);
1426 return ret;
1429 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1430 "Capture Board ver %u.%u.%u successfully loaded.\n",
1431 (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1432 VIVI_VERSION & 0xFF);
1434 /* n_devs will reflect the actual number of allocated devices */
1435 n_devs = i;
1437 return ret;
1440 static void __exit vivi_exit(void)
1442 vivi_release();
1445 module_init(vivi_init);
1446 module_exit(vivi_exit);