1 /* 2 * Copyright (C) 2010-2013 Bluecherry, LLC <http://www.bluecherrydvr.com> 3 * 4 * Original author: 5 * Ben Collins <bcollins@ubuntu.com> 6 * 7 * Additional work by: 8 * John Brooks <john.brooks@bluecherry.net> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 */ 20 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/kthread.h> 24 #include <linux/freezer.h> 25 26 #include <media/v4l2-ioctl.h> 27 #include <media/v4l2-common.h> 28 #include <media/v4l2-event.h> 29 #include <media/videobuf2-v4l2.h> 30 #include <media/videobuf2-dma-contig.h> 31 32 #include "solo6x10.h" 33 #include "solo6x10-tw28.h" 34 35 /* Image size is two fields, SOLO_HW_BPL is one horizontal line in hardware */ 36 #define SOLO_HW_BPL 2048 37 #define solo_vlines(__solo) (__solo->video_vsize * 2) 38 #define solo_image_size(__solo) (solo_bytesperline(__solo) * \ 39 solo_vlines(__solo)) 40 #define solo_bytesperline(__solo) (__solo->video_hsize * 2) 41 42 #define MIN_VID_BUFFERS 2 43 44 static inline void erase_on(struct solo_dev *solo_dev) 45 { 46 solo_reg_write(solo_dev, SOLO_VO_DISP_ERASE, SOLO_VO_DISP_ERASE_ON); 47 solo_dev->erasing = 1; 48 solo_dev->frame_blank = 0; 49 } 50 51 static inline int erase_off(struct solo_dev *solo_dev) 52 { 53 if (!solo_dev->erasing) 54 return 0; 55 56 /* First time around, assert erase off */ 57 if (!solo_dev->frame_blank) 58 solo_reg_write(solo_dev, SOLO_VO_DISP_ERASE, 0); 59 /* Keep the erasing flag on for 8 frames minimum */ 60 if (solo_dev->frame_blank++ >= 8) 61 solo_dev->erasing = 0; 62 63 return 1; 64 } 65 66 void solo_video_in_isr(struct solo_dev *solo_dev) 67 { 68 wake_up_interruptible_all(&solo_dev->disp_thread_wait); 69 } 70 71 static void solo_win_setup(struct solo_dev *solo_dev, u8 ch, 72 int sx, int sy, int ex, int ey, int scale) 73 { 74 if (ch >= solo_dev->nr_chans) 75 return; 76 77 /* Here, we just keep window/channel the same */ 78 solo_reg_write(solo_dev, SOLO_VI_WIN_CTRL0(ch), 79 SOLO_VI_WIN_CHANNEL(ch) | 80 SOLO_VI_WIN_SX(sx) | 81 SOLO_VI_WIN_EX(ex) | 82 SOLO_VI_WIN_SCALE(scale)); 83 84 solo_reg_write(solo_dev, SOLO_VI_WIN_CTRL1(ch), 85 SOLO_VI_WIN_SY(sy) | 86 SOLO_VI_WIN_EY(ey)); 87 } 88 89 static int solo_v4l2_ch_ext_4up(struct solo_dev *solo_dev, u8 idx, int on) 90 { 91 u8 ch = idx * 4; 92 93 if (ch >= solo_dev->nr_chans) 94 return -EINVAL; 95 96 if (!on) { 97 u8 i; 98 99 for (i = ch; i < ch + 4; i++) 100 solo_win_setup(solo_dev, i, solo_dev->video_hsize, 101 solo_vlines(solo_dev), 102 solo_dev->video_hsize, 103 solo_vlines(solo_dev), 0); 104 return 0; 105 } 106 107 /* Row 1 */ 108 solo_win_setup(solo_dev, ch, 0, 0, solo_dev->video_hsize / 2, 109 solo_vlines(solo_dev) / 2, 3); 110 solo_win_setup(solo_dev, ch + 1, solo_dev->video_hsize / 2, 0, 111 solo_dev->video_hsize, solo_vlines(solo_dev) / 2, 3); 112 /* Row 2 */ 113 solo_win_setup(solo_dev, ch + 2, 0, solo_vlines(solo_dev) / 2, 114 solo_dev->video_hsize / 2, solo_vlines(solo_dev), 3); 115 solo_win_setup(solo_dev, ch + 3, solo_dev->video_hsize / 2, 116 solo_vlines(solo_dev) / 2, solo_dev->video_hsize, 117 solo_vlines(solo_dev), 3); 118 119 return 0; 120 } 121 122 static int solo_v4l2_ch_ext_16up(struct solo_dev *solo_dev, int on) 123 { 124 int sy, ysize, hsize, i; 125 126 if (!on) { 127 for (i = 0; i < 16; i++) 128 solo_win_setup(solo_dev, i, solo_dev->video_hsize, 129 solo_vlines(solo_dev), 130 solo_dev->video_hsize, 131 solo_vlines(solo_dev), 0); 132 return 0; 133 } 134 135 ysize = solo_vlines(solo_dev) / 4; 136 hsize = solo_dev->video_hsize / 4; 137 138 for (sy = 0, i = 0; i < 4; i++, sy += ysize) { 139 solo_win_setup(solo_dev, i * 4, 0, sy, hsize, 140 sy + ysize, 5); 141 solo_win_setup(solo_dev, (i * 4) + 1, hsize, sy, 142 hsize * 2, sy + ysize, 5); 143 solo_win_setup(solo_dev, (i * 4) + 2, hsize * 2, sy, 144 hsize * 3, sy + ysize, 5); 145 solo_win_setup(solo_dev, (i * 4) + 3, hsize * 3, sy, 146 solo_dev->video_hsize, sy + ysize, 5); 147 } 148 149 return 0; 150 } 151 152 static int solo_v4l2_ch(struct solo_dev *solo_dev, u8 ch, int on) 153 { 154 u8 ext_ch; 155 156 if (ch < solo_dev->nr_chans) { 157 solo_win_setup(solo_dev, ch, on ? 0 : solo_dev->video_hsize, 158 on ? 0 : solo_vlines(solo_dev), 159 solo_dev->video_hsize, solo_vlines(solo_dev), 160 on ? 1 : 0); 161 return 0; 162 } 163 164 if (ch >= solo_dev->nr_chans + solo_dev->nr_ext) 165 return -EINVAL; 166 167 ext_ch = ch - solo_dev->nr_chans; 168 169 /* 4up's first */ 170 if (ext_ch < 4) 171 return solo_v4l2_ch_ext_4up(solo_dev, ext_ch, on); 172 173 /* Remaining case is 16up for 16-port */ 174 return solo_v4l2_ch_ext_16up(solo_dev, on); 175 } 176 177 static int solo_v4l2_set_ch(struct solo_dev *solo_dev, u8 ch) 178 { 179 if (ch >= solo_dev->nr_chans + solo_dev->nr_ext) 180 return -EINVAL; 181 182 erase_on(solo_dev); 183 184 solo_v4l2_ch(solo_dev, solo_dev->cur_disp_ch, 0); 185 solo_v4l2_ch(solo_dev, ch, 1); 186 187 solo_dev->cur_disp_ch = ch; 188 189 return 0; 190 } 191 192 static void solo_fillbuf(struct solo_dev *solo_dev, 193 struct vb2_buffer *vb) 194 { 195 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 196 dma_addr_t addr; 197 unsigned int fdma_addr; 198 int error = -1; 199 int i; 200 201 addr = vb2_dma_contig_plane_dma_addr(vb, 0); 202 if (!addr) 203 goto finish_buf; 204 205 if (erase_off(solo_dev)) { 206 void *p = vb2_plane_vaddr(vb, 0); 207 int image_size = solo_image_size(solo_dev); 208 209 for (i = 0; i < image_size; i += 2) { 210 ((u8 *)p)[i] = 0x80; 211 ((u8 *)p)[i + 1] = 0x00; 212 } 213 error = 0; 214 } else { 215 fdma_addr = SOLO_DISP_EXT_ADDR + (solo_dev->old_write * 216 (SOLO_HW_BPL * solo_vlines(solo_dev))); 217 218 error = solo_p2m_dma_t(solo_dev, 0, addr, fdma_addr, 219 solo_bytesperline(solo_dev), 220 solo_vlines(solo_dev), SOLO_HW_BPL); 221 } 222 223 finish_buf: 224 if (!error) { 225 vb2_set_plane_payload(vb, 0, 226 solo_vlines(solo_dev) * solo_bytesperline(solo_dev)); 227 vbuf->sequence = solo_dev->sequence++; 228 vb->timestamp = ktime_get_ns(); 229 } 230 231 vb2_buffer_done(vb, error ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE); 232 } 233 234 static void solo_thread_try(struct solo_dev *solo_dev) 235 { 236 struct solo_vb2_buf *vb; 237 238 /* Only "break" from this loop if slock is held, otherwise 239 * just return. */ 240 for (;;) { 241 unsigned int cur_write; 242 243 cur_write = SOLO_VI_STATUS0_PAGE( 244 solo_reg_read(solo_dev, SOLO_VI_STATUS0)); 245 if (cur_write == solo_dev->old_write) 246 return; 247 248 spin_lock(&solo_dev->slock); 249 250 if (list_empty(&solo_dev->vidq_active)) 251 break; 252 253 vb = list_first_entry(&solo_dev->vidq_active, struct solo_vb2_buf, 254 list); 255 256 solo_dev->old_write = cur_write; 257 list_del(&vb->list); 258 259 spin_unlock(&solo_dev->slock); 260 261 solo_fillbuf(solo_dev, &vb->vb.vb2_buf); 262 } 263 264 assert_spin_locked(&solo_dev->slock); 265 spin_unlock(&solo_dev->slock); 266 } 267 268 static int solo_thread(void *data) 269 { 270 struct solo_dev *solo_dev = data; 271 DECLARE_WAITQUEUE(wait, current); 272 273 set_freezable(); 274 add_wait_queue(&solo_dev->disp_thread_wait, &wait); 275 276 for (;;) { 277 long timeout = schedule_timeout_interruptible(HZ); 278 279 if (timeout == -ERESTARTSYS || kthread_should_stop()) 280 break; 281 solo_thread_try(solo_dev); 282 try_to_freeze(); 283 } 284 285 remove_wait_queue(&solo_dev->disp_thread_wait, &wait); 286 287 return 0; 288 } 289 290 static int solo_start_thread(struct solo_dev *solo_dev) 291 { 292 int ret = 0; 293 294 solo_dev->kthread = kthread_run(solo_thread, solo_dev, SOLO6X10_NAME "_disp"); 295 296 if (IS_ERR(solo_dev->kthread)) { 297 ret = PTR_ERR(solo_dev->kthread); 298 solo_dev->kthread = NULL; 299 return ret; 300 } 301 solo_irq_on(solo_dev, SOLO_IRQ_VIDEO_IN); 302 303 return ret; 304 } 305 306 static void solo_stop_thread(struct solo_dev *solo_dev) 307 { 308 if (!solo_dev->kthread) 309 return; 310 311 solo_irq_off(solo_dev, SOLO_IRQ_VIDEO_IN); 312 kthread_stop(solo_dev->kthread); 313 solo_dev->kthread = NULL; 314 } 315 316 static int solo_queue_setup(struct vb2_queue *q, 317 unsigned int *num_buffers, unsigned int *num_planes, 318 unsigned int sizes[], struct device *alloc_devs[]) 319 { 320 struct solo_dev *solo_dev = vb2_get_drv_priv(q); 321 322 sizes[0] = solo_image_size(solo_dev); 323 *num_planes = 1; 324 325 if (*num_buffers < MIN_VID_BUFFERS) 326 *num_buffers = MIN_VID_BUFFERS; 327 328 return 0; 329 } 330 331 static int solo_start_streaming(struct vb2_queue *q, unsigned int count) 332 { 333 struct solo_dev *solo_dev = vb2_get_drv_priv(q); 334 335 solo_dev->sequence = 0; 336 return solo_start_thread(solo_dev); 337 } 338 339 static void solo_stop_streaming(struct vb2_queue *q) 340 { 341 struct solo_dev *solo_dev = vb2_get_drv_priv(q); 342 343 solo_stop_thread(solo_dev); 344 INIT_LIST_HEAD(&solo_dev->vidq_active); 345 } 346 347 static void solo_buf_queue(struct vb2_buffer *vb) 348 { 349 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 350 struct vb2_queue *vq = vb->vb2_queue; 351 struct solo_dev *solo_dev = vb2_get_drv_priv(vq); 352 struct solo_vb2_buf *solo_vb = 353 container_of(vbuf, struct solo_vb2_buf, vb); 354 355 spin_lock(&solo_dev->slock); 356 list_add_tail(&solo_vb->list, &solo_dev->vidq_active); 357 spin_unlock(&solo_dev->slock); 358 wake_up_interruptible(&solo_dev->disp_thread_wait); 359 } 360 361 static const struct vb2_ops solo_video_qops = { 362 .queue_setup = solo_queue_setup, 363 .buf_queue = solo_buf_queue, 364 .start_streaming = solo_start_streaming, 365 .stop_streaming = solo_stop_streaming, 366 .wait_prepare = vb2_ops_wait_prepare, 367 .wait_finish = vb2_ops_wait_finish, 368 }; 369 370 static int solo_querycap(struct file *file, void *priv, 371 struct v4l2_capability *cap) 372 { 373 struct solo_dev *solo_dev = video_drvdata(file); 374 375 strcpy(cap->driver, SOLO6X10_NAME); 376 strcpy(cap->card, "Softlogic 6x10"); 377 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s", 378 pci_name(solo_dev->pdev)); 379 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | 380 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 381 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS; 382 return 0; 383 } 384 385 static int solo_enum_ext_input(struct solo_dev *solo_dev, 386 struct v4l2_input *input) 387 { 388 int ext = input->index - solo_dev->nr_chans; 389 unsigned int nup, first; 390 391 if (ext >= solo_dev->nr_ext) 392 return -EINVAL; 393 394 nup = (ext == 4) ? 16 : 4; 395 first = (ext & 3) << 2; /* first channel in the n-up */ 396 snprintf(input->name, sizeof(input->name), 397 "Multi %d-up (cameras %d-%d)", 398 nup, first + 1, first + nup); 399 /* Possible outputs: 400 * Multi 4-up (cameras 1-4) 401 * Multi 4-up (cameras 5-8) 402 * Multi 4-up (cameras 9-12) 403 * Multi 4-up (cameras 13-16) 404 * Multi 16-up (cameras 1-16) 405 */ 406 return 0; 407 } 408 409 static int solo_enum_input(struct file *file, void *priv, 410 struct v4l2_input *input) 411 { 412 struct solo_dev *solo_dev = video_drvdata(file); 413 414 if (input->index >= solo_dev->nr_chans) { 415 int ret = solo_enum_ext_input(solo_dev, input); 416 417 if (ret < 0) 418 return ret; 419 } else { 420 snprintf(input->name, sizeof(input->name), "Camera %d", 421 input->index + 1); 422 423 /* We can only check this for normal inputs */ 424 if (!tw28_get_video_status(solo_dev, input->index)) 425 input->status = V4L2_IN_ST_NO_SIGNAL; 426 } 427 428 input->type = V4L2_INPUT_TYPE_CAMERA; 429 input->std = solo_dev->vfd->tvnorms; 430 return 0; 431 } 432 433 static int solo_set_input(struct file *file, void *priv, unsigned int index) 434 { 435 struct solo_dev *solo_dev = video_drvdata(file); 436 int ret = solo_v4l2_set_ch(solo_dev, index); 437 438 if (!ret) { 439 while (erase_off(solo_dev)) 440 /* Do nothing */; 441 } 442 443 return ret; 444 } 445 446 static int solo_get_input(struct file *file, void *priv, unsigned int *index) 447 { 448 struct solo_dev *solo_dev = video_drvdata(file); 449 450 *index = solo_dev->cur_disp_ch; 451 452 return 0; 453 } 454 455 static int solo_enum_fmt_cap(struct file *file, void *priv, 456 struct v4l2_fmtdesc *f) 457 { 458 if (f->index) 459 return -EINVAL; 460 461 f->pixelformat = V4L2_PIX_FMT_UYVY; 462 strlcpy(f->description, "UYUV 4:2:2 Packed", sizeof(f->description)); 463 464 return 0; 465 } 466 467 static int solo_try_fmt_cap(struct file *file, void *priv, 468 struct v4l2_format *f) 469 { 470 struct solo_dev *solo_dev = video_drvdata(file); 471 struct v4l2_pix_format *pix = &f->fmt.pix; 472 int image_size = solo_image_size(solo_dev); 473 474 if (pix->pixelformat != V4L2_PIX_FMT_UYVY) 475 return -EINVAL; 476 477 pix->width = solo_dev->video_hsize; 478 pix->height = solo_vlines(solo_dev); 479 pix->sizeimage = image_size; 480 pix->field = V4L2_FIELD_INTERLACED; 481 pix->pixelformat = V4L2_PIX_FMT_UYVY; 482 pix->colorspace = V4L2_COLORSPACE_SMPTE170M; 483 pix->priv = 0; 484 return 0; 485 } 486 487 static int solo_set_fmt_cap(struct file *file, void *priv, 488 struct v4l2_format *f) 489 { 490 struct solo_dev *solo_dev = video_drvdata(file); 491 492 if (vb2_is_busy(&solo_dev->vidq)) 493 return -EBUSY; 494 495 /* For right now, if it doesn't match our running config, 496 * then fail */ 497 return solo_try_fmt_cap(file, priv, f); 498 } 499 500 static int solo_get_fmt_cap(struct file *file, void *priv, 501 struct v4l2_format *f) 502 { 503 struct solo_dev *solo_dev = video_drvdata(file); 504 struct v4l2_pix_format *pix = &f->fmt.pix; 505 506 pix->width = solo_dev->video_hsize; 507 pix->height = solo_vlines(solo_dev); 508 pix->pixelformat = V4L2_PIX_FMT_UYVY; 509 pix->field = V4L2_FIELD_INTERLACED; 510 pix->sizeimage = solo_image_size(solo_dev); 511 pix->colorspace = V4L2_COLORSPACE_SMPTE170M; 512 pix->bytesperline = solo_bytesperline(solo_dev); 513 pix->priv = 0; 514 515 return 0; 516 } 517 518 static int solo_g_std(struct file *file, void *priv, v4l2_std_id *i) 519 { 520 struct solo_dev *solo_dev = video_drvdata(file); 521 522 if (solo_dev->video_type == SOLO_VO_FMT_TYPE_NTSC) 523 *i = V4L2_STD_NTSC_M; 524 else 525 *i = V4L2_STD_PAL; 526 return 0; 527 } 528 529 int solo_set_video_type(struct solo_dev *solo_dev, bool is_50hz) 530 { 531 int i; 532 533 /* Make sure all video nodes are idle */ 534 if (vb2_is_busy(&solo_dev->vidq)) 535 return -EBUSY; 536 for (i = 0; i < solo_dev->nr_chans; i++) 537 if (vb2_is_busy(&solo_dev->v4l2_enc[i]->vidq)) 538 return -EBUSY; 539 solo_dev->video_type = is_50hz ? SOLO_VO_FMT_TYPE_PAL : 540 SOLO_VO_FMT_TYPE_NTSC; 541 /* Reconfigure for the new standard */ 542 solo_disp_init(solo_dev); 543 solo_enc_init(solo_dev); 544 solo_tw28_init(solo_dev); 545 for (i = 0; i < solo_dev->nr_chans; i++) 546 solo_update_mode(solo_dev->v4l2_enc[i]); 547 return solo_v4l2_set_ch(solo_dev, solo_dev->cur_disp_ch); 548 } 549 550 static int solo_s_std(struct file *file, void *priv, v4l2_std_id std) 551 { 552 struct solo_dev *solo_dev = video_drvdata(file); 553 554 return solo_set_video_type(solo_dev, std & V4L2_STD_625_50); 555 } 556 557 static int solo_s_ctrl(struct v4l2_ctrl *ctrl) 558 { 559 struct solo_dev *solo_dev = 560 container_of(ctrl->handler, struct solo_dev, disp_hdl); 561 562 switch (ctrl->id) { 563 case V4L2_CID_MOTION_TRACE: 564 if (ctrl->val) { 565 solo_reg_write(solo_dev, SOLO_VI_MOTION_BORDER, 566 SOLO_VI_MOTION_Y_ADD | 567 SOLO_VI_MOTION_Y_VALUE(0x20) | 568 SOLO_VI_MOTION_CB_VALUE(0x10) | 569 SOLO_VI_MOTION_CR_VALUE(0x10)); 570 solo_reg_write(solo_dev, SOLO_VI_MOTION_BAR, 571 SOLO_VI_MOTION_CR_ADD | 572 SOLO_VI_MOTION_Y_VALUE(0x10) | 573 SOLO_VI_MOTION_CB_VALUE(0x80) | 574 SOLO_VI_MOTION_CR_VALUE(0x10)); 575 } else { 576 solo_reg_write(solo_dev, SOLO_VI_MOTION_BORDER, 0); 577 solo_reg_write(solo_dev, SOLO_VI_MOTION_BAR, 0); 578 } 579 return 0; 580 default: 581 break; 582 } 583 return -EINVAL; 584 } 585 586 static const struct v4l2_file_operations solo_v4l2_fops = { 587 .owner = THIS_MODULE, 588 .open = v4l2_fh_open, 589 .release = vb2_fop_release, 590 .read = vb2_fop_read, 591 .poll = vb2_fop_poll, 592 .mmap = vb2_fop_mmap, 593 .unlocked_ioctl = video_ioctl2, 594 }; 595 596 static const struct v4l2_ioctl_ops solo_v4l2_ioctl_ops = { 597 .vidioc_querycap = solo_querycap, 598 .vidioc_s_std = solo_s_std, 599 .vidioc_g_std = solo_g_std, 600 /* Input callbacks */ 601 .vidioc_enum_input = solo_enum_input, 602 .vidioc_s_input = solo_set_input, 603 .vidioc_g_input = solo_get_input, 604 /* Video capture format callbacks */ 605 .vidioc_enum_fmt_vid_cap = solo_enum_fmt_cap, 606 .vidioc_try_fmt_vid_cap = solo_try_fmt_cap, 607 .vidioc_s_fmt_vid_cap = solo_set_fmt_cap, 608 .vidioc_g_fmt_vid_cap = solo_get_fmt_cap, 609 /* Streaming I/O */ 610 .vidioc_reqbufs = vb2_ioctl_reqbufs, 611 .vidioc_querybuf = vb2_ioctl_querybuf, 612 .vidioc_qbuf = vb2_ioctl_qbuf, 613 .vidioc_dqbuf = vb2_ioctl_dqbuf, 614 .vidioc_streamon = vb2_ioctl_streamon, 615 .vidioc_streamoff = vb2_ioctl_streamoff, 616 /* Logging and events */ 617 .vidioc_log_status = v4l2_ctrl_log_status, 618 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 619 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 620 }; 621 622 static struct video_device solo_v4l2_template = { 623 .name = SOLO6X10_NAME, 624 .fops = &solo_v4l2_fops, 625 .ioctl_ops = &solo_v4l2_ioctl_ops, 626 .minor = -1, 627 .release = video_device_release, 628 .tvnorms = V4L2_STD_NTSC_M | V4L2_STD_PAL, 629 }; 630 631 static const struct v4l2_ctrl_ops solo_ctrl_ops = { 632 .s_ctrl = solo_s_ctrl, 633 }; 634 635 static const struct v4l2_ctrl_config solo_motion_trace_ctrl = { 636 .ops = &solo_ctrl_ops, 637 .id = V4L2_CID_MOTION_TRACE, 638 .name = "Motion Detection Trace", 639 .type = V4L2_CTRL_TYPE_BOOLEAN, 640 .max = 1, 641 .step = 1, 642 }; 643 644 int solo_v4l2_init(struct solo_dev *solo_dev, unsigned nr) 645 { 646 int ret; 647 int i; 648 649 init_waitqueue_head(&solo_dev->disp_thread_wait); 650 spin_lock_init(&solo_dev->slock); 651 mutex_init(&solo_dev->lock); 652 INIT_LIST_HEAD(&solo_dev->vidq_active); 653 654 solo_dev->vfd = video_device_alloc(); 655 if (!solo_dev->vfd) 656 return -ENOMEM; 657 658 *solo_dev->vfd = solo_v4l2_template; 659 solo_dev->vfd->v4l2_dev = &solo_dev->v4l2_dev; 660 solo_dev->vfd->queue = &solo_dev->vidq; 661 solo_dev->vfd->lock = &solo_dev->lock; 662 v4l2_ctrl_handler_init(&solo_dev->disp_hdl, 1); 663 v4l2_ctrl_new_custom(&solo_dev->disp_hdl, &solo_motion_trace_ctrl, NULL); 664 if (solo_dev->disp_hdl.error) { 665 ret = solo_dev->disp_hdl.error; 666 goto fail; 667 } 668 solo_dev->vfd->ctrl_handler = &solo_dev->disp_hdl; 669 670 video_set_drvdata(solo_dev->vfd, solo_dev); 671 672 solo_dev->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 673 solo_dev->vidq.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ; 674 solo_dev->vidq.ops = &solo_video_qops; 675 solo_dev->vidq.mem_ops = &vb2_dma_contig_memops; 676 solo_dev->vidq.drv_priv = solo_dev; 677 solo_dev->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 678 solo_dev->vidq.gfp_flags = __GFP_DMA32 | __GFP_KSWAPD_RECLAIM; 679 solo_dev->vidq.buf_struct_size = sizeof(struct solo_vb2_buf); 680 solo_dev->vidq.lock = &solo_dev->lock; 681 solo_dev->vidq.dev = &solo_dev->pdev->dev; 682 ret = vb2_queue_init(&solo_dev->vidq); 683 if (ret < 0) 684 goto fail; 685 686 /* Cycle all the channels and clear */ 687 for (i = 0; i < solo_dev->nr_chans; i++) { 688 solo_v4l2_set_ch(solo_dev, i); 689 while (erase_off(solo_dev)) 690 /* Do nothing */; 691 } 692 693 /* Set the default display channel */ 694 solo_v4l2_set_ch(solo_dev, 0); 695 while (erase_off(solo_dev)) 696 /* Do nothing */; 697 698 ret = video_register_device(solo_dev->vfd, VFL_TYPE_GRABBER, nr); 699 if (ret < 0) 700 goto fail; 701 702 snprintf(solo_dev->vfd->name, sizeof(solo_dev->vfd->name), "%s (%i)", 703 SOLO6X10_NAME, solo_dev->vfd->num); 704 705 dev_info(&solo_dev->pdev->dev, "Display as /dev/video%d with %d inputs (%d extended)\n", 706 solo_dev->vfd->num, 707 solo_dev->nr_chans, solo_dev->nr_ext); 708 709 return 0; 710 711 fail: 712 video_device_release(solo_dev->vfd); 713 v4l2_ctrl_handler_free(&solo_dev->disp_hdl); 714 solo_dev->vfd = NULL; 715 return ret; 716 } 717 718 void solo_v4l2_exit(struct solo_dev *solo_dev) 719 { 720 if (solo_dev->vfd == NULL) 721 return; 722 723 video_unregister_device(solo_dev->vfd); 724 v4l2_ctrl_handler_free(&solo_dev->disp_hdl); 725 solo_dev->vfd = NULL; 726 } 727