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-fh.h>
  35 #include <media/v4l2-common.h>
  36
  37 #define VIVI_MODULE_NAME "vivi"
  38
  39 /* Wake up at about 30 fps */
  40 #define WAKE_NUMERATOR 30
  41 #define WAKE_DENOMINATOR 1001
  42 #define BUFFER_TIMEOUT     msecs_to_jiffies(500)  /* 0.5 seconds */
  43
  44 #define MAX_WIDTH 1920
  45 #define MAX_HEIGHT 1200
  46
  47 #define VIVI_MAJOR_VERSION 0
  48 #define VIVI_MINOR_VERSION 8
  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 /* Global font descriptor */
  74 static const u8 *font8x16;
  75
  76 #define dprintk(dev, level, fmt, arg...) \
  77         v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
  78
  79 /* ------------------------------------------------------------------
  80         Basic structures
  81    ------------------------------------------------------------------*/
  82
  83 struct vivi_fmt {
  84         char  *name;
  85         u32   fourcc;          /* v4l2 format id */
  86         int   depth;
  87 };
  88
  89 static struct vivi_fmt formats[] = {
  90         {
  91                 .name     = "4:2:2, packed, YUYV",
  92                 .fourcc   = V4L2_PIX_FMT_YUYV,
  93                 .depth    = 16,
  94         },
  95         {
  96                 .name     = "4:2:2, packed, UYVY",
  97                 .fourcc   = V4L2_PIX_FMT_UYVY,
  98                 .depth    = 16,
  99         },
 100         {
 101                 .name     = "RGB565 (LE)",
 102                 .fourcc   = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
 103                 .depth    = 16,
 104         },
 105         {
 106                 .name     = "RGB565 (BE)",
 107                 .fourcc   = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
 108                 .depth    = 16,
 109         },
 110         {
 111                 .name     = "RGB555 (LE)",
 112                 .fourcc   = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
 113                 .depth    = 16,
 114         },
 115         {
 116                 .name     = "RGB555 (BE)",
 117                 .fourcc   = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
 118                 .depth    = 16,
 119         },
 120 };
 121
 122 static struct vivi_fmt *get_format(struct v4l2_format *f)
 123 {
 124         struct vivi_fmt *fmt;
 125         unsigned int k;
 126
 127         for (k = 0; k < ARRAY_SIZE(formats); k++) {
 128                 fmt = &formats[k];
 129                 if (fmt->fourcc == f->fmt.pix.pixelformat)
 130                         break;
 131         }
 132
 133         if (k == ARRAY_SIZE(formats))
 134                 return NULL;
 135
 136         return &formats[k];
 137 }
 138
 139 /* buffer for one video frame */
 140 struct vivi_buffer {
 141         /* common v4l buffer stuff -- must be first */
 142         struct vb2_buffer       vb;
 143         struct list_head        list;
 144         struct vivi_fmt        *fmt;
 145 };
 146
 147 struct vivi_dmaqueue {
 148         struct list_head       active;
 149
 150         /* thread for generating video stream*/
 151         struct task_struct         *kthread;
 152         wait_queue_head_t          wq;
 153         /* Counters to control fps rate */
 154         int                        frame;
 155         int                        ini_jiffies;
 156 };
 157
 158 static LIST_HEAD(vivi_devlist);
 159
 160 struct vivi_dev {
 161         struct list_head           vivi_devlist;
 162         struct v4l2_device         v4l2_dev;
 163         struct v4l2_ctrl_handler   ctrl_handler;
 164
 165         /* controls */
 166         struct v4l2_ctrl           *brightness;
 167         struct v4l2_ctrl           *contrast;
 168         struct v4l2_ctrl           *saturation;
 169         struct v4l2_ctrl           *hue;
 170         struct v4l2_ctrl           *volume;
 171         struct v4l2_ctrl           *button;
 172         struct v4l2_ctrl           *boolean;
 173         struct v4l2_ctrl           *int32;
 174         struct v4l2_ctrl           *int64;
 175         struct v4l2_ctrl           *menu;
 176         struct v4l2_ctrl           *string;
 177
 178         spinlock_t                 slock;
 179         struct mutex               mutex;
 180
 181         /* various device info */
 182         struct video_device        *vfd;
 183
 184         struct vivi_dmaqueue       vidq;
 185
 186         /* Several counters */
 187         unsigned                   ms;
 188         unsigned long              jiffies;
 189         unsigned                   button_pressed;
 190
 191         int                        mv_count;    /* Controls bars movement */
 192
 193         /* Input Number */
 194         int                        input;
 195
 196         /* video capture */
 197         struct vivi_fmt            *fmt;
 198         unsigned int               width, height;
 199         struct vb2_queue           vb_vidq;
 200         enum v4l2_field            field;
 201         unsigned int               field_count;
 202
 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 ssize_t
1000 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1001 {
1002         struct vivi_dev *dev = video_drvdata(file);
1003
1004         dprintk(dev, 1, "read called\n");
1005         return vb2_read(&dev->vb_vidq, data, count, ppos,
1006                        file->f_flags & O_NONBLOCK);
1007 }
1008
1009 static unsigned int
1010 vivi_poll(struct file *file, struct poll_table_struct *wait)
1011 {
1012         struct vivi_dev *dev = video_drvdata(file);
1013         struct vb2_queue *q = &dev->vb_vidq;
1014
1015         dprintk(dev, 1, "%s\n", __func__);
1016         return vb2_poll(q, file, wait);
1017 }
1018
1019 static int vivi_close(struct file *file)
1020 {
1021         struct video_device  *vdev = video_devdata(file);
1022         struct vivi_dev *dev = video_drvdata(file);
1023
1024         dprintk(dev, 1, "close called (dev=%s), file %p\n",
1025                 video_device_node_name(vdev), file);
1026
1027         if (v4l2_fh_is_singular_file(file))
1028                 vb2_queue_release(&dev->vb_vidq);
1029         return v4l2_fh_release(file);
1030 }
1031
1032 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1033 {
1034         struct vivi_dev *dev = video_drvdata(file);
1035         int ret;
1036
1037         dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1038
1039         ret = vb2_mmap(&dev->vb_vidq, vma);
1040         dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1041                 (unsigned long)vma->vm_start,
1042                 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
1043                 ret);
1044         return ret;
1045 }
1046
1047 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1048         .s_ctrl = vivi_s_ctrl,
1049 };
1050
1051 #define VIVI_CID_CUSTOM_BASE    (V4L2_CID_USER_BASE | 0xf000)
1052
1053 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1054         .ops = &vivi_ctrl_ops,
1055         .id = VIVI_CID_CUSTOM_BASE + 0,
1056         .name = "Button",
1057         .type = V4L2_CTRL_TYPE_BUTTON,
1058 };
1059
1060 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1061         .ops = &vivi_ctrl_ops,
1062         .id = VIVI_CID_CUSTOM_BASE + 1,
1063         .name = "Boolean",
1064         .type = V4L2_CTRL_TYPE_BOOLEAN,
1065         .min = 0,
1066         .max = 1,
1067         .step = 1,
1068         .def = 1,
1069 };
1070
1071 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1072         .ops = &vivi_ctrl_ops,
1073         .id = VIVI_CID_CUSTOM_BASE + 2,
1074         .name = "Integer 32 Bits",
1075         .type = V4L2_CTRL_TYPE_INTEGER,
1076         .min = 0x80000000,
1077         .max = 0x7fffffff,
1078         .step = 1,
1079 };
1080
1081 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1082         .ops = &vivi_ctrl_ops,
1083         .id = VIVI_CID_CUSTOM_BASE + 3,
1084         .name = "Integer 64 Bits",
1085         .type = V4L2_CTRL_TYPE_INTEGER64,
1086 };
1087
1088 static const char * const vivi_ctrl_menu_strings[] = {
1089         "Menu Item 0 (Skipped)",
1090         "Menu Item 1",
1091         "Menu Item 2 (Skipped)",
1092         "Menu Item 3",
1093         "Menu Item 4",
1094         "Menu Item 5 (Skipped)",
1095         NULL,
1096 };
1097
1098 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1099         .ops = &vivi_ctrl_ops,
1100         .id = VIVI_CID_CUSTOM_BASE + 4,
1101         .name = "Menu",
1102         .type = V4L2_CTRL_TYPE_MENU,
1103         .min = 1,
1104         .max = 4,
1105         .def = 3,
1106         .menu_skip_mask = 0x04,
1107         .qmenu = vivi_ctrl_menu_strings,
1108 };
1109
1110 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1111         .ops = &vivi_ctrl_ops,
1112         .id = VIVI_CID_CUSTOM_BASE + 5,
1113         .name = "String",
1114         .type = V4L2_CTRL_TYPE_STRING,
1115         .min = 2,
1116         .max = 4,
1117         .step = 1,
1118 };
1119
1120 static const struct v4l2_file_operations vivi_fops = {
1121         .owner          = THIS_MODULE,
1122         .open           = v4l2_fh_open,
1123         .release        = vivi_close,
1124         .read           = vivi_read,
1125         .poll           = vivi_poll,
1126         .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1127         .mmap           = vivi_mmap,
1128 };
1129
1130 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1131         .vidioc_querycap      = vidioc_querycap,
1132         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1133         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1134         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1135         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1136         .vidioc_reqbufs       = vidioc_reqbufs,
1137         .vidioc_querybuf      = vidioc_querybuf,
1138         .vidioc_qbuf          = vidioc_qbuf,
1139         .vidioc_dqbuf         = vidioc_dqbuf,
1140         .vidioc_s_std         = vidioc_s_std,
1141         .vidioc_enum_input    = vidioc_enum_input,
1142         .vidioc_g_input       = vidioc_g_input,
1143         .vidioc_s_input       = vidioc_s_input,
1144         .vidioc_streamon      = vidioc_streamon,
1145         .vidioc_streamoff     = vidioc_streamoff,
1146 };
1147
1148 static struct video_device vivi_template = {
1149         .name           = "vivi",
1150         .fops           = &vivi_fops,
1151         .ioctl_ops      = &vivi_ioctl_ops,
1152         .release        = video_device_release,
1153
1154         .tvnorms              = V4L2_STD_525_60,
1155         .current_norm         = V4L2_STD_NTSC_M,
1156 };
1157
1158 /* -----------------------------------------------------------------
1159         Initialization and module stuff
1160    ------------------------------------------------------------------*/
1161
1162 static int vivi_release(void)
1163 {
1164         struct vivi_dev *dev;
1165         struct list_head *list;
1166
1167         while (!list_empty(&vivi_devlist)) {
1168                 list = vivi_devlist.next;
1169                 list_del(list);
1170                 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1171
1172                 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1173                         video_device_node_name(dev->vfd));
1174                 video_unregister_device(dev->vfd);
1175                 v4l2_device_unregister(&dev->v4l2_dev);
1176                 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1177                 kfree(dev);
1178         }
1179
1180         return 0;
1181 }
1182
1183 static int __init vivi_create_instance(int inst)
1184 {
1185         struct vivi_dev *dev;
1186         struct video_device *vfd;
1187         struct v4l2_ctrl_handler *hdl;
1188         struct vb2_queue *q;
1189         int ret;
1190
1191         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1192         if (!dev)
1193                 return -ENOMEM;
1194
1195         snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1196                         "%s-%03d", VIVI_MODULE_NAME, inst);
1197         ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1198         if (ret)
1199                 goto free_dev;
1200
1201         dev->fmt = &formats[0];
1202         dev->width = 640;
1203         dev->height = 480;
1204         hdl = &dev->ctrl_handler;
1205         v4l2_ctrl_handler_init(hdl, 11);
1206         dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1207                         V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1208         dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1209                         V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1210         dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1211                         V4L2_CID_CONTRAST, 0, 255, 1, 16);
1212         dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1213                         V4L2_CID_SATURATION, 0, 255, 1, 127);
1214         dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1215                         V4L2_CID_HUE, -128, 127, 1, 0);
1216         dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1217         dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1218         dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1219         dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1220         dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1221         dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1222         if (hdl->error) {
1223                 ret = hdl->error;
1224                 goto unreg_dev;
1225         }
1226         dev->v4l2_dev.ctrl_handler = hdl;
1227
1228         /* initialize locks */
1229         spin_lock_init(&dev->slock);
1230
1231         /* initialize queue */
1232         q = &dev->vb_vidq;
1233         memset(q, 0, sizeof(dev->vb_vidq));
1234         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1235         q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1236         q->drv_priv = dev;
1237         q->buf_struct_size = sizeof(struct vivi_buffer);
1238         q->ops = &vivi_video_qops;
1239         q->mem_ops = &vb2_vmalloc_memops;
1240
1241         vb2_queue_init(q);
1242
1243         mutex_init(&dev->mutex);
1244
1245         /* init video dma queues */
1246         INIT_LIST_HEAD(&dev->vidq.active);
1247         init_waitqueue_head(&dev->vidq.wq);
1248
1249         ret = -ENOMEM;
1250         vfd = video_device_alloc();
1251         if (!vfd)
1252                 goto unreg_dev;
1253
1254         *vfd = vivi_template;
1255         vfd->debug = debug;
1256         vfd->v4l2_dev = &dev->v4l2_dev;
1257         set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1258
1259         /*
1260          * Provide a mutex to v4l2 core. It will be used to protect
1261          * all fops and v4l2 ioctls.
1262          */
1263         vfd->lock = &dev->mutex;
1264
1265         ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1266         if (ret < 0)
1267                 goto rel_vdev;
1268
1269         video_set_drvdata(vfd, dev);
1270
1271         /* Now that everything is fine, let's add it to device list */
1272         list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1273
1274         if (video_nr != -1)
1275                 video_nr++;
1276
1277         dev->vfd = vfd;
1278         v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1279                   video_device_node_name(vfd));
1280         return 0;
1281
1282 rel_vdev:
1283         video_device_release(vfd);
1284 unreg_dev:
1285         v4l2_ctrl_handler_free(hdl);
1286         v4l2_device_unregister(&dev->v4l2_dev);
1287 free_dev:
1288         kfree(dev);
1289         return ret;
1290 }
1291
1292 /* This routine allocates from 1 to n_devs virtual drivers.
1293
1294    The real maximum number of virtual drivers will depend on how many drivers
1295    will succeed. This is limited to the maximum number of devices that
1296    videodev supports, which is equal to VIDEO_NUM_DEVICES.
1297  */
1298 static int __init vivi_init(void)
1299 {
1300         const struct font_desc *font = find_font("VGA8x16");
1301         int ret = 0, i;
1302
1303         if (font == NULL) {
1304                 printk(KERN_ERR "vivi: could not find font\n");
1305                 return -ENODEV;
1306         }
1307         font8x16 = font->data;
1308
1309         if (n_devs <= 0)
1310                 n_devs = 1;
1311
1312         for (i = 0; i < n_devs; i++) {
1313                 ret = vivi_create_instance(i);
1314                 if (ret) {
1315                         /* If some instantiations succeeded, keep driver */
1316                         if (i)
1317                                 ret = 0;
1318                         break;
1319                 }
1320         }
1321
1322         if (ret < 0) {
1323                 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1324                 return ret;
1325         }
1326
1327         printk(KERN_INFO "Video Technology Magazine Virtual Video "
1328                         "Capture Board ver %u.%u.%u successfully loaded.\n",
1329                         (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1330                         VIVI_VERSION & 0xFF);
1331
1332         /* n_devs will reflect the actual number of allocated devices */
1333         n_devs = i;
1334
1335         return ret;
1336 }
1337
1338 static void __exit vivi_exit(void)
1339 {
1340         vivi_release();
1341 }
1342
1343 module_init(vivi_init);
1344 module_exit(vivi_exit);