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