Pileus Git - ~andy/linux/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  *      Conversion to videobuf2 by Pawel Osciak & Marek Szyprowski
  11  *      Copyright (c) 2010 Samsung Electronics
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the BSD Licence, GNU General Public License
  15  * as published by the Free Software Foundation; either version 2 of the
  16  * License, or (at your option) any later version
  17  */
  18 #include <linux/module.h>
  19 #include <linux/errno.h>
  20 #include <linux/kernel.h>
  21 #include <linux/init.h>
  22 #include <linux/sched.h>
  23 #include <linux/slab.h>
  24 #include <linux/font.h>
  25 #include <linux/version.h>
  26 #include <linux/mutex.h>
  27 #include <linux/videodev2.h>
  28 #include <linux/kthread.h>
  29 #include <linux/freezer.h>
  30 #include <media/videobuf2-vmalloc.h>
  31 #include <media/v4l2-device.h>
  32 #include <media/v4l2-ioctl.h>
  33 #include <media/v4l2-ctrls.h>
  34 #include <media/v4l2-common.h>
  35
  36 #define VIVI_MODULE_NAME "vivi"
  37
  38 /* Wake up at about 30 fps */
  39 #define WAKE_NUMERATOR 30
  40 #define WAKE_DENOMINATOR 1001
  41 #define BUFFER_TIMEOUT     msecs_to_jiffies(500)  /* 0.5 seconds */
  42
  43 #define MAX_WIDTH 1920
  44 #define MAX_HEIGHT 1200
  45
  46 #define VIVI_MAJOR_VERSION 0
  47 #define VIVI_MINOR_VERSION 8
  48 #define VIVI_RELEASE 0
  49 #define VIVI_VERSION \
  50         KERNEL_VERSION(VIVI_MAJOR_VERSION, VIVI_MINOR_VERSION, VIVI_RELEASE)
  51
  52 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
  53 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
  54 MODULE_LICENSE("Dual BSD/GPL");
  55
  56 static unsigned video_nr = -1;
  57 module_param(video_nr, uint, 0644);
  58 MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect");
  59
  60 static unsigned n_devs = 1;
  61 module_param(n_devs, uint, 0644);
  62 MODULE_PARM_DESC(n_devs, "number of video devices to create");
  63
  64 static unsigned debug;
  65 module_param(debug, uint, 0644);
  66 MODULE_PARM_DESC(debug, "activates debug info");
  67
  68 static unsigned int vid_limit = 16;
  69 module_param(vid_limit, uint, 0644);
  70 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
  71
  72 /* Global font descriptor */
  73 static const u8 *font8x16;
  74
  75 #define dprintk(dev, level, fmt, arg...) \
  76         v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
  77
  78 /* ------------------------------------------------------------------
  79         Basic structures
  80    ------------------------------------------------------------------*/
  81
  82 struct vivi_fmt {
  83         char  *name;
  84         u32   fourcc;          /* v4l2 format id */
  85         int   depth;
  86 };
  87
  88 static struct vivi_fmt formats[] = {
  89         {
  90                 .name     = "4:2:2, packed, YUYV",
  91                 .fourcc   = V4L2_PIX_FMT_YUYV,
  92                 .depth    = 16,
  93         },
  94         {
  95                 .name     = "4:2:2, packed, UYVY",
  96                 .fourcc   = V4L2_PIX_FMT_UYVY,
  97                 .depth    = 16,
  98         },
  99         {
 100                 .name     = "RGB565 (LE)",
 101                 .fourcc   = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
 102                 .depth    = 16,
 103         },
 104         {
 105                 .name     = "RGB565 (BE)",
 106                 .fourcc   = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
 107                 .depth    = 16,
 108         },
 109         {
 110                 .name     = "RGB555 (LE)",
 111                 .fourcc   = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
 112                 .depth    = 16,
 113         },
 114         {
 115                 .name     = "RGB555 (BE)",
 116                 .fourcc   = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
 117                 .depth    = 16,
 118         },
 119 };
 120
 121 static struct vivi_fmt *get_format(struct v4l2_format *f)
 122 {
 123         struct vivi_fmt *fmt;
 124         unsigned int k;
 125
 126         for (k = 0; k < ARRAY_SIZE(formats); k++) {
 127                 fmt = &formats[k];
 128                 if (fmt->fourcc == f->fmt.pix.pixelformat)
 129                         break;
 130         }
 131
 132         if (k == ARRAY_SIZE(formats))
 133                 return NULL;
 134
 135         return &formats[k];
 136 }
 137
 138 /* buffer for one video frame */
 139 struct vivi_buffer {
 140         /* common v4l buffer stuff -- must be first */
 141         struct vb2_buffer       vb;
 142         struct list_head        list;
 143         struct vivi_fmt        *fmt;
 144 };
 145
 146 struct vivi_dmaqueue {
 147         struct list_head       active;
 148
 149         /* thread for generating video stream*/
 150         struct task_struct         *kthread;
 151         wait_queue_head_t          wq;
 152         /* Counters to control fps rate */
 153         int                        frame;
 154         int                        ini_jiffies;
 155 };
 156
 157 static LIST_HEAD(vivi_devlist);
 158
 159 struct vivi_dev {
 160         struct list_head           vivi_devlist;
 161         struct v4l2_device         v4l2_dev;
 162         struct v4l2_ctrl_handler   ctrl_handler;
 163
 164         /* controls */
 165         struct v4l2_ctrl           *brightness;
 166         struct v4l2_ctrl           *contrast;
 167         struct v4l2_ctrl           *saturation;
 168         struct v4l2_ctrl           *hue;
 169         struct v4l2_ctrl           *volume;
 170         struct v4l2_ctrl           *button;
 171         struct v4l2_ctrl           *boolean;
 172         struct v4l2_ctrl           *int32;
 173         struct v4l2_ctrl           *int64;
 174         struct v4l2_ctrl           *menu;
 175         struct v4l2_ctrl           *string;
 176
 177         spinlock_t                 slock;
 178         struct mutex               mutex;
 179
 180         /* various device info */
 181         struct video_device        *vfd;
 182
 183         struct vivi_dmaqueue       vidq;
 184
 185         /* Several counters */
 186         unsigned                   ms;
 187         unsigned long              jiffies;
 188         unsigned                   button_pressed;
 189
 190         int                        mv_count;    /* Controls bars movement */
 191
 192         /* Input Number */
 193         int                        input;
 194
 195         /* video capture */
 196         struct vivi_fmt            *fmt;
 197         unsigned int               width, height;
 198         struct vb2_queue           vb_vidq;
 199         enum v4l2_field            field;
 200         unsigned int               field_count;
 201
 202         unsigned int               open_count;
 203         u8                         bars[9][3];
 204         u8                         line[MAX_WIDTH * 4];
 205 };
 206
 207 /* ------------------------------------------------------------------
 208         DMA and thread functions
 209    ------------------------------------------------------------------*/
 210
 211 /* Bars and Colors should match positions */
 212
 213 enum colors {
 214         WHITE,
 215         AMBER,
 216         CYAN,
 217         GREEN,
 218         MAGENTA,
 219         RED,
 220         BLUE,
 221         BLACK,
 222         TEXT_BLACK,
 223 };
 224
 225 /* R   G   B */
 226 #define COLOR_WHITE     {204, 204, 204}
 227 #define COLOR_AMBER     {208, 208,   0}
 228 #define COLOR_CYAN      {  0, 206, 206}
 229 #define COLOR_GREEN     {  0, 239,   0}
 230 #define COLOR_MAGENTA   {239,   0, 239}
 231 #define COLOR_RED       {205,   0,   0}
 232 #define COLOR_BLUE      {  0,   0, 255}
 233 #define COLOR_BLACK     {  0,   0,   0}
 234
 235 struct bar_std {
 236         u8 bar[9][3];
 237 };
 238
 239 /* Maximum number of bars are 10 - otherwise, the input print code
 240    should be modified */
 241 static struct bar_std bars[] = {
 242         {       /* Standard ITU-R color bar sequence */
 243                 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
 244                   COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
 245         }, {
 246                 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
 247                   COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
 248         }, {
 249                 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
 250                   COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
 251         }, {
 252                 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
 253                   COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
 254         },
 255 };
 256
 257 #define NUM_INPUTS ARRAY_SIZE(bars)
 258
 259 #define TO_Y(r, g, b) \
 260         (((16829 * r + 33039 * g + 6416 * b  + 32768) >> 16) + 16)
 261 /* RGB to  V(Cr) Color transform */
 262 #define TO_V(r, g, b) \
 263         (((28784 * r - 24103 * g - 4681 * b  + 32768) >> 16) + 128)
 264 /* RGB to  U(Cb) Color transform */
 265 #define TO_U(r, g, b) \
 266         (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
 267
 268 /* precalculate color bar values to speed up rendering */
 269 static void precalculate_bars(struct vivi_dev *dev)
 270 {
 271         u8 r, g, b;
 272         int k, is_yuv;
 273
 274         for (k = 0; k < 9; k++) {
 275                 r = bars[dev->input].bar[k][0];
 276                 g = bars[dev->input].bar[k][1];
 277                 b = bars[dev->input].bar[k][2];
 278                 is_yuv = 0;
 279
 280                 switch (dev->fmt->fourcc) {
 281                 case V4L2_PIX_FMT_YUYV:
 282                 case V4L2_PIX_FMT_UYVY:
 283                         is_yuv = 1;
 284                         break;
 285                 case V4L2_PIX_FMT_RGB565:
 286                 case V4L2_PIX_FMT_RGB565X:
 287                         r >>= 3;
 288                         g >>= 2;
 289                         b >>= 3;
 290                         break;
 291                 case V4L2_PIX_FMT_RGB555:
 292                 case V4L2_PIX_FMT_RGB555X:
 293                         r >>= 3;
 294                         g >>= 3;
 295                         b >>= 3;
 296                         break;
 297                 }
 298
 299                 if (is_yuv) {
 300                         dev->bars[k][0] = TO_Y(r, g, b);        /* Luma */
 301                         dev->bars[k][1] = TO_U(r, g, b);        /* Cb */
 302                         dev->bars[k][2] = TO_V(r, g, b);        /* Cr */
 303                 } else {
 304                         dev->bars[k][0] = r;
 305                         dev->bars[k][1] = g;
 306                         dev->bars[k][2] = b;
 307                 }
 308         }
 309 }
 310
 311 #define TSTAMP_MIN_Y    24
 312 #define TSTAMP_MAX_Y    (TSTAMP_MIN_Y + 15)
 313 #define TSTAMP_INPUT_X  10
 314 #define TSTAMP_MIN_X    (54 + TSTAMP_INPUT_X)
 315
 316 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos)
 317 {
 318         u8 r_y, g_u, b_v;
 319         int color;
 320         u8 *p;
 321
 322         r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
 323         g_u = dev->bars[colorpos][1]; /* G or precalculated U */
 324         b_v = dev->bars[colorpos][2]; /* B or precalculated V */
 325
 326         for (color = 0; color < 4; color++) {
 327                 p = buf + color;
 328
 329                 switch (dev->fmt->fourcc) {
 330                 case V4L2_PIX_FMT_YUYV:
 331                         switch (color) {
 332                         case 0:
 333                         case 2:
 334                                 *p = r_y;
 335                                 break;
 336                         case 1:
 337                                 *p = g_u;
 338                                 break;
 339                         case 3:
 340                                 *p = b_v;
 341                                 break;
 342                         }
 343                         break;
 344                 case V4L2_PIX_FMT_UYVY:
 345                         switch (color) {
 346                         case 1:
 347                         case 3:
 348                                 *p = r_y;
 349                                 break;
 350                         case 0:
 351                                 *p = g_u;
 352                                 break;
 353                         case 2:
 354                                 *p = b_v;
 355                                 break;
 356                         }
 357                         break;
 358                 case V4L2_PIX_FMT_RGB565:
 359                         switch (color) {
 360                         case 0:
 361                         case 2:
 362                                 *p = (g_u << 5) | b_v;
 363                                 break;
 364                         case 1:
 365                         case 3:
 366                                 *p = (r_y << 3) | (g_u >> 3);
 367                                 break;
 368                         }
 369                         break;
 370                 case V4L2_PIX_FMT_RGB565X:
 371                         switch (color) {
 372                         case 0:
 373                         case 2:
 374                                 *p = (r_y << 3) | (g_u >> 3);
 375                                 break;
 376                         case 1:
 377                         case 3:
 378                                 *p = (g_u << 5) | b_v;
 379                                 break;
 380                         }
 381                         break;
 382                 case V4L2_PIX_FMT_RGB555:
 383                         switch (color) {
 384                         case 0:
 385                         case 2:
 386                                 *p = (g_u << 5) | b_v;
 387                                 break;
 388                         case 1:
 389                         case 3:
 390                                 *p = (r_y << 2) | (g_u >> 3);
 391                                 break;
 392                         }
 393                         break;
 394                 case V4L2_PIX_FMT_RGB555X:
 395                         switch (color) {
 396                         case 0:
 397                         case 2:
 398                                 *p = (r_y << 2) | (g_u >> 3);
 399                                 break;
 400                         case 1:
 401                         case 3:
 402                                 *p = (g_u << 5) | b_v;
 403                                 break;
 404                         }
 405                         break;
 406                 }
 407         }
 408 }
 409
 410 static void precalculate_line(struct vivi_dev *dev)
 411 {
 412         int w;
 413
 414         for (w = 0; w < dev->width * 2; w += 2) {
 415                 int colorpos = (w / (dev->width / 8) % 8);
 416
 417                 gen_twopix(dev, dev->line + w * 2, colorpos);
 418         }
 419 }
 420
 421 static void gen_text(struct vivi_dev *dev, char *basep,
 422                                         int y, int x, char *text)
 423 {
 424         int line;
 425
 426         /* Checks if it is possible to show string */
 427         if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
 428                 return;
 429
 430         /* Print stream time */
 431         for (line = y; line < y + 16; line++) {
 432                 int j = 0;
 433                 char *pos = basep + line * dev->width * 2 + x * 2;
 434                 char *s;
 435
 436                 for (s = text; *s; s++) {
 437                         u8 chr = font8x16[*s * 16 + line - y];
 438                         int i;
 439
 440                         for (i = 0; i < 7; i++, j++) {
 441                                 /* Draw white font on black background */
 442                                 if (chr & (1 << (7 - i)))
 443                                         gen_twopix(dev, pos + j * 2, WHITE);
 444                                 else
 445                                         gen_twopix(dev, pos + j * 2, TEXT_BLACK);
 446                         }
 447                 }
 448         }
 449 }
 450
 451 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
 452 {
 453         int wmax = dev->width;
 454         int hmax = dev->height;
 455         struct timeval ts;
 456         void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
 457         unsigned ms;
 458         char str[100];
 459         int h, line = 1;
 460
 461         if (!vbuf)
 462                 return;
 463
 464         for (h = 0; h < hmax; h++)
 465                 memcpy(vbuf + h * wmax * 2, dev->line + (dev->mv_count % wmax) * 2, wmax * 2);
 466
 467         /* Updates stream time */
 468
 469         dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
 470         dev->jiffies = jiffies;
 471         ms = dev->ms;
 472         snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
 473                         (ms / (60 * 60 * 1000)) % 24,
 474                         (ms / (60 * 1000)) % 60,
 475                         (ms / 1000) % 60,
 476                         ms % 1000);
 477         gen_text(dev, vbuf, line++ * 16, 16, str);
 478         snprintf(str, sizeof(str), " %dx%d, input %d ",
 479                         dev->width, dev->height, dev->input);
 480         gen_text(dev, vbuf, line++ * 16, 16, str);
 481
 482         mutex_lock(&dev->ctrl_handler.lock);
 483         snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
 484                         dev->brightness->cur.val,
 485                         dev->contrast->cur.val,
 486                         dev->saturation->cur.val,
 487                         dev->hue->cur.val);
 488         gen_text(dev, vbuf, line++ * 16, 16, str);
 489         snprintf(str, sizeof(str), " volume %3d ", dev->volume->cur.val);
 490         gen_text(dev, vbuf, line++ * 16, 16, str);
 491         snprintf(str, sizeof(str), " int32 %d, int64 %lld ",
 492                         dev->int32->cur.val,
 493                         dev->int64->cur.val64);
 494         gen_text(dev, vbuf, line++ * 16, 16, str);
 495         snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
 496                         dev->boolean->cur.val,
 497                         dev->menu->qmenu[dev->menu->cur.val],
 498                         dev->string->cur.string);
 499         mutex_unlock(&dev->ctrl_handler.lock);
 500         gen_text(dev, vbuf, line++ * 16, 16, str);
 501         if (dev->button_pressed) {
 502                 dev->button_pressed--;
 503                 snprintf(str, sizeof(str), " button pressed!");
 504                 gen_text(dev, vbuf, line++ * 16, 16, str);
 505         }
 506
 507         dev->mv_count += 2;
 508
 509         buf->vb.v4l2_buf.field = dev->field;
 510         dev->field_count++;
 511         buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
 512         do_gettimeofday(&ts);
 513         buf->vb.v4l2_buf.timestamp = ts;
 514 }
 515
 516 static void vivi_thread_tick(struct vivi_dev *dev)
 517 {
 518         struct vivi_dmaqueue *dma_q = &dev->vidq;
 519         struct vivi_buffer *buf;
 520         unsigned long flags = 0;
 521
 522         dprintk(dev, 1, "Thread tick\n");
 523
 524         spin_lock_irqsave(&dev->slock, flags);
 525         if (list_empty(&dma_q->active)) {
 526                 dprintk(dev, 1, "No active queue to serve\n");
 527                 goto unlock;
 528         }
 529
 530         buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
 531         list_del(&buf->list);
 532
 533         do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
 534
 535         /* Fill buffer */
 536         vivi_fillbuff(dev, buf);
 537         dprintk(dev, 1, "filled buffer %p\n", buf);
 538
 539         vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
 540         dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
 541 unlock:
 542         spin_unlock_irqrestore(&dev->slock, flags);
 543 }
 544
 545 #define frames_to_ms(frames)                                    \
 546         ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
 547
 548 static void vivi_sleep(struct vivi_dev *dev)
 549 {
 550         struct vivi_dmaqueue *dma_q = &dev->vidq;
 551         int timeout;
 552         DECLARE_WAITQUEUE(wait, current);
 553
 554         dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
 555                 (unsigned long)dma_q);
 556
 557         add_wait_queue(&dma_q->wq, &wait);
 558         if (kthread_should_stop())
 559                 goto stop_task;
 560
 561         /* Calculate time to wake up */
 562         timeout = msecs_to_jiffies(frames_to_ms(1));
 563
 564         vivi_thread_tick(dev);
 565
 566         schedule_timeout_interruptible(timeout);
 567
 568 stop_task:
 569         remove_wait_queue(&dma_q->wq, &wait);
 570         try_to_freeze();
 571 }
 572
 573 static int vivi_thread(void *data)
 574 {
 575         struct vivi_dev *dev = data;
 576
 577         dprintk(dev, 1, "thread started\n");
 578
 579         set_freezable();
 580
 581         for (;;) {
 582                 vivi_sleep(dev);
 583
 584                 if (kthread_should_stop())
 585                         break;
 586         }
 587         dprintk(dev, 1, "thread: exit\n");
 588         return 0;
 589 }
 590
 591 static int vivi_start_generating(struct vivi_dev *dev)
 592 {
 593         struct vivi_dmaqueue *dma_q = &dev->vidq;
 594
 595         dprintk(dev, 1, "%s\n", __func__);
 596
 597         /* Resets frame counters */
 598         dev->ms = 0;
 599         dev->mv_count = 0;
 600         dev->jiffies = jiffies;
 601
 602         dma_q->frame = 0;
 603         dma_q->ini_jiffies = jiffies;
 604         dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
 605
 606         if (IS_ERR(dma_q->kthread)) {
 607                 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
 608                 return PTR_ERR(dma_q->kthread);
 609         }
 610         /* Wakes thread */
 611         wake_up_interruptible(&dma_q->wq);
 612
 613         dprintk(dev, 1, "returning from %s\n", __func__);
 614         return 0;
 615 }
 616
 617 static void vivi_stop_generating(struct vivi_dev *dev)
 618 {
 619         struct vivi_dmaqueue *dma_q = &dev->vidq;
 620
 621         dprintk(dev, 1, "%s\n", __func__);
 622
 623         /* shutdown control thread */
 624         if (dma_q->kthread) {
 625                 kthread_stop(dma_q->kthread);
 626                 dma_q->kthread = NULL;
 627         }
 628
 629         /*
 630          * Typical driver might need to wait here until dma engine stops.
 631          * In this case we can abort imiedetly, so it's just a noop.
 632          */
 633
 634         /* Release all active buffers */
 635         while (!list_empty(&dma_q->active)) {
 636                 struct vivi_buffer *buf;
 637                 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
 638                 list_del(&buf->list);
 639                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
 640                 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
 641         }
 642 }
 643 /* ------------------------------------------------------------------
 644         Videobuf operations
 645    ------------------------------------------------------------------*/
 646 static int queue_setup(struct vb2_queue *vq, unsigned int *nbuffers,
 647                                 unsigned int *nplanes, unsigned long sizes[],
 648                                 void *alloc_ctxs[])
 649 {
 650         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 651         unsigned long size;
 652
 653         size = dev->width * dev->height * 2;
 654
 655         if (0 == *nbuffers)
 656                 *nbuffers = 32;
 657
 658         while (size * *nbuffers > vid_limit * 1024 * 1024)
 659                 (*nbuffers)--;
 660
 661         *nplanes = 1;
 662
 663         sizes[0] = size;
 664
 665         /*
 666          * videobuf2-vmalloc allocator is context-less so no need to set
 667          * alloc_ctxs array.
 668          */
 669
 670         dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
 671                 *nbuffers, size);
 672
 673         return 0;
 674 }
 675
 676 static int buffer_init(struct vb2_buffer *vb)
 677 {
 678         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 679
 680         BUG_ON(NULL == dev->fmt);
 681
 682         /*
 683          * This callback is called once per buffer, after its allocation.
 684          *
 685          * Vivi does not allow changing format during streaming, but it is
 686          * possible to do so when streaming is paused (i.e. in streamoff state).
 687          * Buffers however are not freed when going into streamoff and so
 688          * buffer size verification has to be done in buffer_prepare, on each
 689          * qbuf.
 690          * It would be best to move verification code here to buf_init and
 691          * s_fmt though.
 692          */
 693
 694         return 0;
 695 }
 696
 697 static int buffer_prepare(struct vb2_buffer *vb)
 698 {
 699         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 700         struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
 701         unsigned long size;
 702
 703         dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
 704
 705         BUG_ON(NULL == dev->fmt);
 706
 707         /*
 708          * Theses properties only change when queue is idle, see s_fmt.
 709          * The below checks should not be performed here, on each
 710          * buffer_prepare (i.e. on each qbuf). Most of the code in this function
 711          * should thus be moved to buffer_init and s_fmt.
 712          */
 713         if (dev->width  < 48 || dev->width  > MAX_WIDTH ||
 714             dev->height < 32 || dev->height > MAX_HEIGHT)
 715                 return -EINVAL;
 716
 717         size = dev->width * dev->height * 2;
 718         if (vb2_plane_size(vb, 0) < size) {
 719                 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
 720                                 __func__, vb2_plane_size(vb, 0), size);
 721                 return -EINVAL;
 722         }
 723
 724         vb2_set_plane_payload(&buf->vb, 0, size);
 725
 726         buf->fmt = dev->fmt;
 727
 728         precalculate_bars(dev);
 729         precalculate_line(dev);
 730
 731         return 0;
 732 }
 733
 734 static int buffer_finish(struct vb2_buffer *vb)
 735 {
 736         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 737         dprintk(dev, 1, "%s\n", __func__);
 738         return 0;
 739 }
 740
 741 static void buffer_cleanup(struct vb2_buffer *vb)
 742 {
 743         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 744         dprintk(dev, 1, "%s\n", __func__);
 745
 746 }
 747
 748 static void buffer_queue(struct vb2_buffer *vb)
 749 {
 750         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 751         struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
 752         struct vivi_dmaqueue *vidq = &dev->vidq;
 753         unsigned long flags = 0;
 754
 755         dprintk(dev, 1, "%s\n", __func__);
 756
 757         spin_lock_irqsave(&dev->slock, flags);
 758         list_add_tail(&buf->list, &vidq->active);
 759         spin_unlock_irqrestore(&dev->slock, flags);
 760 }
 761
 762 static int start_streaming(struct vb2_queue *vq)
 763 {
 764         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 765         dprintk(dev, 1, "%s\n", __func__);
 766         return vivi_start_generating(dev);
 767 }
 768
 769 /* abort streaming and wait for last buffer */
 770 static int stop_streaming(struct vb2_queue *vq)
 771 {
 772         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 773         dprintk(dev, 1, "%s\n", __func__);
 774         vivi_stop_generating(dev);
 775         return 0;
 776 }
 777
 778 static void vivi_lock(struct vb2_queue *vq)
 779 {
 780         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 781         mutex_lock(&dev->mutex);
 782 }
 783
 784 static void vivi_unlock(struct vb2_queue *vq)
 785 {
 786         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 787         mutex_unlock(&dev->mutex);
 788 }
 789
 790
 791 static struct vb2_ops vivi_video_qops = {
 792         .queue_setup            = queue_setup,
 793         .buf_init               = buffer_init,
 794         .buf_prepare            = buffer_prepare,
 795         .buf_finish             = buffer_finish,
 796         .buf_cleanup            = buffer_cleanup,
 797         .buf_queue              = buffer_queue,
 798         .start_streaming        = start_streaming,
 799         .stop_streaming         = stop_streaming,
 800         .wait_prepare           = vivi_unlock,
 801         .wait_finish            = vivi_lock,
 802 };
 803
 804 /* ------------------------------------------------------------------
 805         IOCTL vidioc handling
 806    ------------------------------------------------------------------*/
 807 static int vidioc_querycap(struct file *file, void  *priv,
 808                                         struct v4l2_capability *cap)
 809 {
 810         struct vivi_dev *dev = video_drvdata(file);
 811
 812         strcpy(cap->driver, "vivi");
 813         strcpy(cap->card, "vivi");
 814         strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
 815         cap->version = VIVI_VERSION;
 816         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | \
 817                             V4L2_CAP_READWRITE;
 818         return 0;
 819 }
 820
 821 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
 822                                         struct v4l2_fmtdesc *f)
 823 {
 824         struct vivi_fmt *fmt;
 825
 826         if (f->index >= ARRAY_SIZE(formats))
 827                 return -EINVAL;
 828
 829         fmt = &formats[f->index];
 830
 831         strlcpy(f->description, fmt->name, sizeof(f->description));
 832         f->pixelformat = fmt->fourcc;
 833         return 0;
 834 }
 835
 836 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 837                                         struct v4l2_format *f)
 838 {
 839         struct vivi_dev *dev = video_drvdata(file);
 840
 841         f->fmt.pix.width        = dev->width;
 842         f->fmt.pix.height       = dev->height;
 843         f->fmt.pix.field        = dev->field;
 844         f->fmt.pix.pixelformat  = dev->fmt->fourcc;
 845         f->fmt.pix.bytesperline =
 846                 (f->fmt.pix.width * dev->fmt->depth) >> 3;
 847         f->fmt.pix.sizeimage =
 848                 f->fmt.pix.height * f->fmt.pix.bytesperline;
 849         return 0;
 850 }
 851
 852 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 853                         struct v4l2_format *f)
 854 {
 855         struct vivi_dev *dev = video_drvdata(file);
 856         struct vivi_fmt *fmt;
 857         enum v4l2_field field;
 858
 859         fmt = get_format(f);
 860         if (!fmt) {
 861                 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
 862                         f->fmt.pix.pixelformat);
 863                 return -EINVAL;
 864         }
 865
 866         field = f->fmt.pix.field;
 867
 868         if (field == V4L2_FIELD_ANY) {
 869                 field = V4L2_FIELD_INTERLACED;
 870         } else if (V4L2_FIELD_INTERLACED != field) {
 871                 dprintk(dev, 1, "Field type invalid.\n");
 872                 return -EINVAL;
 873         }
 874
 875         f->fmt.pix.field = field;
 876         v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
 877                               &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
 878         f->fmt.pix.bytesperline =
 879                 (f->fmt.pix.width * fmt->depth) >> 3;
 880         f->fmt.pix.sizeimage =
 881                 f->fmt.pix.height * f->fmt.pix.bytesperline;
 882         return 0;
 883 }
 884
 885 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 886                                         struct v4l2_format *f)
 887 {
 888         struct vivi_dev *dev = video_drvdata(file);
 889         struct vb2_queue *q = &dev->vb_vidq;
 890
 891         int ret = vidioc_try_fmt_vid_cap(file, priv, f);
 892         if (ret < 0)
 893                 return ret;
 894
 895         if (vb2_is_streaming(q)) {
 896                 dprintk(dev, 1, "%s device busy\n", __func__);
 897                 return -EBUSY;
 898         }
 899
 900         dev->fmt = get_format(f);
 901         dev->width = f->fmt.pix.width;
 902         dev->height = f->fmt.pix.height;
 903         dev->field = f->fmt.pix.field;
 904
 905         return 0;
 906 }
 907
 908 static int vidioc_reqbufs(struct file *file, void *priv,
 909                           struct v4l2_requestbuffers *p)
 910 {
 911         struct vivi_dev *dev = video_drvdata(file);
 912         return vb2_reqbufs(&dev->vb_vidq, p);
 913 }
 914
 915 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
 916 {
 917         struct vivi_dev *dev = video_drvdata(file);
 918         return vb2_querybuf(&dev->vb_vidq, p);
 919 }
 920
 921 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
 922 {
 923         struct vivi_dev *dev = video_drvdata(file);
 924         return vb2_qbuf(&dev->vb_vidq, p);
 925 }
 926
 927 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
 928 {
 929         struct vivi_dev *dev = video_drvdata(file);
 930         return vb2_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK);
 931 }
 932
 933 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
 934 {
 935         struct vivi_dev *dev = video_drvdata(file);
 936         return vb2_streamon(&dev->vb_vidq, i);
 937 }
 938
 939 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
 940 {
 941         struct vivi_dev *dev = video_drvdata(file);
 942         return vb2_streamoff(&dev->vb_vidq, i);
 943 }
 944
 945 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
 946 {
 947         return 0;
 948 }
 949
 950 /* only one input in this sample driver */
 951 static int vidioc_enum_input(struct file *file, void *priv,
 952                                 struct v4l2_input *inp)
 953 {
 954         if (inp->index >= NUM_INPUTS)
 955                 return -EINVAL;
 956
 957         inp->type = V4L2_INPUT_TYPE_CAMERA;
 958         inp->std = V4L2_STD_525_60;
 959         sprintf(inp->name, "Camera %u", inp->index);
 960         return 0;
 961 }
 962
 963 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 964 {
 965         struct vivi_dev *dev = video_drvdata(file);
 966
 967         *i = dev->input;
 968         return 0;
 969 }
 970
 971 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 972 {
 973         struct vivi_dev *dev = video_drvdata(file);
 974
 975         if (i >= NUM_INPUTS)
 976                 return -EINVAL;
 977
 978         dev->input = i;
 979         precalculate_bars(dev);
 980         precalculate_line(dev);
 981         return 0;
 982 }
 983
 984 /* --- controls ---------------------------------------------- */
 985
 986 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
 987 {
 988         struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
 989
 990         if (ctrl == dev->button)
 991                 dev->button_pressed = 30;
 992         return 0;
 993 }
 994
 995 /* ------------------------------------------------------------------
 996         File operations for the device
 997    ------------------------------------------------------------------*/
 998
 999 static int vivi_open(struct file *file)
