/* * Xilinx Video DMA * * Copyright (C) 2013-2015 Ideas on Board * Copyright (C) 2013-2015 Xilinx, Inc. * * Contacts: Hyun Kwon * Laurent Pinchart * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #include #include #include #include #include #include #include #include #include #include #include #include "xilinx-dma.h" #include "xilinx-vip.h" #include "xilinx-vipp.h" #define XVIP_DMA_DEF_FORMAT V4L2_PIX_FMT_YUYV #define XVIP_DMA_DEF_WIDTH 1920 #define XVIP_DMA_DEF_HEIGHT 1080 /* Minimum and maximum widths are expressed in bytes */ #define XVIP_DMA_MIN_WIDTH 1U #define XVIP_DMA_MAX_WIDTH 65535U #define XVIP_DMA_MIN_HEIGHT 1U #define XVIP_DMA_MAX_HEIGHT 8191U /* ----------------------------------------------------------------------------- * Helper functions */ static struct v4l2_subdev * xvip_dma_remote_subdev(struct media_pad *local, u32 *pad) { struct media_pad *remote; remote = media_entity_remote_pad(local); if (remote == NULL || media_entity_type(remote->entity) != MEDIA_ENT_T_V4L2_SUBDEV) return NULL; if (pad) *pad = remote->index; return media_entity_to_v4l2_subdev(remote->entity); } static int xvip_dma_verify_format(struct xvip_dma *dma) { struct v4l2_subdev_format fmt; struct v4l2_subdev *subdev; int ret; subdev = xvip_dma_remote_subdev(&dma->pad, &fmt.pad); if (subdev == NULL) return -EPIPE; fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt); if (ret < 0) return ret == -ENOIOCTLCMD ? -EINVAL : ret; if (dma->fmtinfo->code != fmt.format.code || dma->format.height != fmt.format.height || dma->format.width != fmt.format.width || dma->format.colorspace != fmt.format.colorspace) return -EINVAL; return 0; } /* ----------------------------------------------------------------------------- * Pipeline Stream Management */ /** * xvip_pipeline_start_stop - Start ot stop streaming on a pipeline * @pipe: The pipeline * @start: Start (when true) or stop (when false) the pipeline * * Walk the entities chain starting at the pipeline output video node and start * or stop all of them. * * Return: 0 if successful, or the return value of the failed video::s_stream * operation otherwise. */ static int xvip_pipeline_start_stop(struct xvip_pipeline *pipe, bool start) { struct xvip_dma *dma = pipe->output; struct media_entity *entity; struct media_pad *pad; struct v4l2_subdev *subdev; int ret; entity = &dma->video.entity; while (1) { pad = &entity->pads[0]; if (!(pad->flags & MEDIA_PAD_FL_SINK)) break; pad = media_entity_remote_pad(pad); if (pad == NULL || media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV) break; entity = pad->entity; subdev = media_entity_to_v4l2_subdev(entity); ret = v4l2_subdev_call(subdev, video, s_stream, start); if (start && ret < 0 && ret != -ENOIOCTLCMD) return ret; } return 0; } /** * xvip_pipeline_set_stream - Enable/disable streaming on a pipeline * @pipe: The pipeline * @on: Turn the stream on when true or off when false * * The pipeline is shared between all DMA engines connect at its input and * output. While the stream state of DMA engines can be controlled * independently, pipelines have a shared stream state that enable or disable * all entities in the pipeline. For this reason the pipeline uses a streaming * counter that tracks the number of DMA engines that have requested the stream * to be enabled. * * When called with the @on argument set to true, this function will increment * the pipeline streaming count. If the streaming count reaches the number of * DMA engines in the pipeline it will enable all entities that belong to the * pipeline. * * Similarly, when called with the @on argument set to false, this function will * decrement the pipeline streaming count and disable all entities in the * pipeline when the streaming count reaches zero. * * Return: 0 if successful, or the return value of the failed video::s_stream * operation otherwise. Stopping the pipeline never fails. The pipeline state is * not updated when the operation fails. */ static int xvip_pipeline_set_stream(struct xvip_pipeline *pipe, bool on) { int ret = 0; mutex_lock(&pipe->lock); if (on) { if (pipe->stream_count == pipe->num_dmas - 1) { ret = xvip_pipeline_start_stop(pipe, true); if (ret < 0) goto done; } pipe->stream_count++; } else { if (--pipe->stream_count == 0) xvip_pipeline_start_stop(pipe, false); } done: mutex_unlock(&pipe->lock); return ret; } static int xvip_pipeline_validate(struct xvip_pipeline *pipe, struct xvip_dma *start) { struct media_entity_graph graph; struct media_entity *entity = &start->video.entity; struct media_device *mdev = entity->parent; unsigned int num_inputs = 0; unsigned int num_outputs = 0; mutex_lock(&mdev->graph_mutex); /* Walk the graph to locate the video nodes. */ media_entity_graph_walk_start(&graph, entity); while ((entity = media_entity_graph_walk_next(&graph))) { struct xvip_dma *dma; if (entity->type != MEDIA_ENT_T_DEVNODE_V4L) continue; dma = to_xvip_dma(media_entity_to_video_device(entity)); if (dma->pad.flags & MEDIA_PAD_FL_SINK) { pipe->output = dma; num_outputs++; } else { num_inputs++; } } mutex_unlock(&mdev->graph_mutex); /* We need exactly one output and zero or one input. */ if (num_outputs != 1 || num_inputs > 1) return -EPIPE; pipe->num_dmas = num_inputs + num_outputs; return 0; } static void __xvip_pipeline_cleanup(struct xvip_pipeline *pipe) { pipe->num_dmas = 0; pipe->output = NULL; } /** * xvip_pipeline_cleanup - Cleanup the pipeline after streaming * @pipe: the pipeline * * Decrease the pipeline use count and clean it up if we were the last user. */ static void xvip_pipeline_cleanup(struct xvip_pipeline *pipe) { mutex_lock(&pipe->lock); /* If we're the last user clean up the pipeline. */ if (--pipe->use_count == 0) __xvip_pipeline_cleanup(pipe); mutex_unlock(&pipe->lock); } /** * xvip_pipeline_prepare - Prepare the pipeline for streaming * @pipe: the pipeline * @dma: DMA engine at one end of the pipeline * * Validate the pipeline if no user exists yet, otherwise just increase the use * count. * * Return: 0 if successful or -EPIPE if the pipeline is not valid. */ static int xvip_pipeline_prepare(struct xvip_pipeline *pipe, struct xvip_dma *dma) { int ret; mutex_lock(&pipe->lock); /* If we're the first user validate and initialize the pipeline. */ if (pipe->use_count == 0) { ret = xvip_pipeline_validate(pipe, dma); if (ret < 0) { __xvip_pipeline_cleanup(pipe); goto done; } } pipe->use_count++; ret = 0; done: mutex_unlock(&pipe->lock); return ret; } /* ----------------------------------------------------------------------------- * videobuf2 queue operations */ /** * struct xvip_dma_buffer - Video DMA buffer * @buf: vb2 buffer base object * @queue: buffer list entry in the DMA engine queued buffers list * @dma: DMA channel that uses the buffer */ struct xvip_dma_buffer { struct vb2_v4l2_buffer buf; struct list_head queue; struct xvip_dma *dma; }; #define to_xvip_dma_buffer(vb) container_of(vb, struct xvip_dma_buffer, buf) static void xvip_dma_complete(void *param) { struct xvip_dma_buffer *buf = param; struct xvip_dma *dma = buf->dma; spin_lock(&dma->queued_lock); list_del(&buf->queue); spin_unlock(&dma->queued_lock); buf->buf.field = V4L2_FIELD_NONE; buf->buf.sequence = dma->sequence++; v4l2_get_timestamp(&buf->buf.timestamp); vb2_set_plane_payload(&buf->buf.vb2_buf, 0, dma->format.sizeimage); vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_DONE); } static int xvip_dma_queue_setup(struct vb2_queue *vq, const void *parg, unsigned int *nbuffers, unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[]) { const struct v4l2_format *fmt = parg; struct xvip_dma *dma = vb2_get_drv_priv(vq); /* Make sure the image size is large enough. */ if (fmt && fmt->fmt.pix.sizeimage < dma->format.sizeimage) return -EINVAL; *nplanes = 1; sizes[0] = fmt ? fmt->fmt.pix.sizeimage : dma->format.sizeimage; alloc_ctxs[0] = dma->alloc_ctx; return 0; } static int xvip_dma_buffer_prepare(struct vb2_buffer *vb) { struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); struct xvip_dma *dma = vb2_get_drv_priv(vb->vb2_queue); struct xvip_dma_buffer *buf = to_xvip_dma_buffer(vbuf); buf->dma = dma; return 0; } static void xvip_dma_buffer_queue(struct vb2_buffer *vb) { struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); struct xvip_dma *dma = vb2_get_drv_priv(vb->vb2_queue); struct xvip_dma_buffer *buf = to_xvip_dma_buffer(vbuf); struct dma_async_tx_descriptor *desc; dma_addr_t addr = vb2_dma_contig_plane_dma_addr(vb, 0); u32 flags; if (dma->queue.type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { flags = DMA_PREP_INTERRUPT | DMA_CTRL_ACK; dma->xt.dir = DMA_DEV_TO_MEM; dma->xt.src_sgl = false; dma->xt.dst_sgl = true; dma->xt.dst_start = addr; } else { flags = DMA_PREP_INTERRUPT | DMA_CTRL_ACK; dma->xt.dir = DMA_MEM_TO_DEV; dma->xt.src_sgl = true; dma->xt.dst_sgl = false; dma->xt.src_start = addr; } dma->xt.frame_size = 1; dma->sgl[0].size = dma->format.width * dma->fmtinfo->bpp; dma->sgl[0].icg = dma->format.bytesperline - dma->sgl[0].size; dma->xt.numf = dma->format.height; desc = dmaengine_prep_interleaved_dma(dma->dma, &dma->xt, flags); if (!desc) { dev_err(dma->xdev->dev, "Failed to prepare DMA transfer\n"); vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_ERROR); return; } desc->callback = xvip_dma_complete; desc->callback_param = buf; spin_lock_irq(&dma->queued_lock); list_add_tail(&buf->queue, &dma->queued_bufs); spin_unlock_irq(&dma->queued_lock); dmaengine_submit(desc); if (vb2_is_streaming(&dma->queue)) dma_async_issue_pending(dma->dma); } static int xvip_dma_start_streaming(struct vb2_queue *vq, unsigned int count) { struct xvip_dma *dma = vb2_get_drv_priv(vq); struct xvip_dma_buffer *buf, *nbuf; struct xvip_pipeline *pipe; int ret; dma->sequence = 0; /* * Start streaming on the pipeline. No link touching an entity in the * pipeline can be activated or deactivated once streaming is started. * * Use the pipeline object embedded in the first DMA object that starts * streaming. */ pipe = dma->video.entity.pipe ? to_xvip_pipeline(&dma->video.entity) : &dma->pipe; ret = media_entity_pipeline_start(&dma->video.entity, &pipe->pipe); if (ret < 0) goto error; /* Verify that the configured format matches the output of the * connected subdev. */ ret = xvip_dma_verify_format(dma); if (ret < 0) goto error_stop; ret = xvip_pipeline_prepare(pipe, dma); if (ret < 0) goto error_stop; /* Start the DMA engine. This must be done before starting the blocks * in the pipeline to avoid DMA synchronization issues. */ dma_async_issue_pending(dma->dma); /* Start the pipeline. */ xvip_pipeline_set_stream(pipe, true); return 0; error_stop: media_entity_pipeline_stop(&dma->video.entity); error: /* Give back all queued buffers to videobuf2. */ spin_lock_irq(&dma->queued_lock); list_for_each_entry_safe(buf, nbuf, &dma->queued_bufs, queue) { vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_QUEUED); list_del(&buf->queue); } spin_unlock_irq(&dma->queued_lock); return ret; } static void xvip_dma_stop_streaming(struct vb2_queue *vq) { struct xvip_dma *dma = vb2_get_drv_priv(vq); struct xvip_pipeline *pipe = to_xvip_pipeline(&dma->video.entity); struct xvip_dma_buffer *buf, *nbuf; /* Stop the pipeline. */ xvip_pipeline_set_stream(pipe, false); /* Stop and reset the DMA engine. */ dmaengine_terminate_all(dma->dma); /* Cleanup the pipeline and mark it as being stopped. */ xvip_pipeline_cleanup(pipe); media_entity_pipeline_stop(&dma->video.entity); /* Give back all queued buffers to videobuf2. */ spin_lock_irq(&dma->queued_lock); list_for_each_entry_safe(buf, nbuf, &dma->queued_bufs, queue) { vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_ERROR); list_del(&buf->queue); } spin_unlock_irq(&dma->queued_lock); } static struct vb2_ops xvip_dma_queue_qops = { .queue_setup = xvip_dma_queue_setup, .buf_prepare = xvip_dma_buffer_prepare, .buf_queue = xvip_dma_buffer_queue, .wait_prepare = vb2_ops_wait_prepare, .wait_finish = vb2_ops_wait_finish, .start_streaming = xvip_dma_start_streaming, .stop_streaming = xvip_dma_stop_streaming, }; /* ----------------------------------------------------------------------------- * V4L2 ioctls */ static int xvip_dma_querycap(struct file *file, void *fh, struct v4l2_capability *cap) { struct v4l2_fh *vfh = file->private_data; struct xvip_dma *dma = to_xvip_dma(vfh->vdev); cap->capabilities = V4L2_CAP_DEVICE_CAPS | V4L2_CAP_STREAMING | dma->xdev->v4l2_caps; if (dma->queue.type == V4L2_BUF_TYPE_VIDEO_CAPTURE) cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; else cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING; strlcpy(cap->driver, "xilinx-vipp", sizeof(cap->driver)); strlcpy(cap->card, dma->video.name, sizeof(cap->card)); snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s:%u", dma->xdev->dev->of_node->name, dma->port); return 0; } /* FIXME: without this callback function, some applications are not configured * with correct formats, and it results in frames in wrong format. Whether this * callback needs to be required is not clearly defined, so it should be * clarified through the mailing list. */ static int xvip_dma_enum_format(struct file *file, void *fh, struct v4l2_fmtdesc *f) { struct v4l2_fh *vfh = file->private_data; struct xvip_dma *dma = to_xvip_dma(vfh->vdev); if (f->index > 0) return -EINVAL; f->pixelformat = dma->format.pixelformat; strlcpy(f->description, dma->fmtinfo->description, sizeof(f->description)); return 0; } static int xvip_dma_get_format(struct file *file, void *fh, struct v4l2_format *format) { struct v4l2_fh *vfh = file->private_data; struct xvip_dma *dma = to_xvip_dma(vfh->vdev); format->fmt.pix = dma->format; return 0; } static void __xvip_dma_try_format(struct xvip_dma *dma, struct v4l2_pix_format *pix, const struct xvip_video_format **fmtinfo) { const struct xvip_video_format *info; unsigned int min_width; unsigned int max_width; unsigned int min_bpl; unsigned int max_bpl; unsigned int width; unsigned int align; unsigned int bpl; /* Retrieve format information and select the default format if the * requested format isn't supported. */ info = xvip_get_format_by_fourcc(pix->pixelformat); if (IS_ERR(info)) info = xvip_get_format_by_fourcc(XVIP_DMA_DEF_FORMAT); pix->pixelformat = info->fourcc; pix->field = V4L2_FIELD_NONE; /* The transfer alignment requirements are expressed in bytes. Compute * the minimum and maximum values, clamp the requested width and convert * it back to pixels. */ align = lcm(dma->align, info->bpp); min_width = roundup(XVIP_DMA_MIN_WIDTH, align); max_width = rounddown(XVIP_DMA_MAX_WIDTH, align); width = rounddown(pix->width * info->bpp, align); pix->width = clamp(width, min_width, max_width) / info->bpp; pix->height = clamp(pix->height, XVIP_DMA_MIN_HEIGHT, XVIP_DMA_MAX_HEIGHT); /* Clamp the requested bytes per line value. If the maximum bytes per * line value is zero, the module doesn't support user configurable line * sizes. Override the requested value with the minimum in that case. */ min_bpl = pix->width * info->bpp; max_bpl = rounddown(XVIP_DMA_MAX_WIDTH, dma->align); bpl = rounddown(pix->bytesperline, dma->align); pix->bytesperline = clamp(bpl, min_bpl, max_bpl); pix->sizeimage = pix->bytesperline * pix->height; if (fmtinfo) *fmtinfo = info; } static int xvip_dma_try_format(struct file *file, void *fh, struct v4l2_format *format) { struct v4l2_fh *vfh = file->private_data; struct xvip_dma *dma = to_xvip_dma(vfh->vdev); __xvip_dma_try_format(dma, &format->fmt.pix, NULL); return 0; } static int xvip_dma_set_format(struct file *file, void *fh, struct v4l2_format *format) { struct v4l2_fh *vfh = file->private_data; struct xvip_dma *dma = to_xvip_dma(vfh->vdev); const struct xvip_video_format *info; __xvip_dma_try_format(dma, &format->fmt.pix, &info); if (vb2_is_busy(&dma->queue)) return -EBUSY; dma->format = format->fmt.pix; dma->fmtinfo = info; return 0; } static const struct v4l2_ioctl_ops xvip_dma_ioctl_ops = { .vidioc_querycap = xvip_dma_querycap, .vidioc_enum_fmt_vid_cap = xvip_dma_enum_format, .vidioc_g_fmt_vid_cap = xvip_dma_get_format, .vidioc_g_fmt_vid_out = xvip_dma_get_format, .vidioc_s_fmt_vid_cap = xvip_dma_set_format, .vidioc_s_fmt_vid_out = xvip_dma_set_format, .vidioc_try_fmt_vid_cap = xvip_dma_try_format, .vidioc_try_fmt_vid_out = xvip_dma_try_format, .vidioc_reqbufs = vb2_ioctl_reqbufs, .vidioc_querybuf = vb2_ioctl_querybuf, .vidioc_qbuf = vb2_ioctl_qbuf, .vidioc_dqbuf = vb2_ioctl_dqbuf, .vidioc_create_bufs = vb2_ioctl_create_bufs, .vidioc_expbuf = vb2_ioctl_expbuf, .vidioc_streamon = vb2_ioctl_streamon, .vidioc_streamoff = vb2_ioctl_streamoff, }; /* ----------------------------------------------------------------------------- * V4L2 file operations */ static const struct v4l2_file_operations xvip_dma_fops = { .owner = THIS_MODULE, .unlocked_ioctl = video_ioctl2, .open = v4l2_fh_open, .release = vb2_fop_release, .poll = vb2_fop_poll, .mmap = vb2_fop_mmap, }; /* ----------------------------------------------------------------------------- * Xilinx Video DMA Core */ int xvip_dma_init(struct xvip_composite_device *xdev, struct xvip_dma *dma, enum v4l2_buf_type type, unsigned int port) { char name[16]; int ret; dma->xdev = xdev; dma->port = port; mutex_init(&dma->lock); mutex_init(&dma->pipe.lock); INIT_LIST_HEAD(&dma->queued_bufs); spin_lock_init(&dma->queued_lock); dma->fmtinfo = xvip_get_format_by_fourcc(XVIP_DMA_DEF_FORMAT); dma->format.pixelformat = dma->fmtinfo->fourcc; dma->format.colorspace = V4L2_COLORSPACE_SRGB; dma->format.field = V4L2_FIELD_NONE; dma->format.width = XVIP_DMA_DEF_WIDTH; dma->format.height = XVIP_DMA_DEF_HEIGHT; dma->format.bytesperline = dma->format.width * dma->fmtinfo->bpp; dma->format.sizeimage = dma->format.bytesperline * dma->format.height; /* Initialize the media entity... */ dma->pad.flags = type == V4L2_BUF_TYPE_VIDEO_CAPTURE ? MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE; ret = media_entity_init(&dma->video.entity, 1, &dma->pad, 0); if (ret < 0) goto error; /* ... and the video node... */ dma->video.fops = &xvip_dma_fops; dma->video.v4l2_dev = &xdev->v4l2_dev; dma->video.queue = &dma->queue; snprintf(dma->video.name, sizeof(dma->video.name), "%s %s %u", xdev->dev->of_node->name, type == V4L2_BUF_TYPE_VIDEO_CAPTURE ? "output" : "input", port); dma->video.vfl_type = VFL_TYPE_GRABBER; dma->video.vfl_dir = type == V4L2_BUF_TYPE_VIDEO_CAPTURE ? VFL_DIR_RX : VFL_DIR_TX; dma->video.release = video_device_release_empty; dma->video.ioctl_ops = &xvip_dma_ioctl_ops; dma->video.lock = &dma->lock; video_set_drvdata(&dma->video, dma); /* ... and the buffers queue... */ dma->alloc_ctx = vb2_dma_contig_init_ctx(dma->xdev->dev); if (IS_ERR(dma->alloc_ctx)) { ret = PTR_ERR(dma->alloc_ctx); goto error; } /* Don't enable VB2_READ and VB2_WRITE, as using the read() and write() * V4L2 APIs would be inefficient. Testing on the command line with a * 'cat /dev/video?' thus won't be possible, but given that the driver * anyway requires a test tool to setup the pipeline before any video * stream can be started, requiring a specific V4L2 test tool as well * instead of 'cat' isn't really a drawback. */ dma->queue.type = type; dma->queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF; dma->queue.lock = &dma->lock; dma->queue.drv_priv = dma; dma->queue.buf_struct_size = sizeof(struct xvip_dma_buffer); dma->queue.ops = &xvip_dma_queue_qops; dma->queue.mem_ops = &vb2_dma_contig_memops; dma->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC | V4L2_BUF_FLAG_TSTAMP_SRC_EOF; ret = vb2_queue_init(&dma->queue); if (ret < 0) { dev_err(dma->xdev->dev, "failed to initialize VB2 queue\n"); goto error; } /* ... and the DMA channel. */ snprintf(name, sizeof(name), "port%u", port); dma->dma = dma_request_slave_channel(dma->xdev->dev, name); if (dma->dma == NULL) { dev_err(dma->xdev->dev, "no VDMA channel found\n"); ret = -ENODEV; goto error; } dma->align = 1 << dma->dma->device->copy_align; ret = video_register_device(&dma->video, VFL_TYPE_GRABBER, -1); if (ret < 0) { dev_err(dma->xdev->dev, "failed to register video device\n"); goto error; } return 0; error: xvip_dma_cleanup(dma); return ret; } void xvip_dma_cleanup(struct xvip_dma *dma) { if (video_is_registered(&dma->video)) video_unregister_device(&dma->video); if (dma->dma) dma_release_channel(dma->dma); if (!IS_ERR_OR_NULL(dma->alloc_ctx)) vb2_dma_contig_cleanup_ctx(dma->alloc_ctx); media_entity_cleanup(&dma->video.entity); mutex_destroy(&dma->lock); mutex_destroy(&dma->pipe.lock); }