mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Nas Chung <nas.chung@chipsnmedia.com>
To: mchehab@kernel.org, hverkuil@kernel.org, robh@kernel.org,
	krzk+dt@kernel.org, conor+dt@kernel.org, Frank.Li@nxp.com,
	s.hauer@pengutronix.de
Cc: linux-media@vger.kernel.org, devicetree@vger.kernel.org,
	linux-kernel@vger.kernel.org, imx@lists.linux.dev,
	linux-arm-kernel@lists.infradead.org, festevam@gmail.com,
	kernel@pengutronix.de, nicolas.dufresne@collabora.com,
	ming.qian@oss.nxp.com, marek.vasut@mailbox.org,
	jackson.lee@chipsnmedia.com, lafley.kim@chipsnmedia.com,
	Nas Chung <nas.chung@chipsnmedia.com>
Subject: [PATCH v8 06/11] media: chips-media: wave6: Add Wave6 encoder firmware interface
Date: Thu, 19 Nov 2026 18:00:00 +0900	[thread overview]
Message-ID: <85ce28c44e167aa05ffc19dc02ce2be26dd99893.1795075581.git.nas.chung@chipsnmedia.com> (raw)
In-Reply-To: <cover.1795075577.git.nas.chung@chipsnmedia.com>

Add an interface layer to manage hardware register configuration
and communication with the Chips&Media Wave6 video codec IP for
video encoding.

The interface provides low-level helper functions used by the
Wave6 core driver to implement video encoding operations.
It handles command submission to the firmware via MMIO registers,
and waits for a response by polling the firmware busy flag.

The encoder commands cover instance creation and destruction,
parameter setting and change, frame buffer registration, and picture
encoding.

Parameter setting and picture encoding complete asynchronously:
the interface interrupt reports completion and a query command reads
back the result.

Tested-by: Ming Qian <ming.qian@oss.nxp.com>
Tested-by: Marek Vasut <marek.vasut@mailbox.org>
Signed-off-by: Nas Chung <nas.chung@chipsnmedia.com>
---
 .../platform/chips-media/wave6/wave6-hw.c     | 940 +++++++++++++++++-
 .../platform/chips-media/wave6/wave6-hw.h     |   7 +
 .../chips-media/wave6/wave6-regdefine.h       | 312 ++++++
 .../chips-media/wave6/wave6-vpu-core.c        |   3 +-
 .../platform/chips-media/wave6/wave6-vpuapi.c | 131 +++
 .../platform/chips-media/wave6/wave6-vpuapi.h | 428 ++++++++
 .../chips-media/wave6/wave6-vpuconfig.h       |  14 +
 7 files changed, 1833 insertions(+), 2 deletions(-)

diff --git a/drivers/media/platform/chips-media/wave6/wave6-hw.c b/drivers/media/platform/chips-media/wave6/wave6-hw.c
index 872a540df021..171391f797cb 100644
--- a/drivers/media/platform/chips-media/wave6/wave6-hw.c
+++ b/drivers/media/platform/chips-media/wave6/wave6-hw.c
@@ -162,7 +162,9 @@ void wave6_vpu_enable_interrupt(struct vpu_core_device *core)
 
 	lockdep_assert_held(&core->hw_lock);
 
-	data = BIT(W6_INT_BIT_INIT_SEQ);
+	data = BIT(W6_INT_BIT_ENC_SET_PARAM);
+	data |= BIT(W6_INT_BIT_ENC_PIC);
+	data |= BIT(W6_INT_BIT_INIT_SEQ);
 	data |= BIT(W6_INT_BIT_DEC_PIC);
 	data |= BIT(W6_INT_BIT_BSBUF_ERROR);
 	data |= BIT(W6_INT_BIT_REQ_WORK_BUF);
@@ -932,3 +934,939 @@ int wave6_vpu_dec_flush_instance(struct vpu_instance *inst)
 
 	return 0;
 }
