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