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/delay.h>
13 #include <linux/videodev2.h>
14 #include <linux/ktime.h>
15 #include <linux/rational.h>
16 #include <linux/vmalloc.h>
17 #include <media/v4l2-device.h>
18 #include <media/v4l2-event.h>
19 #include <media/v4l2-mem2mem.h>
20 #include <media/v4l2-ioctl.h>
21 #include <media/videobuf2-v4l2.h>
22 #include <media/videobuf2-dma-contig.h>
23 #include <media/videobuf2-vmalloc.h>
24 #include "vpu.h"
25 #include "vpu_defs.h"
26 #include "vpu_core.h"
27 #include "vpu_helpers.h"
28 #include "vpu_v4l2.h"
29 #include "vpu_cmds.h"
30 #include "vpu_rpc.h"
31 
32 #define VENC_OUTPUT_ENABLE	BIT(0)
33 #define VENC_CAPTURE_ENABLE	BIT(1)
34 #define VENC_ENABLE_MASK	(VENC_OUTPUT_ENABLE | VENC_CAPTURE_ENABLE)
35 #define VENC_MAX_BUF_CNT	8
36 #define VENC_MIN_BUFFER_OUT	6
37 #define VENC_MIN_BUFFER_CAP	6
38 
39 struct venc_t {
40 	struct vpu_encode_params params;
41 	u32 request_key_frame;
42 	u32 input_ready;
43 	u32 cpb_size;
44 	bool bitrate_change;
45 
46 	struct vpu_buffer enc[VENC_MAX_BUF_CNT];
47 	struct vpu_buffer ref[VENC_MAX_BUF_CNT];
48 	struct vpu_buffer act[VENC_MAX_BUF_CNT];
49 	struct list_head frames;
50 	u32 frame_count;
51 	u32 encode_count;
52 	u32 ready_count;
53 	u32 enable;
54 	u32 stopped;
55 
56 	u32 skipped_count;
57 	u32 skipped_bytes;
58 
59 	wait_queue_head_t wq;
60 };
61 
62 struct venc_frame_t {
63 	struct list_head list;
64 	struct vpu_enc_pic_info info;
65 	u32 bytesused;
66 	s64 timestamp;
67 };
68 
69 static const struct vpu_format venc_formats[] = {
70 	{
71 		.pixfmt = V4L2_PIX_FMT_NV12M,
72 		.mem_planes = 2,
73 		.comp_planes = 2,
74 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
75 		.sibling = V4L2_PIX_FMT_NV12,
76 	},
77 	{
78 		.pixfmt = V4L2_PIX_FMT_NV12,
79 		.mem_planes = 1,
80 		.comp_planes = 2,
81 		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
82 		.sibling = V4L2_PIX_FMT_NV12M,
83 	},
84 	{
85 		.pixfmt = V4L2_PIX_FMT_H264,
86 		.mem_planes = 1,
87 		.comp_planes = 1,
88 		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
89 		.flags = V4L2_FMT_FLAG_COMPRESSED
90 	},
91 	{0, 0, 0, 0},
92 };
93 
94 static int venc_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
95 {
96 	strscpy(cap->driver, "amphion-vpu", sizeof(cap->driver));
97 	strscpy(cap->card, "amphion vpu encoder", sizeof(cap->card));
98 	strscpy(cap->bus_info, "platform: amphion-vpu", sizeof(cap->bus_info));
99 
100 	return 0;
101 }
102 
103 static int venc_enum_fmt(struct file *file, void *fh, struct v4l2_fmtdesc *f)
104 {
105 	struct vpu_inst *inst = to_inst(file);
106 	const struct vpu_format *fmt;
107 
108 	memset(f->reserved, 0, sizeof(f->reserved));
109 	fmt = vpu_helper_enum_format(inst, f->type, f->index);
110 	if (!fmt)
111 		return -EINVAL;
112 
113 	f->pixelformat = fmt->pixfmt;
114 	f->flags = fmt->flags;
115 
116 	return 0;
117 }
118 
119 static int venc_enum_framesizes(struct file *file, void *fh, struct v4l2_frmsizeenum *fsize)
120 {
121 	struct vpu_inst *inst = to_inst(file);
122 	const struct vpu_core_resources *res;
123 
124 	if (!fsize || fsize->index)
125 		return -EINVAL;
126 
127 	if (!vpu_helper_find_format(inst, 0, fsize->pixel_format))
128 		return -EINVAL;
129 
130 	res = vpu_get_resource(inst);
131 	if (!res)
132 		return -EINVAL;
133 	fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
134 	fsize->stepwise.max_width = res->max_width;
135 	fsize->stepwise.max_height = res->max_height;
136 	fsize->stepwise.min_width = res->min_width;
137 	fsize->stepwise.min_height = res->min_height;
138 	fsize->stepwise.step_width = res->step_width;
139 	fsize->stepwise.step_height = res->step_height;
140 
141 	return 0;
142 }
143 
144 static int venc_enum_frameintervals(struct file *file, void *fh, struct v4l2_frmivalenum *fival)
145 {
146 	struct vpu_inst *inst = to_inst(file);
147 	const struct vpu_core_resources *res;
148 
149 	if (!fival || fival->index)
150 		return -EINVAL;
151 
152 	if (!vpu_helper_find_format(inst, 0, fival->pixel_format))
153 		return -EINVAL;
154 
155 	if (!fival->width || !fival->height)
156 		return -EINVAL;
157 
158 	res = vpu_get_resource(inst);
159 	if (!res)
160 		return -EINVAL;
161 	if (fival->width < res->min_width || fival->width > res->max_width ||
162 	    fival->height < res->min_height || fival->height > res->max_height)
163 		return -EINVAL;
164 
165 	fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
166 	fival->stepwise.min.numerator = 1;
167 	fival->stepwise.min.denominator = USHRT_MAX;
168 	fival->stepwise.max.numerator = USHRT_MAX;
169 	fival->stepwise.max.denominator = 1;
170 	fival->stepwise.step.numerator = 1;
171 	fival->stepwise.step.denominator = 1;
172 
173 	return 0;
174 }
175 
176 static int venc_g_fmt(struct file *file, void *fh, struct v4l2_format *f)
177 {
178 	struct vpu_inst *inst = to_inst(file);
179 	struct venc_t *venc = inst->priv;
180 	struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
181 	struct vpu_format *cur_fmt;
182 	int i;
183 
184 	cur_fmt = vpu_get_format(inst, f->type);
185 
186 	pixmp->pixelformat = cur_fmt->pixfmt;
187 	pixmp->num_planes = cur_fmt->mem_planes;
188 	pixmp->width = cur_fmt->width;
189 	pixmp->height = cur_fmt->height;
190 	pixmp->field = cur_fmt->field;
191 	pixmp->flags = cur_fmt->flags;
192 	for (i = 0; i < pixmp->num_planes; i++) {
193 		pixmp->plane_fmt[i].bytesperline = cur_fmt->bytesperline[i];
194 		pixmp->plane_fmt[i].sizeimage = vpu_get_fmt_plane_size(cur_fmt, i);
195 	}
196 
197 	f->fmt.pix_mp.colorspace = venc->params.color.primaries;
198 	f->fmt.pix_mp.xfer_func = venc->params.color.transfer;
199 	f->fmt.pix_mp.ycbcr_enc = venc->params.color.matrix;
200 	f->fmt.pix_mp.quantization = venc->params.color.full_range;
201 
202 	return 0;
203 }
204 
205 static int venc_try_fmt(struct file *file, void *fh, struct v4l2_format *f)
206 {
207 	struct vpu_inst *inst = to_inst(file);
208 	struct vpu_format fmt;
209 
210 	vpu_try_fmt_common(inst, f, &fmt);
211 
212 	return 0;
213 }
214 
215 static int venc_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
216 {
217 	struct vpu_inst *inst = to_inst(file);
218 	struct vpu_format fmt;
219 	struct vpu_format *cur_fmt;
220 	struct vb2_queue *q;
221 	struct venc_t *venc = inst->priv;
222 	struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
223 
224 	q = v4l2_m2m_get_vq(inst->fh.m2m_ctx, f->type);
225 	if (!q)
226 		return -EINVAL;
227 	if (vb2_is_busy(q))
228 		return -EBUSY;
229 
230 	if (vpu_try_fmt_common(inst, f, &fmt))
231 		return -EINVAL;
232 
233 	cur_fmt = vpu_get_format(inst, f->type);
234 
235 	memcpy(cur_fmt, &fmt, sizeof(*cur_fmt));
236 
237 	if (V4L2_TYPE_IS_OUTPUT(f->type)) {
238 		venc->params.input_format = cur_fmt->pixfmt;
239 		venc->params.src_stride = cur_fmt->bytesperline[0];
240 		venc->params.src_width = cur_fmt->width;
241 		venc->params.src_height = cur_fmt->height;
242 		venc->params.crop.left = 0;
243 		venc->params.crop.top = 0;
244 		venc->params.crop.width = cur_fmt->width;
245 		venc->params.crop.height = cur_fmt->height;
246 	} else {
247 		venc->params.codec_format = cur_fmt->pixfmt;
248 		venc->params.out_width = cur_fmt->width;
249 		venc->params.out_height = cur_fmt->height;
250 	}
251 
252 	if (V4L2_TYPE_IS_OUTPUT(f->type)) {
253 		venc->params.color.primaries = pix_mp->colorspace;
254 		venc->params.color.transfer = pix_mp->xfer_func;
255 		venc->params.color.matrix = pix_mp->ycbcr_enc;
256 		venc->params.color.full_range = pix_mp->quantization;
257 	}
258 
259 	pix_mp->colorspace = venc->params.color.primaries;
260 	pix_mp->xfer_func = venc->params.color.transfer;
261 	pix_mp->ycbcr_enc = venc->params.color.matrix;
262 	pix_mp->quantization = venc->params.color.full_range;
263 
264 	return 0;
265 }
266 
267 static int venc_g_parm(struct file *file, void *fh, struct v4l2_streamparm *parm)
268 {
269 	struct vpu_inst *inst = to_inst(file);
270 	struct venc_t *venc = inst->priv;
271 	struct v4l2_fract *timeperframe;
272 
273 	if (!parm)
274 		return -EINVAL;
275 
276 	if (!V4L2_TYPE_IS_OUTPUT(parm->type))
277 		return -EINVAL;
278 
279 	if (!vpu_helper_check_type(inst, parm->type))
280 		return -EINVAL;
281 
282 	timeperframe = &parm->parm.capture.timeperframe;
283 	parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
284 	parm->parm.capture.readbuffers = 0;
285 	timeperframe->numerator = venc->params.frame_rate.numerator;
286 	timeperframe->denominator = venc->params.frame_rate.denominator;
287 
288 	return 0;
289 }
290 
291 static int venc_s_parm(struct file *file, void *fh, struct v4l2_streamparm *parm)
292 {
293 	struct vpu_inst *inst = to_inst(file);
294 	struct venc_t *venc = inst->priv;
295 	struct v4l2_fract *timeperframe;
296 	unsigned long n, d;
297 
298 	if (!parm)
299 		return -EINVAL;
300 
301 	if (!V4L2_TYPE_IS_OUTPUT(parm->type))
302 		return -EINVAL;
303 
304 	if (!vpu_helper_check_type(inst, parm->type))
305 		return -EINVAL;
306 
307 	timeperframe = &parm->parm.capture.timeperframe;
308 	if (!timeperframe->numerator)
309 		timeperframe->numerator = venc->params.frame_rate.numerator;
310 	if (!timeperframe->denominator)
311 		timeperframe->denominator = venc->params.frame_rate.denominator;
312 
313 	venc->params.frame_rate.numerator = timeperframe->numerator;
314 	venc->params.frame_rate.denominator = timeperframe->denominator;
315 
316 	rational_best_approximation(venc->params.frame_rate.numerator,
317 				    venc->params.frame_rate.denominator,
318 				    venc->params.frame_rate.numerator,
319 				    venc->params.frame_rate.denominator,
320 				    &n, &d);
321 	venc->params.frame_rate.numerator = n;
322 	venc->params.frame_rate.denominator = d;
323 
324 	parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
325 	memset(parm->parm.capture.reserved, 0, sizeof(parm->parm.capture.reserved));
326 
327 	return 0;
328 }
329 
330 static int venc_g_selection(struct file *file, void *fh, struct v4l2_selection *s)
331 {
332 	struct vpu_inst *inst = to_inst(file);
333 	struct venc_t *venc = inst->priv;
334 
335 	if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
336 		return -EINVAL;
337 
338 	switch (s->target) {
339 	case V4L2_SEL_TGT_CROP_DEFAULT:
340 	case V4L2_SEL_TGT_CROP_BOUNDS:
341 		s->r.left = 0;
342 		s->r.top = 0;
343 		s->r.width = inst->out_format.width;
344 		s->r.height = inst->out_format.height;
345 		break;
346 	case V4L2_SEL_TGT_CROP:
347 		s->r = venc->params.crop;
348 		break;
349 	default:
350 		return -EINVAL;
351 	}
352 
353 	return 0;
354 }
355 
356 static int venc_valid_crop(struct venc_t *venc, const struct vpu_core_resources *res)
357 {
358 	struct v4l2_rect *rect = NULL;
359 	u32 min_width;
360 	u32 min_height;
361 	u32 src_width;
362 	u32 src_height;
363 
364 	rect = &venc->params.crop;
365 	min_width = res->min_width;
366 	min_height = res->min_height;
367 	src_width = venc->params.src_width;
368 	src_height = venc->params.src_height;
369 
370 	if (rect->width == 0 || rect->height == 0)
371 		return -EINVAL;
372 	if (rect->left > src_width - min_width || rect->top > src_height - min_height)
373 		return -EINVAL;
374 
375 	rect->width = min(rect->width, src_width - rect->left);
376 	rect->width = max_t(u32, rect->width, min_width);
377 
378 	rect->height = min(rect->height, src_height - rect->top);
379 	rect->height = max_t(u32, rect->height, min_height);
380 
381 	return 0;
382 }
383 
384 static int venc_s_selection(struct file *file, void *fh, struct v4l2_selection *s)
385 {
386 	struct vpu_inst *inst = to_inst(file);
387 	const struct vpu_core_resources *res;
388 	struct venc_t *venc = inst->priv;
389 
390 	res = vpu_get_resource(inst);
391 	if (!res)
392 		return -EINVAL;
393 
394 	if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
395 		return -EINVAL;
396 	if (s->target != V4L2_SEL_TGT_CROP)
397 		return -EINVAL;
398 
399 	venc->params.crop.left = ALIGN(s->r.left, res->step_width);
400 	venc->params.crop.top = ALIGN(s->r.top, res->step_height);
401 	venc->params.crop.width = ALIGN(s->r.width, res->step_width);
402 	venc->params.crop.height = ALIGN(s->r.height, res->step_height);
403 	if (venc_valid_crop(venc, res)) {
404 		venc->params.crop.left = 0;
405 		venc->params.crop.top = 0;
406 		venc->params.crop.width = venc->params.src_width;
407 		venc->params.crop.height = venc->params.src_height;
408 	}
409 
410 	inst->crop = venc->params.crop;
411 
412 	return 0;
413 }
414 
415 static int venc_drain(struct vpu_inst *inst)
416 {
417 	struct venc_t *venc = inst->priv;
418 	int ret;
419 
420 	if (!inst->fh.m2m_ctx)
421 		return 0;
422 
423 	if (inst->state != VPU_CODEC_STATE_DRAIN)
424 		return 0;
425 
426 	if (!vpu_is_source_empty(inst))
427 		return 0;
428 
429 	if (!venc->input_ready)
430 		return 0;
431 
432 	venc->input_ready = false;
433 	vpu_trace(inst->dev, "[%d]\n", inst->id);
434 	ret = vpu_session_stop(inst);
435 	if (ret)
436 		return ret;
437 	inst->state = VPU_CODEC_STATE_STOP;
438 	wake_up_all(&venc->wq);
439 
440 	return 0;
441 }
442 
443 static int venc_request_eos(struct vpu_inst *inst)
444 {
445 	inst->state = VPU_CODEC_STATE_DRAIN;
446 	venc_drain(inst);
447 
448 	return 0;
449 }
450 
451 static int venc_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *cmd)
452 {
453 	struct vpu_inst *inst = to_inst(file);
454 	int ret;
455 
456 	ret = v4l2_m2m_ioctl_try_encoder_cmd(file, fh, cmd);
457 	if (ret)
458 		return ret;
459 
460 	vpu_inst_lock(inst);
461 	if (cmd->cmd == V4L2_ENC_CMD_STOP) {
462 		if (inst->state == VPU_CODEC_STATE_DEINIT)
463 			vpu_set_last_buffer_dequeued(inst, true);
464 		else
465 			venc_request_eos(inst);
466 	}
467 	vpu_inst_unlock(inst);
468 
469 	return 0;
470 }
471 
472 static int venc_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
473 {
474 	switch (sub->type) {
475 	case V4L2_EVENT_EOS:
476 		return v4l2_event_subscribe(fh, sub, 0, NULL);
477 	case V4L2_EVENT_CTRL:
478 		return v4l2_ctrl_subscribe_event(fh, sub);
479 	default:
480 		return -EINVAL;
481 	}
482 }
483 
484 static const struct v4l2_ioctl_ops venc_ioctl_ops = {
485 	.vidioc_querycap               = venc_querycap,
486 	.vidioc_enum_fmt_vid_cap       = venc_enum_fmt,
487 	.vidioc_enum_fmt_vid_out       = venc_enum_fmt,
488 	.vidioc_enum_framesizes        = venc_enum_framesizes,
489 	.vidioc_enum_frameintervals    = venc_enum_frameintervals,
490 	.vidioc_g_fmt_vid_cap_mplane   = venc_g_fmt,
491 	.vidioc_g_fmt_vid_out_mplane   = venc_g_fmt,
492 	.vidioc_try_fmt_vid_cap_mplane = venc_try_fmt,
493 	.vidioc_try_fmt_vid_out_mplane = venc_try_fmt,
494 	.vidioc_s_fmt_vid_cap_mplane   = venc_s_fmt,
495 	.vidioc_s_fmt_vid_out_mplane   = venc_s_fmt,
496 	.vidioc_g_parm                 = venc_g_parm,
497 	.vidioc_s_parm                 = venc_s_parm,
498 	.vidioc_g_selection            = venc_g_selection,
499 	.vidioc_s_selection            = venc_s_selection,
500 	.vidioc_try_encoder_cmd        = v4l2_m2m_ioctl_try_encoder_cmd,
501 	.vidioc_encoder_cmd            = venc_encoder_cmd,
502 	.vidioc_subscribe_event        = venc_subscribe_event,
503 	.vidioc_unsubscribe_event      = v4l2_event_unsubscribe,
504 	.vidioc_reqbufs                = v4l2_m2m_ioctl_reqbufs,
505 	.vidioc_querybuf               = v4l2_m2m_ioctl_querybuf,
506 	.vidioc_create_bufs	       = v4l2_m2m_ioctl_create_bufs,
507 	.vidioc_prepare_buf	       = v4l2_m2m_ioctl_prepare_buf,
508 	.vidioc_qbuf                   = v4l2_m2m_ioctl_qbuf,
509 	.vidioc_expbuf                 = v4l2_m2m_ioctl_expbuf,
510 	.vidioc_dqbuf                  = v4l2_m2m_ioctl_dqbuf,
511 	.vidioc_streamon               = v4l2_m2m_ioctl_streamon,
512 	.vidioc_streamoff              = v4l2_m2m_ioctl_streamoff,
513 };
514 
515 static int venc_op_s_ctrl(struct v4l2_ctrl *ctrl)
516 {
517 	struct vpu_inst *inst = ctrl_to_inst(ctrl);
518 	struct venc_t *venc = inst->priv;
519 	int ret = 0;
520 
521 	vpu_inst_lock(inst);
522 	switch (ctrl->id) {
523 	case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
524 		venc->params.profile = ctrl->val;
525 		break;
526 	case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
527 		venc->params.level = ctrl->val;
528 		break;
529 	case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
530 		venc->params.rc_enable = ctrl->val;
531 		break;
532 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
533 		venc->params.rc_mode = ctrl->val;
534 		break;
535 	case V4L2_CID_MPEG_VIDEO_BITRATE:
536 		if (ctrl->val != venc->params.bitrate)
537 			venc->bitrate_change = true;
538 		venc->params.bitrate = ctrl->val;
539 		break;
540 	case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
541 		venc->params.bitrate_max = ctrl->val;
542 		break;
543 	case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
544 		venc->params.gop_length = ctrl->val;
545 		break;
546 	case V4L2_CID_MPEG_VIDEO_B_FRAMES:
547 		venc->params.bframes = ctrl->val;
548 		break;
549 	case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:
550 		venc->params.i_frame_qp = ctrl->val;
551 		break;
552 	case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:
553 		venc->params.p_frame_qp = ctrl->val;
554 		break;
555 	case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:
556 		venc->params.b_frame_qp = ctrl->val;
557 		break;
558 	case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:
559 		venc->request_key_frame = 1;
560 		break;
561 	case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:
562 		venc->cpb_size = ctrl->val * 1024;
563 		break;
564 	case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
565 		venc->params.sar.enable = ctrl->val;
566 		break;
567 	case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
568 		venc->params.sar.idc = ctrl->val;
569 		break;
570 	case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:
571 		venc->params.sar.width = ctrl->val;
572 		break;
573 	case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:
574 		venc->params.sar.height = ctrl->val;
575 		break;
576 	case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
577 		break;
578 	default:
579 		ret = -EINVAL;
580 		break;
581 	}
582 	vpu_inst_unlock(inst);
583 
584 	return ret;
585 }
586 
587 static const struct v4l2_ctrl_ops venc_ctrl_ops = {
588 	.s_ctrl = venc_op_s_ctrl,
589 	.g_volatile_ctrl = vpu_helper_g_volatile_ctrl,
590 };
591 
592 static int venc_ctrl_init(struct vpu_inst *inst)
593 {
594 	struct v4l2_ctrl *ctrl;
595 	int ret;
596 
597 	ret = v4l2_ctrl_handler_init(&inst->ctrl_handler, 20);
598 	if (ret)
599 		return ret;
600 
601 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
602 			       V4L2_CID_MPEG_VIDEO_H264_PROFILE,
603 			       V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
604 			       ~((1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
605 				 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
606 				 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)),
607 			       V4L2_MPEG_VIDEO_H264_PROFILE_HIGH);
608 
609 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
610 			       V4L2_CID_MPEG_VIDEO_H264_LEVEL,
611 			       V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
612 			       0x0,
613 			       V4L2_MPEG_VIDEO_H264_LEVEL_4_0);
614 
615 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
616 			  V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE, 0, 1, 1, 1);
617 
618 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
619 			       V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
620 			       V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
621 			       ~((1 << V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) |
622 				 (1 << V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)),
623 			       V4L2_MPEG_VIDEO_BITRATE_MODE_CBR);
624 
625 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
626 			  V4L2_CID_MPEG_VIDEO_BITRATE,
627 			  BITRATE_MIN,
628 			  BITRATE_MAX,
629 			  BITRATE_STEP,
630 			  BITRATE_DEFAULT);
631 
632 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
633 			  V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
634 			  BITRATE_MIN, BITRATE_MAX,
635 			  BITRATE_STEP,
636 			  BITRATE_DEFAULT_PEAK);
637 
638 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
639 			  V4L2_CID_MPEG_VIDEO_GOP_SIZE, 1, 8000, 1, 30);
640 
641 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
642 			  V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 4, 1, 0);
643 
644 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
645 			  V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP, 1, 51, 1, 26);
646 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
647 			  V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP, 1, 51, 1, 28);
648 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
649 			  V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP, 1, 51, 1, 30);
650 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
651 			  V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME, 0, 0, 0, 0);
652 	ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
653 				 V4L2_CID_MIN_BUFFERS_FOR_CAPTURE, 1, 32, 1, 2);
654 	if (ctrl)
655 		ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
656 	ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
657 				 V4L2_CID_MIN_BUFFERS_FOR_OUTPUT, 1, 32, 1, 2);
658 	if (ctrl)
659 		ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
660 
661 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
662 			  V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE, 64, 10240, 1, 1024);
663 
664 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
665 			  V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE, 0, 1, 1, 1);
666 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
667 			       V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC,
668 			       V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED,
669 			       0x0,
670 			       V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1);
671 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
672 			  V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH,
673 			  0, USHRT_MAX, 1, 1);
674 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
675 			  V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT,
676 			  0, USHRT_MAX, 1, 1);
677 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
678 			       V4L2_CID_MPEG_VIDEO_HEADER_MODE,
679 			       V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,
680 			       ~(1 << V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME),
681 			       V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME);
682 
683 	if (inst->ctrl_handler.error) {
684 		ret = inst->ctrl_handler.error;
685 		v4l2_ctrl_handler_free(&inst->ctrl_handler);
686 		return ret;
687 	}
688 
689 	ret = v4l2_ctrl_handler_setup(&inst->ctrl_handler);
690 	if (ret) {
691 		dev_err(inst->dev, "[%d] setup ctrls fail, ret = %d\n", inst->id, ret);
692 		v4l2_ctrl_handler_free(&inst->ctrl_handler);
693 		return ret;
694 	}
695 
696 	return 0;
697 }
698 
699 static bool venc_check_ready(struct vpu_inst *inst, unsigned int type)
700 {
701 	struct venc_t *venc = inst->priv;
702 
703 	if (V4L2_TYPE_IS_OUTPUT(type)) {
704 		if (vpu_helper_get_free_space(inst) < venc->cpb_size)
705 			return false;
706 		return venc->input_ready;
707 	}
708 
709 	if (list_empty(&venc->frames))
710 		return false;
711 	return true;
712 }
713 
714 static u32 venc_get_enable_mask(u32 type)
715 {
716 	if (V4L2_TYPE_IS_OUTPUT(type))
717 		return VENC_OUTPUT_ENABLE;
718 	else
719 		return VENC_CAPTURE_ENABLE;
720 }
721 
722 static void venc_set_enable(struct venc_t *venc, u32 type, int enable)
723 {
724 	u32 mask = venc_get_enable_mask(type);
725 
726 	if (enable)
727 		venc->enable |= mask;
728 	else
729 		venc->enable &= ~mask;
730 }
731 
732 static u32 venc_get_enable(struct venc_t *venc, u32 type)
733 {
734 	return venc->enable & venc_get_enable_mask(type);
735 }
736 
737 static void venc_input_done(struct vpu_inst *inst)
738 {
739 	struct venc_t *venc = inst->priv;
740 
741 	vpu_inst_lock(inst);
742 	venc->input_ready = true;
743 	vpu_process_output_buffer(inst);
744 	if (inst->state == VPU_CODEC_STATE_DRAIN)
745 		venc_drain(inst);
746 	vpu_inst_unlock(inst);
747 }
748 
749 /*
750  * It's hardware limitation, that there may be several bytes
751  * redundant data at the beginning of frame.
752  * For android platform, the redundant data may cause cts test fail
753  * So driver will strip them
754  */
755 static int venc_precheck_encoded_frame(struct vpu_inst *inst, struct venc_frame_t *frame)
756 {
757 	struct venc_t *venc;
758 	int skipped;
759 
760 	if (!frame || !frame->bytesused)
761 		return -EINVAL;
762 
763 	venc = inst->priv;
764 	skipped = vpu_helper_find_startcode(&inst->stream_buffer,
765 					    inst->cap_format.pixfmt,
766 					    frame->info.wptr - inst->stream_buffer.phys,
767 					    frame->bytesused);
768 	if (skipped > 0) {
769 		frame->bytesused -= skipped;
770 		frame->info.wptr = vpu_helper_step_walk(&inst->stream_buffer,
771 							frame->info.wptr, skipped);
772 		venc->skipped_bytes += skipped;
773 		venc->skipped_count++;
774 	}
775 
776 	return 0;
777 }
778 
779 static int venc_get_one_encoded_frame(struct vpu_inst *inst,
780 				      struct venc_frame_t *frame,
781 				      struct vb2_v4l2_buffer *vbuf)
782 {
783 	struct venc_t *venc = inst->priv;
784 	struct vb2_v4l2_buffer *src_buf;
785 
786 	if (!vbuf)
787 		return -EAGAIN;
788 
789 	src_buf = vpu_find_buf_by_sequence(inst, inst->out_format.type, frame->info.frame_id);
790 	if (src_buf) {
791 		v4l2_m2m_buf_copy_metadata(src_buf, vbuf, true);
792 		vpu_set_buffer_state(src_buf, VPU_BUF_STATE_IDLE);
793 		v4l2_m2m_src_buf_remove_by_buf(inst->fh.m2m_ctx, src_buf);
794 		v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
795 	} else {
796 		vbuf->vb2_buf.timestamp = frame->info.timestamp;
797 	}
798 	if (!venc_get_enable(inst->priv, vbuf->vb2_buf.type)) {
799 		v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
800 		return 0;
801 	}
802 	if (frame->bytesused > vbuf->vb2_buf.planes[0].length) {
803 		v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
804 		return -ENOMEM;
805 	}
806 
807 	venc_precheck_encoded_frame(inst, frame);
808 
809 	if (frame->bytesused) {
810 		u32 rptr = frame->info.wptr;
811 		void *dst = vb2_plane_vaddr(&vbuf->vb2_buf, 0);
812 
813 		vpu_helper_copy_from_stream_buffer(&inst->stream_buffer,
814 						   &rptr, frame->bytesused, dst);
815 		vpu_iface_update_stream_buffer(inst, rptr, 0);
816 	}
817 	vb2_set_plane_payload(&vbuf->vb2_buf, 0, frame->bytesused);
818 	vbuf->sequence = frame->info.frame_id;
819 	vbuf->field = inst->cap_format.field;
820 	vbuf->flags |= frame->info.pic_type;
821 	vpu_set_buffer_state(vbuf, VPU_BUF_STATE_IDLE);
822 	dev_dbg(inst->dev, "[%d][OUTPUT TS]%32lld\n", inst->id, vbuf->vb2_buf.timestamp);
823 	v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE);
824 	venc->ready_count++;
825 
826 	if (vbuf->flags & V4L2_BUF_FLAG_KEYFRAME)
827 		dev_dbg(inst->dev, "[%d][%d]key frame\n", inst->id, frame->info.frame_id);
828 
829 	return 0;
830 }
831 
832 static int venc_get_encoded_frames(struct vpu_inst *inst)
833 {
834 	struct venc_t *venc;
835 	struct venc_frame_t *frame;
836 	struct venc_frame_t *tmp;
837 
838 	if (!inst->fh.m2m_ctx)
839 		return 0;
840 	venc = inst->priv;
841 	list_for_each_entry_safe(frame, tmp, &venc->frames, list) {
842 		if (venc_get_one_encoded_frame(inst, frame,
843 					       v4l2_m2m_dst_buf_remove(inst->fh.m2m_ctx)))
844 			break;
845 		list_del_init(&frame->list);
846 		vfree(frame);
847 	}
848 
849 	return 0;
850 }
851 
852 static int venc_frame_encoded(struct vpu_inst *inst, void *arg)
853 {
854 	struct vpu_enc_pic_info *info = arg;
855 	struct venc_frame_t *frame;
856 	struct venc_t *venc;
857 	int ret = 0;
858 
859 	if (!info)
860 		return -EINVAL;
861 	venc = inst->priv;
862 	frame = vzalloc(sizeof(*frame));
863 	if (!frame)
864 		return -ENOMEM;
865 
866 	memcpy(&frame->info, info, sizeof(frame->info));
867 	frame->bytesused = info->frame_size;
868 
869 	vpu_inst_lock(inst);
870 	list_add_tail(&frame->list, &venc->frames);
871 	venc->encode_count++;
872 	venc_get_encoded_frames(inst);
873 	vpu_inst_unlock(inst);
874 
875 	return ret;
876 }
877 
878 static void venc_set_last_buffer_dequeued(struct vpu_inst *inst)
879 {
880 	struct venc_t *venc = inst->priv;
881 
882 	if (venc->stopped && list_empty(&venc->frames))
883 		vpu_set_last_buffer_dequeued(inst, true);
884 }
885 
886 static void venc_stop_done(struct vpu_inst *inst)
887 {
888 	struct venc_t *venc = inst->priv;
889 
890 	vpu_inst_lock(inst);
891 	venc->stopped = true;
892 	venc_set_last_buffer_dequeued(inst);
893 	vpu_inst_unlock(inst);
894 
895 	wake_up_all(&venc->wq);
896 }
897 
898 static void venc_event_notify(struct vpu_inst *inst, u32 event, void *data)
899 {
900 }
901 
902 static void venc_release(struct vpu_inst *inst)
903 {
904 }
905 
906 static void venc_cleanup(struct vpu_inst *inst)
907 {
908 	struct venc_t *venc;
909 
910 	if (!inst)
911 		return;
912 
913 	venc = inst->priv;
914 	vfree(venc);
915 	inst->priv = NULL;
916 	vfree(inst);
917 }
918 
919 static int venc_start_session(struct vpu_inst *inst, u32 type)
920 {
921 	struct venc_t *venc = inst->priv;
922 	int stream_buffer_size;
923 	int ret;
924 
925 	venc_set_enable(venc, type, 1);
926 	if ((venc->enable & VENC_ENABLE_MASK) != VENC_ENABLE_MASK)
927 		return 0;
928 
929 	vpu_iface_init_instance(inst);
930 	stream_buffer_size = vpu_iface_get_stream_buffer_size(inst->core);
931 	if (stream_buffer_size > 0) {
932 		inst->stream_buffer.length = max_t(u32, stream_buffer_size, venc->cpb_size * 3);
933 		ret = vpu_alloc_dma(inst->core, &inst->stream_buffer);
934 		if (ret)
935 			goto error;
936 
937 		inst->use_stream_buffer = true;
938 		vpu_iface_config_stream_buffer(inst, &inst->stream_buffer);
939 	}
940 
941 	ret = vpu_iface_set_encode_params(inst, &venc->params, 0);
942 	if (ret)
943 		goto error;
944 	ret = vpu_session_configure_codec(inst);
945 	if (ret)
946 		goto error;
947 
948 	inst->state = VPU_CODEC_STATE_CONFIGURED;
949 	/*vpu_iface_config_memory_resource*/
950 
951 	/*config enc expert mode parameter*/
952 	ret = vpu_iface_set_encode_params(inst, &venc->params, 1);
953 	if (ret)
954 		goto error;
955 
956 	ret = vpu_session_start(inst);
957 	if (ret)
958 		goto error;
959 	inst->state = VPU_CODEC_STATE_STARTED;
960 
961 	venc->bitrate_change = false;
962 	venc->input_ready = true;
963 	venc->frame_count = 0;
964 	venc->encode_count = 0;
965 	venc->ready_count = 0;
966 	venc->stopped = false;
967 	vpu_process_output_buffer(inst);
968 	if (venc->frame_count == 0)
969 		dev_err(inst->dev, "[%d] there is no input when starting\n", inst->id);
970 
971 	return 0;
972 error:
973 	venc_set_enable(venc, type, 0);
974 	inst->state = VPU_CODEC_STATE_DEINIT;
975 
976 	vpu_free_dma(&inst->stream_buffer);
977 	return ret;
978 }
979 
980 static void venc_cleanup_mem_resource(struct vpu_inst *inst)
981 {
982 	struct venc_t *venc;
983 	u32 i;
984 
985 	venc = inst->priv;
986 
987 	for (i = 0; i < ARRAY_SIZE(venc->enc); i++)
988 		vpu_free_dma(&venc->enc[i]);
989 	for (i = 0; i < ARRAY_SIZE(venc->ref); i++)
990 		vpu_free_dma(&venc->ref[i]);
991 }
992 
993 static void venc_request_mem_resource(struct vpu_inst *inst,
994 				      u32 enc_frame_size,
995 				      u32 enc_frame_num,
996 				      u32 ref_frame_size,
997 				      u32 ref_frame_num,
998 				      u32 act_frame_size,
999 				      u32 act_frame_num)
1000 {
1001 	struct venc_t *venc;
1002 	u32 i;
1003 	int ret;
1004 
1005 	venc = inst->priv;
1006 	if (enc_frame_num > ARRAY_SIZE(venc->enc)) {
1007 		dev_err(inst->dev, "[%d] enc num(%d) is out of range\n", inst->id, enc_frame_num);
1008 		return;
1009 	}
1010 	if (ref_frame_num > ARRAY_SIZE(venc->ref)) {
1011 		dev_err(inst->dev, "[%d] ref num(%d) is out of range\n", inst->id, ref_frame_num);
1012 		return;
1013 	}
1014 	if (act_frame_num > ARRAY_SIZE(venc->act)) {
1015 		dev_err(inst->dev, "[%d] act num(%d) is out of range\n", inst->id, act_frame_num);
1016 		return;
1017 	}
1018 
1019 	for (i = 0; i < enc_frame_num; i++) {
1020 		venc->enc[i].length = enc_frame_size;
1021 		ret = vpu_alloc_dma(inst->core, &venc->enc[i]);
1022 		if (ret) {
1023 			venc_cleanup_mem_resource(inst);
1024 			return;
1025 		}
1026 	}
1027 	for (i = 0; i < ref_frame_num; i++) {
1028 		venc->ref[i].length = ref_frame_size;
1029 		ret = vpu_alloc_dma(inst->core, &venc->ref[i]);
1030 		if (ret) {
1031 			venc_cleanup_mem_resource(inst);
1032 			return;
1033 		}
1034 	}
1035 	if (act_frame_num != 1 || act_frame_size > inst->act.length) {
1036 		venc_cleanup_mem_resource(inst);
1037 		return;
1038 	}
1039 	venc->act[0].length = act_frame_size;
1040 	venc->act[0].phys = inst->act.phys;
1041 	venc->act[0].virt = inst->act.virt;
1042 
1043 	for (i = 0; i < enc_frame_num; i++)
1044 		vpu_iface_config_memory_resource(inst, MEM_RES_ENC, i, &venc->enc[i]);
1045 	for (i = 0; i < ref_frame_num; i++)
1046 		vpu_iface_config_memory_resource(inst, MEM_RES_REF, i, &venc->ref[i]);
1047 	for (i = 0; i < act_frame_num; i++)
1048 		vpu_iface_config_memory_resource(inst, MEM_RES_ACT, i, &venc->act[i]);
1049 }
1050 
1051 static void venc_cleanup_frames(struct venc_t *venc)
1052 {
1053 	struct venc_frame_t *frame;
1054 	struct venc_frame_t *tmp;
1055 
1056 	list_for_each_entry_safe(frame, tmp, &venc->frames, list) {
1057 		list_del_init(&frame->list);
1058 		vfree(frame);
1059 	}
1060 }
1061 
1062 static int venc_stop_session(struct vpu_inst *inst, u32 type)
1063 {
1064 	struct venc_t *venc = inst->priv;
1065 
1066 	venc_set_enable(venc, type, 0);
1067 	if (venc->enable & VENC_ENABLE_MASK)
1068 		return 0;
1069 
1070 	if (inst->state == VPU_CODEC_STATE_DEINIT)
1071 		return 0;
1072 
1073 	if (inst->state != VPU_CODEC_STATE_STOP)
1074 		venc_request_eos(inst);
1075 
1076 	call_void_vop(inst, wait_prepare);
1077 	if (!wait_event_timeout(venc->wq, venc->stopped, VPU_TIMEOUT)) {
1078 		set_bit(inst->id, &inst->core->hang_mask);
1079 		vpu_session_debug(inst);
1080 	}
1081 	call_void_vop(inst, wait_finish);
1082 
1083 	inst->state = VPU_CODEC_STATE_DEINIT;
1084 	venc_cleanup_frames(inst->priv);
1085 	vpu_free_dma(&inst->stream_buffer);
1086 	venc_cleanup_mem_resource(inst);
1087 
1088 	return 0;
1089 }
1090 
1091 static int venc_process_output(struct vpu_inst *inst, struct vb2_buffer *vb)
1092 {
1093 	struct venc_t *venc = inst->priv;
1094 	struct vb2_v4l2_buffer *vbuf;
1095 	u32 flags;
1096 
1097 	if (inst->state == VPU_CODEC_STATE_DEINIT)
1098 		return -EINVAL;
1099 
1100 	vbuf = to_vb2_v4l2_buffer(vb);
1101 	if (inst->state == VPU_CODEC_STATE_STARTED)
1102 		inst->state = VPU_CODEC_STATE_ACTIVE;
1103 
1104 	flags = vbuf->flags;
1105 	if (venc->request_key_frame) {
1106 		vbuf->flags |= V4L2_BUF_FLAG_KEYFRAME;
1107 		venc->request_key_frame = 0;
1108 	}
1109 	if (venc->bitrate_change) {
1110 		vpu_session_update_parameters(inst, &venc->params);
1111 		venc->bitrate_change = false;
1112 	}
1113 	dev_dbg(inst->dev, "[%d][INPUT  TS]%32lld\n", inst->id, vb->timestamp);
1114 	vpu_iface_input_frame(inst, vb);
1115 	vbuf->flags = flags;
1116 	venc->input_ready = false;
1117 	venc->frame_count++;
1118 	vpu_set_buffer_state(vbuf, VPU_BUF_STATE_INUSE);
1119 
1120 	return 0;
1121 }
1122 
1123 static int venc_process_capture(struct vpu_inst *inst, struct vb2_buffer *vb)
1124 {
1125 	struct venc_t *venc;
1126 	struct venc_frame_t *frame = NULL;
1127 	struct vb2_v4l2_buffer *vbuf;
1128 	int ret;
1129 
1130 	venc = inst->priv;
1131 	if (list_empty(&venc->frames))
1132 		return -EINVAL;
1133 
1134 	frame = list_first_entry(&venc->frames, struct venc_frame_t, list);
1135 	vbuf = to_vb2_v4l2_buffer(vb);
1136 	v4l2_m2m_dst_buf_remove_by_buf(inst->fh.m2m_ctx, vbuf);
1137 	ret = venc_get_one_encoded_frame(inst, frame, vbuf);
1138 	if (ret)
1139 		return ret;
1140 
1141 	list_del_init(&frame->list);
1142 	vfree(frame);
1143 	return 0;
1144 }
1145 
1146 static void venc_on_queue_empty(struct vpu_inst *inst, u32 type)
1147 {
1148 	struct venc_t *venc = inst->priv;
1149 
1150 	if (V4L2_TYPE_IS_OUTPUT(type))
1151 		return;
1152 
1153 	if (venc->stopped)
1154 		venc_set_last_buffer_dequeued(inst);
1155 }
1156 
1157 static int venc_get_debug_info(struct vpu_inst *inst, char *str, u32 size, u32 i)
1158 {
1159 	struct venc_t *venc = inst->priv;
1160 	int num = -1;
1161 
1162 	switch (i) {
1163 	case 0:
1164 		num = scnprintf(str, size, "profile = %d\n", venc->params.profile);
1165 		break;
1166 	case 1:
1167 		num = scnprintf(str, size, "level = %d\n", venc->params.level);
1168 		break;
1169 	case 2:
1170 		num = scnprintf(str, size, "fps = %d/%d\n",
1171 				venc->params.frame_rate.numerator,
1172 				venc->params.frame_rate.denominator);
1173 		break;
1174 	case 3:
1175 		num = scnprintf(str, size, "%d x %d -> %d x %d\n",
1176 				venc->params.src_width,
1177 				venc->params.src_height,
1178 				venc->params.out_width,
1179 				venc->params.out_height);
1180 		break;
1181 	case 4:
1182 		num = scnprintf(str, size, "(%d, %d)  %d x %d\n",
1183 				venc->params.crop.left,
1184 				venc->params.crop.top,
1185 				venc->params.crop.width,
1186 				venc->params.crop.height);
1187 		break;
1188 	case 5:
1189 		num = scnprintf(str, size,
1190 				"enable = 0x%x, input = %d, encode = %d, ready = %d, stopped = %d\n",
1191 				venc->enable,
1192 				venc->frame_count, venc->encode_count,
1193 				venc->ready_count,
1194 				venc->stopped);
1195 		break;
1196 	case 6:
1197 		num = scnprintf(str, size, "gop = %d\n", venc->params.gop_length);
1198 		break;
1199 	case 7:
1200 		num = scnprintf(str, size, "bframes = %d\n", venc->params.bframes);
1201 		break;
1202 	case 8:
1203 		num = scnprintf(str, size, "rc: %s, mode = %d, bitrate = %d(%d), qp = %d\n",
1204 				venc->params.rc_enable ? "enable" : "disable",
1205 				venc->params.rc_mode,
1206 				venc->params.bitrate,
1207 				venc->params.bitrate_max,
1208 				venc->params.i_frame_qp);
1209 		break;
1210 	case 9:
1211 		num = scnprintf(str, size, "sar: enable = %d, idc = %d, %d x %d\n",
1212 				venc->params.sar.enable,
1213 				venc->params.sar.idc,
1214 				venc->params.sar.width,
1215 				venc->params.sar.height);
1216 
1217 		break;
1218 	case 10:
1219 		num = scnprintf(str, size,
1220 				"colorspace: primaries = %d, transfer = %d, matrix = %d, full_range = %d\n",
1221 				venc->params.color.primaries,
1222 				venc->params.color.transfer,
1223 				venc->params.color.matrix,
1224 				venc->params.color.full_range);
1225 		break;
1226 	case 11:
1227 		num = scnprintf(str, size, "skipped: count = %d, bytes = %d\n",
1228 				venc->skipped_count, venc->skipped_bytes);
1229 		break;
1230 	default:
1231 		break;
1232 	}
1233 
1234 	return num;
1235 }
1236 
1237 static struct vpu_inst_ops venc_inst_ops = {
1238 	.ctrl_init = venc_ctrl_init,
1239 	.check_ready = venc_check_ready,
1240 	.input_done = venc_input_done,
1241 	.get_one_frame = venc_frame_encoded,
1242 	.stop_done = venc_stop_done,
1243 	.event_notify = venc_event_notify,
1244 	.release = venc_release,
1245 	.cleanup = venc_cleanup,
1246 	.start = venc_start_session,
1247 	.mem_request = venc_request_mem_resource,
1248 	.stop = venc_stop_session,
1249 	.process_output = venc_process_output,
1250 	.process_capture = venc_process_capture,
1251 	.on_queue_empty = venc_on_queue_empty,
1252 	.get_debug_info = venc_get_debug_info,
1253 	.wait_prepare = vpu_inst_unlock,
1254 	.wait_finish = vpu_inst_lock,
1255 };
1256 
1257 static void venc_init(struct file *file)
1258 {
1259 	struct vpu_inst *inst = to_inst(file);
1260 	struct venc_t *venc;
1261 	struct v4l2_format f;
1262 	struct v4l2_streamparm parm;
1263 
1264 	venc = inst->priv;
1265 	venc->params.qp_min = 1;
1266 	venc->params.qp_max = 51;
1267 	venc->params.qp_min_i = 1;
1268 	venc->params.qp_max_i = 51;
1269 	venc->params.bitrate_min = BITRATE_MIN;
1270 
1271 	memset(&f, 0, sizeof(f));
1272 	f.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1273 	f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M;
1274 	f.fmt.pix_mp.width = 1280;
1275 	f.fmt.pix_mp.height = 720;
1276 	f.fmt.pix_mp.field = V4L2_FIELD_NONE;
1277 	venc_s_fmt(file, &inst->fh, &f);
1278 
1279 	memset(&f, 0, sizeof(f));
1280 	f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1281 	f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;
1282 	f.fmt.pix_mp.width = 1280;
1283 	f.fmt.pix_mp.height = 720;
1284 	f.fmt.pix_mp.field = V4L2_FIELD_NONE;
1285 	venc_s_fmt(file, &inst->fh, &f);
1286 
1287 	memset(&parm, 0, sizeof(parm));
1288 	parm.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1289 	parm.parm.capture.timeperframe.numerator = 1;
1290 	parm.parm.capture.timeperframe.denominator = 30;
1291 	venc_s_parm(file, &inst->fh, &parm);
1292 }
1293 
1294 static int venc_open(struct file *file)
1295 {
1296 	struct vpu_inst *inst;
1297 	struct venc_t *venc;
1298 	int ret;
1299 
1300 	inst = vzalloc(sizeof(*inst));
1301 	if (!inst)
1302 		return -ENOMEM;
1303 
1304 	venc = vzalloc(sizeof(*venc));
1305 	if (!venc) {
1306 		vfree(inst);
1307 		return -ENOMEM;
1308 	}
1309 
1310 	inst->ops = &venc_inst_ops;
1311 	inst->formats = venc_formats;
1312 	inst->type = VPU_CORE_TYPE_ENC;
1313 	inst->priv = venc;
1314 	INIT_LIST_HEAD(&venc->frames);
1315 	init_waitqueue_head(&venc->wq);
1316 
1317 	ret = vpu_v4l2_open(file, inst);
1318 	if (ret)
1319 		return ret;
1320 
1321 	inst->min_buffer_out = VENC_MIN_BUFFER_OUT;
1322 	inst->min_buffer_cap = VENC_MIN_BUFFER_CAP;
1323 	venc_init(file);
1324 
1325 	return 0;
1326 }
1327 
1328 static const struct v4l2_file_operations venc_fops = {
1329 	.owner = THIS_MODULE,
1330 	.open = venc_open,
1331 	.release = vpu_v4l2_close,
1332 	.unlocked_ioctl = video_ioctl2,
1333 	.poll = v4l2_m2m_fop_poll,
1334 	.mmap = v4l2_m2m_fop_mmap,
1335 };
1336 
1337 const struct v4l2_ioctl_ops *venc_get_ioctl_ops(void)
1338 {
1339 	return &venc_ioctl_ops;
1340 }
1341 
1342 const struct v4l2_file_operations *venc_get_fops(void)
1343 {
1344 	return &venc_fops;
1345 }
1346