drivers/media/video/vivi.c

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