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