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
 192         /* controls */
 193         struct v4l2_ctrl           *brightness;
 194         struct v4l2_ctrl           *contrast;
 195         struct v4l2_ctrl           *saturation;
 196         struct v4l2_ctrl           *hue;
 197         struct {
 198                 /* autogain/gain cluster */
 199                 struct v4l2_ctrl           *autogain;
 200                 struct v4l2_ctrl           *gain;
 201         };
 202         struct v4l2_ctrl           *volume;
 203         struct v4l2_ctrl           *alpha;
 204         struct v4l2_ctrl           *button;
 205         struct v4l2_ctrl           *boolean;
 206         struct v4l2_ctrl           *int32;
 207         struct v4l2_ctrl           *int64;
 208         struct v4l2_ctrl           *menu;
 209         struct v4l2_ctrl           *string;
 210         struct v4l2_ctrl           *bitmask;
 211         struct v4l2_ctrl           *int_menu;
 212
 213         spinlock_t                 slock;
 214         struct mutex               mutex;
 215
 216         /* various device info */
 217         struct video_device        *vfd;
 218
 219         struct vivi_dmaqueue       vidq;
 220
 221         /* Several counters */
 222         unsigned                   ms;
 223         unsigned long              jiffies;
 224         unsigned                   button_pressed;
 225
 226         int                        mv_count;    /* Controls bars movement */
 227
 228         /* Input Number */
 229         int                        input;
 230
 231         /* video capture */
 232         struct vivi_fmt            *fmt;
 233         unsigned int               width, height;
 234         struct vb2_queue           vb_vidq;
 235         enum v4l2_field            field;
 236         unsigned int               field_count;
 237
 238         u8                         bars[9][3];
 239         u8                         line[MAX_WIDTH * 8];
 240         unsigned int               pixelsize;
 241         u8                         alpha_component;
 242 };
 243
 244 /* ------------------------------------------------------------------
 245         DMA and thread functions
 246    ------------------------------------------------------------------*/
 247
 248 /* Bars and Colors should match positions */
 249
 250 enum colors {
 251         WHITE,
 252         AMBER,
 253         CYAN,
 254         GREEN,
 255         MAGENTA,
 256         RED,
 257         BLUE,
 258         BLACK,
 259         TEXT_BLACK,
 260 };
 261
 262 /* R   G   B */
 263 #define COLOR_WHITE     {204, 204, 204}
 264 #define COLOR_AMBER     {208, 208,   0}
 265 #define COLOR_CYAN      {  0, 206, 206}
 266 #define COLOR_GREEN     {  0, 239,   0}
 267 #define COLOR_MAGENTA   {239,   0, 239}
 268 #define COLOR_RED       {205,   0,   0}
 269 #define COLOR_BLUE      {  0,   0, 255}
 270 #define COLOR_BLACK     {  0,   0,   0}
 271
 272 struct bar_std {
 273         u8 bar[9][3];
 274 };
 275
 276 /* Maximum number of bars are 10 - otherwise, the input print code
 277    should be modified */
 278 static struct bar_std bars[] = {
 279         {       /* Standard ITU-R color bar sequence */
 280                 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
 281                   COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
 282         }, {
 283                 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
 284                   COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
 285         }, {
 286                 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
 287                   COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
 288         }, {
 289                 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
 290                   COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
 291         },
 292 };
 293
 294 #define NUM_INPUTS ARRAY_SIZE(bars)
 295
 296 #define TO_Y(r, g, b) \
 297         (((16829 * r + 33039 * g + 6416 * b  + 32768) >> 16) + 16)
 298 /* RGB to  V(Cr) Color transform */
 299 #define TO_V(r, g, b) \
 300         (((28784 * r - 24103 * g - 4681 * b  + 32768) >> 16) + 128)
 301 /* RGB to  U(Cb) Color transform */
 302 #define TO_U(r, g, b) \
 303         (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
 304
 305 /* precalculate color bar values to speed up rendering */
 306 static void precalculate_bars(struct vivi_dev *dev)
 307 {
 308         u8 r, g, b;
 309         int k, is_yuv;
 310
 311         for (k = 0; k < 9; k++) {
 312                 r = bars[dev->input].bar[k][0];
 313                 g = bars[dev->input].bar[k][1];
 314                 b = bars[dev->input].bar[k][2];
 315                 is_yuv = 0;
 316
 317                 switch (dev->fmt->fourcc) {
 318                 case V4L2_PIX_FMT_YUYV:
 319                 case V4L2_PIX_FMT_UYVY:
 320                 case V4L2_PIX_FMT_YVYU:
 321                 case V4L2_PIX_FMT_VYUY:
 322                         is_yuv = 1;
 323                         break;
 324                 case V4L2_PIX_FMT_RGB565:
 325                 case V4L2_PIX_FMT_RGB565X:
 326                         r >>= 3;
 327                         g >>= 2;
 328                         b >>= 3;
 329                         break;
 330                 case V4L2_PIX_FMT_RGB555:
 331                 case V4L2_PIX_FMT_RGB555X:
 332                         r >>= 3;
 333                         g >>= 3;
 334                         b >>= 3;
 335                         break;
 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 = dev->field;
 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         size = dev->width * dev->height * dev->pixelsize;
 773
 774         if (0 == *nbuffers)
 775                 *nbuffers = 32;
 776
 777         while (size * *nbuffers > vid_limit * 1024 * 1024)
 778                 (*nbuffers)--;
 779
 780         *nplanes = 1;
 781
 782         sizes[0] = size;
 783
 784         /*
 785          * videobuf2-vmalloc allocator is context-less so no need to set
 786          * alloc_ctxs array.
 787          */
 788
 789         dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
 790                 *nbuffers, size);
 791
 792         return 0;
 793 }
 794
 795 static int buffer_init(struct vb2_buffer *vb)
 796 {
 797         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 798
 799         BUG_ON(NULL == dev->fmt);
 800
 801         /*
 802          * This callback is called once per buffer, after its allocation.
 803          *
 804          * Vivi does not allow changing format during streaming, but it is
 805          * possible to do so when streaming is paused (i.e. in streamoff state).
 806          * Buffers however are not freed when going into streamoff and so
 807          * buffer size verification has to be done in buffer_prepare, on each
 808          * qbuf.
 809          * It would be best to move verification code here to buf_init and
 810          * s_fmt though.
 811          */
 812
 813         return 0;
 814 }
 815
 816 static int buffer_prepare(struct vb2_buffer *vb)
 817 {
 818         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 819         struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
 820         unsigned long size;
 821
 822         dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
 823
 824         BUG_ON(NULL == dev->fmt);
 825
 826         /*
 827          * Theses properties only change when queue is idle, see s_fmt.
 828          * The below checks should not be performed here, on each
 829          * buffer_prepare (i.e. on each qbuf). Most of the code in this function
 830          * should thus be moved to buffer_init and s_fmt.
 831          */
 832         if (dev->width  < 48 || dev->width  > MAX_WIDTH ||
 833             dev->height < 32 || dev->height > MAX_HEIGHT)
 834                 return -EINVAL;
 835
 836         size = dev->width * dev->height * dev->pixelsize;
 837         if (vb2_plane_size(vb, 0) < size) {
 838                 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
 839                                 __func__, vb2_plane_size(vb, 0), size);
 840                 return -EINVAL;
 841         }
 842
 843         vb2_set_plane_payload(&buf->vb, 0, size);
 844
 845         buf->fmt = dev->fmt;
 846
 847         precalculate_bars(dev);
 848         precalculate_line(dev);
 849
 850         return 0;
 851 }
 852
 853 static int buffer_finish(struct vb2_buffer *vb)
 854 {
 855         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 856         dprintk(dev, 1, "%s\n", __func__);
 857         return 0;
 858 }
 859
 860 static void buffer_cleanup(struct vb2_buffer *vb)
 861 {
 862         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 863         dprintk(dev, 1, "%s\n", __func__);
 864
 865 }
 866
 867 static void buffer_queue(struct vb2_buffer *vb)
 868 {
 869         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 870         struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
 871         struct vivi_dmaqueue *vidq = &dev->vidq;
 872         unsigned long flags = 0;
 873
 874         dprintk(dev, 1, "%s\n", __func__);
 875
 876         spin_lock_irqsave(&dev->slock, flags);
 877         list_add_tail(&buf->list, &vidq->active);
 878         spin_unlock_irqrestore(&dev->slock, flags);
 879 }
 880
 881 static int start_streaming(struct vb2_queue *vq, unsigned int count)
 882 {
 883         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 884         dprintk(dev, 1, "%s\n", __func__);
 885         return vivi_start_generating(dev);
 886 }
 887
 888 /* abort streaming and wait for last buffer */
 889 static int stop_streaming(struct vb2_queue *vq)
 890 {
 891         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 892         dprintk(dev, 1, "%s\n", __func__);
 893         vivi_stop_generating(dev);
 894         return 0;
 895 }
 896
 897 static void vivi_lock(struct vb2_queue *vq)
 898 {
 899         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 900         mutex_lock(&dev->mutex);
 901 }
 902
 903 static void vivi_unlock(struct vb2_queue *vq)
 904 {
 905         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 906         mutex_unlock(&dev->mutex);
 907 }
 908
 909
 910 static struct vb2_ops vivi_video_qops = {
 911         .queue_setup            = queue_setup,
 912         .buf_init               = buffer_init,
 913         .buf_prepare            = buffer_prepare,
 914         .buf_finish             = buffer_finish,
 915         .buf_cleanup            = buffer_cleanup,
 916         .buf_queue              = buffer_queue,
 917         .start_streaming        = start_streaming,
 918         .stop_streaming         = stop_streaming,
 919         .wait_prepare           = vivi_unlock,
 920         .wait_finish            = vivi_lock,
 921 };
 922
 923 /* ------------------------------------------------------------------
 924         IOCTL vidioc handling
 925    ------------------------------------------------------------------*/
 926 static int vidioc_querycap(struct file *file, void  *priv,
 927                                         struct v4l2_capability *cap)
 928 {
 929         struct vivi_dev *dev = video_drvdata(file);
 930
 931         strcpy(cap->driver, "vivi");
 932         strcpy(cap->card, "vivi");
 933         strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
 934         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
 935                             V4L2_CAP_READWRITE;
 936         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 937         return 0;
 938 }
 939
 940 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
 941                                         struct v4l2_fmtdesc *f)
 942 {
 943         struct vivi_fmt *fmt;
 944
 945         if (f->index >= ARRAY_SIZE(formats))
 946                 return -EINVAL;
 947
 948         fmt = &formats[f->index];
 949
 950         strlcpy(f->description, fmt->name, sizeof(f->description));
 951         f->pixelformat = fmt->fourcc;
 952         return 0;
 953 }
 954
 955 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 956                                         struct v4l2_format *f)
 957 {
 958         struct vivi_dev *dev = video_drvdata(file);
 959
 960         f->fmt.pix.width        = dev->width;
 961         f->fmt.pix.height       = dev->height;
 962         f->fmt.pix.field        = dev->field;
 963         f->fmt.pix.pixelformat  = dev->fmt->fourcc;
 964         f->fmt.pix.bytesperline =
 965                 (f->fmt.pix.width * dev->fmt->depth) >> 3;
 966         f->fmt.pix.sizeimage =
 967                 f->fmt.pix.height * f->fmt.pix.bytesperline;
 968         if (dev->fmt->fourcc == V4L2_PIX_FMT_YUYV ||
 969             dev->fmt->fourcc == V4L2_PIX_FMT_UYVY)
 970                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 971         else
 972                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
 973         return 0;
 974 }
 975
 976 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 977                         struct v4l2_format *f)
 978 {
 979         struct vivi_dev *dev = video_drvdata(file);
 980         struct vivi_fmt *fmt;
 981         enum v4l2_field field;
 982
 983         fmt = get_format(f);
 984         if (!fmt) {
 985                 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
 986                         f->fmt.pix.pixelformat);
 987                 return -EINVAL;
 988         }
 989
 990         field = f->fmt.pix.field;
 991
 992         if (field == V4L2_FIELD_ANY) {
 993                 field = V4L2_FIELD_INTERLACED;
 994         } else if (V4L2_FIELD_INTERLACED != field) {
 995                 dprintk(dev, 1, "Field type invalid.\n");
 996                 return -EINVAL;
 997         }
 998
 999         f->fmt.pix.field = field;
