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