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