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