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