SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the BSD Licence, GNU General Public License
  12  * as published by the Free Software Foundation; either version 2 of the
  13  * License, or (at your option) any later version
  14  */
  15 #include <linux/module.h>
  16 #include <linux/errno.h>
  17 #include <linux/kernel.h>
  18 #include <linux/init.h>
  19 #include <linux/sched.h>
  20 #include <linux/font.h>
  21 #include <linux/version.h>
  22 #include <linux/mutex.h>
  23 #include <linux/videodev2.h>
  24 #include <linux/kthread.h>
  25 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
  26 #include <linux/freezer.h>
  27 #endif
  28 #include <media/videobuf-vmalloc.h>
  29 #include <media/v4l2-device.h>
  30 #include <media/v4l2-ioctl.h>
  31 #include <media/v4l2-common.h>
  32
  33 #define VIVI_MODULE_NAME "vivi"
  34
  35 /* Wake up at about 30 fps */
  36 #define WAKE_NUMERATOR 30
  37 #define WAKE_DENOMINATOR 1001
  38 #define BUFFER_TIMEOUT     msecs_to_jiffies(500)  /* 0.5 seconds */
  39
  40 #define MAX_WIDTH 1920
  41 #define MAX_HEIGHT 1200
  42
  43 #define VIVI_MAJOR_VERSION 0
  44 #define VIVI_MINOR_VERSION 7
  45 #define VIVI_RELEASE 0
  46 #define VIVI_VERSION \
  47         KERNEL_VERSION(VIVI_MAJOR_VERSION, VIVI_MINOR_VERSION, VIVI_RELEASE)
  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
  53 static unsigned video_nr = -1;
  54 module_param(video_nr, uint, 0644);
  55 MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect");
  56
  57 static unsigned n_devs = 1;
  58 module_param(n_devs, uint, 0644);
  59 MODULE_PARM_DESC(n_devs, "number of video devices to create");
  60
  61 static unsigned debug;
  62 module_param(debug, uint, 0644);
  63 MODULE_PARM_DESC(debug, "activates debug info");
  64
  65 static unsigned int vid_limit = 16;
  66 module_param(vid_limit, uint, 0644);
  67 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
  68
  69 /* Global font descriptor */
  70 static const u8 *font8x16;
  71
  72 #define dprintk(dev, level, fmt, arg...) \
  73         v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
  74
  75 /* ------------------------------------------------------------------
  76         Basic structures
  77    ------------------------------------------------------------------*/
  78
  79 struct vivi_fmt {
  80         char  *name;
  81         u32   fourcc;          /* v4l2 format id */
  82         int   depth;
  83 };
  84
  85 static struct vivi_fmt formats[] = {
  86         {
  87                 .name     = "4:2:2, packed, YUYV",
  88                 .fourcc   = V4L2_PIX_FMT_YUYV,
  89                 .depth    = 16,
  90         },
  91         {
  92                 .name     = "4:2:2, packed, UYVY",
  93                 .fourcc   = V4L2_PIX_FMT_UYVY,
  94                 .depth    = 16,
  95         },
  96         {
  97                 .name     = "RGB565 (LE)",
  98                 .fourcc   = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
  99                 .depth    = 16,
 100         },
 101         {
 102                 .name     = "RGB565 (BE)",
 103                 .fourcc   = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
 104                 .depth    = 16,
 105         },
 106         {
 107                 .name     = "RGB555 (LE)",
 108                 .fourcc   = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
 109                 .depth    = 16,
 110         },
 111         {
 112                 .name     = "RGB555 (BE)",
 113                 .fourcc   = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
 114                 .depth    = 16,
 115         },
 116 };
 117
 118 static struct vivi_fmt *get_format(struct v4l2_format *f)
 119 {
 120         struct vivi_fmt *fmt;
 121         unsigned int k;
 122
 123         for (k = 0; k < ARRAY_SIZE(formats); k++) {
 124                 fmt = &formats[k];
 125                 if (fmt->fourcc == f->fmt.pix.pixelformat)
 126                         break;
 127         }
 128
 129         if (k == ARRAY_SIZE(formats))
 130                 return NULL;
 131
 132         return &formats[k];
 133 }
 134
 135 struct sg_to_addr {
 136         int pos;
 137         struct scatterlist *sg;
 138 };
 139
 140 /* buffer for one video frame */
 141 struct vivi_buffer {
 142         /* common v4l buffer stuff -- must be first */
 143         struct videobuf_buffer vb;
 144
 145         struct vivi_fmt        *fmt;
 146 };
 147
 148 struct vivi_dmaqueue {
 149         struct list_head       active;
 150
 151         /* thread for generating video stream*/
 152         struct task_struct         *kthread;
 153         wait_queue_head_t          wq;
 154         /* Counters to control fps rate */
 155         int                        frame;
 156         int                        ini_jiffies;
 157 };
 158
 159 static LIST_HEAD(vivi_devlist);
 160
 161 struct vivi_dev {
 162         struct list_head           vivi_devlist;
 163         struct v4l2_device         v4l2_dev;
 164
 165         /* controls */
 166         int                        brightness;
 167         int                        contrast;
 168         int                        saturation;
 169         int                        hue;
 170         int                        volume;
 171
 172         spinlock_t                 slock;
 173         struct mutex               mutex;
 174
 175         /* various device info */
 176         struct video_device        *vfd;
 177
 178         struct vivi_dmaqueue       vidq;
 179
 180         /* Several counters */
 181         unsigned                   ms;
 182         unsigned long              jiffies;
 183
 184         int                        mv_count;    /* Controls bars movement */
 185
 186         /* Input Number */
 187         int                        input;
 188
 189         /* video capture */
 190         struct vivi_fmt            *fmt;
 191         unsigned int               width, height;
 192         struct videobuf_queue      vb_vidq;
 193
 194         unsigned long              generating;
 195         u8                         bars[9][3];
 196         u8                         line[MAX_WIDTH * 4];
 197 };
 198
 199 /* ------------------------------------------------------------------
 200         DMA and thread functions
 201    ------------------------------------------------------------------*/
 202
 203 /* Bars and Colors should match positions */
 204
 205 enum colors {
 206         WHITE,
 207         AMBER,
 208         CYAN,
 209         GREEN,
 210         MAGENTA,
 211         RED,
 212         BLUE,
 213         BLACK,
 214         TEXT_BLACK,
 215 };
 216
 217 /* R   G   B */
 218 #define COLOR_WHITE     {204, 204, 204}
 219 #define COLOR_AMBER     {208, 208,   0}
 220 #define COLOR_CYAN      {  0, 206, 206}
 221 #define COLOR_GREEN     {  0, 239,   0}
 222 #define COLOR_MAGENTA   {239,   0, 239}
 223 #define COLOR_RED       {205,   0,   0}
 224 #define COLOR_BLUE      {  0,   0, 255}
 225 #define COLOR_BLACK     {  0,   0,   0}
 226
 227 struct bar_std {
 228         u8 bar[9][3];
 229 };
 230
 231 /* Maximum number of bars are 10 - otherwise, the input print code
 232    should be modified */
 233 static struct bar_std bars[] = {
 234         {       /* Standard ITU-R color bar sequence */
 235                 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
 236                   COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
 237         }, {
 238                 { COLOR_WHITE, COLOR_AMBER, COLOR_BLACK, COLOR_WHITE,
 239                   COLOR_AMBER, COLOR_BLACK, COLOR_WHITE, COLOR_AMBER, COLOR_BLACK }
 240         }, {
 241                 { COLOR_WHITE, COLOR_CYAN, COLOR_BLACK, COLOR_WHITE,
 242                   COLOR_CYAN, COLOR_BLACK, COLOR_WHITE, COLOR_CYAN, COLOR_BLACK }
 243         }, {
 244                 { COLOR_WHITE, COLOR_GREEN, COLOR_BLACK, COLOR_WHITE,
 245                   COLOR_GREEN, COLOR_BLACK, COLOR_WHITE, COLOR_GREEN, COLOR_BLACK }
 246         },
 247 };
 248
 249 #define NUM_INPUTS ARRAY_SIZE(bars)
 250
 251 #define TO_Y(r, g, b) \
 252         (((16829 * r + 33039 * g + 6416 * b  + 32768) >> 16) + 16)
 253 /* RGB to  V(Cr) Color transform */
 254 #define TO_V(r, g, b) \
 255         (((28784 * r - 24103 * g - 4681 * b  + 32768) >> 16) + 128)
 256 /* RGB to  U(Cb) Color transform */
 257 #define TO_U(r, g, b) \
 258         (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
 259
 260 /* precalculate color bar values to speed up rendering */
 261 static void precalculate_bars(struct vivi_dev *dev)
 262 {
 263         u8 r, g, b;
 264         int k, is_yuv;
 265
 266         for (k = 0; k < 9; k++) {
 267                 r = bars[dev->input].bar[k][0];
 268                 g = bars[dev->input].bar[k][1];
 269                 b = bars[dev->input].bar[k][2];
 270                 is_yuv = 0;
 271
 272                 switch (dev->fmt->fourcc) {
 273                 case V4L2_PIX_FMT_YUYV:
 274                 case V4L2_PIX_FMT_UYVY:
 275                         is_yuv = 1;
 276                         break;
 277                 case V4L2_PIX_FMT_RGB565:
 278                 case V4L2_PIX_FMT_RGB565X:
 279                         r >>= 3;
 280                         g >>= 2;
 281                         b >>= 3;
 282                         break;
 283                 case V4L2_PIX_FMT_RGB555:
 284                 case V4L2_PIX_FMT_RGB555X:
 285                         r >>= 3;
 286                         g >>= 3;
 287                         b >>= 3;
 288                         break;
 289                 }
 290
 291                 if (is_yuv) {
 292                         dev->bars[k][0] = TO_Y(r, g, b);        /* Luma */
 293                         dev->bars[k][1] = TO_U(r, g, b);        /* Cb */
 294                         dev->bars[k][2] = TO_V(r, g, b);        /* Cr */
 295                 } else {
 296                         dev->bars[k][0] = r;
 297                         dev->bars[k][1] = g;
 298                         dev->bars[k][2] = b;
 299                 }
 300         }
 301 }
 302
 303 #define TSTAMP_MIN_Y    24
 304 #define TSTAMP_MAX_Y    (TSTAMP_MIN_Y + 15)
 305 #define TSTAMP_INPUT_X  10
 306 #define TSTAMP_MIN_X    (54 + TSTAMP_INPUT_X)
 307
 308 static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos)
 309 {
 310         u8 r_y, g_u, b_v;
 311         int color;
 312         u8 *p;
 313
 314         r_y = dev->bars[colorpos][0]; /* R or precalculated Y */
 315         g_u = dev->bars[colorpos][1]; /* G or precalculated U */
 316         b_v = dev->bars[colorpos][2]; /* B or precalculated V */
 317
 318         for (color = 0; color < 4; color++) {
 319                 p = buf + color;
 320
 321                 switch (dev->fmt->fourcc) {
 322                 case V4L2_PIX_FMT_YUYV:
 323                         switch (color) {
 324                         case 0:
 325                         case 2:
 326                                 *p = r_y;
 327                                 break;
 328                         case 1:
 329                                 *p = g_u;
 330                                 break;
 331                         case 3:
 332                                 *p = b_v;
 333                                 break;
 334                         }
 335                         break;
 336                 case V4L2_PIX_FMT_UYVY:
 337                         switch (color) {
 338                         case 1:
 339                         case 3:
 340                                 *p = r_y;
 341                                 break;
 342                         case 0:
 343                                 *p = g_u;
 344                                 break;
 345                         case 2:
 346                                 *p = b_v;
 347                                 break;
 348                         }
 349                         break;
 350                 case V4L2_PIX_FMT_RGB565:
 351                         switch (color) {
 352                         case 0:
 353                         case 2:
 354                                 *p = (g_u << 5) | b_v;
 355                                 break;
 356                         case 1:
 357                         case 3:
 358                                 *p = (r_y << 3) | (g_u >> 3);
 359                                 break;
 360                         }
 361                         break;
 362                 case V4L2_PIX_FMT_RGB565X:
 363                         switch (color) {
 364                         case 0:
 365                         case 2:
 366                                 *p = (r_y << 3) | (g_u >> 3);
 367                                 break;
 368                         case 1:
 369                         case 3:
 370                                 *p = (g_u << 5) | b_v;
 371                                 break;
 372                         }
 373                         break;
 374                 case V4L2_PIX_FMT_RGB555:
 375                         switch (color) {
 376                         case 0:
 377                         case 2:
 378                                 *p = (g_u << 5) | b_v;
 379                                 break;
 380                         case 1:
 381                         case 3:
 382                                 *p = (r_y << 2) | (g_u >> 3);
 383                                 break;
 384                         }
 385                         break;
 386                 case V4L2_PIX_FMT_RGB555X:
 387                         switch (color) {
 388                         case 0:
 389                         case 2:
 390                                 *p = (r_y << 2) | (g_u >> 3);
 391                                 break;
 392                         case 1:
 393                         case 3:
 394                                 *p = (g_u << 5) | b_v;
 395                                 break;
 396                         }
 397                         break;
 398                 }
 399         }
 400 }
 401
 402 static void precalculate_line(struct vivi_dev *dev)
 403 {
 404         int w;
 405
 406         for (w = 0; w < dev->width * 2; w += 2) {
 407                 int colorpos = (w / (dev->width / 8) % 8);
 408
 409                 gen_twopix(dev, dev->line + w * 2, colorpos);
 410         }
 411 }
 412
 413 static void gen_text(struct vivi_dev *dev, char *basep,
 414                                         int y, int x, char *text)
 415 {
 416         int line;
 417
 418         /* Checks if it is possible to show string */
 419         if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
 420                 return;
 421
 422         /* Print stream time */
 423         for (line = y; line < y + 16; line++) {
 424                 int j = 0;
 425                 char *pos = basep + line * dev->width * 2 + x * 2;
 426                 char *s;
 427
 428                 for (s = text; *s; s++) {
 429                         u8 chr = font8x16[*s * 16 + line - y];
 430                         int i;
 431
 432                         for (i = 0; i < 7; i++, j++) {
 433                                 /* Draw white font on black background */
 434                                 if (chr & (1 << (7 - i)))
 435                                         gen_twopix(dev, pos + j * 2, WHITE);
 436                                 else
 437                                         gen_twopix(dev, pos + j * 2, TEXT_BLACK);
 438                         }
 439                 }
 440         }
 441 }
 442
 443 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
 444 {
 445         int hmax = buf->vb.height;
 446         int wmax = buf->vb.width;
 447         struct timeval ts;
 448         void *vbuf = videobuf_to_vmalloc(&buf->vb);
 449         unsigned ms;
 450         char str[100];
 451         int h, line = 1;
 452
 453         if (!vbuf)
 454                 return;
 455
 456         for (h = 0; h < hmax; h++)
 457                 memcpy(vbuf + h * wmax * 2, dev->line + (dev->mv_count % wmax) * 2, wmax * 2);
 458
 459         /* Updates stream time */
 460
 461         dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
 462         dev->jiffies = jiffies;
 463         ms = dev->ms;
 464         snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d ",
 465                         (ms / (60 * 60 * 1000)) % 24,
 466                         (ms / (60 * 1000)) % 60,
 467                         (ms / 1000) % 60,
 468                         ms % 1000);
 469         gen_text(dev, vbuf, line++ * 16, 16, str);
 470         snprintf(str, sizeof(str), " %dx%d, input %d ",
 471                         dev->width, dev->height, dev->input);
 472         gen_text(dev, vbuf, line++ * 16, 16, str);
 473
 474         snprintf(str, sizeof(str), " brightness %3d, contrast %3d, saturation %3d, hue %d ",
 475                         dev->brightness,
 476                         dev->contrast,
 477                         dev->saturation,
 478                         dev->hue);
 479         gen_text(dev, vbuf, line++ * 16, 16, str);
 480         snprintf(str, sizeof(str), " volume %3d ", dev->volume);
 481         gen_text(dev, vbuf, line++ * 16, 16, str);
 482
 483         dev->mv_count += 2;
 484
 485         /* Advice that buffer was filled */
 486         buf->vb.field_count++;
 487         do_gettimeofday(&ts);
 488         buf->vb.ts = ts;
 489         buf->vb.state = VIDEOBUF_DONE;
 490 }
 491
 492 static void vivi_thread_tick(struct vivi_dev *dev)
 493 {
 494         struct vivi_dmaqueue *dma_q = &dev->vidq;
 495         struct vivi_buffer *buf;
 496         unsigned long flags = 0;
 497
 498         dprintk(dev, 1, "Thread tick\n");
 499
 500         spin_lock_irqsave(&dev->slock, flags);
 501         if (list_empty(&dma_q->active)) {
 502                 dprintk(dev, 1, "No active queue to serve\n");
 503                 goto unlock;
 504         }
 505
 506         buf = list_entry(dma_q->active.next,
 507                          struct vivi_buffer, vb.queue);
 508
 509         /* Nobody is waiting on this buffer, return */
 510         if (!waitqueue_active(&buf->vb.done))
 511                 goto unlock;
 512
 513         list_del(&buf->vb.queue);
 514
 515         do_gettimeofday(&buf->vb.ts);
 516
 517         /* Fill buffer */
 518         vivi_fillbuff(dev, buf);
 519         dprintk(dev, 1, "filled buffer %p\n", buf);
 520
 521         wake_up(&buf->vb.done);
 522         dprintk(dev, 2, "[%p/%d] wakeup\n", buf, buf->vb. i);
 523 unlock:
 524         spin_unlock_irqrestore(&dev->slock, flags);
 525 }
 526
 527 #define frames_to_ms(frames)                                    \
 528         ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
 529
 530 static void vivi_sleep(struct vivi_dev *dev)
 531 {
 532         struct vivi_dmaqueue *dma_q = &dev->vidq;
 533         int timeout;
 534         DECLARE_WAITQUEUE(wait, current);
 535
 536         dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
 537                 (unsigned long)dma_q);
 538
 539         add_wait_queue(&dma_q->wq, &wait);
 540         if (kthread_should_stop())
 541                 goto stop_task;
 542
 543         /* Calculate time to wake up */
 544         timeout = msecs_to_jiffies(frames_to_ms(1));
 545
 546         vivi_thread_tick(dev);
 547
 548         schedule_timeout_interruptible(timeout);
 549
 550 stop_task:
 551         remove_wait_queue(&dma_q->wq, &wait);
 552         try_to_freeze();
 553 }
 554
 555 static int vivi_thread(void *data)
 556 {
 557         struct vivi_dev *dev = data;
 558
 559         dprintk(dev, 1, "thread started\n");
 560
 561         set_freezable();
 562
 563         for (;;) {
 564                 vivi_sleep(dev);
 565
 566                 if (kthread_should_stop())
 567                         break;
 568         }
 569         dprintk(dev, 1, "thread: exit\n");
 570         return 0;
 571 }
 572
 573 static void vivi_start_generating(struct file *file)
 574 {
 575         struct vivi_dev *dev = video_drvdata(file);
 576         struct vivi_dmaqueue *dma_q = &dev->vidq;
 577
 578         dprintk(dev, 1, "%s\n", __func__);
 579
 580         if (test_and_set_bit(0, &dev->generating))
 581                 return;
 582         file->private_data = dev;
 583
 584         /* Resets frame counters */
 585         dev->ms = 0;
 586         dev->mv_count = 0;
 587         dev->jiffies = jiffies;
 588
 589         dma_q->frame = 0;
 590         dma_q->ini_jiffies = jiffies;
 591         dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
 592
 593         if (IS_ERR(dma_q->kthread)) {
 594                 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
 595                 clear_bit(0, &dev->generating);
 596                 return;
 597         }
 598         /* Wakes thread */
 599         wake_up_interruptible(&dma_q->wq);
 600
 601         dprintk(dev, 1, "returning from %s\n", __func__);
 602 }
 603
 604 static void vivi_stop_generating(struct file *file)
 605 {
 606         struct vivi_dev *dev = video_drvdata(file);
 607         struct vivi_dmaqueue *dma_q = &dev->vidq;
 608
 609         dprintk(dev, 1, "%s\n", __func__);
 610
 611         if (!file->private_data)
 612                 return;
 613         if (!test_and_clear_bit(0, &dev->generating))
 614                 return;
 615
 616         /* shutdown control thread */
 617         if (dma_q->kthread) {
 618                 kthread_stop(dma_q->kthread);
 619                 dma_q->kthread = NULL;
 620         }
 621         videobuf_stop(&dev->vb_vidq);
 622         videobuf_mmap_free(&dev->vb_vidq);
 623 }
 624
 625 static int vivi_is_generating(struct vivi_dev *dev)
 626 {
 627         return test_bit(0, &dev->generating);
 628 }
 629
 630 /* ------------------------------------------------------------------
 631         Videobuf operations
 632    ------------------------------------------------------------------*/
 633 static int
 634 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
 635 {
 636         struct vivi_dev *dev = vq->priv_data;
 637
 638         *size = dev->width * dev->height * 2;
 639
 640         if (0 == *count)
 641                 *count = 32;
 642
 643         while (*size * *count > vid_limit * 1024 * 1024)
 644                 (*count)--;
 645
 646         dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__,
 647                 *count, *size);
 648
 649         return 0;
 650 }
 651
 652 static void free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
 653 {
 654         struct vivi_dev *dev = vq->priv_data;
 655
 656         dprintk(dev, 1, "%s, state: %i\n", __func__, buf->vb.state);
 657
 658         videobuf_vmalloc_free(&buf->vb);
 659         dprintk(dev, 1, "free_buffer: freed\n");
 660         buf->vb.state = VIDEOBUF_NEEDS_INIT;
 661 }
 662
 663 static int
 664 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
 665                                                 enum v4l2_field field)
 666 {
 667         struct vivi_dev *dev = vq->priv_data;
 668         struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
 669         int rc;
 670
 671         dprintk(dev, 1, "%s, field=%d\n", __func__, field);
 672
 673         BUG_ON(NULL == dev->fmt);
 674
 675         if (dev->width  < 48 || dev->width  > MAX_WIDTH ||
 676             dev->height < 32 || dev->height > MAX_HEIGHT)
 677                 return -EINVAL;
 678
 679         buf->vb.size = dev->width * dev->height * 2;
 680         if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
 681                 return -EINVAL;
 682
 683         /* These properties only change when queue is idle, see s_fmt */
 684         buf->fmt       = dev->fmt;
 685         buf->vb.width  = dev->width;
 686         buf->vb.height = dev->height;
 687         buf->vb.field  = field;
 688
 689         precalculate_bars(dev);
 690         precalculate_line(dev);
 691
 692         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
 693                 rc = videobuf_iolock(vq, &buf->vb, NULL);
 694                 if (rc < 0)
 695                         goto fail;
 696         }
 697
 698         buf->vb.state = VIDEOBUF_PREPARED;
 699         return 0;
 700
 701 fail:
 702         free_buffer(vq, buf);
 703         return rc;
 704 }
 705
 706 static void
 707 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 708 {
 709         struct vivi_dev *dev = vq->priv_data;
 710         struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
 711         struct vivi_dmaqueue *vidq = &dev->vidq;
 712
 713         dprintk(dev, 1, "%s\n", __func__);
 714
 715         buf->vb.state = VIDEOBUF_QUEUED;
 716         list_add_tail(&buf->vb.queue, &vidq->active);
 717 }
 718
 719 static void buffer_release(struct videobuf_queue *vq,
 720                            struct videobuf_buffer *vb)
 721 {
 722         struct vivi_dev *dev = vq->priv_data;
 723         struct vivi_buffer *buf  = container_of(vb, struct vivi_buffer, vb);
 724
 725         dprintk(dev, 1, "%s\n", __func__);
 726
 727         free_buffer(vq, buf);
 728 }
 729
 730 static struct videobuf_queue_ops vivi_video_qops = {
 731         .buf_setup      = buffer_setup,
 732         .buf_prepare    = buffer_prepare,
 733         .buf_queue      = buffer_queue,
 734         .buf_release    = buffer_release,
 735 };
 736
 737 /* ------------------------------------------------------------------
 738         IOCTL vidioc handling
 739    ------------------------------------------------------------------*/
 740 static int vidioc_querycap(struct file *file, void  *priv,
 741                                         struct v4l2_capability *cap)
 742 {
 743         struct vivi_dev *dev = video_drvdata(file);
 744
 745         strcpy(cap->driver, "vivi");
 746         strcpy(cap->card, "vivi");
 747         strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
 748         cap->version = VIVI_VERSION;
 749         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | \
 750                             V4L2_CAP_READWRITE;
 751         return 0;
 752 }
 753
 754 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
 755                                         struct v4l2_fmtdesc *f)
 756 {
 757         struct vivi_fmt *fmt;
 758
 759         if (f->index >= ARRAY_SIZE(formats))
 760                 return -EINVAL;
 761
 762         fmt = &formats[f->index];
 763
 764         strlcpy(f->description, fmt->name, sizeof(f->description));
 765         f->pixelformat = fmt->fourcc;
 766         return 0;
 767 }
 768
 769 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 770                                         struct v4l2_format *f)
 771 {
 772         struct vivi_dev *dev = video_drvdata(file);
 773
 774         f->fmt.pix.width        = dev->width;
 775         f->fmt.pix.height       = dev->height;
 776         f->fmt.pix.field        = dev->vb_vidq.field;
 777         f->fmt.pix.pixelformat  = dev->fmt->fourcc;
 778         f->fmt.pix.bytesperline =
 779                 (f->fmt.pix.width * dev->fmt->depth) >> 3;
 780         f->fmt.pix.sizeimage =
 781                 f->fmt.pix.height * f->fmt.pix.bytesperline;
 782         return 0;
 783 }
 784
 785 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 786                         struct v4l2_format *f)
 787 {
 788         struct vivi_dev *dev = video_drvdata(file);
 789         struct vivi_fmt *fmt;
 790         enum v4l2_field field;
 791
 792         fmt = get_format(f);
 793         if (!fmt) {
 794                 dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
 795                         f->fmt.pix.pixelformat);
 796                 return -EINVAL;
 797         }
 798
 799         field = f->fmt.pix.field;
 800
 801         if (field == V4L2_FIELD_ANY) {
 802                 field = V4L2_FIELD_INTERLACED;
 803         } else if (V4L2_FIELD_INTERLACED != field) {
 804                 dprintk(dev, 1, "Field type invalid.\n");
 805                 return -EINVAL;
 806         }
 807
 808         f->fmt.pix.field = field;
 809         v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,
 810                               &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);
 811         f->fmt.pix.bytesperline =
 812                 (f->fmt.pix.width * fmt->depth) >> 3;
 813         f->fmt.pix.sizeimage =
 814                 f->fmt.pix.height * f->fmt.pix.bytesperline;
 815         return 0;
 816 }
 817
 818 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 819                                         struct v4l2_format *f)
 820 {
 821         struct vivi_dev *dev = video_drvdata(file);
 822         struct videobuf_queue *q = &dev->vb_vidq;
 823
 824         int ret = vidioc_try_fmt_vid_cap(file, priv, f);
 825         if (ret < 0)
 826                 return ret;
 827
 828         mutex_lock(&q->vb_lock);
 829
 830         if (vivi_is_generating(dev)) {
 831                 dprintk(dev, 1, "%s device busy\n", __func__);
 832                 ret = -EBUSY;
 833                 goto out;
 834         }
 835
 836         dev->fmt = get_format(f);
 837         dev->width = f->fmt.pix.width;
 838         dev->height = f->fmt.pix.height;
 839         dev->vb_vidq.field = f->fmt.pix.field;
 840         ret = 0;
 841 out:
 842         mutex_unlock(&q->vb_lock);
 843         return ret;
 844 }
 845
 846 static int vidioc_reqbufs(struct file *file, void *priv,
 847                           struct v4l2_requestbuffers *p)
 848 {
 849         struct vivi_dev *dev = video_drvdata(file);
 850
 851         return videobuf_reqbufs(&dev->vb_vidq, p);
 852 }
 853
 854 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
 855 {
 856         struct vivi_dev *dev = video_drvdata(file);
 857
 858         return videobuf_querybuf(&dev->vb_vidq, p);
 859 }
 860
 861 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
 862 {
 863         struct vivi_dev *dev = video_drvdata(file);
 864
 865         return videobuf_qbuf(&dev->vb_vidq, p);
 866 }
 867
 868 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
 869 {
 870         struct vivi_dev *dev = video_drvdata(file);
 871
 872         return videobuf_dqbuf(&dev->vb_vidq, p,
 873                                 file->f_flags & O_NONBLOCK);
 874 }
 875
 876 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 877 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
 878 {
 879         struct vivi_dev *dev = video_drvdata(file);
 880
 881         return videobuf_cgmbuf(&dev->vb_vidq, mbuf, 8);
 882 }
 883 #endif
 884
 885 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
 886 {
 887         struct vivi_dev *dev = video_drvdata(file);
 888         int ret;
 889
 890         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 891                 return -EINVAL;
 892         ret = videobuf_streamon(&dev->vb_vidq);
 893         if (ret)
 894                 return ret;
 895
 896         vivi_start_generating(file);
 897         return 0;
 898 }
 899
 900 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
 901 {
 902         struct vivi_dev *dev = video_drvdata(file);
 903         int ret;
 904
 905         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 906                 return -EINVAL;
 907         ret = videobuf_streamoff(&dev->vb_vidq);
 908         if (!ret)
 909                 vivi_stop_generating(file);
 910         return ret;
 911 }
 912
 913 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
 914 {
 915         return 0;
 916 }
 917
 918 /* only one input in this sample driver */
 919 static int vidioc_enum_input(struct file *file, void *priv,
 920                                 struct v4l2_input *inp)
 921 {
 922         if (inp->index >= NUM_INPUTS)
 923                 return -EINVAL;
 924
 925         inp->type = V4L2_INPUT_TYPE_CAMERA;
 926         inp->std = V4L2_STD_525_60;
 927         sprintf(inp->name, "Camera %u", inp->index);
 928         return 0;
 929 }
 930
 931 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 932 {
 933         struct vivi_dev *dev = video_drvdata(file);
 934
 935         *i = dev->input;
 936         return 0;
 937 }
 938
 939 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 940 {
 941         struct vivi_dev *dev = video_drvdata(file);
 942
 943         if (i >= NUM_INPUTS)
 944                 return -EINVAL;
 945
 946         dev->input = i;
 947         precalculate_bars(dev);
 948         precalculate_line(dev);
 949         return 0;
 950 }
 951
 952 /* --- controls ---------------------------------------------- */
 953 static int vidioc_queryctrl(struct file *file, void *priv,
 954                             struct v4l2_queryctrl *qc)
 955 {
 956         switch (qc->id) {
 957         case V4L2_CID_AUDIO_VOLUME:
 958                 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 200);
 959         case V4L2_CID_BRIGHTNESS:
 960                 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 127);
 961         case V4L2_CID_CONTRAST:
 962                 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 16);
 963         case V4L2_CID_SATURATION:
 964                 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 127);
 965         case V4L2_CID_HUE:
 966                 return v4l2_ctrl_query_fill(qc, -128, 127, 1, 0);
 967         }
 968         return -EINVAL;
 969 }
 970
 971 static int vidioc_g_ctrl(struct file *file, void *priv,
 972                          struct v4l2_control *ctrl)
 973 {
 974         struct vivi_dev *dev = video_drvdata(file);
 975
 976         switch (ctrl->id) {
 977         case V4L2_CID_AUDIO_VOLUME:
 978                 ctrl->value = dev->volume;
 979                 return 0;
 980         case V4L2_CID_BRIGHTNESS:
 981                 ctrl->value = dev->brightness;
 982                 return 0;
 983         case V4L2_CID_CONTRAST:
 984                 ctrl->value = dev->contrast;
 985                 return 0;
 986         case V4L2_CID_SATURATION:
 987                 ctrl->value = dev->saturation;
 988                 return 0;
 989         case V4L2_CID_HUE:
 990                 ctrl->value = dev->hue;
 991                 return 0;
 992         }
 993         return -EINVAL;
 994 }
 995
 996 static int vidioc_s_ctrl(struct file *file, void *priv,
 997                                 struct v4l2_control *ctrl)
 998 {
 999         struct vivi_dev *dev = video_drvdata(file);
1000         struct v4l2_queryctrl qc;
1001         int err;
1002
1003         qc.id = ctrl->id;
1004         err = vidioc_queryctrl(file, priv, &qc);
1005         if (err < 0)
1006                 return err;
1007         if (ctrl->value < qc.minimum || ctrl->value > qc.maximum)
1008                 return -ERANGE;
1009         switch (ctrl->id) {
1010         case V4L2_CID_AUDIO_VOLUME:
1011                 dev->volume = ctrl->value;
1012                 return 0;
1013         case V4L2_CID_BRIGHTNESS:
1014                 dev->brightness = ctrl->value;
1015                 return 0;
1016         case V4L2_CID_CONTRAST:
1017                 dev->contrast = ctrl->value;
1018                 return 0;
1019         case V4L2_CID_SATURATION:
1020                 dev->saturation = ctrl->value;
1021                 return 0;
1022         case V4L2_CID_HUE:
1023                 dev->hue = ctrl->value;
1024                 return 0;
1025         }
1026         return -EINVAL;
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         vivi_start_generating(file);
1039         return videobuf_read_stream(&dev->vb_vidq, data, count, ppos, 0,
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 videobuf_queue *q = &dev->vb_vidq;
1048
1049         dprintk(dev, 1, "%s\n", __func__);
1050
1051         vivi_start_generating(file);
1052         return videobuf_poll_stream(file, q, wait);
1053 }
1054
1055 static int vivi_close(struct file *file)
1056 {
1057         struct video_device  *vdev = video_devdata(file);
1058         struct vivi_dev *dev = video_drvdata(file);
1059
1060         vivi_stop_generating(file);
1061
1062         dprintk(dev, 1, "close called (dev=%s)\n",
1063                 video_device_node_name(vdev));
1064         return 0;
1065 }
1066
1067 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
1068 {
1069         struct vivi_dev *dev = video_drvdata(file);
1070         int ret;
1071
1072         dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1073
1074         ret = videobuf_mmap_mapper(&dev->vb_vidq, vma);
1075
1076         dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1077                 (unsigned long)vma->vm_start,
1078                 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
1079                 ret);
1080         return ret;
1081 }
1082
1083 static const struct v4l2_file_operations vivi_fops = {
1084         .owner          = THIS_MODULE,
1085         .release        = vivi_close,
1086         .read           = vivi_read,
1087         .poll           = vivi_poll,
1088         .ioctl          = video_ioctl2, /* V4L2 ioctl handler */
1089         .mmap           = vivi_mmap,
1090 };
1091
1092 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1093         .vidioc_querycap      = vidioc_querycap,
1094         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1095         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1096         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1097         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1098         .vidioc_reqbufs       = vidioc_reqbufs,
1099         .vidioc_querybuf      = vidioc_querybuf,
1100         .vidioc_qbuf          = vidioc_qbuf,
1101         .vidioc_dqbuf         = vidioc_dqbuf,
1102         .vidioc_s_std         = vidioc_s_std,
1103         .vidioc_enum_input    = vidioc_enum_input,
1104         .vidioc_g_input       = vidioc_g_input,
1105         .vidioc_s_input       = vidioc_s_input,
1106         .vidioc_streamon      = vidioc_streamon,
1107         .vidioc_streamoff     = vidioc_streamoff,
1108         .vidioc_queryctrl     = vidioc_queryctrl,
1109         .vidioc_g_ctrl        = vidioc_g_ctrl,
1110         .vidioc_s_ctrl        = vidioc_s_ctrl,
1111 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1112         .vidiocgmbuf          = vidiocgmbuf,
1113 #endif
1114 };
1115
1116 static struct video_device vivi_template = {
1117         .name           = "vivi",
1118         .fops           = &vivi_fops,
1119         .ioctl_ops      = &vivi_ioctl_ops,
1120         .release        = video_device_release,
1121
1122         .tvnorms              = V4L2_STD_525_60,
1123         .current_norm         = V4L2_STD_NTSC_M,
1124 };
1125
1126 /* -----------------------------------------------------------------
1127         Initialization and module stuff
1128    ------------------------------------------------------------------*/
1129
1130 static int vivi_release(void)
1131 {
1132         struct vivi_dev *dev;
1133         struct list_head *list;
1134
1135         while (!list_empty(&vivi_devlist)) {
1136                 list = vivi_devlist.next;
1137                 list_del(list);
1138                 dev = list_entry(list, struct vivi_dev, vivi_devlist);
1139
1140                 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1141                         video_device_node_name(dev->vfd));
1142                 video_unregister_device(dev->vfd);
1143                 v4l2_device_unregister(&dev->v4l2_dev);
1144                 kfree(dev);
1145         }
1146
1147         return 0;
1148 }
1149
1150 static int __init vivi_create_instance(int inst)
1151 {
1152         struct vivi_dev *dev;
1153         struct video_device *vfd;
1154         int ret;
1155
1156         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1157         if (!dev)
1158                 return -ENOMEM;
1159
1160         snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1161                         "%s-%03d", VIVI_MODULE_NAME, inst);
1162         ret = v4l2_device_register(NULL, &dev->v4l2_dev);
1163         if (ret)
1164                 goto free_dev;
1165
1166         dev->fmt = &formats[0];
1167         dev->width = 640;
1168         dev->height = 480;
1169         dev->volume = 200;
1170         dev->brightness = 127;
1171         dev->contrast = 16;
1172         dev->saturation = 127;
1173         dev->hue = 0;
1174
1175         videobuf_queue_vmalloc_init(&dev->vb_vidq, &vivi_video_qops,
1176                         NULL, &dev->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
1177                         V4L2_FIELD_INTERLACED,
1178                         sizeof(struct vivi_buffer), dev);
1179
1180         /* init video dma queues */
1181         INIT_LIST_HEAD(&dev->vidq.active);
1182         init_waitqueue_head(&dev->vidq.wq);
1183
1184         /* initialize locks */
1185         spin_lock_init(&dev->slock);
1186         mutex_init(&dev->mutex);
1187
1188         ret = -ENOMEM;
1189         vfd = video_device_alloc();
1190         if (!vfd)
1191                 goto unreg_dev;
1192
1193         *vfd = vivi_template;
1194         vfd->debug = debug;
1195         vfd->v4l2_dev = &dev->v4l2_dev;
1196
1197         ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
1198         if (ret < 0)
1199                 goto rel_vdev;
1200
1201         video_set_drvdata(vfd, dev);
1202
1203         /* Now that everything is fine, let's add it to device list */
1204         list_add_tail(&dev->vivi_devlist, &vivi_devlist);
1205
1206         if (video_nr != -1)
1207                 video_nr++;
1208
1209         dev->vfd = vfd;
1210         v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1211                   video_device_node_name(vfd));
1212         return 0;
1213
1214 rel_vdev:
1215         video_device_release(vfd);
1216 unreg_dev:
1217         v4l2_device_unregister(&dev->v4l2_dev);
1218 free_dev:
1219         kfree(dev);
1220         return ret;
1221 }
1222
1223 /* This routine allocates from 1 to n_devs virtual drivers.
1224
1225    The real maximum number of virtual drivers will depend on how many drivers
1226    will succeed. This is limited to the maximum number of devices that
1227    videodev supports, which is equal to VIDEO_NUM_DEVICES.
1228  */
1229 static int __init vivi_init(void)
1230 {
1231         const struct font_desc *font = find_font("VGA8x16");
1232         int ret = 0, i;
1233
1234         if (font == NULL) {
1235                 printk(KERN_ERR "vivi: could not find font\n");
1236                 return -ENODEV;
1237         }
1238         font8x16 = font->data;
1239
1240         if (n_devs <= 0)
1241                 n_devs = 1;
1242
1243         for (i = 0; i < n_devs; i++) {
1244                 ret = vivi_create_instance(i);
1245                 if (ret) {
1246                         /* If some instantiations succeeded, keep driver */
1247                         if (i)
1248                                 ret = 0;
1249                         break;
1250                 }
1251         }
1252
1253         if (ret < 0) {
1254                 printk(KERN_ERR "vivi: error %d while loading driver\n", ret);
1255                 return ret;
1256         }
1257
1258         printk(KERN_INFO "Video Technology Magazine Virtual Video "
1259                         "Capture Board ver %u.%u.%u successfully loaded.\n",
1260                         (VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
1261                         VIVI_VERSION & 0xFF);
1262
1263         /* n_devs will reflect the actual number of allocated devices */
1264         n_devs = i;
1265
1266         return ret;
1267 }
1268
1269 static void __exit vivi_exit(void)
1270 {
1271         vivi_release();
1272 }
1273
1274 module_init(vivi_init);
1275 module_exit(vivi_exit);