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