1000         v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
1001                               &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
1002         f->fmt.pix.bytesperline =
1003                 (f->fmt.pix.width * fmt->depth) >> 3;
1004         f->fmt.pix.sizeimage =
1005                 f->fmt.pix.height * f->fmt.pix.bytesperline;
1006         if (fmt->fourcc == V4L2_PIX_FMT_YUYV ||
1007             fmt->fourcc == V4L2_PIX_FMT_UYVY)
1008                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1009         else
1010                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
1011         return 0;
1012 }
1013
1014 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1015                                         struct v4l2_format *f)
1016 {
1017         struct vivi_dev *dev = video_drvdata(file);
1018         struct vb2_queue *q = &dev->vb_vidq;
1019
1020         int ret = vidioc_try_fmt_vid_cap(file, priv, f);
1021         if (ret < 0)
1022                 return ret;
1023
1024         if (vb2_is_streaming(q)) {
1025                 dprintk(dev, 1, "%s device busy\n", __func__);
1026                 return -EBUSY;
1027         }
1028
1029         dev->fmt = get_format(f);
1030         dev->pixelsize = dev->fmt->depth / 8;
1031         dev->width = f->fmt.pix.width;
1032         dev->height = f->fmt.pix.height;
1033         dev->field = f->fmt.pix.field;
1034
1035         return 0;
1036 }
1037
1038 static int vidioc_reqbufs(struct file *file, void *priv,
1039                           struct v4l2_requestbuffers *p)
1040 {
1041         struct vivi_dev *dev = video_drvdata(file);
1042         return vb2_reqbufs(&dev->vb_vidq, p);
1043 }
1044
1045 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
1046 {
1047         struct vivi_dev *dev = video_drvdata(file);
1048         return vb2_querybuf(&dev->vb_vidq, p);
1049 }
1050
1051 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1052 {
1053         struct vivi_dev *dev = video_drvdata(file);
1054         return vb2_qbuf(&dev->vb_vidq, p);
1055 }
1056
1057 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1058 {
1059         struct vivi_dev *dev = video_drvdata(file);
1060         return vb2_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK);
1061 }
1062
1063 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1064 {
1065         struct vivi_dev *dev = video_drvdata(file);
1066         return vb2_streamon(&dev->vb_vidq, i);
1067 }
1068
1069 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1070 {
1071         struct vivi_dev *dev = video_drvdata(file);
1072         return vb2_streamoff(&dev->vb_vidq, i);
1073 }
1074
1075 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1076 {
1077         return 0;
1078 }
1079
1080 /* only one input in this sample driver */
1081 static int vidioc_enum_input(struct file *file, void *priv,
1082                                 struct v4l2_input *inp)
1083 {
1084         if (inp->index >= NUM_INPUTS)
1085                 return -EINVAL;
1086
1087         inp->type = V4L2_INPUT_TYPE_CAMERA;
1088         inp->std = V4L2_STD_525_60;
1089         sprintf(inp->name, "Camera %u", inp->index);
1090         return 0;
1091 }
1092
1093 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1094 {
1095         struct vivi_dev *dev = video_drvdata(file);
1096
1097         *i = dev->input;
1098         return 0;
1099 }
1100
1101 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1102 {
1103         struct vivi_dev *dev = video_drvdata(file);
1104
1105         if (i >= NUM_INPUTS)
1106                 return -EINVAL;
1107
1108         if (i == dev->input)
1109                 return 0;
1110
1111         dev->input = i;
1112         precalculate_bars(dev);
1113         precalculate_line(dev);
1114         return 0;
1115 }
1116
1117 /* --- controls ---------------------------------------------- */
1118
1119 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1120 {
1121         struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1122
1123         if (ctrl == dev->autogain)
1124                 dev->gain->val = jiffies & 0xff;
1125         return 0;
1126 }
1127
1128 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1129 {
1130         struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1131
1132         switch (ctrl->id) {
1133         case V4L2_CID_ALPHA_COMPONENT:
1134                 dev->alpha_component = ctrl->val;
1135                 break;
1136         default:
1137                 if (ctrl == dev->button)
1138                         dev->button_pressed = 30;
1139                 break;
1140         }
1141         return 0;
1142 }
1143
1144 /* ------------------------------------------------------------------
1145         File operations for the device
1146    ------------------------------------------------------------------*/
1147
1148 static ssize_t
1149 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1150 {
1151         struct vivi_dev *dev = video_drvdata(file);
1152         int err;
1153
1154         dprintk(dev, 1, "read called\n");
1155         mutex_lock(&dev->mutex);
1156         err = vb2_read(&dev->vb_vidq, data, count, ppos,
1157                        file->f_flags & O_NONBLOCK);
1158         mutex_unlock(&dev->mutex);
1159         return err;
1160 }
1161
1162 static unsigned int
1163 vivi_poll(struct file *file, struct poll_table_struct *wait)
1164 {
1165         struct vivi_dev *dev = video_drvdata(file);
1166         struct vb2_queue *q = &dev->vb_vidq;
1167
1168         dprintk(dev, 1, "%s\n", __func__);
1169         return vb2_poll(q, file, wait);
1170 }
1171
1172 static int vivi_close(struct file *file)
1173 {
1174         struct video_device  *vdev = video_devdata(file);
1175         struct vivi_dev *dev = video_drvdata(file);
1176
1177         dprintk(dev, 1, "close called (dev=%s), file %p\n",
1178                 video_device_node_name(vdev), file);
1179
1180         if (v4l2_fh_is_singular_file(file))
1181                 vb2_queue_release(&dev->vb_vidq);
1182         return v4l2_fh_release(file);
1183 }
1184
1185 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1186 {
1187         struct vivi_dev *dev = video_drvdata(file);
1188         int ret;
1189
1190         dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1191
1192         ret = vb2_mmap(&dev->vb_vidq, vma);
1193         dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1194                 (unsigned long)vma->vm_start,
1195                 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
1196                 ret);
1197         return ret;
1198 }
1199
1200 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1201         .g_volatile_ctrl = vivi_g_volatile_ctrl,
1202         .s_ctrl = vivi_s_ctrl,
1203 };
1204
1205 #define VIVI_CID_CUSTOM_BASE    (V4L2_CID_USER_BASE | 0xf000)
1206
1207 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1208         .ops = &vivi_ctrl_ops,
1209         .id = VIVI_CID_CUSTOM_BASE + 0,
1210         .name = "Button",
1211         .type = V4L2_CTRL_TYPE_BUTTON,
1212 };
1213
1214 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1215         .ops = &vivi_ctrl_ops,
1216         .id = VIVI_CID_CUSTOM_BASE + 1,
1217         .name = "Boolean",
1218         .type = V4L2_CTRL_TYPE_BOOLEAN,
1219         .min = 0,
1220         .max = 1,
1221         .step = 1,
1222         .def = 1,
1223 };
1224
1225 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1226         .ops = &vivi_ctrl_ops,
1227         .id = VIVI_CID_CUSTOM_BASE + 2,
1228         .name = "Integer 32 Bits",
1229         .type = V4L2_CTRL_TYPE_INTEGER,
1230         .min = 0x80000000,
1231         .max = 0x7fffffff,
1232         .step = 1,
1233 };
1234
1235 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1236         .ops = &vivi_ctrl_ops,
1237         .id = VIVI_CID_CUSTOM_BASE + 3,
1238         .name = "Integer 64 Bits",
1239         .type = V4L2_CTRL_TYPE_INTEGER64,
1240 };
1241
1242 static const char * const vivi_ctrl_menu_strings[] = {
1243         "Menu Item 0 (Skipped)",
1244         "Menu Item 1",
1245         "Menu Item 2 (Skipped)",
1246         "Menu Item 3",
1247         "Menu Item 4",
1248         "Menu Item 5 (Skipped)",
1249         NULL,
1250 };
1251
1252 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1253         .ops = &vivi_ctrl_ops,
1254         .id = VIVI_CID_CUSTOM_BASE + 4,
1255         .name = "Menu",
1256         .type = V4L2_CTRL_TYPE_MENU,
1257         .min = 1,
1258         .max = 4,
1259         .def = 3,
1260         .menu_skip_mask = 0x04,
1261         .qmenu = vivi_ctrl_menu_strings,
1262 };
1263
1264 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1265         .ops = &vivi_ctrl_ops,
1266         .id = VIVI_CID_CUSTOM_BASE + 5,
1267         .name = "String",
1268         .type = V4L2_CTRL_TYPE_STRING,
1269         .min = 2,
1270         .max = 4,
1271         .step = 1,
1272 };
1273
1274 static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1275         .ops = &vivi_ctrl_ops,
1276         .id = VIVI_CID_CUSTOM_BASE + 6,
1277         .name = "Bitmask",
1278         .type = V4L2_CTRL_TYPE_BITMASK,
1279         .def = 0x80002000,
1280         .min = 0,
1281         .max = 0x80402010,
1282         .step = 0,
1283 };
1284
1285 static const s64 vivi_ctrl_int_menu_values[] = {
1286         1, 1, 2, 3, 5, 8, 13, 21, 42,
1287 };
1288
1289 static const struct v4l2_ctrl_config vivi_ctrl_int_menu = {
1290         .ops = &vivi_ctrl_ops,
1291         .id = VIVI_CID_CUSTOM_BASE + 7,
1292         .name = "Integer menu",
1293         .type = V4L2_CTRL_TYPE_INTEGER_MENU,
1294         .min = 1,
1295         .max = 8,
1296         .def = 4,
1297         .menu_skip_mask = 0x02,
1298         .qmenu_int = vivi_ctrl_int_menu_values,
1299 };
1300
1301 static const struct v4l2_file_operations vivi_fops = {
1302         .owner          = THIS_MODULE,
1303         .open           = v4l2_fh_open,
1304         .release        = vivi_close,
1305         .read           = vivi_read,
1306         .poll           = vivi_poll,
1307         .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1308         .mmap           = vivi_mmap,
1309 };
1310
1311 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1312         .vidioc_querycap      = vidioc_querycap,
1313         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1314         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1315         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1316         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1317         .vidioc_reqbufs       = vidioc_reqbufs,
1318         .vidioc_querybuf      = vidioc_querybuf,
1319         .vidioc_qbuf          = vidioc_qbuf,
1320         .vidioc_dqbuf         = vidioc_dqbuf,
1321         .vidioc_s_std         = vidioc_s_std,
1322         .vidioc_enum_input    = vidioc_enum_input,
1323         .vidioc_g_input       = vidioc_g_input,
1324         .vidioc_s_input       = vidioc_s_input,
1325         .vidioc_streamon      = vidioc_streamon,
1326         .vidioc_streamoff     = vidioc_streamoff,
1327         .vidioc_log_status    = v4l2_ctrl_log_status,
1328         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1329         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1330 };
1331
1332 static struct video_device vivi_template = {
1333         .name           = "vivi",
1334         .fops           = &vivi_fops,
1335         .ioctl_ops      = &vivi_ioctl_ops,
1336         .release        = video_device_release,
1337
1338         .tvnorms              = V4L2_STD_525_60,
1339         .current_norm         = V4L2_STD_NTSC_M,
1340 };
1341
1342 /* -----------------------------------------------------------------
1343         Initialization and module stuff
1344    ------------------------------------------------------------------*/
1345
1346 static int vivi_release(void)
1347 {
1348         struct vivi_dev *dev;
1349         struct list_head *list;
1350
1351         while (!list_empty(&vivi_devlist)) {
1352                 list = vivi_devlist.next;
1353                 list_del(list);
1354                 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1355
1356                 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1357                         video_device_node_name(dev->vfd));
1358                 video_unregister_device(dev->vfd);
1359                 v4l2_device_unregister(&dev->v4l2_dev);
1360                 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1361                 kfree(dev);
1362         }
1363
1364         return 0;
1365 }
1366
1367 static int __init vivi_create_instance(int inst)
1368 {
1369         struct vivi_dev *dev;
1370         struct video_device *vfd;
1371         struct v4l2_ctrl_handler *hdl;
1372         struct vb2_queue *q;
1373         int ret;
1374
1375         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1376         if (!dev)
1377                 return -ENOMEM;
1378
1379         snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1380                         "%s-%03d", VIVI_MODULE_NAME, inst);
1381         ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1382         if (ret)
1383                 goto free_dev;
1384
1385         dev->fmt = &formats[0];
1386         dev->width = 640;
1387         dev->height = 480;
1388         dev->pixelsize = dev->fmt->depth / 8;
1389         hdl = &dev->ctrl_handler;
1390         v4l2_ctrl_handler_init(hdl, 11);
1391         dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1392                         V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1393         dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1394                         V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1395         dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1396                         V4L2_CID_CONTRAST, 0, 255, 1, 16);
1397         dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1398                         V4L2_CID_SATURATION, 0, 255, 1, 127);
1399         dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1400                         V4L2_CID_HUE, -128, 127, 1, 0);
1401         dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1402                         V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1403         dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1404                         V4L2_CID_GAIN, 0, 255, 1, 100);
1405         dev->alpha = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1406                         V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1407         dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1408         dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1409         dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1410         dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1411         dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1412         dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1413         dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1414         dev->int_menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int_menu, NULL);
1415         if (hdl->error) {
1416                 ret = hdl->error;
1417                 goto unreg_dev;
1418         }
1419         v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1420         dev->v4l2_dev.ctrl_handler = hdl;
1421
1422         /* initialize locks */
1423         spin_lock_init(&dev->slock);
1424
1425         /* initialize queue */
1426         q = &dev->vb_vidq;
1427         memset(q, 0, sizeof(dev->vb_vidq));
1428         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1429         q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1430         q->drv_priv = dev;
1431         q->buf_struct_size = sizeof(struct vivi_buffer);
1432         q->ops = &vivi_video_qops;
1433         q->mem_ops = &vb2_vmalloc_memops;
1434
1435         vb2_queue_init(q);
1436
1437         mutex_init(&dev->mutex);
1438
1439         /* init video dma queues */
1440         INIT_LIST_HEAD(&dev->vidq.active);
1441         init_waitqueue_head(&dev->vidq.wq);
1442
1443         ret = -ENOMEM;
1444         vfd = video_device_alloc();
1445         if (!vfd)
1446                 goto unreg_dev;
1447
1448         *vfd = vivi_template;
1449         vfd->debug = debug;
1450         vfd->v4l2_dev = &dev->v4l2_dev;
1451         set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1452
1453         /*
1454          * Provide a mutex to v4l2 core. It will be used to protect
1455          * all fops and v4l2 ioctls.
1456          */
1457         vfd->lock = &dev->mutex;
1458
1459         ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1460         if (ret < 0)
1461                 goto rel_vdev;
1462
1463         video_set_drvdata(vfd, dev);
1464
1465         /* Now that everything is fine, let's add it to device list */
1466         list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1467
1468         if (video_nr != -1)
1469                 video_nr++;
1470
1471         dev->vfd = vfd;
1472         v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1473                   video_device_node_name(vfd));
1474         return 0;
1475
1476 rel_vdev:
1477         video_device_release(vfd);
1478 unreg_dev:
1479         v4l2_ctrl_handler_free(hdl);
1480         v4l2_device_unregister(&dev->v4l2_dev);
1481 free_dev:
1482         kfree(dev);
1483         return ret;
1484 }
1485
1486 /* This routine allocates from 1 to n_devs virtual drivers.
1487
1488    The real maximum number of virtual drivers will depend on how many drivers
1489    will succeed. This is limited to the maximum number of devices that
1490    videodev supports, which is equal to VIDEO_NUM_DEVICES.
1491  */
1492 static int __init vivi_init(void)
1493 {
1494         const struct font_desc *font = find_font("VGA8x16");
1495         int ret = 0, i;
1496
1497         if (font == NULL) {
1498                 printk(KERN_ERR "vivi: could not find font\n");
1499                 return -ENODEV;
1500         }
1501         font8x16 = font->data;
1502
1503         if (n_devs <= 0)
1504                 n_devs = 1;
1505
1506         for (i = 0; i < n_devs; i++) {
1507                 ret = vivi_create_instance(i);
1508                 if (ret) {
1509                         /* If some instantiations succeeded, keep driver */
1510                         if (i)
1511                                 ret = 0;
1512                         break;
1513                 }
1514         }
1515
1516         if (ret < 0) {
1517                 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1518                 return ret;
1519         }
1520
1521         printk(KERN_INFO "Video Technology Magazine Virtual Video "
1522                         "Capture Board ver %s successfully loaded.\n",
1523                         VIVI_VERSION);
1524
1525         /* n_devs will reflect the actual number of allocated devices */
1526         n_devs = i;
1527
1528         return ret;
1529 }
1530
1531 static void __exit vivi_exit(void)
1532 {
1533         vivi_release();
1534 }
1535
1536 module_init(vivi_init);
1537 module_exit(vivi_exit);