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