1446 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3* Copyright (c) 2016 MediaTek Inc.4* Author: PC Chen <pc.chen@mediatek.com>5* Tiffany Lin <tiffany.lin@mediatek.com>6*/7 8#include <media/v4l2-event.h>9#include <media/v4l2-mem2mem.h>10#include <media/videobuf2-dma-contig.h>11#include <linux/pm_runtime.h>12 13#include "mtk_vcodec_enc.h"14#include "venc_drv_if.h"15 16#define MTK_VENC_MIN_W 160U17#define MTK_VENC_MIN_H 128U18#define MTK_VENC_HD_MAX_W 1920U19#define MTK_VENC_HD_MAX_H 1088U20#define MTK_VENC_4K_MAX_W 3840U21#define MTK_VENC_4K_MAX_H 2176U22 23#define DFT_CFG_WIDTH MTK_VENC_MIN_W24#define DFT_CFG_HEIGHT MTK_VENC_MIN_H25#define MTK_MAX_CTRLS_HINT 2026 27#define MTK_DEFAULT_FRAMERATE_NUM 100128#define MTK_DEFAULT_FRAMERATE_DENOM 3000029#define MTK_VENC_4K_CAPABILITY_ENABLE BIT(0)30 31static void mtk_venc_worker(struct work_struct *work);32 33static const struct v4l2_frmsize_stepwise mtk_venc_hd_framesizes = {34 MTK_VENC_MIN_W, MTK_VENC_HD_MAX_W, 16,35 MTK_VENC_MIN_H, MTK_VENC_HD_MAX_H, 16,36};37 38static const struct v4l2_frmsize_stepwise mtk_venc_4k_framesizes = {39 MTK_VENC_MIN_W, MTK_VENC_4K_MAX_W, 16,40 MTK_VENC_MIN_H, MTK_VENC_4K_MAX_H, 16,41};42 43static int vidioc_venc_s_ctrl(struct v4l2_ctrl *ctrl)44{45 struct mtk_vcodec_enc_ctx *ctx = ctrl_to_enc_ctx(ctrl);46 struct mtk_enc_params *p = &ctx->enc_params;47 int ret = 0;48 49 switch (ctrl->id) {50 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:51 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_BITRATE_MODE val= %d", ctrl->val);52 if (ctrl->val != V4L2_MPEG_VIDEO_BITRATE_MODE_CBR) {53 mtk_v4l2_venc_err(ctx, "Unsupported bitrate mode =%d", ctrl->val);54 ret = -EINVAL;55 }56 break;57 case V4L2_CID_MPEG_VIDEO_BITRATE:58 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_BITRATE val = %d", ctrl->val);59 p->bitrate = ctrl->val;60 ctx->param_change |= MTK_ENCODE_PARAM_BITRATE;61 break;62 case V4L2_CID_MPEG_VIDEO_B_FRAMES:63 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_B_FRAMES val = %d", ctrl->val);64 p->num_b_frame = ctrl->val;65 break;66 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:67 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE val = %d",68 ctrl->val);69 p->rc_frame = ctrl->val;70 break;71 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:72 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_H264_MAX_QP val = %d", ctrl->val);73 p->h264_max_qp = ctrl->val;74 break;75 case V4L2_CID_MPEG_VIDEO_HEADER_MODE:76 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_HEADER_MODE val = %d", ctrl->val);77 p->seq_hdr_mode = ctrl->val;78 break;79 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:80 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE val = %d", ctrl->val);81 p->rc_mb = ctrl->val;82 break;83 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:84 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_H264_PROFILE val = %d", ctrl->val);85 p->h264_profile = ctrl->val;86 break;87 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:88 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_H264_LEVEL val = %d", ctrl->val);89 p->h264_level = ctrl->val;90 break;91 case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:92 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_H264_I_PERIOD val = %d", ctrl->val);93 p->intra_period = ctrl->val;94 ctx->param_change |= MTK_ENCODE_PARAM_INTRA_PERIOD;95 break;96 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:97 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_GOP_SIZE val = %d", ctrl->val);98 p->gop_size = ctrl->val;99 ctx->param_change |= MTK_ENCODE_PARAM_GOP_SIZE;100 break;101 case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:102 /*103 * FIXME - what vp8 profiles are actually supported?104 * The ctrl is added (with only profile 0 supported) for now.105 */106 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_VP8_PROFILE val = %d", ctrl->val);107 break;108 case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:109 mtk_v4l2_venc_dbg(2, ctx, "V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME");110 p->force_intra = 1;111 ctx->param_change |= MTK_ENCODE_PARAM_FORCE_INTRA;112 break;113 default:114 ret = -EINVAL;115 break;116 }117 118 return ret;119}120 121static const struct v4l2_ctrl_ops mtk_vcodec_enc_ctrl_ops = {122 .s_ctrl = vidioc_venc_s_ctrl,123};124 125static int vidioc_enum_fmt(struct v4l2_fmtdesc *f,126 const struct mtk_video_fmt *formats,127 size_t num_formats)128{129 if (f->index >= num_formats)130 return -EINVAL;131 132 f->pixelformat = formats[f->index].fourcc;133 134 return 0;135}136 137static const struct mtk_video_fmt *138mtk_venc_find_format(u32 fourcc, const struct mtk_vcodec_enc_pdata *pdata)139{140 const struct mtk_video_fmt *fmt;141 unsigned int k;142 143 for (k = 0; k < pdata->num_capture_formats; k++) {144 fmt = &pdata->capture_formats[k];145 if (fmt->fourcc == fourcc)146 return fmt;147 }148 149 for (k = 0; k < pdata->num_output_formats; k++) {150 fmt = &pdata->output_formats[k];151 if (fmt->fourcc == fourcc)152 return fmt;153 }154 155 return NULL;156}157 158static int vidioc_enum_framesizes(struct file *file, void *fh,159 struct v4l2_frmsizeenum *fsize)160{161 const struct mtk_video_fmt *fmt;162 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(fh);163 164 if (fsize->index != 0)165 return -EINVAL;166 167 fmt = mtk_venc_find_format(fsize->pixel_format,168 ctx->dev->venc_pdata);169 if (!fmt)170 return -EINVAL;171 172 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;173 174 if (ctx->dev->enc_capability & MTK_VENC_4K_CAPABILITY_ENABLE)175 fsize->stepwise = mtk_venc_4k_framesizes;176 else177 fsize->stepwise = mtk_venc_hd_framesizes;178 179 return 0;180}181 182static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,183 struct v4l2_fmtdesc *f)184{185 const struct mtk_vcodec_enc_pdata *pdata =186 fh_to_enc_ctx(priv)->dev->venc_pdata;187 188 return vidioc_enum_fmt(f, pdata->capture_formats,189 pdata->num_capture_formats);190}191 192static int vidioc_enum_fmt_vid_out(struct file *file, void *priv,193 struct v4l2_fmtdesc *f)194{195 const struct mtk_vcodec_enc_pdata *pdata =196 fh_to_enc_ctx(priv)->dev->venc_pdata;197 198 return vidioc_enum_fmt(f, pdata->output_formats,199 pdata->num_output_formats);200}201 202static int mtk_vcodec_enc_get_chip_name(void *priv)203{204 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);205 struct device *dev = &ctx->dev->plat_dev->dev;206 207 if (of_device_is_compatible(dev->of_node, "mediatek,mt8173-vcodec-enc"))208 return 8173;209 else if (of_device_is_compatible(dev->of_node, "mediatek,mt8183-vcodec-enc"))210 return 8183;211 else if (of_device_is_compatible(dev->of_node, "mediatek,mt8192-vcodec-enc"))212 return 8192;213 else if (of_device_is_compatible(dev->of_node, "mediatek,mt8195-vcodec-enc"))214 return 8195;215 else if (of_device_is_compatible(dev->of_node, "mediatek,mt8188-vcodec-enc"))216 return 8188;217 else218 return 8173;219}220 221static int vidioc_venc_querycap(struct file *file, void *priv,222 struct v4l2_capability *cap)223{224 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);225 struct device *dev = &ctx->dev->plat_dev->dev;226 int platform_name = mtk_vcodec_enc_get_chip_name(priv);227 228 strscpy(cap->driver, dev->driver->name, sizeof(cap->driver));229 snprintf(cap->card, sizeof(cap->card), "MT%d video encoder", platform_name);230 231 return 0;232}233 234static int vidioc_venc_s_parm(struct file *file, void *priv,235 struct v4l2_streamparm *a)236{237 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);238 struct v4l2_fract *timeperframe = &a->parm.output.timeperframe;239 240 if (a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)241 return -EINVAL;242 243 if (timeperframe->numerator == 0 || timeperframe->denominator == 0) {244 timeperframe->numerator = MTK_DEFAULT_FRAMERATE_NUM;245 timeperframe->denominator = MTK_DEFAULT_FRAMERATE_DENOM;246 }247 248 ctx->enc_params.framerate_num = timeperframe->denominator;249 ctx->enc_params.framerate_denom = timeperframe->numerator;250 ctx->param_change |= MTK_ENCODE_PARAM_FRAMERATE;251 252 a->parm.output.capability = V4L2_CAP_TIMEPERFRAME;253 254 return 0;255}256 257static int vidioc_venc_g_parm(struct file *file, void *priv,258 struct v4l2_streamparm *a)259{260 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);261 262 if (a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)263 return -EINVAL;264 265 a->parm.output.capability = V4L2_CAP_TIMEPERFRAME;266 a->parm.output.timeperframe.denominator =267 ctx->enc_params.framerate_num;268 a->parm.output.timeperframe.numerator =269 ctx->enc_params.framerate_denom;270 271 return 0;272}273 274static struct mtk_q_data *mtk_venc_get_q_data(struct mtk_vcodec_enc_ctx *ctx,275 enum v4l2_buf_type type)276{277 if (V4L2_TYPE_IS_OUTPUT(type))278 return &ctx->q_data[MTK_Q_DATA_SRC];279 280 return &ctx->q_data[MTK_Q_DATA_DST];281}282 283static void vidioc_try_fmt_cap(struct v4l2_format *f)284{285 f->fmt.pix_mp.field = V4L2_FIELD_NONE;286 f->fmt.pix_mp.num_planes = 1;287 f->fmt.pix_mp.plane_fmt[0].bytesperline = 0;288 f->fmt.pix_mp.flags = 0;289}290 291/* V4L2 specification suggests the driver corrects the format struct if any of292 * the dimensions is unsupported293 */294static int vidioc_try_fmt_out(struct mtk_vcodec_enc_ctx *ctx, struct v4l2_format *f,295 const struct mtk_video_fmt *fmt)296{297 struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;298 int tmp_w, tmp_h;299 unsigned int max_width, max_height;300 301 pix_fmt_mp->field = V4L2_FIELD_NONE;302 303 if (ctx->dev->enc_capability & MTK_VENC_4K_CAPABILITY_ENABLE) {304 max_width = MTK_VENC_4K_MAX_W;305 max_height = MTK_VENC_4K_MAX_H;306 } else {307 max_width = MTK_VENC_HD_MAX_W;308 max_height = MTK_VENC_HD_MAX_H;309 }310 311 pix_fmt_mp->height = clamp(pix_fmt_mp->height, MTK_VENC_MIN_H, max_height);312 pix_fmt_mp->width = clamp(pix_fmt_mp->width, MTK_VENC_MIN_W, max_width);313 314 /* find next closer width align 16, height align 32, size align315 * 64 rectangle316 */317 tmp_w = pix_fmt_mp->width;318 tmp_h = pix_fmt_mp->height;319 v4l_bound_align_image(&pix_fmt_mp->width,320 MTK_VENC_MIN_W,321 max_width, 4,322 &pix_fmt_mp->height,323 MTK_VENC_MIN_H,324 max_height, 5, 6);325 326 if (pix_fmt_mp->width < tmp_w && (pix_fmt_mp->width + 16) <= max_width)327 pix_fmt_mp->width += 16;328 if (pix_fmt_mp->height < tmp_h && (pix_fmt_mp->height + 32) <= max_height)329 pix_fmt_mp->height += 32;330 331 mtk_v4l2_venc_dbg(0, ctx,332 "before resize wxh=%dx%d, after resize wxh=%dx%d, sizeimage=%d %d",333 tmp_w, tmp_h, pix_fmt_mp->width,334 pix_fmt_mp->height,335 pix_fmt_mp->plane_fmt[0].sizeimage,336 pix_fmt_mp->plane_fmt[1].sizeimage);337 338 pix_fmt_mp->num_planes = fmt->num_planes;339 pix_fmt_mp->plane_fmt[0].sizeimage =340 pix_fmt_mp->width * pix_fmt_mp->height +341 ((ALIGN(pix_fmt_mp->width, 16) * 2) * 16);342 pix_fmt_mp->plane_fmt[0].bytesperline = pix_fmt_mp->width;343 344 if (pix_fmt_mp->num_planes == 2) {345 pix_fmt_mp->plane_fmt[1].sizeimage =346 (pix_fmt_mp->width * pix_fmt_mp->height) / 2 +347 (ALIGN(pix_fmt_mp->width, 16) * 16);348 pix_fmt_mp->plane_fmt[2].sizeimage = 0;349 pix_fmt_mp->plane_fmt[1].bytesperline =350 pix_fmt_mp->width;351 pix_fmt_mp->plane_fmt[2].bytesperline = 0;352 } else if (pix_fmt_mp->num_planes == 3) {353 pix_fmt_mp->plane_fmt[1].sizeimage =354 pix_fmt_mp->plane_fmt[2].sizeimage =355 (pix_fmt_mp->width * pix_fmt_mp->height) / 4 +356 ((ALIGN(pix_fmt_mp->width, 16) / 2) * 16);357 pix_fmt_mp->plane_fmt[1].bytesperline =358 pix_fmt_mp->plane_fmt[2].bytesperline =359 pix_fmt_mp->width / 2;360 }361 362 pix_fmt_mp->flags = 0;363 364 return 0;365}366 367static void mtk_venc_set_param(struct mtk_vcodec_enc_ctx *ctx,368 struct venc_enc_param *param)369{370 struct mtk_q_data *q_data_src = &ctx->q_data[MTK_Q_DATA_SRC];371 struct mtk_enc_params *enc_params = &ctx->enc_params;372 373 switch (q_data_src->fmt->fourcc) {374 case V4L2_PIX_FMT_YUV420M:375 param->input_yuv_fmt = VENC_YUV_FORMAT_I420;376 break;377 case V4L2_PIX_FMT_YVU420M:378 param->input_yuv_fmt = VENC_YUV_FORMAT_YV12;379 break;380 case V4L2_PIX_FMT_NV12M:381 param->input_yuv_fmt = VENC_YUV_FORMAT_NV12;382 break;383 case V4L2_PIX_FMT_NV21M:384 param->input_yuv_fmt = VENC_YUV_FORMAT_NV21;385 break;386 default:387 mtk_v4l2_venc_err(ctx, "Unsupported fourcc =%d", q_data_src->fmt->fourcc);388 break;389 }390 param->h264_profile = enc_params->h264_profile;391 param->h264_level = enc_params->h264_level;392 393 /* Config visible resolution */394 param->width = q_data_src->visible_width;395 param->height = q_data_src->visible_height;396 /* Config coded resolution */397 param->buf_width = q_data_src->coded_width;398 param->buf_height = q_data_src->coded_height;399 param->frm_rate = enc_params->framerate_num /400 enc_params->framerate_denom;401 param->intra_period = enc_params->intra_period;402 param->gop_size = enc_params->gop_size;403 param->bitrate = enc_params->bitrate;404 405 mtk_v4l2_venc_dbg(0, ctx,406 "fmt 0x%x, P/L %d/%d w/h %d/%d buf %d/%d fps/bps %d/%d gop %d i_per %d",407 param->input_yuv_fmt, param->h264_profile,408 param->h264_level, param->width, param->height,409 param->buf_width, param->buf_height,410 param->frm_rate, param->bitrate,411 param->gop_size, param->intra_period);412}413 414static int vidioc_venc_s_fmt_cap(struct file *file, void *priv,415 struct v4l2_format *f)416{417 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);418 const struct mtk_vcodec_enc_pdata *pdata = ctx->dev->venc_pdata;419 struct vb2_queue *vq;420 struct mtk_q_data *q_data = mtk_venc_get_q_data(ctx, f->type);421 int i, ret;422 const struct mtk_video_fmt *fmt;423 424 vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);425 if (!vq) {426 mtk_v4l2_venc_err(ctx, "fail to get vq");427 return -EINVAL;428 }429 430 if (vb2_is_busy(vq)) {431 mtk_v4l2_venc_err(ctx, "queue busy");432 return -EBUSY;433 }434 435 fmt = mtk_venc_find_format(f->fmt.pix.pixelformat, pdata);436 if (!fmt) {437 fmt = &ctx->dev->venc_pdata->capture_formats[0];438 f->fmt.pix.pixelformat = fmt->fourcc;439 }440 441 q_data->fmt = fmt;442 vidioc_try_fmt_cap(f);443 444 q_data->coded_width = f->fmt.pix_mp.width;445 q_data->coded_height = f->fmt.pix_mp.height;446 q_data->field = f->fmt.pix_mp.field;447 448 for (i = 0; i < f->fmt.pix_mp.num_planes; i++) {449 struct v4l2_plane_pix_format *plane_fmt;450 451 plane_fmt = &f->fmt.pix_mp.plane_fmt[i];452 q_data->bytesperline[i] = plane_fmt->bytesperline;453 q_data->sizeimage[i] = plane_fmt->sizeimage;454 }455 456 if (ctx->state == MTK_STATE_FREE) {457 ret = venc_if_init(ctx, q_data->fmt->fourcc);458 if (ret) {459 mtk_v4l2_venc_err(ctx, "venc_if_init failed=%d, codec type=%x",460 ret, q_data->fmt->fourcc);461 return -EBUSY;462 }463 ctx->state = MTK_STATE_INIT;464 }465 466 return 0;467}468 469static int vidioc_venc_s_fmt_out(struct file *file, void *priv,470 struct v4l2_format *f)471{472 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);473 const struct mtk_vcodec_enc_pdata *pdata = ctx->dev->venc_pdata;474 struct vb2_queue *vq;475 struct mtk_q_data *q_data = mtk_venc_get_q_data(ctx, f->type);476 int ret, i;477 const struct mtk_video_fmt *fmt;478 479 vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);480 if (!vq) {481 mtk_v4l2_venc_err(ctx, "fail to get vq");482 return -EINVAL;483 }484 485 if (vb2_is_busy(vq)) {486 mtk_v4l2_venc_err(ctx, "queue busy");487 return -EBUSY;488 }489 490 fmt = mtk_venc_find_format(f->fmt.pix.pixelformat, pdata);491 if (!fmt) {492 fmt = &ctx->dev->venc_pdata->output_formats[0];493 f->fmt.pix.pixelformat = fmt->fourcc;494 }495 496 ret = vidioc_try_fmt_out(ctx, f, fmt);497 if (ret)498 return ret;499 500 q_data->fmt = fmt;501 q_data->visible_width = f->fmt.pix_mp.width;502 q_data->visible_height = f->fmt.pix_mp.height;503 q_data->coded_width = f->fmt.pix_mp.width;504 q_data->coded_height = f->fmt.pix_mp.height;505 506 q_data->field = f->fmt.pix_mp.field;507 ctx->colorspace = f->fmt.pix_mp.colorspace;508 ctx->ycbcr_enc = f->fmt.pix_mp.ycbcr_enc;509 ctx->quantization = f->fmt.pix_mp.quantization;510 ctx->xfer_func = f->fmt.pix_mp.xfer_func;511 512 for (i = 0; i < f->fmt.pix_mp.num_planes; i++) {513 struct v4l2_plane_pix_format *plane_fmt;514 515 plane_fmt = &f->fmt.pix_mp.plane_fmt[i];516 q_data->bytesperline[i] = plane_fmt->bytesperline;517 q_data->sizeimage[i] = plane_fmt->sizeimage;518 }519 520 return 0;521}522 523static int vidioc_venc_g_fmt(struct file *file, void *priv,524 struct v4l2_format *f)525{526 struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp;527 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);528 struct vb2_queue *vq;529 struct mtk_q_data *q_data = mtk_venc_get_q_data(ctx, f->type);530 int i;531 532 vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);533 if (!vq)534 return -EINVAL;535 536 537 pix->width = q_data->coded_width;538 pix->height = q_data->coded_height;539 pix->pixelformat = q_data->fmt->fourcc;540 pix->field = q_data->field;541 pix->num_planes = q_data->fmt->num_planes;542 for (i = 0; i < pix->num_planes; i++) {543 pix->plane_fmt[i].bytesperline = q_data->bytesperline[i];544 pix->plane_fmt[i].sizeimage = q_data->sizeimage[i];545 }546 547 pix->flags = 0;548 pix->colorspace = ctx->colorspace;549 pix->ycbcr_enc = ctx->ycbcr_enc;550 pix->quantization = ctx->quantization;551 pix->xfer_func = ctx->xfer_func;552 553 return 0;554}555 556static int vidioc_try_fmt_vid_cap_mplane(struct file *file, void *priv,557 struct v4l2_format *f)558{559 const struct mtk_video_fmt *fmt;560 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);561 const struct mtk_vcodec_enc_pdata *pdata = ctx->dev->venc_pdata;562 563 fmt = mtk_venc_find_format(f->fmt.pix.pixelformat, pdata);564 if (!fmt) {565 fmt = &ctx->dev->venc_pdata->capture_formats[0];566 f->fmt.pix.pixelformat = fmt->fourcc;567 }568 f->fmt.pix_mp.colorspace = ctx->colorspace;569 f->fmt.pix_mp.ycbcr_enc = ctx->ycbcr_enc;570 f->fmt.pix_mp.quantization = ctx->quantization;571 f->fmt.pix_mp.xfer_func = ctx->xfer_func;572 573 vidioc_try_fmt_cap(f);574 575 return 0;576}577 578static int vidioc_try_fmt_vid_out_mplane(struct file *file, void *priv,579 struct v4l2_format *f)580{581 const struct mtk_video_fmt *fmt;582 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);583 const struct mtk_vcodec_enc_pdata *pdata = ctx->dev->venc_pdata;584 585 fmt = mtk_venc_find_format(f->fmt.pix.pixelformat, pdata);586 if (!fmt) {587 fmt = &ctx->dev->venc_pdata->output_formats[0];588 f->fmt.pix.pixelformat = fmt->fourcc;589 }590 if (!f->fmt.pix_mp.colorspace) {591 f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_REC709;592 f->fmt.pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;593 f->fmt.pix_mp.quantization = V4L2_QUANTIZATION_DEFAULT;594 f->fmt.pix_mp.xfer_func = V4L2_XFER_FUNC_DEFAULT;595 }596 597 return vidioc_try_fmt_out(ctx, f, fmt);598}599 600static int vidioc_venc_g_selection(struct file *file, void *priv,601 struct v4l2_selection *s)602{603 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);604 struct mtk_q_data *q_data = mtk_venc_get_q_data(ctx, s->type);605 606 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)607 return -EINVAL;608 609 switch (s->target) {610 case V4L2_SEL_TGT_CROP_DEFAULT:611 case V4L2_SEL_TGT_CROP_BOUNDS:612 s->r.top = 0;613 s->r.left = 0;614 s->r.width = q_data->coded_width;615 s->r.height = q_data->coded_height;616 break;617 case V4L2_SEL_TGT_CROP:618 s->r.top = 0;619 s->r.left = 0;620 s->r.width = q_data->visible_width;621 s->r.height = q_data->visible_height;622 break;623 default:624 return -EINVAL;625 }626 627 return 0;628}629 630static int vidioc_venc_s_selection(struct file *file, void *priv,631 struct v4l2_selection *s)632{633 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);634 struct mtk_q_data *q_data = mtk_venc_get_q_data(ctx, s->type);635 636 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)637 return -EINVAL;638 639 switch (s->target) {640 case V4L2_SEL_TGT_CROP:641 /* Only support crop from (0,0) */642 s->r.top = 0;643 s->r.left = 0;644 s->r.width = min(s->r.width, q_data->coded_width);645 s->r.height = min(s->r.height, q_data->coded_height);646 q_data->visible_width = s->r.width;647 q_data->visible_height = s->r.height;648 break;649 default:650 return -EINVAL;651 }652 return 0;653}654 655static int vidioc_venc_qbuf(struct file *file, void *priv,656 struct v4l2_buffer *buf)657{658 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);659 660 if (ctx->state == MTK_STATE_ABORT) {661 mtk_v4l2_venc_err(ctx, "[%d] Call on QBUF after unrecoverable error",662 ctx->id);663 return -EIO;664 }665 666 return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf);667}668 669static int vidioc_venc_dqbuf(struct file *file, void *priv,670 struct v4l2_buffer *buf)671{672 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);673 int ret;674 675 if (ctx->state == MTK_STATE_ABORT) {676 mtk_v4l2_venc_err(ctx, "[%d] Call on QBUF after unrecoverable error",677 ctx->id);678 return -EIO;679 }680 681 ret = v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);682 if (ret)683 return ret;684 685 /*686 * Complete flush if the user dequeued the 0-payload LAST buffer.687 * We check the payload because a buffer with the LAST flag can also688 * be seen during resolution changes. If we happen to be flushing at689 * that time, the last buffer before the resolution changes could be690 * misinterpreted for the buffer generated by the flush and terminate691 * it earlier than we want.692 */693 if (!V4L2_TYPE_IS_OUTPUT(buf->type) &&694 buf->flags & V4L2_BUF_FLAG_LAST &&695 buf->m.planes[0].bytesused == 0 &&696 ctx->is_flushing) {697 /*698 * Last CAPTURE buffer is dequeued, we can allow another flush699 * to take place.700 */701 ctx->is_flushing = false;702 }703 704 return 0;705}706 707static int vidioc_encoder_cmd(struct file *file, void *priv,708 struct v4l2_encoder_cmd *cmd)709{710 struct mtk_vcodec_enc_ctx *ctx = fh_to_enc_ctx(priv);711 struct vb2_queue *src_vq, *dst_vq;712 int ret;713 714 if (ctx->state == MTK_STATE_ABORT) {715 mtk_v4l2_venc_err(ctx, "[%d] Call to CMD after unrecoverable error",716 ctx->id);717 return -EIO;718 }719 720 ret = v4l2_m2m_ioctl_try_encoder_cmd(file, priv, cmd);721 if (ret)722 return ret;723 724 /* Calling START or STOP is invalid if a flush is in progress */725 if (ctx->is_flushing)726 return -EBUSY;727 728 mtk_v4l2_venc_dbg(1, ctx, "encoder cmd=%u", cmd->cmd);729 730 dst_vq = v4l2_m2m_get_vq(ctx->m2m_ctx,731 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);732 switch (cmd->cmd) {733 case V4L2_ENC_CMD_STOP:734 src_vq = v4l2_m2m_get_vq(ctx->m2m_ctx,735 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);736 if (!vb2_is_streaming(src_vq)) {737 mtk_v4l2_venc_dbg(1, ctx, "Output stream is off. No need to flush.");738 return 0;739 }740 if (!vb2_is_streaming(dst_vq)) {741 mtk_v4l2_venc_dbg(1, ctx, "Capture stream is off. No need to flush.");742 return 0;743 }744 ctx->is_flushing = true;745 v4l2_m2m_buf_queue(ctx->m2m_ctx, &ctx->empty_flush_buf.vb);746 v4l2_m2m_try_schedule(ctx->m2m_ctx);747 break;748 749 case V4L2_ENC_CMD_START:750 vb2_clear_last_buffer_dequeued(dst_vq);751 break;752 753 default:754 return -EINVAL;755 }756 757 return 0;758}759 760const struct v4l2_ioctl_ops mtk_venc_ioctl_ops = {761 .vidioc_streamon = v4l2_m2m_ioctl_streamon,762 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,763 764 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,765 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,766 .vidioc_qbuf = vidioc_venc_qbuf,767 .vidioc_dqbuf = vidioc_venc_dqbuf,768 769 .vidioc_querycap = vidioc_venc_querycap,770 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,771 .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid_out,772 .vidioc_enum_framesizes = vidioc_enum_framesizes,773 774 .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt_vid_cap_mplane,775 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_vid_out_mplane,776 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,777 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,778 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,779 780 .vidioc_s_parm = vidioc_venc_s_parm,781 .vidioc_g_parm = vidioc_venc_g_parm,782 .vidioc_s_fmt_vid_cap_mplane = vidioc_venc_s_fmt_cap,783 .vidioc_s_fmt_vid_out_mplane = vidioc_venc_s_fmt_out,784 785 .vidioc_g_fmt_vid_cap_mplane = vidioc_venc_g_fmt,786 .vidioc_g_fmt_vid_out_mplane = vidioc_venc_g_fmt,787 788 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,789 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,790 791 .vidioc_g_selection = vidioc_venc_g_selection,792 .vidioc_s_selection = vidioc_venc_s_selection,793 794 .vidioc_encoder_cmd = vidioc_encoder_cmd,795 .vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd,796};797 798static int vb2ops_venc_queue_setup(struct vb2_queue *vq,799 unsigned int *nbuffers,800 unsigned int *nplanes,801 unsigned int sizes[],802 struct device *alloc_devs[])803{804 struct mtk_vcodec_enc_ctx *ctx = vb2_get_drv_priv(vq);805 struct mtk_q_data *q_data = mtk_venc_get_q_data(ctx, vq->type);806 unsigned int i;807 808 if (q_data == NULL)809 return -EINVAL;810 811 if (*nplanes) {812 if (*nplanes != q_data->fmt->num_planes)813 return -EINVAL;814 for (i = 0; i < *nplanes; i++)815 if (sizes[i] < q_data->sizeimage[i])816 return -EINVAL;817 } else {818 *nplanes = q_data->fmt->num_planes;819 for (i = 0; i < *nplanes; i++)820 sizes[i] = q_data->sizeimage[i];821 }822 823 return 0;824}825 826static int vb2ops_venc_buf_prepare(struct vb2_buffer *vb)827{828 struct mtk_vcodec_enc_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);829 struct mtk_q_data *q_data = mtk_venc_get_q_data(ctx, vb->vb2_queue->type);830 int i;831 832 for (i = 0; i < q_data->fmt->num_planes; i++) {833 if (vb2_plane_size(vb, i) < q_data->sizeimage[i]) {834 mtk_v4l2_venc_err(ctx, "data will not fit into plane %d (%lu < %d)",835 i, vb2_plane_size(vb, i), q_data->sizeimage[i]);836 return -EINVAL;837 }838 }839 840 return 0;841}842 843static void vb2ops_venc_buf_queue(struct vb2_buffer *vb)844{845 struct mtk_vcodec_enc_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);846 struct vb2_v4l2_buffer *vb2_v4l2 =847 container_of(vb, struct vb2_v4l2_buffer, vb2_buf);848 849 struct mtk_video_enc_buf *mtk_buf =850 container_of(vb2_v4l2, struct mtk_video_enc_buf,851 m2m_buf.vb);852 853 if ((vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) &&854 (ctx->param_change != MTK_ENCODE_PARAM_NONE)) {855 mtk_v4l2_venc_dbg(1, ctx, "[%d] Before id=%d encode parameter change %x",856 ctx->id, vb2_v4l2->vb2_buf.index, ctx->param_change);857 mtk_buf->param_change = ctx->param_change;858 mtk_buf->enc_params = ctx->enc_params;859 ctx->param_change = MTK_ENCODE_PARAM_NONE;860 }861 862 v4l2_m2m_buf_queue(ctx->m2m_ctx, to_vb2_v4l2_buffer(vb));863}864 865static int vb2ops_venc_start_streaming(struct vb2_queue *q, unsigned int count)866{867 struct mtk_vcodec_enc_ctx *ctx = vb2_get_drv_priv(q);868 struct venc_enc_param param;869 int ret;870 int i;871 872 /* Once state turn into MTK_STATE_ABORT, we need stop_streaming873 * to clear it874 */875 if ((ctx->state == MTK_STATE_ABORT) || (ctx->state == MTK_STATE_FREE)) {876 ret = -EIO;877 goto err_start_stream;878 }879 880 /* Do the initialization when both start_streaming have been called */881 if (V4L2_TYPE_IS_OUTPUT(q->type)) {882 if (!vb2_start_streaming_called(&ctx->m2m_ctx->cap_q_ctx.q))883 return 0;884 } else {885 if (!vb2_start_streaming_called(&ctx->m2m_ctx->out_q_ctx.q))886 return 0;887 }888 889 mtk_venc_set_param(ctx, ¶m);890 ret = venc_if_set_param(ctx, VENC_SET_PARAM_ENC, ¶m);891 if (ret) {892 mtk_v4l2_venc_err(ctx, "venc_if_set_param failed=%d", ret);893 ctx->state = MTK_STATE_ABORT;894 goto err_start_stream;895 }896 ctx->param_change = MTK_ENCODE_PARAM_NONE;897 898 if ((ctx->q_data[MTK_Q_DATA_DST].fmt->fourcc == V4L2_PIX_FMT_H264) &&899 (ctx->enc_params.seq_hdr_mode !=900 V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE)) {901 ret = venc_if_set_param(ctx,902 VENC_SET_PARAM_PREPEND_HEADER,903 NULL);904 if (ret) {905 mtk_v4l2_venc_err(ctx, "venc_if_set_param failed=%d", ret);906 ctx->state = MTK_STATE_ABORT;907 goto err_start_stream;908 }909 ctx->state = MTK_STATE_HEADER;910 }911 912 return 0;913 914err_start_stream:915 for (i = 0; i < vb2_get_num_buffers(q); ++i) {916 struct vb2_buffer *buf = vb2_get_buffer(q, i);917 918 /*919 * FIXME: This check is not needed as only active buffers920 * can be marked as done.921 */922 if (buf && buf->state == VB2_BUF_STATE_ACTIVE) {923 mtk_v4l2_venc_dbg(0, ctx, "[%d] id=%d, type=%d, %d->VB2_BUF_STATE_QUEUED",924 ctx->id, i, q->type, (int)buf->state);925 v4l2_m2m_buf_done(to_vb2_v4l2_buffer(buf),926 VB2_BUF_STATE_QUEUED);927 }928 }929 930 return ret;931}932 933static void vb2ops_venc_stop_streaming(struct vb2_queue *q)934{935 struct mtk_vcodec_enc_ctx *ctx = vb2_get_drv_priv(q);936 struct vb2_v4l2_buffer *src_buf, *dst_buf;937 int ret;938 939 mtk_v4l2_venc_dbg(2, ctx, "[%d]-> type=%d", ctx->id, q->type);940 941 if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {942 while ((dst_buf = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx))) {943 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, 0);944 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR);945 }946 /* STREAMOFF on the CAPTURE queue completes any ongoing flush */947 if (ctx->is_flushing) {948 struct v4l2_m2m_buffer *b, *n;949 950 mtk_v4l2_venc_dbg(1, ctx, "STREAMOFF called while flushing");951 /*952 * STREAMOFF could be called before the flush buffer is953 * dequeued. Check whether empty flush buf is still in954 * queue before removing it.955 */956 v4l2_m2m_for_each_src_buf_safe(ctx->m2m_ctx, b, n) {957 if (b == &ctx->empty_flush_buf) {958 v4l2_m2m_src_buf_remove_by_buf(ctx->m2m_ctx, &b->vb);959 break;960 }961 }962 ctx->is_flushing = false;963 }964 } else {965 while ((src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx))) {966 if (src_buf != &ctx->empty_flush_buf.vb)967 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR);968 }969 if (ctx->is_flushing) {970 /*971 * If we are in the middle of a flush, put the flush972 * buffer back into the queue so the next CAPTURE973 * buffer gets returned with the LAST flag set.974 */975 v4l2_m2m_buf_queue(ctx->m2m_ctx,976 &ctx->empty_flush_buf.vb);977 }978 }979 980 if ((q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&981 vb2_is_streaming(&ctx->m2m_ctx->out_q_ctx.q)) ||982 (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE &&983 vb2_is_streaming(&ctx->m2m_ctx->cap_q_ctx.q))) {984 mtk_v4l2_venc_dbg(1, ctx, "[%d]-> q type %d out=%d cap=%d",985 ctx->id, q->type,986 vb2_is_streaming(&ctx->m2m_ctx->out_q_ctx.q),987 vb2_is_streaming(&ctx->m2m_ctx->cap_q_ctx.q));988 return;989 }990 991 /* Release the encoder if both streams are stopped. */992 ret = venc_if_deinit(ctx);993 if (ret)994 mtk_v4l2_venc_err(ctx, "venc_if_deinit failed=%d", ret);995 996 ctx->state = MTK_STATE_FREE;997}998 999static int vb2ops_venc_buf_out_validate(struct vb2_buffer *vb)1000{1001 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);1002 1003 vbuf->field = V4L2_FIELD_NONE;1004 return 0;1005}1006 1007static const struct vb2_ops mtk_venc_vb2_ops = {1008 .queue_setup = vb2ops_venc_queue_setup,1009 .buf_out_validate = vb2ops_venc_buf_out_validate,1010 .buf_prepare = vb2ops_venc_buf_prepare,1011 .buf_queue = vb2ops_venc_buf_queue,1012 .wait_prepare = vb2_ops_wait_prepare,1013 .wait_finish = vb2_ops_wait_finish,1014 .start_streaming = vb2ops_venc_start_streaming,1015 .stop_streaming = vb2ops_venc_stop_streaming,1016};1017 1018static int mtk_venc_encode_header(void *priv)1019{1020 struct mtk_vcodec_enc_ctx *ctx = priv;1021 int ret;1022 struct vb2_v4l2_buffer *src_buf, *dst_buf;1023 struct mtk_vcodec_mem bs_buf;1024 struct venc_done_result enc_result;1025 1026 dst_buf = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);1027 if (!dst_buf) {1028 mtk_v4l2_venc_dbg(1, ctx, "No dst buffer");1029 return -EINVAL;1030 }1031 1032 bs_buf.va = vb2_plane_vaddr(&dst_buf->vb2_buf, 0);1033 bs_buf.dma_addr = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0);1034 bs_buf.size = (size_t)dst_buf->vb2_buf.planes[0].length;1035 1036 mtk_v4l2_venc_dbg(1, ctx,1037 "[%d] buf id=%d va=0x%p dma_addr=0x%llx size=%zu",1038 ctx->id, dst_buf->vb2_buf.index, bs_buf.va,1039 (u64)bs_buf.dma_addr, bs_buf.size);1040 1041 ret = venc_if_encode(ctx,1042 VENC_START_OPT_ENCODE_SEQUENCE_HEADER,1043 NULL, &bs_buf, &enc_result);1044 1045 if (ret) {1046 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, 0);1047 ctx->state = MTK_STATE_ABORT;1048 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR);1049 mtk_v4l2_venc_err(ctx, "venc_if_encode failed=%d", ret);1050 return -EINVAL;1051 }1052 src_buf = v4l2_m2m_next_src_buf(ctx->m2m_ctx);1053 if (src_buf) {1054 dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;1055 dst_buf->timecode = src_buf->timecode;1056 } else {1057 mtk_v4l2_venc_err(ctx, "No timestamp for the header buffer.");1058 }1059 1060 ctx->state = MTK_STATE_HEADER;1061 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, enc_result.bs_size);1062 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_DONE);1063 1064 return 0;1065}1066 1067static int mtk_venc_param_change(struct mtk_vcodec_enc_ctx *ctx)1068{1069 struct venc_enc_param enc_prm;1070 struct vb2_v4l2_buffer *vb2_v4l2 = v4l2_m2m_next_src_buf(ctx->m2m_ctx);1071 struct mtk_video_enc_buf *mtk_buf;1072 int ret = 0;1073 1074 /* Don't upcast the empty flush buffer */1075 if (vb2_v4l2 == &ctx->empty_flush_buf.vb)1076 return 0;1077 1078 mtk_buf = container_of(vb2_v4l2, struct mtk_video_enc_buf, m2m_buf.vb);1079 1080 memset(&enc_prm, 0, sizeof(enc_prm));1081 if (mtk_buf->param_change == MTK_ENCODE_PARAM_NONE)1082 return 0;1083 1084 if (mtk_buf->param_change & MTK_ENCODE_PARAM_BITRATE) {1085 enc_prm.bitrate = mtk_buf->enc_params.bitrate;1086 mtk_v4l2_venc_dbg(1, ctx, "[%d] id=%d, change param br=%d",1087 ctx->id, vb2_v4l2->vb2_buf.index, enc_prm.bitrate);1088 ret |= venc_if_set_param(ctx,1089 VENC_SET_PARAM_ADJUST_BITRATE,1090 &enc_prm);1091 }1092 if (!ret && mtk_buf->param_change & MTK_ENCODE_PARAM_FRAMERATE) {1093 enc_prm.frm_rate = mtk_buf->enc_params.framerate_num /1094 mtk_buf->enc_params.framerate_denom;1095 mtk_v4l2_venc_dbg(1, ctx, "[%d] id=%d, change param fr=%d",1096 ctx->id, vb2_v4l2->vb2_buf.index, enc_prm.frm_rate);1097 ret |= venc_if_set_param(ctx,1098 VENC_SET_PARAM_ADJUST_FRAMERATE,1099 &enc_prm);1100 }1101 if (!ret && mtk_buf->param_change & MTK_ENCODE_PARAM_GOP_SIZE) {1102 enc_prm.gop_size = mtk_buf->enc_params.gop_size;1103 mtk_v4l2_venc_dbg(1, ctx, "change param intra period=%d", enc_prm.gop_size);1104 ret |= venc_if_set_param(ctx,1105 VENC_SET_PARAM_GOP_SIZE,1106 &enc_prm);1107 }1108 if (!ret && mtk_buf->param_change & MTK_ENCODE_PARAM_FORCE_INTRA) {1109 mtk_v4l2_venc_dbg(1, ctx, "[%d] id=%d, change param force I=%d",1110 ctx->id, vb2_v4l2->vb2_buf.index,1111 mtk_buf->enc_params.force_intra);1112 if (mtk_buf->enc_params.force_intra)1113 ret |= venc_if_set_param(ctx,1114 VENC_SET_PARAM_FORCE_INTRA,1115 NULL);1116 }1117 1118 mtk_buf->param_change = MTK_ENCODE_PARAM_NONE;1119 1120 if (ret) {1121 ctx->state = MTK_STATE_ABORT;1122 mtk_v4l2_venc_err(ctx, "venc_if_set_param %d failed=%d",1123 mtk_buf->param_change, ret);1124 return -1;1125 }1126 1127 return 0;1128}1129 1130/*1131 * v4l2_m2m_streamoff() holds dev_mutex and waits mtk_venc_worker()1132 * to call v4l2_m2m_job_finish().1133 * If mtk_venc_worker() tries to acquire dev_mutex, it will deadlock.1134 * So this function must not try to acquire dev->dev_mutex.1135 * This means v4l2 ioctls and mtk_venc_worker() can run at the same time.1136 * mtk_venc_worker() should be carefully implemented to avoid bugs.1137 */1138static void mtk_venc_worker(struct work_struct *work)1139{1140 struct mtk_vcodec_enc_ctx *ctx = container_of(work, struct mtk_vcodec_enc_ctx,1141 encode_work);1142 struct vb2_v4l2_buffer *src_buf, *dst_buf;1143 struct venc_frm_buf frm_buf;1144 struct mtk_vcodec_mem bs_buf;1145 struct venc_done_result enc_result;1146 int ret, i;1147 1148 /* check dst_buf, dst_buf may be removed in device_run1149 * to stored encdoe header so we need check dst_buf and1150 * call job_finish here to prevent recursion1151 */1152 dst_buf = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);1153 if (!dst_buf) {1154 v4l2_m2m_job_finish(ctx->dev->m2m_dev_enc, ctx->m2m_ctx);1155 return;1156 }1157 1158 src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);1159 1160 /*1161 * If we see the flush buffer, send an empty buffer with the LAST flag1162 * to the client. is_flushing will be reset at the time the buffer1163 * is dequeued.1164 */1165 if (src_buf == &ctx->empty_flush_buf.vb) {1166 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, 0);1167 dst_buf->flags |= V4L2_BUF_FLAG_LAST;1168 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_DONE);1169 v4l2_m2m_job_finish(ctx->dev->m2m_dev_enc, ctx->m2m_ctx);1170 return;1171 }1172 1173 memset(&frm_buf, 0, sizeof(frm_buf));1174 for (i = 0; i < src_buf->vb2_buf.num_planes ; i++) {1175 frm_buf.fb_addr[i].dma_addr =1176 vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, i);1177 frm_buf.fb_addr[i].size =1178 (size_t)src_buf->vb2_buf.planes[i].length;1179 }1180 bs_buf.va = vb2_plane_vaddr(&dst_buf->vb2_buf, 0);1181 bs_buf.dma_addr = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0);1182 bs_buf.size = (size_t)dst_buf->vb2_buf.planes[0].length;1183 1184 mtk_v4l2_venc_dbg(2, ctx,1185 "Framebuf PA=%llx Size=0x%zx;PA=0x%llx Size=0x%zx;PA=0x%llx Size=%zu",1186 (u64)frm_buf.fb_addr[0].dma_addr, frm_buf.fb_addr[0].size,1187 (u64)frm_buf.fb_addr[1].dma_addr, frm_buf.fb_addr[1].size,1188 (u64)frm_buf.fb_addr[2].dma_addr, frm_buf.fb_addr[2].size);1189 1190 ret = venc_if_encode(ctx, VENC_START_OPT_ENCODE_FRAME,1191 &frm_buf, &bs_buf, &enc_result);1192 1193 dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;1194 dst_buf->timecode = src_buf->timecode;1195 1196 if (enc_result.is_key_frm)1197 dst_buf->flags |= V4L2_BUF_FLAG_KEYFRAME;1198 1199 if (ret) {1200 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR);1201 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, 0);1202 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR);1203 mtk_v4l2_venc_err(ctx, "venc_if_encode failed=%d", ret);1204 } else {1205 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);1206 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, enc_result.bs_size);1207 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_DONE);1208 mtk_v4l2_venc_dbg(2, ctx, "venc_if_encode bs size=%d",1209 enc_result.bs_size);1210 }1211 1212 v4l2_m2m_job_finish(ctx->dev->m2m_dev_enc, ctx->m2m_ctx);1213 1214 mtk_v4l2_venc_dbg(1, ctx, "<=== src_buf[%d] dst_buf[%d] venc_if_encode ret=%d Size=%u===>",1215 src_buf->vb2_buf.index, dst_buf->vb2_buf.index, ret, enc_result.bs_size);1216}1217 1218static void m2mops_venc_device_run(void *priv)1219{1220 struct mtk_vcodec_enc_ctx *ctx = priv;1221 1222 if ((ctx->q_data[MTK_Q_DATA_DST].fmt->fourcc == V4L2_PIX_FMT_H264) &&1223 (ctx->state != MTK_STATE_HEADER)) {1224 /* encode h264 sps/pps header */1225 mtk_venc_encode_header(ctx);1226 queue_work(ctx->dev->encode_workqueue, &ctx->encode_work);1227 return;1228 }1229 1230 mtk_venc_param_change(ctx);1231 queue_work(ctx->dev->encode_workqueue, &ctx->encode_work);1232}1233 1234static int m2mops_venc_job_ready(void *m2m_priv)1235{1236 struct mtk_vcodec_enc_ctx *ctx = m2m_priv;1237 1238 if (ctx->state == MTK_STATE_ABORT || ctx->state == MTK_STATE_FREE) {1239 mtk_v4l2_venc_dbg(3, ctx, "[%d]Not ready: state=0x%x.", ctx->id, ctx->state);1240 return 0;1241 }1242 1243 return 1;1244}1245 1246static void m2mops_venc_job_abort(void *priv)1247{1248 struct mtk_vcodec_enc_ctx *ctx = priv;1249 1250 ctx->state = MTK_STATE_ABORT;1251}1252 1253const struct v4l2_m2m_ops mtk_venc_m2m_ops = {1254 .device_run = m2mops_venc_device_run,1255 .job_ready = m2mops_venc_job_ready,1256 .job_abort = m2mops_venc_job_abort,1257};1258 1259void mtk_vcodec_enc_set_default_params(struct mtk_vcodec_enc_ctx *ctx)1260{1261 struct mtk_q_data *q_data;1262 1263 ctx->m2m_ctx->q_lock = &ctx->q_mutex;1264 ctx->fh.m2m_ctx = ctx->m2m_ctx;1265 ctx->fh.ctrl_handler = &ctx->ctrl_hdl;1266 INIT_WORK(&ctx->encode_work, mtk_venc_worker);1267 1268 ctx->colorspace = V4L2_COLORSPACE_REC709;1269 ctx->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;1270 ctx->quantization = V4L2_QUANTIZATION_DEFAULT;1271 ctx->xfer_func = V4L2_XFER_FUNC_DEFAULT;1272 1273 q_data = &ctx->q_data[MTK_Q_DATA_SRC];1274 memset(q_data, 0, sizeof(struct mtk_q_data));1275 q_data->visible_width = DFT_CFG_WIDTH;1276 q_data->visible_height = DFT_CFG_HEIGHT;1277 q_data->coded_width = DFT_CFG_WIDTH;1278 q_data->coded_height = DFT_CFG_HEIGHT;1279 q_data->field = V4L2_FIELD_NONE;1280 1281 q_data->fmt = &ctx->dev->venc_pdata->output_formats[0];1282 1283 v4l_bound_align_image(&q_data->coded_width,1284 MTK_VENC_MIN_W,1285 MTK_VENC_HD_MAX_W, 4,1286 &q_data->coded_height,1287 MTK_VENC_MIN_H,1288 MTK_VENC_HD_MAX_H, 5, 6);1289 1290 if (q_data->coded_width < DFT_CFG_WIDTH &&1291 (q_data->coded_width + 16) <= MTK_VENC_HD_MAX_W)1292 q_data->coded_width += 16;1293 if (q_data->coded_height < DFT_CFG_HEIGHT &&1294 (q_data->coded_height + 32) <= MTK_VENC_HD_MAX_H)1295 q_data->coded_height += 32;1296 1297 q_data->sizeimage[0] =1298 q_data->coded_width * q_data->coded_height+1299 ((ALIGN(q_data->coded_width, 16) * 2) * 16);1300 q_data->bytesperline[0] = q_data->coded_width;1301 q_data->sizeimage[1] =1302 (q_data->coded_width * q_data->coded_height) / 2 +1303 (ALIGN(q_data->coded_width, 16) * 16);1304 q_data->bytesperline[1] = q_data->coded_width;1305 1306 q_data = &ctx->q_data[MTK_Q_DATA_DST];1307 memset(q_data, 0, sizeof(struct mtk_q_data));1308 q_data->coded_width = DFT_CFG_WIDTH;1309 q_data->coded_height = DFT_CFG_HEIGHT;1310 q_data->fmt = &ctx->dev->venc_pdata->capture_formats[0];1311 q_data->field = V4L2_FIELD_NONE;1312 ctx->q_data[MTK_Q_DATA_DST].sizeimage[0] =1313 DFT_CFG_WIDTH * DFT_CFG_HEIGHT;1314 ctx->q_data[MTK_Q_DATA_DST].bytesperline[0] = 0;1315 1316 ctx->enc_params.framerate_num = MTK_DEFAULT_FRAMERATE_NUM;1317 ctx->enc_params.framerate_denom = MTK_DEFAULT_FRAMERATE_DENOM;1318}1319 1320int mtk_vcodec_enc_ctrls_setup(struct mtk_vcodec_enc_ctx *ctx)1321{1322 const struct v4l2_ctrl_ops *ops = &mtk_vcodec_enc_ctrl_ops;1323 struct v4l2_ctrl_handler *handler = &ctx->ctrl_hdl;1324 u8 h264_max_level;1325 1326 if (ctx->dev->enc_capability & MTK_VENC_4K_CAPABILITY_ENABLE)1327 h264_max_level = V4L2_MPEG_VIDEO_H264_LEVEL_5_1;1328 else1329 h264_max_level = V4L2_MPEG_VIDEO_H264_LEVEL_4_2;1330 1331 v4l2_ctrl_handler_init(handler, MTK_MAX_CTRLS_HINT);1332 1333 v4l2_ctrl_new_std(handler, ops, V4L2_CID_MIN_BUFFERS_FOR_OUTPUT,1334 1, 1, 1, 1);1335 v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_BITRATE,1336 ctx->dev->venc_pdata->min_bitrate,1337 ctx->dev->venc_pdata->max_bitrate, 1, 4000000);1338 v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_B_FRAMES,1339 0, 2, 1, 0);1340 v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE,1341 0, 1, 1, 1);1342 v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_H264_MAX_QP,1343 0, 51, 1, 51);1344 v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_H264_I_PERIOD,1345 0, 65535, 1, 0);1346 v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_GOP_SIZE,1347 0, 65535, 1, 0);1348 v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE,1349 0, 1, 1, 0);1350 v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME,1351 0, 0, 0, 0);1352 v4l2_ctrl_new_std_menu(handler, ops,1353 V4L2_CID_MPEG_VIDEO_HEADER_MODE,1354 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,1355 0, V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE);1356 v4l2_ctrl_new_std_menu(handler, ops, V4L2_CID_MPEG_VIDEO_H264_PROFILE,1357 V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,1358 ~((1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |1359 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |1360 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)),1361 V4L2_MPEG_VIDEO_H264_PROFILE_HIGH);1362 v4l2_ctrl_new_std_menu(handler, ops, V4L2_CID_MPEG_VIDEO_H264_LEVEL,1363 h264_max_level,1364 0, V4L2_MPEG_VIDEO_H264_LEVEL_4_0);1365 v4l2_ctrl_new_std_menu(handler, ops, V4L2_CID_MPEG_VIDEO_VP8_PROFILE,1366 V4L2_MPEG_VIDEO_VP8_PROFILE_0, 0, V4L2_MPEG_VIDEO_VP8_PROFILE_0);1367 v4l2_ctrl_new_std_menu(handler, ops, V4L2_CID_MPEG_VIDEO_BITRATE_MODE,1368 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,1369 ~(1 << V4L2_MPEG_VIDEO_BITRATE_MODE_CBR),1370 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR);1371 1372 1373 if (handler->error) {1374 mtk_v4l2_venc_err(ctx, "Init control handler fail %d", handler->error);1375 return handler->error;1376 }1377 1378 v4l2_ctrl_handler_setup(&ctx->ctrl_hdl);1379 1380 return 0;1381}1382 1383int mtk_vcodec_enc_queue_init(void *priv, struct vb2_queue *src_vq,1384 struct vb2_queue *dst_vq)1385{1386 struct mtk_vcodec_enc_ctx *ctx = priv;1387 int ret;1388 1389 /* Note: VB2_USERPTR works with dma-contig because mt81731390 * support iommu1391 * https://patchwork.kernel.org/patch/8335461/1392 * https://patchwork.kernel.org/patch/7596181/1393 */1394 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;1395 src_vq->io_modes = VB2_DMABUF | VB2_MMAP | VB2_USERPTR;1396 src_vq->drv_priv = ctx;1397 src_vq->buf_struct_size = sizeof(struct mtk_video_enc_buf);1398 src_vq->ops = &mtk_venc_vb2_ops;1399 src_vq->mem_ops = &vb2_dma_contig_memops;1400 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;1401 src_vq->lock = &ctx->q_mutex;1402 src_vq->dev = &ctx->dev->plat_dev->dev;1403 1404 ret = vb2_queue_init(src_vq);1405 if (ret)1406 return ret;1407 1408 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;1409 dst_vq->io_modes = VB2_DMABUF | VB2_MMAP | VB2_USERPTR;1410 dst_vq->drv_priv = ctx;1411 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);1412 dst_vq->ops = &mtk_venc_vb2_ops;1413 dst_vq->mem_ops = &vb2_dma_contig_memops;1414 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;1415 dst_vq->lock = &ctx->q_mutex;1416 dst_vq->dev = &ctx->dev->plat_dev->dev;1417 1418 return vb2_queue_init(dst_vq);1419}1420 1421int mtk_venc_unlock(struct mtk_vcodec_enc_ctx *ctx)1422{1423 struct mtk_vcodec_enc_dev *dev = ctx->dev;1424 1425 mutex_unlock(&dev->enc_mutex);1426 return 0;1427}1428 1429int mtk_venc_lock(struct mtk_vcodec_enc_ctx *ctx)1430{1431 struct mtk_vcodec_enc_dev *dev = ctx->dev;1432 1433 mutex_lock(&dev->enc_mutex);1434 return 0;1435}1436 1437void mtk_vcodec_enc_release(struct mtk_vcodec_enc_ctx *ctx)1438{1439 int ret = venc_if_deinit(ctx);1440 1441 if (ret)1442 mtk_v4l2_venc_err(ctx, "venc_if_deinit failed=%d", ret);1443 1444 ctx->state = MTK_STATE_FREE;1445}1446