1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Xilinx Video DMA 4 * 5 * Copyright (C) 2013-2015 Ideas on Board 6 * Copyright (C) 2013-2015 Xilinx, Inc. 7 * 8 * Contacts: Hyun Kwon <hyun.kwon@xilinx.com> 9 * Laurent Pinchart <laurent.pinchart@ideasonboard.com> 10 */ 11 12 #include <linux/dma/xilinx_dma.h> 13 #include <linux/lcm.h> 14 #include <linux/list.h> 15 #include <linux/module.h> 16 #include <linux/of.h> 17 #include <linux/slab.h> 18 19 #include <media/v4l2-dev.h> 20 #include <media/v4l2-fh.h> 21 #include <media/v4l2-ioctl.h> 22 #include <media/videobuf2-v4l2.h> 23 #include <media/videobuf2-dma-contig.h> 24 25 #include "xilinx-dma.h" 26 #include "xilinx-vip.h" 27 #include "xilinx-vipp.h" 28 29 #define XVIP_DMA_DEF_WIDTH 1920 30 #define XVIP_DMA_DEF_HEIGHT 1080 31 32 /* Minimum and maximum widths are expressed in bytes */ 33 #define XVIP_DMA_MIN_WIDTH 1U 34 #define XVIP_DMA_MAX_WIDTH 65535U 35 #define XVIP_DMA_MIN_HEIGHT 1U 36 #define XVIP_DMA_MAX_HEIGHT 8191U 37 38 /* ----------------------------------------------------------------------------- 39 * Helper functions 40 */ 41 42 static struct v4l2_subdev * 43 xvip_dma_remote_subdev(struct media_pad *local, u32 *pad) 44 { 45 struct media_pad *remote; 46 47 remote = media_pad_remote_pad_first(local); 48 if (!remote || !is_media_entity_v4l2_subdev(remote->entity)) 49 return NULL; 50 51 if (pad) 52 *pad = remote->index; 53 54 return media_entity_to_v4l2_subdev(remote->entity); 55 } 56 57 static int xvip_dma_verify_format(struct xvip_dma *dma) 58 { 59 struct v4l2_subdev_format fmt; 60 struct v4l2_subdev *subdev; 61 int ret; 62 63 subdev = xvip_dma_remote_subdev(&dma->pad, &fmt.pad); 64 if (subdev == NULL) 65 return -EPIPE; 66 67 fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; 68 ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt); 69 if (ret < 0) 70 return ret == -ENOIOCTLCMD ? -EINVAL : ret; 71 72 if (dma->fmtinfo->code != fmt.format.code || 73 dma->format.height != fmt.format.height || 74 dma->format.width != fmt.format.width || 75 dma->format.colorspace != fmt.format.colorspace) 76 return -EINVAL; 77 78 return 0; 79 } 80 81 /* ----------------------------------------------------------------------------- 82 * Pipeline Stream Management 83 */ 84 85 /** 86 * xvip_pipeline_start_stop - Start ot stop streaming on a pipeline 87 * @pipe: The pipeline 88 * @start: Start (when true) or stop (when false) the pipeline 89 * 90 * Walk the entities chain starting at the pipeline output video node and start 91 * or stop all of them. 92 * 93 * Return: 0 if successful, or the return value of the failed video::s_stream 94 * operation otherwise. 95 */ 96 static int xvip_pipeline_start_stop(struct xvip_pipeline *pipe, bool start) 97 { 98 struct xvip_dma *dma = pipe->output; 99 struct media_entity *entity; 100 struct media_pad *pad; 101 struct v4l2_subdev *subdev; 102 int ret; 103 104 entity = &dma->video.entity; 105 while (1) { 106 pad = &entity->pads[0]; 107 if (!(pad->flags & MEDIA_PAD_FL_SINK)) 108 break; 109 110 pad = media_pad_remote_pad_first(pad); 111 if (!pad || !is_media_entity_v4l2_subdev(pad->entity)) 112 break; 113 114 entity = pad->entity; 115 subdev = media_entity_to_v4l2_subdev(entity); 116 117 ret = v4l2_subdev_call(subdev, video, s_stream, start); 118 if (start && ret < 0 && ret != -ENOIOCTLCMD) 119 return ret; 120 } 121 122 return 0; 123 } 124 125 /** 126 * xvip_pipeline_set_stream - Enable/disable streaming on a pipeline 127 * @pipe: The pipeline 128 * @on: Turn the stream on when true or off when false 129 * 130 * The pipeline is shared between all DMA engines connect at its input and 131 * output. While the stream state of DMA engines can be controlled 132 * independently, pipelines have a shared stream state that enable or disable 133 * all entities in the pipeline. For this reason the pipeline uses a streaming 134 * counter that tracks the number of DMA engines that have requested the stream 135 * to be enabled. 136 * 137 * When called with the @on argument set to true, this function will increment 138 * the pipeline streaming count. If the streaming count reaches the number of 139 * DMA engines in the pipeline it will enable all entities that belong to the 140 * pipeline. 141 * 142 * Similarly, when called with the @on argument set to false, this function will 143 * decrement the pipeline streaming count and disable all entities in the 144 * pipeline when the streaming count reaches zero. 145 * 146 * Return: 0 if successful, or the return value of the failed video::s_stream 147 * operation otherwise. Stopping the pipeline never fails. The pipeline state is 148 * not updated when the operation fails. 149 */ 150 static int xvip_pipeline_set_stream(struct xvip_pipeline *pipe, bool on) 151 { 152 int ret = 0; 153 154 mutex_lock(&pipe->lock); 155 156 if (on) { 157 if (pipe->stream_count == pipe->num_dmas - 1) { 158 ret = xvip_pipeline_start_stop(pipe, true); 159 if (ret < 0) 160 goto done; 161 } 162 pipe->stream_count++; 163 } else { 164 if (--pipe->stream_count == 0) 165 xvip_pipeline_start_stop(pipe, false); 166 } 167 168 done: 169 mutex_unlock(&pipe->lock); 170 return ret; 171 } 172 173 static int xvip_pipeline_validate(struct xvip_pipeline *pipe, 174 struct xvip_dma *start) 175 { 176 struct media_pipeline_pad_iter iter; 177 unsigned int num_inputs = 0; 178 unsigned int num_outputs = 0; 179 struct media_pad *pad; 180 181 /* Locate the video nodes in the pipeline. */ 182 media_pipeline_for_each_pad(&pipe->pipe, &iter, pad) { 183 struct xvip_dma *dma; 184 185 if (pad->entity->function != MEDIA_ENT_F_IO_V4L) 186 continue; 187 188 dma = to_xvip_dma(media_entity_to_video_device(pad->entity)); 189 190 if (dma->pad.flags & MEDIA_PAD_FL_SINK) { 191 pipe->output = dma; 192 num_outputs++; 193 } else { 194 num_inputs++; 195 } 196 } 197 198 /* We need exactly one output and zero or one input. */ 199 if (num_outputs != 1 || num_inputs > 1) 200 return -EPIPE; 201 202 pipe->num_dmas = num_inputs + num_outputs; 203 204 return 0; 205 } 206 207 static void __xvip_pipeline_cleanup(struct xvip_pipeline *pipe) 208 { 209 pipe->num_dmas = 0; 210 pipe->output = NULL; 211 } 212 213 /** 214 * xvip_pipeline_cleanup - Cleanup the pipeline after streaming 215 * @pipe: the pipeline 216 * 217 * Decrease the pipeline use count and clean it up if we were the last user. 218 */ 219 static void xvip_pipeline_cleanup(struct xvip_pipeline *pipe) 220 { 221 mutex_lock(&pipe->lock); 222 223 /* If we're the last user clean up the pipeline. */ 224 if (--pipe->use_count == 0) 225 __xvip_pipeline_cleanup(pipe); 226 227 mutex_unlock(&pipe->lock); 228 } 229 230 /** 231 * xvip_pipeline_prepare - Prepare the pipeline for streaming 232 * @pipe: the pipeline 233 * @dma: DMA engine at one end of the pipeline 234 * 235 * Validate the pipeline if no user exists yet, otherwise just increase the use 236 * count. 237 * 238 * Return: 0 if successful or -EPIPE if the pipeline is not valid. 239 */ 240 static int xvip_pipeline_prepare(struct xvip_pipeline *pipe, 241 struct xvip_dma *dma) 242 { 243 int ret; 244 245 mutex_lock(&pipe->lock); 246 247 /* If we're the first user validate and initialize the pipeline. */ 248 if (pipe->use_count == 0) { 249 ret = xvip_pipeline_validate(pipe, dma); 250 if (ret < 0) { 251 __xvip_pipeline_cleanup(pipe); 252 goto done; 253 } 254 } 255 256 pipe->use_count++; 257 ret = 0; 258 259 done: 260 mutex_unlock(&pipe->lock); 261 return ret; 262 } 263 264 /* ----------------------------------------------------------------------------- 265 * videobuf2 queue operations 266 */ 267 268 /** 269 * struct xvip_dma_buffer - Video DMA buffer 270 * @buf: vb2 buffer base object 271 * @queue: buffer list entry in the DMA engine queued buffers list 272 * @dma: DMA channel that uses the buffer 273 */ 274 struct xvip_dma_buffer { 275 struct vb2_v4l2_buffer buf; 276 struct list_head queue; 277 struct xvip_dma *dma; 278 }; 279 280 #define to_xvip_dma_buffer(vb) container_of(vb, struct xvip_dma_buffer, buf) 281 282 static void xvip_dma_complete(void *param) 283 { 284 struct xvip_dma_buffer *buf = param; 285 struct xvip_dma *dma = buf->dma; 286 287 spin_lock(&dma->queued_lock); 288 list_del(&buf->queue); 289 spin_unlock(&dma->queued_lock); 290 291 buf->buf.field = V4L2_FIELD_NONE; 292 buf->buf.sequence = dma->sequence++; 293 buf->buf.vb2_buf.timestamp = ktime_get_ns(); 294 vb2_set_plane_payload(&buf->buf.vb2_buf, 0, dma->format.sizeimage); 295 vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_DONE); 296 } 297 298 static int 299 xvip_dma_queue_setup(struct vb2_queue *vq, 300 unsigned int *nbuffers, unsigned int *nplanes, 301 unsigned int sizes[], struct device *alloc_devs[]) 302 { 303 struct xvip_dma *dma = vb2_get_drv_priv(vq); 304 305 /* Make sure the image size is large enough. */ 306 if (*nplanes) 307 return sizes[0] < dma->format.sizeimage ? -EINVAL : 0; 308 309 *nplanes = 1; 310 sizes[0] = dma->format.sizeimage; 311 312 return 0; 313 } 314 315 static int xvip_dma_buffer_prepare(struct vb2_buffer *vb) 316 { 317 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 318 struct xvip_dma *dma = vb2_get_drv_priv(vb->vb2_queue); 319 struct xvip_dma_buffer *buf = to_xvip_dma_buffer(vbuf); 320 321 buf->dma = dma; 322 323 return 0; 324 } 325 326 static void xvip_dma_buffer_queue(struct vb2_buffer *vb) 327 { 328 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 329 struct xvip_dma *dma = vb2_get_drv_priv(vb->vb2_queue); 330 struct xvip_dma_buffer *buf = to_xvip_dma_buffer(vbuf); 331 struct dma_async_tx_descriptor *desc; 332 dma_addr_t addr = vb2_dma_contig_plane_dma_addr(vb, 0); 333 u32 flags; 334 335 if (dma->queue.type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 336 flags = DMA_PREP_INTERRUPT | DMA_CTRL_ACK; 337 dma->xt.dir = DMA_DEV_TO_MEM; 338 dma->xt.src_sgl = false; 339 dma->xt.dst_sgl = true; 340 dma->xt.dst_start = addr; 341 } else { 342 flags = DMA_PREP_INTERRUPT | DMA_CTRL_ACK; 343 dma->xt.dir = DMA_MEM_TO_DEV; 344 dma->xt.src_sgl = true; 345 dma->xt.dst_sgl = false; 346 dma->xt.src_start = addr; 347 } 348 349 dma->xt.frame_size = 1; 350 dma->sgl[0].size = dma->format.width * dma->fmtinfo->bpp; 351 dma->sgl[0].icg = dma->format.bytesperline - dma->sgl[0].size; 352 dma->xt.numf = dma->format.height; 353 354 desc = dmaengine_prep_interleaved_dma(dma->dma, &dma->xt, flags); 355 if (!desc) { 356 dev_err(dma->xdev->dev, "Failed to prepare DMA transfer\n"); 357 vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_ERROR); 358 return; 359 } 360 desc->callback = xvip_dma_complete; 361 desc->callback_param = buf; 362 363 spin_lock_irq(&dma->queued_lock); 364 list_add_tail(&buf->queue, &dma->queued_bufs); 365 spin_unlock_irq(&dma->queued_lock); 366 367 dmaengine_submit(desc); 368 369 if (vb2_is_streaming(&dma->queue)) 370 dma_async_issue_pending(dma->dma); 371 } 372 373 static int xvip_dma_start_streaming(struct vb2_queue *vq, unsigned int count) 374 { 375 struct xvip_dma *dma = vb2_get_drv_priv(vq); 376 struct xvip_dma_buffer *buf, *nbuf; 377 struct xvip_pipeline *pipe; 378 int ret; 379 380 dma->sequence = 0; 381 382 /* 383 * Start streaming on the pipeline. No link touching an entity in the 384 * pipeline can be activated or deactivated once streaming is started. 385 * 386 * Use the pipeline object embedded in the first DMA object that starts 387 * streaming. 388 */ 389 pipe = to_xvip_pipeline(&dma->video) ? : &dma->pipe; 390 391 ret = video_device_pipeline_start(&dma->video, &pipe->pipe); 392 if (ret < 0) 393 goto error; 394 395 /* Verify that the configured format matches the output of the 396 * connected subdev. 397 */ 398 ret = xvip_dma_verify_format(dma); 399 if (ret < 0) 400 goto error_stop; 401 402 ret = xvip_pipeline_prepare(pipe, dma); 403 if (ret < 0) 404 goto error_stop; 405 406 /* Start the DMA engine. This must be done before starting the blocks 407 * in the pipeline to avoid DMA synchronization issues. 408 */ 409 dma_async_issue_pending(dma->dma); 410 411 /* Start the pipeline. */ 412 xvip_pipeline_set_stream(pipe, true); 413 414 return 0; 415 416 error_stop: 417 video_device_pipeline_stop(&dma->video); 418 419 error: 420 /* Give back all queued buffers to videobuf2. */ 421 spin_lock_irq(&dma->queued_lock); 422 list_for_each_entry_safe(buf, nbuf, &dma->queued_bufs, queue) { 423 vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_QUEUED); 424 list_del(&buf->queue); 425 } 426 spin_unlock_irq(&dma->queued_lock); 427 428 return ret; 429 } 430 431 static void xvip_dma_stop_streaming(struct vb2_queue *vq) 432 { 433 struct xvip_dma *dma = vb2_get_drv_priv(vq); 434 struct xvip_pipeline *pipe = to_xvip_pipeline(&dma->video); 435 struct xvip_dma_buffer *buf, *nbuf; 436 437 /* Stop the pipeline. */ 438 xvip_pipeline_set_stream(pipe, false); 439 440 /* Stop and reset the DMA engine. */ 441 dmaengine_terminate_all(dma->dma); 442 443 /* Cleanup the pipeline and mark it as being stopped. */ 444 xvip_pipeline_cleanup(pipe); 445 video_device_pipeline_stop(&dma->video); 446 447 /* Give back all queued buffers to videobuf2. */ 448 spin_lock_irq(&dma->queued_lock); 449 list_for_each_entry_safe(buf, nbuf, &dma->queued_bufs, queue) { 450 vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_ERROR); 451 list_del(&buf->queue); 452 } 453 spin_unlock_irq(&dma->queued_lock); 454 } 455 456 static const struct vb2_ops xvip_dma_queue_qops = { 457 .queue_setup = xvip_dma_queue_setup, 458 .buf_prepare = xvip_dma_buffer_prepare, 459 .buf_queue = xvip_dma_buffer_queue, 460 .wait_prepare = vb2_ops_wait_prepare, 461 .wait_finish = vb2_ops_wait_finish, 462 .start_streaming = xvip_dma_start_streaming, 463 .stop_streaming = xvip_dma_stop_streaming, 464 }; 465 466 /* ----------------------------------------------------------------------------- 467 * V4L2 ioctls 468 */ 469 470 static int 471 xvip_dma_querycap(struct file *file, void *fh, struct v4l2_capability *cap) 472 { 473 struct v4l2_fh *vfh = file->private_data; 474 struct xvip_dma *dma = to_xvip_dma(vfh->vdev); 475 476 cap->capabilities = dma->xdev->v4l2_caps | V4L2_CAP_STREAMING | 477 V4L2_CAP_DEVICE_CAPS; 478 479 strscpy(cap->driver, "xilinx-vipp", sizeof(cap->driver)); 480 strscpy(cap->card, dma->video.name, sizeof(cap->card)); 481 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%pOFn:%u", 482 dma->xdev->dev->of_node, dma->port); 483 484 return 0; 485 } 486 487 /* FIXME: without this callback function, some applications are not configured 488 * with correct formats, and it results in frames in wrong format. Whether this 489 * callback needs to be required is not clearly defined, so it should be 490 * clarified through the mailing list. 491 */ 492 static int 493 xvip_dma_enum_format(struct file *file, void *fh, struct v4l2_fmtdesc *f) 494 { 495 struct v4l2_fh *vfh = file->private_data; 496 struct xvip_dma *dma = to_xvip_dma(vfh->vdev); 497 498 if (f->index > 0) 499 return -EINVAL; 500 501 f->pixelformat = dma->format.pixelformat; 502 503 return 0; 504 } 505 506 static int 507 xvip_dma_get_format(struct file *file, void *fh, struct v4l2_format *format) 508 { 509 struct v4l2_fh *vfh = file->private_data; 510 struct xvip_dma *dma = to_xvip_dma(vfh->vdev); 511 512 format->fmt.pix = dma->format; 513 514 return 0; 515 } 516 517 static void 518 __xvip_dma_try_format(struct xvip_dma *dma, struct v4l2_pix_format *pix, 519 const struct xvip_video_format **fmtinfo) 520 { 521 const struct xvip_video_format *info; 522 unsigned int min_width; 523 unsigned int max_width; 524 unsigned int min_bpl; 525 unsigned int max_bpl; 526 unsigned int width; 527 unsigned int align; 528 unsigned int bpl; 529 530 /* Retrieve format information and select the default format if the 531 * requested format isn't supported. 532 */ 533 info = xvip_get_format_by_fourcc(pix->pixelformat); 534 535 pix->pixelformat = info->fourcc; 536 pix->field = V4L2_FIELD_NONE; 537 538 /* The transfer alignment requirements are expressed in bytes. Compute 539 * the minimum and maximum values, clamp the requested width and convert 540 * it back to pixels. 541 */ 542 align = lcm(dma->align, info->bpp); 543 min_width = roundup(XVIP_DMA_MIN_WIDTH, align); 544 max_width = rounddown(XVIP_DMA_MAX_WIDTH, align); 545 width = rounddown(pix->width * info->bpp, align); 546 547 pix->width = clamp(width, min_width, max_width) / info->bpp; 548 pix->height = clamp(pix->height, XVIP_DMA_MIN_HEIGHT, 549 XVIP_DMA_MAX_HEIGHT); 550 551 /* Clamp the requested bytes per line value. If the maximum bytes per 552 * line value is zero, the module doesn't support user configurable line 553 * sizes. Override the requested value with the minimum in that case. 554 */ 555 min_bpl = pix->width * info->bpp; 556 max_bpl = rounddown(XVIP_DMA_MAX_WIDTH, dma->align); 557 bpl = rounddown(pix->bytesperline, dma->align); 558 559 pix->bytesperline = clamp(bpl, min_bpl, max_bpl); 560 pix->sizeimage = pix->bytesperline * pix->height; 561 562 if (fmtinfo) 563 *fmtinfo = info; 564 } 565 566 static int 567 xvip_dma_try_format(struct file *file, void *fh, struct v4l2_format *format) 568 { 569 struct v4l2_fh *vfh = file->private_data; 570 struct xvip_dma *dma = to_xvip_dma(vfh->vdev); 571 572 __xvip_dma_try_format(dma, &format->fmt.pix, NULL); 573 return 0; 574 } 575 576 static int 577 xvip_dma_set_format(struct file *file, void *fh, struct v4l2_format *format) 578 { 579 struct v4l2_fh *vfh = file->private_data; 580 struct xvip_dma *dma = to_xvip_dma(vfh->vdev); 581 const struct xvip_video_format *info; 582 583 __xvip_dma_try_format(dma, &format->fmt.pix, &info); 584 585 if (vb2_is_busy(&dma->queue)) 586 return -EBUSY; 587 588 dma->format = format->fmt.pix; 589 dma->fmtinfo = info; 590 591 return 0; 592 } 593 594 static const struct v4l2_ioctl_ops xvip_dma_ioctl_ops = { 595 .vidioc_querycap = xvip_dma_querycap, 596 .vidioc_enum_fmt_vid_cap = xvip_dma_enum_format, 597 .vidioc_g_fmt_vid_cap = xvip_dma_get_format, 598 .vidioc_g_fmt_vid_out = xvip_dma_get_format, 599 .vidioc_s_fmt_vid_cap = xvip_dma_set_format, 600 .vidioc_s_fmt_vid_out = xvip_dma_set_format, 601 .vidioc_try_fmt_vid_cap = xvip_dma_try_format, 602 .vidioc_try_fmt_vid_out = xvip_dma_try_format, 603 .vidioc_reqbufs = vb2_ioctl_reqbufs, 604 .vidioc_querybuf = vb2_ioctl_querybuf, 605 .vidioc_qbuf = vb2_ioctl_qbuf, 606 .vidioc_dqbuf = vb2_ioctl_dqbuf, 607 .vidioc_create_bufs = vb2_ioctl_create_bufs, 608 .vidioc_expbuf = vb2_ioctl_expbuf, 609 .vidioc_streamon = vb2_ioctl_streamon, 610 .vidioc_streamoff = vb2_ioctl_streamoff, 611 }; 612 613 /* ----------------------------------------------------------------------------- 614 * V4L2 file operations 615 */ 616 617 static const struct v4l2_file_operations xvip_dma_fops = { 618 .owner = THIS_MODULE, 619 .unlocked_ioctl = video_ioctl2, 620 .open = v4l2_fh_open, 621 .release = vb2_fop_release, 622 .poll = vb2_fop_poll, 623 .mmap = vb2_fop_mmap, 624 }; 625 626 /* ----------------------------------------------------------------------------- 627 * Xilinx Video DMA Core 628 */ 629 630 int xvip_dma_init(struct xvip_composite_device *xdev, struct xvip_dma *dma, 631 enum v4l2_buf_type type, unsigned int port) 632 { 633 char name[16]; 634 int ret; 635 636 dma->xdev = xdev; 637 dma->port = port; 638 mutex_init(&dma->lock); 639 mutex_init(&dma->pipe.lock); 640 INIT_LIST_HEAD(&dma->queued_bufs); 641 spin_lock_init(&dma->queued_lock); 642 643 dma->fmtinfo = xvip_get_format_by_fourcc(V4L2_PIX_FMT_YUYV); 644 dma->format.pixelformat = dma->fmtinfo->fourcc; 645 dma->format.colorspace = V4L2_COLORSPACE_SRGB; 646 dma->format.field = V4L2_FIELD_NONE; 647 dma->format.width = XVIP_DMA_DEF_WIDTH; 648 dma->format.height = XVIP_DMA_DEF_HEIGHT; 649 dma->format.bytesperline = dma->format.width * dma->fmtinfo->bpp; 650 dma->format.sizeimage = dma->format.bytesperline * dma->format.height; 651 652 /* Initialize the media entity... */ 653 dma->pad.flags = type == V4L2_BUF_TYPE_VIDEO_CAPTURE 654 ? MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE; 655 656 ret = media_entity_pads_init(&dma->video.entity, 1, &dma->pad); 657 if (ret < 0) 658 goto error; 659 660 /* ... and the video node... */ 661 dma->video.fops = &xvip_dma_fops; 662 dma->video.v4l2_dev = &xdev->v4l2_dev; 663 dma->video.queue = &dma->queue; 664 snprintf(dma->video.name, sizeof(dma->video.name), "%pOFn %s %u", 665 xdev->dev->of_node, 666 type == V4L2_BUF_TYPE_VIDEO_CAPTURE ? "output" : "input", 667 port); 668 dma->video.vfl_type = VFL_TYPE_VIDEO; 669 dma->video.vfl_dir = type == V4L2_BUF_TYPE_VIDEO_CAPTURE 670 ? VFL_DIR_RX : VFL_DIR_TX; 671 dma->video.release = video_device_release_empty; 672 dma->video.ioctl_ops = &xvip_dma_ioctl_ops; 673 dma->video.lock = &dma->lock; 674 dma->video.device_caps = V4L2_CAP_STREAMING; 675 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 676 dma->video.device_caps |= V4L2_CAP_VIDEO_CAPTURE; 677 else 678 dma->video.device_caps |= V4L2_CAP_VIDEO_OUTPUT; 679 680 video_set_drvdata(&dma->video, dma); 681 682 /* ... and the buffers queue... */ 683 /* Don't enable VB2_READ and VB2_WRITE, as using the read() and write() 684 * V4L2 APIs would be inefficient. Testing on the command line with a 685 * 'cat /dev/video?' thus won't be possible, but given that the driver 686 * anyway requires a test tool to setup the pipeline before any video 687 * stream can be started, requiring a specific V4L2 test tool as well 688 * instead of 'cat' isn't really a drawback. 689 */ 690 dma->queue.type = type; 691 dma->queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 692 dma->queue.lock = &dma->lock; 693 dma->queue.drv_priv = dma; 694 dma->queue.buf_struct_size = sizeof(struct xvip_dma_buffer); 695 dma->queue.ops = &xvip_dma_queue_qops; 696 dma->queue.mem_ops = &vb2_dma_contig_memops; 697 dma->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC 698 | V4L2_BUF_FLAG_TSTAMP_SRC_EOF; 699 dma->queue.dev = dma->xdev->dev; 700 ret = vb2_queue_init(&dma->queue); 701 if (ret < 0) { 702 dev_err(dma->xdev->dev, "failed to initialize VB2 queue\n"); 703 goto error; 704 } 705 706 /* ... and the DMA channel. */ 707 snprintf(name, sizeof(name), "port%u", port); 708 dma->dma = dma_request_chan(dma->xdev->dev, name); 709 if (IS_ERR(dma->dma)) { 710 ret = PTR_ERR(dma->dma); 711 if (ret != -EPROBE_DEFER) 712 dev_err(dma->xdev->dev, "no VDMA channel found\n"); 713 goto error; 714 } 715 716 dma->align = 1 << dma->dma->device->copy_align; 717 718 ret = video_register_device(&dma->video, VFL_TYPE_VIDEO, -1); 719 if (ret < 0) { 720 dev_err(dma->xdev->dev, "failed to register video device\n"); 721 goto error; 722 } 723 724 return 0; 725 726 error: 727 xvip_dma_cleanup(dma); 728 return ret; 729 } 730 731 void xvip_dma_cleanup(struct xvip_dma *dma) 732 { 733 if (video_is_registered(&dma->video)) 734 video_unregister_device(&dma->video); 735 736 if (!IS_ERR_OR_NULL(dma->dma)) 737 dma_release_channel(dma->dma); 738 739 media_entity_cleanup(&dma->video.entity); 740 741 mutex_destroy(&dma->lock); 742 mutex_destroy(&dma->pipe.lock); 743 } 744