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->p_cur.p_s64,
 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->p_cur.p_char);
 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         int err;
 893
 894         dprintk(dev, 1, "%s\n", __func__);
 895         dev->seq_count = 0;
 896         err = vivi_start_generating(dev);
 897         if (err) {
 898                 struct vivi_buffer *buf, *tmp;
 899
 900                 list_for_each_entry_safe(buf, tmp, &dev->vidq.active, list) {
 901                         list_del(&buf->list);
 902                         vb2_buffer_done(&buf->vb, VB2_BUF_STATE_QUEUED);
 903                 }
 904         }
 905         return err;
 906 }
 907
 908 /* abort streaming and wait for last buffer */
 909 static void stop_streaming(struct vb2_queue *vq)
 910 {
 911         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 912         dprintk(dev, 1, "%s\n", __func__);
 913         vivi_stop_generating(dev);
 914 }
 915
 916 static void vivi_lock(struct vb2_queue *vq)
 917 {
 918         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 919         mutex_lock(&dev->mutex);
 920 }
 921
 922 static void vivi_unlock(struct vb2_queue *vq)
 923 {
 924         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 925         mutex_unlock(&dev->mutex);
 926 }
 927
 928
 929 static const struct vb2_ops vivi_video_qops = {
 930         .queue_setup            = queue_setup,
 931         .buf_prepare            = buffer_prepare,
 932         .buf_queue              = buffer_queue,
 933         .start_streaming        = start_streaming,
 934         .stop_streaming         = stop_streaming,
 935         .wait_prepare           = vivi_unlock,
 936         .wait_finish            = vivi_lock,
 937 };
 938
 939 /* ------------------------------------------------------------------
 940         IOCTL vidioc handling
 941    ------------------------------------------------------------------*/
 942 static int vidioc_querycap(struct file *file, void  *priv,
 943                                         struct v4l2_capability *cap)
 944 {
 945         struct vivi_dev *dev = video_drvdata(file);
 946
 947         strcpy(cap->driver, "vivi");
 948         strcpy(cap->card, "vivi");
 949         snprintf(cap->bus_info, sizeof(cap->bus_info),
 950                         "platform:%s", dev->v4l2_dev.name);
 951         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
 952                             V4L2_CAP_READWRITE;
 953         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 954         return 0;
 955 }
 956
 957 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
 958                                         struct v4l2_fmtdesc *f)
 959 {
 960         const struct vivi_fmt *fmt;
 961
 962         if (f->index >= ARRAY_SIZE(formats))
 963                 return -EINVAL;
 964
 965         fmt = &formats[f->index];
 966
 967         strlcpy(f->description, fmt->name, sizeof(f->description));
 968         f->pixelformat = fmt->fourcc;
 969         return 0;
 970 }
 971
 972 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 973                                         struct v4l2_format *f)
 974 {
 975         struct vivi_dev *dev = video_drvdata(file);
 976
 977         f->fmt.pix.width        = dev->width;
 978         f->fmt.pix.height       = dev->height;
 979         f->fmt.pix.field        = V4L2_FIELD_INTERLACED;
 980         f->fmt.pix.pixelformat  = dev->fmt->fourcc;
 981         f->fmt.pix.bytesperline =
 982                 (f->fmt.pix.width * dev->fmt->depth) >> 3;
 983         f->fmt.pix.sizeimage =
 984                 f->fmt.pix.height * f->fmt.pix.bytesperline;
 985         if (dev->fmt->is_yuv)
 986                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 987         else
 988                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
 989         return 0;
 990 }
 991
 992 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 993                         struct v4l2_format *f)
 994 {
 995         struct vivi_dev *dev = video_drvdata(file);
 996         const struct vivi_fmt *fmt;
 997
 998         fmt = get_format(f);
 999         if (!fmt) {
1000                 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
1001                         f->fmt.pix.pixelformat);
1002                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1003                 fmt = get_format(f);
1004         }
1005
1006         f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1007         v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
1008                               &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
1009         f->fmt.pix.bytesperline =
1010                 (f->fmt.pix.width * fmt->depth) >> 3;
1011         f->fmt.pix.sizeimage =
1012                 f->fmt.pix.height * f->fmt.pix.bytesperline;
1013         if (fmt->is_yuv)
1014                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1015         else
1016                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
1017         f->fmt.pix.priv = 0;
1018         return 0;
1019 }
1020
1021 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1022                                         struct v4l2_format *f)
1023 {
1024         struct vivi_dev *dev = video_drvdata(file);
1025         struct vb2_queue *q = &dev->vb_vidq;
1026
1027         int ret = vidioc_try_fmt_vid_cap(file, priv, f);
1028         if (ret < 0)
1029                 return ret;
1030
1031         if (vb2_is_busy(q)) {
1032                 dprintk(dev, 1, "%s device busy\n", __func__);
1033                 return -EBUSY;
1034         }
1035
1036         dev->fmt = get_format(f);
1037         dev->pixelsize = dev->fmt->depth / 8;
1038         dev->width = f->fmt.pix.width;
1039         dev->height = f->fmt.pix.height;
1040
1041         return 0;
1042 }
1043
1044 static int vidioc_enum_framesizes(struct file *file, void *fh,
1045                                          struct v4l2_frmsizeenum *fsize)
1046 {
1047         static const struct v4l2_frmsize_stepwise sizes = {
1048                 48, MAX_WIDTH, 4,
1049                 32, MAX_HEIGHT, 1
1050         };
1051         int i;
1052
1053         if (fsize->index)
1054                 return -EINVAL;
1055         for (i = 0; i < ARRAY_SIZE(formats); i++)
1056                 if (formats[i].fourcc == fsize->pixel_format)
1057                         break;
1058         if (i == ARRAY_SIZE(formats))
1059                 return -EINVAL;
1060         fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1061         fsize->stepwise = sizes;
1062         return 0;
1063 }
1064
1065 /* only one input in this sample driver */
1066 static int vidioc_enum_input(struct file *file, void *priv,
1067                                 struct v4l2_input *inp)
1068 {
1069         if (inp->index >= NUM_INPUTS)
1070                 return -EINVAL;
1071
1072         inp->type = V4L2_INPUT_TYPE_CAMERA;
1073         sprintf(inp->name, "Camera %u", inp->index);
1074         return 0;
1075 }
1076
1077 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1078 {
1079         struct vivi_dev *dev = video_drvdata(file);
1080
1081         *i = dev->input;
1082         return 0;
1083 }
1084
1085 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1086 {
1087         struct vivi_dev *dev = video_drvdata(file);
1088
1089         if (i >= NUM_INPUTS)
1090                 return -EINVAL;
1091
1092         if (i == dev->input)
1093                 return 0;
1094
1095         dev->input = i;
1096         /*
1097          * Modify the brightness range depending on the input.
1098          * This makes it easy to use vivi to test if applications can
1099          * handle control range modifications and is also how this is
1100          * typically used in practice as different inputs may be hooked
1101          * up to different receivers with different control ranges.
1102          */
1103         v4l2_ctrl_modify_range(dev->brightness,
1104                         128 * i, 255 + 128 * i, 1, 127 + 128 * i);
1105         precalculate_bars(dev);
1106         precalculate_line(dev);
1107         return 0;
1108 }
1109
1110 /* timeperframe is arbitrary and continuous */
1111 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1112                                              struct v4l2_frmivalenum *fival)
1113 {
1114         const struct vivi_fmt *fmt;
1115
1116         if (fival->index)
1117                 return -EINVAL;
1118
1119         fmt = __get_format(fival->pixel_format);
1120         if (!fmt)
1121                 return -EINVAL;
1122
1123         /* check for valid width/height */
1124         if (fival->width < 48 || fival->width > MAX_WIDTH || (fival->width & 3))
1125                 return -EINVAL;
1126         if (fival->height < 32 || fival->height > MAX_HEIGHT)
1127                 return -EINVAL;
1128
1129         fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
1130
1131         /* fill in stepwise (step=1.0 is required by V4L2 spec) */
1132         fival->stepwise.min  = tpf_min;
1133         fival->stepwise.max  = tpf_max;
1134         fival->stepwise.step = (struct v4l2_fract) {1, 1};
1135
1136         return 0;
1137 }
1138
1139 static int vidioc_g_parm(struct file *file, void *priv,
1140                           struct v4l2_streamparm *parm)
1141 {
1142         struct vivi_dev *dev = video_drvdata(file);
1143
1144         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1145                 return -EINVAL;
1146
1147         parm->parm.capture.capability   = V4L2_CAP_TIMEPERFRAME;
1148         parm->parm.capture.timeperframe = dev->timeperframe;
1149         parm->parm.capture.readbuffers  = 1;
1150         return 0;
1151 }
1152
1153 #define FRACT_CMP(a, OP, b)     \
1154         ((u64)(a).numerator * (b).denominator  OP  (u64)(b).numerator * (a).denominator)
1155
1156 static int vidioc_s_parm(struct file *file, void *priv,
1157                           struct v4l2_streamparm *parm)
1158 {
1159         struct vivi_dev *dev = video_drvdata(file);
1160         struct v4l2_fract tpf;
1161
1162         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1163                 return -EINVAL;
1164
1165         tpf = parm->parm.capture.timeperframe;
1166
1167         /* tpf: {*, 0} resets timing; clip to [min, max]*/
1168         tpf = tpf.denominator ? tpf : tpf_default;
1169         tpf = FRACT_CMP(tpf, <, tpf_min) ? tpf_min : tpf;
1170         tpf = FRACT_CMP(tpf, >, tpf_max) ? tpf_max : tpf;
1171
1172         dev->timeperframe = tpf;
1173         parm->parm.capture.timeperframe = tpf;
1174         parm->parm.capture.readbuffers  = 1;
1175         return 0;
1176 }
1177
1178 /* --- controls ---------------------------------------------- */
1179
1180 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1181 {
1182         struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1183
1184         if (ctrl == dev->autogain)
1185                 dev->gain->val = jiffies & 0xff;
1186         return 0;
1187 }
1188
1189 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1190 {
1191         struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1192
1193         switch (ctrl->id) {
1194         case V4L2_CID_ALPHA_COMPONENT:
1195                 dev->alpha_component = ctrl->val;
1196                 break;
1197         default:
1198                 if (ctrl == dev->button)
1199                         dev->button_pressed = 30;
1200                 break;
1201         }
1202         return 0;
1203 }
1204
1205 /* ------------------------------------------------------------------
1206         File operations for the device
1207    ------------------------------------------------------------------*/
1208
1209 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1210         .g_volatile_ctrl = vivi_g_volatile_ctrl,
1211         .s_ctrl = vivi_s_ctrl,
1212 };
1213
1214 #define VIVI_CID_CUSTOM_BASE    (V4L2_CID_USER_BASE | 0xf000)
1215
1216 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1217         .ops = &vivi_ctrl_ops,
1218         .id = VIVI_CID_CUSTOM_BASE + 0,
1219         .name = "Button",
1220         .type = V4L2_CTRL_TYPE_BUTTON,
1221 };
1222
1223 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1224         .ops = &vivi_ctrl_ops,
1225         .id = VIVI_CID_CUSTOM_BASE + 1,
1226         .name = "Boolean",
1227         .type = V4L2_CTRL_TYPE_BOOLEAN,
1228         .min = 0,
1229         .max = 1,
1230         .step = 1,
1231         .def = 1,
1232 };
1233
1234 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1235         .ops = &vivi_ctrl_ops,
1236         .id = VIVI_CID_CUSTOM_BASE + 2,
1237         .name = "Integer 32 Bits",
1238         .type = V4L2_CTRL_TYPE_INTEGER,
1239         .min = -0x80000000LL,
1240         .max = 0x7fffffff,
1241         .step = 1,
1242 };
1243
1244 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1245         .ops = &vivi_ctrl_ops,
1246         .id = VIVI_CID_CUSTOM_BASE + 3,
1247         .name = "Integer 64 Bits",
1248         .type = V4L2_CTRL_TYPE_INTEGER64,
1249         .min = LLONG_MIN,
1250         .max = LLONG_MAX,
1251         .step = 1,
1252 };
1253
1254 static const char * const vivi_ctrl_menu_strings[] = {
1255         "Menu Item 0 (Skipped)",
1256         "Menu Item 1",
1257         "Menu Item 2 (Skipped)",
1258         "Menu Item 3",
1259         "Menu Item 4",
1260         "Menu Item 5 (Skipped)",
1261         NULL,
1262 };
1263
1264 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1265         .ops = &vivi_ctrl_ops,
1266         .id = VIVI_CID_CUSTOM_BASE + 4,
1267         .name = "Menu",
1268         .type = V4L2_CTRL_TYPE_MENU,
1269         .min = 1,
1270         .max = 4,
1271         .def = 3,
1272         .menu_skip_mask = 0x04,
1273         .qmenu = vivi_ctrl_menu_strings,
1274 };
1275
1276 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1277         .ops = &vivi_ctrl_ops,
1278         .id = VIVI_CID_CUSTOM_BASE + 5,
1279         .name = "String",
1280         .type = V4L2_CTRL_TYPE_STRING,
1281         .min = 2,
1282         .max = 4,
1283         .step = 1,
1284 };
1285
1286 static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1287         .ops = &vivi_ctrl_ops,
1288         .id = VIVI_CID_CUSTOM_BASE + 6,
1289         .name = "Bitmask",
1290         .type = V4L2_CTRL_TYPE_BITMASK,
1291         .def = 0x80002000,
1292         .min = 0,
1293         .max = 0x80402010,
1294         .step = 0,
1295 };
1296
1297 static const s64 vivi_ctrl_int_menu_values[] = {
1298         1, 1, 2, 3, 5, 8, 13, 21, 42,
1299 };
1300
1301 static const struct v4l2_ctrl_config vivi_ctrl_int_menu = {
1302         .ops = &vivi_ctrl_ops,
1303         .id = VIVI_CID_CUSTOM_BASE + 7,
1304         .name = "Integer menu",
1305         .type = V4L2_CTRL_TYPE_INTEGER_MENU,
1306         .min = 1,
1307         .max = 8,
1308         .def = 4,
1309         .menu_skip_mask = 0x02,
1310         .qmenu_int = vivi_ctrl_int_menu_values,
1311 };
1312
1313 static const struct v4l2_file_operations vivi_fops = {
1314         .owner          = THIS_MODULE,
1315         .open           = v4l2_fh_open,
1316         .release        = vb2_fop_release,
1317         .read           = vb2_fop_read,
1318         .poll           = vb2_fop_poll,
1319         .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1320         .mmap           = vb2_fop_mmap,
1321 };
1322
1323 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1324         .vidioc_querycap      = vidioc_querycap,
1325         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1326         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1327         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1328         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1329         .vidioc_enum_framesizes   = vidioc_enum_framesizes,
1330         .vidioc_reqbufs       = vb2_ioctl_reqbufs,
1331         .vidioc_create_bufs   = vb2_ioctl_create_bufs,
1332         .vidioc_prepare_buf   = vb2_ioctl_prepare_buf,
1333         .vidioc_querybuf      = vb2_ioctl_querybuf,
1334         .vidioc_qbuf          = vb2_ioctl_qbuf,
1335         .vidioc_dqbuf         = vb2_ioctl_dqbuf,
1336         .vidioc_enum_input    = vidioc_enum_input,
1337         .vidioc_g_input       = vidioc_g_input,
1338         .vidioc_s_input       = vidioc_s_input,
1339         .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1340         .vidioc_g_parm        = vidioc_g_parm,
1341         .vidioc_s_parm        = vidioc_s_parm,
1342         .vidioc_streamon      = vb2_ioctl_streamon,
1343         .vidioc_streamoff     = vb2_ioctl_streamoff,
1344         .vidioc_log_status    = v4l2_ctrl_log_status,
1345         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1346         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1347 };
1348
1349 static const struct video_device vivi_template = {
1350         .name           = "vivi",
1351         .fops           = &vivi_fops,
1352         .ioctl_ops      = &vivi_ioctl_ops,
1353         .release        = video_device_release_empty,
1354 };
1355
1356 /* -----------------------------------------------------------------
1357         Initialization and module stuff
1358    ------------------------------------------------------------------*/
1359
1360 static int vivi_release(void)
1361 {
1362         struct vivi_dev *dev;
1363         struct list_head *list;
1364
1365         while (!list_empty(&vivi_devlist)) {
1366                 list = vivi_devlist.next;
1367                 list_del(list);
1368                 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1369
1370                 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1371                         video_device_node_name(&dev->vdev));
1372                 video_unregister_device(&dev->vdev);
1373                 v4l2_device_unregister(&dev->v4l2_dev);
1374                 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1375                 kfree(dev);
1376         }
1377
1378         return 0;
1379 }
1380
1381 static int __init vivi_create_instance(int inst)
1382 {
1383         struct vivi_dev *dev;
1384         struct video_device *vfd;
1385         struct v4l2_ctrl_handler *hdl;
1386         struct vb2_queue *q;
1387         int ret;
1388
1389         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1390         if (!dev)
1391                 return -ENOMEM;
1392
1393         snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1394                         "%s-%03d", VIVI_MODULE_NAME, inst);
1395         ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1396         if (ret)
1397                 goto free_dev;
1398
1399         dev->fmt = &formats[0];
1400         dev->timeperframe = tpf_default;
1401         dev->width = 640;
1402         dev->height = 480;
1403         dev->pixelsize = dev->fmt->depth / 8;
1404         hdl = &dev->ctrl_handler;
1405         v4l2_ctrl_handler_init(hdl, 11);
1406         dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1407                         V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1408         dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1409                         V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1410         dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1411                         V4L2_CID_CONTRAST, 0, 255, 1, 16);
1412         dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1413                         V4L2_CID_SATURATION, 0, 255, 1, 127);
1414         dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1415                         V4L2_CID_HUE, -128, 127, 1, 0);
1416         dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1417                         V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1418         dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1419                         V4L2_CID_GAIN, 0, 255, 1, 100);
1420         dev->alpha = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1421                         V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1422         dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1423         dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1424         dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1425         dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1426         dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1427         dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1428         dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1429         dev->int_menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int_menu, NULL);
1430         if (hdl->error) {
1431                 ret = hdl->error;
1432                 goto unreg_dev;
1433         }
1434         v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1435         dev->v4l2_dev.ctrl_handler = hdl;
1436
1437         /* initialize locks */
1438         spin_lock_init(&dev->slock);
1439
1440         /* initialize queue */
1441         q = &dev->vb_vidq;
1442         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1443         q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1444         q->drv_priv = dev;
1445         q->buf_struct_size = sizeof(struct vivi_buffer);
1446         q->ops = &vivi_video_qops;
1447         q->mem_ops = &vb2_vmalloc_memops;
1448         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1449
1450         ret = vb2_queue_init(q);
1451         if (ret)
1452                 goto unreg_dev;
1453
1454         mutex_init(&dev->mutex);
1455
1456         /* init video dma queues */
1457         INIT_LIST_HEAD(&dev->vidq.active);
1458         init_waitqueue_head(&dev->vidq.wq);
1459
1460         vfd = &dev->vdev;
1461         *vfd = vivi_template;
1462         vfd->debug = debug;
1463         vfd->v4l2_dev = &dev->v4l2_dev;
1464         vfd->queue = q;
1465
1466         /*
1467          * Provide a mutex to v4l2 core. It will be used to protect
1468          * all fops and v4l2 ioctls.
1469          */
1470         vfd->lock = &dev->mutex;
1471         video_set_drvdata(vfd, dev);
1472
1473         ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1474         if (ret < 0)
1475                 goto unreg_dev;
1476
1477         /* Now that everything is fine, let's add it to device list */
1478         list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1479
1480         v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1481                   video_device_node_name(vfd));
1482         return 0;
1483
1484 unreg_dev:
1485         v4l2_ctrl_handler_free(hdl);
1486         v4l2_device_unregister(&dev->v4l2_dev);
1487 free_dev:
1488         kfree(dev);
1489         return ret;
1490 }
1491
1492 /* This routine allocates from 1 to n_devs virtual drivers.
1493
1494    The real maximum number of virtual drivers will depend on how many drivers
1495    will succeed. This is limited to the maximum number of devices that
1496    videodev supports, which is equal to VIDEO_NUM_DEVICES.
1497  */
1498 static int __init vivi_init(void)
1499 {
1500         const struct font_desc *font = find_font("VGA8x16");
1501         int ret = 0, i;
1502
1503         if (font == NULL) {
1504                 printk(KERN_ERR "vivi: could not find font\n");
1505                 return -ENODEV;
1506         }
1507         font8x16 = font->data;
1508
1509         if (n_devs <= 0)
1510                 n_devs = 1;
1511
1512         for (i = 0; i < n_devs; i++) {
1513                 ret = vivi_create_instance(i);
1514                 if (ret) {
1515                         /* If some instantiations succeeded, keep driver */
1516                         if (i)
1517                                 ret = 0;
1518                         break;
1519                 }
1520         }
1521
1522         if (ret < 0) {
1523                 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1524                 return ret;
1525         }
1526
1527         printk(KERN_INFO "Video Technology Magazine Virtual Video "
1528                         "Capture Board ver %s successfully loaded.\n",
1529                         VIVI_VERSION);
1530
1531         /* n_devs will reflect the actual number of allocated devices */
1532         n_devs = i;
1533
1534         return ret;
1535 }
1536
1537 static void __exit vivi_exit(void)
1538 {
1539         vivi_release();
1540 }
1541
1542 module_init(vivi_init);
1543 module_exit(vivi_exit);