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