git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/vivi.c

   1 /*
   2  * Virtual Video driver - This code emulates a real video device with v4l2 api
   3  *
   4  * Copyright (c) 2006 by:
   5  *      Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
   6  *      Ted Walther <ted--a.t--enumera.com>
   7  *      John Sokol <sokol--a.t--videotechnology.com>
   8  *      http://v4l.videotechnology.com/
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the BSD Licence, GNU General Public License
  12  * as published by the Free Software Foundation; either version 2 of the
  13  * License, or (at your option) any later version
  14  */
  15 #include <linux/module.h>
  16 #include <linux/delay.h>
  17 #include <linux/errno.h>
  18 #include <linux/fs.h>
  19 #include <linux/kernel.h>
  20 #include <linux/slab.h>
  21 #include <linux/mm.h>
  22 #include <linux/ioport.h>
  23 #include <linux/init.h>
  24 #include <linux/sched.h>
  25 #include <linux/pci.h>
  26 #include <linux/random.h>
  27 #include <linux/version.h>
  28 #include <linux/mutex.h>
  29 #include <linux/videodev2.h>
  30 #include <linux/dma-mapping.h>
  31 #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         if (f->fmt.pix.height < 32)
 887                 f->fmt.pix.height = 32;
 888         if (f->fmt.pix.height > maxh)
 889                 f->fmt.pix.height = maxh;
 890         if (f->fmt.pix.width < 48)
 891                 f->fmt.pix.width = 48;
 892         if (f->fmt.pix.width > maxw)
 893                 f->fmt.pix.width = maxw;
 894         f->fmt.pix.width &= ~0x03;
 895         f->fmt.pix.bytesperline =
 896                 (f->fmt.pix.width * fmt->depth) >> 3;
 897         f->fmt.pix.sizeimage =
 898                 f->fmt.pix.height * f->fmt.pix.bytesperline;
 899
 900         return 0;
 901 }
 902
 903 /* precalculate color bar values to speed up rendering */
 904 static void precalculate_bars(struct vivi_fh *fh)
 905 {
 906         struct vivi_dev *dev = fh->dev;
 907         unsigned char r, g, b;
 908         int k, is_yuv;
 909
 910         fh->input = dev->input;
 911
 912         for (k = 0; k < 8; k++) {
 913                 r = bars[fh->input].bar[k][0];
 914                 g = bars[fh->input].bar[k][1];
 915                 b = bars[fh->input].bar[k][2];
 916                 is_yuv = 0;
 917
 918                 switch (fh->fmt->fourcc) {
 919                 case V4L2_PIX_FMT_YUYV:
 920                 case V4L2_PIX_FMT_UYVY:
 921                         is_yuv = 1;
 922                         break;
 923                 case V4L2_PIX_FMT_RGB565:
 924                 case V4L2_PIX_FMT_RGB565X:
 925                         r >>= 3;
 926                         g >>= 2;
 927                         b >>= 3;
 928                         break;
 929                 case V4L2_PIX_FMT_RGB555:
 930                 case V4L2_PIX_FMT_RGB555X:
 931                         r >>= 3;
 932                         g >>= 3;
 933                         b >>= 3;
 934                         break;
 935                 }
 936
 937                 if (is_yuv) {
 938                         fh->bars[k][0] = TO_Y(r, g, b); /* Luma */
 939                         fh->bars[k][1] = TO_U(r, g, b); /* Cb */
 940                         fh->bars[k][2] = TO_V(r, g, b); /* Cr */
 941                 } else {
 942                         fh->bars[k][0] = r;
 943                         fh->bars[k][1] = g;
 944                         fh->bars[k][2] = b;
 945                 }
 946         }
 947
 948 }
 949
 950 /*FIXME: This seems to be generic enough to be at videodev2 */
 951 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 952                                         struct v4l2_format *f)
 953 {
 954         struct vivi_fh *fh = priv;
 955         struct videobuf_queue *q = &fh->vb_vidq;
 956
 957         int ret = vidioc_try_fmt_vid_cap(file, fh, f);
 958         if (ret < 0)
 959                 return ret;
 960
 961         mutex_lock(&q->vb_lock);
 962
 963         if (videobuf_queue_is_busy(&fh->vb_vidq)) {
 964                 dprintk(fh->dev, 1, "%s queue busy\n", __func__);
 965                 ret = -EBUSY;
 966                 goto out;
 967         }
 968
 969         fh->fmt           = get_format(f);
 970         fh->width         = f->fmt.pix.width;
 971         fh->height        = f->fmt.pix.height;
 972         fh->vb_vidq.field = f->fmt.pix.field;
 973         fh->type          = f->type;
 974
 975         precalculate_bars(fh);
 976
 977         ret = 0;
 978 out:
 979         mutex_unlock(&q->vb_lock);
 980
 981         return ret;
 982 }
 983
 984 static int vidioc_reqbufs(struct file *file, void *priv,
 985                           struct v4l2_requestbuffers *p)
 986 {
 987         struct vivi_fh  *fh = priv;
 988
 989         return (videobuf_reqbufs(&fh->vb_vidq, p));
 990 }
 991
 992 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
 993 {
 994         struct vivi_fh  *fh = priv;
 995
 996         return (videobuf_querybuf(&fh->vb_vidq, p));
 997 }
 998
 999 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1000 {
1001         struct vivi_fh *fh = priv;
1002
1003         return (videobuf_qbuf(&fh->vb_vidq, p));
1004 }
1005
1006 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1007 {
1008         struct vivi_fh  *fh = priv;
1009
1010         return (videobuf_dqbuf(&fh->vb_vidq, p,
1011                                 file->f_flags & O_NONBLOCK));
1012 }
1013
1014 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1015 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1016 {
1017         struct vivi_fh  *fh = priv;
1018
1019         return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1020 }
1021 #endif
1022
1023 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1024 {
1025         struct vivi_fh  *fh = priv;
1026
1027         if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1028                 return -EINVAL;
1029         if (i != fh->type)
1030                 return -EINVAL;
1031
1032         return videobuf_streamon(&fh->vb_vidq);
1033 }
1034
1035 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1036 {
1037         struct vivi_fh  *fh = priv;
1038
1039         if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1040                 return -EINVAL;
1041         if (i != fh->type)
1042                 return -EINVAL;
1043
1044         return videobuf_streamoff(&fh->vb_vidq);
1045 }
1046
1047 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1048 {
1049         return 0;
1050 }
1051
1052 /* only one input in this sample driver */
1053 static int vidioc_enum_input(struct file *file, void *priv,
1054                                 struct v4l2_input *inp)
1055 {
1056         if (inp->index >= NUM_INPUTS)
1057                 return -EINVAL;
1058
1059         inp->type = V4L2_INPUT_TYPE_CAMERA;
1060         inp->std = V4L2_STD_525_60;
1061         sprintf(inp->name, "Camera %u", inp->index);
1062
1063         return (0);
1064 }
1065
1066 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1067 {
1068         struct vivi_fh *fh = priv;
1069         struct vivi_dev *dev = fh->dev;
1070
1071         *i = dev->input;
1072
1073         return (0);
1074 }
1075 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1076 {
1077         struct vivi_fh *fh = priv;
1078         struct vivi_dev *dev = fh->dev;
1079
1080         if (i >= NUM_INPUTS)
1081                 return -EINVAL;
1082
1083         dev->input = i;
1084         precalculate_bars(fh);
1085
1086         return (0);
1087 }
1088
1089         /* --- controls ---------------------------------------------- */
1090 static int vidioc_queryctrl(struct file *file, void *priv,
1091                             struct v4l2_queryctrl *qc)
1092 {
1093         int i;
1094
1095         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1096                 if (qc->id && qc->id == vivi_qctrl[i].id) {
1097                         memcpy(qc, &(vivi_qctrl[i]),
1098                                 sizeof(*qc));
1099                         return (0);
1100                 }
1101
1102         return -EINVAL;
1103 }
1104
1105 static int vidioc_g_ctrl(struct file *file, void *priv,
1106                          struct v4l2_control *ctrl)
1107 {
1108         struct vivi_fh *fh = priv;
1109         struct vivi_dev *dev = fh->dev;
1110         int i;
1111
1112         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1113                 if (ctrl->id == vivi_qctrl[i].id) {
1114                         ctrl->value = dev->qctl_regs[i];
1115                         return 0;
1116                 }
1117
1118         return -EINVAL;
1119 }
1120 static int vidioc_s_ctrl(struct file *file, void *priv,
1121                                 struct v4l2_control *ctrl)
1122 {
1123         struct vivi_fh *fh = priv;
1124         struct vivi_dev *dev = fh->dev;
1125         int i;
1126
1127         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1128                 if (ctrl->id == vivi_qctrl[i].id) {
1129                         if (ctrl->value < vivi_qctrl[i].minimum ||
1130                             ctrl->value > vivi_qctrl[i].maximum) {
1131                                 return -ERANGE;
1132                         }
1133                         dev->qctl_regs[i] = ctrl->value;
1134                         return 0;
1135                 }
1136         return -EINVAL;
1137 }
1138
1139 /* ------------------------------------------------------------------
1140         File operations for the device
1141    ------------------------------------------------------------------*/
1142
1143 static int vivi_open(struct file *file)
1144 {
1145         struct vivi_dev *dev = video_drvdata(file);
1146         struct vivi_fh *fh = NULL;
1147         int retval = 0;
1148
1149         mutex_lock(&dev->mutex);
1150         dev->users++;
1151
1152         if (dev->users > 1) {
1153                 dev->users--;
1154                 mutex_unlock(&dev->mutex);
1155                 return -EBUSY;
1156         }
1157
1158         dprintk(dev, 1, "open /dev/video%d type=%s users=%d\n", dev->vfd->num,
1159                 v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
1160
1161         /* allocate + initialize per filehandle data */
1162         fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1163         if (NULL == fh) {
1164                 dev->users--;
1165                 retval = -ENOMEM;
1166         }
1167         mutex_unlock(&dev->mutex);
1168
1169         if (retval)
1170                 return retval;
1171
1172         file->private_data = fh;
1173         fh->dev      = dev;
1174
1175         fh->type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1176         fh->fmt      = &formats[0];
1177         fh->width    = 640;
1178         fh->height   = 480;
1179
1180         /* Resets frame counters */
1181         dev->h = 0;
1182         dev->m = 0;
1183         dev->s = 0;
1184         dev->ms = 0;
1185         dev->mv_count = 0;
1186         dev->jiffies = jiffies;
1187         sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
1188                         dev->h, dev->m, dev->s, dev->ms);
1189
1190         videobuf_queue_vmalloc_init(&fh->vb_vidq, &vivi_video_qops,
1191                         NULL, &dev->slock, fh->type, V4L2_FIELD_INTERLACED,
1192                         sizeof(struct vivi_buffer), fh);
1193
1194         vivi_start_thread(fh);
1195
1196         return 0;
1197 }
1198
1199 static ssize_t
1200 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1201 {
1202         struct vivi_fh *fh = file->private_data;
1203
1204         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1205                 return videobuf_read_stream(&fh->vb_vidq, data, count, ppos, 0,
1206                                         file->f_flags & O_NONBLOCK);
1207         }
1208         return 0;
1209 }
1210
1211 static unsigned int
1212 vivi_poll(struct file *file, struct poll_table_struct *wait)
1213 {
1214         struct vivi_fh        *fh = file->private_data;
1215         struct vivi_dev       *dev = fh->dev;
1216         struct videobuf_queue *q = &fh->vb_vidq;
1217
1218         dprintk(dev, 1, "%s\n", __func__);
1219
1220         if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1221                 return POLLERR;
1222
1223         return videobuf_poll_stream(file, q, wait);
1224 }
1225
1226 static int vivi_close(struct file *file)
1227 {
1228         struct vivi_fh         *fh = file->private_data;
1229         struct vivi_dev *dev       = fh->dev;
1230         struct vivi_dmaqueue *vidq = &dev->vidq;
1231
1232         int minor = video_devdata(file)->minor;
1233
1234         vivi_stop_thread(vidq);
1235         videobuf_stop(&fh->vb_vidq);
1236         videobuf_mmap_free(&fh->vb_vidq);
1237
1238         kfree(fh);
1239
1240         mutex_lock(&dev->mutex);
1241         dev->users--;
1242         mutex_unlock(&dev->mutex);
1243
1244         dprintk(dev, 1, "close called (minor=%d, users=%d)\n",
1245                 minor, dev->users);
1246
1247         return 0;
1248 }
1249
1250 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1251 {
1252         struct vivi_fh  *fh = file->private_data;
1253         struct vivi_dev *dev = fh->dev;
1254         int ret;
1255
1256         dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1257
1258         ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1259
1260         dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1261                 (unsigned long)vma->vm_start,
1262                 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1263                 ret);
1264
1265         return ret;
1266 }
1267
1268 static const struct v4l2_file_operations vivi_fops = {
1269         .owner          = THIS_MODULE,
1270         .open           = vivi_open,
1271         .release        = vivi_close,
1272         .read           = vivi_read,
1273         .poll           = vivi_poll,
1274         .ioctl          = video_ioctl2, /* V4L2 ioctl handler */
1275         .mmap           = vivi_mmap,
1276 };
1277
1278 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1279         .vidioc_querycap      = vidioc_querycap,
1280         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1281         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1282         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1283         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1284         .vidioc_reqbufs       = vidioc_reqbufs,
1285         .vidioc_querybuf      = vidioc_querybuf,
1286         .vidioc_qbuf          = vidioc_qbuf,
1287         .vidioc_dqbuf         = vidioc_dqbuf,
1288         .vidioc_s_std         = vidioc_s_std,
1289         .vidioc_enum_input    = vidioc_enum_input,
1290         .vidioc_g_input       = vidioc_g_input,
1291         .vidioc_s_input       = vidioc_s_input,
1292         .vidioc_queryctrl     = vidioc_queryctrl,
1293         .vidioc_g_ctrl        = vidioc_g_ctrl,
1294         .vidioc_s_ctrl        = vidioc_s_ctrl,
1295         .vidioc_streamon      = vidioc_streamon,
1296         .vidioc_streamoff     = vidioc_streamoff,
1297 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1298         .vidiocgmbuf          = vidiocgmbuf,
1299 #endif
1300 };
1301
1302 static struct video_device vivi_template = {
1303         .name           = "vivi",
1304         .fops           = &vivi_fops,
1305         .ioctl_ops      = &vivi_ioctl_ops,
1306         .minor          = -1,
1307         .release        = video_device_release,
1308
1309         .tvnorms              = V4L2_STD_525_60,
1310         .current_norm         = V4L2_STD_NTSC_M,
1311 };
1312
1313 /* -----------------------------------------------------------------
1314         Initialization and module stuff
1315    ------------------------------------------------------------------*/
1316
1317 static int vivi_release(void)
1318 {
1319         struct vivi_dev *dev;
1320         struct list_head *list;
1321
1322         while (!list_empty(&vivi_devlist)) {
1323                 list = vivi_devlist.next;
1324                 list_del(list);
1325                 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1326
1327                 v4l2_info(&dev->v4l2_dev, "unregistering /dev/video%d\n",
1328                         dev->vfd->num);
1329                 video_unregister_device(dev->vfd);
1330                 v4l2_device_unregister(&dev->v4l2_dev);
1331                 kfree(dev);
1332         }
1333
1334         return 0;
1335 }
1336
1337 static int __init vivi_create_instance(int inst)
1338 {
1339         struct vivi_dev *dev;
1340         struct video_device *vfd;
1341         int ret, i;
1342
1343         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1344         if (!dev)
1345                 return -ENOMEM;
1346
1347         snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1348                         "%s-%03d", VIVI_MODULE_NAME, inst);
1349         ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1350         if (ret)
1351                 goto free_dev;
1352
1353         /* init video dma queues */
1354         INIT_LIST_HEAD(&dev->vidq.active);
1355         init_waitqueue_head(&dev->vidq.wq);
1356
1357         /* initialize locks */
1358         spin_lock_init(&dev->slock);
1359         mutex_init(&dev->mutex);
1360
1361         ret = -ENOMEM;
1362         vfd = video_device_alloc();
1363         if (!vfd)
1364                 goto unreg_dev;
1365
1366         *vfd = vivi_template;
1367
1368         ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1369         if (ret < 0)
1370                 goto rel_vdev;
1371
1372         video_set_drvdata(vfd, dev);
1373
1374         /* Set all controls to their default value. */
1375         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1376                 dev->qctl_regs[i] = vivi_qctrl[i].default_value;
1377
1378         /* Now that everything is fine, let's add it to device list */
1379         list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1380
1381         snprintf(vfd->name, sizeof(vfd->name), "%s (%i)",
1382                         vivi_template.name, vfd->num);
1383
1384         if (video_nr >= 0)
1385                 video_nr++;
1386
1387         dev->vfd = vfd;
1388         v4l2_info(&dev->v4l2_dev, "V4L2 device registered as /dev/video%d\n",
1389                         vfd->num);
1390         return 0;
1391
1392 rel_vdev:
1393         video_device_release(vfd);
1394 unreg_dev:
1395         v4l2_device_unregister(&dev->v4l2_dev);
1396 free_dev:
1397         kfree(dev);
1398         return ret;
1399 }
1400
1401 /* This routine allocates from 1 to n_devs virtual drivers.
1402
1403    The real maximum number of virtual drivers will depend on how many drivers
1404    will succeed. This is limited to the maximum number of devices that
1405    videodev supports, which is equal to VIDEO_NUM_DEVICES.
1406  */
1407 static int __init vivi_init(void)
1408 {
1409         int ret = 0, i;
1410
1411         if (n_devs <= 0)
1412                 n_devs = 1;
1413
1414         for (i = 0; i < n_devs; i++) {
1415                 ret = vivi_create_instance(i);
1416                 if (ret) {
1417                         /* If some instantiations succeeded, keep driver */
1418                         if (i)
1419                                 ret = 0;
1420                         break;
1421                 }
1422         }
1423
1424         if (ret < 0) {
1425                 printk(KERN_INFO "Error %d while loading vivi driver\n", ret);
1426                 return ret;
1427         }
1428
1429         printk(KERN_INFO "Video Technology Magazine Virtual Video "
1430                         "Capture Board ver %u.%u.%u successfully loaded.\n",
1431                         (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1432                         VIVI_VERSION & 0xFF);
1433
1434         /* n_devs will reflect the actual number of allocated devices */
1435         n_devs = i;
1436
1437         return ret;
1438 }
1439
1440 static void __exit vivi_exit(void)
1441 {
1442         vivi_release();
1443 }
1444
1445 module_init(vivi_init);
1446 module_exit(vivi_exit);