Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20;
Message-ID: <58eadd485f11d1d67214b4ebf45e01ae6111c4d5.camel@ndufresne.ca>
Subject: Re: [PATCH v7, 12/15] media: mtk-vcodec: Extract H264 common code
From:   Nicolas Dufresne <nicolas@ndufresne.ca>
To:     Yunfei Dong <yunfei.dong@mediatek.com>,
        Alexandre Courbot <acourbot@chromium.org>,
        Hans Verkuil <hverkuil-cisco@xs4all.nl>,
        Tzung-Bi Shih <tzungbi@chromium.org>,
        AngeloGioacchino Del Regno 
        <angelogioacchino.delregno@collabora.com>,
        Benjamin Gaignard <benjamin.gaignard@collabora.com>,
        Tiffany Lin <tiffany.lin@mediatek.com>,
        Andrew-CT Chen <andrew-ct.chen@mediatek.com>,
        Mauro Carvalho Chehab <mchehab@kernel.org>,
        Rob Herring <robh+dt@kernel.org>,
        Matthias Brugger <matthias.bgg@gmail.com>,
        Tomasz Figa <tfiga@google.com>
Cc:     George Sun <george.sun@mediatek.com>,
        Xiaoyong Lu <xiaoyong.lu@mediatek.com>,
        Hsin-Yi Wang <hsinyi@chromium.org>,
        Fritz Koenig <frkoenig@chromium.org>,
        Daniel Vetter <daniel@ffwll.ch>,
        dri-devel <dri-devel@lists.freedesktop.org>,
        Irui Wang <irui.wang@mediatek.com>,
        Steve Cho <stevecho@chromium.org>, linux-media@vger.kernel.org,
        devicetree@vger.kernel.org, linux-kernel@vger.kernel.org,
        linux-arm-kernel@lists.infradead.org, srv_heupstream@mediatek.com,
        linux-mediatek@lists.infradead.org,
        Project_Global_Chrome_Upstream_Group@mediatek.com
Date:   Tue, 01 Mar 2022 16:30:54 -0500
In-Reply-To: <20220223034008.15781-13-yunfei.dong@mediatek.com>
References: <20220223034008.15781-1-yunfei.dong@mediatek.com>
         <20220223034008.15781-13-yunfei.dong@mediatek.com>
Content-Type: text/plain; charset="UTF-8"
User-Agent: Evolution 3.42.3 (3.42.3-1.fc35) 
MIME-Version: 1.0
Content-Transfer-Encoding: 8bit
Precedence: bulk

Le mercredi 23 février 2022 à 11:40 +0800, Yunfei Dong a écrit :
> Mt8192 can use some of common code with mt8183. Moves them to
> a new file in order to reuse.

With the documentation fixed as per my comments below, you can add:

Reviewed-by: Nicolas Dufresne <nicolas.dufresne@collabora.com>

