drivers/media/platform/vivi.c

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