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