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