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