1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
4  * Copyright (C) 2017 Linaro Ltd.
5  */
6 #include <linux/clk.h>
7 #include <linux/module.h>
8 #include <linux/mod_devicetable.h>
9 #include <linux/platform_device.h>
10 #include <linux/pm_runtime.h>
11 #include <linux/slab.h>
12 #include <media/v4l2-ioctl.h>
13 #include <media/v4l2-event.h>
14 #include <media/v4l2-ctrls.h>
15 #include <media/v4l2-mem2mem.h>
16 #include <media/videobuf2-dma-contig.h>
17 
18 #include "hfi_venus_io.h"
19 #include "hfi_parser.h"
20 #include "core.h"
21 #include "helpers.h"
22 #include "vdec.h"
23 #include "pm_helpers.h"
24 
25 /*
26  * Three resons to keep MPLANE formats (despite that the number of planes
27  * currently is one):
28  * - the MPLANE formats allow only one plane to be used
29  * - the downstream driver use MPLANE formats too
30  * - future firmware versions could add support for >1 planes
31  */
32 static const struct venus_format vdec_formats[] = {
33 	[VENUS_FMT_NV12] = {
34 		.pixfmt = V4L2_PIX_FMT_NV12,
35 		.num_planes = 1,
36 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
37 	},
38 	[VENUS_FMT_QC08C] = {
39 		.pixfmt = V4L2_PIX_FMT_QC08C,
40 		.num_planes = 1,
41 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
42 	},
43 	[VENUS_FMT_QC10C] = {
44 		.pixfmt = V4L2_PIX_FMT_QC10C,
45 		.num_planes = 1,
46 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
47 	},
48 	[VENUS_FMT_P010] = {
49 		.pixfmt = V4L2_PIX_FMT_P010,
50 		.num_planes = 1,
51 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
52 	},
53 	[VENUS_FMT_H264] = {
54 		.pixfmt = V4L2_PIX_FMT_H264,
55 		.num_planes = 1,
56 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
57 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
58 	},
59 	[VENUS_FMT_VP8] = {
60 		.pixfmt = V4L2_PIX_FMT_VP8,
61 		.num_planes = 1,
62 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
63 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
64 	},
65 	[VENUS_FMT_VP9] = {
66 		.pixfmt = V4L2_PIX_FMT_VP9,
67 		.num_planes = 1,
68 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
69 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
70 	},
71 	[VENUS_FMT_HEVC] = {
72 		.pixfmt = V4L2_PIX_FMT_HEVC,
73 		.num_planes = 1,
74 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
75 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
76 	},
77 	[VENUS_FMT_VC1_ANNEX_G] = {
78 		.pixfmt = V4L2_PIX_FMT_VC1_ANNEX_G,
79 		.num_planes = 1,
80 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
81 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
82 	},
83 	[VENUS_FMT_VC1_ANNEX_L] = {
84 		.pixfmt = V4L2_PIX_FMT_VC1_ANNEX_L,
85 		.num_planes = 1,
86 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
87 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
88 	},
89 	[VENUS_FMT_MPEG4] = {
90 		.pixfmt = V4L2_PIX_FMT_MPEG4,
91 		.num_planes = 1,
92 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
93 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
94 	},
95 	[VENUS_FMT_MPEG2] = {
96 		.pixfmt = V4L2_PIX_FMT_MPEG2,
97 		.num_planes = 1,
98 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
99 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
100 	},
101 	[VENUS_FMT_H263] = {
102 		.pixfmt = V4L2_PIX_FMT_H263,
103 		.num_planes = 1,
104 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
105 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
106 	},
107 	[VENUS_FMT_XVID] = {
108 		.pixfmt = V4L2_PIX_FMT_XVID,
109 		.num_planes = 1,
110 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
111 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
112 	},
113 
114 };
115 
116 static const struct venus_format *
117 find_format(struct venus_inst *inst, u32 pixfmt, u32 type)
118 {
119 	const struct venus_format *fmt = vdec_formats;
120 	unsigned int size = ARRAY_SIZE(vdec_formats);
121 	unsigned int i;
122 
123 	for (i = 0; i < size; i++) {
124 		if (fmt[i].pixfmt == pixfmt)
125 			break;
126 	}
127 
128 	if (i == size || fmt[i].type != type)
129 		return NULL;
130 
131 	if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE &&
132 	    !venus_helper_check_codec(inst, fmt[i].pixfmt))
133 		return NULL;
134 
135 	if (V4L2_TYPE_IS_CAPTURE(type) &&
136 	    !venus_helper_check_format(inst, fmt[i].pixfmt))
137 		return NULL;
138 
139 	if (V4L2_TYPE_IS_CAPTURE(type) && fmt[i].pixfmt == V4L2_PIX_FMT_QC10C &&
140 	    !(inst->bit_depth == VIDC_BITDEPTH_10))
141 		return NULL;
142 
143 	return &fmt[i];
144 }
145 
146 static const struct venus_format *
147 find_format_by_index(struct venus_inst *inst, unsigned int index, u32 type)
148 {
149 	const struct venus_format *fmt = vdec_formats;
150 	unsigned int size = ARRAY_SIZE(vdec_formats);
151 	unsigned int i, k = 0;
152 
153 	if (index > size)
154 		return NULL;
155 
156 	for (i = 0; i < size; i++) {
157 		bool valid;
158 
159 		if (fmt[i].type != type)
160 			continue;
161 
162 		if (V4L2_TYPE_IS_OUTPUT(type)) {
163 			valid = venus_helper_check_codec(inst, fmt[i].pixfmt);
164 		} else if (V4L2_TYPE_IS_CAPTURE(type)) {
165 			valid = venus_helper_check_format(inst, fmt[i].pixfmt);
166 
167 			if (fmt[i].pixfmt == V4L2_PIX_FMT_QC10C &&
168 			    !(inst->bit_depth == VIDC_BITDEPTH_10))
169 				valid = false;
170 		}
171 
172 		if (k == index && valid)
173 			break;
174 		if (valid)
175 			k++;
176 	}
177 
178 	if (i == size)
179 		return NULL;
180 
181 	return &fmt[i];
182 }
183 
184 static const struct venus_format *
185 vdec_try_fmt_common(struct venus_inst *inst, struct v4l2_format *f)
186 {
187 	struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
188 	struct v4l2_plane_pix_format *pfmt = pixmp->plane_fmt;
189 	const struct venus_format *fmt;
190 	u32 szimage;
191 
192 	memset(pfmt[0].reserved, 0, sizeof(pfmt[0].reserved));
193 	memset(pixmp->reserved, 0, sizeof(pixmp->reserved));
194 
195 	fmt = find_format(inst, pixmp->pixelformat, f->type);
196 	if (!fmt) {
197 		if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
198 			pixmp->pixelformat = V4L2_PIX_FMT_NV12;
199 		else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
200 			pixmp->pixelformat = V4L2_PIX_FMT_H264;
201 		else
202 			return NULL;
203 		fmt = find_format(inst, pixmp->pixelformat, f->type);
204 		if (!fmt)
205 			return NULL;
206 	}
207 
208 	pixmp->width = clamp(pixmp->width, frame_width_min(inst),
209 			     frame_width_max(inst));
210 	pixmp->height = clamp(pixmp->height, frame_height_min(inst),
211 			      frame_height_max(inst));
212 
213 	if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
214 		pixmp->height = ALIGN(pixmp->height, 32);
215 
216 	if (pixmp->field == V4L2_FIELD_ANY)
217 		pixmp->field = V4L2_FIELD_NONE;
218 	pixmp->num_planes = fmt->num_planes;
219 	pixmp->flags = 0;
220 
221 	szimage = venus_helper_get_framesz(pixmp->pixelformat, pixmp->width,
222 					   pixmp->height);
223 
224 	if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
225 		unsigned int stride = pixmp->width;
226 
227 		if (pixmp->pixelformat == V4L2_PIX_FMT_P010)
228 			stride *= 2;
229 
230 		pfmt[0].sizeimage = szimage;
231 		pfmt[0].bytesperline = ALIGN(stride, 128);
232 	} else {
233 		pfmt[0].sizeimage = clamp_t(u32, pfmt[0].sizeimage, 0, SZ_8M);
234 		pfmt[0].sizeimage = max(pfmt[0].sizeimage, szimage);
235 		pfmt[0].bytesperline = 0;
236 	}
237 
238 	return fmt;
239 }
240 
241 static int vdec_try_fmt(struct file *file, void *fh, struct v4l2_format *f)
242 {
243 	struct venus_inst *inst = to_inst(file);
244 
245 	vdec_try_fmt_common(inst, f);
246 
247 	return 0;
248 }
249 
250 static int vdec_check_src_change(struct venus_inst *inst)
251 {
252 	int ret;
253 
254 	if (inst->subscriptions & V4L2_EVENT_SOURCE_CHANGE &&
255 	    inst->codec_state == VENUS_DEC_STATE_INIT &&
256 	    !inst->reconfig)
257 		return -EINVAL;
258 
259 	if (inst->subscriptions & V4L2_EVENT_SOURCE_CHANGE)
260 		return 0;
261 
262 	/*
263 	 * The code snippet below is a workaround for backward compatibility
264 	 * with applications which doesn't support V4L2 events. It will be
265 	 * dropped in future once those applications are fixed.
266 	 */
267 
268 	if (inst->codec_state != VENUS_DEC_STATE_INIT)
269 		goto done;
270 
271 	ret = wait_event_timeout(inst->reconf_wait, inst->reconfig,
272 				 msecs_to_jiffies(100));
273 	if (!ret)
274 		return -EINVAL;
275 
276 	if (!(inst->codec_state == VENUS_DEC_STATE_CAPTURE_SETUP) ||
277 	    !inst->reconfig)
278 		dev_dbg(inst->core->dev, VDBGH "wrong state\n");
279 
280 done:
281 	return 0;
282 }
283 
284 static int vdec_g_fmt(struct file *file, void *fh, struct v4l2_format *f)
285 {
286 	struct venus_inst *inst = to_inst(file);
287 	const struct venus_format *fmt = NULL;
288 	struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
289 	int ret;
290 
291 	if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
292 		fmt = inst->fmt_cap;
293 	else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
294 		fmt = inst->fmt_out;
295 
296 	if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
297 		ret = vdec_check_src_change(inst);
298 		if (ret)
299 			return ret;
300 	}
301 
302 	pixmp->pixelformat = fmt->pixfmt;
303 
304 	if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
305 		pixmp->width = inst->width;
306 		pixmp->height = inst->height;
307 		pixmp->colorspace = inst->colorspace;
308 		pixmp->ycbcr_enc = inst->ycbcr_enc;
309 		pixmp->quantization = inst->quantization;
310 		pixmp->xfer_func = inst->xfer_func;
311 	} else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
312 		pixmp->width = inst->out_width;
313 		pixmp->height = inst->out_height;
314 	}
315 
316 	vdec_try_fmt_common(inst, f);
317 
318 	return 0;
319 }
320 
321 static int vdec_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
322 {
323 	struct venus_inst *inst = to_inst(file);
324 	struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
325 	struct v4l2_pix_format_mplane orig_pixmp;
326 	const struct venus_format *fmt;
327 	struct v4l2_format format;
328 	u32 pixfmt_out = 0, pixfmt_cap = 0;
329 	struct vb2_queue *q;
330 
331 	q = v4l2_m2m_get_vq(inst->m2m_ctx, f->type);
332 	if (!q)
333 		return -EINVAL;
334 
335 	if (vb2_is_busy(q))
336 		return -EBUSY;
337 
338 	orig_pixmp = *pixmp;
339 
340 	fmt = vdec_try_fmt_common(inst, f);
341 
342 	if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
343 		pixfmt_out = pixmp->pixelformat;
344 		pixfmt_cap = inst->fmt_cap->pixfmt;
345 	} else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
346 		pixfmt_cap = pixmp->pixelformat;
347 		pixfmt_out = inst->fmt_out->pixfmt;
348 	}
349 
350 	memset(&format, 0, sizeof(format));
351 
352 	format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
353 	format.fmt.pix_mp.pixelformat = pixfmt_out;
354 	format.fmt.pix_mp.width = orig_pixmp.width;
355 	format.fmt.pix_mp.height = orig_pixmp.height;
356 	vdec_try_fmt_common(inst, &format);
357 
358 	if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
359 		inst->out_width = format.fmt.pix_mp.width;
360 		inst->out_height = format.fmt.pix_mp.height;
361 		inst->colorspace = pixmp->colorspace;
362 		inst->ycbcr_enc = pixmp->ycbcr_enc;
363 		inst->quantization = pixmp->quantization;
364 		inst->xfer_func = pixmp->xfer_func;
365 		inst->input_buf_size = pixmp->plane_fmt[0].sizeimage;
366 	}
367 
368 	memset(&format, 0, sizeof(format));
369 
370 	format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
371 	format.fmt.pix_mp.pixelformat = pixfmt_cap;
372 	format.fmt.pix_mp.width = orig_pixmp.width;
373 	format.fmt.pix_mp.height = orig_pixmp.height;
374 	vdec_try_fmt_common(inst, &format);
375 
376 	inst->width = format.fmt.pix_mp.width;
377 	inst->height = format.fmt.pix_mp.height;
378 	inst->crop.top = 0;
379 	inst->crop.left = 0;
380 	inst->crop.width = inst->width;
381 	inst->crop.height = inst->height;
382 
383 	if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
384 		inst->fmt_out = fmt;
385 	else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
386 		inst->fmt_cap = fmt;
387 		inst->output2_buf_size =
388 			venus_helper_get_framesz(pixfmt_cap, orig_pixmp.width, orig_pixmp.height);
389 	}
390 
391 	return 0;
392 }
393 
394 static int
395 vdec_g_selection(struct file *file, void *fh, struct v4l2_selection *s)
396 {
397 	struct venus_inst *inst = to_inst(file);
398 
399 	if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
400 	    s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
401 		return -EINVAL;
402 
403 	s->r.top = 0;
404 	s->r.left = 0;
405 
406 	switch (s->target) {
407 	case V4L2_SEL_TGT_CROP_BOUNDS:
408 	case V4L2_SEL_TGT_CROP_DEFAULT:
409 	case V4L2_SEL_TGT_CROP:
410 		if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
411 			return -EINVAL;
412 		s->r.width = inst->out_width;
413 		s->r.height = inst->out_height;
414 		break;
415 	case V4L2_SEL_TGT_COMPOSE_BOUNDS:
416 	case V4L2_SEL_TGT_COMPOSE_PADDED:
417 		if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
418 			return -EINVAL;
419 		s->r.width = inst->width;
420 		s->r.height = inst->height;
421 		break;
422 	case V4L2_SEL_TGT_COMPOSE_DEFAULT:
423 	case V4L2_SEL_TGT_COMPOSE:
424 		if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
425 			return -EINVAL;
426 		s->r = inst->crop;
427 		break;
428 	default:
429 		return -EINVAL;
430 	}
431 
432 	return 0;
433 }
434 
435 static int
436 vdec_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
437 {
438 	strscpy(cap->driver, "qcom-venus", sizeof(cap->driver));
439 	strscpy(cap->card, "Qualcomm Venus video decoder", sizeof(cap->card));
440 	strscpy(cap->bus_info, "platform:qcom-venus", sizeof(cap->bus_info));
441 
442 	return 0;
443 }
444 
445 static int vdec_enum_fmt(struct file *file, void *fh, struct v4l2_fmtdesc *f)
446 {
447 	struct venus_inst *inst = to_inst(file);
448 	const struct venus_format *fmt;
449 
450 	memset(f->reserved, 0, sizeof(f->reserved));
451 
452 	fmt = find_format_by_index(inst, f->index, f->type);
453 	if (!fmt)
454 		return -EINVAL;
455 
456 	f->pixelformat = fmt->pixfmt;
457 	f->flags = fmt->flags;
458 
459 	return 0;
460 }
461 
462 static int vdec_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
463 {
464 	struct venus_inst *inst = to_inst(file);
465 	struct v4l2_captureparm *cap = &a->parm.capture;
466 	struct v4l2_fract *timeperframe = &cap->timeperframe;
467 	u64 us_per_frame, fps;
468 
469 	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
470 	    a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
471 		return -EINVAL;
472 
473 	memset(cap->reserved, 0, sizeof(cap->reserved));
474 	if (!timeperframe->denominator)
475 		timeperframe->denominator = inst->timeperframe.denominator;
476 	if (!timeperframe->numerator)
477 		timeperframe->numerator = inst->timeperframe.numerator;
478 	cap->readbuffers = 0;
479 	cap->extendedmode = 0;
480 	cap->capability = V4L2_CAP_TIMEPERFRAME;
481 	us_per_frame = timeperframe->numerator * (u64)USEC_PER_SEC;
482 	do_div(us_per_frame, timeperframe->denominator);
483 
484 	if (!us_per_frame)
485 		return -EINVAL;
486 
487 	fps = (u64)USEC_PER_SEC;
488 	do_div(fps, us_per_frame);
489 
490 	inst->fps = fps;
491 	inst->timeperframe = *timeperframe;
492 
493 	return 0;
494 }
495 
496 static int vdec_enum_framesizes(struct file *file, void *fh,
497 				struct v4l2_frmsizeenum *fsize)
498 {
499 	struct venus_inst *inst = to_inst(file);
500 	const struct venus_format *fmt;
501 
502 	fmt = find_format(inst, fsize->pixel_format,
503 			  V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
504 	if (!fmt) {
505 		fmt = find_format(inst, fsize->pixel_format,
506 				  V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
507 		if (!fmt)
508 			return -EINVAL;
509 	}
510 
511 	if (fsize->index)
512 		return -EINVAL;
513 
514 	fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
515 
516 	fsize->stepwise.min_width = frame_width_min(inst);
517 	fsize->stepwise.max_width = frame_width_max(inst);
518 	fsize->stepwise.step_width = frame_width_step(inst);
519 	fsize->stepwise.min_height = frame_height_min(inst);
520 	fsize->stepwise.max_height = frame_height_max(inst);
521 	fsize->stepwise.step_height = frame_height_step(inst);
522 
523 	return 0;
524 }
525 
526 static int vdec_subscribe_event(struct v4l2_fh *fh,
527 				const struct v4l2_event_subscription *sub)
528 {
529 	struct venus_inst *inst = container_of(fh, struct venus_inst, fh);
530 	int ret;
531 
532 	switch (sub->type) {
533 	case V4L2_EVENT_EOS:
534 		return v4l2_event_subscribe(fh, sub, 2, NULL);
535 	case V4L2_EVENT_SOURCE_CHANGE:
536 		ret = v4l2_src_change_event_subscribe(fh, sub);
537 		if (ret)
538 			return ret;
539 		inst->subscriptions |= V4L2_EVENT_SOURCE_CHANGE;
540 		return 0;
541 	case V4L2_EVENT_CTRL:
542 		return v4l2_ctrl_subscribe_event(fh, sub);
543 	default:
544 		return -EINVAL;
545 	}
546 }
547 
548 static int
549 vdec_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *cmd)
550 {
551 	struct venus_inst *inst = to_inst(file);
552 	struct vb2_queue *dst_vq;
553 	struct hfi_frame_data fdata = {0};
554 	int ret;
555 
556 	ret = v4l2_m2m_ioctl_try_decoder_cmd(file, fh, cmd);
557 	if (ret)
558 		return ret;
559 
560 	mutex_lock(&inst->lock);
561 
562 	if (cmd->cmd == V4L2_DEC_CMD_STOP) {
563 		/*
564 		 * Implement V4L2_DEC_CMD_STOP by enqueue an empty buffer on
565 		 * decoder input to signal EOS.
566 		 */
567 		if (!(inst->streamon_out && inst->streamon_cap))
568 			goto unlock;
569 
570 		fdata.buffer_type = HFI_BUFFER_INPUT;
571 		fdata.flags |= HFI_BUFFERFLAG_EOS;
572 		if (IS_V6(inst->core) && is_fw_rev_or_older(inst->core, 1, 0, 87))
573 			fdata.device_addr = 0;
574 		else
575 			fdata.device_addr = 0xdeadb000;
576 
577 		ret = hfi_session_process_buf(inst, &fdata);
578 
579 		if (!ret && inst->codec_state == VENUS_DEC_STATE_DECODING) {
580 			inst->codec_state = VENUS_DEC_STATE_DRAIN;
581 			inst->drain_active = true;
582 		}
583 	} else if (cmd->cmd == V4L2_DEC_CMD_START &&
584 		   inst->codec_state == VENUS_DEC_STATE_STOPPED) {
585 		dst_vq = v4l2_m2m_get_vq(inst->fh.m2m_ctx,
586 					 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
587 		vb2_clear_last_buffer_dequeued(dst_vq);
588 
589 		inst->codec_state = VENUS_DEC_STATE_DECODING;
590 	}
591 
592 unlock:
593 	mutex_unlock(&inst->lock);
594 	return ret;
595 }
596 
597 static const struct v4l2_ioctl_ops vdec_ioctl_ops = {
598 	.vidioc_querycap = vdec_querycap,
599 	.vidioc_enum_fmt_vid_cap = vdec_enum_fmt,
600 	.vidioc_enum_fmt_vid_out = vdec_enum_fmt,
601 	.vidioc_s_fmt_vid_cap_mplane = vdec_s_fmt,
602 	.vidioc_s_fmt_vid_out_mplane = vdec_s_fmt,
603 	.vidioc_g_fmt_vid_cap_mplane = vdec_g_fmt,
604 	.vidioc_g_fmt_vid_out_mplane = vdec_g_fmt,
605 	.vidioc_try_fmt_vid_cap_mplane = vdec_try_fmt,
606 	.vidioc_try_fmt_vid_out_mplane = vdec_try_fmt,
607 	.vidioc_g_selection = vdec_g_selection,
608 	.vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
609 	.vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
610 	.vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
611 	.vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,
612 	.vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
613 	.vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
614 	.vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
615 	.vidioc_streamon = v4l2_m2m_ioctl_streamon,
616 	.vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
617 	.vidioc_s_parm = vdec_s_parm,
618 	.vidioc_enum_framesizes = vdec_enum_framesizes,
619 	.vidioc_subscribe_event = vdec_subscribe_event,
620 	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
621 	.vidioc_try_decoder_cmd = v4l2_m2m_ioctl_try_decoder_cmd,
622 	.vidioc_decoder_cmd = vdec_decoder_cmd,
623 };
624 
625 static int vdec_pm_get(struct venus_inst *inst)
626 {
627 	struct venus_core *core = inst->core;
628 	struct device *dev = core->dev_dec;
629 	int ret;
630 
631 	mutex_lock(&core->pm_lock);
632 	ret = pm_runtime_resume_and_get(dev);
633 	mutex_unlock(&core->pm_lock);
634 
635 	return ret;
636 }
637 
638 static int vdec_pm_put(struct venus_inst *inst, bool autosuspend)
639 {
640 	struct venus_core *core = inst->core;
641 	struct device *dev = core->dev_dec;
642 	int ret;
643 
644 	mutex_lock(&core->pm_lock);
645 
646 	if (autosuspend)
647 		ret = pm_runtime_put_autosuspend(dev);
648 	else
649 		ret = pm_runtime_put_sync(dev);
650 
651 	mutex_unlock(&core->pm_lock);
652 
653 	return ret < 0 ? ret : 0;
654 }
655 
656 static int vdec_pm_get_put(struct venus_inst *inst)
657 {
658 	struct venus_core *core = inst->core;
659 	struct device *dev = core->dev_dec;
660 	int ret = 0;
661 
662 	mutex_lock(&core->pm_lock);
663 
664 	if (pm_runtime_suspended(dev)) {
665 		ret = pm_runtime_resume_and_get(dev);
666 		if (ret < 0)
667 			goto error;
668 
669 		ret = pm_runtime_put_autosuspend(dev);
670 	}
671 
672 error:
673 	mutex_unlock(&core->pm_lock);
674 
675 	return ret < 0 ? ret : 0;
676 }
677 
678 static void vdec_pm_touch(struct venus_inst *inst)
679 {
680 	pm_runtime_mark_last_busy(inst->core->dev_dec);
681 }
682 
683 static int vdec_set_properties(struct venus_inst *inst)
684 {
685 	struct vdec_controls *ctr = &inst->controls.dec;
686 	struct hfi_enable en = { .enable = 1 };
687 	u32 ptype, decode_order, conceal;
688 	int ret;
689 
690 	if (ctr->post_loop_deb_mode) {
691 		ptype = HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER;
692 		ret = hfi_session_set_property(inst, ptype, &en);
693 		if (ret)
694 			return ret;
695 	}
696 
697 	if (ctr->display_delay_enable && ctr->display_delay == 0) {
698 		ptype = HFI_PROPERTY_PARAM_VDEC_OUTPUT_ORDER;
699 		decode_order = HFI_OUTPUT_ORDER_DECODE;
700 		ret = hfi_session_set_property(inst, ptype, &decode_order);
701 		if (ret)
702 			return ret;
703 	}
704 
705 	/* Enabling sufficient sequence change support for VP9 */
706 	if (is_fw_rev_or_newer(inst->core, 5, 4, 51)) {
707 		ptype = HFI_PROPERTY_PARAM_VDEC_ENABLE_SUFFICIENT_SEQCHANGE_EVENT;
708 		ret = hfi_session_set_property(inst, ptype, &en);
709 		if (ret)
710 			return ret;
711 	}
712 
713 	ptype = HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR;
714 	conceal = ctr->conceal_color & 0xffff;
715 	conceal |= ((ctr->conceal_color >> 16) & 0xffff) << 10;
716 	conceal |= ((ctr->conceal_color >> 32) & 0xffff) << 20;
717 
718 	ret = hfi_session_set_property(inst, ptype, &conceal);
719 	if (ret)
720 		return ret;
721 
722 	return 0;
723 }
724 
725 static int vdec_set_work_route(struct venus_inst *inst)
726 {
727 	u32 ptype = HFI_PROPERTY_PARAM_WORK_ROUTE;
728 	struct hfi_video_work_route wr;
729 
730 	if (!(IS_IRIS2(inst->core) || IS_IRIS2_1(inst->core)))
731 		return 0;
732 
733 	wr.video_work_route = inst->core->res->num_vpp_pipes;
734 
735 	return hfi_session_set_property(inst, ptype, &wr);
736 }
737 
738 #define is_ubwc_fmt(fmt) (!!((fmt) & HFI_COLOR_FORMAT_UBWC_BASE))
739 #define is_10bit_ubwc_fmt(fmt) (!!((fmt) & HFI_COLOR_FORMAT_10_BIT_BASE & \
740 				 HFI_COLOR_FORMAT_UBWC_BASE))
741 
742 
743 static int vdec_output_conf(struct venus_inst *inst)
744 {
745 	struct venus_core *core = inst->core;
746 	struct hfi_enable en = { .enable = 1 };
747 	struct hfi_buffer_requirements bufreq;
748 	u32 width = inst->width;
749 	u32 height = inst->height;
750 	u32 out_fmt, out2_fmt;
751 	bool ubwc = false;
752 	u32 ptype;
753 	int ret;
754 
755 	ret = venus_helper_set_work_mode(inst);
756 	if (ret)
757 		return ret;
758 
759 	if (core->res->hfi_version == HFI_VERSION_1XX) {
760 		ptype = HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER;
761 		ret = hfi_session_set_property(inst, ptype, &en);
762 		if (ret)
763 			return ret;
764 	}
765 
766 	/* Force searching UBWC formats for bigger then HD resolutions */
767 	if (width > 1920 && height > ALIGN(1080, 32))
768 		ubwc = true;
769 
770 	/* For Venus v4/v6 UBWC format is mandatory */
771 	if (IS_V4(core) || IS_V6(core))
772 		ubwc = true;
773 
774 	ret = venus_helper_get_out_fmts(inst, inst->fmt_cap->pixfmt, &out_fmt,
775 					&out2_fmt, ubwc);
776 	if (ret)
777 		return ret;
778 
779 	inst->output_buf_size =
780 			venus_helper_get_framesz_raw(out_fmt, width, height);
781 	inst->output2_buf_size =
782 			venus_helper_get_framesz_raw(out2_fmt, width, height);
783 
784 	if (is_ubwc_fmt(out_fmt)) {
785 		inst->opb_buftype = HFI_BUFFER_OUTPUT2;
786 		inst->opb_fmt = out2_fmt;
787 		inst->dpb_buftype = HFI_BUFFER_OUTPUT;
788 		inst->dpb_fmt = out_fmt;
789 	} else if (is_ubwc_fmt(out2_fmt) || is_10bit_ubwc_fmt(out_fmt)) {
790 		inst->opb_buftype = HFI_BUFFER_OUTPUT;
791 		inst->opb_fmt = out_fmt;
792 		inst->dpb_buftype = HFI_BUFFER_OUTPUT2;
793 		inst->dpb_fmt = out2_fmt;
794 	} else {
795 		inst->opb_buftype = HFI_BUFFER_OUTPUT;
796 		inst->opb_fmt = out_fmt;
797 		inst->dpb_buftype = 0;
798 		inst->dpb_fmt = 0;
799 	}
800 
801 	ret = venus_helper_set_raw_format(inst, inst->opb_fmt,
802 					  inst->opb_buftype);
803 	if (ret)
804 		return ret;
805 
806 	ret = venus_helper_set_format_constraints(inst);
807 	if (ret)
808 		return ret;
809 
810 	if (inst->dpb_fmt) {
811 		ret = venus_helper_set_multistream(inst, false, true);
812 		if (ret)
813 			return ret;
814 
815 		ret = venus_helper_set_raw_format(inst, inst->dpb_fmt,
816 						  inst->dpb_buftype);
817 		if (ret)
818 			return ret;
819 
820 		ret = venus_helper_set_output_resolution(inst, width, height,
821 							 HFI_BUFFER_OUTPUT2);
822 		if (ret)
823 			return ret;
824 	}
825 
826 	if (IS_V3(core) || IS_V4(core) || IS_V6(core)) {
827 		ret = venus_helper_get_bufreq(inst, HFI_BUFFER_OUTPUT, &bufreq);
828 		if (ret)
829 			return ret;
830 
831 		if (bufreq.size > inst->output_buf_size)
832 			return -EINVAL;
833 
834 		if (inst->dpb_fmt) {
835 			ret = venus_helper_get_bufreq(inst, HFI_BUFFER_OUTPUT2,
836 						      &bufreq);
837 			if (ret)
838 				return ret;
839 
840 			if (bufreq.size > inst->output2_buf_size)
841 				return -EINVAL;
842 		}
843 
844 		if (inst->output2_buf_size) {
845 			ret = venus_helper_set_bufsize(inst,
846 						       inst->output2_buf_size,
847 						       HFI_BUFFER_OUTPUT2);
848 			if (ret)
849 				return ret;
850 		}
851 
852 		if (inst->output_buf_size) {
853 			ret = venus_helper_set_bufsize(inst,
854 						       inst->output_buf_size,
855 						       HFI_BUFFER_OUTPUT);
856 			if (ret)
857 				return ret;
858 		}
859 	}
860 
861 	ret = venus_helper_set_dyn_bufmode(inst);
862 	if (ret)
863 		return ret;
864 
865 	return 0;
866 }
867 
868 static int vdec_session_init(struct venus_inst *inst)
869 {
870 	int ret;
871 
872 	ret = venus_helper_session_init(inst);
873 	if (ret == -EALREADY)
874 		return 0;
875 	else if (ret)
876 		return ret;
877 
878 	ret = venus_helper_set_input_resolution(inst, frame_width_min(inst),
879 						frame_height_min(inst));
880 	if (ret)
881 		goto deinit;
882 
883 	return 0;
884 deinit:
885 	hfi_session_deinit(inst);
886 	return ret;
887 }
888 
889 static int vdec_num_buffers(struct venus_inst *inst, unsigned int *in_num,
890 			    unsigned int *out_num)
891 {
892 	enum hfi_version ver = inst->core->res->hfi_version;
893 	struct hfi_buffer_requirements bufreq;
894 	int ret;
895 
896 	*in_num = *out_num = 0;
897 
898 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_INPUT, &bufreq);
899 	if (ret)
900 		return ret;
901 
902 	*in_num = hfi_bufreq_get_count_min(&bufreq, ver);
903 
904 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_OUTPUT, &bufreq);
905 	if (ret)
906 		return ret;
907 
908 	*out_num = hfi_bufreq_get_count_min(&bufreq, ver);
909 
910 	return 0;
911 }
912 
913 static int vdec_queue_setup(struct vb2_queue *q,
914 			    unsigned int *num_buffers, unsigned int *num_planes,
915 			    unsigned int sizes[], struct device *alloc_devs[])
916 {
917 	struct venus_inst *inst = vb2_get_drv_priv(q);
918 	struct venus_core *core = inst->core;
919 	unsigned int in_num, out_num;
920 	int ret = 0;
921 
922 	if (*num_planes) {
923 		unsigned int output_buf_size = venus_helper_get_opb_size(inst);
924 
925 		if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE &&
926 		    *num_planes != inst->fmt_out->num_planes)
927 			return -EINVAL;
928 
929 		if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
930 		    *num_planes != inst->fmt_cap->num_planes)
931 			return -EINVAL;
932 
933 		if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE &&
934 		    sizes[0] < inst->input_buf_size)
935 			return -EINVAL;
936 
937 		if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
938 		    sizes[0] < output_buf_size)
939 			return -EINVAL;
940 
941 		return 0;
942 	}
943 
944 	if (test_bit(0, &core->sys_error)) {
945 		if (inst->nonblock)
946 			return -EAGAIN;
947 
948 		ret = wait_event_interruptible(core->sys_err_done,
949 					       !test_bit(0, &core->sys_error));
950 		if (ret)
951 			return ret;
952 	}
953 
954 	ret = vdec_pm_get(inst);
955 	if (ret)
956 		return ret;
957 
958 	ret = vdec_session_init(inst);
959 	if (ret)
960 		goto put_power;
961 
962 	ret = vdec_num_buffers(inst, &in_num, &out_num);
963 	if (ret)
964 		goto put_power;
965 
966 	ret = vdec_pm_put(inst, false);
967 	if (ret)
968 		return ret;
969 
970 	switch (q->type) {
971 	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
972 		*num_planes = inst->fmt_out->num_planes;
973 		sizes[0] = venus_helper_get_framesz(inst->fmt_out->pixfmt,
974 						    inst->out_width,
975 						    inst->out_height);
976 		sizes[0] = max(sizes[0], inst->input_buf_size);
977 		inst->input_buf_size = sizes[0];
978 		*num_buffers = max(*num_buffers, in_num);
979 		inst->num_input_bufs = *num_buffers;
980 		inst->num_output_bufs = out_num;
981 		break;
982 	case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
983 		*num_planes = inst->fmt_cap->num_planes;
984 		sizes[0] = venus_helper_get_framesz(inst->fmt_cap->pixfmt,
985 						    inst->width,
986 						    inst->height);
987 		inst->output_buf_size = sizes[0];
988 		*num_buffers = max(*num_buffers, out_num);
989 		inst->num_output_bufs = *num_buffers;
990 
991 		mutex_lock(&inst->lock);
992 		if (inst->codec_state == VENUS_DEC_STATE_CAPTURE_SETUP)
993 			inst->codec_state = VENUS_DEC_STATE_STOPPED;
994 		mutex_unlock(&inst->lock);
995 		break;
996 	default:
997 		ret = -EINVAL;
998 		break;
999 	}
1000 
1001 	return ret;
1002 
1003 put_power:
1004 	vdec_pm_put(inst, false);
1005 	return ret;
1006 }
1007 
1008 static int vdec_verify_conf(struct venus_inst *inst)
1009 {
1010 	enum hfi_version ver = inst->core->res->hfi_version;
1011 	struct hfi_buffer_requirements bufreq;
1012 	int ret;
1013 
1014 	if (!inst->num_input_bufs || !inst->num_output_bufs)
1015 		return -EINVAL;
1016 
1017 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_OUTPUT, &bufreq);
1018 	if (ret)
1019 		return ret;
1020 
1021 	if (inst->num_output_bufs < bufreq.count_actual ||
1022 	    inst->num_output_bufs < hfi_bufreq_get_count_min(&bufreq, ver))
1023 		return -EINVAL;
1024 
1025 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_INPUT, &bufreq);
1026 	if (ret)
1027 		return ret;
1028 
1029 	if (inst->num_input_bufs < hfi_bufreq_get_count_min(&bufreq, ver))
1030 		return -EINVAL;
1031 
1032 	return 0;
1033 }
1034 
1035 static int vdec_start_capture(struct venus_inst *inst)
1036 {
1037 	int ret;
1038 
1039 	if (!inst->streamon_out)
1040 		return 0;
1041 
1042 	if (inst->codec_state == VENUS_DEC_STATE_DECODING) {
1043 		if (inst->reconfig)
1044 			goto reconfigure;
1045 
1046 		venus_helper_queue_dpb_bufs(inst);
1047 		venus_helper_process_initial_cap_bufs(inst);
1048 		inst->streamon_cap = 1;
1049 		return 0;
1050 	}
1051 
1052 	if (inst->codec_state != VENUS_DEC_STATE_STOPPED)
1053 		return 0;
1054 
1055 reconfigure:
1056 	ret = vdec_output_conf(inst);
1057 	if (ret)
1058 		return ret;
1059 
1060 	ret = venus_helper_set_num_bufs(inst, inst->num_input_bufs,
1061 					VB2_MAX_FRAME, VB2_MAX_FRAME);
1062 	if (ret)
1063 		return ret;
1064 
1065 	ret = venus_helper_intbufs_realloc(inst);
1066 	if (ret)
1067 		goto err;
1068 
1069 	venus_pm_load_scale(inst);
1070 
1071 	inst->next_buf_last = false;
1072 
1073 	ret = venus_helper_alloc_dpb_bufs(inst);
1074 	if (ret)
1075 		goto err;
1076 
1077 	ret = hfi_session_continue(inst);
1078 	if (ret)
1079 		goto free_dpb_bufs;
1080 
1081 	ret = venus_helper_queue_dpb_bufs(inst);
1082 	if (ret)
1083 		goto free_dpb_bufs;
1084 
1085 	ret = venus_helper_process_initial_cap_bufs(inst);
1086 	if (ret)
1087 		goto free_dpb_bufs;
1088 
1089 	inst->codec_state = VENUS_DEC_STATE_DECODING;
1090 
1091 	if (inst->drain_active)
1092 		inst->codec_state = VENUS_DEC_STATE_DRAIN;
1093 
1094 	inst->streamon_cap = 1;
1095 	inst->sequence_cap = 0;
1096 	inst->reconfig = false;
1097 	inst->drain_active = false;
1098 
1099 	return 0;
1100 
1101 free_dpb_bufs:
1102 	venus_helper_free_dpb_bufs(inst);
1103 err:
1104 	return ret;
1105 }
1106 
1107 static int vdec_start_output(struct venus_inst *inst)
1108 {
1109 	int ret;
1110 
1111 	if (inst->codec_state == VENUS_DEC_STATE_SEEK) {
1112 		ret = venus_helper_process_initial_out_bufs(inst);
1113 		if (inst->next_buf_last)
1114 			inst->codec_state = VENUS_DEC_STATE_DRC;
1115 		else
1116 			inst->codec_state = VENUS_DEC_STATE_DECODING;
1117 		goto done;
1118 	}
1119 
1120 	if (inst->codec_state == VENUS_DEC_STATE_INIT ||
1121 	    inst->codec_state == VENUS_DEC_STATE_CAPTURE_SETUP) {
1122 		ret = venus_helper_process_initial_out_bufs(inst);
1123 		goto done;
1124 	}
1125 
1126 	if (inst->codec_state != VENUS_DEC_STATE_DEINIT)
1127 		return -EINVAL;
1128 
1129 	venus_helper_init_instance(inst);
1130 	inst->sequence_out = 0;
1131 	inst->reconfig = false;
1132 	inst->next_buf_last = false;
1133 
1134 	ret = vdec_set_properties(inst);
1135 	if (ret)
1136 		return ret;
1137 
1138 	ret = vdec_set_work_route(inst);
1139 	if (ret)
1140 		return ret;
1141 
1142 	ret = vdec_output_conf(inst);
1143 	if (ret)
1144 		return ret;
1145 
1146 	ret = vdec_verify_conf(inst);
1147 	if (ret)
1148 		return ret;
1149 
1150 	ret = venus_helper_set_num_bufs(inst, inst->num_input_bufs,
1151 					VB2_MAX_FRAME, VB2_MAX_FRAME);
1152 	if (ret)
1153 		return ret;
1154 
1155 	ret = venus_helper_vb2_start_streaming(inst);
1156 	if (ret)
1157 		return ret;
1158 
1159 	ret = venus_helper_process_initial_out_bufs(inst);
1160 	if (ret)
1161 		return ret;
1162 
1163 	inst->codec_state = VENUS_DEC_STATE_INIT;
1164 
1165 done:
1166 	inst->streamon_out = 1;
1167 	return ret;
1168 }
1169 
1170 static int vdec_start_streaming(struct vb2_queue *q, unsigned int count)
1171 {
1172 	struct venus_inst *inst = vb2_get_drv_priv(q);
1173 	int ret;
1174 
1175 	mutex_lock(&inst->lock);
1176 
1177 	if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1178 		ret = vdec_start_capture(inst);
1179 	} else {
1180 		ret = vdec_pm_get(inst);
1181 		if (ret)
1182 			goto error;
1183 
1184 		ret = venus_pm_acquire_core(inst);
1185 		if (ret)
1186 			goto put_power;
1187 
1188 		ret = vdec_pm_put(inst, true);
1189 		if (ret)
1190 			goto error;
1191 
1192 		ret = vdec_start_output(inst);
1193 	}
1194 
1195 	if (ret)
1196 		goto error;
1197 
1198 	mutex_unlock(&inst->lock);
1199 	return 0;
1200 
1201 put_power:
1202 	vdec_pm_put(inst, false);
1203 error:
1204 	venus_helper_buffers_done(inst, q->type, VB2_BUF_STATE_QUEUED);
1205 	mutex_unlock(&inst->lock);
1206 	return ret;
1207 }
1208 
1209 static void vdec_cancel_dst_buffers(struct venus_inst *inst)
1210 {
1211 	struct vb2_v4l2_buffer *buf;
1212 
1213 	while ((buf = v4l2_m2m_dst_buf_remove(inst->m2m_ctx)))
1214 		v4l2_m2m_buf_done(buf, VB2_BUF_STATE_ERROR);
1215 }
1216 
1217 static int vdec_stop_capture(struct venus_inst *inst)
1218 {
1219 	int ret = 0;
1220 
1221 	switch (inst->codec_state) {
1222 	case VENUS_DEC_STATE_DECODING:
1223 		ret = hfi_session_flush(inst, HFI_FLUSH_ALL, true);
1224 		fallthrough;
1225 	case VENUS_DEC_STATE_DRAIN:
1226 		inst->codec_state = VENUS_DEC_STATE_STOPPED;
1227 		inst->drain_active = false;
1228 		fallthrough;
1229 	case VENUS_DEC_STATE_SEEK:
1230 		vdec_cancel_dst_buffers(inst);
1231 		break;
1232 	case VENUS_DEC_STATE_DRC:
1233 		ret = hfi_session_flush(inst, HFI_FLUSH_OUTPUT, true);
1234 		inst->codec_state = VENUS_DEC_STATE_CAPTURE_SETUP;
1235 		venus_helper_free_dpb_bufs(inst);
1236 		break;
1237 	default:
1238 		break;
1239 	}
1240 
1241 	return ret;
1242 }
1243 
1244 static int vdec_stop_output(struct venus_inst *inst)
1245 {
1246 	int ret = 0;
1247 
1248 	switch (inst->codec_state) {
1249 	case VENUS_DEC_STATE_DECODING:
1250 	case VENUS_DEC_STATE_DRAIN:
1251 	case VENUS_DEC_STATE_STOPPED:
1252 	case VENUS_DEC_STATE_DRC:
1253 		ret = hfi_session_flush(inst, HFI_FLUSH_ALL, true);
1254 		inst->codec_state = VENUS_DEC_STATE_SEEK;
1255 		break;
1256 	case VENUS_DEC_STATE_INIT:
1257 	case VENUS_DEC_STATE_CAPTURE_SETUP:
1258 		ret = hfi_session_flush(inst, HFI_FLUSH_INPUT, true);
1259 		break;
1260 	default:
1261 		break;
1262 	}
1263 
1264 	return ret;
1265 }
1266 
1267 static void vdec_stop_streaming(struct vb2_queue *q)
1268 {
1269 	struct venus_inst *inst = vb2_get_drv_priv(q);
1270 	int ret = -EINVAL;
1271 
1272 	vdec_pm_get_put(inst);
1273 
1274 	mutex_lock(&inst->lock);
1275 
1276 	if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1277 		ret = vdec_stop_capture(inst);
1278 	else
1279 		ret = vdec_stop_output(inst);
1280 
1281 	venus_helper_buffers_done(inst, q->type, VB2_BUF_STATE_ERROR);
1282 
1283 	inst->session_error = 0;
1284 
1285 	if (ret)
1286 		goto unlock;
1287 
1288 	if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1289 		inst->streamon_out = 0;
1290 	else
1291 		inst->streamon_cap = 0;
1292 
1293 unlock:
1294 	mutex_unlock(&inst->lock);
1295 }
1296 
1297 static void vdec_session_release(struct venus_inst *inst)
1298 {
1299 	struct venus_core *core = inst->core;
1300 	int ret, abort = 0;
1301 
1302 	vdec_pm_get(inst);
1303 
1304 	mutex_lock(&inst->lock);
1305 	inst->codec_state = VENUS_DEC_STATE_DEINIT;
1306 
1307 	ret = hfi_session_stop(inst);
1308 	abort = (ret && ret != -EINVAL) ? 1 : 0;
1309 	ret = hfi_session_unload_res(inst);
1310 	abort = (ret && ret != -EINVAL) ? 1 : 0;
1311 	ret = venus_helper_unregister_bufs(inst);
1312 	abort = (ret && ret != -EINVAL) ? 1 : 0;
1313 	ret = venus_helper_intbufs_free(inst);
1314 	abort = (ret && ret != -EINVAL) ? 1 : 0;
1315 	ret = hfi_session_deinit(inst);
1316 	abort = (ret && ret != -EINVAL) ? 1 : 0;
1317 
1318 	if (inst->session_error || test_bit(0, &core->sys_error))
1319 		abort = 1;
1320 
1321 	if (abort)
1322 		hfi_session_abort(inst);
1323 
1324 	venus_helper_free_dpb_bufs(inst);
1325 	venus_pm_load_scale(inst);
1326 	INIT_LIST_HEAD(&inst->registeredbufs);
1327 	mutex_unlock(&inst->lock);
1328 
1329 	venus_pm_release_core(inst);
1330 	vdec_pm_put(inst, false);
1331 }
1332 
1333 static int vdec_buf_init(struct vb2_buffer *vb)
1334 {
1335 	struct venus_inst *inst = vb2_get_drv_priv(vb->vb2_queue);
1336 
1337 	inst->buf_count++;
1338 
1339 	return venus_helper_vb2_buf_init(vb);
1340 }
1341 
1342 static void vdec_buf_cleanup(struct vb2_buffer *vb)
1343 {
1344 	struct venus_inst *inst = vb2_get_drv_priv(vb->vb2_queue);
1345 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1346 	struct venus_buffer *buf = to_venus_buffer(vbuf);
1347 
1348 	mutex_lock(&inst->lock);
1349 	if (vb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1350 		if (!list_empty(&inst->registeredbufs))
1351 			list_del_init(&buf->reg_list);
1352 	mutex_unlock(&inst->lock);
1353 
1354 	inst->buf_count--;
1355 	if (!inst->buf_count)
1356 		vdec_session_release(inst);
1357 }
1358 
1359 static void vdec_vb2_buf_queue(struct vb2_buffer *vb)
1360 {
1361 	struct venus_inst *inst = vb2_get_drv_priv(vb->vb2_queue);
1362 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1363 	static const struct v4l2_event eos = { .type = V4L2_EVENT_EOS };
1364 
1365 	vdec_pm_get_put(inst);
1366 
1367 	mutex_lock(&inst->lock);
1368 
1369 	if (inst->next_buf_last && V4L2_TYPE_IS_CAPTURE(vb->vb2_queue->type) &&
1370 	    inst->codec_state == VENUS_DEC_STATE_DRC) {
1371 		vbuf->flags |= V4L2_BUF_FLAG_LAST;
1372 		vbuf->sequence = inst->sequence_cap++;
1373 		vbuf->field = V4L2_FIELD_NONE;
1374 		vb2_set_plane_payload(vb, 0, 0);
1375 		v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE);
1376 		v4l2_event_queue_fh(&inst->fh, &eos);
1377 		inst->next_buf_last = false;
1378 		mutex_unlock(&inst->lock);
1379 		return;
1380 	}
1381 
1382 	venus_helper_vb2_buf_queue(vb);
1383 	mutex_unlock(&inst->lock);
1384 }
1385 
1386 static const struct vb2_ops vdec_vb2_ops = {
1387 	.queue_setup = vdec_queue_setup,
1388 	.buf_init = vdec_buf_init,
1389 	.buf_cleanup = vdec_buf_cleanup,
1390 	.buf_prepare = venus_helper_vb2_buf_prepare,
1391 	.start_streaming = vdec_start_streaming,
1392 	.stop_streaming = vdec_stop_streaming,
1393 	.buf_queue = vdec_vb2_buf_queue,
1394 };
1395 
1396 static void vdec_buf_done(struct venus_inst *inst, unsigned int buf_type,
1397 			  u32 tag, u32 bytesused, u32 data_offset, u32 flags,
1398 			  u32 hfi_flags, u64 timestamp_us)
1399 {
1400 	enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
1401 	struct vb2_v4l2_buffer *vbuf;
1402 	struct vb2_buffer *vb;
1403 	unsigned int type;
1404 
1405 	vdec_pm_touch(inst);
1406 
1407 	if (buf_type == HFI_BUFFER_INPUT)
1408 		type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1409 	else
1410 		type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1411 
1412 	vbuf = venus_helper_find_buf(inst, type, tag);
1413 	if (!vbuf) {
1414 		venus_helper_change_dpb_owner(inst, vbuf, type, buf_type, tag);
1415 		return;
1416 	}
1417 
1418 	vbuf->flags = flags;
1419 	vbuf->field = V4L2_FIELD_NONE;
1420 	vb = &vbuf->vb2_buf;
1421 
1422 	if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1423 		vb2_set_plane_payload(vb, 0, bytesused);
1424 		vb->planes[0].data_offset = data_offset;
1425 		vb->timestamp = timestamp_us * NSEC_PER_USEC;
1426 		vbuf->sequence = inst->sequence_cap++;
1427 
1428 		if (vbuf->flags & V4L2_BUF_FLAG_LAST) {
1429 			const struct v4l2_event ev = { .type = V4L2_EVENT_EOS };
1430 
1431 			v4l2_event_queue_fh(&inst->fh, &ev);
1432 
1433 			if (inst->codec_state == VENUS_DEC_STATE_DRAIN) {
1434 				inst->drain_active = false;
1435 				inst->codec_state = VENUS_DEC_STATE_STOPPED;
1436 			}
1437 		}
1438 
1439 		if (!bytesused)
1440 			state = VB2_BUF_STATE_ERROR;
1441 	} else {
1442 		vbuf->sequence = inst->sequence_out++;
1443 	}
1444 
1445 	venus_helper_get_ts_metadata(inst, timestamp_us, vbuf);
1446 
1447 	if (hfi_flags & HFI_BUFFERFLAG_READONLY)
1448 		venus_helper_acquire_buf_ref(vbuf);
1449 
1450 	if (hfi_flags & HFI_BUFFERFLAG_DATACORRUPT)
1451 		state = VB2_BUF_STATE_ERROR;
1452 
1453 	if (hfi_flags & HFI_BUFFERFLAG_DROP_FRAME) {
1454 		state = VB2_BUF_STATE_ERROR;
1455 		vb2_set_plane_payload(vb, 0, 0);
1456 		vb->timestamp = 0;
1457 	}
1458 
1459 	v4l2_m2m_buf_done(vbuf, state);
1460 }
1461 
1462 static void vdec_event_change(struct venus_inst *inst,
1463 			      struct hfi_event_data *ev_data, bool sufficient)
1464 {
1465 	static const struct v4l2_event ev = {
1466 		.type = V4L2_EVENT_SOURCE_CHANGE,
1467 		.u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION };
1468 	struct device *dev = inst->core->dev_dec;
1469 	struct v4l2_format format = {};
1470 
1471 	mutex_lock(&inst->lock);
1472 
1473 	format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1474 	format.fmt.pix_mp.pixelformat = inst->fmt_cap->pixfmt;
1475 	format.fmt.pix_mp.width = ev_data->width;
1476 	format.fmt.pix_mp.height = ev_data->height;
1477 
1478 	vdec_try_fmt_common(inst, &format);
1479 
1480 	inst->width = format.fmt.pix_mp.width;
1481 	inst->height = format.fmt.pix_mp.height;
1482 	/*
1483 	 * Some versions of the firmware do not report crop information for
1484 	 * all codecs. For these cases, set the crop to the coded resolution.
1485 	 */
1486 	if (ev_data->input_crop.width > 0 && ev_data->input_crop.height > 0) {
1487 		inst->crop.left = ev_data->input_crop.left;
1488 		inst->crop.top = ev_data->input_crop.top;
1489 		inst->crop.width = ev_data->input_crop.width;
1490 		inst->crop.height = ev_data->input_crop.height;
1491 	} else {
1492 		inst->crop.left = 0;
1493 		inst->crop.top = 0;
1494 		inst->crop.width = ev_data->width;
1495 		inst->crop.height = ev_data->height;
1496 	}
1497 
1498 	inst->fw_min_cnt = ev_data->buf_count;
1499 	/* overwriting this to 11 for vp9 due to fw bug */
1500 	if (inst->hfi_codec == HFI_VIDEO_CODEC_VP9)
1501 		inst->fw_min_cnt = 11;
1502 
1503 	inst->out_width = ev_data->width;
1504 	inst->out_height = ev_data->height;
1505 
1506 	if (inst->bit_depth != ev_data->bit_depth) {
1507 		inst->bit_depth = ev_data->bit_depth;
1508 		if (inst->bit_depth == VIDC_BITDEPTH_10)
1509 			inst->fmt_cap = &vdec_formats[VENUS_FMT_P010];
1510 		else
1511 			inst->fmt_cap = &vdec_formats[VENUS_FMT_NV12];
1512 	}
1513 
1514 	if (inst->pic_struct != ev_data->pic_struct)
1515 		inst->pic_struct = ev_data->pic_struct;
1516 
1517 	dev_dbg(dev, VDBGM "event %s sufficient resources (%ux%u)\n",
1518 		sufficient ? "" : "not", ev_data->width, ev_data->height);
1519 
1520 	switch (inst->codec_state) {
1521 	case VENUS_DEC_STATE_INIT:
1522 		inst->codec_state = VENUS_DEC_STATE_CAPTURE_SETUP;
1523 		break;
1524 	case VENUS_DEC_STATE_DECODING:
1525 	case VENUS_DEC_STATE_DRAIN:
1526 		inst->codec_state = VENUS_DEC_STATE_DRC;
1527 		break;
1528 	default:
1529 		break;
1530 	}
1531 
1532 	/*
1533 	 * The assumption is that the firmware have to return the last buffer
1534 	 * before this event is received in the v4l2 driver. Also the firmware
1535 	 * itself doesn't mark the last decoder output buffer with HFI EOS flag.
1536 	 */
1537 
1538 	if (inst->codec_state == VENUS_DEC_STATE_DRC) {
1539 		int ret;
1540 
1541 		inst->next_buf_last = true;
1542 
1543 		ret = hfi_session_flush(inst, HFI_FLUSH_OUTPUT, false);
1544 		if (ret)
1545 			dev_dbg(dev, VDBGH "flush output error %d\n", ret);
1546 	}
1547 
1548 	inst->next_buf_last = true;
1549 	inst->reconfig = true;
1550 	v4l2_event_queue_fh(&inst->fh, &ev);
1551 	wake_up(&inst->reconf_wait);
1552 
1553 	mutex_unlock(&inst->lock);
1554 }
1555 
1556 static void vdec_event_notify(struct venus_inst *inst, u32 event,
1557 			      struct hfi_event_data *data)
1558 {
1559 	struct venus_core *core = inst->core;
1560 	struct device *dev = core->dev_dec;
1561 
1562 	vdec_pm_touch(inst);
1563 
1564 	switch (event) {
1565 	case EVT_SESSION_ERROR:
1566 		inst->session_error = true;
1567 		venus_helper_vb2_queue_error(inst);
1568 		dev_err(dev, "dec: event session error %x\n", inst->error);
1569 		break;
1570 	case EVT_SYS_EVENT_CHANGE:
1571 		switch (data->event_type) {
1572 		case HFI_EVENT_DATA_SEQUENCE_CHANGED_SUFFICIENT_BUF_RESOURCES:
1573 			vdec_event_change(inst, data, true);
1574 			break;
1575 		case HFI_EVENT_DATA_SEQUENCE_CHANGED_INSUFFICIENT_BUF_RESOURCES:
1576 			vdec_event_change(inst, data, false);
1577 			break;
1578 		case HFI_EVENT_RELEASE_BUFFER_REFERENCE:
1579 			venus_helper_release_buf_ref(inst, data->tag);
1580 			break;
1581 		default:
1582 			break;
1583 		}
1584 		break;
1585 	default:
1586 		break;
1587 	}
1588 }
1589 
1590 static void vdec_flush_done(struct venus_inst *inst)
1591 {
1592 	dev_dbg(inst->core->dev_dec, VDBGH "flush done\n");
1593 }
1594 
1595 static const struct hfi_inst_ops vdec_hfi_ops = {
1596 	.buf_done = vdec_buf_done,
1597 	.event_notify = vdec_event_notify,
1598 	.flush_done = vdec_flush_done,
1599 };
1600 
1601 static void vdec_inst_init(struct venus_inst *inst)
1602 {
1603 	inst->hfi_codec = HFI_VIDEO_CODEC_H264;
1604 	inst->fmt_out = &vdec_formats[VENUS_FMT_H264];
1605 	inst->fmt_cap = &vdec_formats[VENUS_FMT_NV12];
1606 	inst->width = frame_width_min(inst);
1607 	inst->height = ALIGN(frame_height_min(inst), 32);
1608 	inst->crop.left = 0;
1609 	inst->crop.top = 0;
1610 	inst->crop.width = inst->width;
1611 	inst->crop.height = inst->height;
1612 	inst->fw_min_cnt = 8;
1613 	inst->out_width = frame_width_min(inst);
1614 	inst->out_height = frame_height_min(inst);
1615 	inst->fps = 30;
1616 	inst->timeperframe.numerator = 1;
1617 	inst->timeperframe.denominator = 30;
1618 	inst->opb_buftype = HFI_BUFFER_OUTPUT;
1619 }
1620 
1621 static void vdec_m2m_device_run(void *priv)
1622 {
1623 }
1624 
1625 static const struct v4l2_m2m_ops vdec_m2m_ops = {
1626 	.device_run = vdec_m2m_device_run,
1627 	.job_abort = venus_helper_m2m_job_abort,
1628 };
1629 
1630 static int m2m_queue_init(void *priv, struct vb2_queue *src_vq,
1631 			  struct vb2_queue *dst_vq)
1632 {
1633 	struct venus_inst *inst = priv;
1634 	int ret;
1635 
1636 	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1637 	src_vq->io_modes = VB2_MMAP | VB2_DMABUF;
1638 	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1639 	src_vq->ops = &vdec_vb2_ops;
1640 	src_vq->mem_ops = &vb2_dma_contig_memops;
1641 	src_vq->drv_priv = inst;
1642 	src_vq->buf_struct_size = sizeof(struct venus_buffer);
1643 	src_vq->allow_zero_bytesused = 1;
1644 	src_vq->min_buffers_needed = 0;
1645 	src_vq->dev = inst->core->dev;
1646 	src_vq->lock = &inst->ctx_q_lock;
1647 	ret = vb2_queue_init(src_vq);
1648 	if (ret)
1649 		return ret;
1650 
1651 	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1652 	dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;
1653 	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1654 	dst_vq->ops = &vdec_vb2_ops;
1655 	dst_vq->mem_ops = &vb2_dma_contig_memops;
1656 	dst_vq->drv_priv = inst;
1657 	dst_vq->buf_struct_size = sizeof(struct venus_buffer);
1658 	dst_vq->allow_zero_bytesused = 1;
1659 	dst_vq->min_buffers_needed = 0;
1660 	dst_vq->dev = inst->core->dev;
1661 	dst_vq->lock = &inst->ctx_q_lock;
1662 	return vb2_queue_init(dst_vq);
1663 }
1664 
1665 static int vdec_open(struct file *file)
1666 {
1667 	struct venus_core *core = video_drvdata(file);
1668 	struct venus_inst *inst;
1669 	int ret;
1670 
1671 	inst = kzalloc(sizeof(*inst), GFP_KERNEL);
1672 	if (!inst)
1673 		return -ENOMEM;
1674 
1675 	INIT_LIST_HEAD(&inst->dpbbufs);
1676 	INIT_LIST_HEAD(&inst->registeredbufs);
1677 	INIT_LIST_HEAD(&inst->internalbufs);
1678 	INIT_LIST_HEAD(&inst->list);
1679 	mutex_init(&inst->lock);
1680 	mutex_init(&inst->ctx_q_lock);
1681 
1682 	inst->core = core;
1683 	inst->session_type = VIDC_SESSION_TYPE_DEC;
1684 	inst->num_output_bufs = 1;
1685 	inst->codec_state = VENUS_DEC_STATE_DEINIT;
1686 	inst->buf_count = 0;
1687 	inst->clk_data.core_id = VIDC_CORE_ID_DEFAULT;
1688 	inst->core_acquired = false;
1689 	inst->bit_depth = VIDC_BITDEPTH_8;
1690 	inst->pic_struct = HFI_INTERLACE_FRAME_PROGRESSIVE;
1691 	init_waitqueue_head(&inst->reconf_wait);
1692 	inst->nonblock = file->f_flags & O_NONBLOCK;
1693 
1694 	venus_helper_init_instance(inst);
1695 
1696 	ret = vdec_ctrl_init(inst);
1697 	if (ret)
1698 		goto err_free;
1699 
1700 	ret = hfi_session_create(inst, &vdec_hfi_ops);
1701 	if (ret)
1702 		goto err_ctrl_deinit;
1703 
1704 	vdec_inst_init(inst);
1705 
1706 	ida_init(&inst->dpb_ids);
1707 
1708 	/*
1709 	 * create m2m device for every instance, the m2m context scheduling
1710 	 * is made by firmware side so we do not need to care about.
1711 	 */
1712 	inst->m2m_dev = v4l2_m2m_init(&vdec_m2m_ops);
1713 	if (IS_ERR(inst->m2m_dev)) {
1714 		ret = PTR_ERR(inst->m2m_dev);
1715 		goto err_session_destroy;
1716 	}
1717 
1718 	inst->m2m_ctx = v4l2_m2m_ctx_init(inst->m2m_dev, inst, m2m_queue_init);
1719 	if (IS_ERR(inst->m2m_ctx)) {
1720 		ret = PTR_ERR(inst->m2m_ctx);
1721 		goto err_m2m_release;
1722 	}
1723 
1724 	v4l2_fh_init(&inst->fh, core->vdev_dec);
1725 
1726 	inst->fh.ctrl_handler = &inst->ctrl_handler;
1727 	v4l2_fh_add(&inst->fh);
1728 	inst->fh.m2m_ctx = inst->m2m_ctx;
1729 	file->private_data = &inst->fh;
1730 
1731 	return 0;
1732 
1733 err_m2m_release:
1734 	v4l2_m2m_release(inst->m2m_dev);
1735 err_session_destroy:
1736 	hfi_session_destroy(inst);
1737 err_ctrl_deinit:
1738 	vdec_ctrl_deinit(inst);
1739 err_free:
1740 	kfree(inst);
1741 	return ret;
1742 }
1743 
1744 static int vdec_close(struct file *file)
1745 {
1746 	struct venus_inst *inst = to_inst(file);
1747 
1748 	vdec_pm_get(inst);
1749 
1750 	v4l2_m2m_ctx_release(inst->m2m_ctx);
1751 	v4l2_m2m_release(inst->m2m_dev);
1752 	vdec_ctrl_deinit(inst);
1753 	ida_destroy(&inst->dpb_ids);
1754 	hfi_session_destroy(inst);
1755 	mutex_destroy(&inst->lock);
1756 	mutex_destroy(&inst->ctx_q_lock);
1757 	v4l2_fh_del(&inst->fh);
1758 	v4l2_fh_exit(&inst->fh);
1759 
1760 	vdec_pm_put(inst, false);
1761 
1762 	kfree(inst);
1763 	return 0;
1764 }
1765 
1766 static const struct v4l2_file_operations vdec_fops = {
1767 	.owner = THIS_MODULE,
1768 	.open = vdec_open,
1769 	.release = vdec_close,
1770 	.unlocked_ioctl = video_ioctl2,
1771 	.poll = v4l2_m2m_fop_poll,
1772 	.mmap = v4l2_m2m_fop_mmap,
1773 };
1774 
1775 static int vdec_probe(struct platform_device *pdev)
1776 {
1777 	struct device *dev = &pdev->dev;
1778 	struct video_device *vdev;
1779 	struct venus_core *core;
1780 	int ret;
1781 
1782 	if (!dev->parent)
1783 		return -EPROBE_DEFER;
1784 
1785 	core = dev_get_drvdata(dev->parent);
1786 	if (!core)
1787 		return -EPROBE_DEFER;
1788 
1789 	platform_set_drvdata(pdev, core);
1790 
1791 	if (core->pm_ops->vdec_get) {
1792 		ret = core->pm_ops->vdec_get(dev);
1793 		if (ret)
1794 			return ret;
1795 	}
1796 
1797 	vdev = video_device_alloc();
1798 	if (!vdev)
1799 		return -ENOMEM;
1800 
1801 	strscpy(vdev->name, "qcom-venus-decoder", sizeof(vdev->name));
1802 	vdev->release = video_device_release;
1803 	vdev->fops = &vdec_fops;
1804 	vdev->ioctl_ops = &vdec_ioctl_ops;
1805 	vdev->vfl_dir = VFL_DIR_M2M;
1806 	vdev->v4l2_dev = &core->v4l2_dev;
1807 	vdev->device_caps = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
1808 
1809 	ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
1810 	if (ret)
1811 		goto err_vdev_release;
1812 
1813 	core->vdev_dec = vdev;
1814 	core->dev_dec = dev;
1815 
1816 	video_set_drvdata(vdev, core);
1817 	pm_runtime_set_autosuspend_delay(dev, 2000);
1818 	pm_runtime_use_autosuspend(dev);
1819 	pm_runtime_enable(dev);
1820 
1821 	return 0;
1822 
1823 err_vdev_release:
1824 	video_device_release(vdev);
1825 	return ret;
1826 }
1827 
1828 static void vdec_remove(struct platform_device *pdev)
1829 {
1830 	struct venus_core *core = dev_get_drvdata(pdev->dev.parent);
1831 
1832 	video_unregister_device(core->vdev_dec);
1833 	pm_runtime_disable(core->dev_dec);
1834 
1835 	if (core->pm_ops->vdec_put)
1836 		core->pm_ops->vdec_put(core->dev_dec);
1837 }
1838 
1839 static __maybe_unused int vdec_runtime_suspend(struct device *dev)
1840 {
1841 	struct venus_core *core = dev_get_drvdata(dev);
1842 	const struct venus_pm_ops *pm_ops = core->pm_ops;
1843 	int ret = 0;
1844 
1845 	if (pm_ops->vdec_power)
1846 		ret = pm_ops->vdec_power(dev, POWER_OFF);
1847 
1848 	return ret;
1849 }
1850 
1851 static __maybe_unused int vdec_runtime_resume(struct device *dev)
1852 {
1853 	struct venus_core *core = dev_get_drvdata(dev);
1854 	const struct venus_pm_ops *pm_ops = core->pm_ops;
1855 	int ret = 0;
1856 
1857 	if (pm_ops->vdec_power)
1858 		ret = pm_ops->vdec_power(dev, POWER_ON);
1859 
1860 	return ret;
1861 }
1862 
1863 static const struct dev_pm_ops vdec_pm_ops = {
1864 	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
1865 				pm_runtime_force_resume)
1866 	SET_RUNTIME_PM_OPS(vdec_runtime_suspend, vdec_runtime_resume, NULL)
1867 };
1868 
1869 static const struct of_device_id vdec_dt_match[] = {
1870 	{ .compatible = "venus-decoder" },
1871 	{ }
1872 };
1873 MODULE_DEVICE_TABLE(of, vdec_dt_match);
1874 
1875 static struct platform_driver qcom_venus_dec_driver = {
1876 	.probe = vdec_probe,
1877 	.remove_new = vdec_remove,
1878 	.driver = {
1879 		.name = "qcom-venus-decoder",
1880 		.of_match_table = vdec_dt_match,
1881 		.pm = &vdec_pm_ops,
1882 	},
1883 };
1884 module_platform_driver(qcom_venus_dec_driver);
1885 
1886 MODULE_ALIAS("platform:qcom-venus-decoder");
1887 MODULE_DESCRIPTION("Qualcomm Venus video decoder driver");
1888 MODULE_LICENSE("GPL v2");
1889