1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright 2020-2021 NXP
4  */
5 
6 #include <linux/init.h>
7 #include <linux/interconnect.h>
8 #include <linux/ioctl.h>
9 #include <linux/list.h>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/vmalloc.h>
13 #include <linux/videodev2.h>
14 #include <media/v4l2-device.h>
15 #include <media/v4l2-event.h>
16 #include <media/v4l2-mem2mem.h>
17 #include <media/v4l2-ioctl.h>
18 #include <media/videobuf2-v4l2.h>
19 #include <media/videobuf2-dma-contig.h>
20 #include <media/videobuf2-vmalloc.h>
21 #include "vpu.h"
22 #include "vpu_defs.h"
23 #include "vpu_core.h"
24 #include "vpu_helpers.h"
25 #include "vpu_v4l2.h"
26 #include "vpu_cmds.h"
27 #include "vpu_rpc.h"
28 
29 #define VDEC_MIN_BUFFER_CAP		8
30 #define VDEC_MIN_BUFFER_OUT		8
31 
32 struct vdec_fs_info {
33 	char name[8];
34 	u32 type;
35 	u32 max_count;
36 	u32 req_count;
37 	u32 count;
38 	u32 index;
39 	u32 size;
40 	struct vpu_buffer buffer[32];
41 	u32 tag;
42 };
43 
44 struct vdec_t {
45 	u32 seq_hdr_found;
46 	struct vpu_buffer udata;
47 	struct vpu_decode_params params;
48 	struct vpu_dec_codec_info codec_info;
49 	enum vpu_codec_state state;
50 
51 	struct vpu_vb2_buffer *slots[VB2_MAX_FRAME];
52 	u32 req_frame_count;
53 	struct vdec_fs_info mbi;
54 	struct vdec_fs_info dcp;
55 	u32 seq_tag;
56 
57 	bool reset_codec;
58 	bool fixed_fmt;
59 	u32 decoded_frame_count;
60 	u32 display_frame_count;
61 	u32 sequence;
62 	u32 eos_received;
63 	bool is_source_changed;
64 	u32 source_change;
65 	u32 drain;
66 	bool aborting;
67 };
68 
69 static const struct vpu_format vdec_formats[] = {
70 	{
71 		.pixfmt = V4L2_PIX_FMT_NV12M_8L128,
72 		.mem_planes = 2,
73 		.comp_planes = 2,
74 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
75 		.sibling = V4L2_PIX_FMT_NV12_8L128,
76 	},
77 	{
78 		.pixfmt = V4L2_PIX_FMT_NV12_8L128,
79 		.mem_planes = 1,
80 		.comp_planes = 2,
81 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
82 		.sibling = V4L2_PIX_FMT_NV12M_8L128,
83 	},
84 	{
85 		.pixfmt = V4L2_PIX_FMT_NV12M_10BE_8L128,
86 		.mem_planes = 2,
87 		.comp_planes = 2,
88 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
89 		.sibling = V4L2_PIX_FMT_NV12_10BE_8L128,
90 	},
91 	{
92 		.pixfmt = V4L2_PIX_FMT_NV12_10BE_8L128,
93 		.mem_planes = 1,
94 		.comp_planes = 2,
95 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
96 		.sibling = V4L2_PIX_FMT_NV12M_10BE_8L128
97 	},
98 	{
99 		.pixfmt = V4L2_PIX_FMT_H264,
100 		.mem_planes = 1,
101 		.comp_planes = 1,
102 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
103 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
104 	},
105 	{
106 		.pixfmt = V4L2_PIX_FMT_H264_MVC,
107 		.mem_planes = 1,
108 		.comp_planes = 1,
109 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
110 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
111 	},
112 	{
113 		.pixfmt = V4L2_PIX_FMT_HEVC,
114 		.mem_planes = 1,
115 		.comp_planes = 1,
116 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
117 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
118 	},
119 	{
120 		.pixfmt = V4L2_PIX_FMT_VC1_ANNEX_G,
121 		.mem_planes = 1,
122 		.comp_planes = 1,
123 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
124 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
125 	},
126 	{
127 		.pixfmt = V4L2_PIX_FMT_VC1_ANNEX_L,
128 		.mem_planes = 1,
129 		.comp_planes = 1,
130 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
131 		.flags = V4L2_FMT_FLAG_COMPRESSED
132 	},
133 	{
134 		.pixfmt = V4L2_PIX_FMT_MPEG2,
135 		.mem_planes = 1,
136 		.comp_planes = 1,
137 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
138 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
139 	},
140 	{
141 		.pixfmt = V4L2_PIX_FMT_MPEG4,
142 		.mem_planes = 1,
143 		.comp_planes = 1,
144 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
145 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
146 	},
147 	{
148 		.pixfmt = V4L2_PIX_FMT_XVID,
149 		.mem_planes = 1,
150 		.comp_planes = 1,
151 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
152 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
153 	},
154 	{
155 		.pixfmt = V4L2_PIX_FMT_VP8,
156 		.mem_planes = 1,
157 		.comp_planes = 1,
158 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
159 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
160 	},
161 	{
162 		.pixfmt = V4L2_PIX_FMT_H263,
163 		.mem_planes = 1,
164 		.comp_planes = 1,
165 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
166 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
167 	},
168 	{
169 		.pixfmt = V4L2_PIX_FMT_SPK,
170 		.mem_planes = 1,
171 		.comp_planes = 1,
172 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
173 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
174 	},
175 	{
176 		.pixfmt = V4L2_PIX_FMT_RV30,
177 		.mem_planes = 1,
178 		.comp_planes = 1,
179 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
180 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
181 	},
182 	{
183 		.pixfmt = V4L2_PIX_FMT_RV40,
184 		.mem_planes = 1,
185 		.comp_planes = 1,
186 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
187 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
188 	},
189 	{0, 0, 0, 0},
190 };
191 
192 static int vdec_op_s_ctrl(struct v4l2_ctrl *ctrl)
193 {
194 	struct vpu_inst *inst = ctrl_to_inst(ctrl);
195 	struct vdec_t *vdec = inst->priv;
196 	int ret = 0;
197 
198 	vpu_inst_lock(inst);
199 	switch (ctrl->id) {
200 	case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE:
201 		vdec->params.display_delay_enable = ctrl->val;
202 		break;
203 	case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY:
204 		vdec->params.display_delay = ctrl->val;
205 		break;
206 	default:
207 		ret = -EINVAL;
208 		break;
209 	}
210 	vpu_inst_unlock(inst);
211 
212 	return ret;
213 }
214 
215 static const struct v4l2_ctrl_ops vdec_ctrl_ops = {
216 	.s_ctrl = vdec_op_s_ctrl,
217 	.g_volatile_ctrl = vpu_helper_g_volatile_ctrl,
218 };
219 
220 static int vdec_ctrl_init(struct vpu_inst *inst)
221 {
222 	struct v4l2_ctrl *ctrl;
223 	int ret;
224 
225 	ret = v4l2_ctrl_handler_init(&inst->ctrl_handler, 20);
226 	if (ret)
227 		return ret;
228 
229 	v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
230 			  V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY,
231 			  0, 0, 1, 0);
232 
233 	v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
234 			  V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE,
235 			  0, 1, 1, 0);
236 
237 	ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
238 				 V4L2_CID_MIN_BUFFERS_FOR_CAPTURE, 1, 32, 1, 2);
239 	if (ctrl)
240 		ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
241 
242 	ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
243 				 V4L2_CID_MIN_BUFFERS_FOR_OUTPUT, 1, 32, 1, 2);
244 	if (ctrl)
245 		ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
246 
247 	if (inst->ctrl_handler.error) {
248 		ret = inst->ctrl_handler.error;
249 		v4l2_ctrl_handler_free(&inst->ctrl_handler);
250 		return ret;
251 	}
252 
253 	ret = v4l2_ctrl_handler_setup(&inst->ctrl_handler);
254 	if (ret) {
255 		dev_err(inst->dev, "[%d] setup ctrls fail, ret = %d\n", inst->id, ret);
256 		v4l2_ctrl_handler_free(&inst->ctrl_handler);
257 		return ret;
258 	}
259 
260 	return 0;
261 }
262 
263 static void vdec_handle_resolution_change(struct vpu_inst *inst)
264 {
265 	struct vdec_t *vdec = inst->priv;
266 	struct vb2_queue *q;
267 
268 	if (!inst->fh.m2m_ctx)
269 		return;
270 
271 	if (inst->state != VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
272 		return;
273 	if (!vdec->source_change)
274 		return;
275 
276 	q = v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx);
277 	if (!list_empty(&q->done_list))
278 		return;
279 
280 	vdec->source_change--;
281 	vpu_notify_source_change(inst);
282 }
283 
284 static int vdec_update_state(struct vpu_inst *inst, enum vpu_codec_state state, u32 force)
285 {
286 	struct vdec_t *vdec = inst->priv;
287 	enum vpu_codec_state pre_state = inst->state;
288 
289 	if (state == VPU_CODEC_STATE_SEEK) {
290 		if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
291 			vdec->state = inst->state;
292 		else
293 			vdec->state = VPU_CODEC_STATE_ACTIVE;
294 	}
295 	if (inst->state != VPU_CODEC_STATE_SEEK || force)
296 		inst->state = state;
297 	else if (state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
298 		vdec->state = VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE;
299 
300 	if (inst->state != pre_state)
301 		vpu_trace(inst->dev, "[%d] %d -> %d\n", inst->id, pre_state, inst->state);
302 
303 	if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
304 		vdec_handle_resolution_change(inst);
305 
306 	return 0;
307 }
308 
309 static void vdec_set_last_buffer_dequeued(struct vpu_inst *inst)
310 {
311 	struct vdec_t *vdec = inst->priv;
312 
313 	if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
314 		return;
315 
316 	if (vdec->eos_received) {
317 		if (!vpu_set_last_buffer_dequeued(inst)) {
318 			vdec->eos_received--;
319 			vdec_update_state(inst, VPU_CODEC_STATE_DRAIN, 0);
320 		}
321 	}
322 }
323 
324 static int vdec_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
325 {
326 	strscpy(cap->driver, "amphion-vpu", sizeof(cap->driver));
327 	strscpy(cap->card, "amphion vpu decoder", sizeof(cap->card));
328 	strscpy(cap->bus_info, "platform: amphion-vpu", sizeof(cap->bus_info));
329 
330 	return 0;
331 }
332 
333 static int vdec_enum_fmt(struct file *file, void *fh, struct v4l2_fmtdesc *f)
334 {
335 	struct vpu_inst *inst = to_inst(file);
336 	struct vdec_t *vdec = inst->priv;
337 	const struct vpu_format *fmt;
338 	int ret = -EINVAL;
339 
340 	vpu_inst_lock(inst);
341 	if (V4L2_TYPE_IS_CAPTURE(f->type) && vdec->fixed_fmt) {
342 		fmt = vpu_get_format(inst, f->type);
343 		if (f->index == 1)
344 			fmt = vpu_helper_find_sibling(inst, f->type, fmt->pixfmt);
345 		if (f->index > 1)
346 			fmt = NULL;
347 	} else {
348 		fmt = vpu_helper_enum_format(inst, f->type, f->index);
349 	}
350 	if (!fmt)
351 		goto exit;
352 
353 	memset(f->reserved, 0, sizeof(f->reserved));
354 	f->pixelformat = fmt->pixfmt;
355 	f->flags = fmt->flags;
356 	ret = 0;
357 exit:
358 	vpu_inst_unlock(inst);
359 	return ret;
360 }
361 
362 static int vdec_g_fmt(struct file *file, void *fh, struct v4l2_format *f)
363 {
364 	struct vpu_inst *inst = to_inst(file);
365 	struct vdec_t *vdec = inst->priv;
366 	struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
367 	struct vpu_format *cur_fmt;
368 	int i;
369 
370 	vpu_inst_lock(inst);
371 	cur_fmt = vpu_get_format(inst, f->type);
372 
373 	pixmp->pixelformat = cur_fmt->pixfmt;
374 	pixmp->num_planes = cur_fmt->mem_planes;
375 	pixmp->width = cur_fmt->width;
376 	pixmp->height = cur_fmt->height;
377 	pixmp->field = cur_fmt->field;
378 	pixmp->flags = cur_fmt->flags;
379 	for (i = 0; i < pixmp->num_planes; i++) {
380 		pixmp->plane_fmt[i].bytesperline = cur_fmt->bytesperline[i];
381 		pixmp->plane_fmt[i].sizeimage = vpu_get_fmt_plane_size(cur_fmt, i);
382 	}
383 
384 	f->fmt.pix_mp.colorspace = vdec->codec_info.color_primaries;
385 	f->fmt.pix_mp.xfer_func = vdec->codec_info.transfer_chars;
386 	f->fmt.pix_mp.ycbcr_enc = vdec->codec_info.matrix_coeffs;
387 	f->fmt.pix_mp.quantization = vdec->codec_info.full_range;
388 	vpu_inst_unlock(inst);
389 
390 	return 0;
391 }
392 
393 static int vdec_try_fmt(struct file *file, void *fh, struct v4l2_format *f)
394 {
395 	struct vpu_inst *inst = to_inst(file);
396 	struct vdec_t *vdec = inst->priv;
397 	struct vpu_format fmt;
398 
399 	vpu_inst_lock(inst);
400 	if (V4L2_TYPE_IS_CAPTURE(f->type) && vdec->fixed_fmt) {
401 		struct vpu_format *cap_fmt = vpu_get_format(inst, f->type);
402 
403 		if (!vpu_helper_match_format(inst, cap_fmt->type, cap_fmt->pixfmt,
404 					     f->fmt.pix_mp.pixelformat))
405 			f->fmt.pix_mp.pixelformat = cap_fmt->pixfmt;
406 	}
407 
408 	vpu_try_fmt_common(inst, f, &fmt);
409 
410 	if (vdec->fixed_fmt) {
411 		f->fmt.pix_mp.colorspace = vdec->codec_info.color_primaries;
412 		f->fmt.pix_mp.xfer_func = vdec->codec_info.transfer_chars;
413 		f->fmt.pix_mp.ycbcr_enc = vdec->codec_info.matrix_coeffs;
414 		f->fmt.pix_mp.quantization = vdec->codec_info.full_range;
415 	} else {
416 		f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_DEFAULT;
417 		f->fmt.pix_mp.xfer_func = V4L2_XFER_FUNC_DEFAULT;
418 		f->fmt.pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
419 		f->fmt.pix_mp.quantization = V4L2_QUANTIZATION_DEFAULT;
420 	}
421 	vpu_inst_unlock(inst);
422 
423 	return 0;
424 }
425 
426 static int vdec_s_fmt_common(struct vpu_inst *inst, struct v4l2_format *f)
427 {
428 	struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
429 	struct vpu_format fmt;
430 	struct vpu_format *cur_fmt;
431 	struct vb2_queue *q;
432 	struct vdec_t *vdec = inst->priv;
433 	int i;
434 
435 	if (!inst->fh.m2m_ctx)
436 		return -EINVAL;
437 
438 	q = v4l2_m2m_get_vq(inst->fh.m2m_ctx, f->type);
439 	if (!q)
440 		return -EINVAL;
441 	if (vb2_is_busy(q))
442 		return -EBUSY;
443 
444 	if (vpu_try_fmt_common(inst, f, &fmt))
445 		return -EINVAL;
446 
447 	cur_fmt = vpu_get_format(inst, f->type);
448 	if (V4L2_TYPE_IS_OUTPUT(f->type) && inst->state != VPU_CODEC_STATE_DEINIT) {
449 		if (cur_fmt->pixfmt != fmt.pixfmt) {
450 			vdec->reset_codec = true;
451 			vdec->fixed_fmt = false;
452 		}
453 	}
454 	if (V4L2_TYPE_IS_OUTPUT(f->type) || !vdec->fixed_fmt) {
455 		memcpy(cur_fmt, &fmt, sizeof(*cur_fmt));
456 	} else {
457 		if (vpu_helper_match_format(inst, f->type, cur_fmt->pixfmt, pixmp->pixelformat)) {
458 			cur_fmt->pixfmt = fmt.pixfmt;
459 			cur_fmt->mem_planes = fmt.mem_planes;
460 		}
461 		pixmp->pixelformat = cur_fmt->pixfmt;
462 		pixmp->num_planes = cur_fmt->mem_planes;
463 		pixmp->width = cur_fmt->width;
464 		pixmp->height = cur_fmt->height;
465 		for (i = 0; i < pixmp->num_planes; i++) {
466 			pixmp->plane_fmt[i].bytesperline = cur_fmt->bytesperline[i];
467 			pixmp->plane_fmt[i].sizeimage = vpu_get_fmt_plane_size(cur_fmt, i);
468 		}
469 		pixmp->field = cur_fmt->field;
470 	}
471 
472 	if (!vdec->fixed_fmt) {
473 		if (V4L2_TYPE_IS_OUTPUT(f->type)) {
474 			vdec->params.codec_format = cur_fmt->pixfmt;
475 			vdec->codec_info.color_primaries = f->fmt.pix_mp.colorspace;
476 			vdec->codec_info.transfer_chars = f->fmt.pix_mp.xfer_func;
477 			vdec->codec_info.matrix_coeffs = f->fmt.pix_mp.ycbcr_enc;
478 			vdec->codec_info.full_range = f->fmt.pix_mp.quantization;
479 		} else {
480 			vdec->params.output_format = cur_fmt->pixfmt;
481 			inst->crop.left = 0;
482 			inst->crop.top = 0;
483 			inst->crop.width = cur_fmt->width;
484 			inst->crop.height = cur_fmt->height;
485 		}
486 	}
487 
488 	vpu_trace(inst->dev, "[%d] %c%c%c%c %dx%d\n", inst->id,
489 		  f->fmt.pix_mp.pixelformat,
490 		  f->fmt.pix_mp.pixelformat >> 8,
491 		  f->fmt.pix_mp.pixelformat >> 16,
492 		  f->fmt.pix_mp.pixelformat >> 24,
493 		  f->fmt.pix_mp.width,
494 		  f->fmt.pix_mp.height);
495 
496 	return 0;
497 }
498 
499 static int vdec_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
500 {
501 	struct vpu_inst *inst = to_inst(file);
502 	struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
503 	struct vdec_t *vdec = inst->priv;
504 	int ret = 0;
505 
506 	vpu_inst_lock(inst);
507 	ret = vdec_s_fmt_common(inst, f);
508 	if (ret)
509 		goto exit;
510 
511 	if (V4L2_TYPE_IS_OUTPUT(f->type) && !vdec->fixed_fmt) {
512 		struct v4l2_format fc;
513 
514 		memset(&fc, 0, sizeof(fc));
515 		fc.type = inst->cap_format.type;
516 		fc.fmt.pix_mp.pixelformat = inst->cap_format.pixfmt;
517 		fc.fmt.pix_mp.width = pixmp->width;
518 		fc.fmt.pix_mp.height = pixmp->height;
519 		vdec_s_fmt_common(inst, &fc);
520 	}
521 
522 	f->fmt.pix_mp.colorspace = vdec->codec_info.color_primaries;
523 	f->fmt.pix_mp.xfer_func = vdec->codec_info.transfer_chars;
524 	f->fmt.pix_mp.ycbcr_enc = vdec->codec_info.matrix_coeffs;
525 	f->fmt.pix_mp.quantization = vdec->codec_info.full_range;
526 
527 exit:
528 	vpu_inst_unlock(inst);
529 	return ret;
530 }
531 
532 static int vdec_g_selection(struct file *file, void *fh, struct v4l2_selection *s)
533 {
534 	struct vpu_inst *inst = to_inst(file);
535 
536 	if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
537 		return -EINVAL;
538 
539 	switch (s->target) {
540 	case V4L2_SEL_TGT_COMPOSE:
541 	case V4L2_SEL_TGT_COMPOSE_DEFAULT:
542 	case V4L2_SEL_TGT_COMPOSE_PADDED:
543 		s->r = inst->crop;
544 		break;
545 	case V4L2_SEL_TGT_COMPOSE_BOUNDS:
546 		s->r.left = 0;
547 		s->r.top = 0;
548 		s->r.width = inst->cap_format.width;
549 		s->r.height = inst->cap_format.height;
550 		break;
551 	default:
552 		return -EINVAL;
553 	}
554 
555 	return 0;
556 }
557 
558 static int vdec_drain(struct vpu_inst *inst)
559 {
560 	struct vdec_t *vdec = inst->priv;
561 
562 	if (!inst->fh.m2m_ctx)
563 		return 0;
564 
565 	if (!vdec->drain)
566 		return 0;
567 
568 	if (!vpu_is_source_empty(inst))
569 		return 0;
570 
571 	if (!vdec->params.frame_count) {
572 		vpu_set_last_buffer_dequeued(inst);
573 		return 0;
574 	}
575 
576 	vpu_iface_add_scode(inst, SCODE_PADDING_EOS);
577 	vdec->params.end_flag = 1;
578 	vpu_iface_set_decode_params(inst, &vdec->params, 1);
579 	vdec->drain = 0;
580 	vpu_trace(inst->dev, "[%d] frame_count = %d\n", inst->id, vdec->params.frame_count);
581 
582 	return 0;
583 }
584 
585 static int vdec_cmd_start(struct vpu_inst *inst)
586 {
587 	struct vdec_t *vdec = inst->priv;
588 
589 	switch (inst->state) {
590 	case VPU_CODEC_STATE_STARTED:
591 	case VPU_CODEC_STATE_DRAIN:
592 	case VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE:
593 		vdec_update_state(inst, VPU_CODEC_STATE_ACTIVE, 0);
594 		break;
595 	default:
596 		break;
597 	}
598 	vpu_process_capture_buffer(inst);
599 	if (vdec->eos_received)
600 		vdec_set_last_buffer_dequeued(inst);
601 	return 0;
602 }
603 
604 static int vdec_cmd_stop(struct vpu_inst *inst)
605 {
606 	struct vdec_t *vdec = inst->priv;
607 
608 	vpu_trace(inst->dev, "[%d]\n", inst->id);
609 
610 	if (inst->state == VPU_CODEC_STATE_DEINIT) {
611 		vpu_set_last_buffer_dequeued(inst);
612 	} else {
613 		vdec->drain = 1;
614 		vdec_drain(inst);
615 	}
616 
617 	return 0;
618 }
619 
620 static int vdec_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *cmd)
621 {
622 	struct vpu_inst *inst = to_inst(file);
623 	int ret;
624 
625 	ret = v4l2_m2m_ioctl_try_decoder_cmd(file, fh, cmd);
626 	if (ret)
627 		return ret;
628 
629 	vpu_inst_lock(inst);
630 	switch (cmd->cmd) {
631 	case V4L2_DEC_CMD_START:
632 		vdec_cmd_start(inst);
633 		break;
634 	case V4L2_DEC_CMD_STOP:
635 		vdec_cmd_stop(inst);
636 		break;
637 	default:
638 		break;
639 	}
640 	vpu_inst_unlock(inst);
641 
642 	return 0;
643 }
644 
645 static int vdec_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
646 {
647 	switch (sub->type) {
648 	case V4L2_EVENT_EOS:
649 		return v4l2_event_subscribe(fh, sub, 0, NULL);
650 	case V4L2_EVENT_SOURCE_CHANGE:
651 		return v4l2_src_change_event_subscribe(fh, sub);
652 	case V4L2_EVENT_CTRL:
653 		return v4l2_ctrl_subscribe_event(fh, sub);
654 	default:
655 		return -EINVAL;
656 	}
657 
658 	return 0;
659 }
660 
661 static const struct v4l2_ioctl_ops vdec_ioctl_ops = {
662 	.vidioc_querycap               = vdec_querycap,
663 	.vidioc_enum_fmt_vid_cap       = vdec_enum_fmt,
664 	.vidioc_enum_fmt_vid_out       = vdec_enum_fmt,
665 	.vidioc_g_fmt_vid_cap_mplane   = vdec_g_fmt,
666 	.vidioc_g_fmt_vid_out_mplane   = vdec_g_fmt,
667 	.vidioc_try_fmt_vid_cap_mplane = vdec_try_fmt,
668 	.vidioc_try_fmt_vid_out_mplane = vdec_try_fmt,
669 	.vidioc_s_fmt_vid_cap_mplane   = vdec_s_fmt,
670 	.vidioc_s_fmt_vid_out_mplane   = vdec_s_fmt,
671 	.vidioc_g_selection            = vdec_g_selection,
672 	.vidioc_try_decoder_cmd        = v4l2_m2m_ioctl_try_decoder_cmd,
673 	.vidioc_decoder_cmd            = vdec_decoder_cmd,
674 	.vidioc_subscribe_event        = vdec_subscribe_event,
675 	.vidioc_unsubscribe_event      = v4l2_event_unsubscribe,
676 	.vidioc_reqbufs                = v4l2_m2m_ioctl_reqbufs,
677 	.vidioc_create_bufs	       = v4l2_m2m_ioctl_create_bufs,
678 	.vidioc_prepare_buf	       = v4l2_m2m_ioctl_prepare_buf,
679 	.vidioc_querybuf               = v4l2_m2m_ioctl_querybuf,
680 	.vidioc_qbuf                   = v4l2_m2m_ioctl_qbuf,
681 	.vidioc_expbuf                 = v4l2_m2m_ioctl_expbuf,
682 	.vidioc_dqbuf                  = v4l2_m2m_ioctl_dqbuf,
683 	.vidioc_streamon               = v4l2_m2m_ioctl_streamon,
684 	.vidioc_streamoff              = v4l2_m2m_ioctl_streamoff,
685 };
686 
687 static bool vdec_check_ready(struct vpu_inst *inst, unsigned int type)
688 {
689 	struct vdec_t *vdec = inst->priv;
690 
691 	if (V4L2_TYPE_IS_OUTPUT(type))
692 		return true;
693 
694 	if (vdec->req_frame_count)
695 		return true;
696 
697 	return false;
698 }
699 
700 static struct vb2_v4l2_buffer *vdec_get_src_buffer(struct vpu_inst *inst, u32 count)
701 {
702 	if (count > 1)
703 		vpu_skip_frame(inst, count - 1);
704 
705 	return vpu_next_src_buf(inst);
706 }
707 
708 static int vdec_frame_decoded(struct vpu_inst *inst, void *arg)
709 {
710 	struct vdec_t *vdec = inst->priv;
711 	struct vpu_dec_pic_info *info = arg;
712 	struct vpu_vb2_buffer *vpu_buf;
713 	struct vb2_v4l2_buffer *vbuf;
714 	struct vb2_v4l2_buffer *src_buf;
715 	int ret = 0;
716 
717 	if (!info || info->id >= ARRAY_SIZE(vdec->slots))
718 		return -EINVAL;
719 
720 	vpu_inst_lock(inst);
721 	vpu_buf = vdec->slots[info->id];
722 	if (!vpu_buf) {
723 		dev_err(inst->dev, "[%d] decoded invalid frame[%d]\n", inst->id, info->id);
724 		ret = -EINVAL;
725 		goto exit;
726 	}
727 	vbuf = &vpu_buf->m2m_buf.vb;
728 	src_buf = vdec_get_src_buffer(inst, info->consumed_count);
729 	if (src_buf) {
730 		v4l2_m2m_buf_copy_metadata(src_buf, vbuf, true);
731 		if (info->consumed_count) {
732 			v4l2_m2m_src_buf_remove(inst->fh.m2m_ctx);
733 			vpu_set_buffer_state(src_buf, VPU_BUF_STATE_IDLE);
734 			v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
735 		} else {
736 			vpu_set_buffer_state(src_buf, VPU_BUF_STATE_DECODED);
737 		}
738 	}
739 	if (vpu_get_buffer_state(vbuf) == VPU_BUF_STATE_DECODED)
740 		dev_info(inst->dev, "[%d] buf[%d] has been decoded\n", inst->id, info->id);
741 	vpu_set_buffer_state(vbuf, VPU_BUF_STATE_DECODED);
742 	vdec->decoded_frame_count++;
743 exit:
744 	vpu_inst_unlock(inst);
745 
746 	return ret;
747 }
748 
749 static struct vpu_vb2_buffer *vdec_find_buffer(struct vpu_inst *inst, u32 luma)
750 {
751 	struct vdec_t *vdec = inst->priv;
752 	int i;
753 
754 	for (i = 0; i < ARRAY_SIZE(vdec->slots); i++) {
755 		if (!vdec->slots[i])
756 			continue;
757 		if (luma == vdec->slots[i]->luma)
758 			return vdec->slots[i];
759 	}
760 
761 	return NULL;
762 }
763 
764 static void vdec_buf_done(struct vpu_inst *inst, struct vpu_frame_info *frame)
765 {
766 	struct vdec_t *vdec = inst->priv;
767 	struct vpu_format *cur_fmt;
768 	struct vpu_vb2_buffer *vpu_buf;
769 	struct vb2_v4l2_buffer *vbuf;
770 	u32 sequence;
771 	int i;
772 
773 	if (!frame)
774 		return;
775 
776 	vpu_inst_lock(inst);
777 	sequence = vdec->sequence++;
778 	vpu_buf = vdec_find_buffer(inst, frame->luma);
779 	vpu_inst_unlock(inst);
780 	if (!vpu_buf) {
781 		dev_err(inst->dev, "[%d] can't find buffer, id = %d, addr = 0x%x\n",
782 			inst->id, frame->id, frame->luma);
783 		return;
784 	}
785 	if (frame->skipped) {
786 		dev_dbg(inst->dev, "[%d] frame skip\n", inst->id);
787 		return;
788 	}
789 
790 	cur_fmt = vpu_get_format(inst, inst->cap_format.type);
791 	vbuf = &vpu_buf->m2m_buf.vb;
792 	if (vbuf->vb2_buf.index != frame->id)
793 		dev_err(inst->dev, "[%d] buffer id(%d, %d) dismatch\n",
794 			inst->id, vbuf->vb2_buf.index, frame->id);
795 
796 	if (vpu_get_buffer_state(vbuf) != VPU_BUF_STATE_DECODED)
797 		dev_err(inst->dev, "[%d] buffer(%d) ready without decoded\n", inst->id, frame->id);
798 	vpu_set_buffer_state(vbuf, VPU_BUF_STATE_READY);
799 	for (i = 0; i < vbuf->vb2_buf.num_planes; i++)
800 		vb2_set_plane_payload(&vbuf->vb2_buf, i, vpu_get_fmt_plane_size(cur_fmt, i));
801 	vbuf->field = cur_fmt->field;
802 	vbuf->sequence = sequence;
803 	dev_dbg(inst->dev, "[%d][OUTPUT TS]%32lld\n", inst->id, vbuf->vb2_buf.timestamp);
804 
805 	v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE);
806 	vpu_inst_lock(inst);
807 	vdec->display_frame_count++;
808 	vpu_inst_unlock(inst);
809 	dev_dbg(inst->dev, "[%d] decoded : %d, display : %d, sequence : %d\n",
810 		inst->id, vdec->decoded_frame_count, vdec->display_frame_count, vdec->sequence);
811 }
812 
813 static void vdec_stop_done(struct vpu_inst *inst)
814 {
815 	struct vdec_t *vdec = inst->priv;
816 
817 	vpu_inst_lock(inst);
818 	vdec_update_state(inst, VPU_CODEC_STATE_DEINIT, 0);
819 	vdec->seq_hdr_found = 0;
820 	vdec->req_frame_count = 0;
821 	vdec->reset_codec = false;
822 	vdec->fixed_fmt = false;
823 	vdec->params.end_flag = 0;
824 	vdec->drain = 0;
825 	vdec->params.frame_count = 0;
826 	vdec->decoded_frame_count = 0;
827 	vdec->display_frame_count = 0;
828 	vdec->sequence = 0;
829 	vdec->eos_received = 0;
830 	vdec->is_source_changed = false;
831 	vdec->source_change = 0;
832 	inst->total_input_count = 0;
833 	vpu_inst_unlock(inst);
834 }
835 
836 static bool vdec_check_source_change(struct vpu_inst *inst)
837 {
838 	struct vdec_t *vdec = inst->priv;
839 	const struct vpu_format *sibling;
840 
841 	if (!inst->fh.m2m_ctx)
842 		return false;
843 
844 	if (vdec->reset_codec)
845 		return false;
846 
847 	sibling = vpu_helper_find_sibling(inst, inst->cap_format.type, inst->cap_format.pixfmt);
848 	if (sibling && vdec->codec_info.pixfmt == sibling->pixfmt)
849 		vdec->codec_info.pixfmt = inst->cap_format.pixfmt;
850 
851 	if (!vb2_is_streaming(v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx)))
852 		return true;
853 	if (inst->cap_format.pixfmt != vdec->codec_info.pixfmt)
854 		return true;
855 	if (inst->cap_format.width != vdec->codec_info.decoded_width)
856 		return true;
857 	if (inst->cap_format.height != vdec->codec_info.decoded_height)
858 		return true;
859 	if (vpu_get_num_buffers(inst, inst->cap_format.type) < inst->min_buffer_cap)
860 		return true;
861 	if (inst->crop.left != vdec->codec_info.offset_x)
862 		return true;
863 	if (inst->crop.top != vdec->codec_info.offset_y)
864 		return true;
865 	if (inst->crop.width != vdec->codec_info.width)
866 		return true;
867 	if (inst->crop.height != vdec->codec_info.height)
868 		return true;
869 
870 	return false;
871 }
872 
873 static void vdec_init_fmt(struct vpu_inst *inst)
874 {
875 	struct vdec_t *vdec = inst->priv;
876 	struct v4l2_format f;
877 
878 	memset(&f, 0, sizeof(f));
879 	f.type = inst->cap_format.type;
880 	f.fmt.pix_mp.pixelformat = vdec->codec_info.pixfmt;
881 	f.fmt.pix_mp.width = vdec->codec_info.decoded_width;
882 	f.fmt.pix_mp.height = vdec->codec_info.decoded_height;
883 	if (vdec->codec_info.progressive)
884 		f.fmt.pix_mp.field = V4L2_FIELD_NONE;
885 	else
886 		f.fmt.pix_mp.field = V4L2_FIELD_SEQ_TB;
887 	vpu_try_fmt_common(inst, &f, &inst->cap_format);
888 
889 	inst->out_format.width = vdec->codec_info.width;
890 	inst->out_format.height = vdec->codec_info.height;
891 }
892 
893 static void vdec_init_crop(struct vpu_inst *inst)
894 {
895 	struct vdec_t *vdec = inst->priv;
896 
897 	inst->crop.left = vdec->codec_info.offset_x;
898 	inst->crop.top = vdec->codec_info.offset_y;
899 	inst->crop.width = vdec->codec_info.width;
900 	inst->crop.height = vdec->codec_info.height;
901 }
902 
903 static void vdec_init_mbi(struct vpu_inst *inst)
904 {
905 	struct vdec_t *vdec = inst->priv;
906 
907 	vdec->mbi.size = vdec->codec_info.mbi_size;
908 	vdec->mbi.max_count = ARRAY_SIZE(vdec->mbi.buffer);
909 	scnprintf(vdec->mbi.name, sizeof(vdec->mbi.name), "mbi");
910 	vdec->mbi.type = MEM_RES_MBI;
911 	vdec->mbi.tag = vdec->seq_tag;
912 }
913 
914 static void vdec_init_dcp(struct vpu_inst *inst)
915 {
916 	struct vdec_t *vdec = inst->priv;
917 
918 	vdec->dcp.size = vdec->codec_info.dcp_size;
919 	vdec->dcp.max_count = ARRAY_SIZE(vdec->dcp.buffer);
920 	scnprintf(vdec->dcp.name, sizeof(vdec->dcp.name), "dcp");
921 	vdec->dcp.type = MEM_RES_DCP;
922 	vdec->dcp.tag = vdec->seq_tag;
923 }
924 
925 static void vdec_request_one_fs(struct vdec_fs_info *fs)
926 {
927 	fs->req_count++;
928 	if (fs->req_count > fs->max_count)
929 		fs->req_count = fs->max_count;
930 }
931 
932 static int vdec_alloc_fs_buffer(struct vpu_inst *inst, struct vdec_fs_info *fs)
933 {
934 	struct vpu_buffer *buffer;
935 
936 	if (!fs->size)
937 		return -EINVAL;
938 
939 	if (fs->count >= fs->req_count)
940 		return -EINVAL;
941 
942 	buffer = &fs->buffer[fs->count];
943 	if (buffer->virt && buffer->length >= fs->size)
944 		return 0;
945 
946 	vpu_free_dma(buffer);
947 	buffer->length = fs->size;
948 	return vpu_alloc_dma(inst->core, buffer);
949 }
950 
951 static void vdec_alloc_fs(struct vpu_inst *inst, struct vdec_fs_info *fs)
952 {
953 	int ret;
954 
955 	while (fs->count < fs->req_count) {
956 		ret = vdec_alloc_fs_buffer(inst, fs);
957 		if (ret)
958 			break;
959 		fs->count++;
960 	}
961 }
962 
963 static void vdec_clear_fs(struct vdec_fs_info *fs)
964 {
965 	u32 i;
966 
967 	if (!fs)
968 		return;
969 
970 	for (i = 0; i < ARRAY_SIZE(fs->buffer); i++)
971 		vpu_free_dma(&fs->buffer[i]);
972 	memset(fs, 0, sizeof(*fs));
973 }
974 
975 static int vdec_response_fs(struct vpu_inst *inst, struct vdec_fs_info *fs)
976 {
977 	struct vpu_fs_info info;
978 	int ret;
979 
980 	if (fs->index >= fs->count)
981 		return 0;
982 
983 	memset(&info, 0, sizeof(info));
984 	info.id = fs->index;
985 	info.type = fs->type;
986 	info.tag = fs->tag;
987 	info.luma_addr = fs->buffer[fs->index].phys;
988 	info.luma_size = fs->buffer[fs->index].length;
989 	ret = vpu_session_alloc_fs(inst, &info);
990 	if (ret)
991 		return ret;
992 
993 	fs->index++;
994 	return 0;
995 }
996 
997 static int vdec_response_frame_abnormal(struct vpu_inst *inst)
998 {
999 	struct vdec_t *vdec = inst->priv;
1000 	struct vpu_fs_info info;
1001 
1002 	if (!vdec->req_frame_count)
1003 		return 0;
1004 
1005 	memset(&info, 0, sizeof(info));
1006 	info.type = MEM_RES_FRAME;
1007 	info.tag = vdec->seq_tag + 0xf0;
1008 	vpu_session_alloc_fs(inst, &info);
1009 	vdec->req_frame_count--;
1010 
1011 	return 0;
1012 }
1013 
1014 static int vdec_response_frame(struct vpu_inst *inst, struct vb2_v4l2_buffer *vbuf)
1015 {
1016 	struct vdec_t *vdec = inst->priv;
1017 	struct vpu_vb2_buffer *vpu_buf;
1018 	struct vpu_fs_info info;
1019 	int ret;
1020 
1021 	if (inst->state != VPU_CODEC_STATE_ACTIVE)
1022 		return -EINVAL;
1023 
1024 	if (vdec->aborting)
1025 		return -EINVAL;
1026 
1027 	if (!vdec->req_frame_count)
1028 		return -EINVAL;
1029 
1030 	if (!vbuf)
1031 		return -EINVAL;
1032 
1033 	if (vdec->slots[vbuf->vb2_buf.index]) {
1034 		dev_err(inst->dev, "[%d] repeat alloc fs %d\n",
1035 			inst->id, vbuf->vb2_buf.index);
1036 		return -EINVAL;
1037 	}
1038 
1039 	dev_dbg(inst->dev, "[%d] state = %d, alloc fs %d, tag = 0x%x\n",
1040 		inst->id, inst->state, vbuf->vb2_buf.index, vdec->seq_tag);
1041 	vpu_buf = to_vpu_vb2_buffer(vbuf);
1042 
1043 	memset(&info, 0, sizeof(info));
1044 	info.id = vbuf->vb2_buf.index;
1045 	info.type = MEM_RES_FRAME;
1046 	info.tag = vdec->seq_tag;
1047 	info.luma_addr = vpu_get_vb_phy_addr(&vbuf->vb2_buf, 0);
1048 	info.luma_size = inst->cap_format.sizeimage[0];
1049 	if (vbuf->vb2_buf.num_planes > 1)
1050 		info.chroma_addr = vpu_get_vb_phy_addr(&vbuf->vb2_buf, 1);
1051 	else
1052 		info.chroma_addr = info.luma_addr + info.luma_size;
1053 	info.chromau_size = inst->cap_format.sizeimage[1];
1054 	info.bytesperline = inst->cap_format.bytesperline[0];
1055 	ret = vpu_session_alloc_fs(inst, &info);
1056 	if (ret)
1057 		return ret;
1058 
1059 	vpu_buf->tag = info.tag;
1060 	vpu_buf->luma = info.luma_addr;
1061 	vpu_buf->chroma_u = info.chroma_addr;
1062 	vpu_buf->chroma_v = 0;
1063 	vpu_set_buffer_state(vbuf, VPU_BUF_STATE_INUSE);
1064 	vdec->slots[info.id] = vpu_buf;
1065 	vdec->req_frame_count--;
1066 
1067 	return 0;
1068 }
1069 
1070 static void vdec_response_fs_request(struct vpu_inst *inst, bool force)
1071 {
1072 	struct vdec_t *vdec = inst->priv;
1073 	int i;
1074 	int ret;
1075 
1076 	if (force) {
1077 		for (i = vdec->req_frame_count; i > 0; i--)
1078 			vdec_response_frame_abnormal(inst);
1079 		return;
1080 	}
1081 
1082 	for (i = vdec->req_frame_count; i > 0; i--) {
1083 		ret = vpu_process_capture_buffer(inst);
1084 		if (ret)
1085 			break;
1086 		if (vdec->eos_received)
1087 			break;
1088 	}
1089 
1090 	for (i = vdec->mbi.index; i < vdec->mbi.count; i++) {
1091 		if (vdec_response_fs(inst, &vdec->mbi))
1092 			break;
1093 		if (vdec->eos_received)
1094 			break;
1095 	}
1096 	for (i = vdec->dcp.index; i < vdec->dcp.count; i++) {
1097 		if (vdec_response_fs(inst, &vdec->dcp))
1098 			break;
1099 		if (vdec->eos_received)
1100 			break;
1101 	}
1102 }
1103 
1104 static void vdec_response_fs_release(struct vpu_inst *inst, u32 id, u32 tag)
1105 {
1106 	struct vpu_fs_info info;
1107 
1108 	memset(&info, 0, sizeof(info));
1109 	info.id = id;
1110 	info.tag = tag;
1111 	vpu_session_release_fs(inst, &info);
1112 }
1113 
1114 static void vdec_recycle_buffer(struct vpu_inst *inst, struct vb2_v4l2_buffer *vbuf)
1115 {
1116 	if (!inst->fh.m2m_ctx)
1117 		return;
1118 	if (vbuf->vb2_buf.state != VB2_BUF_STATE_ACTIVE)
1119 		return;
1120 	if (vpu_find_buf_by_idx(inst, vbuf->vb2_buf.type, vbuf->vb2_buf.index))
1121 		return;
1122 	v4l2_m2m_buf_queue(inst->fh.m2m_ctx, vbuf);
1123 }
1124 
1125 static void vdec_clear_slots(struct vpu_inst *inst)
1126 {
1127 	struct vdec_t *vdec = inst->priv;
1128 	struct vpu_vb2_buffer *vpu_buf;
1129 	struct vb2_v4l2_buffer *vbuf;
1130 	int i;
1131 
1132 	for (i = 0; i < ARRAY_SIZE(vdec->slots); i++) {
1133 		if (!vdec->slots[i])
1134 			continue;
1135 
1136 		vpu_buf = vdec->slots[i];
1137 		vbuf = &vpu_buf->m2m_buf.vb;
1138 
1139 		vpu_trace(inst->dev, "clear slot %d\n", i);
1140 		vdec_response_fs_release(inst, i, vpu_buf->tag);
1141 		vdec_recycle_buffer(inst, vbuf);
1142 		vdec->slots[i]->state = VPU_BUF_STATE_IDLE;
1143 		vdec->slots[i] = NULL;
1144 	}
1145 }
1146 
1147 static void vdec_event_seq_hdr(struct vpu_inst *inst, struct vpu_dec_codec_info *hdr)
1148 {
1149 	struct vdec_t *vdec = inst->priv;
1150 
1151 	vpu_inst_lock(inst);
1152 	memcpy(&vdec->codec_info, hdr, sizeof(vdec->codec_info));
1153 
1154 	vpu_trace(inst->dev, "[%d] %d x %d, crop : (%d, %d) %d x %d, %d, %d\n",
1155 		  inst->id,
1156 		  vdec->codec_info.decoded_width,
1157 		  vdec->codec_info.decoded_height,
1158 		  vdec->codec_info.offset_x,
1159 		  vdec->codec_info.offset_y,
1160 		  vdec->codec_info.width,
1161 		  vdec->codec_info.height,
1162 		  hdr->num_ref_frms,
1163 		  hdr->num_dpb_frms);
1164 	inst->min_buffer_cap = hdr->num_ref_frms + hdr->num_dpb_frms;
1165 	vdec->is_source_changed = vdec_check_source_change(inst);
1166 	vdec_init_fmt(inst);
1167 	vdec_init_crop(inst);
1168 	vdec_init_mbi(inst);
1169 	vdec_init_dcp(inst);
1170 	if (!vdec->seq_hdr_found) {
1171 		vdec->seq_tag = vdec->codec_info.tag;
1172 		if (vdec->is_source_changed) {
1173 			vdec_update_state(inst, VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE, 0);
1174 			vdec->source_change++;
1175 			vdec_handle_resolution_change(inst);
1176 			vdec->is_source_changed = false;
1177 		}
1178 	}
1179 	if (vdec->seq_tag != vdec->codec_info.tag) {
1180 		vdec_response_fs_request(inst, true);
1181 		vpu_trace(inst->dev, "[%d] seq tag change: %d -> %d\n",
1182 			  inst->id, vdec->seq_tag, vdec->codec_info.tag);
1183 	}
1184 	vdec->seq_hdr_found++;
1185 	vdec->fixed_fmt = true;
1186 	vpu_inst_unlock(inst);
1187 }
1188 
1189 static void vdec_event_resolution_change(struct vpu_inst *inst)
1190 {
1191 	struct vdec_t *vdec = inst->priv;
1192 
1193 	vpu_trace(inst->dev, "[%d]\n", inst->id);
1194 	vpu_inst_lock(inst);
1195 	vdec->seq_tag = vdec->codec_info.tag;
1196 	vdec_clear_fs(&vdec->mbi);
1197 	vdec_clear_fs(&vdec->dcp);
1198 	vdec_clear_slots(inst);
1199 	vdec_init_mbi(inst);
1200 	vdec_init_dcp(inst);
1201 	if (vdec->is_source_changed) {
1202 		vdec_update_state(inst, VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE, 0);
1203 		vdec->source_change++;
1204 		vdec_handle_resolution_change(inst);
1205 		vdec->is_source_changed = false;
1206 	}
1207 	vpu_inst_unlock(inst);
1208 }
1209 
1210 static void vdec_event_req_fs(struct vpu_inst *inst, struct vpu_fs_info *fs)
1211 {
1212 	struct vdec_t *vdec = inst->priv;
1213 
1214 	if (!fs)
1215 		return;
1216 
1217 	vpu_inst_lock(inst);
1218 
1219 	switch (fs->type) {
1220 	case MEM_RES_FRAME:
1221 		vdec->req_frame_count++;
1222 		break;
1223 	case MEM_RES_MBI:
1224 		vdec_request_one_fs(&vdec->mbi);
1225 		break;
1226 	case MEM_RES_DCP:
1227 		vdec_request_one_fs(&vdec->dcp);
1228 		break;
1229 	default:
1230 		break;
1231 	}
1232 
1233 	vdec_alloc_fs(inst, &vdec->mbi);
1234 	vdec_alloc_fs(inst, &vdec->dcp);
1235 
1236 	vdec_response_fs_request(inst, false);
1237 
1238 	vpu_inst_unlock(inst);
1239 }
1240 
1241 static void vdec_evnet_rel_fs(struct vpu_inst *inst, struct vpu_fs_info *fs)
1242 {
1243 	struct vdec_t *vdec = inst->priv;
1244 	struct vpu_vb2_buffer *vpu_buf;
1245 	struct vb2_v4l2_buffer *vbuf;
1246 
1247 	if (!fs || fs->id >= ARRAY_SIZE(vdec->slots))
1248 		return;
1249 	if (fs->type != MEM_RES_FRAME)
1250 		return;
1251 
1252 	if (fs->id >= vpu_get_num_buffers(inst, inst->cap_format.type)) {
1253 		dev_err(inst->dev, "[%d] invalid fs(%d) to release\n", inst->id, fs->id);
1254 		return;
1255 	}
1256 
1257 	vpu_inst_lock(inst);
1258 	vpu_buf = vdec->slots[fs->id];
1259 	vdec->slots[fs->id] = NULL;
1260 
1261 	if (!vpu_buf) {
1262 		dev_dbg(inst->dev, "[%d] fs[%d] has bee released\n", inst->id, fs->id);
1263 		goto exit;
1264 	}
1265 
1266 	vbuf = &vpu_buf->m2m_buf.vb;
1267 	if (vpu_get_buffer_state(vbuf) == VPU_BUF_STATE_DECODED) {
1268 		dev_dbg(inst->dev, "[%d] frame skip\n", inst->id);
1269 		vdec->sequence++;
1270 	}
1271 
1272 	vdec_response_fs_release(inst, fs->id, vpu_buf->tag);
1273 	if (vpu_get_buffer_state(vbuf) != VPU_BUF_STATE_READY)
1274 		vdec_recycle_buffer(inst, vbuf);
1275 
1276 	vpu_set_buffer_state(vbuf, VPU_BUF_STATE_IDLE);
1277 	vpu_process_capture_buffer(inst);
1278 
1279 exit:
1280 	vpu_inst_unlock(inst);
1281 }
1282 
1283 static void vdec_event_eos(struct vpu_inst *inst)
1284 {
1285 	struct vdec_t *vdec = inst->priv;
1286 
1287 	vpu_trace(inst->dev, "[%d] input : %d, decoded : %d, display : %d, sequence : %d\n",
1288 		  inst->id,
1289 		  vdec->params.frame_count,
1290 		  vdec->decoded_frame_count,
1291 		  vdec->display_frame_count,
1292 		  vdec->sequence);
1293 	vpu_inst_lock(inst);
1294 	vdec->eos_received++;
1295 	vdec->fixed_fmt = false;
1296 	inst->min_buffer_cap = VDEC_MIN_BUFFER_CAP;
1297 	vdec_set_last_buffer_dequeued(inst);
1298 	vpu_inst_unlock(inst);
1299 }
1300 
1301 static void vdec_event_notify(struct vpu_inst *inst, u32 event, void *data)
1302 {
1303 	switch (event) {
1304 	case VPU_MSG_ID_SEQ_HDR_FOUND:
1305 		vdec_event_seq_hdr(inst, data);
1306 		break;
1307 	case VPU_MSG_ID_RES_CHANGE:
1308 		vdec_event_resolution_change(inst);
1309 		break;
1310 	case VPU_MSG_ID_FRAME_REQ:
1311 		vdec_event_req_fs(inst, data);
1312 		break;
1313 	case VPU_MSG_ID_FRAME_RELEASE:
1314 		vdec_evnet_rel_fs(inst, data);
1315 		break;
1316 	case VPU_MSG_ID_PIC_EOS:
1317 		vdec_event_eos(inst);
1318 		break;
1319 	default:
1320 		break;
1321 	}
1322 }
1323 
1324 static int vdec_process_output(struct vpu_inst *inst, struct vb2_buffer *vb)
1325 {
1326 	struct vdec_t *vdec = inst->priv;
1327 	struct vb2_v4l2_buffer *vbuf;
1328 	struct vpu_rpc_buffer_desc desc;
1329 	u32 free_space;
1330 	int ret;
1331 
1332 	vbuf = to_vb2_v4l2_buffer(vb);
1333 	dev_dbg(inst->dev, "[%d] dec output [%d] %d : %ld\n",
1334 		inst->id, vbuf->sequence, vb->index, vb2_get_plane_payload(vb, 0));
1335 
1336 	if (inst->state == VPU_CODEC_STATE_DEINIT)
1337 		return -EINVAL;
1338 	if (vdec->reset_codec)
1339 		return -EINVAL;
1340 
1341 	if (inst->state == VPU_CODEC_STATE_STARTED)
1342 		vdec_update_state(inst, VPU_CODEC_STATE_ACTIVE, 0);
1343 
1344 	ret = vpu_iface_get_stream_buffer_desc(inst, &desc);
1345 	if (ret)
1346 		return ret;
1347 
1348 	free_space = vpu_helper_get_free_space(inst);
1349 	if (free_space < vb2_get_plane_payload(vb, 0) + 0x40000)
1350 		return -ENOMEM;
1351 
1352 	vpu_set_buffer_state(vbuf, VPU_BUF_STATE_INUSE);
1353 	ret = vpu_iface_input_frame(inst, vb);
1354 	if (ret < 0)
1355 		return -ENOMEM;
1356 
1357 	dev_dbg(inst->dev, "[%d][INPUT  TS]%32lld\n", inst->id, vb->timestamp);
1358 	vdec->params.frame_count++;
1359 
1360 	if (vdec->drain)
1361 		vdec_drain(inst);
1362 
1363 	return 0;
1364 }
1365 
1366 static int vdec_process_capture(struct vpu_inst *inst, struct vb2_buffer *vb)
1367 {
1368 	struct vdec_t *vdec = inst->priv;
1369 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1370 	int ret;
1371 
1372 	if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
1373 		return -EINVAL;
1374 	if (vdec->reset_codec)
1375 		return -EINVAL;
1376 
1377 	ret = vdec_response_frame(inst, vbuf);
1378 	if (ret)
1379 		return ret;
1380 	v4l2_m2m_dst_buf_remove_by_buf(inst->fh.m2m_ctx, vbuf);
1381 	return 0;
1382 }
1383 
1384 static void vdec_on_queue_empty(struct vpu_inst *inst, u32 type)
1385 {
1386 	struct vdec_t *vdec = inst->priv;
1387 
1388 	if (V4L2_TYPE_IS_OUTPUT(type))
1389 		return;
1390 
1391 	vdec_handle_resolution_change(inst);
1392 	if (vdec->eos_received)
1393 		vdec_set_last_buffer_dequeued(inst);
1394 }
1395 
1396 static void vdec_abort(struct vpu_inst *inst)
1397 {
1398 	struct vdec_t *vdec = inst->priv;
1399 	struct vpu_rpc_buffer_desc desc;
1400 	int ret;
1401 
1402 	vpu_trace(inst->dev, "[%d] state = %d\n", inst->id, inst->state);
1403 
1404 	vdec->aborting = true;
1405 	vpu_iface_add_scode(inst, SCODE_PADDING_ABORT);
1406 	vdec->params.end_flag = 1;
1407 	vpu_iface_set_decode_params(inst, &vdec->params, 1);
1408 
1409 	vpu_session_abort(inst);
1410 
1411 	ret = vpu_iface_get_stream_buffer_desc(inst, &desc);
1412 	if (!ret)
1413 		vpu_iface_update_stream_buffer(inst, desc.rptr, 1);
1414 
1415 	vpu_session_rst_buf(inst);
1416 	vpu_trace(inst->dev, "[%d] input : %d, decoded : %d, display : %d, sequence : %d\n",
1417 		  inst->id,
1418 		  vdec->params.frame_count,
1419 		  vdec->decoded_frame_count,
1420 		  vdec->display_frame_count,
1421 		  vdec->sequence);
1422 	if (!vdec->seq_hdr_found)
1423 		vdec->reset_codec = true;
1424 	vdec->params.end_flag = 0;
1425 	vdec->drain = 0;
1426 	vdec->params.frame_count = 0;
1427 	vdec->decoded_frame_count = 0;
1428 	vdec->display_frame_count = 0;
1429 	vdec->sequence = 0;
1430 	vdec->aborting = false;
1431 	inst->extra_size = 0;
1432 }
1433 
1434 static void vdec_stop(struct vpu_inst *inst, bool free)
1435 {
1436 	struct vdec_t *vdec = inst->priv;
1437 
1438 	vdec_clear_slots(inst);
1439 	if (inst->state != VPU_CODEC_STATE_DEINIT)
1440 		vpu_session_stop(inst);
1441 	vdec_clear_fs(&vdec->mbi);
1442 	vdec_clear_fs(&vdec->dcp);
1443 	if (free) {
1444 		vpu_free_dma(&vdec->udata);
1445 		vpu_free_dma(&inst->stream_buffer);
1446 	}
1447 	vdec_update_state(inst, VPU_CODEC_STATE_DEINIT, 1);
1448 	vdec->reset_codec = false;
1449 }
1450 
1451 static void vdec_release(struct vpu_inst *inst)
1452 {
1453 	if (inst->id != VPU_INST_NULL_ID)
1454 		vpu_trace(inst->dev, "[%d]\n", inst->id);
1455 	vpu_inst_lock(inst);
1456 	vdec_stop(inst, true);
1457 	vpu_inst_unlock(inst);
1458 }
1459 
1460 static void vdec_cleanup(struct vpu_inst *inst)
1461 {
1462 	struct vdec_t *vdec;
1463 
1464 	if (!inst)
1465 		return;
1466 
1467 	vdec = inst->priv;
1468 	vfree(vdec);
1469 	inst->priv = NULL;
1470 	vfree(inst);
1471 }
1472 
1473 static void vdec_init_params(struct vdec_t *vdec)
1474 {
1475 	vdec->params.frame_count = 0;
1476 	vdec->params.end_flag = 0;
1477 }
1478 
1479 static int vdec_start(struct vpu_inst *inst)
1480 {
1481 	struct vdec_t *vdec = inst->priv;
1482 	int stream_buffer_size;
1483 	int ret;
1484 
1485 	if (inst->state != VPU_CODEC_STATE_DEINIT)
1486 		return 0;
1487 
1488 	vpu_trace(inst->dev, "[%d]\n", inst->id);
1489 	if (!vdec->udata.virt) {
1490 		vdec->udata.length = 0x1000;
1491 		ret = vpu_alloc_dma(inst->core, &vdec->udata);
1492 		if (ret) {
1493 			dev_err(inst->dev, "[%d] alloc udata fail\n", inst->id);
1494 			goto error;
1495 		}
1496 	}
1497 
1498 	if (!inst->stream_buffer.virt) {
1499 		stream_buffer_size = vpu_iface_get_stream_buffer_size(inst->core);
1500 		if (stream_buffer_size > 0) {
1501 			inst->stream_buffer.length = stream_buffer_size;
1502 			ret = vpu_alloc_dma(inst->core, &inst->stream_buffer);
1503 			if (ret) {
1504 				dev_err(inst->dev, "[%d] alloc stream buffer fail\n", inst->id);
1505 				goto error;
1506 			}
1507 			inst->use_stream_buffer = true;
1508 		}
1509 	}
1510 
1511 	if (inst->use_stream_buffer)
1512 		vpu_iface_config_stream_buffer(inst, &inst->stream_buffer);
1513 	vpu_iface_init_instance(inst);
1514 	vdec->params.udata.base = vdec->udata.phys;
1515 	vdec->params.udata.size = vdec->udata.length;
1516 	ret = vpu_iface_set_decode_params(inst, &vdec->params, 0);
1517 	if (ret) {
1518 		dev_err(inst->dev, "[%d] set decode params fail\n", inst->id);
1519 		goto error;
1520 	}
1521 
1522 	vdec_init_params(vdec);
1523 	ret = vpu_session_start(inst);
1524 	if (ret) {
1525 		dev_err(inst->dev, "[%d] start fail\n", inst->id);
1526 		goto error;
1527 	}
1528 
1529 	vdec_update_state(inst, VPU_CODEC_STATE_STARTED, 0);
1530 
1531 	return 0;
1532 error:
1533 	vpu_free_dma(&vdec->udata);
1534 	vpu_free_dma(&inst->stream_buffer);
1535 	return ret;
1536 }
1537 
1538 static int vdec_start_session(struct vpu_inst *inst, u32 type)
1539 {
1540 	struct vdec_t *vdec = inst->priv;
1541 	int ret = 0;
1542 
1543 	if (V4L2_TYPE_IS_OUTPUT(type)) {
1544 		if (vdec->reset_codec)
1545 			vdec_stop(inst, false);
1546 		if (inst->state == VPU_CODEC_STATE_DEINIT) {
1547 			ret = vdec_start(inst);
1548 			if (ret)
1549 				return ret;
1550 		}
1551 	}
1552 
1553 	if (V4L2_TYPE_IS_OUTPUT(type)) {
1554 		vdec_update_state(inst, vdec->state, 1);
1555 		vdec->eos_received = 0;
1556 		vpu_process_output_buffer(inst);
1557 	} else {
1558 		vdec_cmd_start(inst);
1559 	}
1560 	if (inst->state == VPU_CODEC_STATE_ACTIVE)
1561 		vdec_response_fs_request(inst, false);
1562 
1563 	return ret;
1564 }
1565 
1566 static int vdec_stop_session(struct vpu_inst *inst, u32 type)
1567 {
1568 	struct vdec_t *vdec = inst->priv;
1569 
1570 	if (inst->state == VPU_CODEC_STATE_DEINIT)
1571 		return 0;
1572 
1573 	if (V4L2_TYPE_IS_OUTPUT(type)) {
1574 		vdec_update_state(inst, VPU_CODEC_STATE_SEEK, 0);
1575 		vdec->drain = 0;
1576 	} else {
1577 		if (inst->state != VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE) {
1578 			vdec_abort(inst);
1579 			vdec->eos_received = 0;
1580 		}
1581 		vdec_clear_slots(inst);
1582 	}
1583 
1584 	return 0;
1585 }
1586 
1587 static int vdec_get_debug_info(struct vpu_inst *inst, char *str, u32 size, u32 i)
1588 {
1589 	struct vdec_t *vdec = inst->priv;
1590 	int num = -1;
1591 
1592 	switch (i) {
1593 	case 0:
1594 		num = scnprintf(str, size,
1595 				"req_frame_count = %d\ninterlaced = %d\n",
1596 				vdec->req_frame_count,
1597 				vdec->codec_info.progressive ? 0 : 1);
1598 		break;
1599 	case 1:
1600 		num = scnprintf(str, size,
1601 				"mbi: size = 0x%x request = %d, alloc = %d, response = %d\n",
1602 				vdec->mbi.size,
1603 				vdec->mbi.req_count,
1604 				vdec->mbi.count,
1605 				vdec->mbi.index);
1606 		break;
1607 	case 2:
1608 		num = scnprintf(str, size,
1609 				"dcp: size = 0x%x request = %d, alloc = %d, response = %d\n",
1610 				vdec->dcp.size,
1611 				vdec->dcp.req_count,
1612 				vdec->dcp.count,
1613 				vdec->dcp.index);
1614 		break;
1615 	case 3:
1616 		num = scnprintf(str, size, "input_frame_count = %d\n", vdec->params.frame_count);
1617 		break;
1618 	case 4:
1619 		num = scnprintf(str, size, "decoded_frame_count = %d\n", vdec->decoded_frame_count);
1620 		break;
1621 	case 5:
1622 		num = scnprintf(str, size, "display_frame_count = %d\n", vdec->display_frame_count);
1623 		break;
1624 	case 6:
1625 		num = scnprintf(str, size, "sequence = %d\n", vdec->sequence);
1626 		break;
1627 	case 7:
1628 		num = scnprintf(str, size, "drain = %d, eos = %d, source_change = %d\n",
1629 				vdec->drain, vdec->eos_received, vdec->source_change);
1630 		break;
1631 	case 8:
1632 		num = scnprintf(str, size, "fps = %d/%d\n",
1633 				vdec->codec_info.frame_rate.numerator,
1634 				vdec->codec_info.frame_rate.denominator);
1635 		break;
1636 	case 9:
1637 		num = scnprintf(str, size, "colorspace: %d, %d, %d, %d (%d)\n",
1638 				vdec->codec_info.color_primaries,
1639 				vdec->codec_info.transfer_chars,
1640 				vdec->codec_info.matrix_coeffs,
1641 				vdec->codec_info.full_range,
1642 				vdec->codec_info.vui_present);
1643 		break;
1644 	default:
1645 		break;
1646 	}
1647 
1648 	return num;
1649 }
1650 
1651 static struct vpu_inst_ops vdec_inst_ops = {
1652 	.ctrl_init = vdec_ctrl_init,
1653 	.check_ready = vdec_check_ready,
1654 	.buf_done = vdec_buf_done,
1655 	.get_one_frame = vdec_frame_decoded,
1656 	.stop_done = vdec_stop_done,
1657 	.event_notify = vdec_event_notify,
1658 	.release = vdec_release,
1659 	.cleanup = vdec_cleanup,
1660 	.start = vdec_start_session,
1661 	.stop = vdec_stop_session,
1662 	.process_output = vdec_process_output,
1663 	.process_capture = vdec_process_capture,
1664 	.on_queue_empty = vdec_on_queue_empty,
1665 	.get_debug_info = vdec_get_debug_info,
1666 	.wait_prepare = vpu_inst_unlock,
1667 	.wait_finish = vpu_inst_lock,
1668 };
1669 
1670 static void vdec_init(struct file *file)
1671 {
1672 	struct vpu_inst *inst = to_inst(file);
1673 	struct v4l2_format f;
1674 
1675 	memset(&f, 0, sizeof(f));
1676 	f.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1677 	f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;
1678 	f.fmt.pix_mp.width = 1280;
1679 	f.fmt.pix_mp.height = 720;
1680 	f.fmt.pix_mp.field = V4L2_FIELD_NONE;
1681 	vdec_s_fmt(file, &inst->fh, &f);
1682 
1683 	memset(&f, 0, sizeof(f));
1684 	f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1685 	f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M_8L128;
1686 	f.fmt.pix_mp.width = 1280;
1687 	f.fmt.pix_mp.height = 720;
1688 	f.fmt.pix_mp.field = V4L2_FIELD_NONE;
1689 	vdec_s_fmt(file, &inst->fh, &f);
1690 }
1691 
1692 static int vdec_open(struct file *file)
1693 {
1694 	struct vpu_inst *inst;
1695 	struct vdec_t *vdec;
1696 	int ret;
1697 
1698 	inst = vzalloc(sizeof(*inst));
1699 	if (!inst)
1700 		return -ENOMEM;
1701 
1702 	vdec = vzalloc(sizeof(*vdec));
1703 	if (!vdec) {
1704 		vfree(inst);
1705 		return -ENOMEM;
1706 	}
1707 
1708 	inst->ops = &vdec_inst_ops;
1709 	inst->formats = vdec_formats;
1710 	inst->type = VPU_CORE_TYPE_DEC;
1711 	inst->priv = vdec;
1712 
1713 	ret = vpu_v4l2_open(file, inst);
1714 	if (ret)
1715 		return ret;
1716 
1717 	vdec->fixed_fmt = false;
1718 	vdec->state = VPU_CODEC_STATE_ACTIVE;
1719 	inst->min_buffer_cap = VDEC_MIN_BUFFER_CAP;
1720 	inst->min_buffer_out = VDEC_MIN_BUFFER_OUT;
1721 	vdec_init(file);
1722 
1723 	return 0;
1724 }
1725 
1726 static const struct v4l2_file_operations vdec_fops = {
1727 	.owner = THIS_MODULE,
1728 	.open = vdec_open,
1729 	.release = vpu_v4l2_close,
1730 	.unlocked_ioctl = video_ioctl2,
1731 	.poll = v4l2_m2m_fop_poll,
1732 	.mmap = v4l2_m2m_fop_mmap,
1733 };
1734 
1735 const struct v4l2_ioctl_ops *vdec_get_ioctl_ops(void)
1736 {
1737 	return &vdec_ioctl_ops;
1738 }
1739 
1740 const struct v4l2_file_operations *vdec_get_fops(void)
1741 {
1742 	return &vdec_fops;
1743 }
1744