1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Cedrus VPU driver
4 *
5 * Copyright (C) 2016 Florent Revest <florent.revest@free-electrons.com>
6 * Copyright (C) 2018 Paul Kocialkowski <paul.kocialkowski@bootlin.com>
7 * Copyright (C) 2018 Bootlin
8 *
9 * Based on the vim2m driver, that is:
10 *
11 * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd.
12 * Pawel Osciak, <pawel@osciak.com>
13 * Marek Szyprowski, <m.szyprowski@samsung.com>
14 */
15
16 #include <linux/pm_runtime.h>
17
18 #include <media/videobuf2-dma-contig.h>
19 #include <media/v4l2-device.h>
20 #include <media/v4l2-ioctl.h>
21 #include <media/v4l2-event.h>
22 #include <media/v4l2-mem2mem.h>
23
24 #include "cedrus.h"
25 #include "cedrus_video.h"
26 #include "cedrus_dec.h"
27 #include "cedrus_hw.h"
28
29 #define CEDRUS_DECODE_SRC BIT(0)
30 #define CEDRUS_DECODE_DST BIT(1)
31
32 #define CEDRUS_MIN_WIDTH 16U
33 #define CEDRUS_MIN_HEIGHT 16U
34 #define CEDRUS_MAX_WIDTH 4096U
35 #define CEDRUS_MAX_HEIGHT 2304U
36
37 static struct cedrus_format cedrus_formats[] = {
38 {
39 .pixelformat = V4L2_PIX_FMT_MPEG2_SLICE,
40 .directions = CEDRUS_DECODE_SRC,
41 .capabilities = CEDRUS_CAPABILITY_MPEG2_DEC,
42 },
43 {
44 .pixelformat = V4L2_PIX_FMT_H264_SLICE,
45 .directions = CEDRUS_DECODE_SRC,
46 .capabilities = CEDRUS_CAPABILITY_H264_DEC,
47 },
48 {
49 .pixelformat = V4L2_PIX_FMT_HEVC_SLICE,
50 .directions = CEDRUS_DECODE_SRC,
51 .capabilities = CEDRUS_CAPABILITY_H265_DEC,
52 },
53 {
54 .pixelformat = V4L2_PIX_FMT_VP8_FRAME,
55 .directions = CEDRUS_DECODE_SRC,
56 .capabilities = CEDRUS_CAPABILITY_VP8_DEC,
57 },
58 {
59 .pixelformat = V4L2_PIX_FMT_SUNXI_TILED_NV12,
60 .directions = CEDRUS_DECODE_DST,
61 },
62 {
63 .pixelformat = V4L2_PIX_FMT_NV12,
64 .directions = CEDRUS_DECODE_DST,
65 .capabilities = CEDRUS_CAPABILITY_UNTILED,
66 },
67 };
68
69 #define CEDRUS_FORMATS_COUNT ARRAY_SIZE(cedrus_formats)
70
cedrus_file2ctx(struct file * file)71 static inline struct cedrus_ctx *cedrus_file2ctx(struct file *file)
72 {
73 return container_of(file->private_data, struct cedrus_ctx, fh);
74 }
75
cedrus_find_format(u32 pixelformat,u32 directions,unsigned int capabilities)76 static struct cedrus_format *cedrus_find_format(u32 pixelformat, u32 directions,
77 unsigned int capabilities)
78 {
79 struct cedrus_format *first_valid_fmt = NULL;
80 struct cedrus_format *fmt;
81 unsigned int i;
82
83 for (i = 0; i < CEDRUS_FORMATS_COUNT; i++) {
84 fmt = &cedrus_formats[i];
85
86 if ((fmt->capabilities & capabilities) != fmt->capabilities ||
87 !(fmt->directions & directions))
88 continue;
89
90 if (fmt->pixelformat == pixelformat)
91 break;
92
93 if (!first_valid_fmt)
94 first_valid_fmt = fmt;
95 }
96
97 if (i == CEDRUS_FORMATS_COUNT)
98 return first_valid_fmt;
99
100 return &cedrus_formats[i];
101 }
102
cedrus_prepare_format(struct v4l2_pix_format * pix_fmt)103 void cedrus_prepare_format(struct v4l2_pix_format *pix_fmt)
104 {
105 unsigned int width = pix_fmt->width;
106 unsigned int height = pix_fmt->height;
107 unsigned int sizeimage = pix_fmt->sizeimage;
108 unsigned int bytesperline = pix_fmt->bytesperline;
109
110 pix_fmt->field = V4L2_FIELD_NONE;
111
112 /* Limit to hardware min/max. */
113 width = clamp(width, CEDRUS_MIN_WIDTH, CEDRUS_MAX_WIDTH);
114 height = clamp(height, CEDRUS_MIN_HEIGHT, CEDRUS_MAX_HEIGHT);
115
116 switch (pix_fmt->pixelformat) {
117 case V4L2_PIX_FMT_MPEG2_SLICE:
118 case V4L2_PIX_FMT_H264_SLICE:
119 case V4L2_PIX_FMT_HEVC_SLICE:
120 case V4L2_PIX_FMT_VP8_FRAME:
121 /* Zero bytes per line for encoded source. */
122 bytesperline = 0;
123 /* Choose some minimum size since this can't be 0 */
124 sizeimage = max_t(u32, SZ_1K, sizeimage);
125 break;
126
127 case V4L2_PIX_FMT_SUNXI_TILED_NV12:
128 /* 32-aligned stride. */
129 bytesperline = ALIGN(width, 32);
130
131 /* 32-aligned height. */
132 height = ALIGN(height, 32);
133
134 /* Luma plane size. */
135 sizeimage = bytesperline * height;
136
137 /* Chroma plane size. */
138 sizeimage += bytesperline * ALIGN(height, 64) / 2;
139
140 break;
141
142 case V4L2_PIX_FMT_NV12:
143 /* 16-aligned stride. */
144 bytesperline = ALIGN(width, 16);
145
146 /* 16-aligned height. */
147 height = ALIGN(height, 16);
148
149 /* Luma plane size. */
150 sizeimage = bytesperline * height;
151
152 /* Chroma plane size. */
153 sizeimage += bytesperline * height / 2;
154
155 break;
156 }
157
158 pix_fmt->width = width;
159 pix_fmt->height = height;
160
161 pix_fmt->bytesperline = bytesperline;
162 pix_fmt->sizeimage = sizeimage;
163 }
164
cedrus_querycap(struct file * file,void * priv,struct v4l2_capability * cap)165 static int cedrus_querycap(struct file *file, void *priv,
166 struct v4l2_capability *cap)
167 {
168 strscpy(cap->driver, CEDRUS_NAME, sizeof(cap->driver));
169 strscpy(cap->card, CEDRUS_NAME, sizeof(cap->card));
170 snprintf(cap->bus_info, sizeof(cap->bus_info),
171 "platform:%s", CEDRUS_NAME);
172
173 return 0;
174 }
175
cedrus_enum_fmt(struct file * file,struct v4l2_fmtdesc * f,u32 direction)176 static int cedrus_enum_fmt(struct file *file, struct v4l2_fmtdesc *f,
177 u32 direction)
178 {
179 struct cedrus_ctx *ctx = cedrus_file2ctx(file);
180 struct cedrus_dev *dev = ctx->dev;
181 unsigned int capabilities = dev->capabilities;
182 struct cedrus_format *fmt;
183 unsigned int i, index;
184
185 /* Index among formats that match the requested direction. */
186 index = 0;
187
188 for (i = 0; i < CEDRUS_FORMATS_COUNT; i++) {
189 fmt = &cedrus_formats[i];
190
191 if (fmt->capabilities && (fmt->capabilities & capabilities) !=
192 fmt->capabilities)
193 continue;
194
195 if (!(cedrus_formats[i].directions & direction))
196 continue;
197
198 if (index == f->index)
199 break;
200
201 index++;
202 }
203
204 /* Matched format. */
205 if (i < CEDRUS_FORMATS_COUNT) {
206 f->pixelformat = cedrus_formats[i].pixelformat;
207
208 return 0;
209 }
210
211 return -EINVAL;
212 }
213
cedrus_enum_fmt_vid_cap(struct file * file,void * priv,struct v4l2_fmtdesc * f)214 static int cedrus_enum_fmt_vid_cap(struct file *file, void *priv,
215 struct v4l2_fmtdesc *f)
216 {
217 return cedrus_enum_fmt(file, f, CEDRUS_DECODE_DST);
218 }
219
cedrus_enum_fmt_vid_out(struct file * file,void * priv,struct v4l2_fmtdesc * f)220 static int cedrus_enum_fmt_vid_out(struct file *file, void *priv,
221 struct v4l2_fmtdesc *f)
222 {
223 return cedrus_enum_fmt(file, f, CEDRUS_DECODE_SRC);
224 }
225
cedrus_g_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)226 static int cedrus_g_fmt_vid_cap(struct file *file, void *priv,
227 struct v4l2_format *f)
228 {
229 struct cedrus_ctx *ctx = cedrus_file2ctx(file);
230
231 f->fmt.pix = ctx->dst_fmt;
232 return 0;
233 }
234
cedrus_g_fmt_vid_out(struct file * file,void * priv,struct v4l2_format * f)235 static int cedrus_g_fmt_vid_out(struct file *file, void *priv,
236 struct v4l2_format *f)
237 {
238 struct cedrus_ctx *ctx = cedrus_file2ctx(file);
239
240 f->fmt.pix = ctx->src_fmt;
241 return 0;
242 }
243
cedrus_try_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)244 static int cedrus_try_fmt_vid_cap(struct file *file, void *priv,
245 struct v4l2_format *f)
246 {
247 struct cedrus_ctx *ctx = cedrus_file2ctx(file);
248 struct cedrus_dev *dev = ctx->dev;
249 struct v4l2_pix_format *pix_fmt = &f->fmt.pix;
250 struct cedrus_format *fmt =
251 cedrus_find_format(pix_fmt->pixelformat, CEDRUS_DECODE_DST,
252 dev->capabilities);
253
254 if (!fmt)
255 return -EINVAL;
256
257 pix_fmt->pixelformat = fmt->pixelformat;
258 pix_fmt->width = ctx->src_fmt.width;
259 pix_fmt->height = ctx->src_fmt.height;
260 cedrus_prepare_format(pix_fmt);
261
262 return 0;
263 }
264
cedrus_try_fmt_vid_out(struct file * file,void * priv,struct v4l2_format * f)265 static int cedrus_try_fmt_vid_out(struct file *file, void *priv,
266 struct v4l2_format *f)
267 {
268 struct cedrus_ctx *ctx = cedrus_file2ctx(file);
269 struct cedrus_dev *dev = ctx->dev;
270 struct v4l2_pix_format *pix_fmt = &f->fmt.pix;
271 struct cedrus_format *fmt =
272 cedrus_find_format(pix_fmt->pixelformat, CEDRUS_DECODE_SRC,
273 dev->capabilities);
274
275 if (!fmt)
276 return -EINVAL;
277
278 pix_fmt->pixelformat = fmt->pixelformat;
279 cedrus_prepare_format(pix_fmt);
280
281 return 0;
282 }
283
cedrus_s_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)284 static int cedrus_s_fmt_vid_cap(struct file *file, void *priv,
285 struct v4l2_format *f)
286 {
287 struct cedrus_ctx *ctx = cedrus_file2ctx(file);
288 struct vb2_queue *vq;
289 int ret;
290
291 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
292 if (vb2_is_busy(vq))
293 return -EBUSY;
294
295 ret = cedrus_try_fmt_vid_cap(file, priv, f);
296 if (ret)
297 return ret;
298
299 ctx->dst_fmt = f->fmt.pix;
300
301 return 0;
302 }
303
cedrus_s_fmt_vid_out(struct file * file,void * priv,struct v4l2_format * f)304 static int cedrus_s_fmt_vid_out(struct file *file, void *priv,
305 struct v4l2_format *f)
306 {
307 struct cedrus_ctx *ctx = cedrus_file2ctx(file);
308 struct vb2_queue *vq;
309 struct vb2_queue *peer_vq;
310 int ret;
311
312 ret = cedrus_try_fmt_vid_out(file, priv, f);
313 if (ret)
314 return ret;
315
316 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
317 /*
318 * In order to support dynamic resolution change,
319 * the decoder admits a resolution change, as long
320 * as the pixelformat remains. Can't be done if streaming.
321 */
322 if (vb2_is_streaming(vq) || (vb2_is_busy(vq) &&
323 f->fmt.pix.pixelformat != ctx->src_fmt.pixelformat))
324 return -EBUSY;
325 /*
326 * Since format change on the OUTPUT queue will reset
327 * the CAPTURE queue, we can't allow doing so
328 * when the CAPTURE queue has buffers allocated.
329 */
330 peer_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
331 V4L2_BUF_TYPE_VIDEO_CAPTURE);
332 if (vb2_is_busy(peer_vq))
333 return -EBUSY;
334
335 ret = cedrus_try_fmt_vid_out(file, priv, f);
336 if (ret)
337 return ret;
338
339 ctx->src_fmt = f->fmt.pix;
340
341 switch (ctx->src_fmt.pixelformat) {
342 case V4L2_PIX_FMT_H264_SLICE:
343 case V4L2_PIX_FMT_HEVC_SLICE:
344 vq->subsystem_flags |=
345 VB2_V4L2_FL_SUPPORTS_M2M_HOLD_CAPTURE_BUF;
346 break;
347 default:
348 vq->subsystem_flags &=
349 ~VB2_V4L2_FL_SUPPORTS_M2M_HOLD_CAPTURE_BUF;
350 break;
351 }
352
353 /* Propagate format information to capture. */
354 ctx->dst_fmt.colorspace = f->fmt.pix.colorspace;
355 ctx->dst_fmt.xfer_func = f->fmt.pix.xfer_func;
356 ctx->dst_fmt.ycbcr_enc = f->fmt.pix.ycbcr_enc;
357 ctx->dst_fmt.quantization = f->fmt.pix.quantization;
358 ctx->dst_fmt.width = ctx->src_fmt.width;
359 ctx->dst_fmt.height = ctx->src_fmt.height;
360 cedrus_prepare_format(&ctx->dst_fmt);
361
362 return 0;
363 }
364
365 const struct v4l2_ioctl_ops cedrus_ioctl_ops = {
366 .vidioc_querycap = cedrus_querycap,
367
368 .vidioc_enum_fmt_vid_cap = cedrus_enum_fmt_vid_cap,
369 .vidioc_g_fmt_vid_cap = cedrus_g_fmt_vid_cap,
370 .vidioc_try_fmt_vid_cap = cedrus_try_fmt_vid_cap,
371 .vidioc_s_fmt_vid_cap = cedrus_s_fmt_vid_cap,
372
373 .vidioc_enum_fmt_vid_out = cedrus_enum_fmt_vid_out,
374 .vidioc_g_fmt_vid_out = cedrus_g_fmt_vid_out,
375 .vidioc_try_fmt_vid_out = cedrus_try_fmt_vid_out,
376 .vidioc_s_fmt_vid_out = cedrus_s_fmt_vid_out,
377
378 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
379 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
380 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
381 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
382 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,
383 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
384 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
385
386 .vidioc_streamon = v4l2_m2m_ioctl_streamon,
387 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
388
389 .vidioc_try_decoder_cmd = v4l2_m2m_ioctl_stateless_try_decoder_cmd,
390 .vidioc_decoder_cmd = v4l2_m2m_ioctl_stateless_decoder_cmd,
391
392 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
393 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
394 };
395
cedrus_queue_setup(struct vb2_queue * vq,unsigned int * nbufs,unsigned int * nplanes,unsigned int sizes[],struct device * alloc_devs[])396 static int cedrus_queue_setup(struct vb2_queue *vq, unsigned int *nbufs,
397 unsigned int *nplanes, unsigned int sizes[],
398 struct device *alloc_devs[])
399 {
400 struct cedrus_ctx *ctx = vb2_get_drv_priv(vq);
401 struct v4l2_pix_format *pix_fmt;
402
403 if (V4L2_TYPE_IS_OUTPUT(vq->type))
404 pix_fmt = &ctx->src_fmt;
405 else
406 pix_fmt = &ctx->dst_fmt;
407
408 if (*nplanes) {
409 if (sizes[0] < pix_fmt->sizeimage)
410 return -EINVAL;
411 } else {
412 sizes[0] = pix_fmt->sizeimage;
413 *nplanes = 1;
414 }
415
416 return 0;
417 }
418
cedrus_queue_cleanup(struct vb2_queue * vq,u32 state)419 static void cedrus_queue_cleanup(struct vb2_queue *vq, u32 state)
420 {
421 struct cedrus_ctx *ctx = vb2_get_drv_priv(vq);
422 struct vb2_v4l2_buffer *vbuf;
423
424 for (;;) {
425 if (V4L2_TYPE_IS_OUTPUT(vq->type))
426 vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
427 else
428 vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
429
430 if (!vbuf)
431 return;
432
433 v4l2_ctrl_request_complete(vbuf->vb2_buf.req_obj.req,
434 &ctx->hdl);
435 v4l2_m2m_buf_done(vbuf, state);
436 }
437 }
438
cedrus_buf_out_validate(struct vb2_buffer * vb)439 static int cedrus_buf_out_validate(struct vb2_buffer *vb)
440 {
441 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
442
443 vbuf->field = V4L2_FIELD_NONE;
444 return 0;
445 }
446
cedrus_buf_prepare(struct vb2_buffer * vb)447 static int cedrus_buf_prepare(struct vb2_buffer *vb)
448 {
449 struct vb2_queue *vq = vb->vb2_queue;
450 struct cedrus_ctx *ctx = vb2_get_drv_priv(vq);
451 struct v4l2_pix_format *pix_fmt;
452
453 if (V4L2_TYPE_IS_OUTPUT(vq->type))
454 pix_fmt = &ctx->src_fmt;
455 else
456 pix_fmt = &ctx->dst_fmt;
457
458 if (vb2_plane_size(vb, 0) < pix_fmt->sizeimage)
459 return -EINVAL;
460
461 /*
462 * Buffer's bytesused must be written by driver for CAPTURE buffers.
463 * (for OUTPUT buffers, if userspace passes 0 bytesused, v4l2-core sets
464 * it to buffer length).
465 */
466 if (V4L2_TYPE_IS_CAPTURE(vq->type))
467 vb2_set_plane_payload(vb, 0, pix_fmt->sizeimage);
468
469 return 0;
470 }
471
cedrus_start_streaming(struct vb2_queue * vq,unsigned int count)472 static int cedrus_start_streaming(struct vb2_queue *vq, unsigned int count)
473 {
474 struct cedrus_ctx *ctx = vb2_get_drv_priv(vq);
475 struct cedrus_dev *dev = ctx->dev;
476 int ret = 0;
477
478 switch (ctx->src_fmt.pixelformat) {
479 case V4L2_PIX_FMT_MPEG2_SLICE:
480 ctx->current_codec = CEDRUS_CODEC_MPEG2;
481 break;
482
483 case V4L2_PIX_FMT_H264_SLICE:
484 ctx->current_codec = CEDRUS_CODEC_H264;
485 break;
486
487 case V4L2_PIX_FMT_HEVC_SLICE:
488 ctx->current_codec = CEDRUS_CODEC_H265;
489 break;
490
491 case V4L2_PIX_FMT_VP8_FRAME:
492 ctx->current_codec = CEDRUS_CODEC_VP8;
493 break;
494
495 default:
496 return -EINVAL;
497 }
498
499 if (V4L2_TYPE_IS_OUTPUT(vq->type)) {
500 ret = pm_runtime_resume_and_get(dev->dev);
501 if (ret < 0)
502 goto err_cleanup;
503
504 if (dev->dec_ops[ctx->current_codec]->start) {
505 ret = dev->dec_ops[ctx->current_codec]->start(ctx);
506 if (ret)
507 goto err_pm;
508 }
509 }
510
511 return 0;
512
513 err_pm:
514 pm_runtime_put(dev->dev);
515 err_cleanup:
516 cedrus_queue_cleanup(vq, VB2_BUF_STATE_QUEUED);
517
518 return ret;
519 }
520
cedrus_stop_streaming(struct vb2_queue * vq)521 static void cedrus_stop_streaming(struct vb2_queue *vq)
522 {
523 struct cedrus_ctx *ctx = vb2_get_drv_priv(vq);
524 struct cedrus_dev *dev = ctx->dev;
525
526 if (V4L2_TYPE_IS_OUTPUT(vq->type)) {
527 if (dev->dec_ops[ctx->current_codec]->stop)
528 dev->dec_ops[ctx->current_codec]->stop(ctx);
529
530 pm_runtime_put(dev->dev);
531 }
532
533 cedrus_queue_cleanup(vq, VB2_BUF_STATE_ERROR);
534 }
535
cedrus_buf_queue(struct vb2_buffer * vb)536 static void cedrus_buf_queue(struct vb2_buffer *vb)
537 {
538 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
539 struct cedrus_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
540
541 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
542 }
543
cedrus_buf_request_complete(struct vb2_buffer * vb)544 static void cedrus_buf_request_complete(struct vb2_buffer *vb)
545 {
546 struct cedrus_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
547
548 v4l2_ctrl_request_complete(vb->req_obj.req, &ctx->hdl);
549 }
550
551 static struct vb2_ops cedrus_qops = {
552 .queue_setup = cedrus_queue_setup,
553 .buf_prepare = cedrus_buf_prepare,
554 .buf_queue = cedrus_buf_queue,
555 .buf_out_validate = cedrus_buf_out_validate,
556 .buf_request_complete = cedrus_buf_request_complete,
557 .start_streaming = cedrus_start_streaming,
558 .stop_streaming = cedrus_stop_streaming,
559 .wait_prepare = vb2_ops_wait_prepare,
560 .wait_finish = vb2_ops_wait_finish,
561 };
562
cedrus_queue_init(void * priv,struct vb2_queue * src_vq,struct vb2_queue * dst_vq)563 int cedrus_queue_init(void *priv, struct vb2_queue *src_vq,
564 struct vb2_queue *dst_vq)
565 {
566 struct cedrus_ctx *ctx = priv;
567 int ret;
568
569 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
570 src_vq->io_modes = VB2_MMAP | VB2_DMABUF;
571 src_vq->drv_priv = ctx;
572 src_vq->buf_struct_size = sizeof(struct cedrus_buffer);
573 src_vq->min_buffers_needed = 1;
574 src_vq->ops = &cedrus_qops;
575 src_vq->mem_ops = &vb2_dma_contig_memops;
576 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
577 src_vq->lock = &ctx->dev->dev_mutex;
578 src_vq->dev = ctx->dev->dev;
579 src_vq->supports_requests = true;
580 src_vq->requires_requests = true;
581
582 ret = vb2_queue_init(src_vq);
583 if (ret)
584 return ret;
585
586 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
587 dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;
588 dst_vq->drv_priv = ctx;
589 dst_vq->buf_struct_size = sizeof(struct cedrus_buffer);
590 dst_vq->min_buffers_needed = 1;
591 dst_vq->ops = &cedrus_qops;
592 dst_vq->mem_ops = &vb2_dma_contig_memops;
593 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
594 dst_vq->lock = &ctx->dev->dev_mutex;
595 dst_vq->dev = ctx->dev->dev;
596
597 return vb2_queue_init(dst_vq);
598 }
599