> 
> Signed-off-by: Yunfei Dong <yunfei.dong@mediatek.com>
> ---
>  drivers/media/platform/mtk-vcodec/Makefile    |   1 +
>  .../mtk-vcodec/vdec/vdec_h264_req_common.c    | 310 +++++++++++++
>  .../mtk-vcodec/vdec/vdec_h264_req_common.h    | 253 +++++++++++
>  .../mtk-vcodec/vdec/vdec_h264_req_if.c        | 424 ++----------------
>  4 files changed, 606 insertions(+), 382 deletions(-)
>  create mode 100644 drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.c
>  create mode 100644 drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.h
> 
> diff --git a/drivers/media/platform/mtk-vcodec/Makefile b/drivers/media/platform/mtk-vcodec/Makefile
> index 359619653a0e..3f41d748eee5 100644
> --- a/drivers/media/platform/mtk-vcodec/Makefile
> +++ b/drivers/media/platform/mtk-vcodec/Makefile
> @@ -9,6 +9,7 @@ mtk-vcodec-dec-y := vdec/vdec_h264_if.o \
>  		vdec/vdec_vp8_if.o \
>  		vdec/vdec_vp9_if.o \
>  		vdec/vdec_h264_req_if.o \
> +		vdec/vdec_h264_req_common.o \
>  		mtk_vcodec_dec_drv.o \
>  		vdec_drv_if.o \
>  		vdec_vpu_if.o \
> diff --git a/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.c b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.c
> new file mode 100644
> index 000000000000..6c68bee632d6
> --- /dev/null
> +++ b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.c
> @@ -0,0 +1,310 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2021 MediaTek Inc.
> + * Author: Yunfei Dong <yunfei.dong@mediatek.com>
> + */
> +
> +#include "vdec_h264_req_common.h"
> +
> +/* get used parameters for sps/pps */
> +#define GET_MTK_VDEC_FLAG(cond, flag) \
> +	{ dst_param->cond = ((src_param->flags & flag) ? (1) : (0)); }
> +#define GET_MTK_VDEC_PARAM(param) \
> +	{ dst_param->param = src_param->param; }
> +
> +/*
> + * The firmware expects unused reflist entries to have the value 0x20.
> + */
> +void mtk_vdec_h264_fixup_ref_list(u8 *ref_list, size_t num_valid)
> +{
> +	memset_io(&ref_list[num_valid], 0x20, 32 - num_valid);
> +}
> +
> +void *mtk_vdec_h264_get_ctrl_ptr(struct mtk_vcodec_ctx *ctx, int id)
> +{
> +	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(&ctx->ctrl_hdl, id);
> +
> +	if (!ctrl)
> +		return ERR_PTR(-EINVAL);
> +
> +	return ctrl->p_cur.p;
> +}
> +
> +void mtk_vdec_h264_fill_dpb_info(struct mtk_vcodec_ctx *ctx,
> +				 struct slice_api_h264_decode_param *decode_params,
> +				 struct mtk_h264_dpb_info *h264_dpb_info)
> +{
> +	const struct slice_h264_dpb_entry *dpb;
> +	struct vb2_queue *vq;
> +	struct vb2_buffer *vb;
> +	struct vb2_v4l2_buffer *vb2_v4l2;
> +	int index, vb2_index;
> +
> +	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> +
> +	for (index = 0; index < V4L2_H264_NUM_DPB_ENTRIES; index++) {
> +		dpb = &decode_params->dpb[index];
> +		if (!(dpb->flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE)) {
> +			h264_dpb_info[index].reference_flag = 0;
> +			continue;
> +		}
> +
> +		vb2_index = vb2_find_timestamp(vq, dpb->reference_ts, 0);
> +		if (vb2_index < 0) {
> +			dev_err(&ctx->dev->plat_dev->dev,
> +				"Reference invalid: dpb_index(%d) reference_ts(%lld)",
> +				index, dpb->reference_ts);
> +			continue;
> +		}
> +
> +		/* 1 for short term reference, 2 for long term reference */
> +		if (!(dpb->flags & V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM))
> +			h264_dpb_info[index].reference_flag = 1;
> +		else
> +			h264_dpb_info[index].reference_flag = 2;
> +
> +		vb = vq->bufs[vb2_index];
> +		vb2_v4l2 = container_of(vb, struct vb2_v4l2_buffer, vb2_buf);
> +		h264_dpb_info[index].field = vb2_v4l2->field;
> +
> +		h264_dpb_info[index].y_dma_addr =
> +			vb2_dma_contig_plane_dma_addr(vb, 0);
> +		if (ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 2)
> +			h264_dpb_info[index].c_dma_addr =
> +				vb2_dma_contig_plane_dma_addr(vb, 1);
> +		else
> +			h264_dpb_info[index].c_dma_addr =
> +				h264_dpb_info[index].y_dma_addr +
> +				ctx->picinfo.fb_sz[0];
> +	}
> +}
> +
> +void mtk_vdec_h264_copy_sps_params(struct mtk_h264_sps_param *dst_param,
> +				   const struct v4l2_ctrl_h264_sps *src_param)
> +{
> +	GET_MTK_VDEC_PARAM(chroma_format_idc);
> +	GET_MTK_VDEC_PARAM(bit_depth_luma_minus8);
> +	GET_MTK_VDEC_PARAM(bit_depth_chroma_minus8);
> +	GET_MTK_VDEC_PARAM(log2_max_frame_num_minus4);
> +	GET_MTK_VDEC_PARAM(pic_order_cnt_type);
> +	GET_MTK_VDEC_PARAM(log2_max_pic_order_cnt_lsb_minus4);
> +	GET_MTK_VDEC_PARAM(max_num_ref_frames);
> +	GET_MTK_VDEC_PARAM(pic_width_in_mbs_minus1);
> +	GET_MTK_VDEC_PARAM(pic_height_in_map_units_minus1);
> +
> +	GET_MTK_VDEC_FLAG(separate_colour_plane_flag,
> +			  V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE);
> +	GET_MTK_VDEC_FLAG(qpprime_y_zero_transform_bypass_flag,
> +			  V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS);
> +	GET_MTK_VDEC_FLAG(delta_pic_order_always_zero_flag,
> +			  V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO);
> +	GET_MTK_VDEC_FLAG(frame_mbs_only_flag,
> +			  V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY);
> +	GET_MTK_VDEC_FLAG(mb_adaptive_frame_field_flag,
> +			  V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD);
> +	GET_MTK_VDEC_FLAG(direct_8x8_inference_flag,
> +			  V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE);
> +}
> +
> +void mtk_vdec_h264_copy_pps_params(struct mtk_h264_pps_param *dst_param,
> +				   const struct v4l2_ctrl_h264_pps *src_param)
> +{
> +	GET_MTK_VDEC_PARAM(num_ref_idx_l0_default_active_minus1);
> +	GET_MTK_VDEC_PARAM(num_ref_idx_l1_default_active_minus1);
> +	GET_MTK_VDEC_PARAM(weighted_bipred_idc);
> +	GET_MTK_VDEC_PARAM(pic_init_qp_minus26);
> +	GET_MTK_VDEC_PARAM(chroma_qp_index_offset);
> +	GET_MTK_VDEC_PARAM(second_chroma_qp_index_offset);
> +
> +	GET_MTK_VDEC_FLAG(entropy_coding_mode_flag,
> +			  V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE);
> +	GET_MTK_VDEC_FLAG(pic_order_present_flag,
> +			  V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT);
> +	GET_MTK_VDEC_FLAG(weighted_pred_flag,
> +			  V4L2_H264_PPS_FLAG_WEIGHTED_PRED);
> +	GET_MTK_VDEC_FLAG(deblocking_filter_control_present_flag,
> +			  V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT);
> +	GET_MTK_VDEC_FLAG(constrained_intra_pred_flag,
> +			  V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED);
> +	GET_MTK_VDEC_FLAG(redundant_pic_cnt_present_flag,
> +			  V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT);
> +	GET_MTK_VDEC_FLAG(transform_8x8_mode_flag,
> +			  V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE);
> +	GET_MTK_VDEC_FLAG(scaling_matrix_present_flag,
> +			  V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT);
> +}
> +
> +void mtk_vdec_h264_copy_slice_hd_params(struct mtk_h264_slice_hd_param *dst_param,
> +					const struct v4l2_ctrl_h264_slice_params *src_param,
> +					const struct v4l2_ctrl_h264_decode_params *dec_param)
> +{
> +	int temp;
> +
> +	GET_MTK_VDEC_PARAM(first_mb_in_slice);
> +	GET_MTK_VDEC_PARAM(slice_type);
> +	GET_MTK_VDEC_PARAM(cabac_init_idc);
> +	GET_MTK_VDEC_PARAM(slice_qp_delta);
> +	GET_MTK_VDEC_PARAM(disable_deblocking_filter_idc);
> +	GET_MTK_VDEC_PARAM(slice_alpha_c0_offset_div2);
> +	GET_MTK_VDEC_PARAM(slice_beta_offset_div2);
> +	GET_MTK_VDEC_PARAM(num_ref_idx_l0_active_minus1);
> +	GET_MTK_VDEC_PARAM(num_ref_idx_l1_active_minus1);
> +
> +	dst_param->frame_num = dec_param->frame_num;
> +	dst_param->pic_order_cnt_lsb = dec_param->pic_order_cnt_lsb;
> +
> +	dst_param->delta_pic_order_cnt_bottom =
> +		dec_param->delta_pic_order_cnt_bottom;
> +	dst_param->delta_pic_order_cnt0 =
> +		dec_param->delta_pic_order_cnt0;
> +	dst_param->delta_pic_order_cnt1 =
> +		dec_param->delta_pic_order_cnt1;
> +
> +	temp = dec_param->flags & V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC;
> +	dst_param->field_pic_flag = temp ? 1 : 0;
> +
> +	temp = dec_param->flags & V4L2_H264_DECODE_PARAM_FLAG_BOTTOM_FIELD;
> +	dst_param->bottom_field_flag = temp ? 1 : 0;
> +
> +	GET_MTK_VDEC_FLAG(direct_spatial_mv_pred_flag,
> +			  V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED);
> +}
> +
> +void mtk_vdec_h264_copy_scaling_matrix(struct slice_api_h264_scaling_matrix *dst_matrix,
> +				       const struct v4l2_ctrl_h264_scaling_matrix *src_matrix)
> +{
> +	memcpy_toio(dst_matrix->scaling_list_4x4, src_matrix->scaling_list_4x4,
> +		    sizeof(dst_matrix->scaling_list_4x4));
> +
> +	memcpy_toio(dst_matrix->scaling_list_8x8, src_matrix->scaling_list_8x8,
> +		    sizeof(dst_matrix->scaling_list_8x8));
> +}
> +
> +void
> +mtk_vdec_h264_copy_decode_params(struct slice_api_h264_decode_param *dst_params,
> +				 const struct v4l2_ctrl_h264_decode_params *src_params,
> +				 const struct v4l2_h264_dpb_entry dpb[V4L2_H264_NUM_DPB_ENTRIES])
> +{
> +	struct slice_h264_dpb_entry *dst_entry;
> +	const struct v4l2_h264_dpb_entry *src_entry;
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(dst_params->dpb); i++) {
> +		dst_entry = &dst_params->dpb[i];
> +		src_entry = &dpb[i];
> +
> +		dst_entry->reference_ts = src_entry->reference_ts;
> +		dst_entry->frame_num = src_entry->frame_num;
> +		dst_entry->pic_num = src_entry->pic_num;
> +		dst_entry->top_field_order_cnt = src_entry->top_field_order_cnt;
> +		dst_entry->bottom_field_order_cnt =
> +			src_entry->bottom_field_order_cnt;
> +		dst_entry->flags = src_entry->flags;
> +	}
> +
> +	/* num_slices is a leftover from the old H.264 support and is ignored
> +	 * by the firmware.
> +	 */
> +	dst_params->num_slices = 0;
> +	dst_params->nal_ref_idc = src_params->nal_ref_idc;
> +	dst_params->top_field_order_cnt = src_params->top_field_order_cnt;
> +	dst_params->bottom_field_order_cnt = src_params->bottom_field_order_cnt;
> +	dst_params->flags = src_params->flags;
> +}
> +
> +static bool mtk_vdec_h264_dpb_entry_match(const struct v4l2_h264_dpb_entry *a,
> +					  const struct v4l2_h264_dpb_entry *b)
> +{
> +	return a->top_field_order_cnt == b->top_field_order_cnt &&
> +	       a->bottom_field_order_cnt == b->bottom_field_order_cnt;
> +}
> +
> +/*
> + * Move DPB entries of dec_param that refer to a frame already existing in dpb
> + * into the already existing slot in dpb, and move other entries into new slots.
> + *
> + * This function is an adaptation of the similarly-named function in
> + * hantro_h264.c.
> + */
> +void mtk_vdec_h264_update_dpb(const struct v4l2_ctrl_h264_decode_params *dec_param,
> +			      struct v4l2_h264_dpb_entry *dpb)
> +{
> +	DECLARE_BITMAP(new, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> +	DECLARE_BITMAP(in_use, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> +	DECLARE_BITMAP(used, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> +	unsigned int i, j;
> +
> +	/* Disable all entries by default, and mark the ones in use. */
> +	for (i = 0; i < ARRAY_SIZE(dec_param->dpb); i++) {
> +		if (dpb[i].flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE)
> +			set_bit(i, in_use);
> +		dpb[i].flags &= ~V4L2_H264_DPB_ENTRY_FLAG_ACTIVE;
> +	}
> +
> +	/* Try to match new DPB entries with existing ones by their POCs. */
> +	for (i = 0; i < ARRAY_SIZE(dec_param->dpb); i++) {
> +		const struct v4l2_h264_dpb_entry *ndpb = &dec_param->dpb[i];
> +
> +		if (!(ndpb->flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE))
> +			continue;
> +
> +		/*
> +		 * To cut off some comparisons, iterate only on target DPB
> +		 * entries were already used.
> +		 */
> +		for_each_set_bit(j, in_use, ARRAY_SIZE(dec_param->dpb)) {
> +			struct v4l2_h264_dpb_entry *cdpb;
> +
> +			cdpb = &dpb[j];
> +			if (!mtk_vdec_h264_dpb_entry_match(cdpb, ndpb))
> +				continue;
> +
> +			*cdpb = *ndpb;
> +			set_bit(j, used);
> +			/* Don't reiterate on this one. */
> +			clear_bit(j, in_use);
> +			break;
> +		}
> +
> +		if (j == ARRAY_SIZE(dec_param->dpb))
> +			set_bit(i, new);
> +	}
> +
> +	/* For entries that could not be matched, use remaining free slots. */
> +	for_each_set_bit(i, new, ARRAY_SIZE(dec_param->dpb)) {
> +		const struct v4l2_h264_dpb_entry *ndpb = &dec_param->dpb[i];
> +		struct v4l2_h264_dpb_entry *cdpb;
> +
> +		/*
> +		 * Both arrays are of the same sizes, so there is no way
> +		 * we can end up with no space in target array, unless
> +		 * something is buggy.
> +		 */
> +		j = find_first_zero_bit(used, ARRAY_SIZE(dec_param->dpb));
> +		if (WARN_ON(j >= ARRAY_SIZE(dec_param->dpb)))
> +			return;
> +
> +		cdpb = &dpb[j];
> +		*cdpb = *ndpb;
> +		set_bit(j, used);
> +	}
> +}
> +
> +unsigned int mtk_vdec_h264_get_mv_buf_size(unsigned int width, unsigned int height)
> +{
> +	int unit_size = (width / MB_UNIT_LEN) * (height / MB_UNIT_LEN) + 8;
> +
> +	return HW_MB_STORE_SZ * unit_size;
> +}
> +
> +int mtk_vdec_h264_find_start_code(unsigned char *data, unsigned int data_sz)
> +{
> +	if (data_sz > 3 && data[0] == 0 && data[1] == 0 && data[2] == 1)
> +		return 3;
> +
> +	if (data_sz > 4 && data[0] == 0 && data[1] == 0 && data[2] == 0 &&
> +	    data[3] == 1)
> +		return 4;
> +
> +	return -1;
> +}
> diff --git a/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.h b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.h
> new file mode 100644
> index 000000000000..2d731bc777ca
> --- /dev/null
> +++ b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.h
> @@ -0,0 +1,253 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Copyright (c) 2021 MediaTek Inc.
> + * Author: Yunfei Dong <yunfei.dong@mediatek.com>
> + */
> +
> +#ifndef _VDEC_H264_REQ_COMMON_H_
> +#define _VDEC_H264_REQ_COMMON_H_
> +
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +#include <media/v4l2-h264.h>
> +#include <media/v4l2-mem2mem.h>
> +#include <media/videobuf2-dma-contig.h>
> +
> +#include "../mtk_vcodec_drv.h"
> +
> +#define NAL_NON_IDR_SLICE			0x01
> +#define NAL_IDR_SLICE				0x05
> +#define NAL_TYPE(value)				((value) & 0x1F)
> +
> +#define BUF_PREDICTION_SZ			(64 * 4096)
> +#define MB_UNIT_LEN				16
> +
> +/* motion vector size (bytes) for every macro block */
> +#define HW_MB_STORE_SZ				64
> +
> +#define H264_MAX_MV_NUM				32
> +
> +/**
> + * struct mtk_h264_dpb_info  - h264 dpb information

All other doc I have seen will add an empty line between this and the first
parameter.

> + * @y_dma_addr: Y bitstream physical address
> + * @c_dma_addr: CbCr bitstream physical address
> + * @reference_flag: reference picture flag (short/long term reference picture)
> + * @field: field picture flag
> + */
> +struct mtk_h264_dpb_info {
> +	dma_addr_t y_dma_addr;
> +	dma_addr_t c_dma_addr;
> +	int reference_flag;
> +	int field;
> +};
> +
> +/**
> + * struct mtk_h264_sps_param  - parameters for sps

Each member is documented in previous structure, why not this one ? Same apply
in many places.

> + */
> +struct mtk_h264_sps_param {
> +	unsigned char chroma_format_idc;
> +	unsigned char bit_depth_luma_minus8;
> +	unsigned char bit_depth_chroma_minus8;
> +	unsigned char log2_max_frame_num_minus4;
> +	unsigned char pic_order_cnt_type;
> +	unsigned char log2_max_pic_order_cnt_lsb_minus4;
> +	unsigned char max_num_ref_frames;
> +	unsigned char separate_colour_plane_flag;
> +	unsigned short pic_width_in_mbs_minus1;
> +	unsigned short pic_height_in_map_units_minus1;
> +	unsigned int max_frame_nums;
> +	unsigned char qpprime_y_zero_transform_bypass_flag;
> +	unsigned char delta_pic_order_always_zero_flag;
> +	unsigned char frame_mbs_only_flag;
> +	unsigned char mb_adaptive_frame_field_flag;
> +	unsigned char direct_8x8_inference_flag;
> +	unsigned char reserved[3];
> +};
> +
> +/**
> + * struct mtk_h264_pps_param  - parameters for pps
> + */
> +struct mtk_h264_pps_param {
> +	unsigned char num_ref_idx_l0_default_active_minus1;
> +	unsigned char num_ref_idx_l1_default_active_minus1;
> +	unsigned char weighted_bipred_idc;
> +	char pic_init_qp_minus26;
> +	char chroma_qp_index_offset;
> +	char second_chroma_qp_index_offset;
> +	unsigned char entropy_coding_mode_flag;
> +	unsigned char pic_order_present_flag;
> +	unsigned char deblocking_filter_control_present_flag;
> +	unsigned char constrained_intra_pred_flag;
> +	unsigned char weighted_pred_flag;
> +	unsigned char redundant_pic_cnt_present_flag;
> +	unsigned char transform_8x8_mode_flag;
> +	unsigned char scaling_matrix_present_flag;
> +	unsigned char reserved[2];
> +};
> +
> +/**
> + * struct mtk_h264_slice_hd_param  - parameters for slice header
> + */
> +struct mtk_h264_slice_hd_param {
> +	unsigned int first_mb_in_slice;
> +	unsigned int field_pic_flag;
> +	unsigned int slice_type;
> +	unsigned int frame_num;
> +	int pic_order_cnt_lsb;
> +	int delta_pic_order_cnt_bottom;
> +	unsigned int bottom_field_flag;
> +	unsigned int direct_spatial_mv_pred_flag;
> +	int delta_pic_order_cnt0;
> +	int delta_pic_order_cnt1;
> +	unsigned int cabac_init_idc;
> +	int slice_qp_delta;
> +	unsigned int disable_deblocking_filter_idc;
> +	int slice_alpha_c0_offset_div2;
> +	int slice_beta_offset_div2;
> +	unsigned int num_ref_idx_l0_active_minus1;
> +	unsigned int num_ref_idx_l1_active_minus1;
> +	unsigned int reserved;
> +};
> +

And why these two don't have doc now ?

> +struct slice_api_h264_scaling_matrix {
> +	unsigned char scaling_list_4x4[6][16];
> +	unsigned char scaling_list_8x8[6][64];
> +};
> +
> +struct slice_h264_dpb_entry {
> +	unsigned long long reference_ts;
> +	unsigned short frame_num;
> +	unsigned short pic_num;
> +	/* Note that field is indicated by v4l2_buffer.field */
> +	int top_field_order_cnt;
> +	int bottom_field_order_cnt;
> +	unsigned int flags; /* V4L2_H264_DPB_ENTRY_FLAG_* */

You could move that into a doc block ?

> +};
> +
> +/**
> + * struct slice_api_h264_decode_param - parameters for decode.
> + */
> +struct slice_api_h264_decode_param {
> +	struct slice_h264_dpb_entry dpb[V4L2_H264_NUM_DPB_ENTRIES];
> +	unsigned short num_slices;
> +	unsigned short nal_ref_idc;
> +	unsigned char ref_pic_list_p0[32];
> +	unsigned char ref_pic_list_b0[32];
> +	unsigned char ref_pic_list_b1[32];
> +	int top_field_order_cnt;
> +	int bottom_field_order_cnt;
> +	unsigned int flags; /* V4L2_H264_DECODE_PARAM_FLAG_* */
> +};
> +
> +/**
> + * struct h264_fb - h264 decode frame buffer information
> + * @vdec_fb_va  : virtual address of struct vdec_fb
> + * @y_fb_dma    : dma address of Y frame buffer (luma)
> + * @c_fb_dma    : dma address of C frame buffer (chroma)
> + * @poc         : picture order count of frame buffer
> + * @reserved    : for 8 bytes alignment

This style does not match what came before.

> + */
> +struct h264_fb {
> +	u64 vdec_fb_va;
> +	u64 y_fb_dma;
> +	u64 c_fb_dma;
> +	s32 poc;
> +	u32 reserved;
> +};
> +
> +/**
> + * mtk_vdec_h264_fixup_ref_list - fixup unused reference to 0x20.
> + * @ref_list: reference picture list
> + * @num_valid: used reference number
> + */
> +void mtk_vdec_h264_fixup_ref_list(u8 *ref_list, size_t num_valid);
> +
> +/**
> + * mtk_vdec_h264_get_ctrl_ptr - get each CID contrl address.
> + * @ctx: v4l2 ctx
> + * @id: CID control ID
> + */
> +void *mtk_vdec_h264_get_ctrl_ptr(struct mtk_vcodec_ctx *ctx, int id);
> +
> +/**
> + * mtk_vdec_h264_fill_dpb_info - get each CID contrl address.
> + * @ctx: v4l2 ctx
> + * @decode_params: slice decode params
> + * @h264_dpb_info: dpb buffer information
> + */
> +void mtk_vdec_h264_fill_dpb_info(struct mtk_vcodec_ctx *ctx,
> +				 struct slice_api_h264_decode_param *decode_params,
> +				 struct mtk_h264_dpb_info *h264_dpb_info);
> +
> +/**
> + * mtk_vdec_h264_copy_sps_params - get sps params.
> + * @dst_params: sps params for hw decoder
> + * @src_params: sps params from user driver
> + */
> +void mtk_vdec_h264_copy_sps_params(struct mtk_h264_sps_param *dst_param,
> +				   const struct v4l2_ctrl_h264_sps *src_param);
> +
> +/**
> + * mtk_vdec_h264_copy_pps_params - get pps params.
> + * @dst_params: pps params for hw decoder
> + * @src_params: pps params from user driver
> + */
> +void mtk_vdec_h264_copy_pps_params(struct mtk_h264_pps_param *dst_param,
> +				   const struct v4l2_ctrl_h264_pps *src_param);
> +
> +/**
> + * mtk_vdec_h264_copy_slice_hd_params - get slice header params.
> + * @dst_params: slice params for hw decoder
> + * @src_params: slice params from user driver
> + * @dec_param: decode params from user driver
> + */
> +void mtk_vdec_h264_copy_slice_hd_params(struct mtk_h264_slice_hd_param *dst_param,
> +					const struct v4l2_ctrl_h264_slice_params *src_param,
> +					const struct v4l2_ctrl_h264_decode_params *dec_param);
> +
> +/**
> + * mtk_vdec_h264_copy_scaling_matrix - get each CID contrl address.
> + * @dst_matrix: scaling list params for hw decoder
> + * @src_matrix: scaling list params from user driver
> + */
> +void mtk_vdec_h264_copy_scaling_matrix(struct slice_api_h264_scaling_matrix *dst_matrix,
> +				       const struct v4l2_ctrl_h264_scaling_matrix *src_matrix);
> +
> +/**
> + * mtk_vdec_h264_copy_decode_params - get decode params.
> + * @dst_params: dst params for hw decoder
> + * @src_params: decode params from user driver
> + * @dpb: dpb information
> + */
> +void
> +mtk_vdec_h264_copy_decode_params(struct slice_api_h264_decode_param *dst_params,
> +				 const struct v4l2_ctrl_h264_decode_params *src_params,
> +				 const struct v4l2_h264_dpb_entry dpb[V4L2_H264_NUM_DPB_ENTRIES]);
> +
> +/**
> + * mtk_vdec_h264_update_dpb - updata dpb list.
> + * @dec_param: v4l2 control decode params
> + * @dpb: dpb entry informaton
> + */
> +void mtk_vdec_h264_update_dpb(const struct v4l2_ctrl_h264_decode_params *dec_param,
> +			      struct v4l2_h264_dpb_entry *dpb);
> +
> +/**
> + * mtk_vdec_h264_find_start_code - find h264 start code using sofeware.
> + * @data: input buffer address
> + * @data_sz: input buffer size
> + *
> + * Return: returns start code position.
> + */
> +int mtk_vdec_h264_find_start_code(unsigned char *data, unsigned int data_sz);
> +
> +/**
> + * mtk_vdec_h264_get_mv_buf_size - get mv buffer size.
> + * @width: picture width
> + * @height: picture height
> + *
> + * Return: returns mv buffer size.
> + */
> +unsigned int mtk_vdec_h264_get_mv_buf_size(unsigned int width, unsigned int height);
> +
> +#endif
> diff --git a/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_if.c b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_if.c
> index 36f3dc1fbe3b..87e0b2f95572 100644
> --- a/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_if.c
> +++ b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_if.c
> @@ -12,109 +12,7 @@
>  #include "../vdec_drv_base.h"
>  #include "../vdec_drv_if.h"
>  #include "../vdec_vpu_if.h"
> -
> -#define BUF_PREDICTION_SZ			(64 * 4096)
> -#define MB_UNIT_LEN				16
> -
> -/* get used parameters for sps/pps */
> -#define GET_MTK_VDEC_FLAG(cond, flag) \
> -	{ dst_param->cond = ((src_param->flags & (flag)) ? (1) : (0)); }
> -#define GET_MTK_VDEC_PARAM(param) \
> -	{ dst_param->param = src_param->param; }
> -/* motion vector size (bytes) for every macro block */
> -#define HW_MB_STORE_SZ				64
> -
> -#define H264_MAX_FB_NUM				17
> -#define H264_MAX_MV_NUM				32
> -#define HDR_PARSING_BUF_SZ			1024
> -
> -/**
> - * struct mtk_h264_dpb_info  - h264 dpb information
> - * @y_dma_addr: Y bitstream physical address
> - * @c_dma_addr: CbCr bitstream physical address
> - * @reference_flag: reference picture flag (short/long term reference picture)
> - * @field: field picture flag
> - */
> -struct mtk_h264_dpb_info {
> -	dma_addr_t y_dma_addr;
> -	dma_addr_t c_dma_addr;
> -	int reference_flag;
> -	int field;
> -};
> -
> -/*
> - * struct mtk_h264_sps_param  - parameters for sps
> - */
> -struct mtk_h264_sps_param {
> -	unsigned char chroma_format_idc;
> -	unsigned char bit_depth_luma_minus8;
> -	unsigned char bit_depth_chroma_minus8;
> -	unsigned char log2_max_frame_num_minus4;
> -	unsigned char pic_order_cnt_type;
> -	unsigned char log2_max_pic_order_cnt_lsb_minus4;
> -	unsigned char max_num_ref_frames;
> -	unsigned char separate_colour_plane_flag;
> -	unsigned short pic_width_in_mbs_minus1;
> -	unsigned short pic_height_in_map_units_minus1;
> -	unsigned int max_frame_nums;
> -	unsigned char qpprime_y_zero_transform_bypass_flag;
> -	unsigned char delta_pic_order_always_zero_flag;
> -	unsigned char frame_mbs_only_flag;
> -	unsigned char mb_adaptive_frame_field_flag;
> -	unsigned char direct_8x8_inference_flag;
> -	unsigned char reserved[3];
> -};
> -
> -/*
> - * struct mtk_h264_pps_param  - parameters for pps
> - */
> -struct mtk_h264_pps_param {
> -	unsigned char num_ref_idx_l0_default_active_minus1;
> -	unsigned char num_ref_idx_l1_default_active_minus1;
> -	unsigned char weighted_bipred_idc;
> -	char pic_init_qp_minus26;
> -	char chroma_qp_index_offset;
> -	char second_chroma_qp_index_offset;
> -	unsigned char entropy_coding_mode_flag;
> -	unsigned char pic_order_present_flag;
> -	unsigned char deblocking_filter_control_present_flag;
> -	unsigned char constrained_intra_pred_flag;
> -	unsigned char weighted_pred_flag;
> -	unsigned char redundant_pic_cnt_present_flag;
> -	unsigned char transform_8x8_mode_flag;
> -	unsigned char scaling_matrix_present_flag;
> -	unsigned char reserved[2];
> -};
> -
> -struct slice_api_h264_scaling_matrix {
> -	unsigned char scaling_list_4x4[6][16];
> -	unsigned char scaling_list_8x8[6][64];
> -};
> -
> -struct slice_h264_dpb_entry {
> -	unsigned long long reference_ts;
> -	unsigned short frame_num;
> -	unsigned short pic_num;
> -	/* Note that field is indicated by v4l2_buffer.field */
> -	int top_field_order_cnt;
> -	int bottom_field_order_cnt;
> -	unsigned int flags; /* V4L2_H264_DPB_ENTRY_FLAG_* */
> -};
> -
> -/*
> - * struct slice_api_h264_decode_param - parameters for decode.
> - */
> -struct slice_api_h264_decode_param {
> -	struct slice_h264_dpb_entry dpb[16];
> -	unsigned short num_slices;
> -	unsigned short nal_ref_idc;
> -	unsigned char ref_pic_list_p0[32];
> -	unsigned char ref_pic_list_b0[32];
> -	unsigned char ref_pic_list_b1[32];
> -	int top_field_order_cnt;
> -	int bottom_field_order_cnt;
> -	unsigned int flags; /* V4L2_H264_DECODE_PARAM_FLAG_* */
> -};
> +#include "vdec_h264_req_common.h"
>  
>  /*
>   * struct mtk_h264_dec_slice_param  - parameters for decode current frame
> @@ -127,22 +25,6 @@ struct mtk_h264_dec_slice_param {
>  	struct mtk_h264_dpb_info h264_dpb_info[16];
>  };
>  
> -/**
> - * struct h264_fb - h264 decode frame buffer information
> - * @vdec_fb_va  : virtual address of struct vdec_fb
> - * @y_fb_dma    : dma address of Y frame buffer (luma)
> - * @c_fb_dma    : dma address of C frame buffer (chroma)
> - * @poc         : picture order count of frame buffer
> - * @reserved    : for 8 bytes alignment
> - */
> -struct h264_fb {
> -	u64 vdec_fb_va;
> -	u64 y_fb_dma;
> -	u64 c_fb_dma;
> -	s32 poc;
> -	u32 reserved;
> -};
> -
>  /**
>   * struct vdec_h264_dec_info - decode information
>   * @dpb_sz		: decoding picture buffer size
> @@ -212,265 +94,45 @@ struct vdec_h264_slice_inst {
>  	struct v4l2_h264_dpb_entry dpb[16];
>  };
>  
> -static void *get_ctrl_ptr(struct mtk_vcodec_ctx *ctx, int id)
> -{
> -	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(&ctx->ctrl_hdl, id);
> -
> -	return ctrl->p_cur.p;
> -}
> -
> -static void get_h264_dpb_list(struct vdec_h264_slice_inst *inst,
> -			      struct mtk_h264_dec_slice_param *slice_param)
> -{
> -	struct vb2_queue *vq;
> -	struct vb2_buffer *vb;
> -	struct vb2_v4l2_buffer *vb2_v4l2;
> -	u64 index;
> -
> -	vq = v4l2_m2m_get_vq(inst->ctx->m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> -
> -	for (index = 0; index < ARRAY_SIZE(slice_param->decode_params.dpb); index++) {
> -		const struct slice_h264_dpb_entry *dpb;
> -		int vb2_index;
> -
> -		dpb = &slice_param->decode_params.dpb[index];
> -		if (!(dpb->flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE)) {
> -			slice_param->h264_dpb_info[index].reference_flag = 0;
> -			continue;
> -		}
> -
> -		vb2_index = vb2_find_timestamp(vq, dpb->reference_ts, 0);
> -		if (vb2_index < 0) {
> -			mtk_vcodec_err(inst, "Reference invalid: dpb_index(%lld) reference_ts(%lld)",
> -				       index, dpb->reference_ts);
> -			continue;
> -		}
> -		/* 1 for short term reference, 2 for long term reference */
> -		if (!(dpb->flags & V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM))
> -			slice_param->h264_dpb_info[index].reference_flag = 1;
> -		else
> -			slice_param->h264_dpb_info[index].reference_flag = 2;
> -
> -		vb = vq->bufs[vb2_index];
> -		vb2_v4l2 = container_of(vb, struct vb2_v4l2_buffer, vb2_buf);
> -		slice_param->h264_dpb_info[index].field = vb2_v4l2->field;
> -
> -		slice_param->h264_dpb_info[index].y_dma_addr =
> -			vb2_dma_contig_plane_dma_addr(vb, 0);
> -		if (inst->ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 2) {
> -			slice_param->h264_dpb_info[index].c_dma_addr =
> -				vb2_dma_contig_plane_dma_addr(vb, 1);
> -		}
> -	}
> -}
> -
> -static void get_h264_sps_parameters(struct mtk_h264_sps_param *dst_param,
> -				    const struct v4l2_ctrl_h264_sps *src_param)
> -{
> -	GET_MTK_VDEC_PARAM(chroma_format_idc);
> -	GET_MTK_VDEC_PARAM(bit_depth_luma_minus8);
> -	GET_MTK_VDEC_PARAM(bit_depth_chroma_minus8);
> -	GET_MTK_VDEC_PARAM(log2_max_frame_num_minus4);
> -	GET_MTK_VDEC_PARAM(pic_order_cnt_type);
> -	GET_MTK_VDEC_PARAM(log2_max_pic_order_cnt_lsb_minus4);
> -	GET_MTK_VDEC_PARAM(max_num_ref_frames);
> -	GET_MTK_VDEC_PARAM(pic_width_in_mbs_minus1);
> -	GET_MTK_VDEC_PARAM(pic_height_in_map_units_minus1);
> -
> -	GET_MTK_VDEC_FLAG(separate_colour_plane_flag,
> -			  V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE);
> -	GET_MTK_VDEC_FLAG(qpprime_y_zero_transform_bypass_flag,
> -			  V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS);
> -	GET_MTK_VDEC_FLAG(delta_pic_order_always_zero_flag,
> -			  V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO);
> -	GET_MTK_VDEC_FLAG(frame_mbs_only_flag,
> -			  V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY);
> -	GET_MTK_VDEC_FLAG(mb_adaptive_frame_field_flag,
> -			  V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD);
> -	GET_MTK_VDEC_FLAG(direct_8x8_inference_flag,
> -			  V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE);
> -}
> -
> -static void get_h264_pps_parameters(struct mtk_h264_pps_param *dst_param,
> -				    const struct v4l2_ctrl_h264_pps *src_param)
> +static int get_vdec_decode_parameters(struct vdec_h264_slice_inst *inst)
>  {
> -	GET_MTK_VDEC_PARAM(num_ref_idx_l0_default_active_minus1);
> -	GET_MTK_VDEC_PARAM(num_ref_idx_l1_default_active_minus1);
> -	GET_MTK_VDEC_PARAM(weighted_bipred_idc);
> -	GET_MTK_VDEC_PARAM(pic_init_qp_minus26);
> -	GET_MTK_VDEC_PARAM(chroma_qp_index_offset);
> -	GET_MTK_VDEC_PARAM(second_chroma_qp_index_offset);
> -
> -	GET_MTK_VDEC_FLAG(entropy_coding_mode_flag,
> -			  V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE);
> -	GET_MTK_VDEC_FLAG(pic_order_present_flag,
> -			  V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT);
> -	GET_MTK_VDEC_FLAG(weighted_pred_flag,
> -			  V4L2_H264_PPS_FLAG_WEIGHTED_PRED);
> -	GET_MTK_VDEC_FLAG(deblocking_filter_control_present_flag,
> -			  V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT);
> -	GET_MTK_VDEC_FLAG(constrained_intra_pred_flag,
> -			  V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED);
> -	GET_MTK_VDEC_FLAG(redundant_pic_cnt_present_flag,
> -			  V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT);
> -	GET_MTK_VDEC_FLAG(transform_8x8_mode_flag,
> -			  V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE);
> -	GET_MTK_VDEC_FLAG(scaling_matrix_present_flag,
> -			  V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT);
> -}
> -
> -static void
> -get_h264_scaling_matrix(struct slice_api_h264_scaling_matrix *dst_matrix,
> -			const struct v4l2_ctrl_h264_scaling_matrix *src_matrix)
> -{
> -	memcpy(dst_matrix->scaling_list_4x4, src_matrix->scaling_list_4x4,
> -	       sizeof(dst_matrix->scaling_list_4x4));
> -
> -	memcpy(dst_matrix->scaling_list_8x8, src_matrix->scaling_list_8x8,
> -	       sizeof(dst_matrix->scaling_list_8x8));
> -}
> -
> -static void
> -get_h264_decode_parameters(struct slice_api_h264_decode_param *dst_params,
> -			   const struct v4l2_ctrl_h264_decode_params *src_params,
> -			   const struct v4l2_h264_dpb_entry dpb[V4L2_H264_NUM_DPB_ENTRIES])
> -{
> -	int i;
> -
> -	for (i = 0; i < ARRAY_SIZE(dst_params->dpb); i++) {
> -		struct slice_h264_dpb_entry *dst_entry = &dst_params->dpb[i];
> -		const struct v4l2_h264_dpb_entry *src_entry = &dpb[i];
> -
> -		dst_entry->reference_ts = src_entry->reference_ts;
> -		dst_entry->frame_num = src_entry->frame_num;
> -		dst_entry->pic_num = src_entry->pic_num;
> -		dst_entry->top_field_order_cnt = src_entry->top_field_order_cnt;
> -		dst_entry->bottom_field_order_cnt =
> -			src_entry->bottom_field_order_cnt;
> -		dst_entry->flags = src_entry->flags;
> -	}
> -
> -	/*
> -	 * num_slices is a leftover from the old H.264 support and is ignored
> -	 * by the firmware.
> -	 */
> -	dst_params->num_slices = 0;
> -	dst_params->nal_ref_idc = src_params->nal_ref_idc;
> -	dst_params->top_field_order_cnt = src_params->top_field_order_cnt;
> -	dst_params->bottom_field_order_cnt = src_params->bottom_field_order_cnt;
> -	dst_params->flags = src_params->flags;
> -}
> -
> -static bool dpb_entry_match(const struct v4l2_h264_dpb_entry *a,
> -			    const struct v4l2_h264_dpb_entry *b)
> -{
> -	return a->top_field_order_cnt == b->top_field_order_cnt &&
> -	       a->bottom_field_order_cnt == b->bottom_field_order_cnt;
> -}
> -
> -/*
> - * Move DPB entries of dec_param that refer to a frame already existing in dpb
> - * into the already existing slot in dpb, and move other entries into new slots.
> - *
> - * This function is an adaptation of the similarly-named function in
> - * hantro_h264.c.
> - */
> -static void update_dpb(const struct v4l2_ctrl_h264_decode_params *dec_param,
> -		       struct v4l2_h264_dpb_entry *dpb)
> -{
> -	DECLARE_BITMAP(new, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> -	DECLARE_BITMAP(in_use, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> -	DECLARE_BITMAP(used, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> -	unsigned int i, j;
> -
> -	/* Disable all entries by default, and mark the ones in use. */
> -	for (i = 0; i < ARRAY_SIZE(dec_param->dpb); i++) {
> -		if (dpb[i].flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE)
> -			set_bit(i, in_use);
> -		dpb[i].flags &= ~V4L2_H264_DPB_ENTRY_FLAG_ACTIVE;
> -	}
> -
> -	/* Try to match new DPB entries with existing ones by their POCs. */
> -	for (i = 0; i < ARRAY_SIZE(dec_param->dpb); i++) {
> -		const struct v4l2_h264_dpb_entry *ndpb = &dec_param->dpb[i];
> -
> -		if (!(ndpb->flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE))
> -			continue;
> -
> -		/*
> -		 * To cut off some comparisons, iterate only on target DPB
> -		 * entries were already used.
> -		 */
> -		for_each_set_bit(j, in_use, ARRAY_SIZE(dec_param->dpb)) {
> -			struct v4l2_h264_dpb_entry *cdpb;
> -
> -			cdpb = &dpb[j];
> -			if (!dpb_entry_match(cdpb, ndpb))
> -				continue;
> -
> -			*cdpb = *ndpb;
> -			set_bit(j, used);
> -			/* Don't reiterate on this one. */
> -			clear_bit(j, in_use);
> -			break;
> -		}
> -
> -		if (j == ARRAY_SIZE(dec_param->dpb))
> -			set_bit(i, new);
> -	}
> -
> -	/* For entries that could not be matched, use remaining free slots. */
> -	for_each_set_bit(i, new, ARRAY_SIZE(dec_param->dpb)) {
> -		const struct v4l2_h264_dpb_entry *ndpb = &dec_param->dpb[i];
> -		struct v4l2_h264_dpb_entry *cdpb;
> -
> -		/*
> -		 * Both arrays are of the same sizes, so there is no way
> -		 * we can end up with no space in target array, unless
> -		 * something is buggy.
> -		 */
> -		j = find_first_zero_bit(used, ARRAY_SIZE(dec_param->dpb));
> -		if (WARN_ON(j >= ARRAY_SIZE(dec_param->dpb)))
> -			return;
> -
> -		cdpb = &dpb[j];
> -		*cdpb = *ndpb;
> -		set_bit(j, used);
> -	}
> -}
> -
> -/*
> - * The firmware expects unused reflist entries to have the value 0x20.
> - */
> -static void fixup_ref_list(u8 *ref_list, size_t num_valid)
> -{
> -	memset(&ref_list[num_valid], 0x20, 32 - num_valid);
> -}
> -
> -static void get_vdec_decode_parameters(struct vdec_h264_slice_inst *inst)
> -{
> -	const struct v4l2_ctrl_h264_decode_params *dec_params =
> -		get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);
> -	const struct v4l2_ctrl_h264_sps *sps =
> -		get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_SPS);
> -	const struct v4l2_ctrl_h264_pps *pps =
> -		get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_PPS);
> -	const struct v4l2_ctrl_h264_scaling_matrix *scaling_matrix =
> -		get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_SCALING_MATRIX);
> +	const struct v4l2_ctrl_h264_decode_params *dec_params;
> +	const struct v4l2_ctrl_h264_sps *sps;
> +	const struct v4l2_ctrl_h264_pps *pps;
> +	const struct v4l2_ctrl_h264_scaling_matrix *scaling_matrix;
>  	struct mtk_h264_dec_slice_param *slice_param = &inst->h264_slice_param;
>  	struct v4l2_h264_reflist_builder reflist_builder;
>  	u8 *p0_reflist = slice_param->decode_params.ref_pic_list_p0;
>  	u8 *b0_reflist = slice_param->decode_params.ref_pic_list_b0;
>  	u8 *b1_reflist = slice_param->decode_params.ref_pic_list_b1;
>  
> -	update_dpb(dec_params, inst->dpb);
> +	dec_params =
> +		mtk_vdec_h264_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);
> +	if (IS_ERR(dec_params))
> +		return PTR_ERR(dec_params);
> +
> +	sps = mtk_vdec_h264_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_SPS);
> +	if (IS_ERR(sps))
> +		return PTR_ERR(sps);
> +
> +	pps = mtk_vdec_h264_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_PPS);
> +	if (IS_ERR(pps))
> +		return PTR_ERR(pps);
>  
> -	get_h264_sps_parameters(&slice_param->sps, sps);
> -	get_h264_pps_parameters(&slice_param->pps, pps);
> -	get_h264_scaling_matrix(&slice_param->scaling_matrix, scaling_matrix);
> -	get_h264_decode_parameters(&slice_param->decode_params, dec_params,
> -				   inst->dpb);
> -	get_h264_dpb_list(inst, slice_param);
> +	scaling_matrix =
> +		mtk_vdec_h264_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_SCALING_MATRIX);
> +	if (IS_ERR(scaling_matrix))
> +		return PTR_ERR(scaling_matrix);
> +
> +	mtk_vdec_h264_update_dpb(dec_params, inst->dpb);
> +
> +	mtk_vdec_h264_copy_sps_params(&slice_param->sps, sps);
> +	mtk_vdec_h264_copy_pps_params(&slice_param->pps, pps);
> +	mtk_vdec_h264_copy_scaling_matrix(&slice_param->scaling_matrix, scaling_matrix);
> +	mtk_vdec_h264_copy_decode_params(&slice_param->decode_params,
> +					 dec_params, inst->dpb);
> +	mtk_vdec_h264_fill_dpb_info(inst->ctx, &slice_param->decode_params,
> +				    slice_param->h264_dpb_info);
>  
>  	/* Build the reference lists */
>  	v4l2_h264_init_reflist_builder(&reflist_builder, dec_params, sps,
> @@ -478,19 +140,14 @@ static void get_vdec_decode_parameters(struct vdec_h264_slice_inst *inst)
>  	v4l2_h264_build_p_ref_list(&reflist_builder, p0_reflist);
>  	v4l2_h264_build_b_ref_lists(&reflist_builder, b0_reflist, b1_reflist);
>  	/* Adapt the built lists to the firmware's expectations */
> -	fixup_ref_list(p0_reflist, reflist_builder.num_valid);
> -	fixup_ref_list(b0_reflist, reflist_builder.num_valid);
> -	fixup_ref_list(b1_reflist, reflist_builder.num_valid);
> +	mtk_vdec_h264_fixup_ref_list(p0_reflist, reflist_builder.num_valid);
> +	mtk_vdec_h264_fixup_ref_list(b0_reflist, reflist_builder.num_valid);
> +	mtk_vdec_h264_fixup_ref_list(b1_reflist, reflist_builder.num_valid);
>  
>  	memcpy(&inst->vsi_ctx.h264_slice_params, slice_param,
>  	       sizeof(inst->vsi_ctx.h264_slice_params));
> -}
>  
> -static unsigned int get_mv_buf_size(unsigned int width, unsigned int height)
> -{
> -	int unit_size = (width / MB_UNIT_LEN) * (height / MB_UNIT_LEN) + 8;
> -
> -	return HW_MB_STORE_SZ * unit_size;
> +	return 0;
>  }
>  
>  static int allocate_predication_buf(struct vdec_h264_slice_inst *inst)
> @@ -525,7 +182,7 @@ static int alloc_mv_buf(struct vdec_h264_slice_inst *inst,
>  	int i;
>  	int err;
>  	struct mtk_vcodec_mem *mem = NULL;
> -	unsigned int buf_sz = get_mv_buf_size(pic->buf_w, pic->buf_h);
> +	unsigned int buf_sz = mtk_vdec_h264_get_mv_buf_size(pic->buf_w, pic->buf_h);
>  
>  	mtk_v4l2_debug(3, "size = 0x%x", buf_sz);
>  	for (i = 0; i < H264_MAX_MV_NUM; i++) {
> @@ -674,7 +331,7 @@ static int vdec_h264_slice_decode(void *h_vdec, struct mtk_vcodec_mem *bs,
>  {
>  	struct vdec_h264_slice_inst *inst = h_vdec;
>  	const struct v4l2_ctrl_h264_decode_params *dec_params =
> -		get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);
> +		mtk_vdec_h264_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);
>  	struct vdec_vpu_inst *vpu = &inst->vpu;
>  	struct mtk_video_dec_buf *src_buf_info;
>  	struct mtk_video_dec_buf *dst_buf_info;
> @@ -706,7 +363,10 @@ static int vdec_h264_slice_decode(void *h_vdec, struct mtk_vcodec_mem *bs,
>  
>  	v4l2_m2m_buf_copy_metadata(&src_buf_info->m2m_buf.vb,
>  				   &dst_buf_info->m2m_buf.vb, true);
> -	get_vdec_decode_parameters(inst);
> +	err = get_vdec_decode_parameters(inst);
> +	if (err)
> +		goto err_free_fb_out;
> +
>  	data[0] = bs->size;
>  	/*
>  	 * Reconstruct the first byte of the NAL unit, as the firmware requests