drivers/media/video/vivi.c

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