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