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