Pileus Git - ~andy/linux/blob - 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, dev->v4l2_dev.name);
 772
 773         if (IS_ERR(dma_q->kthread)) {
 774                 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
 775                 return PTR_ERR(dma_q->kthread);
 776         }
 777         /* Wakes thread */
 778         wake_up_interruptible(&dma_q->wq);
 779
 780         dprintk(dev, 1, "returning from %s\n", __func__);
 781         return 0;
 782 }
 783
 784 static void vivi_stop_generating(struct vivi_dev *dev)
 785 {
 786         struct vivi_dmaqueue *dma_q = &dev->vidq;
 787
 788         dprintk(dev, 1, "%s\n", __func__);
 789
 790         /* shutdown control thread */
 791         if (dma_q->kthread) {
 792                 kthread_stop(dma_q->kthread);
 793                 dma_q->kthread = NULL;
 794         }
 795
 796         /*
 797          * Typical driver might need to wait here until dma engine stops.
 798          * In this case we can abort imiedetly, so it's just a noop.
 799          */
 800
 801         /* Release all active buffers */
 802         while (!list_empty(&dma_q->active)) {
 803                 struct vivi_buffer *buf;
 804                 buf = list_entry(dma_q->active.next, struct vivi_buffer, list);
 805                 list_del(&buf->list);
 806                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
 807                 dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
 808         }
 809 }
 810 /* ------------------------------------------------------------------
 811         Videobuf operations
 812    ------------------------------------------------------------------*/
 813 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
 814                                 unsigned int *nbuffers, unsigned int *nplanes,
 815                                 unsigned int sizes[], void *alloc_ctxs[])
 816 {
 817         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 818         unsigned long size;
 819
 820         if (fmt)
 821                 size = fmt->fmt.pix.sizeimage;
 822         else
 823                 size = dev->width * dev->height * dev->pixelsize;
 824
 825         if (size == 0)
 826                 return -EINVAL;
 827
 828         if (0 == *nbuffers)
 829                 *nbuffers = 32;
 830
 831         while (size * *nbuffers > vid_limit * 1024 * 1024)
 832                 (*nbuffers)--;
 833
 834         *nplanes = 1;
 835
 836         sizes[0] = size;
 837
 838         /*
 839          * videobuf2-vmalloc allocator is context-less so no need to set
 840          * alloc_ctxs array.
 841          */
 842
 843         dprintk(dev, 1, "%s, count=%d, size=%ld\n", __func__,
 844                 *nbuffers, size);
 845
 846         return 0;
 847 }
 848
 849 static int buffer_prepare(struct vb2_buffer *vb)
 850 {
 851         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 852         struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
 853         unsigned long size;
 854
 855         dprintk(dev, 1, "%s, field=%d\n", __func__, vb->v4l2_buf.field);
 856
 857         BUG_ON(NULL == dev->fmt);
 858
 859         /*
 860          * Theses properties only change when queue is idle, see s_fmt.
 861          * The below checks should not be performed here, on each
 862          * buffer_prepare (i.e. on each qbuf). Most of the code in this function
 863          * should thus be moved to buffer_init and s_fmt.
 864          */
 865         if (dev->width  < 48 || dev->width  > MAX_WIDTH ||
 866             dev->height < 32 || dev->height > MAX_HEIGHT)
 867                 return -EINVAL;
 868
 869         size = dev->width * dev->height * dev->pixelsize;
 870         if (vb2_plane_size(vb, 0) < size) {
 871                 dprintk(dev, 1, "%s data will not fit into plane (%lu < %lu)\n",
 872                                 __func__, vb2_plane_size(vb, 0), size);
 873                 return -EINVAL;
 874         }
 875
 876         vb2_set_plane_payload(&buf->vb, 0, size);
 877
 878         buf->fmt = dev->fmt;
 879
 880         precalculate_bars(dev);
 881         precalculate_line(dev);
 882
 883         return 0;
 884 }
 885
 886 static void buffer_queue(struct vb2_buffer *vb)
 887 {
 888         struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
 889         struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
 890         struct vivi_dmaqueue *vidq = &dev->vidq;
 891         unsigned long flags = 0;
 892
 893         dprintk(dev, 1, "%s\n", __func__);
 894
 895         spin_lock_irqsave(&dev->slock, flags);
 896         list_add_tail(&buf->list, &vidq->active);
 897         spin_unlock_irqrestore(&dev->slock, flags);
 898 }
 899
 900 static int start_streaming(struct vb2_queue *vq, unsigned int count)
 901 {
 902         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 903         dprintk(dev, 1, "%s\n", __func__);
 904         return vivi_start_generating(dev);
 905 }
 906
 907 /* abort streaming and wait for last buffer */
 908 static int stop_streaming(struct vb2_queue *vq)
 909 {
 910         struct vivi_dev *dev = vb2_get_drv_priv(vq);
 911         dprintk(dev, 1, "%s\n", __func__);
 912         vivi_stop_generating(dev);
 913         return 0;
 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         precalculate_bars(dev);
1097         precalculate_line(dev);
1098         return 0;
1099 }
1100
1101 /* timeperframe is arbitrary and continous */
1102 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1103                                              struct v4l2_frmivalenum *fival)
1104 {
1105         const struct vivi_fmt *fmt;
1106
1107         if (fival->index)
1108                 return -EINVAL;
1109
1110         fmt = __get_format(fival->pixel_format);
1111         if (!fmt)
1112                 return -EINVAL;
1113
1114         /* regarding width & height - we support any */
1115
1116         fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
1117
1118         /* fill in stepwise (step=1.0 is requred by V4L2 spec) */
1119         fival->stepwise.min  = tpf_min;
1120         fival->stepwise.max  = tpf_max;
1121         fival->stepwise.step = (struct v4l2_fract) {1, 1};
1122
1123         return 0;
1124 }
1125
1126 static int vidioc_g_parm(struct file *file, void *priv,
1127                           struct v4l2_streamparm *parm)
1128 {
1129         struct vivi_dev *dev = video_drvdata(file);
1130
1131         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1132                 return -EINVAL;
1133
1134         parm->parm.capture.capability   = V4L2_CAP_TIMEPERFRAME;
1135         parm->parm.capture.timeperframe = dev->timeperframe;
1136         parm->parm.capture.readbuffers  = 1;
1137         return 0;
1138 }
1139
1140 #define FRACT_CMP(a, OP, b)     \
1141         ((u64)(a).numerator * (b).denominator  OP  (u64)(b).numerator * (a).denominator)
1142
1143 static int vidioc_s_parm(struct file *file, void *priv,
1144                           struct v4l2_streamparm *parm)
1145 {
1146         struct vivi_dev *dev = video_drvdata(file);
1147         struct v4l2_fract tpf;
1148
1149         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1150                 return -EINVAL;
1151
1152         tpf = parm->parm.capture.timeperframe;
1153
1154         /* tpf: {*, 0} resets timing; clip to [min, max]*/
1155         tpf = tpf.denominator ? tpf : tpf_default;
1156         tpf = FRACT_CMP(tpf, <, tpf_min) ? tpf_min : tpf;
1157         tpf = FRACT_CMP(tpf, >, tpf_max) ? tpf_max : tpf;
1158
1159         dev->timeperframe = tpf;
1160         parm->parm.capture.timeperframe = tpf;
1161         parm->parm.capture.readbuffers  = 1;
1162         return 0;
1163 }
1164
1165 /* --- controls ---------------------------------------------- */
1166
1167 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1168 {
1169         struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1170
1171         if (ctrl == dev->autogain)
1172                 dev->gain->val = jiffies & 0xff;
1173         return 0;
1174 }
1175
1176 static int vivi_s_ctrl(struct v4l2_ctrl *ctrl)
1177 {
1178         struct vivi_dev *dev = container_of(ctrl->handler, struct vivi_dev, ctrl_handler);
1179
1180         switch (ctrl->id) {
1181         case V4L2_CID_ALPHA_COMPONENT:
1182                 dev->alpha_component = ctrl->val;
1183                 break;
1184         default:
1185                 if (ctrl == dev->button)
1186                         dev->button_pressed = 30;
1187                 break;
1188         }
1189         return 0;
1190 }
1191
1192 /* ------------------------------------------------------------------
1193         File operations for the device
1194    ------------------------------------------------------------------*/
1195
1196 static const struct v4l2_ctrl_ops vivi_ctrl_ops = {
1197         .g_volatile_ctrl = vivi_g_volatile_ctrl,
1198         .s_ctrl = vivi_s_ctrl,
1199 };
1200
1201 #define VIVI_CID_CUSTOM_BASE    (V4L2_CID_USER_BASE | 0xf000)
1202
1203 static const struct v4l2_ctrl_config vivi_ctrl_button = {
1204         .ops = &vivi_ctrl_ops,
1205         .id = VIVI_CID_CUSTOM_BASE + 0,
1206         .name = "Button",
1207         .type = V4L2_CTRL_TYPE_BUTTON,
1208 };
1209
1210 static const struct v4l2_ctrl_config vivi_ctrl_boolean = {
1211         .ops = &vivi_ctrl_ops,
1212         .id = VIVI_CID_CUSTOM_BASE + 1,
1213         .name = "Boolean",
1214         .type = V4L2_CTRL_TYPE_BOOLEAN,
1215         .min = 0,
1216         .max = 1,
1217         .step = 1,
1218         .def = 1,
1219 };
1220
1221 static const struct v4l2_ctrl_config vivi_ctrl_int32 = {
1222         .ops = &vivi_ctrl_ops,
1223         .id = VIVI_CID_CUSTOM_BASE + 2,
1224         .name = "Integer 32 Bits",
1225         .type = V4L2_CTRL_TYPE_INTEGER,
1226         .min = 0x80000000,
1227         .max = 0x7fffffff,
1228         .step = 1,
1229 };
1230
1231 static const struct v4l2_ctrl_config vivi_ctrl_int64 = {
1232         .ops = &vivi_ctrl_ops,
1233         .id = VIVI_CID_CUSTOM_BASE + 3,
1234         .name = "Integer 64 Bits",
1235         .type = V4L2_CTRL_TYPE_INTEGER64,
1236 };
1237
1238 static const char * const vivi_ctrl_menu_strings[] = {
1239         "Menu Item 0 (Skipped)",
1240         "Menu Item 1",
1241         "Menu Item 2 (Skipped)",
1242         "Menu Item 3",
1243         "Menu Item 4",
1244         "Menu Item 5 (Skipped)",
1245         NULL,
1246 };
1247
1248 static const struct v4l2_ctrl_config vivi_ctrl_menu = {
1249         .ops = &vivi_ctrl_ops,
1250         .id = VIVI_CID_CUSTOM_BASE + 4,
1251         .name = "Menu",
1252         .type = V4L2_CTRL_TYPE_MENU,
1253         .min = 1,
1254         .max = 4,
1255         .def = 3,
1256         .menu_skip_mask = 0x04,
1257         .qmenu = vivi_ctrl_menu_strings,
1258 };
1259
1260 static const struct v4l2_ctrl_config vivi_ctrl_string = {
1261         .ops = &vivi_ctrl_ops,
1262         .id = VIVI_CID_CUSTOM_BASE + 5,
1263         .name = "String",
1264         .type = V4L2_CTRL_TYPE_STRING,
1265         .min = 2,
1266         .max = 4,
1267         .step = 1,
1268 };
1269
1270 static const struct v4l2_ctrl_config vivi_ctrl_bitmask = {
1271         .ops = &vivi_ctrl_ops,
1272         .id = VIVI_CID_CUSTOM_BASE + 6,
1273         .name = "Bitmask",
1274         .type = V4L2_CTRL_TYPE_BITMASK,
1275         .def = 0x80002000,
1276         .min = 0,
1277         .max = 0x80402010,
1278         .step = 0,
1279 };
1280
1281 static const s64 vivi_ctrl_int_menu_values[] = {
1282         1, 1, 2, 3, 5, 8, 13, 21, 42,
1283 };
1284
1285 static const struct v4l2_ctrl_config vivi_ctrl_int_menu = {
1286         .ops = &vivi_ctrl_ops,
1287         .id = VIVI_CID_CUSTOM_BASE + 7,
1288         .name = "Integer menu",
1289         .type = V4L2_CTRL_TYPE_INTEGER_MENU,
1290         .min = 1,
1291         .max = 8,
1292         .def = 4,
1293         .menu_skip_mask = 0x02,
1294         .qmenu_int = vivi_ctrl_int_menu_values,
1295 };
1296
1297 static const struct v4l2_file_operations vivi_fops = {
1298         .owner          = THIS_MODULE,
1299         .open           = v4l2_fh_open,
1300         .release        = vb2_fop_release,
1301         .read           = vb2_fop_read,
1302         .poll           = vb2_fop_poll,
1303         .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1304         .mmap           = vb2_fop_mmap,
1305 };
1306
1307 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1308         .vidioc_querycap      = vidioc_querycap,
1309         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1310         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1311         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1312         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1313         .vidioc_enum_framesizes   = vidioc_enum_framesizes,
1314         .vidioc_reqbufs       = vb2_ioctl_reqbufs,
1315         .vidioc_create_bufs   = vb2_ioctl_create_bufs,
1316         .vidioc_prepare_buf   = vb2_ioctl_prepare_buf,
1317         .vidioc_querybuf      = vb2_ioctl_querybuf,
1318         .vidioc_qbuf          = vb2_ioctl_qbuf,
1319         .vidioc_dqbuf         = vb2_ioctl_dqbuf,
1320         .vidioc_enum_input    = vidioc_enum_input,
1321         .vidioc_g_input       = vidioc_g_input,
1322         .vidioc_s_input       = vidioc_s_input,
1323         .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1324         .vidioc_g_parm        = vidioc_g_parm,
1325         .vidioc_s_parm        = vidioc_s_parm,
1326         .vidioc_streamon      = vb2_ioctl_streamon,
1327         .vidioc_streamoff     = vb2_ioctl_streamoff,
1328         .vidioc_log_status    = v4l2_ctrl_log_status,
1329         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1330         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1331 };
1332
1333 static const struct video_device vivi_template = {
1334         .name           = "vivi",
1335         .fops           = &vivi_fops,
1336         .ioctl_ops      = &vivi_ioctl_ops,
1337         .release        = video_device_release_empty,
1338 };
1339
1340 /* -----------------------------------------------------------------
1341         Initialization and module stuff
1342    ------------------------------------------------------------------*/
1343
1344 static int vivi_release(void)
1345 {
1346         struct vivi_dev *dev;
1347         struct list_head *list;
1348
1349         while (!list_empty(&vivi_devlist)) {
1350                 list = vivi_devlist.next;
1351                 list_del(list);
1352                 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1353
1354                 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1355                         video_device_node_name(&dev->vdev));
1356                 video_unregister_device(&dev->vdev);
1357                 v4l2_device_unregister(&dev->v4l2_dev);
1358                 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1359                 kfree(dev);
1360         }
1361
1362         return 0;
1363 }
1364
1365 static int __init vivi_create_instance(int inst)
1366 {
1367         struct vivi_dev *dev;
1368         struct video_device *vfd;
1369         struct v4l2_ctrl_handler *hdl;
1370         struct vb2_queue *q;
1371         int ret;
1372
1373         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1374         if (!dev)
1375                 return -ENOMEM;
1376
1377         snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1378                         "%s-%03d", VIVI_MODULE_NAME, inst);
1379         ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1380         if (ret)
1381                 goto free_dev;
1382
1383         dev->fmt = &formats[0];
1384         dev->timeperframe = tpf_default;
1385         dev->width = 640;
1386         dev->height = 480;
1387         dev->pixelsize = dev->fmt->depth / 8;
1388         hdl = &dev->ctrl_handler;
1389         v4l2_ctrl_handler_init(hdl, 11);
1390         dev->volume = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1391                         V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1392         dev->brightness = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1393                         V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1394         dev->contrast = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1395                         V4L2_CID_CONTRAST, 0, 255, 1, 16);
1396         dev->saturation = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1397                         V4L2_CID_SATURATION, 0, 255, 1, 127);
1398         dev->hue = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1399                         V4L2_CID_HUE, -128, 127, 1, 0);
1400         dev->autogain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1401                         V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1402         dev->gain = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1403                         V4L2_CID_GAIN, 0, 255, 1, 100);
1404         dev->alpha = v4l2_ctrl_new_std(hdl, &vivi_ctrl_ops,
1405                         V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1406         dev->button = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_button, NULL);
1407         dev->int32 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int32, NULL);
1408         dev->int64 = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int64, NULL);
1409         dev->boolean = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_boolean, NULL);
1410         dev->menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_menu, NULL);
1411         dev->string = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_string, NULL);
1412         dev->bitmask = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_bitmask, NULL);
1413         dev->int_menu = v4l2_ctrl_new_custom(hdl, &vivi_ctrl_int_menu, NULL);
1414         if (hdl->error) {
1415                 ret = hdl->error;
1416                 goto unreg_dev;
1417         }
1418         v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1419         dev->v4l2_dev.ctrl_handler = hdl;
1420
1421         /* initialize locks */
1422         spin_lock_init(&dev->slock);
1423
1424         /* initialize queue */
1425         q = &dev->vb_vidq;
1426         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1427         q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1428         q->drv_priv = dev;
1429         q->buf_struct_size = sizeof(struct vivi_buffer);
1430         q->ops = &vivi_video_qops;
1431         q->mem_ops = &vb2_vmalloc_memops;
1432
1433         ret = vb2_queue_init(q);
1434         if (ret)
1435                 goto unreg_dev;
1436
1437         mutex_init(&dev->mutex);
1438
1439         /* init video dma queues */
1440         INIT_LIST_HEAD(&dev->vidq.active);
1441         init_waitqueue_head(&dev->vidq.wq);
1442
1443         vfd = &dev->vdev;
1444         *vfd = vivi_template;
1445         vfd->debug = debug;
1446         vfd->v4l2_dev = &dev->v4l2_dev;
1447         vfd->queue = q;
1448         set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1449
1450         /*
1451          * Provide a mutex to v4l2 core. It will be used to protect
1452          * all fops and v4l2 ioctls.
1453          */
1454         vfd->lock = &dev->mutex;
1455         video_set_drvdata(vfd, dev);
1456
1457         ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1458         if (ret < 0)
1459                 goto unreg_dev;
1460
1461         /* Now that everything is fine, let's add it to device list */
1462         list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1463
1464         v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1465                   video_device_node_name(vfd));
1466         return 0;
1467
1468 unreg_dev:
1469         v4l2_ctrl_handler_free(hdl);
1470         v4l2_device_unregister(&dev->v4l2_dev);
1471 free_dev:
1472         kfree(dev);
1473         return ret;
1474 }
1475
1476 /* This routine allocates from 1 to n_devs virtual drivers.
1477
1478    The real maximum number of virtual drivers will depend on how many drivers
1479    will succeed. This is limited to the maximum number of devices that
1480    videodev supports, which is equal to VIDEO_NUM_DEVICES.
1481  */
1482 static int __init vivi_init(void)
1483 {
1484         const struct font_desc *font = find_font("VGA8x16");
1485         int ret = 0, i;
1486
1487         if (font == NULL) {
1488                 printk(KERN_ERR "vivi: could not find font\n");
1489                 return -ENODEV;
1490         }
1491         font8x16 = font->data;
1492
1493         if (n_devs <= 0)
1494                 n_devs = 1;
1495
1496         for (i = 0; i < n_devs; i++) {
1497                 ret = vivi_create_instance(i);
1498                 if (ret) {
1499                         /* If some instantiations succeeded, keep driver */
1500                         if (i)
1501                                 ret = 0;
1502                         break;
1503                 }
1504         }
1505
1506         if (ret < 0) {
1507                 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1508                 return ret;
1509         }
1510
1511         printk(KERN_INFO "Video Technology Magazine Virtual Video "
1512                         "Capture Board ver %s successfully loaded.\n",
1513                         VIVI_VERSION);
1514
1515         /* n_devs will reflect the actual number of allocated devices */
1516         n_devs = i;
1517
1518         return ret;
1519 }
1520
1521 static void __exit vivi_exit(void)
1522 {
1523         vivi_release();
1524 }
1525
1526 module_init(vivi_init);
1527 module_exit(vivi_exit);