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