?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (9237): Add uyvy pixel format support to vivi
[linux-2.6/mini2440.git] / drivers / media / video / vivi.c
blob2a6ebc126c09ad6c7aa18acf271a516e740ed610
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 * 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
14 */
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 #ifdef CONFIG_VIDEO_V4L1_COMPAT
32 /* Include V4L1 specific functions. Should be removed soon */
33 #include <linux/videodev.h>
34 #endif
35 #include <linux/interrupt.h>
36 #include <media/videobuf-vmalloc.h>
37 #include <media/v4l2-common.h>
38 #include <media/v4l2-ioctl.h>
39 #include <linux/kthread.h>
40 #include <linux/highmem.h>
41 #include <linux/freezer.h>
42
43 #define VIVI_MODULE_NAME "vivi"
44
45 /* Wake up at about 30 fps */
46 #define WAKE_NUMERATOR 30
47 #define WAKE_DENOMINATOR 1001
48 #define BUFFER_TIMEOUT msecs_to_jiffies(500) /* 0.5 seconds */
49
50 #include "font.h"
51
52 #define VIVI_MAJOR_VERSION 0
53 #define VIVI_MINOR_VERSION 5
54 #define VIVI_RELEASE 0
55 #define VIVI_VERSION \
56 KERNEL_VERSION(VIVI_MAJOR_VERSION, VIVI_MINOR_VERSION, VIVI_RELEASE)
57
58 /* Declare static vars that will be used as parameters */
59 static unsigned int vid_limit = 16; /* Video memory limit, in Mb */
60 static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
61 static int n_devs = 1; /* Number of virtual devices */
62
63 /* supported controls */
64 static struct v4l2_queryctrl vivi_qctrl[] = {
65 {
66 .id = V4L2_CID_AUDIO_VOLUME,
67 .name = "Volume",
68 .minimum = 0,
69 .maximum = 65535,
70 .step = 65535/100,
71 .default_value = 65535,
72 .flags = 0,
73 .type = V4L2_CTRL_TYPE_INTEGER,
74 }, {
75 .id = V4L2_CID_BRIGHTNESS,
76 .type = V4L2_CTRL_TYPE_INTEGER,
77 .name = "Brightness",
78 .minimum = 0,
79 .maximum = 255,
80 .step = 1,
81 .default_value = 127,
82 .flags = 0,
83 }, {
84 .id = V4L2_CID_CONTRAST,
85 .type = V4L2_CTRL_TYPE_INTEGER,
86 .name = "Contrast",
87 .minimum = 0,
88 .maximum = 255,
89 .step = 0x1,
90 .default_value = 0x10,
91 .flags = 0,
92 }, {
93 .id = V4L2_CID_SATURATION,
94 .type = V4L2_CTRL_TYPE_INTEGER,
95 .name = "Saturation",
96 .minimum = 0,
97 .maximum = 255,
98 .step = 0x1,
99 .default_value = 127,
100 .flags = 0,
101 }, {
102 .id = V4L2_CID_HUE,
103 .type = V4L2_CTRL_TYPE_INTEGER,
104 .name = "Hue",
105 .minimum = -128,
106 .maximum = 127,
107 .step = 0x1,
108 .default_value = 0,
109 .flags = 0,
110 }
111 };
112
113 static int qctl_regs[ARRAY_SIZE(vivi_qctrl)];
114
115 #define dprintk(dev, level, fmt, arg...) \
116 do { \
117 if (dev->vfd->debug >= (level)) \
118 printk(KERN_DEBUG "vivi: " fmt , ## arg); \
119 } while (0)
120
121 /* ------------------------------------------------------------------
122 Basic structures
123 ------------------------------------------------------------------*/
124
125 struct vivi_fmt {
126 char *name;
127 u32 fourcc; /* v4l2 format id */
128 int depth;
129 };
130
131 static struct vivi_fmt formats[] = {
132 {
133 .name = "4:2:2, packed, YUYV",
134 .fourcc = V4L2_PIX_FMT_YUYV,
135 .depth = 16,
136 },
137 {
138 .name = "4:2:2, packed, UYVY",
139 .fourcc = V4L2_PIX_FMT_UYVY,
140 .depth = 16,
141 },
142 };
143
144 static struct vivi_fmt *get_format(struct v4l2_format *f)
145 {
146 struct vivi_fmt *fmt;
147 unsigned int k;
148
149 for (k = 0; k < ARRAY_SIZE(formats); k++) {
150 fmt = &formats[k];
151 if (fmt->fourcc == f->fmt.pix.pixelformat)
152 break;
153 }
154
155 if (k == ARRAY_SIZE(formats))
156 return NULL;
157
158 return &formats[k];
159 }
160
161 struct sg_to_addr {
162 int pos;
163 struct scatterlist *sg;
164 };
165
166 /* buffer for one video frame */
167 struct vivi_buffer {
168 /* common v4l buffer stuff -- must be first */
169 struct videobuf_buffer vb;
170
171 struct vivi_fmt *fmt;
172 };
173
174 struct vivi_dmaqueue {
175 struct list_head active;
176
177 /* thread for generating video stream*/
178 struct task_struct *kthread;
179 wait_queue_head_t wq;
180 /* Counters to control fps rate */
181 int frame;
182 int ini_jiffies;
183 };
184
185 static LIST_HEAD(vivi_devlist);
186
187 struct vivi_dev {
188 struct list_head vivi_devlist;
189
190 spinlock_t slock;
191 struct mutex mutex;
192
193 int users;
194
195 /* various device info */
196 struct video_device *vfd;
197
198 struct vivi_dmaqueue vidq;
199
200 /* Several counters */
201 int h, m, s, ms;
202 unsigned long jiffies;
203 char timestr[13];
204
205 int mv_count; /* Controls bars movement */
206 };
207
208 struct vivi_fh {
209 struct vivi_dev *dev;
210
211 /* video capture */
212 struct vivi_fmt *fmt;
213 unsigned int width, height;
214 struct videobuf_queue vb_vidq;
215
216 enum v4l2_buf_type type;
217 unsigned char bars[8][3];
218 };
219
220 /* ------------------------------------------------------------------
221 DMA and thread functions
222 ------------------------------------------------------------------*/
223
224 /* Bars and Colors should match positions */
225
226 enum colors {
227 WHITE,
228 AMBAR,
229 CYAN,
230 GREEN,
231 MAGENTA,
232 RED,
233 BLUE,
234 BLACK,
235 };
236
237 static u8 bars[8][3] = {
238 /* R G B */
239 {204, 204, 204}, /* white */
240 {208, 208, 0}, /* ambar */
241 { 0, 206, 206}, /* cyan */
242 { 0, 239, 0}, /* green */
243 {239, 0, 239}, /* magenta */
244 {205, 0, 0}, /* red */
245 { 0, 0, 255}, /* blue */
246 { 0, 0, 0}, /* black */
247 };
248
249 #define TO_Y(r, g, b) \
250 (((16829 * r + 33039 * g + 6416 * b + 32768) >> 16) + 16)
251 /* RGB to V(Cr) Color transform */
252 #define TO_V(r, g, b) \
253 (((28784 * r - 24103 * g - 4681 * b + 32768) >> 16) + 128)
254 /* RGB to U(Cb) Color transform */
255 #define TO_U(r, g, b) \
256 (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
257
258 #define TSTAMP_MIN_Y 24
259 #define TSTAMP_MAX_Y TSTAMP_MIN_Y+15
260 #define TSTAMP_MIN_X 64
261
262 static void gen_twopix(struct vivi_fh *fh, unsigned char *buf, int colorpos)
263 {
264 unsigned char r_y, g_u, b_v;
265 unsigned char *p;
266 int color;
267
268 r_y = fh->bars[colorpos][0]; /* R or precalculated Y */
269 g_u = fh->bars[colorpos][1]; /* G or precalculated U */
270 b_v = fh->bars[colorpos][2]; /* B or precalculated V */
271
272 for (color = 0; color < 4; color++) {
273 p = buf + color;
274
275 switch (fh->fmt->fourcc) {
276 case V4L2_PIX_FMT_YUYV:
277 switch (color) {
278 case 0:
279 case 2:
280 *p = r_y;
281 break;
282 case 1:
283 *p = g_u;
284 break;
285 case 3:
286 *p = b_v;
287 break;
288 }
289 break;
290 case V4L2_PIX_FMT_UYVY:
291 switch (color) {
292 case 1:
293 case 3:
294 *p = r_y;
295 break;
296 case 0:
297 *p = g_u;
298 break;
299 case 2:
300 *p = b_v;
301 break;
302 }
303 break;
304 }
305 }
306 }
307
308 static void gen_line(struct vivi_fh *fh, char *basep, int inipos, int wmax,
309 int hmax, int line, int count, char *timestr)
310 {
311 int w, i, j;
312 int pos = inipos;
313 char *s;
314 u8 chr;
315
316 /* We will just duplicate the second pixel at the packet */
317 wmax /= 2;
318
319 /* Generate a standard color bar pattern */
320 for (w = 0; w < wmax; w++) {
321 int colorpos = ((w + count) * 8/(wmax + 1)) % 8;
322
323 gen_twopix(fh, basep + pos, colorpos);
324 pos += 4; /* only 16 bpp supported for now */
325 }
326
327 /* Checks if it is possible to show timestamp */
328 if (TSTAMP_MAX_Y >= hmax)
329 goto end;
330 if (TSTAMP_MIN_X + strlen(timestr) >= wmax)
331 goto end;
332
333 /* Print stream time */
334 if (line >= TSTAMP_MIN_Y && line <= TSTAMP_MAX_Y) {
335 j = TSTAMP_MIN_X;
336 for (s = timestr; *s; s++) {
337 chr = rom8x16_bits[(*s-0x30)*16+line-TSTAMP_MIN_Y];
338 for (i = 0; i < 7; i++) {
339 pos = inipos + j * 2;
340 /* Draw white font on black background */
341 if (chr & 1 << (7 - i))
342 gen_twopix(fh, basep + pos, WHITE);
343 else
344 gen_twopix(fh, basep + pos, BLACK);
345 j++;
346 }
347 }
348 }
349
350 end:
351 return;
352 }
353
354 static void vivi_fillbuff(struct vivi_fh *fh, struct vivi_buffer *buf)
355 {
356 struct vivi_dev *dev = fh->dev;
357 int h , pos = 0;
358 int hmax = buf->vb.height;
359 int wmax = buf->vb.width;
360 struct timeval ts;
361 char *tmpbuf;
362 void *vbuf = videobuf_to_vmalloc(&buf->vb);
363
364 if (!vbuf)
365 return;
366
367 tmpbuf = kmalloc(wmax * 2, GFP_ATOMIC);
368 if (!tmpbuf)
369 return;
370
371 for (h = 0; h < hmax; h++) {
372 gen_line(fh, tmpbuf, 0, wmax, hmax, h, dev->mv_count,
373 dev->timestr);
374 memcpy(vbuf + pos, tmpbuf, wmax * 2);
375 pos += wmax*2;
376 }
377
378 dev->mv_count++;
379
380 kfree(tmpbuf);
381
382 /* Updates stream time */
383
384 dev->ms += jiffies_to_msecs(jiffies-dev->jiffies);
385 dev->jiffies = jiffies;
386 if (dev->ms >= 1000) {
387 dev->ms -= 1000;
388 dev->s++;
389 if (dev->s >= 60) {
390 dev->s -= 60;
391 dev->m++;
392 if (dev->m > 60) {
393 dev->m -= 60;
394 dev->h++;
395 if (dev->h > 24)
396 dev->h -= 24;
397 }
398 }
399 }
400 sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
401 dev->h, dev->m, dev->s, dev->ms);
402
403 dprintk(dev, 2, "vivifill at %s: Buffer 0x%08lx size= %d\n",
404 dev->timestr, (unsigned long)tmpbuf, pos);
405
406 /* Advice that buffer was filled */
407 buf->vb.field_count++;
408 do_gettimeofday(&ts);
409 buf->vb.ts = ts;
410 buf->vb.state = VIDEOBUF_DONE;
411 }
412
413 static void vivi_thread_tick(struct vivi_fh *fh)
414 {
415 struct vivi_buffer *buf;
416 struct vivi_dev *dev = fh->dev;
417 struct vivi_dmaqueue *dma_q = &dev->vidq;
418
419 unsigned long flags = 0;
420
421 dprintk(dev, 1, "Thread tick\n");
422
423 spin_lock_irqsave(&dev->slock, flags);
424 if (list_empty(&dma_q->active)) {
425 dprintk(dev, 1, "No active queue to serve\n");
426 goto unlock;
427 }
428
429 buf = list_entry(dma_q->active.next,
430 struct vivi_buffer, vb.queue);
431
432 /* Nobody is waiting on this buffer, return */
433 if (!waitqueue_active(&buf->vb.done))
434 goto unlock;
435
436 list_del(&buf->vb.queue);
437
438 do_gettimeofday(&buf->vb.ts);
439
440 /* Fill buffer */
441 vivi_fillbuff(fh, buf);
442 dprintk(dev, 1, "filled buffer %p\n", buf);
443
444 wake_up(&buf->vb.done);
445 dprintk(dev, 2, "[%p/%d] wakeup\n", buf, buf->vb. i);
446 unlock:
447 spin_unlock_irqrestore(&dev->slock, flags);
448 return;
449 }
450
451 #define frames_to_ms(frames) \
452 ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
453
454 static void vivi_sleep(struct vivi_fh *fh)
455 {
456 struct vivi_dev *dev = fh->dev;
457 struct vivi_dmaqueue *dma_q = &dev->vidq;
458 int timeout;
459 DECLARE_WAITQUEUE(wait, current);
460
461 dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
462 (unsigned long)dma_q);
463
464 add_wait_queue(&dma_q->wq, &wait);
465 if (kthread_should_stop())
466 goto stop_task;
467
468 /* Calculate time to wake up */
469 timeout = msecs_to_jiffies(frames_to_ms(1));
470
471 vivi_thread_tick(fh);
472
473 schedule_timeout_interruptible(timeout);
474
475 stop_task:
476 remove_wait_queue(&dma_q->wq, &wait);
477 try_to_freeze();
478 }
479
480 static int vivi_thread(void *data)
481 {
482 struct vivi_fh *fh = data;
483 struct vivi_dev *dev = fh->dev;
484
485 dprintk(dev, 1, "thread started\n");
486
487 set_freezable();
488
489 for (;;) {
490 vivi_sleep(fh);
491
492 if (kthread_should_stop())
493 break;
494 }
495 dprintk(dev, 1, "thread: exit\n");
496 return 0;
497 }
498
499 static int vivi_start_thread(struct vivi_fh *fh)
500 {
501 struct vivi_dev *dev = fh->dev;
502 struct vivi_dmaqueue *dma_q = &dev->vidq;
503
504 dma_q->frame = 0;
505 dma_q->ini_jiffies = jiffies;
506
507 dprintk(dev, 1, "%s\n", __func__);
508
509 dma_q->kthread = kthread_run(vivi_thread, fh, "vivi");
510
511 if (IS_ERR(dma_q->kthread)) {
512 printk(KERN_ERR "vivi: kernel_thread() failed\n");
513 return PTR_ERR(dma_q->kthread);
514 }
515 /* Wakes thread */
516 wake_up_interruptible(&dma_q->wq);
517
518 dprintk(dev, 1, "returning from %s\n", __func__);
519 return 0;
520 }
521
522 static void vivi_stop_thread(struct vivi_dmaqueue *dma_q)
523 {
524 struct vivi_dev *dev = container_of(dma_q, struct vivi_dev, vidq);
525
526 dprintk(dev, 1, "%s\n", __func__);
527 /* shutdown control thread */
528 if (dma_q->kthread) {
529 kthread_stop(dma_q->kthread);
530 dma_q->kthread = NULL;
531 }
532 }
533
534 /* ------------------------------------------------------------------
535 Videobuf operations
536 ------------------------------------------------------------------*/
537 static int
538 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
539 {
540 struct vivi_fh *fh = vq->priv_data;
541 struct vivi_dev *dev = fh->dev;
542
543 *size = fh->width*fh->height*2;
544
545 if (0 == *count)
546 *count = 32;
547
548 while (*size * *count > vid_limit * 1024 * 1024)
549 (*count)--;
550
551 dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__,
552 *count, *size);
553
554 return 0;
555 }
556
557 static void free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
558 {
559 struct vivi_fh *fh = vq->priv_data;
560 struct vivi_dev *dev = fh->dev;
561
562 dprintk(dev, 1, "%s, state: %i\n", __func__, buf->vb.state);
563
564 if (in_interrupt())
565 BUG();
566
567 videobuf_vmalloc_free(&buf->vb);
568 dprintk(dev, 1, "free_buffer: freed\n");
569 buf->vb.state = VIDEOBUF_NEEDS_INIT;
570 }
571
572 #define norm_maxw() 1024
573 #define norm_maxh() 768
574 static int
575 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
576 enum v4l2_field field)
577 {
578 struct vivi_fh *fh = vq->priv_data;
579 struct vivi_dev *dev = fh->dev;
580 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
581 int rc;
582
583 dprintk(dev, 1, "%s, field=%d\n", __func__, field);
584
585 BUG_ON(NULL == fh->fmt);
586
587 if (fh->width < 48 || fh->width > norm_maxw() ||
588 fh->height < 32 || fh->height > norm_maxh())
589 return -EINVAL;
590
591 buf->vb.size = fh->width*fh->height*2;
592 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
593 return -EINVAL;
594
595 /* These properties only change when queue is idle, see s_fmt */
596 buf->fmt = fh->fmt;
597 buf->vb.width = fh->width;
598 buf->vb.height = fh->height;
599 buf->vb.field = field;
600
601 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
602 rc = videobuf_iolock(vq, &buf->vb, NULL);
603 if (rc < 0)
604 goto fail;
605 }
606
607 buf->vb.state = VIDEOBUF_PREPARED;
608
609 return 0;
610
611 fail:
612 free_buffer(vq, buf);
613 return rc;
614 }
615
616 static void
617 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
618 {
619 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
620 struct vivi_fh *fh = vq->priv_data;
621 struct vivi_dev *dev = fh->dev;
622 struct vivi_dmaqueue *vidq = &dev->vidq;
623
624 dprintk(dev, 1, "%s\n", __func__);
625
626 buf->vb.state = VIDEOBUF_QUEUED;
627 list_add_tail(&buf->vb.queue, &vidq->active);
628 }
629
630 static void buffer_release(struct videobuf_queue *vq,
631 struct videobuf_buffer *vb)
632 {
633 struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
634 struct vivi_fh *fh = vq->priv_data;
635 struct vivi_dev *dev = (struct vivi_dev *)fh->dev;
636
637 dprintk(dev, 1, "%s\n", __func__);
638
639 free_buffer(vq, buf);
640 }
641
642 static struct videobuf_queue_ops vivi_video_qops = {
643 .buf_setup = buffer_setup,
644 .buf_prepare = buffer_prepare,
645 .buf_queue = buffer_queue,
646 .buf_release = buffer_release,
647 };
648
649 /* ------------------------------------------------------------------
650 IOCTL vidioc handling
651 ------------------------------------------------------------------*/
652 static int vidioc_querycap(struct file *file, void *priv,
653 struct v4l2_capability *cap)
654 {
655 strcpy(cap->driver, "vivi");
656 strcpy(cap->card, "vivi");
657 cap->version = VIVI_VERSION;
658 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
659 V4L2_CAP_STREAMING |
660 V4L2_CAP_READWRITE;
661 return 0;
662 }
663
664 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
665 struct v4l2_fmtdesc *f)
666 {
667 struct vivi_fmt *fmt;
668
669 if (f->index >= ARRAY_SIZE(formats))
670 return -EINVAL;
671
672 fmt = &formats[f->index];
673
674 strlcpy(f->description, fmt->name, sizeof(f->description));
675 f->pixelformat = fmt->fourcc;
676 return 0;
677 }
678
679 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
680 struct v4l2_format *f)
681 {
682 struct vivi_fh *fh = priv;
683
684 f->fmt.pix.width = fh->width;
685 f->fmt.pix.height = fh->height;
686 f->fmt.pix.field = fh->vb_vidq.field;
687 f->fmt.pix.pixelformat = fh->fmt->fourcc;
688 f->fmt.pix.bytesperline =
689 (f->fmt.pix.width * fh->fmt->depth) >> 3;
690 f->fmt.pix.sizeimage =
691 f->fmt.pix.height * f->fmt.pix.bytesperline;
692
693 return (0);
694 }
695
696 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
697 struct v4l2_format *f)
698 {
699 struct vivi_fh *fh = priv;
700 struct vivi_dev *dev = fh->dev;
701 struct vivi_fmt *fmt;
702 enum v4l2_field field;
703 unsigned int maxw, maxh;
704
705 fmt = get_format(f);
706 if (!fmt) {
707 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
708 f->fmt.pix.pixelformat);
709 return -EINVAL;
710 }
711
712 field = f->fmt.pix.field;
713
714 if (field == V4L2_FIELD_ANY) {
715 field = V4L2_FIELD_INTERLACED;
716 } else if (V4L2_FIELD_INTERLACED != field) {
717 dprintk(dev, 1, "Field type invalid.\n");
718 return -EINVAL;
719 }
720
721 maxw = norm_maxw();
722 maxh = norm_maxh();
723
724 f->fmt.pix.field = field;
725 if (f->fmt.pix.height < 32)
726 f->fmt.pix.height = 32;
727 if (f->fmt.pix.height > maxh)
728 f->fmt.pix.height = maxh;
729 if (f->fmt.pix.width < 48)
730 f->fmt.pix.width = 48;
731 if (f->fmt.pix.width > maxw)
732 f->fmt.pix.width = maxw;
733 f->fmt.pix.width &= ~0x03;
734 f->fmt.pix.bytesperline =
735 (f->fmt.pix.width * fmt->depth) >> 3;
736 f->fmt.pix.sizeimage =
737 f->fmt.pix.height * f->fmt.pix.bytesperline;
738
739 return 0;
740 }
741
742 /*FIXME: This seems to be generic enough to be at videodev2 */
743 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
744 struct v4l2_format *f)
745 {
746 struct vivi_fh *fh = priv;
747 struct videobuf_queue *q = &fh->vb_vidq;
748 unsigned char r, g, b;
749 int k, is_yuv;
750
751 int ret = vidioc_try_fmt_vid_cap(file, fh, f);
752 if (ret < 0)
753 return (ret);
754
755 mutex_lock(&q->vb_lock);
756
757 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
758 dprintk(fh->dev, 1, "%s queue busy\n", __func__);
759 ret = -EBUSY;
760 goto out;
761 }
762
763 fh->fmt = get_format(f);
764 fh->width = f->fmt.pix.width;
765 fh->height = f->fmt.pix.height;
766 fh->vb_vidq.field = f->fmt.pix.field;
767 fh->type = f->type;
768
769 /* precalculate color bar values to speed up rendering */
770 for (k = 0; k < 8; k++) {
771 r = bars[k][0];
772 g = bars[k][1];
773 b = bars[k][2];
774 is_yuv = 0;
775
776 switch (fh->fmt->fourcc) {
777 case V4L2_PIX_FMT_YUYV:
778 case V4L2_PIX_FMT_UYVY:
779 is_yuv = 1;
780 break;
781 }
782
783 if (is_yuv) {
784 fh->bars[k][0] = TO_Y(r, g, b); /* Luma */
785 fh->bars[k][1] = TO_U(r, g, b); /* Cb */
786 fh->bars[k][2] = TO_V(r, g, b); /* Cr */
787 } else {
788 fh->bars[k][0] = r;
789 fh->bars[k][1] = g;
790 fh->bars[k][2] = b;
791 }
792 }
793
794 ret = 0;
795 out:
796 mutex_unlock(&q->vb_lock);
797
798 return (ret);
799 }
800
801 static int vidioc_reqbufs(struct file *file, void *priv,
802 struct v4l2_requestbuffers *p)
803 {
804 struct vivi_fh *fh = priv;
805
806 return (videobuf_reqbufs(&fh->vb_vidq, p));
807 }
808
809 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
810 {
811 struct vivi_fh *fh = priv;
812
813 return (videobuf_querybuf(&fh->vb_vidq, p));
814 }
815
816 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
817 {
818 struct vivi_fh *fh = priv;
819
820 return (videobuf_qbuf(&fh->vb_vidq, p));
821 }
822
823 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
824 {
825 struct vivi_fh *fh = priv;
826
827 return (videobuf_dqbuf(&fh->vb_vidq, p,
828 file->f_flags & O_NONBLOCK));
829 }
830
831 #ifdef CONFIG_VIDEO_V4L1_COMPAT
832 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
833 {
834 struct vivi_fh *fh = priv;
835
836 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
837 }
838 #endif
839
840 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
841 {
842 struct vivi_fh *fh = priv;
843
844 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
845 return -EINVAL;
846 if (i != fh->type)
847 return -EINVAL;
848
849 return videobuf_streamon(&fh->vb_vidq);
850 }
851
852 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
853 {
854 struct vivi_fh *fh = priv;
855
856 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
857 return -EINVAL;
858 if (i != fh->type)
859 return -EINVAL;
860
861 return videobuf_streamoff(&fh->vb_vidq);
862 }
863
864 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
865 {
866 return 0;
867 }
868
869 /* only one input in this sample driver */
870 static int vidioc_enum_input(struct file *file, void *priv,
871 struct v4l2_input *inp)
872 {
873 if (inp->index != 0)
874 return -EINVAL;
875
876 inp->type = V4L2_INPUT_TYPE_CAMERA;
877 inp->std = V4L2_STD_525_60;
878 strcpy(inp->name, "Camera");
879
880 return (0);
881 }
882
883 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
884 {
885 *i = 0;
886
887 return (0);
888 }
889 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
890 {
891 if (i > 0)
892 return -EINVAL;
893
894 return (0);
895 }
896
897 /* --- controls ---------------------------------------------- */
898 static int vidioc_queryctrl(struct file *file, void *priv,
899 struct v4l2_queryctrl *qc)
900 {
901 int i;
902
903 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
904 if (qc->id && qc->id == vivi_qctrl[i].id) {
905 memcpy(qc, &(vivi_qctrl[i]),
906 sizeof(*qc));
907 return (0);
908 }
909
910 return -EINVAL;
911 }
912
913 static int vidioc_g_ctrl(struct file *file, void *priv,
914 struct v4l2_control *ctrl)
915 {
916 int i;
917
918 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
919 if (ctrl->id == vivi_qctrl[i].id) {
920 ctrl->value = qctl_regs[i];
921 return (0);
922 }
923
924 return -EINVAL;
925 }
926 static int vidioc_s_ctrl(struct file *file, void *priv,
927 struct v4l2_control *ctrl)
928 {
929 int i;
930
931 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
932 if (ctrl->id == vivi_qctrl[i].id) {
933 if (ctrl->value < vivi_qctrl[i].minimum
934 || ctrl->value > vivi_qctrl[i].maximum) {
935 return (-ERANGE);
936 }
937 qctl_regs[i] = ctrl->value;
938 return (0);
939 }
940 return -EINVAL;
941 }
942
943 /* ------------------------------------------------------------------
944 File operations for the device
945 ------------------------------------------------------------------*/
946
947 static int vivi_open(struct inode *inode, struct file *file)
948 {
949 int minor = iminor(inode);
950 struct vivi_dev *dev;
951 struct vivi_fh *fh = NULL;
952 int i;
953 int retval = 0;
954
955 printk(KERN_DEBUG "vivi: open called (minor=%d)\n", minor);
956
957 lock_kernel();
958 list_for_each_entry(dev, &vivi_devlist, vivi_devlist)
959 if (dev->vfd->minor == minor)
960 goto found;
961 unlock_kernel();
962 return -ENODEV;
963
964 found:
965 mutex_lock(&dev->mutex);
966 dev->users++;
967
968 if (dev->users > 1) {
969 dev->users--;
970 retval = -EBUSY;
971 goto unlock;
972 }
973
974 dprintk(dev, 1, "open minor=%d type=%s users=%d\n", minor,
975 v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
976
977 /* allocate + initialize per filehandle data */
978 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
979 if (NULL == fh) {
980 dev->users--;
981 retval = -ENOMEM;
982 goto unlock;
983 }
984 unlock:
985 mutex_unlock(&dev->mutex);
986 if (retval) {
987 unlock_kernel();
988 return retval;
989 }
990
991 file->private_data = fh;
992 fh->dev = dev;
993
994 fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
995 fh->fmt = &formats[0];
996 fh->width = 640;
997 fh->height = 480;
998
999 /* Put all controls at a sane state */
1000 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1001 qctl_regs[i] = vivi_qctrl[i].default_value;
1002
1003 /* Resets frame counters */
1004 dev->h = 0;
1005 dev->m = 0;
1006 dev->s = 0;
1007 dev->ms = 0;
1008 dev->mv_count = 0;
1009 dev->jiffies = jiffies;
1010 sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
1011 dev->h, dev->m, dev->s, dev->ms);
1012
1013 videobuf_queue_vmalloc_init(&fh->vb_vidq, &vivi_video_qops,
1014 NULL, &dev->slock, fh->type, V4L2_FIELD_INTERLACED,
1015 sizeof(struct vivi_buffer), fh);
1016
1017 vivi_start_thread(fh);
1018 unlock_kernel();
1019
1020 return 0;
1021 }
1022
1023 static ssize_t
1024 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1025 {
1026 struct vivi_fh *fh = file->private_data;
1027
1028 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1029 return videobuf_read_stream(&fh->vb_vidq, data, count, ppos, 0,
1030 file->f_flags & O_NONBLOCK);
1031 }
1032 return 0;
1033 }
1034
1035 static unsigned int
1036 vivi_poll(struct file *file, struct poll_table_struct *wait)
1037 {
1038 struct vivi_fh *fh = file->private_data;
1039 struct vivi_dev *dev = fh->dev;
1040 struct videobuf_queue *q = &fh->vb_vidq;
1041
1042 dprintk(dev, 1, "%s\n", __func__);
1043
1044 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1045 return POLLERR;
1046
1047 return videobuf_poll_stream(file, q, wait);
1048 }
1049
1050 static int vivi_close(struct inode *inode, struct file *file)
1051 {
1052 struct vivi_fh *fh = file->private_data;
1053 struct vivi_dev *dev = fh->dev;
1054 struct vivi_dmaqueue *vidq = &dev->vidq;
1055
1056 int minor = iminor(inode);
1057
1058 vivi_stop_thread(vidq);
1059 videobuf_stop(&fh->vb_vidq);
1060 videobuf_mmap_free(&fh->vb_vidq);
1061
1062 kfree(fh);
1063
1064 mutex_lock(&dev->mutex);
1065 dev->users--;
1066 mutex_unlock(&dev->mutex);
1067
1068 dprintk(dev, 1, "close called (minor=%d, users=%d)\n",
1069 minor, dev->users);
1070
1071 return 0;
1072 }
1073
1074 static int vivi_release(void)
1075 {
1076 struct vivi_dev *dev;
1077 struct list_head *list;
1078
1079 while (!list_empty(&vivi_devlist)) {
1080 list = vivi_devlist.next;
1081 list_del(list);
1082 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1083
1084 if (-1 != dev->vfd->minor) {
1085 printk(KERN_INFO "%s: unregistering /dev/video%d\n",
1086 VIVI_MODULE_NAME, dev->vfd->minor);
1087 video_unregister_device(dev->vfd);
1088 } else {
1089 printk(KERN_INFO "%s: releasing /dev/video%d\n",
1090 VIVI_MODULE_NAME, dev->vfd->minor);
1091 video_device_release(dev->vfd);
1092 }
1093
1094 kfree(dev);
1095 }
1096
1097 return 0;
1098 }
1099
1100 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1101 {
1102 struct vivi_fh *fh = file->private_data;
1103 struct vivi_dev *dev = fh->dev;
1104 int ret;
1105
1106 dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1107
1108 ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1109
1110 dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1111 (unsigned long)vma->vm_start,
1112 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1113 ret);
1114
1115 return ret;
1116 }
1117
1118 static const struct file_operations vivi_fops = {
1119 .owner = THIS_MODULE,
1120 .open = vivi_open,
1121 .release = vivi_close,
1122 .read = vivi_read,
1123 .poll = vivi_poll,
1124 .ioctl = video_ioctl2, /* V4L2 ioctl handler */
1125 .compat_ioctl = v4l_compat_ioctl32,
1126 .mmap = vivi_mmap,
1127 .llseek = no_llseek,
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_queryctrl = vidioc_queryctrl,
1145 .vidioc_g_ctrl = vidioc_g_ctrl,
1146 .vidioc_s_ctrl = vidioc_s_ctrl,
1147 .vidioc_streamon = vidioc_streamon,
1148 .vidioc_streamoff = vidioc_streamoff,
1149 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1150 .vidiocgmbuf = vidiocgmbuf,
1151 #endif
1152 };
1153
1154 static struct video_device vivi_template = {
1155 .name = "vivi",
1156 .fops = &vivi_fops,
1157 .ioctl_ops = &vivi_ioctl_ops,
1158 .minor = -1,
1159 .release = video_device_release,
1160
1161 .tvnorms = V4L2_STD_525_60,
1162 .current_norm = V4L2_STD_NTSC_M,
1163 };
1164 /* -----------------------------------------------------------------
1165 Initialization and module stuff
1166 ------------------------------------------------------------------*/
1167
1168 /* This routine allocates from 1 to n_devs virtual drivers.
1169
1170 The real maximum number of virtual drivers will depend on how many drivers
1171 will succeed. This is limited to the maximum number of devices that
1172 videodev supports. Since there are 64 minors for video grabbers, this is
1173 currently the theoretical maximum limit. However, a further limit does
1174 exist at videodev that forbids any driver to register more than 32 video
1175 grabbers.
1176 */
1177 static int __init vivi_init(void)
1178 {
1179 int ret = -ENOMEM, i;
1180 struct vivi_dev *dev;
1181 struct video_device *vfd;
1182
1183 if (n_devs <= 0)
1184 n_devs = 1;
1185
1186 for (i = 0; i < n_devs; i++) {
1187 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1188 if (!dev)
1189 break;
1190
1191 /* init video dma queues */
1192 INIT_LIST_HEAD(&dev->vidq.active);
1193 init_waitqueue_head(&dev->vidq.wq);
1194
1195 /* initialize locks */
1196 spin_lock_init(&dev->slock);
1197 mutex_init(&dev->mutex);
1198
1199 vfd = video_device_alloc();
1200 if (!vfd) {
1201 kfree(dev);
1202 break;
1203 }
1204
1205 *vfd = vivi_template;
1206
1207 ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1208 if (ret < 0) {
1209 video_device_release(vfd);
1210 kfree(dev);
1211
1212 /* If some registers succeeded, keep driver */
1213 if (i)
1214 ret = 0;
1215
1216 break;
1217 }
1218
1219 /* Now that everything is fine, let's add it to device list */
1220 list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1221
1222 snprintf(vfd->name, sizeof(vfd->name), "%s (%i)",
1223 vivi_template.name, vfd->minor);
1224
1225 if (video_nr >= 0)
1226 video_nr++;
1227
1228 dev->vfd = vfd;
1229 printk(KERN_INFO "%s: V4L2 device registered as /dev/video%d\n",
1230 VIVI_MODULE_NAME, vfd->minor);
1231 }
1232
1233 if (ret < 0) {
1234 vivi_release();
1235 printk(KERN_INFO "Error %d while loading vivi driver\n", ret);
1236 } else {
1237 printk(KERN_INFO "Video Technology Magazine Virtual Video "
1238 "Capture Board ver %u.%u.%u successfully loaded.\n",
1239 (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1240 VIVI_VERSION & 0xFF);
1241
1242 /* n_devs will reflect the actual number of allocated devices */
1243 n_devs = i;
1244 }
1245
1246 return ret;
1247 }
1248
1249 static void __exit vivi_exit(void)
1250 {
1251 vivi_release();
1252 }
1253
1254 module_init(vivi_init);
1255 module_exit(vivi_exit);
1256
1257 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
1258 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
1259 MODULE_LICENSE("Dual BSD/GPL");
1260
1261 module_param(video_nr, uint, 0444);
1262 MODULE_PARM_DESC(video_nr, "video iminor start number");
1263
1264 module_param(n_devs, uint, 0444);
1265 MODULE_PARM_DESC(n_devs, "number of video devices to create");
1266
1267 module_param_named(debug, vivi_template.debug, int, 0444);
1268 MODULE_PARM_DESC(debug, "activates debug info");
1269
1270 module_param(vid_limit, int, 0644);
1271 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
Support for the Chinese Samsung S3C2440 based development boards