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