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 49MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board"); 50MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol"); 51MODULE_LICENSE("Dual BSD/GPL"); 52MODULE_VERSION(VIVI_VERSION); 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 136/* buffer for one video frame */ 137struct 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 144struct 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 155static LIST_HEAD(vivi_devlist); 156 157struct 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 216enum 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 238struct 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 */ 244static 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 */ 272static 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 319static 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 413static 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 424static 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 454static 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 523static 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 555static 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 575stop_task: 576 remove_wait_queue(&dma_q->wq, &wait); 577 try_to_freeze(); 578} 579 580static 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 598static 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 624static 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 ------------------------------------------------------------------*/ 653static 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 683static 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 704static 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 741static 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 748static 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 755static 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 769static 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 */ 777static 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 785static 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 791static 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 798static 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 ------------------------------------------------------------------*/ 814static 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 827static 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 842static 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 863static 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 901static 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 924static 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 931static 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 937static 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 943static 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 949static 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 955static 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 961static 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 969static 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 */ 975static 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 987static 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 995static 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 1011static 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 1024static 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 1033static 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 1046static ssize_t 1047vivi_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 1056static unsigned int 1057vivi_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 1073static 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 1086static 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 1101static 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 1108static 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 1115static 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 1126static 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 1136static 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 1143static 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 1153static 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 1165static 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 1175static 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 1186static 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 1196static 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 1217static 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 1231static 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 1252static 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 1357rel_vdev: 1358 video_device_release(vfd); 1359unreg_dev: 1360 v4l2_ctrl_handler_free(hdl); 1361 v4l2_device_unregister(&dev->v4l2_dev); 1362free_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 */ 1373static 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 1412static void __exit vivi_exit(void) 1413{ 1414 vivi_release(); 1415} 1416 1417module_init(vivi_init); 1418module_exit(vivi_exit); 1419