+
+struct enc_cmd_set_param_reg {
+	u32 enable;
+	u32 src_size;
+	u32 custom_map_endian;
+	u32 sps;
+	u32 pps;
+	u32 gop;
+	u32 intra;
+	u32 conf_win0;
+	u32 conf_win1;
+	u32 rdo;
+	u32 slice;
+	u32 intra_refresh;
+	u32 intra_qp;
+	u32 rc_frame_rate;
+	u32 rc_target_rate;
+	u32 rc;
+	u32 hvs;
+	u32 rc_max_bitrate;
+	u32 rc_vbv_buffer_size;
+	u32 inter_qp;
+	u32 rot;
+	u32 num_units_in_tick;
+	u32 time_scale;
+	u32 num_ticks_poc_diff_one;
+	u32 max_intra_pic_bit;
+	u32 max_inter_pic_bit;
+	u32 bg;
+	u32 non_vcl_param;
+	u32 vui_rbsp_addr;
+	u32 hrd_rbsp_addr;
+	u32 qround_offset;
+	u32 quant1;
+	u32 quant2;
+	u32 custom_gop;
+	u32 custom_gop_pic[MAX_CUSTOM_GOP_NUM];
+	u32 tile_param;
+	u32 custom_lambda[MAX_CUSTOM_LAMBDA_NUM];
+	u32 temp_layer_qp[MAX_NUM_CHANGEABLE_TEMP_LAYER];
+	u32 scaler_size;
+	u32 scaler;
+	u32 color;
+	u32 sar;
+	u32 sar_extended;
+};
+
+struct enc_cmd_change_param_reg {
+	u32 enable;
+	u32 rc_target_rate;
+};
+
+int wave6_vpu_build_up_enc_param(struct device *dev, struct vpu_instance *inst,
+				 struct enc_open_param *param)
+{
+	struct enc_info *p_enc_info = &inst->codec_info->enc_info;
+	u32 reg_val;
+	int ret;
+
+	lockdep_assert_held(&inst->dev->hw_lock);
+
+	p_enc_info->seq_info_obtained = false;
+	p_enc_info->sec_axi.use_enc_rdo = true;
+	p_enc_info->sec_axi.use_enc_lf = true;
+	p_enc_info->mir_dir = param->mir_dir;
+	p_enc_info->rot_angle = param->rot_angle;
+
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_CREATE_INST_TEMP_BASE,
+			      param->inst_buffer.temp_base);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_CREATE_INST_TEMP_SIZE,
+			      param->inst_buffer.temp_size);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_CREATE_INST_AR_TABLE_BASE,
+			      param->inst_buffer.ar_base);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_CREATE_INST_BS_PARAM, VPU_STREAM_ENDIAN);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_CREATE_INST_SRC_OPT, 0);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_CREATE_INST_ADDR_EXT, param->ext_addr_vcpu);
+
+	reg_val = CREATE_INST_CORE_INFO_CQ_DEPTH(COMMAND_QUEUE_DEPTH) |
+		  CREATE_INST_CORE_INFO_CORE_IDC(SINGLE_CORE_IDC) |
+		  CREATE_INST_CORE_INFO_CORE_NUM(SINGLE_CORE);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_CREATE_INST_CORE_INFO, reg_val);
+
+	reg_val = CREATE_INST_PRIORITY_SECURITY_FLAG(param->is_secure_inst) |
+		  CREATE_INST_PRIORITY_VALUE(param->inst_priority);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_CREATE_INST_PRIORITY, reg_val);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_CREATE_INST_TIMEOUT_CYCLE_COUNT,
+			      W6_VPU_TIMEOUT_CYCLE_COUNT);
+
+	wave6_send_command(inst->dev, 0, inst->std, W6_CMD_CREATE_INSTANCE);
+	ret = wave6_wait_vpu_busy(inst->dev, W6_VPU_BUSY_STATUS);
+	if (ret) {
+		dev_err(inst->dev->dev, "%s: timeout\n", __func__);
+		return ret;
+	}
+
+	if (!vpu_read_reg_relaxed(inst->dev, W6_RET_SUCCESS)) {
+		u32 reason_code = vpu_read_reg_relaxed(inst->dev, W6_RET_FAIL_REASON);
+
+		wave6_print_reg_err(inst->dev, reason_code);
+		return -EIO;
+	}
+
+	inst->id = vpu_read_reg_relaxed(inst->dev, W6_RET_INSTANCE_ID);
+
+	return 0;
+}
+
+static int wave6_set_enc_crop_info(u32 codec, struct enc_codec_param *param,
+				   u32 rot_mir, int width, int height)
+{
+	int aligned_height = (codec == W_HEVC_ENC) ? ALIGN(height, 32) : ALIGN(height, 16);
+	int aligned_width = (codec == W_HEVC_ENC) ? ALIGN(width, 32) : ALIGN(width, 16);
+	int crop_right, crop_left, crop_top, crop_bot;
+	int pad_right, pad_bot;
+
+	if (codec == W_HEVC_ENC &&
+	    (!rot_mir ||
+	     rot_mir == (SET_PARAM_ROT_MIRH | SET_PARAM_ROT_MIRV | SET_PARAM_ROT_180)))
+		return 0;
+
+	pad_right = aligned_width - width;
+	pad_bot = aligned_height - height;
+
+	if (param->conf_win.right > 0)
+		crop_right = param->conf_win.right + pad_right;
+	else
+		crop_right = pad_right;
+
+	if (param->conf_win.bottom > 0)
+		crop_bot = param->conf_win.bottom + pad_bot;
+	else
+		crop_bot = pad_bot;
+
+	crop_top = param->conf_win.top;
+	crop_left = param->conf_win.left;
+
+	if (rot_mir == SET_PARAM_ROT_90 ||
+	    rot_mir == (SET_PARAM_ROT_MIRH | SET_PARAM_ROT_MIRV | SET_PARAM_ROT_270)) {
+		param->conf_win.top = crop_right;
+		param->conf_win.left = crop_top;
+		param->conf_win.bottom = crop_left;
+		param->conf_win.right = crop_bot;
+	} else if (rot_mir == SET_PARAM_ROT_180 ||
+		   rot_mir == (SET_PARAM_ROT_MIRH | SET_PARAM_ROT_MIRV)) {
+		param->conf_win.top = crop_bot;
+		param->conf_win.left = crop_right;
+		param->conf_win.bottom = crop_top;
+		param->conf_win.right = crop_left;
+	} else if (rot_mir == SET_PARAM_ROT_270 ||
+		   rot_mir == (SET_PARAM_ROT_MIRH | SET_PARAM_ROT_MIRV | SET_PARAM_ROT_90)) {
+		param->conf_win.top = crop_left;
+		param->conf_win.left = crop_bot;
+		param->conf_win.bottom = crop_right;
+		param->conf_win.right = crop_top;
+	} else if (rot_mir == SET_PARAM_ROT_MIRV ||
+		   rot_mir == (SET_PARAM_ROT_MIRH | SET_PARAM_ROT_180)) {
+		param->conf_win.top = crop_bot;
+		param->conf_win.left = crop_left;
+		param->conf_win.bottom = crop_top;
+		param->conf_win.right = crop_right;
+	} else if (rot_mir == SET_PARAM_ROT_MIRH ||
+		   rot_mir == (SET_PARAM_ROT_MIRV | SET_PARAM_ROT_180)) {
+		param->conf_win.top = crop_top;
+		param->conf_win.left = crop_right;
+		param->conf_win.bottom = crop_bot;
+		param->conf_win.right = crop_left;
+	} else if (rot_mir == (SET_PARAM_ROT_MIRV | SET_PARAM_ROT_90) ||
+		   rot_mir == (SET_PARAM_ROT_MIRH | SET_PARAM_ROT_270)) {
+		param->conf_win.top = crop_left;
+		param->conf_win.left = crop_top;
+		param->conf_win.bottom = crop_right;
+		param->conf_win.right = crop_bot;
+	} else if (rot_mir == (SET_PARAM_ROT_MIRV | SET_PARAM_ROT_270) ||
+		   rot_mir == (SET_PARAM_ROT_MIRH | SET_PARAM_ROT_90)) {
+		param->conf_win.top = crop_right;
+		param->conf_win.left = crop_bot;
+		param->conf_win.bottom = crop_left;
+		param->conf_win.right = crop_top;
+	} else {
+		param->conf_win.top = crop_top;
+		param->conf_win.left = crop_left;
+		param->conf_win.bottom = crop_bot;
+		param->conf_win.right = crop_right;
+	}
+
+	return 0;
+}
+
+static void wave6_update_enc_info(struct enc_info *p_enc_info)
+{
+	struct enc_open_param op = p_enc_info->open_param;
+
+	p_enc_info->width = op.pic_width;
+	p_enc_info->height = op.pic_height;
+	p_enc_info->c_fmt_idc = get_chroma_format_idc(op.out_fmt);
+}
+
+static u32 wave6_enc_rot_mir(enum rotation_angle rot_angle,
+			     enum mirror_direction mir_dir)
+{
+	u32 rot_mir = 0;
+
+	switch (rot_angle) {
+	case ROT_0:
+		break;
+	case ROT_90:
+		rot_mir |= SET_PARAM_ROT_90;
+		break;
+	case ROT_180:
+		rot_mir |= SET_PARAM_ROT_180;
+		break;
+	case ROT_270:
+		rot_mir |= SET_PARAM_ROT_270;
+		break;
+	}
+
+	switch (mir_dir) {
+	case MIR_NONE:
+		break;
+	case MIR_VER:
+		rot_mir |= SET_PARAM_ROT_MIRV;
+		break;
+	case MIR_HOR:
+		rot_mir |= SET_PARAM_ROT_MIRH;
+		break;
+	case MIR_HOR_VER:
+		rot_mir |= SET_PARAM_ROT_MIRH | SET_PARAM_ROT_MIRV;
+		break;
+	}
+
+	return rot_mir;
+}
+
+static void wave6_gen_set_param_reg_common(struct enc_info *p_enc_info, enum codec_std std,
+					   struct enc_cmd_set_param_reg *reg)
+{
+	struct enc_open_param *p_open_param = &p_enc_info->open_param;
+	struct enc_codec_param *p_param = &p_open_param->codec_param;
+	u32 rot_mir;
+
+	rot_mir = wave6_enc_rot_mir(p_enc_info->rot_angle, p_enc_info->mir_dir);
+	wave6_set_enc_crop_info(std, p_param, rot_mir, p_enc_info->width, p_enc_info->height);
+
+	reg->custom_map_endian = VPU_USER_DATA_ENDIAN;
+	if (rot_mir)
+		reg->rot = rot_mir | SET_PARAM_ROT_ENABLE;
+	reg->src_size = SET_PARAM_SRC_SIZE_HEIGHT(p_enc_info->height) |
+			SET_PARAM_SRC_SIZE_WIDTH(p_enc_info->width);
+	reg->conf_win0 = SET_PARAM_CONF_WIN0_BOTTOM(p_param->conf_win.bottom) |
+			 SET_PARAM_CONF_WIN0_TOP(p_param->conf_win.top);
+	reg->conf_win1 = SET_PARAM_CONF_WIN1_RIGHT(p_param->conf_win.right) |
+			 SET_PARAM_CONF_WIN1_LEFT(p_param->conf_win.left);
+	reg->gop = SET_PARAM_GOP_TEMP_LAYER_CNT(p_param->temp_layer_cnt) |
+		   SET_PARAM_GOP_TEMP_LAYER3_QP_ENABLE(p_param->temp_layer[3].change_qp) |
+		   SET_PARAM_GOP_TEMP_LAYER2_QP_ENABLE(p_param->temp_layer[2].change_qp) |
+		   SET_PARAM_GOP_TEMP_LAYER1_QP_ENABLE(p_param->temp_layer[1].change_qp) |
+		   SET_PARAM_GOP_TEMP_LAYER0_QP_ENABLE(p_param->temp_layer[0].change_qp) |
+		   SET_PARAM_GOP_PRESET_IDX(p_param->gop_preset_idx);
+	for (int i = 0; i < MAX_NUM_CHANGEABLE_TEMP_LAYER; i++) {
+		reg->temp_layer_qp[i] = SET_PARAM_TEMP_LAYER_QP_B(p_param->temp_layer[i].qp_b) |
+					SET_PARAM_TEMP_LAYER_QP_P(p_param->temp_layer[i].qp_p) |
+					SET_PARAM_TEMP_LAYER_QP_I(p_param->temp_layer[i].qp_i);
+	}
+	reg->intra_refresh = SET_PARAM_INTRA_REFRESH_ARGUMENT(p_param->intra_refresh_arg) |
+			     SET_PARAM_INTRA_REFRESH_MODE(p_param->intra_refresh_mode);
+	reg->intra_qp = SET_PARAM_INTRA_QP_MAX(p_param->max_qp_i) |
+			SET_PARAM_INTRA_QP_MIN(p_param->min_qp_i);
+	reg->inter_qp = SET_PARAM_INTER_QP_MAX_B(p_param->max_qp_b) |
+			SET_PARAM_INTER_QP_MIN_B(p_param->min_qp_b) |
+			SET_PARAM_INTER_QP_MAX_P(p_param->max_qp_p) |
+			SET_PARAM_INTER_QP_MIN_P(p_param->min_qp_p);
+	reg->rc_frame_rate = p_param->frame_rate;
+	reg->rc_target_rate = p_param->bitrate;
+	reg->rc_max_bitrate = p_param->max_bitrate;
+	reg->rc_vbv_buffer_size = p_param->cpb_size;
+	reg->rc = SET_PARAM_RC_UPDATE_SPEED(p_param->rc_update_speed) |
+		  SET_PARAM_RC_INITIAL_LEVEL(p_param->rc_initial_level) |
+		  SET_PARAM_RC_INITIAL_QP(p_param->rc_initial_qp) |
+		  SET_PARAM_RC_MODE(p_param->rc_mode) |
+		  SET_PARAM_RC_PIC_LEVEL_MAX_DELTA_QP(p_param->pic_rc_max_dqp) |
+		  SET_PARAM_RC_VBV_OVERFLOW_DROP_FRAME(p_param->en_skip_frame) |
+		  SET_PARAM_RC_CU_LEVEL_ENABLE(p_param->en_cu_level_rate_control) |
+		  SET_PARAM_RC_ENABLE(p_param->en_rate_control);
+	reg->hvs = SET_PARAM_HVS_MAX_DELTA_QP(p_param->max_delta_qp) |
+		   SET_PARAM_HVS_QP_SCALE(p_param->hvs_qp_scale_div2);
+	reg->num_units_in_tick = p_param->num_units_in_tick;
+	reg->time_scale = p_param->time_scale;
+	reg->num_ticks_poc_diff_one = p_param->num_ticks_poc_diff_one;
+	reg->max_intra_pic_bit = p_param->max_intra_pic_bit;
+	reg->max_inter_pic_bit = p_param->max_inter_pic_bit;
+	reg->bg = SET_PARAM_BG_DELTA_QP(p_param->bg_delta_qp) |
+		  SET_PARAM_BG_THRESHOLD_MEAN_DIFF(p_param->bg_th_mean_diff) |
+		  SET_PARAM_BG_THRESHOLD_MAX_DIFF(p_param->bg_th_diff) |
+		  SET_PARAM_BG_ENABLE(p_param->en_bg_detect);
+	reg->qround_offset = SET_PARAM_QROUND_OFFSET_INTER(p_param->qround_inter) |
+			     SET_PARAM_QROUND_OFFSET_INTRA(p_param->qround_intra);
+	reg->custom_gop = p_param->gop_param.size;
+	for (int i = 0; i < p_param->gop_param.size; i++) {
+		struct custom_gop_pic_param pic = p_param->gop_param.pic[i];
+
+		reg->custom_gop_pic[i] = SET_PARAM_CUSTOM_GOP_PIC_TEMP_ID(pic.temporal_id) |
+					 SET_PARAM_CUSTOM_GOP_PIC_REF1_POC(pic.ref_poc_l1) |
+					 SET_PARAM_CUSTOM_GOP_PIC_REF0_POC(pic.ref_poc_l0) |
+					 SET_PARAM_CUSTOM_GOP_PIC_MULTI_REF_P(pic.multi_ref_p) |
+					 SET_PARAM_CUSTOM_GOP_PIC_QP(pic.pic_qp) |
+					 SET_PARAM_CUSTOM_GOP_PIC_POC_OFFSET(pic.poc_offset) |
+					 SET_PARAM_CUSTOM_GOP_PIC_TYPE(pic.pic_type);
+	}
+	for (int i = 0; i < MAX_CUSTOM_LAMBDA_NUM; i++) {
+		reg->custom_lambda[i] = SET_PARAM_CUSTOM_LAMBDA_SSD(p_param->lambda_ssd[i]) |
+					SET_PARAM_CUSTOM_LAMBDA_SAD(p_param->lambda_sad[i]);
+	}
+	reg->scaler_size = SET_PARAM_SCALER_SIZE_HEIGHT(p_enc_info->height) |
+			   SET_PARAM_SCALER_SIZE_WIDTH(p_enc_info->width);
+	reg->scaler = SET_PARAM_SCALER_COEF_MODE(p_enc_info->scaler.coef_mode) |
+		      SET_PARAM_SCALER_ENABLE(p_enc_info->scaler.enable);
+	reg->color = SET_PARAM_COLOR_RANGE(p_param->color.color_range) |
+		     SET_PARAM_COLOR_MATRIX_COEFF(p_param->color.matrix_coefficients) |
+		     SET_PARAM_COLOR_TRANS_CHAR(p_param->color.transfer_characteristics) |
+		     SET_PARAM_COLOR_PRIMARIES(p_param->color.color_primaries) |
+		     SET_PARAM_COLOR_DESCRIPTION_PRESENT_ON;
+	reg->sar = SET_PARAM_SAR_ASPECT_RATIO_IDC(p_param->sar.idc) |
+		   SET_PARAM_SAR_ASPECT_RATIO_ENABLE(p_param->sar.enable);
+	reg->sar_extended = SET_PARAM_SAR_EXTENDED_HEIGHT(p_param->sar.height) |
+			    SET_PARAM_SAR_EXTENDED_WIDTH(p_param->sar.width);
+}
+
+static void wave6_gen_set_param_reg_hevc(struct enc_info *p_enc_info,
+					 struct enc_cmd_set_param_reg *reg)
+{
+	struct enc_open_param *p_open_param = &p_enc_info->open_param;
+	struct enc_codec_param *p_param = &p_open_param->codec_param;
+
+	reg->sps = SET_PARAM_SPS_DEFAULT_SCALING_LIST(p_param->en_scaling_list) |
+		   SET_PARAM_SPS_STILL_PICTURE(p_param->en_still_picture) |
+		   SET_PARAM_SPS_AUTO_LEVEL_ADJUSTING_ON |
+		   SET_PARAM_SPS_STRONG_INTRA_SMOOTHING(p_param->en_intra_smooth) |
+		   SET_PARAM_SPS_INTRA_TRANSFORM_SKIP_ON |
+		   SET_PARAM_SPS_SAMPLE_ADAPTIVE_OFFSET(p_param->en_sao) |
+		   SET_PARAM_SPS_TEMPORAL_MVP(p_param->en_temporal_mvp) |
+		   SET_PARAM_SPS_LONGTERM_REFERENCE(p_param->en_longterm) |
+		   SET_PARAM_SPS_C_FMT_IDC(p_enc_info->c_fmt_idc) |
+		   SET_PARAM_SPS_BIT_DEPTH(p_param->internal_bit_depth) |
+		   SET_PARAM_SPS_TIER(p_param->tier) |
+		   SET_PARAM_SPS_LEVEL(p_param->level) |
+		   SET_PARAM_SPS_PROFILE(p_param->profile);
+	reg->pps = SET_PARAM_PPS_CR_QP_OFFSET(p_param->cr_qp_offset) |
+		   SET_PARAM_PPS_CB_QP_OFFSET(p_param->cb_qp_offset) |
+		   SET_PARAM_PPS_TC_OFFSET_DIV2(p_param->tc_offset_div2) |
+		   SET_PARAM_PPS_BETA_OFFSET_DIV2(p_param->beta_offset_div2) |
+		   SET_PARAM_PPS_DEBLOCKING_FILTER(!p_param->en_dbk) |
+		   SET_PARAM_PPS_LF_SLICE_BOUNDARY(p_param->en_lf_slice_boundary) |
+		   SET_PARAM_PPS_CONST_INTRA_PREDICTION(p_param->en_const_intra_pred);
+	reg->intra = SET_PARAM_INTRA_PERIOD(p_param->intra_period) |
+		     SET_PARAM_INTRA_HEADER_MODE(p_param->forced_idr_header) |
+		     SET_PARAM_INTRA_QP(p_param->qp) |
+		     SET_PARAM_INTRA_REFRESH_TYPE(p_param->decoding_refresh_type);
+	reg->rdo = SET_PARAM_RDO_CUSTOM_LAMBDA(p_param->en_custom_lambda) |
+		   SET_PARAM_RDO_ME_SEARCH_CENTER_ON |
+		   SET_PARAM_RDO_QROUND_OFFSET(p_param->en_qround_offset) |
+		   SET_PARAM_RDO_ADAPTIVE_ROUND_ON |
+		   SET_PARAM_RDO_HVS_QP(p_param->en_hvs_qp);
+	reg->slice = SET_PARAM_SLICE_ARGUMENT(p_param->slice_arg) |
+		     SET_PARAM_SLICE_MODE(p_param->slice_mode);
+	reg->quant2 = SET_PARAM_QUANT2_LAMBDA_DQP_INTER(p_param->lambda_dqp_inter) |
+		      SET_PARAM_QUANT2_LAMBDA_DQP_INTRA(p_param->lambda_dqp_intra);
+	reg->non_vcl_param = SET_PARAM_NON_VCL_PARAM_ENCODE_VUI;
+}
+
+static void wave6_gen_set_param_reg_avc(struct enc_info *p_enc_info,
+					struct enc_cmd_set_param_reg *reg)
+{
+	struct enc_open_param *p_open_param = &p_enc_info->open_param;
+	struct enc_codec_param *p_param = &p_open_param->codec_param;
+
+	reg->sps = SET_PARAM_SPS_DEFAULT_SCALING_LIST(p_param->en_scaling_list) |
+		   SET_PARAM_SPS_AUTO_LEVEL_ADJUSTING_ON |
+		   SET_PARAM_SPS_LONGTERM_REFERENCE(p_param->en_longterm) |
+		   SET_PARAM_SPS_C_FMT_IDC(p_enc_info->c_fmt_idc) |
+		   SET_PARAM_SPS_BIT_DEPTH(p_param->internal_bit_depth) |
+		   SET_PARAM_SPS_LEVEL(p_param->level) |
+		   SET_PARAM_SPS_PROFILE(p_param->profile);
+	reg->pps = SET_PARAM_PPS_ENTROPY_CODING_MODE(p_param->en_cabac) |
+		   SET_PARAM_PPS_TRANSFORM8X8(p_param->en_transform8x8) |
+		   SET_PARAM_PPS_CR_QP_OFFSET(p_param->cr_qp_offset) |
+		   SET_PARAM_PPS_CB_QP_OFFSET(p_param->cb_qp_offset) |
+		   SET_PARAM_PPS_TC_OFFSET_DIV2(p_param->tc_offset_div2) |
+		   SET_PARAM_PPS_BETA_OFFSET_DIV2(p_param->beta_offset_div2) |
+		   SET_PARAM_PPS_DEBLOCKING_FILTER(!p_param->en_dbk) |
+		   SET_PARAM_PPS_LF_SLICE_BOUNDARY(p_param->en_lf_slice_boundary) |
+		   SET_PARAM_PPS_CONST_INTRA_PREDICTION(p_param->en_const_intra_pred);
+	reg->intra = SET_PARAM_INTRA_HEADER_MODE_AVC(p_param->forced_idr_header) |
+		     SET_PARAM_INTRA_IDR_PERIOD_AVC(p_param->idr_period) |
+		     SET_PARAM_INTRA_PERIOD_AVC(p_param->intra_period) |
+		     SET_PARAM_INTRA_QP_AVC(p_param->qp);
+	reg->rdo = SET_PARAM_RDO_CUSTOM_LAMBDA(p_param->en_custom_lambda) |
+		   SET_PARAM_RDO_QROUND_OFFSET(p_param->en_qround_offset) |
+		   SET_PARAM_RDO_ADAPTIVE_ROUND_ON |
+		   SET_PARAM_RDO_HVS_QP(p_param->en_hvs_qp);
+	reg->slice = SET_PARAM_SLICE_ARGUMENT(p_param->slice_arg) |
+		     SET_PARAM_SLICE_MODE(p_param->slice_mode);
+	reg->quant2 = SET_PARAM_QUANT2_LAMBDA_DQP_INTER(p_param->lambda_dqp_inter) |
+		      SET_PARAM_QUANT2_LAMBDA_DQP_INTRA(p_param->lambda_dqp_intra);
+	reg->non_vcl_param = SET_PARAM_NON_VCL_PARAM_ENCODE_VUI;
+}
+
+static void wave6_gen_change_param_reg_common(struct vpu_instance *inst,
+					      struct enc_info *p_enc_info,
+					      struct enc_cmd_change_param_reg *reg)
+{
+	if (p_enc_info->open_param.codec_param.bitrate != inst->enc_ctrls.bitrate) {
+		reg->enable |= SET_PARAM_ENABLE_RC_TARGET_RATE;
+		reg->rc_target_rate = inst->enc_ctrls.bitrate;
+		p_enc_info->open_param.codec_param.bitrate = inst->enc_ctrls.bitrate;
+	}
+}
+
+int wave6_vpu_enc_issue_seq_init(struct vpu_instance *inst)
+{
+	struct enc_cmd_set_param_reg reg = {};
+	struct enc_info *p_enc_info;
+	int ret;
+
+	guard(mutex)(&inst->dev->hw_lock);
+
+	p_enc_info = &inst->codec_info->enc_info;
+
+	wave6_update_enc_info(p_enc_info);
+
+	wave6_gen_set_param_reg_common(p_enc_info, inst->std, &reg);
+	if (inst->std == W_HEVC_ENC)
+		wave6_gen_set_param_reg_hevc(p_enc_info, &reg);
+	else if (inst->std == W_AVC_ENC)
+		wave6_gen_set_param_reg_avc(p_enc_info, &reg);
+
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_OPTION, W6_SET_PARAM_OPT_COMMON);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_ENABLE, reg.enable);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_SRC_SIZE, reg.src_size);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_CUSTOM_MAP_ENDIAN,
+			      reg.custom_map_endian);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_SPS, reg.sps);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_PPS, reg.pps);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_GOP, reg.gop);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_INTRA, reg.intra);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_CONF_WIN0, reg.conf_win0);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_CONF_WIN1, reg.conf_win1);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_RDO, reg.rdo);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_SLICE, reg.slice);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_INTRA_REFRESH, reg.intra_refresh);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_INTRA_QP, reg.intra_qp);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_RC_FRAME_RATE, reg.rc_frame_rate);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_RC_TARGET_RATE, reg.rc_target_rate);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_RC, reg.rc);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_HVS, reg.hvs);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_RC_MAX_BITRATE, reg.rc_max_bitrate);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_RC_VBV_BUFFER_SIZE,
+			      reg.rc_vbv_buffer_size);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_INTER_QP, reg.inter_qp);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_ROT, reg.rot);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_NUM_UNITS_IN_TICK,
+			      reg.num_units_in_tick);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_TIME_SCALE, reg.time_scale);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_NUM_TICKS_POC_DIFF_ONE,
+			      reg.num_ticks_poc_diff_one);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_MAX_INTRA_PIC_BIT,
+			      reg.max_intra_pic_bit);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_MAX_INTER_PIC_BIT,
+			      reg.max_inter_pic_bit);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_BG, reg.bg);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_NON_VCL_PARAM, reg.non_vcl_param);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_VUI_RBSP_ADDR, reg.vui_rbsp_addr);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_HRD_RBSP_ADDR, reg.hrd_rbsp_addr);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_QROUND_OFFSET, reg.qround_offset);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_QUANT1, reg.quant1);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_QUANT2, reg.quant2);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_CUSTOM_GOP, reg.custom_gop);
+	for (int i = 0; i < MAX_CUSTOM_GOP_NUM; i++)
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_CUSTOM_GOP_PIC(i),
+				      reg.custom_gop_pic[i]);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_TILE_PARAM, reg.tile_param);
+	for (int i = 0; i < MAX_CUSTOM_LAMBDA_NUM; i++)
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_CUSTOM_LAMBDA(i),
+				      reg.custom_lambda[i]);
+	for (int i = 0; i < MAX_NUM_CHANGEABLE_TEMP_LAYER; i++)
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_TEMP_LAYER_QP(i),
+				      reg.temp_layer_qp[i]);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_SCALER_SIZE, reg.scaler_size);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_SCALER, reg.scaler);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_COLOR, reg.color);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_SAR, reg.sar);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_SAR_EXTENDED, reg.sar_extended);
+
+	wave6_send_command(inst->dev, inst->id, inst->std, W6_CMD_ENC_SET_PARAM);
+	ret = wave6_wait_vpu_busy(inst->dev, W6_VPU_BUSY_STATUS);
+	if (ret) {
+		dev_err(inst->dev->dev, "%s: timeout\n", __func__);
+		return ret;
+	}
+
+	if (!vpu_read_reg_relaxed(inst->dev, W6_RET_SUCCESS)) {
+		u32 reason_code = vpu_read_reg_relaxed(inst->dev, W6_RET_FAIL_REASON);
+
+		wave6_print_reg_err(inst->dev, reason_code);
+		return -EIO;
+	}
+
+	return 0;
+}
+
+int wave6_vpu_enc_get_seq_info(struct vpu_instance *inst, struct enc_seq_info *info)
+{
+	int ret;
+
+	lockdep_assert_held(&inst->dev->hw_lock);
+
+	ret = wave6_send_query(inst->dev, inst->id, inst->std, W6_QUERY_OPT_GET_RESULT);
+	if (ret)
+		return ret;
+
+	if (vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_ENCODING_SUCCESS) != 1) {
+		info->err_reason = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_ERR_INFO);
+		ret = -EIO;
+	} else {
+		info->warn_info = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_WARN_INFO);
+	}
+
+	info->min_frame_buffer_count = vpu_read_reg_relaxed(inst->dev,
+							    W6_RET_ENC_NUM_REQUIRED_FBC_FB);
+	info->min_src_frame_count = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_MIN_SRC_BUF_NUM);
+	info->max_latency_pictures = vpu_read_reg_relaxed(inst->dev,
+							  W6_RET_ENC_PIC_MAX_LATENCY_PICTURES);
+	info->req_mv_buffer_count = vpu_read_reg_relaxed(inst->dev,
+							 W6_RET_ENC_NUM_REQUIRED_COL_BUF);
+
+	return ret;
+}
+
+int wave6_vpu_enc_issue_seq_change(struct vpu_instance *inst, bool *changed)
+{
+	struct enc_cmd_change_param_reg reg = {};
+	struct enc_info *p_enc_info;
+	int ret;
+
+	guard(mutex)(&inst->dev->hw_lock);
+
+	p_enc_info = &inst->codec_info->enc_info;
+
+	wave6_gen_change_param_reg_common(inst, p_enc_info, &reg);
+
+	if (!reg.enable)
+		return 0;
+
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_OPTION,
+			      W6_SET_PARAM_OPT_CHANGE_PARAM);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_ENABLE, reg.enable);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_SET_PARAM_RC_TARGET_RATE, reg.rc_target_rate);
+
+	wave6_send_command(inst->dev, inst->id, inst->std, W6_CMD_ENC_SET_PARAM);
+	ret = wave6_wait_vpu_busy(inst->dev, W6_VPU_BUSY_STATUS);
+	if (ret) {
+		dev_warn(inst->dev->dev, "enc set param timed out\n");
+		return ret;
+	}
+
+	if (!vpu_read_reg_relaxed(inst->dev, W6_RET_SUCCESS)) {
+		u32 reason_code = vpu_read_reg_relaxed(inst->dev, W6_RET_FAIL_REASON);
+
+		wave6_print_reg_err(inst->dev, reason_code);
+		return -EIO;
+	}
+
+	*changed = true;
+
+	return 0;
+}
+
+int wave6_vpu_enc_register_frame_buffer(struct vpu_instance *inst)
+{
+	struct enc_info *p_enc_info;
+	struct frame_buffer *fb_arr;
+	dma_addr_t fbc_cr_tbl_addr;
+	u32 fbc_count, mv_count;
+	int ret;
+
+	guard(mutex)(&inst->dev->hw_lock);
+
+	p_enc_info = &inst->codec_info->enc_info;
+
+	fb_arr = &inst->frame_buf[0];
+	fbc_count = p_enc_info->seq_info.min_frame_buffer_count;
+	mv_count = p_enc_info->seq_info.req_mv_buffer_count;
+	if (!fbc_count || fbc_count > MAX_SET_FB_GROUP_SIZE ||
+	    !mv_count || mv_count > MAX_SET_FB_GROUP_SIZE)
+		return -EINVAL;
+
+	if (!wave6_check_aux_vbuf(inst, AUX_BUF_FBC_Y_TBL, fbc_count) ||
+	    !wave6_check_aux_vbuf(inst, AUX_BUF_FBC_C_TBL, fbc_count) ||
+	    !wave6_check_aux_vbuf(inst, AUX_BUF_SUB_SAMPLE, fbc_count) ||
+	    !wave6_check_aux_vbuf(inst, AUX_BUF_MV_COL, mv_count))
+		return -EINVAL;
+
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_OPTION,
+			      SET_FB_OPTION_END | SET_FB_OPTION_START);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_PIC_INFO,
+			      SET_FB_PIC_INFO_STRIDE(fb_arr[0].stride));
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_PIC_SIZE,
+			      SET_FB_PIC_SIZE_WIDTH(fb_arr[0].stride) |
+			      SET_FB_PIC_SIZE_HEIGHT(fb_arr[0].height));
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_NUM,
+			      SET_FB_NUM_FBC_END_IDX(fbc_count - 1) |
+			      SET_FB_NUM_MV_COL_END_IDX(mv_count - 1));
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_FBC_STRIDE,
+			      SET_FB_FBC_STRIDE_L(fb_arr[0].stride) |
+			      SET_FB_FBC_STRIDE_C(fb_arr[0].stride_c));
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_DEFAULT_CDF, 0);
+
+	for (u32 idx = 0; idx < fbc_count; idx++) {
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_FBC_Y(idx), fb_arr[idx].buf_y);
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_FBC_C(idx), fb_arr[idx].buf_cb);
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_FBC_CR(idx), fb_arr[idx].buf_cr);
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_FBC_Y_OFFSET(idx),
+				      inst->aux_vbuf[AUX_BUF_FBC_Y_TBL][idx].daddr);
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_FBC_C_OFFSET(idx),
+				      inst->aux_vbuf[AUX_BUF_FBC_C_TBL][idx].daddr);
+		fbc_cr_tbl_addr = inst->aux_vbuf[AUX_BUF_FBC_C_TBL][idx].daddr +
+				  (inst->aux_vbuf[AUX_BUF_FBC_C_TBL][idx].size >> 1);
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_FBC_CR_OFFSET(idx),
+				      fbc_cr_tbl_addr);
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_SUB_SAMPLED(idx),
+				      inst->aux_vbuf[AUX_BUF_SUB_SAMPLE][idx].daddr);
+	}
+	for (u32 idx = 0; idx < mv_count; idx++)
+		vpu_write_reg_relaxed(inst->dev, W6_CMD_SET_FB_MV_COL(idx),
+				      inst->aux_vbuf[AUX_BUF_MV_COL][idx].daddr);
+
+	wave6_send_command(inst->dev, inst->id, inst->std, W6_CMD_SET_FB);
+	ret = wave6_wait_vpu_busy(inst->dev, W6_VPU_BUSY_STATUS);
+	if (ret) {
+		dev_err(inst->dev->dev, "%s: timeout\n", __func__);
+		return ret;
+	}
+
+	if (!vpu_read_reg_relaxed(inst->dev, W6_RET_SUCCESS))
+		return -EIO;
+
+	return 0;
+}
+
+struct enc_cmd_enc_pic_reg {
+	u32 bs_start;
+	u32 bs_size;
+	u32 bs_option;
+	u32 sec_axi;
+	u32 report;
+	u32 mv_histo0;
+	u32 mv_histo1;
+	u32 custom_map_param;
+	u32 custom_map_addr;
+	u32 src_pic_idx;
+	u32 src_addr_y;
+	u32 src_addr_u;
+	u32 src_addr_v;
+	u32 src_stride;
+	u32 src_fmt;
+	u32 src_axi_sel;
+	u32 code_option;
+	u32 param;
+	u32 longterm_pic;
+	u32 prefix_sei_nal_addr;
+	u32 prefix_sei_info;
+	u32 suffix_sei_nal_addr;
+	u32 suffix_sei_info;
+	u32 timestamp_low;
+	u32 timestamp_high;
+	u32 csc_coeff[MAX_CSC_COEFF_NUM];
+};
+
+static u32 wave6_enc_src_fmt(enum frame_buffer_format fmt)
+{
+	bool is_csc_format = false;
+	bool is_packed = false;
+	bool is_24bit = false;
+	bool is_10bit = false;
+	bool is_ayuv = false;
+
+	switch (fmt) {
+	case FORMAT_YUYV:
+		is_packed = true;
+		break;
+	case FORMAT_420_P10_16BIT_MSB:
+		is_10bit = true;
+		break;
+	case FORMAT_RGB_24BIT_PACKED:
+		is_24bit = true;
+		is_csc_format = true;
+		break;
+	case FORMAT_RGB_32BIT_PACKED:
+		is_csc_format = true;
+		break;
+	case FORMAT_RGB_P10_32BIT_PACKED:
+		is_csc_format = true;
+		is_10bit = true;
+		break;
+	case FORMAT_YUV444_24BIT_PACKED:
+		is_24bit = true;
+		is_ayuv = true;
+		is_csc_format = true;
+		break;
+	case FORMAT_YUV444_24BIT:
+		is_ayuv = true;
+		break;
+	default:
+		break;
+	}
+
+	return ENC_PIC_SRC_FMT_C_FMT_IDC(get_chroma_format_idc(fmt)) |
+	       ENC_PIC_SRC_FMT_CSC_24BIT(is_24bit) |
+	       ENC_PIC_SRC_FMT_CSC_AYUV(is_ayuv) |
+	       ENC_PIC_SRC_FMT_CSC_ENABLE(is_csc_format) |
+	       ENC_PIC_SRC_FMT_10BIT_ENABLE(is_10bit) |
+	       ENC_PIC_SRC_FMT_YUV422_PACKED(is_packed);
+}
+
+static void wave6_gen_enc_pic_reg(struct enc_info *p_enc_info, bool cbcr_interleave, bool nv21,
+				  struct enc_param *opt, struct enc_cmd_enc_pic_reg *reg)
+{
+	struct enc_open_param open = p_enc_info->open_param;
+	struct enc_codec_param param = open.codec_param;
+	u32 stride_c = opt->source_frame->stride_c;
+	u32 c_fmt_idc;
+
+	c_fmt_idc = get_chroma_format_idc(open.src_fmt);
+	if ((c_fmt_idc == C_FMT_IDC_YUV422 || c_fmt_idc == C_FMT_IDC_YUV444) &&
+	    p_enc_info->c_fmt_idc == C_FMT_IDC_YUV420)
+		stride_c *= 2;
+
+	reg->src_fmt = wave6_enc_src_fmt(open.src_fmt) |
+		       ENC_PIC_SRC_FMT_CSC_FMT_ORDER(opt->csc.fmt_order) |
+		       ENC_PIC_SRC_FMT_ENDIAN(open.source_endian) |
+		       ENC_PIC_SRC_FMT_CBCR_ORDER(nv21) |
+		       ENC_PIC_SRC_FMT_2PLANE(cbcr_interleave);
+	reg->bs_start = opt->pic_stream_buffer_addr;
+	reg->bs_size = opt->pic_stream_buffer_size;
+	reg->sec_axi = ENC_PIC_SEC_AXI_RDO_ENABLE(p_enc_info->sec_axi.use_enc_rdo) |
+		       ENC_PIC_SEC_AXI_LF_ENABLE(p_enc_info->sec_axi.use_enc_lf);
+	reg->report = ENC_PIC_REPORT_MV_HISTO_ENABLE(param.en_report_mv_histo);
+	reg->mv_histo0 = ENC_PIC_MV_HISTO0_THRESHOLD0(param.mv_histo_th0) |
+			 ENC_PIC_MV_HISTO0_THRESHOLD1(param.mv_histo_th1);
+	reg->mv_histo1 = ENC_PIC_MV_HISTO1_THRESHOLD2(param.mv_histo_th2) |
+			 ENC_PIC_MV_HISTO1_THRESHOLD3(param.mv_histo_th3);
+	reg->src_pic_idx = opt->src_idx;
+	reg->src_addr_y = opt->source_frame->buf_y;
+	reg->src_addr_u = opt->source_frame->buf_cb;
+	reg->src_addr_v = opt->source_frame->buf_cr;
+	reg->src_stride = ENC_PIC_SRC_STRIDE_L(opt->source_frame->stride) |
+			  ENC_PIC_SRC_STRIDE_C(stride_c);
+	reg->src_axi_sel = ENC_PIC_SRC_AXI_SEL_PRP_PORT;
+	reg->code_option = ENC_PIC_CODE_OPTION_ENCODE_VCL |
+			   ENC_PIC_CODE_OPTION_ENCODE_HEADER;
+	reg->param = ENC_PIC_PARAM_INTRA_4X4(param.intra_4x4) |
+		     ENC_PIC_PARAM_FORCE_PIC_TYPE(opt->force_pic_type) |
+		     ENC_PIC_PARAM_FORCE_PIC_TYPE_ENABLE(opt->force_pic) |
+		     ENC_PIC_PARAM_FORCE_PIC_QP_B(opt->force_pic_qp_b) |
+		     ENC_PIC_PARAM_FORCE_PIC_QP_P(opt->force_pic_qp_p) |
+		     ENC_PIC_PARAM_FORCE_PIC_QP_I(opt->force_pic_qp_i) |
+		     ENC_PIC_PARAM_FORCE_PIC_QP_ENABLE(opt->force_pic_qp) |
+		     ENC_PIC_PARAM_PIC_SKIP_FLAG(opt->skip_picture);
+	reg->timestamp_low = lower_32_bits(opt->timestamp);
+	reg->timestamp_high = upper_32_bits(opt->timestamp);
+	reg->csc_coeff[0] = ENC_PIC_CSC_COEFF0_RY(opt->csc.coef_ry) |
+			    ENC_PIC_CSC_COEFF0_GY(opt->csc.coef_gy) |
+			    ENC_PIC_CSC_COEFF0_BY(opt->csc.coef_by);
+	reg->csc_coeff[1] = ENC_PIC_CSC_COEFF1_RCB(opt->csc.coef_rcb) |
+			    ENC_PIC_CSC_COEFF1_GCB(opt->csc.coef_gcb) |
+			    ENC_PIC_CSC_COEFF1_BCB(opt->csc.coef_bcb);
+	reg->csc_coeff[2] = ENC_PIC_CSC_COEFF2_RCR(opt->csc.coef_rcr) |
+			    ENC_PIC_CSC_COEFF2_GCR(opt->csc.coef_gcr) |
+			    ENC_PIC_CSC_COEFF2_BCR(opt->csc.coef_bcr);
+	reg->csc_coeff[3] = ENC_PIC_CSC_COEFF3_OFFSET_Y(opt->csc.offset_y) |
+			    ENC_PIC_CSC_COEFF3_OFFSET_CB(opt->csc.offset_cb) |
+			    ENC_PIC_CSC_COEFF3_OFFSET_CR(opt->csc.offset_cr);
+}
+
+int wave6_vpu_enc_start_one_frame(struct vpu_instance *inst, struct enc_param *param,
+				  u32 *fail_res)
+{
+	struct enc_cmd_enc_pic_reg reg = {};
+	struct enc_info *p_enc_info;
+	int ret;
+
+	guard(mutex)(&inst->dev->hw_lock);
+
+	p_enc_info = &inst->codec_info->enc_info;
+
+	wave6_gen_enc_pic_reg(p_enc_info, inst->cbcr_interleave,
+			      inst->nv21, param, &reg);
+
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_BS_START, reg.bs_start);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_BS_SIZE, reg.bs_size);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_BS_OPTION, reg.bs_option);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_SEC_AXI, reg.sec_axi);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_REPORT, reg.report);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_MV_HISTO0, reg.mv_histo0);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_MV_HISTO1, reg.mv_histo1);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_CUSTOM_MAP_PARAM, reg.custom_map_param);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_CUSTOM_MAP_ADDR, reg.custom_map_addr);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_SRC_PIC_IDX, reg.src_pic_idx);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_SRC_ADDR_Y, reg.src_addr_y);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_SRC_ADDR_U, reg.src_addr_u);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_SRC_ADDR_V, reg.src_addr_v);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_SRC_STRIDE, reg.src_stride);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_SRC_FMT, reg.src_fmt);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_SRC_AXI_SEL, reg.src_axi_sel);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_CODE_OPTION, reg.code_option);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_PARAM, reg.param);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_LONGTERM_PIC, reg.longterm_pic);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_PREFIX_SEI_NAL_ADDR,
+			      reg.prefix_sei_nal_addr);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_PREFIX_SEI_INFO, reg.prefix_sei_info);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_SUFFIX_SEI_NAL_ADDR,
+			      reg.suffix_sei_nal_addr);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_SUFFIX_SEI_INFO, reg.suffix_sei_info);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_TIMESTAMP_LOW, reg.timestamp_low);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_TIMESTAMP_HIGH, reg.timestamp_high);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_CSC_COEFF0, reg.csc_coeff[0]);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_CSC_COEFF1, reg.csc_coeff[1]);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_CSC_COEFF2, reg.csc_coeff[2]);
+	vpu_write_reg_relaxed(inst->dev, W6_CMD_ENC_PIC_CSC_COEFF3, reg.csc_coeff[3]);
+
+	wave6_send_command(inst->dev, inst->id, inst->std, W6_CMD_ENC_PIC);
+	ret = wave6_wait_vpu_busy(inst->dev, W6_VPU_BUSY_STATUS);
+	if (ret) {
+		dev_err(inst->dev->dev, "%s: timeout\n", __func__);
+		return -ETIMEDOUT;
+	}
+
+	if (!vpu_read_reg_relaxed(inst->dev, W6_RET_SUCCESS)) {
+		*fail_res = vpu_read_reg_relaxed(inst->dev, W6_RET_FAIL_REASON);
+		wave6_print_reg_err(inst->dev, *fail_res);
+		return -EIO;
+	}
+
+	return 0;
+}
+
+int wave6_vpu_enc_get_output_info(struct vpu_instance *inst, struct enc_output_info *info)
+{
+	u32 reg_val;
+	int ret;
+
+	if (WARN_ON(!info))
+		return -EINVAL;
+
+	guard(mutex)(&inst->dev->hw_lock);
+
+	ret = wave6_send_query(inst->dev, inst->id, inst->std, W6_QUERY_OPT_GET_RESULT);
+	if (ret)
+		return ret;
+
+	info->encoding_success = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_ENCODING_SUCCESS);
+	if (!info->encoding_success)
+		info->error_reason = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_ERR_INFO);
+	else
+		info->warn_info = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_WARN_INFO);
+
+	info->enc_pic_cnt = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_NUM);
+	info->pic_type = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_TYPE);
+	info->enc_vcl_nut = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_VCL_NUT);
+	info->non_ref_pic = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_NON_REF_PIC_FLAG);
+	info->num_of_slices = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_SLICE_NUM);
+	info->pic_skipped = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_SKIP);
+	info->num_of_intra = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_NUM_INTRA);
+	info->num_of_merge = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_NUM_MERGE);
+	info->num_of_skip_block = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_NUM_SKIP);
+	info->avg_ctu_qp = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_AVG_CTU_QP);
+	info->enc_pic_byte = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_BYTE);
+	info->enc_gop_pic_idx = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_GOP_PIC_IDX);
+	info->enc_pic_poc = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_POC);
+	info->enc_src_idx = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_USED_SRC_IDX);
+	info->wr_ptr = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_WR_PTR);
+	info->rd_ptr = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_RD_PTR);
+	info->bitstream_buffer = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_RD_PTR);
+	info->pic_distortion_low = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_DIST_LOW);
+	info->pic_distortion_high = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_DIST_HIGH);
+	info->mv_histo.cnt0 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_HISTO_CNT0);
+	info->mv_histo.cnt1 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_HISTO_CNT1);
+	info->mv_histo.cnt2 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_HISTO_CNT2);
+	info->mv_histo.cnt3 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_HISTO_CNT3);
+	info->mv_histo.cnt4 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_HISTO_CNT4);
+	info->fme_sum.lower_x0 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_SUM_ME0_X_DIR_LOWER);
+	info->fme_sum.higher_x0 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_SUM_ME0_X_DIR_HIGHER);
+	info->fme_sum.lower_y0 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_SUM_ME0_Y_DIR_LOWER);
+	info->fme_sum.higher_y0 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_SUM_ME0_Y_DIR_HIGHER);
+	info->fme_sum.lower_x1 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_SUM_ME1_X_DIR_LOWER);
+	info->fme_sum.higher_x1 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_SUM_ME1_X_DIR_HIGHER);
+	info->fme_sum.lower_y1 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_SUM_ME1_Y_DIR_LOWER);
+	info->fme_sum.higher_y1 = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_SUM_ME1_Y_DIR_HIGHER);
+	info->src_y_addr = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_SRC_Y_ADDR);
+	info->custom_map_addr = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_CUSTOM_MAP_ADDR);
+	info->prefix_sei_nal_addr = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PREFIX_SEI_NAL_ADDR);
+	info->suffix_sei_nal_addr = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_SUFFIX_SEI_NAL_ADDR);
+
+	info->recon_frame_index = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_PIC_IDX);
+	if (info->recon_frame_index == RECON_IDX_FLAG_HEADER_ONLY)
+		info->bitstream_size = info->enc_pic_byte;
+	else if (info->recon_frame_index < 0)
+		info->bitstream_size = 0;
+	else
+		info->bitstream_size = info->enc_pic_byte;
+
+	reg_val = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_TIMESTAMP_LOW);
+	info->timestamp = vpu_read_reg_relaxed(inst->dev, W6_RET_ENC_TIMESTAMP_HIGH);
+	info->timestamp = (info->timestamp << 32) | reg_val;
+
+	return 0;
+}
+
+int wave6_vpu_enc_fini_seq(struct vpu_instance *inst, u32 *fail_res)
+{
+	int ret;
+
+	lockdep_assert_held(&inst->dev->hw_lock);
+
+	wave6_send_command(inst->dev, inst->id, inst->std, W6_CMD_DESTROY_INSTANCE);
+	ret = wave6_wait_vpu_busy(inst->dev, W6_VPU_BUSY_STATUS);
+	if (ret)
+		return -ETIMEDOUT;
+
+	if (!vpu_read_reg_relaxed(inst->dev, W6_RET_SUCCESS)) {
+		*fail_res = vpu_read_reg_relaxed(inst->dev, W6_RET_FAIL_REASON);
+		wave6_print_reg_err(inst->dev, *fail_res);
+		return -EIO;
+	}
+
+	return 0;
+}
diff --git a/drivers/media/platform/chips-media/wave6/wave6-hw.h b/drivers/media/platform/chips-media/wave6/wave6-hw.h
index b163c6bb6724..7adb0a07390e 100644
--- a/drivers/media/platform/chips-media/wave6/wave6-hw.h
+++ b/drivers/media/platform/chips-media/wave6/wave6-hw.h
@@ -32,6 +32,8 @@ enum product_id {
 #define WTL_PIXEL_16BIT			1
 #define WTL_PIXEL_32BIT			2
 
+#define MAX_CSC_COEFF_NUM		4
+
 #define H265_NAL_UNIT_TYPE_IDR_W_RADL	19
 #define H265_NAL_UNIT_TYPE_IDR_N_LP	20
 
@@ -46,4 +48,9 @@ int wave6_vpu_dec_get_seq_info(struct vpu_instance *inst, struct dec_seq_info *i
 int wave6_vpu_dec_fini_seq(struct vpu_instance *inst, u32 *fail_res);
 dma_addr_t wave6_vpu_dec_get_rd_ptr(struct vpu_instance *inst);
 
+int wave6_vpu_build_up_enc_param(struct device *dev, struct vpu_instance *inst,
+				 struct enc_open_param *param);
+int wave6_vpu_enc_get_seq_info(struct vpu_instance *inst, struct enc_seq_info *info);
+int wave6_vpu_enc_fini_seq(struct vpu_instance *inst, u32 *fail_res);
+
 #endif /* __WAVE6_HW_H__ */
diff --git a/drivers/media/platform/chips-media/wave6/wave6-regdefine.h b/drivers/media/platform/chips-media/wave6/wave6-regdefine.h
index 0651f5c1e652..1038b87b2ff9 100644
--- a/drivers/media/platform/chips-media/wave6/wave6-regdefine.h
+++ b/drivers/media/platform/chips-media/wave6/wave6-regdefine.h
@@ -20,6 +20,8 @@ enum wave6_command {
 	W6_CMD_INIT_SEQ		= 0x0040,
 	W6_CMD_SET_FB		= 0x0080,
 	W6_CMD_DEC_PIC		= 0x0100,
+	W6_CMD_ENC_PIC		= 0x0100,
+	W6_CMD_ENC_SET_PARAM	= 0x0200,
 	W6_CMD_DEC_SET_DISP	= 0x0400,
 	W6_CMD_INIT_WORK_BUF	= 0x1000,
 	W6_CMD_QUERY		= 0x4000,
@@ -30,6 +32,11 @@ enum wave6_init_seq_option {
 	W6_INIT_SEQ_OPT_W_THUMBNAIL	= 17,
 };
 
+enum wave6_set_param_option {
+	W6_SET_PARAM_OPT_COMMON		= 0,
+	W6_SET_PARAM_OPT_CHANGE_PARAM	= 1,
+};
+
 enum wave6_dec_pic_option {
 	W6_DEC_PIC_OPT_NORMAL		= 0,
 	W6_DEC_PIC_OPT_W_THUMBNAIL	= 16,
@@ -53,6 +60,8 @@ enum wave6_interrupt_bit {
 	W6_INT_BIT_INIT_SEQ		= 6,
 	W6_INT_BIT_SET_FB		= 7,
 	W6_INT_BIT_DEC_PIC		= 8,
+	W6_INT_BIT_ENC_PIC		= 8,
+	W6_INT_BIT_ENC_SET_PARAM	= 9,
 	W6_INT_BIT_SET_DISP		= 10,
 	W6_INT_BIT_REQ_WORK_BUF		= 12,
 	W6_INT_BIT_BSBUF_ERROR		= 15,
@@ -125,6 +134,7 @@ enum wave6_interrupt_bit {
 
 /* COMMON - CREATE_INSTANCE */
 #define W6_CMD_CREATE_INST_BS_PARAM			(W6_REG_BASE + 0x310)
+#define W6_CMD_CREATE_INST_SRC_OPT			(W6_REG_BASE + 0x314)
 #define W6_CMD_CREATE_INST_ADDR_EXT			(W6_REG_BASE + 0x318)
 #define W6_CMD_CREATE_INST_DISP_MODE			(W6_REG_BASE + 0x31C)
 #define W6_CMD_CREATE_INST_CORE_INFO			(W6_REG_BASE + 0x330)
@@ -136,6 +146,7 @@ enum wave6_interrupt_bit {
 #define		CREATE_INST_PRIORITY_VALUE(x)		FIELD_PREP(GENMASK(4, 0), (x))
 #define W6_CMD_CREATE_INST_TEMP_BASE			(W6_REG_BASE + 0x348)
 #define W6_CMD_CREATE_INST_TEMP_SIZE			(W6_REG_BASE + 0x34C)
+#define W6_CMD_CREATE_INST_AR_TABLE_BASE		(W6_REG_BASE + 0x358)
 #define W6_CMD_CREATE_INST_TIMEOUT_CYCLE_COUNT		(W6_REG_BASE + 0x3A8)
 
 /* COMMON - SET_FB */
@@ -147,6 +158,7 @@ enum wave6_interrupt_bit {
 #define		SET_FB_PIC_INFO_C_FMT_IDC(x)		FIELD_PREP(GENMASK(26, 25), (x))
 #define		SET_FB_PIC_INFO_L_BIT_DEPTH(x)		FIELD_PREP(GENMASK(24, 21), (x))
 #define		SET_FB_PIC_INFO_C_BIT_DEPTH(x)		FIELD_PREP(GENMASK(20, 17), (x))
+#define		SET_FB_PIC_INFO_STRIDE(x)		FIELD_PREP(GENMASK(15, 0), (x))
 #define W6_CMD_SET_FB_PIC_SIZE				(W6_REG_BASE + 0x304)
 #define		SET_FB_PIC_SIZE_WIDTH(x)		FIELD_PREP(GENMASK(31, 16), (x))
 #define		SET_FB_PIC_SIZE_HEIGHT(x)		FIELD_PREP(GENMASK(15, 0), (x))
@@ -155,6 +167,9 @@ enum wave6_interrupt_bit {
 #define		SET_FB_NUM_FBC_END_IDX(x)		FIELD_PREP(GENMASK(20, 16), (x))
 #define		SET_FB_NUM_MV_COL_START_IDX(x)		FIELD_PREP(GENMASK(9, 5), (x))
 #define		SET_FB_NUM_MV_COL_END_IDX(x)		FIELD_PREP(GENMASK(4, 0), (x))
+#define W6_CMD_SET_FB_FBC_STRIDE			(W6_REG_BASE + 0x30C)
+#define		SET_FB_FBC_STRIDE_L(x)			FIELD_PREP(GENMASK(31, 16), (x))
+#define		SET_FB_FBC_STRIDE_C(x)			FIELD_PREP(GENMASK(15, 0), (x))
 
 /* W6_CMD_SET_FB_FBC_Y(x)
  * Address range: 0x310, 0x328, ..., 0x478 (step = 0x18)
@@ -181,6 +196,10 @@ enum wave6_interrupt_bit {
  */
 #define W6_CMD_SET_FB_MV_COL(x)				(W6_REG_BASE + 0x320 + ((x) * 0x18))
 
+/* W6_CMD_SET_FB_SUB_SAMPLED(x)
+ * Address range: 0x324, 0x33C, ..., 0x48C (step = 0x18)
+ */
+#define W6_CMD_SET_FB_SUB_SAMPLED(x)			(W6_REG_BASE + 0x324 + ((x) * 0x18))
 #define W6_CMD_SET_FB_DEFAULT_CDF			(W6_REG_BASE + 0x494)
 #define W6_CMD_SET_FB_SEGMAP				(W6_REG_BASE + 0x498)
 #define W6_CMD_SET_FB_MV_COL_PRE_ENT			(W6_REG_BASE + 0x4DC)
@@ -330,4 +349,297 @@ enum wave6_interrupt_bit {
 #define W6_RET_DEC_FLUSH_CMD_BUF_STATE_USED_IDC		(W6_REG_BASE + 0x580)
 #define W6_RET_DEC_FLUSH_CMD_BUF_STATE_USING_IDC	(W6_REG_BASE + 0x584)
 
+/* ENCODER - SET_PARAM */
+#define W6_CMD_ENC_SET_PARAM_OPTION			(W6_REG_BASE + 0x204)
+#define W6_CMD_ENC_SET_PARAM_ENABLE			(W6_REG_BASE + 0x300)
+#define		SET_PARAM_ENABLE_RC_TARGET_RATE		BIT(10)
+#define W6_CMD_ENC_SET_PARAM_SRC_SIZE			(W6_REG_BASE + 0x304)
+#define		SET_PARAM_SRC_SIZE_HEIGHT(x)		FIELD_PREP(GENMASK(31, 16), (x))
+#define		SET_PARAM_SRC_SIZE_WIDTH(x)		FIELD_PREP(GENMASK(15, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_CUSTOM_MAP_ENDIAN		(W6_REG_BASE + 0x308)
+#define W6_CMD_ENC_SET_PARAM_SPS			(W6_REG_BASE + 0x30C)
+#define		SET_PARAM_SPS_DEFAULT_SCALING_LIST(x)	FIELD_PREP(GENMASK(31, 31), (x))
+#define		SET_PARAM_SPS_STILL_PICTURE(x)		FIELD_PREP(GENMASK(30, 30), (x))
+#define		SET_PARAM_SPS_AUTO_LEVEL_ADJUSTING_ON	BIT(28)
+#define		SET_PARAM_SPS_STRONG_INTRA_SMOOTHING(x)	FIELD_PREP(GENMASK(27, 27), (x))
+#define		SET_PARAM_SPS_INTRA_TRANSFORM_SKIP_ON	BIT(25)
+#define		SET_PARAM_SPS_SAMPLE_ADAPTIVE_OFFSET(x)	FIELD_PREP(GENMASK(24, 24), (x))
+#define		SET_PARAM_SPS_TEMPORAL_MVP(x)		FIELD_PREP(GENMASK(23, 23), (x))
+#define		SET_PARAM_SPS_LONGTERM_REFERENCE(x)	FIELD_PREP(GENMASK(21, 21), (x))
+#define		SET_PARAM_SPS_C_FMT_IDC(x)		FIELD_PREP(GENMASK(20, 19), (x))
+#define		SET_PARAM_SPS_BIT_DEPTH(x)		FIELD_PREP(GENMASK(18, 14), (x))
+#define		SET_PARAM_SPS_TIER(x)			FIELD_PREP(GENMASK(13, 12), (x))
+#define		SET_PARAM_SPS_LEVEL(x)			FIELD_PREP(GENMASK(11, 3), (x))
+#define		SET_PARAM_SPS_PROFILE(x)		FIELD_PREP(GENMASK(2, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_PPS			(W6_REG_BASE + 0x310)
+#define		SET_PARAM_PPS_ENTROPY_CODING_MODE(x)	FIELD_PREP(GENMASK(30, 30), (x))
+#define		SET_PARAM_PPS_TRANSFORM8X8(x)		FIELD_PREP(GENMASK(29, 29), (x))
+#define		SET_PARAM_PPS_CR_QP_OFFSET(x)		FIELD_PREP(GENMASK(23, 19), (x))
+#define		SET_PARAM_PPS_CB_QP_OFFSET(x)		FIELD_PREP(GENMASK(18, 14), (x))
+#define		SET_PARAM_PPS_TC_OFFSET_DIV2(x)		FIELD_PREP(GENMASK(13, 10), (x))
+#define		SET_PARAM_PPS_BETA_OFFSET_DIV2(x)	FIELD_PREP(GENMASK(9, 6), (x))
+#define		SET_PARAM_PPS_DEBLOCKING_FILTER(x)	FIELD_PREP(GENMASK(5, 5), (x))
+#define		SET_PARAM_PPS_LF_SLICE_BOUNDARY(x)	FIELD_PREP(GENMASK(2, 2), (x))
+#define		SET_PARAM_PPS_CONST_INTRA_PREDICTION(x)	FIELD_PREP(GENMASK(1, 1), (x))
+#define W6_CMD_ENC_SET_PARAM_GOP			(W6_REG_BASE + 0x314)
+#define		SET_PARAM_GOP_TEMP_LAYER_CNT(x)		FIELD_PREP(GENMASK(19, 16), (x))
+#define		SET_PARAM_GOP_TEMP_LAYER3_QP_ENABLE(x)	FIELD_PREP(GENMASK(11, 11), (x))
+#define		SET_PARAM_GOP_TEMP_LAYER2_QP_ENABLE(x)	FIELD_PREP(GENMASK(10, 10), (x))
+#define		SET_PARAM_GOP_TEMP_LAYER1_QP_ENABLE(x)	FIELD_PREP(GENMASK(9, 9), (x))
+#define		SET_PARAM_GOP_TEMP_LAYER0_QP_ENABLE(x)	FIELD_PREP(GENMASK(8, 8), (x))
+#define		SET_PARAM_GOP_PRESET_IDX(x)		FIELD_PREP(GENMASK(7, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_INTRA			(W6_REG_BASE + 0x318)
+#define		SET_PARAM_INTRA_PERIOD(x)		FIELD_PREP(GENMASK(31, 16), (x))
+#define		SET_PARAM_INTRA_HEADER_MODE(x)		FIELD_PREP(GENMASK(10, 9), (x))
+#define		SET_PARAM_INTRA_QP(x)			FIELD_PREP(GENMASK(8, 3), (x))
+#define		SET_PARAM_INTRA_REFRESH_TYPE(x)		FIELD_PREP(GENMASK(2, 0), (x))
+
+/* W6_CMD_ENC_SET_PARAM_INTRA for AVC specific fields */
+#define		SET_PARAM_INTRA_HEADER_MODE_AVC(x)	FIELD_PREP(GENMASK(29, 28), (x))
+#define		SET_PARAM_INTRA_IDR_PERIOD_AVC(x)	FIELD_PREP(GENMASK(27, 17), (x))
+#define		SET_PARAM_INTRA_PERIOD_AVC(x)		FIELD_PREP(GENMASK(16, 6), (x))
+#define		SET_PARAM_INTRA_QP_AVC(x)		FIELD_PREP(GENMASK(5, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_CONF_WIN0			(W6_REG_BASE + 0x31C)
+#define		SET_PARAM_CONF_WIN0_BOTTOM(x)		FIELD_PREP(GENMASK(31, 16), (x))
+#define		SET_PARAM_CONF_WIN0_TOP(x)		FIELD_PREP(GENMASK(15, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_CONF_WIN1			(W6_REG_BASE + 0x320)
+#define		SET_PARAM_CONF_WIN1_RIGHT(x)		FIELD_PREP(GENMASK(31, 16), (x))
+#define		SET_PARAM_CONF_WIN1_LEFT(x)		FIELD_PREP(GENMASK(15, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_RDO			(W6_REG_BASE + 0x324)
+#define		SET_PARAM_RDO_CUSTOM_LAMBDA(x)		FIELD_PREP(GENMASK(22, 22), (x))
+#define		SET_PARAM_RDO_ME_SEARCH_CENTER_ON	BIT(21)
+#define		SET_PARAM_RDO_QROUND_OFFSET(x)		FIELD_PREP(GENMASK(17, 17), (x))
+#define		SET_PARAM_RDO_ADAPTIVE_ROUND_ON		BIT(3)
+#define		SET_PARAM_RDO_HVS_QP(x)			FIELD_PREP(GENMASK(2, 2), (x))
+#define W6_CMD_ENC_SET_PARAM_SLICE			(W6_REG_BASE + 0x328)
+#define		SET_PARAM_SLICE_ARGUMENT(x)		FIELD_PREP(GENMASK(31, 3), (x))
+#define		SET_PARAM_SLICE_MODE(x)			FIELD_PREP(GENMASK(2, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_INTRA_REFRESH		(W6_REG_BASE + 0x32C)
+#define		SET_PARAM_INTRA_REFRESH_ARGUMENT(x)	FIELD_PREP(GENMASK(31, 16), (x))
+#define		SET_PARAM_INTRA_REFRESH_MODE(x)		FIELD_PREP(GENMASK(2, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_INTRA_QP			(W6_REG_BASE + 0x330)
+#define		SET_PARAM_INTRA_QP_MAX(x)		FIELD_PREP(GENMASK(11, 6), (x))
+#define		SET_PARAM_INTRA_QP_MIN(x)		FIELD_PREP(GENMASK(5, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_RC_FRAME_RATE		(W6_REG_BASE + 0x334)
+#define W6_CMD_ENC_SET_PARAM_RC_TARGET_RATE		(W6_REG_BASE + 0x338)
+#define W6_CMD_ENC_SET_PARAM_RC				(W6_REG_BASE + 0x33C)
+#define		SET_PARAM_RC_UPDATE_SPEED(x)		FIELD_PREP(GENMASK(31, 24), (x))
+#define		SET_PARAM_RC_INITIAL_LEVEL(x)		FIELD_PREP(GENMASK(23, 20), (x))
+#define		SET_PARAM_RC_INITIAL_QP(x)		FIELD_PREP(GENMASK(19, 14), (x))
+#define		SET_PARAM_RC_MODE(x)			FIELD_PREP(GENMASK(13, 13), (x))
+#define		SET_PARAM_RC_PIC_LEVEL_MAX_DELTA_QP(x)	FIELD_PREP(GENMASK(12, 7), (x))
+#define		SET_PARAM_RC_VBV_OVERFLOW_DROP_FRAME(x)	FIELD_PREP(GENMASK(3, 3), (x))
+#define		SET_PARAM_RC_CU_LEVEL_ENABLE(x)		FIELD_PREP(GENMASK(1, 1), (x))
+#define		SET_PARAM_RC_ENABLE(x)			FIELD_PREP(GENMASK(0, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_HVS			(W6_REG_BASE + 0x340)
+#define		SET_PARAM_HVS_MAX_DELTA_QP(x)		FIELD_PREP(GENMASK(17, 12), (x))
+#define		SET_PARAM_HVS_QP_SCALE(x)		FIELD_PREP(GENMASK(3, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_RC_MAX_BITRATE		(W6_REG_BASE + 0x344)
+#define W6_CMD_ENC_SET_PARAM_RC_VBV_BUFFER_SIZE		(W6_REG_BASE + 0x348)
+#define W6_CMD_ENC_SET_PARAM_INTER_QP			(W6_REG_BASE + 0x34C)
+#define		SET_PARAM_INTER_QP_MAX_B(x)		FIELD_PREP(GENMASK(23, 18), (x))
+#define		SET_PARAM_INTER_QP_MIN_B(x)		FIELD_PREP(GENMASK(17, 12), (x))
+#define		SET_PARAM_INTER_QP_MAX_P(x)		FIELD_PREP(GENMASK(11, 6), (x))
+#define		SET_PARAM_INTER_QP_MIN_P(x)		FIELD_PREP(GENMASK(5, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_ROT			(W6_REG_BASE + 0x350)
+#define		SET_PARAM_ROT_MIRH			BIT(4)
+#define		SET_PARAM_ROT_MIRV			BIT(3)
+#define		SET_PARAM_ROT_270			FIELD_PREP(GENMASK(2, 1), 3)
+#define		SET_PARAM_ROT_180			FIELD_PREP(GENMASK(2, 1), 2)
+#define		SET_PARAM_ROT_90			FIELD_PREP(GENMASK(2, 1), 1)
+#define		SET_PARAM_ROT_ENABLE			BIT(0)
+#define W6_CMD_ENC_SET_PARAM_NUM_UNITS_IN_TICK		(W6_REG_BASE + 0x354)
+#define W6_CMD_ENC_SET_PARAM_TIME_SCALE			(W6_REG_BASE + 0x358)
+#define W6_CMD_ENC_SET_PARAM_NUM_TICKS_POC_DIFF_ONE	(W6_REG_BASE + 0x35C)
+#define W6_CMD_ENC_SET_PARAM_MAX_INTRA_PIC_BIT		(W6_REG_BASE + 0x360)
+#define W6_CMD_ENC_SET_PARAM_MAX_INTER_PIC_BIT		(W6_REG_BASE + 0x364)
+#define W6_CMD_ENC_SET_PARAM_BG				(W6_REG_BASE + 0x36C)
+#define		SET_PARAM_BG_DELTA_QP(x)		FIELD_PREP(GENMASK(29, 24), (x))
+#define		SET_PARAM_BG_THRESHOLD_MEAN_DIFF(x)	FIELD_PREP(GENMASK(17, 10), (x))
+#define		SET_PARAM_BG_THRESHOLD_MAX_DIFF(x)	FIELD_PREP(GENMASK(9, 1), (x))
+#define		SET_PARAM_BG_ENABLE(x)			FIELD_PREP(GENMASK(0, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_NON_VCL_PARAM		(W6_REG_BASE + 0x370)
+#define		SET_PARAM_NON_VCL_PARAM_ENCODE_VUI	BIT(1)
+#define W6_CMD_ENC_SET_PARAM_VUI_RBSP_ADDR		(W6_REG_BASE + 0x374)
+#define W6_CMD_ENC_SET_PARAM_HRD_RBSP_ADDR		(W6_REG_BASE + 0x378)
+#define W6_CMD_ENC_SET_PARAM_QROUND_OFFSET		(W6_REG_BASE + 0x380)
+#define		SET_PARAM_QROUND_OFFSET_INTER(x)	FIELD_PREP(GENMASK(23, 13), (x))
+#define		SET_PARAM_QROUND_OFFSET_INTRA(x)	FIELD_PREP(GENMASK(12, 2), (x))
+#define W6_CMD_ENC_SET_PARAM_QUANT1			(W6_REG_BASE + 0x384)
+#define W6_CMD_ENC_SET_PARAM_QUANT2			(W6_REG_BASE + 0x388)
+#define		SET_PARAM_QUANT2_LAMBDA_DQP_INTER(x)	FIELD_PREP(GENMASK(19, 14), (x))
+#define		SET_PARAM_QUANT2_LAMBDA_DQP_INTRA(x)	FIELD_PREP(GENMASK(13, 8), (x))
+#define W6_CMD_ENC_SET_PARAM_CUSTOM_GOP			(W6_REG_BASE + 0x38C)
+
+/* W6_CMD_ENC_SET_PARAM_CUSTOM_GOP_PIC(x)
+ * Address range: 0x390, 0x394, ..., 0x3AC (step = 0x4)
+ */
+#define W6_CMD_ENC_SET_PARAM_CUSTOM_GOP_PIC(x)		(W6_REG_BASE + 0x390 + ((x) * 0x4))
+#define		SET_PARAM_CUSTOM_GOP_PIC_TEMP_ID(x)	FIELD_PREP(GENMASK(29, 26), (x))
+#define		SET_PARAM_CUSTOM_GOP_PIC_REF1_POC(x)	FIELD_PREP(GENMASK(25, 20), (x))
+#define		SET_PARAM_CUSTOM_GOP_PIC_REF0_POC(x)	FIELD_PREP(GENMASK(19, 14), (x))
+#define		SET_PARAM_CUSTOM_GOP_PIC_MULTI_REF_P(x)	FIELD_PREP(GENMASK(13, 13), (x))
+#define		SET_PARAM_CUSTOM_GOP_PIC_QP(x)		FIELD_PREP(GENMASK(12, 7), (x))
+#define		SET_PARAM_CUSTOM_GOP_PIC_POC_OFFSET(x)	FIELD_PREP(GENMASK(6, 2), (x))
+#define		SET_PARAM_CUSTOM_GOP_PIC_TYPE(x)	FIELD_PREP(GENMASK(1, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_TILE_PARAM			(W6_REG_BASE + 0x3D0)
+
+/* W6_CMD_ENC_SET_PARAM_CUSTOM_LAMBDA(x)
+ * Address range: 0x3D4, 0x3D8, ..., 0x4A0 (step = 0x4)
+ */
+#define W6_CMD_ENC_SET_PARAM_CUSTOM_LAMBDA(x)		(W6_REG_BASE + 0x3D4 + ((x) * 0x4))
+#define		SET_PARAM_CUSTOM_LAMBDA_SSD(x)		FIELD_PREP(GENMASK(20, 7), (x))
+#define		SET_PARAM_CUSTOM_LAMBDA_SAD(x)		FIELD_PREP(GENMASK(6, 0), (x))
+
+/* W6_CMD_ENC_SET_PARAM_TEMP_LAYER_QP(x)
+ * Address range: 0x4A4, 0x4A8, ..., 0x4B0 (step = 0x4)
+ */
+#define W6_CMD_ENC_SET_PARAM_TEMP_LAYER_QP(x)		(W6_REG_BASE + 0x4A4 + ((x) * 0x4))
+#define		SET_PARAM_TEMP_LAYER_QP_B(x)		FIELD_PREP(GENMASK(17, 12), (x))
+#define		SET_PARAM_TEMP_LAYER_QP_P(x)		FIELD_PREP(GENMASK(11, 6), (x))
+#define		SET_PARAM_TEMP_LAYER_QP_I(x)		FIELD_PREP(GENMASK(5, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_SCALER_SIZE		(W6_REG_BASE + 0x4B4)
+#define		SET_PARAM_SCALER_SIZE_HEIGHT(x)		FIELD_PREP(GENMASK(31, 16), (x))
+#define		SET_PARAM_SCALER_SIZE_WIDTH(x)		FIELD_PREP(GENMASK(15, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_SCALER			(W6_REG_BASE + 0x4B8)
+#define		SET_PARAM_SCALER_COEF_MODE(x)		FIELD_PREP(GENMASK(2, 1), (x))
+#define		SET_PARAM_SCALER_ENABLE(x)		FIELD_PREP(GENMASK(0, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_COLOR			(W6_REG_BASE + 0x4F8)
+#define		SET_PARAM_COLOR_RANGE(x)		FIELD_PREP(GENMASK(25, 25), (x))
+#define		SET_PARAM_COLOR_MATRIX_COEFF(x)		FIELD_PREP(GENMASK(24, 17), (x))
+#define		SET_PARAM_COLOR_TRANS_CHAR(x)		FIELD_PREP(GENMASK(16, 9), (x))
+#define		SET_PARAM_COLOR_PRIMARIES(x)		FIELD_PREP(GENMASK(8, 1), (x))
+#define		SET_PARAM_COLOR_DESCRIPTION_PRESENT_ON	BIT(0)
+#define W6_CMD_ENC_SET_PARAM_SAR			(W6_REG_BASE + 0x4FC)
+#define		SET_PARAM_SAR_ASPECT_RATIO_IDC(x)	FIELD_PREP(GENMASK(8, 1), (x))
+#define		SET_PARAM_SAR_ASPECT_RATIO_ENABLE(x)	FIELD_PREP(GENMASK(0, 0), (x))
+#define W6_CMD_ENC_SET_PARAM_SAR_EXTENDED		(W6_REG_BASE + 0x500)
+#define		SET_PARAM_SAR_EXTENDED_HEIGHT(x)	FIELD_PREP(GENMASK(31, 16), (x))
+#define		SET_PARAM_SAR_EXTENDED_WIDTH(x)		FIELD_PREP(GENMASK(15, 0), (x))
+
+/* ENCODER - ENC_PIC */
+#define W6_CMD_ENC_PIC_BS_START				(W6_REG_BASE + 0x300)
+#define W6_CMD_ENC_PIC_BS_SIZE				(W6_REG_BASE + 0x304)
+#define W6_CMD_ENC_PIC_BS_OPTION			(W6_REG_BASE + 0x308)
+#define W6_CMD_ENC_PIC_SEC_AXI				(W6_REG_BASE + 0x30C)
+#define		ENC_PIC_SEC_AXI_RDO_ENABLE(x)		FIELD_PREP(GENMASK(1, 1), (x))
+#define		ENC_PIC_SEC_AXI_LF_ENABLE(x)		FIELD_PREP(GENMASK(0, 0), (x))
+#define W6_CMD_ENC_PIC_REPORT				(W6_REG_BASE + 0x310)
+#define		ENC_PIC_REPORT_MV_HISTO_ENABLE(x)	FIELD_PREP(GENMASK(1, 1), (x))
+#define W6_CMD_ENC_PIC_MV_HISTO0			(W6_REG_BASE + 0x318)
+#define		ENC_PIC_MV_HISTO0_THRESHOLD0(x)		FIELD_PREP(GENMASK(31, 16), (x))
+#define		ENC_PIC_MV_HISTO0_THRESHOLD1(x)		FIELD_PREP(GENMASK(15, 0), (x))
+#define W6_CMD_ENC_PIC_MV_HISTO1			(W6_REG_BASE + 0x31C)
+#define		ENC_PIC_MV_HISTO1_THRESHOLD2(x)		FIELD_PREP(GENMASK(31, 16), (x))
+#define		ENC_PIC_MV_HISTO1_THRESHOLD3(x)		FIELD_PREP(GENMASK(15, 0), (x))
+#define W6_CMD_ENC_PIC_CUSTOM_MAP_PARAM			(W6_REG_BASE + 0x320)
+#define W6_CMD_ENC_PIC_CUSTOM_MAP_ADDR			(W6_REG_BASE + 0x324)
+#define W6_CMD_ENC_PIC_SRC_PIC_IDX			(W6_REG_BASE + 0x32C)
+#define		ENC_PIC_SRC_PIC_IDX_END			0xFFFFFFFF
+#define W6_CMD_ENC_PIC_SRC_ADDR_Y			(W6_REG_BASE + 0x330)
+#define W6_CMD_ENC_PIC_SRC_ADDR_U			(W6_REG_BASE + 0x334)
+#define W6_CMD_ENC_PIC_SRC_ADDR_V			(W6_REG_BASE + 0x338)
+#define W6_CMD_ENC_PIC_SRC_STRIDE			(W6_REG_BASE + 0x33C)
+#define		ENC_PIC_SRC_STRIDE_L(x)			FIELD_PREP(GENMASK(31, 16), (x))
+#define		ENC_PIC_SRC_STRIDE_C(x)			FIELD_PREP(GENMASK(15, 0), (x))
+#define W6_CMD_ENC_PIC_SRC_FMT				(W6_REG_BASE + 0x340)
+#define		ENC_PIC_SRC_FMT_C_FMT_IDC(x)		FIELD_PREP(GENMASK(30, 28), (x))
+#define		ENC_PIC_SRC_FMT_CSC_24BIT(x)		FIELD_PREP(GENMASK(25, 25), (x))
+#define		ENC_PIC_SRC_FMT_CSC_AYUV(x)		FIELD_PREP(GENMASK(24, 24), (x))
+#define		ENC_PIC_SRC_FMT_CSC_ENABLE(x)		FIELD_PREP(GENMASK(20, 20), (x))
+#define		ENC_PIC_SRC_FMT_CSC_FMT_ORDER(x)	FIELD_PREP(GENMASK(19, 16), (x))
+#define		ENC_PIC_SRC_FMT_ENDIAN(x)		FIELD_PREP(GENMASK(15, 12), (x))
+#define		ENC_PIC_SRC_FMT_10BIT_ORDER(x)		FIELD_PREP(GENMASK(6, 6), (x))
+#define		ENC_PIC_SRC_FMT_10BIT_3PIXEL_4BYTE(x)	FIELD_PREP(GENMASK(5, 5), (x))
+#define		ENC_PIC_SRC_FMT_10BIT_ENABLE(x)		FIELD_PREP(GENMASK(4, 4), (x))
+#define		ENC_PIC_SRC_FMT_YUV422_PACKED_ORDER(x)	FIELD_PREP(GENMASK(3, 3), (x))
+#define		ENC_PIC_SRC_FMT_CBCR_ORDER(x)		FIELD_PREP(GENMASK(2, 2), (x))
+#define		ENC_PIC_SRC_FMT_2PLANE(x)		FIELD_PREP(GENMASK(1, 1), (x))
+#define		ENC_PIC_SRC_FMT_YUV422_PACKED(x)	FIELD_PREP(GENMASK(0, 0), (x))
+#define W6_CMD_ENC_PIC_SRC_AXI_SEL			(W6_REG_BASE + 0x348)
+#define		ENC_PIC_SRC_AXI_SEL_PRIMARY_PORT	1
+#define		ENC_PIC_SRC_AXI_SEL_PRP_PORT		0
+#define W6_CMD_ENC_PIC_CODE_OPTION			(W6_REG_BASE + 0x34C)
+#define		ENC_PIC_CODE_OPTION_ENCODE_VCL		BIT(1)
+#define		ENC_PIC_CODE_OPTION_ENCODE_HEADER	BIT(0)
+#define W6_CMD_ENC_PIC_PARAM				(W6_REG_BASE + 0x350)
+#define		ENC_PIC_PARAM_INTRA_4X4(x)		FIELD_PREP(GENMASK(29, 28), (x))
+#define		ENC_PIC_PARAM_FORCE_PIC_TYPE(x)		FIELD_PREP(GENMASK(23, 21), (x))
+#define		ENC_PIC_PARAM_FORCE_PIC_TYPE_ENABLE(x)	FIELD_PREP(GENMASK(20, 20), (x))
+#define		ENC_PIC_PARAM_FORCE_PIC_QP_B(x)		FIELD_PREP(GENMASK(19, 14), (x))
+#define		ENC_PIC_PARAM_FORCE_PIC_QP_P(x)		FIELD_PREP(GENMASK(13, 8), (x))
+#define		ENC_PIC_PARAM_FORCE_PIC_QP_I(x)		FIELD_PREP(GENMASK(7, 2), (x))
+#define		ENC_PIC_PARAM_FORCE_PIC_QP_ENABLE(x)	FIELD_PREP(GENMASK(1, 1), (x))
+#define		ENC_PIC_PARAM_PIC_SKIP_FLAG(x)		FIELD_PREP(GENMASK(0, 0), (x))
+#define W6_CMD_ENC_PIC_LONGTERM_PIC			(W6_REG_BASE + 0x354)
+#define W6_CMD_ENC_PIC_PREFIX_SEI_NAL_ADDR		(W6_REG_BASE + 0x358)
+#define W6_CMD_ENC_PIC_PREFIX_SEI_INFO			(W6_REG_BASE + 0x35C)
+#define W6_CMD_ENC_PIC_SUFFIX_SEI_NAL_ADDR		(W6_REG_BASE + 0x360)
+#define W6_CMD_ENC_PIC_SUFFIX_SEI_INFO			(W6_REG_BASE + 0x364)
+#define W6_CMD_ENC_PIC_CSC_COEFF0			(W6_REG_BASE + 0x374)
+#define		ENC_PIC_CSC_COEFF0_RY(x)		FIELD_PREP(GENMASK(29, 20), (x))
+#define		ENC_PIC_CSC_COEFF0_GY(x)		FIELD_PREP(GENMASK(19, 10), (x))
+#define		ENC_PIC_CSC_COEFF0_BY(x)		FIELD_PREP(GENMASK(9, 0), (x))
+#define W6_CMD_ENC_PIC_CSC_COEFF1			(W6_REG_BASE + 0x378)
+#define		ENC_PIC_CSC_COEFF1_RCB(x)		FIELD_PREP(GENMASK(29, 20), (x))
+#define		ENC_PIC_CSC_COEFF1_GCB(x)		FIELD_PREP(GENMASK(19, 10), (x))
+#define		ENC_PIC_CSC_COEFF1_BCB(x)		FIELD_PREP(GENMASK(9, 0), (x))
+#define W6_CMD_ENC_PIC_CSC_COEFF2			(W6_REG_BASE + 0x37C)
+#define		ENC_PIC_CSC_COEFF2_RCR(x)		FIELD_PREP(GENMASK(29, 20), (x))
+#define		ENC_PIC_CSC_COEFF2_GCR(x)		FIELD_PREP(GENMASK(19, 10), (x))
+#define		ENC_PIC_CSC_COEFF2_BCR(x)		FIELD_PREP(GENMASK(9, 0), (x))
+#define W6_CMD_ENC_PIC_CSC_COEFF3			(W6_REG_BASE + 0x380)
+#define		ENC_PIC_CSC_COEFF3_OFFSET_Y(x)		FIELD_PREP(GENMASK(29, 20), (x))
+#define		ENC_PIC_CSC_COEFF3_OFFSET_CB(x)		FIELD_PREP(GENMASK(19, 10), (x))
+#define		ENC_PIC_CSC_COEFF3_OFFSET_CR(x)		FIELD_PREP(GENMASK(9, 0), (x))
+#define W6_CMD_ENC_PIC_TIMESTAMP_LOW			(W6_REG_BASE + 0x448)
+#define W6_CMD_ENC_PIC_TIMESTAMP_HIGH			(W6_REG_BASE + 0x44C)
+
+/* ENCODER - QUERY : GET_RESULT */
+#define W6_RET_ENC_RD_PTR				(W6_REG_BASE + 0x300)
+#define W6_RET_ENC_WR_PTR				(W6_REG_BASE + 0x304)
+#define W6_RET_ENC_NUM_REQUIRED_FBC_FB			(W6_REG_BASE + 0x308)
+#define W6_RET_ENC_MIN_SRC_BUF_NUM			(W6_REG_BASE + 0x30C)
+#define W6_RET_ENC_PIC_TYPE				(W6_REG_BASE + 0x310)
+#define W6_RET_ENC_PIC_POC				(W6_REG_BASE + 0x314)
+#define W6_RET_ENC_PIC_IDX				(W6_REG_BASE + 0x318)
+#define W6_RET_ENC_PIC_SLICE_NUM			(W6_REG_BASE + 0x31C)
+#define W6_RET_ENC_PIC_SKIP				(W6_REG_BASE + 0x320)
+#define W6_RET_ENC_PIC_NUM_INTRA			(W6_REG_BASE + 0x324)
+#define W6_RET_ENC_PIC_NUM_MERGE			(W6_REG_BASE + 0x328)
+#define W6_RET_ENC_PIC_NON_REF_PIC_FLAG			(W6_REG_BASE + 0x32C)
+#define W6_RET_ENC_PIC_NUM_SKIP				(W6_REG_BASE + 0x330)
+#define W6_RET_ENC_PIC_AVG_CTU_QP			(W6_REG_BASE + 0x334)
+#define W6_RET_ENC_PIC_BYTE				(W6_REG_BASE + 0x338)
+#define W6_RET_ENC_GOP_PIC_IDX				(W6_REG_BASE + 0x33C)
+#define W6_RET_ENC_USED_SRC_IDX				(W6_REG_BASE + 0x340)
+#define W6_RET_ENC_PIC_NUM				(W6_REG_BASE + 0x344)
+#define W6_RET_ENC_VCL_NUT				(W6_REG_BASE + 0x348)
+#define W6_RET_ENC_PIC_DIST_LOW				(W6_REG_BASE + 0x350)
+#define W6_RET_ENC_PIC_DIST_HIGH			(W6_REG_BASE + 0x354)
+#define W6_RET_ENC_PIC_MAX_LATENCY_PICTURES		(W6_REG_BASE + 0x358)
+#define W6_RET_ENC_HISTO_CNT0				(W6_REG_BASE + 0x360)
+#define W6_RET_ENC_HISTO_CNT1				(W6_REG_BASE + 0x364)
+#define W6_RET_ENC_HISTO_CNT2				(W6_REG_BASE + 0x368)
+#define W6_RET_ENC_HISTO_CNT3				(W6_REG_BASE + 0x36C)
+#define W6_RET_ENC_HISTO_CNT4				(W6_REG_BASE + 0x370)
+#define W6_RET_ENC_WARN_INFO				(W6_REG_BASE + 0x3AC)
+#define W6_RET_ENC_ERR_INFO				(W6_REG_BASE + 0x3B0)
+#define W6_RET_ENC_ENCODING_SUCCESS			(W6_REG_BASE + 0x3B4)
+#define W6_RET_ENC_SUM_ME0_X_DIR_LOWER			(W6_REG_BASE + 0x3B8)
+#define W6_RET_ENC_SUM_ME0_X_DIR_HIGHER			(W6_REG_BASE + 0x3BC)
+#define W6_RET_ENC_SUM_ME0_Y_DIR_LOWER			(W6_REG_BASE + 0x3C0)
+#define W6_RET_ENC_SUM_ME0_Y_DIR_HIGHER			(W6_REG_BASE + 0x3C4)
+#define W6_RET_ENC_SUM_ME1_X_DIR_LOWER			(W6_REG_BASE + 0x3C8)
+#define W6_RET_ENC_SUM_ME1_X_DIR_HIGHER			(W6_REG_BASE + 0x3CC)
+#define W6_RET_ENC_SUM_ME1_Y_DIR_LOWER			(W6_REG_BASE + 0x3D0)
+#define W6_RET_ENC_SUM_ME1_Y_DIR_HIGHER			(W6_REG_BASE + 0x3D4)
+#define W6_RET_ENC_SRC_Y_ADDR				(W6_REG_BASE + 0x3E8)
+#define W6_RET_ENC_CUSTOM_MAP_ADDR			(W6_REG_BASE + 0x3EC)
+#define W6_RET_ENC_PREFIX_SEI_NAL_ADDR			(W6_REG_BASE + 0x3F0)
+#define W6_RET_ENC_SUFFIX_SEI_NAL_ADDR			(W6_REG_BASE + 0x3F4)
+#define W6_RET_ENC_NUM_REQUIRED_COL_BUF			(W6_REG_BASE + 0x404)
+#define W6_RET_ENC_TIMESTAMP_LOW			(W6_REG_BASE + 0x44C)
+#define W6_RET_ENC_TIMESTAMP_HIGH			(W6_REG_BASE + 0x450)
+
 #endif /* __WAVE6_REGDEFINE_H__ */
diff --git a/drivers/media/platform/chips-media/wave6/wave6-vpu-core.c b/drivers/media/platform/chips-media/wave6/wave6-vpu-core.c
index 4fd86472b427..2baf51a5709d 100644
--- a/drivers/media/platform/chips-media/wave6/wave6-vpu-core.c
+++ b/drivers/media/platform/chips-media/wave6/wave6-vpu-core.c
@@ -92,7 +92,8 @@ static irqreturn_t wave6_vpu_core_irq_thread(int irq, void *dev_id)
 		if (!inst)
 			continue;
 
-		if (irq_info.status & BIT(W6_INT_BIT_INIT_SEQ)) {
+		if ((irq_info.status & BIT(W6_INT_BIT_INIT_SEQ)) ||
+		    (irq_info.status & BIT(W6_INT_BIT_ENC_SET_PARAM))) {
 			complete(&inst->irq_done);
 			continue;
 		}
diff --git a/drivers/media/platform/chips-media/wave6/wave6-vpuapi.c b/drivers/media/platform/chips-media/wave6/wave6-vpuapi.c
index c8d1138334b3..b841e3f1c9a1 100644
--- a/drivers/media/platform/chips-media/wave6/wave6-vpuapi.c
+++ b/drivers/media/platform/chips-media/wave6/wave6-vpuapi.c
@@ -200,3 +200,134 @@ void wave6_vpu_dec_reset_frame_buffer_info(struct vpu_instance *inst)
 		wave6_vdi_free_dma(&inst->aux_vbuf[AUX_BUF_FBC_C_TBL][i]);
 	}
 }
+
+int wave6_vpu_enc_open(struct vpu_instance *inst, struct enc_open_param *pop)
+{
+	struct enc_info *p_enc_info;
+	int ret;
+	struct vpu_core_device *core = inst->dev;
+
+	guard(mutex)(&core->hw_lock);
+
+	if (!wave6_vpu_is_init(core))
+		return -ENODEV;
+
+	inst->codec_info = kzalloc_obj(*inst->codec_info);
+	if (!inst->codec_info)
+		return -ENOMEM;
+
+	p_enc_info = &inst->codec_info->enc_info;
+	p_enc_info->open_param = *pop;
+
+	ret = wave6_vpu_build_up_enc_param(core->dev, inst, pop);
+	if (ret) {
+		kfree(inst->codec_info);
+		inst->codec_info = NULL;
+	}
+
+	return ret;
+}
+
+int wave6_vpu_enc_close(struct vpu_instance *inst, u32 *fail_res)
+{
+	int ret;
+
+	if (WARN_ON(!inst->codec_info))
+		return -EINVAL;
+
+	guard(mutex)(&inst->dev->hw_lock);
+
+	ret = wave6_vpu_enc_fini_seq(inst, fail_res);
+	if (ret)
+		dev_warn(inst->dev->dev, "enc seq end timed out\n");
+
+	kfree(inst->codec_info);
+	inst->codec_info = NULL;
+
+	return ret;
+}
+
+int wave6_vpu_enc_get_aux_buffer_size(struct vpu_instance *inst,
+				      struct aux_buffer_size_info info, u32 *size)
+{
+	struct enc_info *p_enc_info = &inst->codec_info->enc_info;
+	int width = info.width;
+	int height = info.height;
+	int buf_size, twice;
+
+	if (info.type == AUX_BUF_FBC_Y_TBL) {
+		switch (inst->std) {
+		case W_HEVC_ENC:
+		case W_AVC_ENC:
+			buf_size = WAVE6_FBC_LUMA_TABLE_SIZE(width, height);
+			break;
+		default:
+			return -EINVAL;
+		}
+	} else if (info.type == AUX_BUF_FBC_C_TBL) {
+		if (p_enc_info->c_fmt_idc == C_FMT_IDC_YUV422)
+			twice = 2;
+		else if (p_enc_info->c_fmt_idc == C_FMT_IDC_YUV444)
+			twice = 4;
+		else
+			twice = 1;
+
+		switch (inst->std) {
+		case W_HEVC_ENC:
+		case W_AVC_ENC:
+			buf_size = WAVE6_FBC_CHROMA_TABLE_SIZE(width, height);
+			break;
+		default:
+			return -EINVAL;
+		}
+		buf_size = buf_size * twice;
+	} else if (info.type == AUX_BUF_MV_COL) {
+		switch (inst->std) {
+		case W_HEVC_ENC:
+			buf_size = WAVE6_ENC_HEVC_MVCOL_BUF_SIZE(width, height);
+			break;
+		case W_AVC_ENC:
+			buf_size = WAVE6_ENC_AVC_MVCOL_BUF_SIZE(width, height);
+			break;
+		default:
+			return -EINVAL;
+		}
+	} else if (info.type == AUX_BUF_SUB_SAMPLE) {
+		switch (inst->std) {
+		case W_HEVC_ENC:
+		case W_AVC_ENC:
+			buf_size = WAVE6_ENC_SUBSAMPLED_SIZE(width, height);
+			break;
+		default:
+			return -EINVAL;
+		}
+	} else {
+		return -EINVAL;
+	}
+
+	*size = buf_size;
+
+	return 0;
+}
+
+int wave6_vpu_enc_complete_seq_init(struct vpu_instance *inst,
+				    struct enc_seq_info *info)
+{
+	struct enc_info *p_enc_info = &inst->codec_info->enc_info;
+	int ret;
+
+	guard(mutex)(&inst->dev->hw_lock);
+
+	ret = wave6_vpu_enc_get_seq_info(inst, info);
+	if (ret) {
+		p_enc_info->seq_info_obtained = false;
+		return ret;
+	}
+
+	if (!p_enc_info->seq_info_obtained) {
+		p_enc_info->seq_info_obtained = true;
+		p_enc_info->seq_info = *info;
+	}
+
+	return 0;
+}
diff --git a/drivers/media/platform/chips-media/wave6/wave6-vpuapi.h b/drivers/media/platform/chips-media/wave6/wave6-vpuapi.h
index d8d7b7916d88..d5ecf381276d 100644
--- a/drivers/media/platform/chips-media/wave6/wave6-vpuapi.h
+++ b/drivers/media/platform/chips-media/wave6/wave6-vpuapi.h
@@ -56,6 +56,12 @@ enum vpu_instance_state {
 	(ALIGN((_w), 256) * ALIGN((_h), 64) / 32)
 #define WAVE6_FBC_CHROMA_TABLE_SIZE(_w, _h) \
 	(ALIGN(((_w) / 2), 256) * ALIGN((_h), 64) / 32)
+#define WAVE6_ENC_AVC_MVCOL_BUF_SIZE(_w, _h) \
+	((ALIGN((_w), 512) / 512) * (ALIGN((_h), 16) / 16) * 16)
+#define WAVE6_ENC_HEVC_MVCOL_BUF_SIZE(_w, _h) \
+	((ALIGN((_w), 64) / 64) * (ALIGN((_h), 64) / 64) * 128)
+#define WAVE6_ENC_SUBSAMPLED_SIZE(_w, _h) \
+	(ALIGN(((_w) / 4), 16) * ALIGN(((_h) / 4), 32))
 
 enum codec_std {
 	W_HEVC_DEC	= 0x00,
@@ -78,6 +84,28 @@ enum codec_std {
 
 #define H264_VUI_SAR_IDC_EXTENDED 255
 
+#define DEC_REFRESH_TYPE_NON_IRAP 0
+#define DEC_REFRESH_TYPE_IDR 2
+
+#define DEFAULT_TEMP_LAYER_CNT 1
+#define DEFAULT_RC_INITIAL_LEVEL 8
+#define DEFAULT_RC_INITIAL_QP -1
+#define DEFAULT_PIC_RC_MAX_DQP 3
+#define DEFAULT_QROUND_INTER 85
+#define DEFAULT_QROUND_INTRA 171
+#define DEFAULT_INTRA_4X4 3
+#define DEFAULT_NUM_TICKS_POC_DIFF 1
+#define DEFAULT_RC_UPDATE_SPEED_CBR 64
+#define DEFAULT_RC_UPDATE_SPEED_VBR 16
+#define MAX_INTRA_INTER_PIC_BIT 1500000000
+#define DEFAULT_FRAME_RATE 30
+#define MIN_FRAME_RATE 1
+#define MAX_FRAME_RATE 960
+#define DEFAULT_CPB_SIZE 10000
+#define MIN_CPB_SIZE 10
+#define MAX_CPB_SIZE 100000
+#define AVC_MIN_SLICE_MAX_MB 4
+
 #define SEQ_CHANGE_ENABLE_PROFILE BIT(5)
 #define SEQ_CHANGE_ENABLE_SIZE BIT(16)
 #define SEQ_CHANGE_ENABLE_BIT_DEPTH BIT(18)
@@ -95,6 +123,11 @@ enum codec_std {
 #define DEC_NOTI_FLAG_NO_FB		BIT(1)
 #define DEC_NOTI_FLAG_SEQ_CHANGE	BIT(0)
 
+#define RECON_IDX_FLAG_ENC_END -1
+#define RECON_IDX_FLAG_ENC_DELAY -2
+#define RECON_IDX_FLAG_HEADER_ONLY -3
+#define RECON_IDX_FLAG_CHANGE_PARAM -4
+
 #define FW_VERSION_MAJOR_MASK	0xFF000000
 #define FW_VERSION_MINOR_MASK	0x00FF0000
 #define FW_VERSION_REL_MASK	0x0000FFFF
@@ -102,6 +135,20 @@ enum codec_std {
 #define FW_VERSION_MINOR(x)	FIELD_GET(FW_VERSION_MINOR_MASK, (x))
 #define FW_VERSION_REL(x)	FIELD_GET(FW_VERSION_REL_MASK, (x))
 
+enum mirror_direction {
+	MIR_NONE,
+	MIR_VER,
+	MIR_HOR,
+	MIR_HOR_VER
+};
+
+enum rotation_angle {
+	ROT_0 = 0,
+	ROT_90 = 90,
+	ROT_180 = 180,
+	ROT_270 = 270
+};
+
 enum chroma_format_idc {
 	C_FMT_IDC_YUV400,
 	C_FMT_IDC_YUV420,
@@ -110,6 +157,28 @@ enum chroma_format_idc {
 	C_FMT_IDC_RGB
 };
 
+enum csc_format_order {
+	CSC_FMT_ORDER_RGB	= 0,
+	CSC_FMT_ORDER_RBG	= 1,
+	CSC_FMT_ORDER_GRB	= 2,
+	CSC_FMT_ORDER_GBR	= 3,
+	CSC_FMT_ORDER_BGR	= 4,
+	CSC_FMT_ORDER_BRG	= 5,
+
+	CSC_FMT_ORDER_ARGB	= 0,
+	CSC_FMT_ORDER_ARBG	= 1,
+	CSC_FMT_ORDER_AGRB	= 2,
+	CSC_FMT_ORDER_AGBR	= 3,
+	CSC_FMT_ORDER_ABGR	= 4,
+	CSC_FMT_ORDER_ABRG	= 5,
+	CSC_FMT_ORDER_RGBA	= 8,
+	CSC_FMT_ORDER_RBGA	= 9,
+	CSC_FMT_ORDER_GRBA	= 10,
+	CSC_FMT_ORDER_GBRA	= 11,
+	CSC_FMT_ORDER_BGRA	= 12,
+	CSC_FMT_ORDER_BRGA	= 13,
+};
+
 enum frame_buffer_format {
 	FORMAT_ERR = -1,
 
@@ -183,6 +252,14 @@ enum pic_type {
 	PIC_TYPE_MAX
 };
 
+enum enc_force_pic_type {
+	ENC_FORCE_PIC_TYPE_I = 0,
+	ENC_FORCE_PIC_TYPE_P = 1,
+	ENC_FORCE_PIC_TYPE_B = 2,
+	ENC_FORCE_PIC_TYPE_IDR = 3,
+	ENC_FORCE_PIC_TYPE_DISABLED = 4,
+};
+
 enum display_mode {
 	DISP_MODE_DISP_ORDER,
 	DISP_MODE_DEC_ORDER,
@@ -207,6 +284,12 @@ enum aux_buffer_type {
 	AUX_BUF_TYPE_MAX,
 };
 
+enum intra_refresh_mode {
+	INTRA_REFRESH_NONE = 0,
+	INTRA_REFRESH_ROW = 1,
+	INTRA_REFRESH_COLUMN = 2,
+};
+
 struct vpu_attr {
 	u32 product_id;
 	u32 product_code;
@@ -243,9 +326,17 @@ struct vpu_rect {
 	u32 bottom;
 };
 
+struct sar_info {
+	u32 enable;
+	u32 idc;
+	u32 width;
+	u32 height;
+};
+
 struct instance_buffer {
 	dma_addr_t temp_base;
 	u32 temp_size;
+	dma_addr_t ar_base;
 };
 
 struct color_param {
@@ -260,6 +351,8 @@ struct color_param {
 struct sec_axi_info {
 	bool use_dec_ip;
 	bool use_dec_lf_row;
+	bool use_enc_rdo;
+	bool use_enc_lf;
 };
 
 struct aux_buffer_size_info {
@@ -358,6 +451,320 @@ struct dec_info {
 	enum frame_buffer_format out_fmt;
 };
 
+#define MAX_CUSTOM_LAMBDA_NUM 52
+#define MAX_NUM_TEMP_LAYER 7
+#define MAX_CUSTOM_GOP_NUM 8
+#define MAX_NUM_CHANGEABLE_TEMP_LAYER 4
+
+struct custom_gop_pic_param {
+	int pic_type;
+	int poc_offset;
+	int pic_qp;
+	bool multi_ref_p;
+	int ref_poc_l0;
+	int ref_poc_l1;
+	int temporal_id;
+};
+
+struct custom_gop_param {
+	int size;
+	struct custom_gop_pic_param pic[MAX_CUSTOM_GOP_NUM];
+};
+
+struct temporal_layer_param {
+	bool change_qp;
+	u32 qp_i;
+	u32 qp_p;
+	u32 qp_b;
+};
+
+struct enc_scaler_info {
+	bool enable;
+	int width;
+	int height;
+	int coef_mode;
+};
+
+struct enc_codec_param {
+	u32 internal_bit_depth;
+	u32 decoding_refresh_type;
+	u32 idr_period;
+	u32 intra_period;
+	u32 gop_preset_idx;
+	u32 frame_rate;
+	u32 bitrate;
+	u32 cpb_size;
+	u32 hvs_qp_scale_div2;
+	u32 max_delta_qp;
+	int rc_initial_qp;
+	u32 rc_update_speed;
+	u32 max_bitrate;
+	u32 rc_mode;
+	u32 rc_initial_level;
+	u32 pic_rc_max_dqp;
+	u32 bg_th_diff;
+	u32 bg_th_mean_diff;
+	int bg_delta_qp;
+	u32 intra_refresh_mode;
+	u32 intra_refresh_arg;
+	int beta_offset_div2;
+	int tc_offset_div2;
+	u32 qp;
+	u32 min_qp_i;
+	u32 max_qp_i;
+	u32 min_qp_p;
+	u32 max_qp_p;
+	u32 min_qp_b;
+	u32 max_qp_b;
+	int cb_qp_offset;
+	int cr_qp_offset;
+	u32 qround_intra;
+	u32 qround_inter;
+	int lambda_dqp_intra;
+	int lambda_dqp_inter;
+	u32 slice_mode;
+	u32 slice_arg;
+	u32 level;
+	u32 tier;
+	u32 profile;
+	struct vpu_rect conf_win;
+	u32 forced_idr_header;
+	u16 lambda_ssd[MAX_CUSTOM_LAMBDA_NUM];
+	u16 lambda_sad[MAX_CUSTOM_LAMBDA_NUM];
+	struct custom_gop_param gop_param;
+	struct temporal_layer_param temp_layer[MAX_NUM_CHANGEABLE_TEMP_LAYER];
+	u32 temp_layer_cnt;
+	u32 mv_histo_th0;
+	u32 mv_histo_th1;
+	u32 mv_histo_th2;
+	u32 mv_histo_th3;
+	u32 num_units_in_tick;
+	u32 time_scale;
+	u32 num_ticks_poc_diff_one;
+	struct color_param color;
+	struct sar_info sar;
+	u32 max_intra_pic_bit;
+	u32 max_inter_pic_bit;
+	u32 intra_4x4;
+
+	u32 en_const_intra_pred: 1;
+	u32 en_longterm: 1;
+	u32 en_rate_control: 1;
+	u32 en_transform8x8: 1;
+	u32 en_hvs_qp: 1;
+	u32 en_bg_detect: 1;
+	u32 en_temporal_mvp: 1;
+	u32 en_cabac: 1;
+	u32 en_dbk: 1;
+	u32 en_sao: 1;
+	u32 en_lf_slice_boundary: 1;
+	u32 en_scaling_list: 1;
+	u32 en_qround_offset: 1;
+	u32 en_still_picture: 1;
+	u32 en_intra_smooth: 1;
+	u32 en_custom_lambda: 1;
+	u32 en_report_mv_histo: 1;
+	u32 en_cu_level_rate_control: 1;
+	u32 en_skip_frame: 1;
+};
+
+struct enc_open_param {
+	int pic_width;
+	int pic_height;
+	struct enc_codec_param codec_param;
+	enum endian_mode source_endian;
+	enum frame_buffer_format src_fmt;
+	enum frame_buffer_format out_fmt;
+	u32 ext_addr_vcpu: 8;
+	u32 is_secure_inst: 1;
+	u32 inst_priority: 5;
+	struct instance_buffer inst_buffer;
+	enum mirror_direction mir_dir;
+	enum rotation_angle rot_angle;
+};
+
+struct enc_seq_info {
+	u32 min_frame_buffer_count: 5;
+	u32 min_src_frame_count;
+	u32 req_mv_buffer_count: 5;
+	int max_latency_pictures;
+	int err_reason;
+	int warn_info;
+};
+
+struct enc_csc_param {
+	u32 fmt_order;
+	s32 coef_ry;
+	s32 coef_gy;
+	s32 coef_by;
+	s32 coef_rcb;
+	s32 coef_gcb;
+	s32 coef_bcb;
+	s32 coef_rcr;
+	s32 coef_gcr;
+	s32 coef_bcr;
+	u32 offset_y;
+	u32 offset_cb;
+	u32 offset_cr;
+};
+
+struct enc_param {
+	struct frame_buffer *source_frame;
+	bool skip_picture;
+	dma_addr_t pic_stream_buffer_addr;
+	int pic_stream_buffer_size;
+	bool force_pic_qp;
+	int force_pic_qp_i;
+	int force_pic_qp_p;
+	int force_pic_qp_b;
+	bool force_pic;
+	int force_pic_type;
+	int src_idx;
+	u32 bitrate;
+	struct enc_csc_param csc;
+	u64 timestamp;
+};
+
+struct enc_report_fme_sum {
+	u32 lower_x0;
+	u32 higher_x0;
+	u32 lower_y0;
+	u32 higher_y0;
+	u32 lower_x1;
+	u32 higher_x1;
+	u32 lower_y1;
+	u32 higher_y1;
+};
+
+struct enc_report_mv_histo {
+	u32 cnt0;
+	u32 cnt1;
+	u32 cnt2;
+	u32 cnt3;
+	u32 cnt4;
+};
+
+struct enc_output_info {
+	dma_addr_t bitstream_buffer;
+	u32 bitstream_size;
+	int pic_type;
+	int num_of_slices;
+	int recon_frame_index;
+	dma_addr_t rd_ptr;
+	dma_addr_t wr_ptr;
+	int pic_skipped;
+	int num_of_intra;
+	int num_of_merge;
+	int num_of_skip_block;
+	int avg_ctu_qp;
+	int enc_pic_byte;
+	int enc_gop_pic_idx;
+	int enc_pic_poc;
+	int enc_src_idx;
+	int enc_vcl_nut;
+	int enc_pic_cnt;
+	int error_reason;
+	int warn_info;
+	u32 pic_distortion_low;
+	u32 pic_distortion_high;
+	bool non_ref_pic;
+	bool encoding_success;
+	struct enc_report_fme_sum fme_sum;
+	struct enc_report_mv_histo mv_histo;
+	u64 timestamp;
+	dma_addr_t src_y_addr;
+	dma_addr_t custom_map_addr;
+	dma_addr_t prefix_sei_nal_addr;
+	dma_addr_t suffix_sei_nal_addr;
+};
+
+enum gop_preset_idx {
+	PRESET_IDX_CUSTOM_GOP = 0,
+	PRESET_IDX_ALL_I = 1,
+	PRESET_IDX_IPP = 2,
+	PRESET_IDX_IBBB = 3,
+	PRESET_IDX_IBPBP = 4,
+	PRESET_IDX_IBBBP = 5,
+	PRESET_IDX_IPPPP = 6,
+	PRESET_IDX_IBBBB = 7,
+	PRESET_IDX_RA_IB = 8,
+	PRESET_IDX_IPP_SINGLE = 9,
+	PRESET_IDX_MAX,
+};
+
+struct enc_info {
+	struct enc_open_param open_param;
+	struct enc_seq_info seq_info;
+	enum mirror_direction mir_dir;
+	enum rotation_angle rot_angle;
+	bool seq_info_obtained;
+	struct sec_axi_info sec_axi;
+	u32 width;
+	u32 height;
+	struct enc_scaler_info scaler;
+	enum chroma_format_idc c_fmt_idc;
+};
+
+struct h264_enc_controls {
+	u32 profile;
+	u32 level;
+	u32 min_qp;
+	u32 max_qp;
+	u32 i_frame_qp;
+	u32 p_frame_qp;
+	u32 b_frame_qp;
+	u32 loop_filter_mode;
+	u32 loop_filter_beta;
+	u32 loop_filter_alpha;
+	u32 _8x8_transform;
+	u32 constrained_intra_prediction;
+	u32 chroma_qp_index_offset;
+	u32 entropy_mode;
+	u32 i_period;
+	u32 vui_sar_enable;
+	u32 vui_sar_idc;
+	u32 vui_ext_sar_width;
+	u32 vui_ext_sar_height;
+	u32 cpb_size;
+};
+
+struct hevc_enc_controls {
+	u32 profile;
+	u32 level;
+	u32 min_qp;
+	u32 max_qp;
+	u32 i_frame_qp;
+	u32 p_frame_qp;
+	u32 b_frame_qp;
+	u32 loop_filter_mode;
+	u32 lf_beta_offset_div2;
+	u32 lf_tc_offset_div2;
+	u32 refresh_type;
+	u32 refresh_period;
+	u32 const_intra_pred;
+	u32 strong_smoothing;
+	u32 tmv_prediction;
+};
+
+struct enc_controls {
+	u32 frame_rate;
+	u32 rotation_angle;
+	u32 mirror_direction;
+	u32 bitrate;
+	u32 bitrate_mode;
+	u32 gop_size;
+	u32 frame_rc_enable;
+	u32 mb_rc_enable;
+	u32 slice_mode;
+	u32 slice_max_mb;
+	u32 prepend_spspps_to_idr;
+	u32 intra_refresh_period;
+	struct h264_enc_controls h264;
+	struct hevc_enc_controls hevc;
+	u32 force_key_frame;
+	u32 frame_skip_mode;
+};
+
 /**
  * struct vpu_irq - VPU interrupt information
  * @status:	Value of the VPU interrupt status
@@ -441,6 +848,7 @@ struct vpu_instance_ops {
  * @src_fmt:		V4L2 pixel format for source
  * @dst_fmt:		V4L2 pixel format for destination
  * @crop:		Crop rectangle
+ * @codec_rect:		Actual encoding rectangle
  * @scaler_info:	Decoder scaler information
  * @colorspace:		V4L2 colorspace
  * @xfer_func:		V4L2 transfer function
@@ -456,6 +864,7 @@ struct vpu_instance_ops {
  * @frame_buf:		Metadata for reference frame buffers
  * @frame_vbuf:		Reference frame buffers
  * @aux_vbuf:		Auxiliary buffers
+ * @ar_vbuf:		Auxiliary AR buffer for encoder
  * @fbc_buf_registered:	Reference frame buffers registration flag
  * @queued_src_buf_num:	number of queued source buffers
  * @queued_dst_buf_num:	number of queued destination buffers
@@ -467,7 +876,9 @@ struct vpu_instance_ops {
  * @next_dst_buf_last:	Next queued CAPTURE buffer is returned as the last one
  * @cbcr_interleave:	CbCr interleave format flag
  * @nv21:		NV21 format flag
+ * @error_recovery:	Error recovery flag
  * @disp_mode:		Display mode for decoder V4L2 control
+ * @enc_ctrls:		Encoder V4L2 control and streaming parameters
  */
 struct vpu_instance {
 	struct list_head list;
@@ -489,6 +900,7 @@ struct vpu_instance {
 	struct v4l2_pix_format_mplane src_fmt;
 	struct v4l2_pix_format_mplane dst_fmt;
 	struct v4l2_rect crop;
+	struct v4l2_rect codec_rect;
 	struct dec_scaler_info scaler_info;
 	enum v4l2_colorspace colorspace;
 	enum v4l2_xfer_func xfer_func;
@@ -503,11 +915,13 @@ struct vpu_instance {
 	enum codec_std std;
 	u32 id;
 	union {
+		struct enc_info enc_info;
 		struct dec_info dec_info;
 	} *codec_info;
 	struct frame_buffer frame_buf[WAVE6_MAX_FBS];
 	struct vpu_buf frame_vbuf[WAVE6_MAX_FBS];
 	struct vpu_buf aux_vbuf[AUX_BUF_TYPE_MAX][WAVE6_MAX_FBS];
+	struct vpu_buf ar_vbuf;
 	bool fbc_buf_registered;
 	u32 queued_src_buf_num;
 	u32 queued_dst_buf_num;
@@ -519,8 +933,10 @@ struct vpu_instance {
 	bool next_dst_buf_last;
 	bool cbcr_interleave;
 	bool nv21;
+	bool error_recovery;
 
 	enum display_mode disp_mode;
+	struct enc_controls enc_ctrls;
 };
 
 void wave6_vpu_writel(struct vpu_core_device *core, u32 addr, u32 data);
@@ -548,4 +964,16 @@ void wave6_vpu_dec_get_bitstream_buffer(struct vpu_instance *inst,
 int wave6_vpu_dec_update_bitstream_buffer(struct vpu_instance *inst, int size);
 int wave6_vpu_dec_flush_instance(struct vpu_instance *inst);
 
+int wave6_vpu_enc_open(struct vpu_instance *inst, struct enc_open_param *enc_op_param);
+int wave6_vpu_enc_close(struct vpu_instance *inst, u32 *fail_res);
+int wave6_vpu_enc_issue_seq_init(struct vpu_instance *inst);
+int wave6_vpu_enc_issue_seq_change(struct vpu_instance *inst, bool *changed);
+int wave6_vpu_enc_complete_seq_init(struct vpu_instance *inst, struct enc_seq_info *info);
+int wave6_vpu_enc_get_aux_buffer_size(struct vpu_instance *inst,
+				      struct aux_buffer_size_info info, u32 *size);
+int wave6_vpu_enc_register_frame_buffer(struct vpu_instance *inst);
+int wave6_vpu_enc_start_one_frame(struct vpu_instance *inst, struct enc_param *param,
+				  u32 *fail_res);
+int wave6_vpu_enc_get_output_info(struct vpu_instance *inst, struct enc_output_info *info);
+
 #endif /* __WAVE6_VPUAPI_H__ */
diff --git a/drivers/media/platform/chips-media/wave6/wave6-vpuconfig.h b/drivers/media/platform/chips-media/wave6/wave6-vpuconfig.h
index ef261b5d328c..36daea5d02d1 100644
--- a/drivers/media/platform/chips-media/wave6/wave6-vpuconfig.h
+++ b/drivers/media/platform/chips-media/wave6/wave6-vpuconfig.h
@@ -30,6 +30,17 @@
 #define W6_MAX_DEC_PIC_HEIGHT		4096
 #define W6_DEC_PIC_SIZE_STEP		1
 
+#define W6_DEF_ENC_PIC_WIDTH		416
+#define W6_DEF_ENC_PIC_HEIGHT		240
+#define W6_MIN_ENC_PIC_WIDTH		256
+#define W6_MIN_ENC_PIC_HEIGHT		128
+#define W6_MAX_ENC_PIC_WIDTH		4096
+#define W6_MAX_ENC_PIC_HEIGHT		4096
+#define W6_ENC_PIC_SIZE_STEP		8
+#define W6_ENC_CROP_X_POS_STEP		32
+#define W6_ENC_CROP_Y_POS_STEP		8
+#define W6_ENC_CROP_STEP		2
+
 #define W6_VPU_POLL_DELAY_US		10
 #define W6_VPU_POLL_TIMEOUT		300000
 #define W6_BOOT_WAIT_TIMEOUT		10000
@@ -38,13 +49,16 @@
 
 #define HOST_ENDIAN			VDI_128BIT_LITTLE_ENDIAN
 #define VPU_STREAM_ENDIAN		HOST_ENDIAN
+#define VPU_USER_DATA_ENDIAN		HOST_ENDIAN
 #define VPU_SOURCE_ENDIAN		HOST_ENDIAN
 
 #define W6_MAX_REMAP_PAGE_SIZE		(1024 * 1024)
+#define W6_ARBUF_SIZE			(1024)
 #define W6_MAX_CODE_BUF_SIZE		(4 * 1024 * 1024)
 #define W6_CODE_BUF_SIZE		(1 * 1024 * 1024)
 #define W6_EXTRA_CODE_BUF_SIZE		(256 * 1024)
 #define W6_TEMPBUF_SIZE			(3 * 1024 * 1024)
+#define W627ENC_WORKBUF_SIZE		(512 * 1024)
 #define W637DEC_WORKBUF_SIZE		(2 * 512 * 1024)
 #define W637DEC_WORKBUF_SIZE_FOR_CQ	(3 * 512 * 1024)
 
-- 
2.41.0.windows.3


  parent reply	other threads:[~2026-11-19  9:00 UTC|newest]

Thread overview: 12+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-19  8:59 [PATCH v8 00/11] Add support for Wave6 video codec driver Nas Chung
2026-11-19  8:59 ` [PATCH v8 01/11] dt-bindings: media: nxp: Add Wave6 video codec device Nas Chung
2026-11-19  8:59 ` [PATCH v8 02/11] media: chips-media: wave6: Add Wave6 control driver Nas Chung
2026-11-19  8:59 ` [PATCH v8 03/11] media: chips-media: wave6: Add Wave6 core driver Nas Chung
2026-11-19  8:59 ` [PATCH v8 04/11] media: chips-media: wave6: Add Wave6 decoder firmware interface Nas Chung
2026-11-19  8:59 ` [PATCH v8 05/11] media: chips-media: wave6: Add Wave6 m2m decoder Nas Chung
2026-11-19  9:00 ` Nas Chung [this message]
2026-11-19  9:00 ` [PATCH v8 07/11] media: chips-media: wave6: Add Wave6 m2m encoder Nas Chung
2026-11-19  9:00 ` [PATCH v8 08/11] media: chips-media: wave6: Add trace and debugfs Nas Chung
2026-11-19  9:00 ` [PATCH v8 09/11] media: chips-media: wave6: Add performance profiling Nas Chung
2026-11-19  9:00 ` [PATCH v8 10/11] media: chips-media: wave6: Add Wave6 thermal cooling device Nas Chung
2026-11-19  9:00 ` [PATCH v8 11/11] arm64: dts: freescale: imx95: Add video codec node Nas Chung

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=85ce28c44e167aa05ffc19dc02ce2be26dd99893.1795075581.git.nas.chung@chipsnmedia.com \
    --to=nas.chung@chipsnmedia.com \
    --cc=Frank.Li@nxp.com \
    --cc=conor+dt@kernel.org \
    --cc=devicetree@vger.kernel.org \
    --cc=festevam@gmail.com \
    --cc=hverkuil@kernel.org \
    --cc=imx@lists.linux.dev \
    --cc=jackson.lee@chipsnmedia.com \
    --cc=kernel@pengutronix.de \
    --cc=krzk+dt@kernel.org \
    --cc=lafley.kim@chipsnmedia.com \
    --cc=linux-arm-kernel@lists.infradead.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-media@vger.kernel.org \
    --cc=marek.vasut@mailbox.org \
    --cc=mchehab@kernel.org \
    --cc=ming.qian@oss.nxp.com \
    --cc=nicolas.dufresne@collabora.com \
    --cc=robh@kernel.org \
    --cc=s.hauer@pengutronix.de \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®