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