1000 {
1001         struct vivi_dev *dev = video_drvdata(file);
1002
1003         dprintk(dev, 1, "%s, %p\n", __func__, file);
1004         dev->open_count++;
1005         return 0;
1006 }
1007
1008 static ssize_t
1009 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1010 {
1011         struct vivi_dev *dev = video_drvdata(file);
1012
1013         dprintk(dev, 1, "read called\n");
1014         return vb2_read(&dev->vb_vidq, data, count, ppos,
1015                        file->f_flags & O_NONBLOCK);
1016 }
1017
1018 static unsigned int
1019 vivi_poll(struct file *file, struct poll_table_struct *wait)
1020 {
1021         struct vivi_dev *dev = video_drvdata(file);
1022         struct vb2_queue *q = &dev->vb_vidq;
1023
1024         dprintk(dev, 1, "%s\n", __func__);
1025         return vb2_poll(q, file, wait);
1026 }
1027
1028 static int vivi_close(struct file *file)
1029 {
1030         struct video_device  *vdev = video_devdata(file);
1031         struct vivi_dev *dev = video_drvdata(file);
1032
1033         dprintk(dev, 1, "close called (dev=%s), file %p\n",
1034                 video_device_node_name(vdev), file);
1035
1036         if (--dev->open_count == 0)
1037                 vb2_queue_release(&dev->vb_vidq);
1038         return 0;
1039 }
1040
1041 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1042 {
1043         struct vivi_dev *dev = video_drvdata(file);
1044         int ret;
1045
1046         dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1047
1048         ret = vb2_mmap(&dev->vb_vidq, vma);
1049         dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1050                 (unsigned long)vma->vm_start,
1051                 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
1052                 ret);
1053         return ret;
1054 }
1055
1056 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1057         .s_ctrl = vivi_s_ctrl,
1058 };
1059
1060 #define VIVI_CID_CUSTOM_BASE    (V4L2_CID_USER_BASE | 0xf000)
1061
1062 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1063         .ops = &vivi_ctrl_ops,
1064         .id = VIVI_CID_CUSTOM_BASE + 0,
1065         .name = "Button",
1066         .type = V4L2_CTRL_TYPE_BUTTON,
1067 };
1068
1069 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1070         .ops = &vivi_ctrl_ops,
1071         .id = VIVI_CID_CUSTOM_BASE + 1,
1072         .name = "Boolean",
1073         .type = V4L2_CTRL_TYPE_BOOLEAN,
1074         .min = 0,
1075         .max = 1,
1076         .step = 1,
1077         .def = 1,
1078 };
1079
1080 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1081         .ops = &vivi_ctrl_ops,
1082         .id = VIVI_CID_CUSTOM_BASE + 2,
1083         .name = "Integer 32 Bits",
1084         .type = V4L2_CTRL_TYPE_INTEGER,
1085         .min = -2147483648,
1086         .max = 2147483647,
1087         .step = 1,
1088 };
1089
1090 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1091         .ops = &vivi_ctrl_ops,
1092         .id = VIVI_CID_CUSTOM_BASE + 3,
1093         .name = "Integer 64 Bits",
1094         .type = V4L2_CTRL_TYPE_INTEGER64,
1095 };
1096
1097 static const char * const vivi_ctrl_menu_strings[] = {
1098         "Menu Item 0 (Skipped)",
1099         "Menu Item 1",
1100         "Menu Item 2 (Skipped)",
1101         "Menu Item 3",
1102         "Menu Item 4",
1103         "Menu Item 5 (Skipped)",
1104         NULL,
1105 };
1106
1107 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1108         .ops = &vivi_ctrl_ops,
1109         .id = VIVI_CID_CUSTOM_BASE + 4,
1110         .name = "Menu",
1111         .type = V4L2_CTRL_TYPE_MENU,
1112         .min = 1,
1113         .max = 4,
1114         .def = 3,
1115         .menu_skip_mask = 0x04,
1116         .qmenu = vivi_ctrl_menu_strings,
1117 };
1118
1119 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1120         .ops = &vivi_ctrl_ops,
1121         .id = VIVI_CID_CUSTOM_BASE + 5,
1122         .name = "String",
1123         .type = V4L2_CTRL_TYPE_STRING,
1124         .min = 2,
1125         .max = 4,
1126         .step = 1,
1127 };
1128
1129 static const struct v4l2_file_operations vivi_fops = {
1130         .owner          = THIS_MODULE,
1131         .open           = vivi_open,
1132         .release        = vivi_close,
1133         .read           = vivi_read,
1134         .poll           = vivi_poll,
1135         .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1136         .mmap           = vivi_mmap,
1137 };
1138
1139 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1140         .vidioc_querycap      = vidioc_querycap,
1141         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1142         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1143         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1144         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1145         .vidioc_reqbufs       = vidioc_reqbufs,
1146         .vidioc_querybuf      = vidioc_querybuf,
1147         .vidioc_qbuf          = vidioc_qbuf,
1148         .vidioc_dqbuf         = vidioc_dqbuf,
1149         .vidioc_s_std         = vidioc_s_std,
1150         .vidioc_enum_input    = vidioc_enum_input,
1151         .vidioc_g_input       = vidioc_g_input,
1152         .vidioc_s_input       = vidioc_s_input,
1153         .vidioc_streamon      = vidioc_streamon,
1154         .vidioc_streamoff     = vidioc_streamoff,
1155 };
1156
1157 static struct video_device vivi_template = {
1158         .name           = "vivi",
1159         .fops           = &vivi_fops,
1160         .ioctl_ops      = &vivi_ioctl_ops,
1161         .release        = video_device_release,
1162
1163         .tvnorms              = V4L2_STD_525_60,
1164         .current_norm         = V4L2_STD_NTSC_M,
1165 };
1166
1167 /* -----------------------------------------------------------------
1168         Initialization and module stuff
1169    ------------------------------------------------------------------*/
1170
1171 static int vivi_release(void)
1172 {
1173         struct vivi_dev *dev;
1174         struct list_head *list;
1175
1176         while (!list_empty(&vivi_devlist)) {
1177                 list = vivi_devlist.next;
1178                 list_del(list);
1179                 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1180
1181                 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1182                         video_device_node_name(dev->vfd));
1183                 video_unregister_device(dev->vfd);
1184                 v4l2_device_unregister(&dev->v4l2_dev);
1185                 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1186                 kfree(dev);
1187         }
1188
1189         return 0;
1190 }
1191
1192 static int __init vivi_create_instance(int inst)
1193 {
1194         struct vivi_dev *dev;
1195         struct video_device *vfd;
1196         struct v4l2_ctrl_handler *hdl;
1197         struct vb2_queue *q;
1198         int ret;
1199
1200         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1201         if (!dev)
1202                 return -ENOMEM;
1203
1204         snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1205                         "%s-%03d", VIVI_MODULE_NAME, inst);
1206         ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1207         if (ret)
1208                 goto free_dev;
1209
1210         dev->fmt = &formats[0];
1211         dev->width = 640;
1212         dev->height = 480;
1213         hdl = &dev->ctrl_handler;
1214         v4l2_ctrl_handler_init(hdl, 11);
1215         dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1216                         V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1217         dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1218                         V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1219         dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1220                         V4L2_CID_CONTRAST, 0, 255, 1, 16);
1221         dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1222                         V4L2_CID_SATURATION, 0, 255, 1, 127);
1223         dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1224                         V4L2_CID_HUE, -128, 127, 1, 0);
1225         dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1226         dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1227         dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1228         dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1229         dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1230         dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1231         if (hdl->error) {
1232                 ret = hdl->error;
1233                 goto unreg_dev;
1234         }
1235         dev->v4l2_dev.ctrl_handler = hdl;
1236
1237         /* initialize locks */
1238         spin_lock_init(&dev->slock);
1239
1240         /* initialize queue */
1241         q = &dev->vb_vidq;
1242         memset(q, 0, sizeof(dev->vb_vidq));
1243         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1244         q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1245         q->drv_priv = dev;
1246         q->buf_struct_size = sizeof(struct vivi_buffer);
1247         q->ops = &vivi_video_qops;
1248         q->mem_ops = &vb2_vmalloc_memops;
1249
1250         vb2_queue_init(q);
1251
1252         mutex_init(&dev->mutex);
1253
1254         /* init video dma queues */
1255         INIT_LIST_HEAD(&dev->vidq.active);
1256         init_waitqueue_head(&dev->vidq.wq);
1257
1258         ret = -ENOMEM;
1259         vfd = video_device_alloc();
1260         if (!vfd)
1261                 goto unreg_dev;
1262
1263         *vfd = vivi_template;
1264         vfd->debug = debug;
1265         vfd->v4l2_dev = &dev->v4l2_dev;
1266
1267         /*
1268          * Provide a mutex to v4l2 core. It will be used to protect
1269          * all fops and v4l2 ioctls.
1270          */
1271         vfd->lock = &dev->mutex;
1272
1273         ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1274         if (ret < 0)
1275                 goto rel_vdev;
1276
1277         video_set_drvdata(vfd, dev);
1278
1279         /* Now that everything is fine, let's add it to device list */
1280         list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1281
1282         if (video_nr != -1)
1283                 video_nr++;
1284
1285         dev->vfd = vfd;
1286         v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1287                   video_device_node_name(vfd));
1288         return 0;
1289
1290 rel_vdev:
1291         video_device_release(vfd);
1292 unreg_dev:
1293         v4l2_ctrl_handler_free(hdl);
1294         v4l2_device_unregister(&dev->v4l2_dev);
1295 free_dev:
1296         kfree(dev);
1297         return ret;
1298 }
1299
1300 /* This routine allocates from 1 to n_devs virtual drivers.
1301
1302    The real maximum number of virtual drivers will depend on how many drivers
1303    will succeed. This is limited to the maximum number of devices that
1304    videodev supports, which is equal to VIDEO_NUM_DEVICES.
1305  */
1306 static int __init vivi_init(void)
1307 {
1308         const struct font_desc *font = find_font("VGA8x16");
1309         int ret = 0, i;
1310
1311         if (font == NULL) {
1312                 printk(KERN_ERR "vivi: could not find font\n");
1313                 return -ENODEV;
1314         }
1315         font8x16 = font->data;
1316
1317         if (n_devs <= 0)
1318                 n_devs = 1;
1319
1320         for (i = 0; i < n_devs; i++) {
1321                 ret = vivi_create_instance(i);
1322                 if (ret) {
1323                         /* If some instantiations succeeded, keep driver */
1324                         if (i)
1325                                 ret = 0;
1326                         break;
1327                 }
1328         }
1329
1330         if (ret < 0) {
1331                 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1332                 return ret;
1333         }
1334
1335         printk(KERN_INFO "Video Technology Magazine Virtual Video "
1336                         "Capture Board ver %u.%u.%u successfully loaded.\n",
1337                         (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1338                         VIVI_VERSION & 0xFF);
1339
1340         /* n_devs will reflect the actual number of allocated devices */
1341         n_devs = i;
1342
1343         return ret;
1344 }
1345
1346 static void __exit vivi_exit(void)
1347 {
1348         vivi_release();
1349 }
1350
1351 module_init(vivi_init);
1352 module_exit(vivi_exit);