diff --git a/drivers/media/platform/rockchip/isp/capture_v39.c b/drivers/media/platform/rockchip/isp/capture_v39.c
index 9b99916dc81e..10c6438813bf 100644
--- a/drivers/media/platform/rockchip/isp/capture_v39.c
+++ b/drivers/media/platform/rockchip/isp/capture_v39.c
@@ -462,7 +462,8 @@ static int rkisp_stream_config_dcrop(struct rkisp_stream *stream, bool async)
 
 	if (dcrop->width == input_win->width &&
 	    dcrop->height == input_win->height &&
-	    dcrop->left == 0 && dcrop->top == 0) {
+	    dcrop->left == 0 && dcrop->top == 0 &&
+	    dev->unite_div < ISP_UNITE_DIV2) {
 		rkisp_disable_dcrop(stream, async);
 		v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
 			 "stream %d crop disabled\n", stream->id);
@@ -608,21 +609,21 @@ static int mp_config_mi(struct rkisp_stream *stream)
 	*/
 	val = out_fmt->plane_fmt[0].bytesperline;
 	val /= DIV_ROUND_UP(fmt->bpp[0], 8);
-	rkisp_write(dev, ISP3X_MI_MP_WR_Y_LLENGTH, val, false);
+	rkisp_unite_write(dev, ISP3X_MI_MP_WR_Y_LLENGTH, val, false);
 	val *= height;
-	rkisp_write(dev, stream->config->mi.y_pic_size, val, false);
+	rkisp_unite_write(dev, stream->config->mi.y_pic_size, val, false);
 	val = out_fmt->plane_fmt[0].bytesperline * height;
-	rkisp_write(dev, stream->config->mi.y_size_init, val, false);
+	rkisp_unite_write(dev, stream->config->mi.y_size_init, val, false);
 
 	val = out_fmt->plane_fmt[1].sizeimage;
-	rkisp_write(dev, stream->config->mi.cb_size_init, val, false);
+	rkisp_unite_write(dev, stream->config->mi.cb_size_init, val, false);
 
 	val = out_fmt->plane_fmt[2].sizeimage;
-	rkisp_write(dev, stream->config->mi.cr_size_init, val, false);
+	rkisp_unite_write(dev, stream->config->mi.cr_size_init, val, false);
 
 	val = stream->out_isp_fmt.uv_swap ? ISP3X_MI_XTD_FORMAT_MP_UV_SWAP : 0;
 	mask = ISP3X_MI_XTD_FORMAT_MP_UV_SWAP;
-	rkisp_set_bits(dev, ISP3X_MI_WR_XTD_FORMAT_CTRL, mask, val, false);
+	rkisp_unite_set_bits(dev, ISP3X_MI_WR_XTD_FORMAT_CTRL, mask, val, false);
 
 	mask = ISP3X_MPFBC_FORCE_UPD | ISP3X_MP_YUV_MODE;
 	val = rkisp_read_reg_cache(dev, ISP3X_MPFBC_CTRL) & ~mask;
@@ -634,24 +635,24 @@ static int mp_config_mi(struct rkisp_stream *stream)
 		val |= ISP3X_SEPERATE_YUV_CFG;
 	else
 		val |= ISP3X_SEPERATE_YUV_CFG | ISP3X_MP_YUV_MODE;
-	rkisp_write(dev, ISP3X_MPFBC_CTRL, val, false);
+	rkisp_unite_write(dev, ISP3X_MPFBC_CTRL, val, false);
 
 	val = stream->out_isp_fmt.output_format;
-	rkisp_write(dev, ISP32_MI_MP_WR_CTRL, val, false);
+	rkisp_unite_write(dev, ISP32_MI_MP_WR_CTRL, val, false);
 
 	val = calc_burst_len(stream) | CIF_MI_CTRL_INIT_BASE_EN |
 		CIF_MI_CTRL_INIT_OFFSET_EN | CIF_MI_MP_AUTOUPDATE_ENABLE |
 		stream->out_isp_fmt.write_format;
 	mask = GENMASK(19, 16) | MI_CTRL_MP_FMT_MASK;
-	rkisp_set_bits(dev, ISP3X_MI_WR_CTRL, mask, val, false);
+	rkisp_unite_set_bits(dev, ISP3X_MI_WR_CTRL, mask, val, false);
 
 	mi_frame_end_int_enable(stream);
 	/* set up first buffer */
 	mi_frame_end(stream, FRAME_INIT);
 
-	rkisp_write(dev, stream->config->mi.y_offs_cnt_init, 0, false);
-	rkisp_write(dev, stream->config->mi.cb_offs_cnt_init, 0, false);
-	rkisp_write(dev, stream->config->mi.cr_offs_cnt_init, 0, false);
+	rkisp_unite_write(dev, stream->config->mi.y_offs_cnt_init, 0, false);
+	rkisp_unite_write(dev, stream->config->mi.cb_offs_cnt_init, 0, false);
+	rkisp_unite_write(dev, stream->config->mi.cr_offs_cnt_init, 0, false);
 	return 0;
 }
 
@@ -701,21 +702,21 @@ static int sp_config_mi(struct rkisp_stream *stream)
 	* memory plane formats, so calculate the size explicitly.
 	*/
 	val = stream->u.sp.y_stride;
-	rkisp_write(dev, ISP3X_MI_SP_WR_Y_LLENGTH, val, false);
+	rkisp_unite_write(dev, ISP3X_MI_SP_WR_Y_LLENGTH, val, false);
 	val *= out_fmt->height;
-	rkisp_write(dev, stream->config->mi.y_pic_size, val, false);
+	rkisp_unite_write(dev, stream->config->mi.y_pic_size, val, false);
 	val = out_fmt->plane_fmt[0].bytesperline * out_fmt->height;
-	rkisp_write(dev, stream->config->mi.y_size_init, val, false);
+	rkisp_unite_write(dev, stream->config->mi.y_size_init, val, false);
 
 	val = out_fmt->plane_fmt[1].sizeimage;
-	rkisp_write(dev, stream->config->mi.cb_size_init, val, false);
+	rkisp_unite_write(dev, stream->config->mi.cb_size_init, val, false);
 
 	val = out_fmt->plane_fmt[2].sizeimage;
-	rkisp_write(dev, stream->config->mi.cr_size_init, val, false);
+	rkisp_unite_write(dev, stream->config->mi.cr_size_init, val, false);
 
 	val = stream->out_isp_fmt.uv_swap ? ISP3X_MI_XTD_FORMAT_SP_UV_SWAP : 0;
 	mask = ISP3X_MI_XTD_FORMAT_SP_UV_SWAP;
-	rkisp_set_bits(dev, ISP3X_MI_WR_XTD_FORMAT_CTRL, mask, val, false);
+	rkisp_unite_set_bits(dev, ISP3X_MI_WR_XTD_FORMAT_CTRL, mask, val, false);
 
 	mask = ISP3X_MPFBC_FORCE_UPD | ISP3X_SP_YUV_MODE;
 	val = rkisp_read_reg_cache(dev, ISP3X_MPFBC_CTRL) & ~mask;
@@ -727,22 +728,22 @@ static int sp_config_mi(struct rkisp_stream *stream)
 		val |= ISP3X_SEPERATE_YUV_CFG;
 	else
 		val |= ISP3X_SEPERATE_YUV_CFG | ISP3X_SP_YUV_MODE;
-	rkisp_write(dev, ISP3X_MPFBC_CTRL, val, false);
+	rkisp_unite_write(dev, ISP3X_MPFBC_CTRL, val, false);
 
 	val = calc_burst_len(stream) | CIF_MI_CTRL_INIT_BASE_EN |
 		CIF_MI_CTRL_INIT_OFFSET_EN | stream->out_isp_fmt.write_format |
 		sp_in_fmt | stream->out_isp_fmt.output_format |
 		CIF_MI_SP_AUTOUPDATE_ENABLE;
 	mask = GENMASK(19, 16) | MI_CTRL_SP_FMT_MASK;
-	rkisp_set_bits(dev, ISP3X_MI_WR_CTRL, mask, val, false);
+	rkisp_unite_set_bits(dev, ISP3X_MI_WR_CTRL, mask, val, false);
 
 	mi_frame_end_int_enable(stream);
 	/* set up first buffer */
 	mi_frame_end(stream, FRAME_INIT);
 
-	rkisp_write(dev, stream->config->mi.y_offs_cnt_init, 0, false);
-	rkisp_write(dev, stream->config->mi.cb_offs_cnt_init, 0, false);
-	rkisp_write(dev, stream->config->mi.cr_offs_cnt_init, 0, false);
+	rkisp_unite_write(dev, stream->config->mi.y_offs_cnt_init, 0, false);
+	rkisp_unite_write(dev, stream->config->mi.cb_offs_cnt_init, 0, false);
+	rkisp_unite_write(dev, stream->config->mi.cr_offs_cnt_init, 0, false);
 	return 0;
 }
 
@@ -753,18 +754,18 @@ static int ldc_config_mi(struct rkisp_stream *stream)
 	u32 val;
 
 	val = out_fmt->width;
-	rkisp_write(dev, ISP39_LDCH_OUT_SIZE, val, false);
+	rkisp_unite_write(dev, ISP39_LDCH_OUT_SIZE, val, false);
 	val = out_fmt->height;
-	rkisp_write(dev, ISP39_LDCV_OUT_SIZE, val, false);
+	rkisp_unite_write(dev, ISP39_LDCV_OUT_SIZE, val, false);
 	val = out_fmt->plane_fmt[0].bytesperline;
-	rkisp_write(dev, ISP39_LDCV_WR_STRIDE, val, false);
+	rkisp_unite_write(dev, ISP39_LDCV_WR_STRIDE, val, false);
 	mi_frame_end(stream, FRAME_INIT);
-	rkisp_set_bits(dev, ISP3X_ISP_IMSC, 0, ISP39_LDCV_END, false);
+	rkisp_unite_set_bits(dev, ISP3X_ISP_IMSC, 0, ISP39_LDCV_END, false);
 	val = stream->out_isp_fmt.output_format;
 	if (stream->out_isp_fmt.uv_swap)
 		val |= ISP39_LDCV_UV_SWAP;
 	if (val)
-		rkisp_set_bits(dev, ISP39_LDCV_CTRL, ISP39_LDCV_FORCE_UPD, val, false);
+		rkisp_unite_set_bits(dev, ISP39_LDCV_CTRL, ISP39_LDCV_FORCE_UPD, val, false);
 	return 0;
 }
 
@@ -774,7 +775,7 @@ static void mp_enable_mi(struct rkisp_stream *stream)
 	u32 mask = CIF_MI_CTRL_MP_ENABLE | CIF_MI_CTRL_RAW_ENABLE;
 	u32 val = CIF_MI_CTRL_MP_ENABLE;
 
-	rkisp_set_bits(dev, ISP3X_MI_WR_CTRL, mask, val, false);
+	rkisp_unite_set_bits(dev, ISP3X_MI_WR_CTRL, mask, val, false);
 }
 
 static void sp_enable_mi(struct rkisp_stream *stream)
@@ -787,15 +788,15 @@ static void sp_enable_mi(struct rkisp_stream *stream)
 	if (fmt->fmt_type == FMT_RGB &&
 	    dev->isp_sdev.quantization == V4L2_QUANTIZATION_FULL_RANGE)
 		val |= mask;
-	rkisp_set_bits(stream->ispdev, ISP3X_MI_WR_CTRL, mask, val, false);
+	rkisp_unite_set_bits(stream->ispdev, ISP3X_MI_WR_CTRL, mask, val, false);
 }
 
 static void ldc_enable_mi(struct rkisp_stream *stream)
 {
 	struct rkisp_device *dev = stream->ispdev;
 
-	rkisp_set_bits(dev, ISP39_LDCV_CTRL, ISP39_LDCV_FORCE_UPD, 1, false);
-	rkisp_set_bits(dev, ISP3X_LDCH_STS, ISP3X_LDCH_FORCE_UPD, 1, false);
+	rkisp_unite_set_bits(dev, ISP39_LDCV_CTRL, ISP39_LDCV_FORCE_UPD, 1, false);
+	rkisp_unite_set_bits(dev, ISP3X_LDCH_STS, ISP3X_LDCH_FORCE_UPD, 1, false);
 }
 
 static void mp_disable_mi(struct rkisp_stream *stream)
@@ -803,13 +804,13 @@ static void mp_disable_mi(struct rkisp_stream *stream)
 	struct rkisp_device *dev = stream->ispdev;
 	u32 mask = CIF_MI_CTRL_MP_ENABLE | CIF_MI_CTRL_RAW_ENABLE;
 
-	rkisp_set_bits(dev, 0x1814, 0, BIT(0), false);
-	rkisp_clear_bits(stream->ispdev, ISP3X_MI_WR_CTRL, mask, false);
+	rkisp_unite_set_bits(dev, 0x1814, 0, BIT(0), false);
+	rkisp_unite_clear_bits(stream->ispdev, ISP3X_MI_WR_CTRL, mask, false);
 }
 
 static void sp_disable_mi(struct rkisp_stream *stream)
 {
-	rkisp_clear_bits(stream->ispdev, ISP3X_MI_WR_CTRL, CIF_MI_CTRL_SP_ENABLE, false);
+	rkisp_unite_clear_bits(stream->ispdev, ISP3X_MI_WR_CTRL, CIF_MI_CTRL_SP_ENABLE, false);
 }
 
 static void ldc_disable_mi(struct rkisp_stream *stream)
@@ -818,15 +819,17 @@ static void ldc_disable_mi(struct rkisp_stream *stream)
 	u32 val;
 
 	val = ISP3X_LDCH_EN | ISP3X_LDCH_FORCE_UPD;
-	rkisp_set_bits(dev, ISP3X_LDCH_STS, val, 0, false);
+	rkisp_unite_set_bits(dev, ISP3X_LDCH_STS, val, 0, false);
 
 	val = ISP39_LDCV_EN | ISP39_LDCV_FORCE_UPD;
-	rkisp_set_bits(dev, ISP39_LDCV_CTRL, val, 0, false);
+	rkisp_unite_set_bits(dev, ISP39_LDCV_CTRL, val, 0, false);
 }
 
 static void update_mi(struct rkisp_stream *stream)
 {
 	struct rkisp_device *dev = stream->ispdev;
+	struct v4l2_pix_format_mplane *out_fmt = &stream->out_fmt;
+	u32 div = stream->out_isp_fmt.fourcc == V4L2_PIX_FMT_UYVY ? 1 : 2;
 	u32 val, reg;
 
 	if (stream->next_buf) {
@@ -843,6 +846,27 @@ static void update_mi(struct rkisp_stream *stream)
 			val = stream->next_buf->buff_addr[RKISP_PLANE_CR];
 			rkisp_write(dev, reg, val, false);
 		}
+
+		if (dev->hw_dev->unite > ISP_UNITE_DIV1) {
+			/* right of image, or right top of image */
+			reg = stream->config->mi.y_base_ad_init;
+			val = stream->next_buf->buff_addr[RKISP_PLANE_Y];
+			val += ((out_fmt->width / div) & ~0xf);
+			rkisp_idx_write(dev, reg, val, ISP_UNITE_RIGHT, false);
+
+			reg = stream->config->mi.cb_base_ad_init;
+			val = stream->next_buf->buff_addr[RKISP_PLANE_CB];
+			val += ((out_fmt->width / div) & ~0xf);
+			rkisp_idx_write(dev, reg, val, ISP_UNITE_RIGHT, false);
+
+			if (stream->id != RKISP_STREAM_LDC) {
+				reg = stream->config->mi.cr_base_ad_init;
+				val = stream->next_buf->buff_addr[RKISP_PLANE_CR];
+				val += ((out_fmt->width / div) & ~0xf);
+				rkisp_idx_write(dev, reg, val, ISP_UNITE_RIGHT, false);
+			}
+		}
+
 		if (stream->is_pause) {
 			/* single sensor mode with pingpong buffer:
 			 * if mi on, addr will auto update at frame end
@@ -888,7 +912,7 @@ static void update_mi(struct rkisp_stream *stream)
 		/* no next buf to preclose mi */
 		stream->ops->disable_mi(stream);
 		/* no buf, force to close mi */
-		if (!stream->curr_buf)
+		if (!stream->curr_buf && dev->hw_dev->is_single)
 			stream_self_update(stream);
 	}
 
@@ -1618,6 +1642,8 @@ static int rkisp_stream_init(struct rkisp_device *dev, u32 id)
 		strscpy(vdev->name, SP_VDEV_NAME, sizeof(vdev->name));
 		stream->ops = &rkisp_sp_streams_ops;
 		stream->config = &rkisp_sp_stream_cfg;
+		if (dev->hw_dev->unite)
+			stream->config->max_rsz_width *= 2;
 		break;
 	case RKISP_STREAM_VIR:
 		strscpy(vdev->name, VIR_VDEV_NAME, sizeof(vdev->name));
@@ -1635,6 +1661,10 @@ static int rkisp_stream_init(struct rkisp_device *dev, u32 id)
 		strscpy(vdev->name, MP_VDEV_NAME, sizeof(vdev->name));
 		stream->ops = &rkisp_mp_streams_ops;
 		stream->config = &rkisp_mp_stream_cfg;
+		if (dev->hw_dev->unite) {
+			stream->config->max_rsz_width = CIF_ISP_INPUT_W_MAX_V39_UNITE;
+			stream->config->max_rsz_height = CIF_ISP_INPUT_H_MAX_V39_UNITE;
+		}
 	}
 
 	node = vdev_to_node(vdev);
@@ -1706,6 +1736,12 @@ void rkisp_mi_v39_isr(u32 mis_val, struct rkisp_device *dev)
 	v4l2_dbg(3, rkisp_debug, &dev->v4l2_dev,
 		 "mi isr:0x%x\n", mis_val);
 
+	if ((dev->unite_div == ISP_UNITE_DIV2 && dev->unite_index != ISP_UNITE_RIGHT) ||
+	    (dev->unite_div == ISP_UNITE_DIV4 && dev->unite_index != ISP_UNITE_RIGHT_B)) {
+		rkisp_write(dev, ISP3X_MI_ICR, mis_val, true);
+		goto end;
+	}
+
 	for (i = 0; i <= RKISP_STREAM_SP; ++i) {
 		stream = &dev->cap_dev.stream[i];
 
@@ -1737,7 +1773,7 @@ void rkisp_mi_v39_isr(u32 mis_val, struct rkisp_device *dev)
 			mi_frame_end(stream, FRAME_IRQ);
 		}
 	}
-
+end:
 	if (mis_val & ISP3X_MI_MP_FRAME) {
 		stream = &dev->cap_dev.stream[RKISP_STREAM_MP];
 		if (!stream->streaming)
diff --git a/drivers/media/platform/rockchip/isp/isp_params_v39.c b/drivers/media/platform/rockchip/isp/isp_params_v39.c
index a1328e5dce3b..c9ed7703f4b2 100644
--- a/drivers/media/platform/rockchip/isp/isp_params_v39.c
+++ b/drivers/media/platform/rockchip/isp/isp_params_v39.c
@@ -32,9 +32,9 @@ isp3_param_write_direct(struct rkisp_isp_params_vdev *params_vdev,
 
 static inline void
 isp3_param_write(struct rkisp_isp_params_vdev *params_vdev,
-		 u32 value, u32 addr)
+		 u32 value, u32 addr, u32 id)
 {
-	rkisp_write(params_vdev->dev, addr, value, false);
+	rkisp_idx_write(params_vdev->dev, addr, value, id, false);
 }
 
 static inline u32
@@ -44,45 +44,45 @@ isp3_param_read_direct(struct rkisp_isp_params_vdev *params_vdev, u32 addr)
 }
 
 static inline u32
-isp3_param_read(struct rkisp_isp_params_vdev *params_vdev, u32 addr)
+isp3_param_read(struct rkisp_isp_params_vdev *params_vdev, u32 addr, u32 id)
 {
-	return rkisp_read(params_vdev->dev, addr, false);
+	return rkisp_idx_read(params_vdev->dev, addr, id, false);
 }
 
 static inline u32
-isp3_param_read_cache(struct rkisp_isp_params_vdev *params_vdev, u32 addr)
+isp3_param_read_cache(struct rkisp_isp_params_vdev *params_vdev, u32 addr, u32 id)
 {
-	return rkisp_read_reg_cache(params_vdev->dev, addr);
+	return rkisp_idx_read_reg_cache(params_vdev->dev, addr, id);
 }
 
 static inline void
 isp3_param_set_bits(struct rkisp_isp_params_vdev *params_vdev,
-		    u32 reg, u32 bit_mask)
+		    u32 reg, u32 bit_mask, u32 id)
 {
-	rkisp_set_bits(params_vdev->dev, reg, 0, bit_mask, false);
+	rkisp_idx_set_bits(params_vdev->dev, reg, 0, bit_mask, id, false);
 }
 
 static inline void
 isp3_param_clear_bits(struct rkisp_isp_params_vdev *params_vdev,
-		      u32 reg, u32 bit_mask)
+		      u32 reg, u32 bit_mask, u32 id)
 {
-	rkisp_clear_bits(params_vdev->dev, reg, bit_mask, false);
+	rkisp_idx_clear_bits(params_vdev->dev, reg, bit_mask, id, false);
 }
 
 static void
 isp_dpcc_config(struct rkisp_isp_params_vdev *params_vdev,
-		const struct isp2x_dpcc_cfg *arg)
+		const struct isp2x_dpcc_cfg *arg, u32 id)
 {
 	u32 value;
 	int i;
 
-	value = isp3_param_read(params_vdev, ISP3X_DPCC0_MODE);
+	value = isp3_param_read(params_vdev, ISP3X_DPCC0_MODE, id);
 	value &= ISP_DPCC_EN;
 
 	value |= !!arg->stage1_enable << 2 |
 		 !!arg->grayscale_mode << 1;
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_MODE);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_MODE);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_MODE, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_MODE, id);
 
 	value = (arg->sw_rk_out_sel & 0x03) << 5 |
 		!!arg->sw_dpcc_output_sel << 4 |
@@ -90,15 +90,15 @@ isp_dpcc_config(struct rkisp_isp_params_vdev *params_vdev,
 		!!arg->stage1_g_3x3 << 2 |
 		!!arg->stage1_incl_rb_center << 1 |
 		!!arg->stage1_incl_green_center;
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_OUTPUT_MODE);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_OUTPUT_MODE);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_OUTPUT_MODE, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_OUTPUT_MODE, id);
 
 	value = !!arg->stage1_use_fix_set << 3 |
 		!!arg->stage1_use_set_3 << 2 |
 		!!arg->stage1_use_set_2 << 1 |
 		!!arg->stage1_use_set_1;
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_SET_USE);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_SET_USE);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_SET_USE, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_SET_USE, id);
 
 	value = !!arg->sw_rk_red_blue1_en << 13 |
 		!!arg->rg_red_blue1_enable << 12 |
@@ -112,8 +112,8 @@ isp_dpcc_config(struct rkisp_isp_params_vdev *params_vdev,
 		!!arg->ro_green1_enable << 2 |
 		!!arg->lc_green1_enable << 1 |
 		!!arg->pg_green1_enable;
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_METHODS_SET_1);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_METHODS_SET_1);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_METHODS_SET_1, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_METHODS_SET_1, id);
 
 	value = !!arg->sw_rk_red_blue2_en << 13 |
 		!!arg->rg_red_blue2_enable << 12 |
@@ -127,8 +127,8 @@ isp_dpcc_config(struct rkisp_isp_params_vdev *params_vdev,
 		!!arg->ro_green2_enable << 2 |
 		!!arg->lc_green2_enable << 1 |
 		!!arg->pg_green2_enable;
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_METHODS_SET_2);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_METHODS_SET_2);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_METHODS_SET_2, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_METHODS_SET_2, id);
 
 	value = !!arg->sw_rk_red_blue3_en << 13 |
 		!!arg->rg_red_blue3_enable << 12 |
@@ -142,74 +142,74 @@ isp_dpcc_config(struct rkisp_isp_params_vdev *params_vdev,
 		!!arg->ro_green3_enable << 2 |
 		!!arg->lc_green3_enable << 1 |
 		!!arg->pg_green3_enable;
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_METHODS_SET_3);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_METHODS_SET_3);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_METHODS_SET_3, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_METHODS_SET_3, id);
 
 	value = ISP_PACK_4BYTE(arg->line_thr_1_g, arg->line_thr_1_rb,
 			       arg->sw_mindis1_g, arg->sw_mindis1_rb);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_THRESH_1);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_THRESH_1);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_THRESH_1, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_THRESH_1, id);
 
 	value = ISP_PACK_4BYTE(arg->line_mad_fac_1_g, arg->line_mad_fac_1_rb,
 			       arg->sw_dis_scale_max1, arg->sw_dis_scale_min1);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_MAD_FAC_1);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_MAD_FAC_1);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_MAD_FAC_1, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_MAD_FAC_1, id);
 
 	value = ISP_PACK_4BYTE(arg->pg_fac_1_g, arg->pg_fac_1_rb, 0, 0);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PG_FAC_1);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PG_FAC_1);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PG_FAC_1, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PG_FAC_1, id);
 
 	value = ISP_PACK_4BYTE(arg->rnd_thr_1_g, arg->rnd_thr_1_rb, 0, 0);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RND_THRESH_1);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RND_THRESH_1);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RND_THRESH_1, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RND_THRESH_1, id);
 
 	value = ISP_PACK_4BYTE(arg->rg_fac_1_g, arg->rg_fac_1_rb, 0, 0);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RG_FAC_1);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RG_FAC_1);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RG_FAC_1, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RG_FAC_1, id);
 
 	value = ISP_PACK_4BYTE(arg->line_thr_2_g, arg->line_thr_2_rb,
 			       arg->sw_mindis2_g, arg->sw_mindis2_rb);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_THRESH_2);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_THRESH_2);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_THRESH_2, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_THRESH_2, id);
 
 	value = ISP_PACK_4BYTE(arg->line_mad_fac_2_g, arg->line_mad_fac_2_rb,
 			       arg->sw_dis_scale_max2, arg->sw_dis_scale_min2);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_MAD_FAC_2);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_MAD_FAC_2);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_MAD_FAC_2, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_MAD_FAC_2, id);
 
 	value = ISP_PACK_4BYTE(arg->pg_fac_2_g, arg->pg_fac_2_rb, 0, 0);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PG_FAC_2);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PG_FAC_2);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PG_FAC_2, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PG_FAC_2, id);
 
 	value = ISP_PACK_4BYTE(arg->rnd_thr_2_g, arg->rnd_thr_2_rb, 0, 0);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RND_THRESH_2);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RND_THRESH_2);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RND_THRESH_2, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RND_THRESH_2, id);
 
 	value = ISP_PACK_4BYTE(arg->rg_fac_2_g, arg->rg_fac_2_rb, 0, 0);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RG_FAC_2);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RG_FAC_2);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RG_FAC_2, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RG_FAC_2, id);
 
 	value = ISP_PACK_4BYTE(arg->line_thr_3_g, arg->line_thr_3_rb,
 			       arg->sw_mindis3_g, arg->sw_mindis3_rb);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_THRESH_3);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_THRESH_3);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_THRESH_3, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_THRESH_3, id);
 
 	value = ISP_PACK_4BYTE(arg->line_mad_fac_3_g, arg->line_mad_fac_3_rb,
 			       arg->sw_dis_scale_max3, arg->sw_dis_scale_min3);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_MAD_FAC_3);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_MAD_FAC_3);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_LINE_MAD_FAC_3, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_LINE_MAD_FAC_3, id);
 
 	value = ISP_PACK_4BYTE(arg->pg_fac_3_g, arg->pg_fac_3_rb, 0, 0);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PG_FAC_3);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PG_FAC_3);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PG_FAC_3, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PG_FAC_3, id);
 
 	value = ISP_PACK_4BYTE(arg->rnd_thr_3_g, arg->rnd_thr_3_rb, 0, 0);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RND_THRESH_3);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RND_THRESH_3);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RND_THRESH_3, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RND_THRESH_3, id);
 
 	value = ISP_PACK_4BYTE(arg->rg_fac_3_g, arg->rg_fac_3_rb, 0, 0);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RG_FAC_3);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RG_FAC_3);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RG_FAC_3, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RG_FAC_3, id);
 
 	value = (arg->ro_lim_3_rb & 0x03) << 10 |
 		(arg->ro_lim_3_g & 0x03) << 8 |
@@ -217,8 +217,8 @@ isp_dpcc_config(struct rkisp_isp_params_vdev *params_vdev,
 		(arg->ro_lim_2_g & 0x03) << 4 |
 		(arg->ro_lim_1_rb & 0x03) << 2 |
 		(arg->ro_lim_1_g & 0x03);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RO_LIMITS);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RO_LIMITS);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RO_LIMITS, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RO_LIMITS, id);
 
 	value = (arg->rnd_offs_3_rb & 0x03) << 10 |
 		(arg->rnd_offs_3_g & 0x03) << 8 |
@@ -226,8 +226,8 @@ isp_dpcc_config(struct rkisp_isp_params_vdev *params_vdev,
 		(arg->rnd_offs_2_g & 0x03) << 4 |
 		(arg->rnd_offs_1_rb & 0x03) << 2 |
 		(arg->rnd_offs_1_g & 0x03);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RND_OFFS);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RND_OFFS);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_RND_OFFS, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_RND_OFFS, id);
 
 	value = !!arg->bpt_rb_3x3 << 11 |
 		!!arg->bpt_g_3x3 << 10 |
@@ -239,75 +239,75 @@ isp_dpcc_config(struct rkisp_isp_params_vdev *params_vdev,
 		!!arg->bpt_use_set_1 << 4 |
 		!!arg->bpt_cor_en << 1 |
 		!!arg->bpt_det_en;
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_BPT_CTRL);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_BPT_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_BPT_CTRL, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_BPT_CTRL, id);
 
-	isp3_param_write(params_vdev, arg->bp_number, ISP3X_DPCC0_BPT_NUMBER);
-	isp3_param_write(params_vdev, arg->bp_number, ISP3X_DPCC1_BPT_NUMBER);
-	isp3_param_write(params_vdev, arg->bp_table_addr, ISP3X_DPCC0_BPT_ADDR);
-	isp3_param_write(params_vdev, arg->bp_table_addr, ISP3X_DPCC1_BPT_ADDR);
+	isp3_param_write(params_vdev, arg->bp_number, ISP3X_DPCC0_BPT_NUMBER, id);
+	isp3_param_write(params_vdev, arg->bp_number, ISP3X_DPCC1_BPT_NUMBER, id);
+	isp3_param_write(params_vdev, arg->bp_table_addr, ISP3X_DPCC0_BPT_ADDR, id);
+	isp3_param_write(params_vdev, arg->bp_table_addr, ISP3X_DPCC1_BPT_ADDR, id);
 
 	value = ISP_PACK_2SHORT(arg->bpt_h_addr, arg->bpt_v_addr);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_BPT_DATA);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_BPT_DATA);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_BPT_DATA, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_BPT_DATA, id);
 
-	isp3_param_write(params_vdev, arg->bp_cnt, ISP3X_DPCC0_BP_CNT);
-	isp3_param_write(params_vdev, arg->bp_cnt, ISP3X_DPCC1_BP_CNT);
+	isp3_param_write(params_vdev, arg->bp_cnt, ISP3X_DPCC0_BP_CNT, id);
+	isp3_param_write(params_vdev, arg->bp_cnt, ISP3X_DPCC1_BP_CNT, id);
 
-	isp3_param_write(params_vdev, arg->sw_pdaf_en, ISP3X_DPCC0_PDAF_EN);
-	isp3_param_write(params_vdev, arg->sw_pdaf_en, ISP3X_DPCC1_PDAF_EN);
+	isp3_param_write(params_vdev, arg->sw_pdaf_en, ISP3X_DPCC0_PDAF_EN, id);
+	isp3_param_write(params_vdev, arg->sw_pdaf_en, ISP3X_DPCC1_PDAF_EN, id);
 
 	value = 0;
 	for (i = 0; i < ISP39_DPCC_PDAF_POINT_NUM; i++)
 		value |= !!arg->pdaf_point_en[i] << i;
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PDAF_POINT_EN);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PDAF_POINT_EN);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PDAF_POINT_EN, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PDAF_POINT_EN, id);
 
 	value = ISP_PACK_2SHORT(arg->pdaf_offsetx, arg->pdaf_offsety);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PDAF_OFFSET);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PDAF_OFFSET);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PDAF_OFFSET, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PDAF_OFFSET, id);
 
 	value = ISP_PACK_2SHORT(arg->pdaf_wrapx, arg->pdaf_wrapy);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PDAF_WRAP);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PDAF_WRAP);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_PDAF_WRAP, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_PDAF_WRAP, id);
 
 	value = ISP_PACK_2SHORT(arg->pdaf_wrapx_num, arg->pdaf_wrapy_num);
-	isp3_param_write(params_vdev, value, ISP_DPCC0_PDAF_SCOPE);
-	isp3_param_write(params_vdev, value, ISP_DPCC1_PDAF_SCOPE);
+	isp3_param_write(params_vdev, value, ISP_DPCC0_PDAF_SCOPE, id);
+	isp3_param_write(params_vdev, value, ISP_DPCC1_PDAF_SCOPE, id);
 
 	for (i = 0; i < ISP39_DPCC_PDAF_POINT_NUM / 2; i++) {
 		value = ISP_PACK_4BYTE(arg->point[2 * i].x, arg->point[2 * i].y,
 				       arg->point[2 * i + 1].x, arg->point[2 * i + 1].y);
-		isp3_param_write(params_vdev, value, ISP3X_DPCC0_PDAF_POINT_0 + 4 * i);
-		isp3_param_write(params_vdev, value, ISP3X_DPCC1_PDAF_POINT_0 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP3X_DPCC0_PDAF_POINT_0 + 4 * i, id);
+		isp3_param_write(params_vdev, value, ISP3X_DPCC1_PDAF_POINT_0 + 4 * i, id);
 	}
 
-	isp3_param_write(params_vdev, arg->pdaf_forward_med, ISP3X_DPCC0_PDAF_FORWARD_MED);
-	isp3_param_write(params_vdev, arg->pdaf_forward_med, ISP3X_DPCC1_PDAF_FORWARD_MED);
+	isp3_param_write(params_vdev, arg->pdaf_forward_med, ISP3X_DPCC0_PDAF_FORWARD_MED, id);
+	isp3_param_write(params_vdev, arg->pdaf_forward_med, ISP3X_DPCC1_PDAF_FORWARD_MED, id);
 }
 
 static void
-isp_dpcc_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_dpcc_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 value;
 
-	value = isp3_param_read(params_vdev, ISP3X_DPCC0_MODE);
+	value = isp3_param_read(params_vdev, ISP3X_DPCC0_MODE, id);
 	value &= ~ISP_DPCC_EN;
 
 	if (en)
 		value |= ISP_DPCC_EN;
-	isp3_param_write(params_vdev, value, ISP3X_DPCC0_MODE);
-	isp3_param_write(params_vdev, value, ISP3X_DPCC1_MODE);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC0_MODE, id);
+	isp3_param_write(params_vdev, value, ISP3X_DPCC1_MODE, id);
 }
 
 static void
 isp_bls_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp32_bls_cfg *arg)
+	       const struct isp32_bls_cfg *arg, u32 id)
 {
 	const struct isp2x_bls_fixed_val *pval;
 	u32 new_control, value;
 
-	new_control = isp3_param_read(params_vdev, ISP3X_BLS_CTRL);
+	new_control = isp3_param_read(params_vdev, ISP3X_BLS_CTRL, id);
 	new_control &= (ISP_BLS_ENA | ISP32_BLS_BLS2_EN);
 
 	pval = &arg->bls1_val;
@@ -316,29 +316,29 @@ isp_bls_config(struct rkisp_isp_params_vdev *params_vdev,
 
 		switch (params_vdev->raw_type) {
 		case RAW_BGGR:
-			isp3_param_write(params_vdev, pval->r, ISP3X_BLS1_D_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS1_C_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS1_B_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP3X_BLS1_A_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP3X_BLS1_D_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS1_C_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS1_B_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP3X_BLS1_A_FIXED, id);
 			break;
 		case RAW_GBRG:
-			isp3_param_write(params_vdev, pval->r, ISP3X_BLS1_C_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS1_D_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS1_A_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP3X_BLS1_B_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP3X_BLS1_C_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS1_D_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS1_A_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP3X_BLS1_B_FIXED, id);
 			break;
 		case RAW_GRBG:
-			isp3_param_write(params_vdev, pval->r, ISP3X_BLS1_B_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS1_A_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS1_D_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP3X_BLS1_C_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP3X_BLS1_B_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS1_A_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS1_D_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP3X_BLS1_C_FIXED, id);
 			break;
 		case RAW_RGGB:
 		default:
-			isp3_param_write(params_vdev, pval->r, ISP3X_BLS1_A_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS1_B_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS1_C_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP3X_BLS1_D_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP3X_BLS1_A_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS1_B_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS1_C_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP3X_BLS1_D_FIXED, id);
 			break;
 		}
 	}
@@ -348,120 +348,124 @@ isp_bls_config(struct rkisp_isp_params_vdev *params_vdev,
 	if (!arg->enable_auto) {
 		switch (params_vdev->raw_type) {
 		case RAW_BGGR:
-			isp3_param_write(params_vdev, pval->r, ISP3X_BLS_D_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS_C_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS_B_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP3X_BLS_A_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP3X_BLS_D_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS_C_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS_B_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP3X_BLS_A_FIXED, id);
 			break;
 		case RAW_GBRG:
-			isp3_param_write(params_vdev, pval->r, ISP3X_BLS_C_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS_D_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS_A_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP3X_BLS_B_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP3X_BLS_C_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS_D_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS_A_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP3X_BLS_B_FIXED, id);
 			break;
 		case RAW_GRBG:
-			isp3_param_write(params_vdev, pval->r, ISP3X_BLS_B_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS_A_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS_D_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP3X_BLS_C_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP3X_BLS_B_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS_A_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS_D_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP3X_BLS_C_FIXED, id);
 			break;
 		case RAW_RGGB:
 		default:
-			isp3_param_write(params_vdev, pval->r, ISP3X_BLS_A_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS_B_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS_C_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP3X_BLS_D_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP3X_BLS_A_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP3X_BLS_B_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP3X_BLS_C_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP3X_BLS_D_FIXED, id);
 			break;
 		}
 	} else {
 		if (arg->en_windows & BIT(1)) {
-			isp3_param_write(params_vdev, arg->bls_window2.h_offs, ISP3X_BLS_H2_START);
+			isp3_param_write(params_vdev, arg->bls_window2.h_offs,
+					 ISP3X_BLS_H2_START, id);
 			value = arg->bls_window2.h_offs + arg->bls_window2.h_size;
-			isp3_param_write(params_vdev, value, ISP3X_BLS_H2_STOP);
-			isp3_param_write(params_vdev, arg->bls_window2.v_offs, ISP3X_BLS_V2_START);
+			isp3_param_write(params_vdev, value, ISP3X_BLS_H2_STOP, id);
+			isp3_param_write(params_vdev, arg->bls_window2.v_offs,
+					 ISP3X_BLS_V2_START, id);
 			value = arg->bls_window2.v_offs + arg->bls_window2.v_size;
-			isp3_param_write(params_vdev, value, ISP3X_BLS_V2_STOP);
+			isp3_param_write(params_vdev, value, ISP3X_BLS_V2_STOP, id);
 			new_control |= ISP_BLS_WINDOW_2;
 		}
 
 		if (arg->en_windows & BIT(0)) {
-			isp3_param_write(params_vdev, arg->bls_window1.h_offs, ISP3X_BLS_H1_START);
+			isp3_param_write(params_vdev, arg->bls_window1.h_offs,
+					 ISP3X_BLS_H1_START, id);
 			value = arg->bls_window1.h_offs + arg->bls_window1.h_size;
-			isp3_param_write(params_vdev, value, ISP3X_BLS_H1_STOP);
-			isp3_param_write(params_vdev, arg->bls_window1.v_offs, ISP3X_BLS_V1_START);
+			isp3_param_write(params_vdev, value, ISP3X_BLS_H1_STOP, id);
+			isp3_param_write(params_vdev, arg->bls_window1.v_offs,
+					 ISP3X_BLS_V1_START, id);
 			value = arg->bls_window1.v_offs + arg->bls_window1.v_size;
-			isp3_param_write(params_vdev, value, ISP3X_BLS_V1_STOP);
+			isp3_param_write(params_vdev, value, ISP3X_BLS_V1_STOP, id);
 			new_control |= ISP_BLS_WINDOW_1;
 		}
 
-		isp3_param_write(params_vdev, arg->bls_samples, ISP3X_BLS_SAMPLES);
+		isp3_param_write(params_vdev, arg->bls_samples, ISP3X_BLS_SAMPLES, id);
 
 		new_control |= ISP_BLS_MODE_MEASURED;
 	}
-	isp3_param_write(params_vdev, new_control, ISP3X_BLS_CTRL);
+	isp3_param_write(params_vdev, new_control, ISP3X_BLS_CTRL, id);
 
-	isp3_param_write(params_vdev, arg->isp_ob_offset, ISP32_BLS_ISP_OB_OFFSET);
-	isp3_param_write(params_vdev, arg->isp_ob_predgain, ISP32_BLS_ISP_OB_PREDGAIN);
-	isp3_param_write(params_vdev, arg->isp_ob_max, ISP32_BLS_ISP_OB_MAX);
+	isp3_param_write(params_vdev, arg->isp_ob_offset, ISP32_BLS_ISP_OB_OFFSET, id);
+	isp3_param_write(params_vdev, arg->isp_ob_predgain, ISP32_BLS_ISP_OB_PREDGAIN, id);
+	isp3_param_write(params_vdev, arg->isp_ob_max, ISP32_BLS_ISP_OB_MAX, id);
 }
 
 static void
-isp_bls_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_bls_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 new_control;
 
-	new_control = isp3_param_read(params_vdev, ISP3X_BLS_CTRL);
+	new_control = isp3_param_read(params_vdev, ISP3X_BLS_CTRL, id);
 	if (en)
 		new_control |= ISP_BLS_ENA;
 	else
 		new_control &= ~ISP_BLS_ENA;
-	isp3_param_write(params_vdev, new_control, ISP3X_BLS_CTRL);
+	isp3_param_write(params_vdev, new_control, ISP3X_BLS_CTRL, id);
 }
 
 static void
 isp_sdg_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp2x_sdg_cfg *arg)
+	       const struct isp2x_sdg_cfg *arg, u32 id)
 {
 	int i;
 
-	isp3_param_write(params_vdev, arg->xa_pnts.gamma_dx0, ISP3X_ISP_GAMMA_DX_LO);
-	isp3_param_write(params_vdev, arg->xa_pnts.gamma_dx1, ISP3X_ISP_GAMMA_DX_HI);
+	isp3_param_write(params_vdev, arg->xa_pnts.gamma_dx0, ISP3X_ISP_GAMMA_DX_LO, id);
+	isp3_param_write(params_vdev, arg->xa_pnts.gamma_dx1, ISP3X_ISP_GAMMA_DX_HI, id);
 
 	for (i = 0; i < ISP39_DEGAMMA_CURVE_SIZE; i++) {
 		isp3_param_write(params_vdev, arg->curve_r.gamma_y[i],
-				 ISP3X_ISP_GAMMA_R_Y_0 + i * 4);
+				 ISP3X_ISP_GAMMA_R_Y_0 + i * 4, id);
 		isp3_param_write(params_vdev, arg->curve_g.gamma_y[i],
-				 ISP3X_ISP_GAMMA_G_Y_0 + i * 4);
+				 ISP3X_ISP_GAMMA_G_Y_0 + i * 4, id);
 		isp3_param_write(params_vdev, arg->curve_b.gamma_y[i],
-				 ISP3X_ISP_GAMMA_B_Y_0 + i * 4);
+				 ISP3X_ISP_GAMMA_B_Y_0 + i * 4, id);
 	}
 }
 
 static void
-isp_sdg_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_sdg_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 val;
 
-	val = isp3_param_read_cache(params_vdev, ISP3X_ISP_CTRL0);
+	val = isp3_param_read_cache(params_vdev, ISP3X_ISP_CTRL0, id);
 	if (en)
 		isp3_param_write(params_vdev, val | CIF_ISP_CTRL_ISP_GAMMA_IN_ENA,
-				 ISP3X_ISP_CTRL0);
+				 ISP3X_ISP_CTRL0, id);
 	else
 		isp3_param_write(params_vdev, val & ~CIF_ISP_CTRL_ISP_GAMMA_IN_ENA,
-				 ISP3X_ISP_CTRL0);
+				 ISP3X_ISP_CTRL0, id);
 }
 
 static void
 isp_lsc_matrix_cfg_sram(struct rkisp_isp_params_vdev *params_vdev,
 			const struct isp3x_lsc_cfg *pconfig,
-			bool is_check)
+			bool is_check, u32 id)
 {
 	struct rkisp_device *dev = params_vdev->dev;
-	u32 sram_addr, data, table;
+	u32 data = isp3_param_read(params_vdev, ISP3X_LSC_CTRL, id);
+	u32 sram_addr, table;
 	int i, j;
 
-	if (is_check &&
-	    !(isp3_param_read(params_vdev, ISP3X_LSC_CTRL) & ISP_LSC_EN))
+	if (is_check && (data & ISP3X_LSC_LUT_EN || !(data & ISP_LSC_EN)))
 		return;
 
 	table = isp3_param_read_direct(params_vdev, ISP3X_LSC_STATUS);
@@ -524,20 +528,20 @@ isp_lsc_cfg_sram_task(unsigned long data)
 		(struct rkisp_isp_params_vdev *)data;
 	struct isp39_isp_params_cfg *params = params_vdev->isp39_params;
 
-	isp_lsc_matrix_cfg_sram(params_vdev, &params->others.lsc_cfg, true);
+	isp_lsc_matrix_cfg_sram(params_vdev, &params->others.lsc_cfg, true, 0);
 }
 
 static void
 isp_lsc_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp3x_lsc_cfg *arg)
+	       const struct isp3x_lsc_cfg *arg, u32 id)
 {
 	struct rkisp_isp_params_val_v39 *priv_val = params_vdev->priv_val;
-	struct isp39_isp_params_cfg *params_rec = params_vdev->isp39_params;
+	struct isp39_isp_params_cfg *params_rec = params_vdev->isp39_params + id;
 	struct rkisp_device *dev = params_vdev->dev;
 	u32 data, lsc_ctrl;
 	int i;
 
-	lsc_ctrl = isp3_param_read(params_vdev, ISP3X_LSC_CTRL);
+	lsc_ctrl = isp3_param_read(params_vdev, ISP3X_LSC_CTRL, id);
 	/* two lsc sram table */
 	params_rec->others.lsc_cfg = *arg;
 	if (dev->hw_dev->is_single && (lsc_ctrl & ISP_LSC_EN))
@@ -546,147 +550,152 @@ isp_lsc_config(struct rkisp_isp_params_vdev *params_vdev,
 	for (i = 0; i < ISP39_LSC_SIZE_TBL_SIZE / 4; i++) {
 		/* program x size tables */
 		data = CIF_ISP_LSC_SECT_SIZE(arg->x_size_tbl[i * 2], arg->x_size_tbl[i * 2 + 1]);
-		isp3_param_write(params_vdev, data, ISP3X_LSC_XSIZE_01 + i * 4);
+		isp3_param_write(params_vdev, data, ISP3X_LSC_XSIZE_01 + i * 4, id);
 		data = CIF_ISP_LSC_SECT_SIZE(arg->x_size_tbl[i * 2 + 8], arg->x_size_tbl[i * 2 + 9]);
-		isp3_param_write(params_vdev, data, ISP3X_LSC_XSIZE_89 + i * 4);
+		isp3_param_write(params_vdev, data, ISP3X_LSC_XSIZE_89 + i * 4, id);
 
 		/* program x grad tables */
 		data = CIF_ISP_LSC_SECT_SIZE(arg->x_grad_tbl[i * 2], arg->x_grad_tbl[i * 2 + 1]);
-		isp3_param_write(params_vdev, data, ISP3X_LSC_XGRAD_01 + i * 4);
+		isp3_param_write(params_vdev, data, ISP3X_LSC_XGRAD_01 + i * 4, id);
 		data = CIF_ISP_LSC_SECT_SIZE(arg->x_grad_tbl[i * 2 + 8], arg->x_grad_tbl[i * 2 + 9]);
-		isp3_param_write(params_vdev, data, ISP3X_LSC_XGRAD_89 + i * 4);
+		isp3_param_write(params_vdev, data, ISP3X_LSC_XGRAD_89 + i * 4, id);
 
 		/* program y size tables */
 		data = CIF_ISP_LSC_SECT_SIZE(arg->y_size_tbl[i * 2], arg->y_size_tbl[i * 2 + 1]);
-		isp3_param_write(params_vdev, data, ISP3X_LSC_YSIZE_01 + i * 4);
+		isp3_param_write(params_vdev, data, ISP3X_LSC_YSIZE_01 + i * 4, id);
 		data = CIF_ISP_LSC_SECT_SIZE(arg->y_size_tbl[i * 2 + 8], arg->y_size_tbl[i * 2 + 9]);
-		isp3_param_write(params_vdev, data, ISP3X_LSC_YSIZE_89 + i * 4);
+		isp3_param_write(params_vdev, data, ISP3X_LSC_YSIZE_89 + i * 4, id);
 
 		/* program y grad tables */
 		data = CIF_ISP_LSC_SECT_SIZE(arg->y_grad_tbl[i * 2], arg->y_grad_tbl[i * 2 + 1]);
-		isp3_param_write(params_vdev, data, ISP3X_LSC_YGRAD_01 + i * 4);
+		isp3_param_write(params_vdev, data, ISP3X_LSC_YGRAD_01 + i * 4, id);
 		data = CIF_ISP_LSC_SECT_SIZE(arg->y_grad_tbl[i * 2 + 8], arg->y_grad_tbl[i * 2 + 9]);
-		isp3_param_write(params_vdev, data, ISP3X_LSC_YGRAD_89 + i * 4);
+		isp3_param_write(params_vdev, data, ISP3X_LSC_YGRAD_89 + i * 4, id);
 	}
 
 	if (arg->sector_16x16)
 		lsc_ctrl |= ISP3X_LSC_SECTOR_16X16;
 	else
 		lsc_ctrl &= ~ISP3X_LSC_SECTOR_16X16;
-	isp3_param_write(params_vdev, lsc_ctrl, ISP3X_LSC_CTRL);
+	isp3_param_write(params_vdev, lsc_ctrl, ISP3X_LSC_CTRL, id);
 }
 
 static void
-isp_lsc_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_lsc_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	struct rkisp_device *dev = params_vdev->dev;
-	struct isp39_isp_params_cfg *params_rec = params_vdev->isp39_params;
-	u32 val = isp3_param_read(params_vdev, ISP3X_LSC_CTRL);
+	struct isp39_isp_params_cfg *params_rec = params_vdev->isp39_params + id;
+	u32 val = isp3_param_read(params_vdev, ISP3X_LSC_CTRL, id);
 
 	if (en == !!(val & ISP_LSC_EN))
 		return;
 
 	if (en) {
 		val = ISP_LSC_EN | ISP39_SELF_FORCE_UPD;
-		isp3_param_set_bits(params_vdev, ISP3X_LSC_CTRL, val);
+		isp3_param_set_bits(params_vdev, ISP3X_LSC_CTRL, val, id);
 		if (dev->hw_dev->is_single)
-			isp_lsc_matrix_cfg_sram(params_vdev, &params_rec->others.lsc_cfg, false);
+			isp_lsc_matrix_cfg_sram(params_vdev,
+						&params_rec->others.lsc_cfg, false, id);
 	} else {
-		isp3_param_clear_bits(params_vdev, ISP3X_LSC_CTRL, ISP_LSC_EN);
-		isp3_param_clear_bits(params_vdev, ISP3X_GAIN_CTRL, BIT(8));
+		isp3_param_clear_bits(params_vdev, ISP3X_LSC_CTRL, ISP_LSC_EN, id);
+		isp3_param_clear_bits(params_vdev, ISP3X_GAIN_CTRL, BIT(8), id);
 	}
 }
 
 static void
 isp_debayer_config(struct rkisp_isp_params_vdev *params_vdev,
-		   const struct isp39_debayer_cfg *arg)
+		   const struct isp39_debayer_cfg *arg, u32 id)
 {
 	u32 i, value;
 
-	value = isp3_param_read(params_vdev, ISP3X_DEBAYER_CONTROL);
+	value = isp3_param_read(params_vdev, ISP3X_DEBAYER_CONTROL, id);
 	value &= ISP_DEBAYER_EN;
 
 	value |= !!arg->filter_g_en << 4 | !!arg->filter_c_en << 8;
-	isp3_param_write(params_vdev, value, ISP3X_DEBAYER_CONTROL);
+	isp3_param_write(params_vdev, value, ISP3X_DEBAYER_CONTROL, id);
 
 	value = 0;
 	for (i = 0; i < ISP39_DEBAYER_LUMA_NUM; i++)
 		value |= ((arg->luma_dx[i] & 0xf) << (i * 4));
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_LUMA_DX);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_LUMA_DX, id);
 
 	value = (arg->max_ratio & 0x3F) << 24 | arg->select_thed << 16 |
 		(arg->thed1 & 0x0F) << 12 | (arg->thed0 & 0x0F) << 8 |
 		(arg->dist_scale & 0x0F) << 4 | !!arg->clip_en;
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_INTERP);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_INTERP, id);
 
 	value = (arg->filter1_coe4 & 0x1F) << 24 | (arg->filter1_coe3 & 0x1F) << 16 |
 		(arg->filter1_coe2 & 0x1F) << 8 | (arg->filter1_coe1 & 0x1F);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_INTERP_FILTER1);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_INTERP_FILTER1, id);
 
 	value = (arg->filter2_coe4 & 0x1F) << 24 | (arg->filter2_coe3 & 0x1F) << 16 |
 		(arg->filter2_coe2 & 0x1F) << 8 | (arg->filter2_coe1 & 0x1F);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_INTERP_FILTER2);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_INTERP_FILTER2, id);
 
 	value = (arg->wgt_alpha & 0x7f) << 24 | (arg->gradloflt_alpha & 0x7f) << 16 |
 		(arg->gain_offset & 0xfff);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_INTERP_OFFSET_ALPHA);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_INTERP_OFFSET_ALPHA, id);
 
 	for (i = 0; i < ISP39_DEBAYER_DRCT_OFFSET_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->drct_offset[i * 2], arg->drct_offset[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_INTERP_DRCT_OFFSET0 + i * 4);
+		isp3_param_write(params_vdev, value,
+				 ISP39_DEBAYER_G_INTERP_DRCT_OFFSET0 + i * 4, id);
 	}
 
 	value = (arg->offset & 0x7ff) << 16 | (arg->bf_ratio & 0xfff) << 4 | !!arg->gfilter_mode;
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_FILTER_MODE_OFFSET);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_FILTER_MODE_OFFSET, id);
 
 	value = ISP_PACK_4BYTE(arg->filter_coe0, arg->filter_coe1, arg->filter_coe2, 0);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_FILTER_FILTER);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_FILTER_FILTER, id);
 
 	for (i = 0; i < ISP39_DEBAYER_VSIGMA_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->vsigma[i * 2], arg->vsigma[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP39_DEBAYER_G_FILTER_VSIGMA0 + i * 4);
+		isp3_param_write(params_vdev, value,
+				 ISP39_DEBAYER_G_FILTER_VSIGMA0 + i * 4, id);
 	}
 
 	value = ISP_PACK_4BYTE(arg->guid_gaus_coe0, arg->guid_gaus_coe1, arg->guid_gaus_coe2, 0);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_GUIDE_GAUS);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_GUIDE_GAUS, id);
 
 	value = ISP_PACK_4BYTE(arg->ce_gaus_coe0, arg->ce_gaus_coe1, arg->ce_gaus_coe2, 0);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_CE_GAUS);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_CE_GAUS, id);
 
 	value = ISP_PACK_4BYTE(arg->alpha_gaus_coe0, arg->alpha_gaus_coe1, arg->alpha_gaus_coe2, 0);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_ALPHA_GAUS);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_ALPHA_GAUS, id);
 
 	value = !!arg->log_en << 31 | (arg->loggd_offset & 0xfff) << 16 | (arg->loghf_offset & 0x1fff);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_LOG_OFFSET);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_LOG_OFFSET, id);
 
 	value = (arg->alpha_scale & 0xfffff) << 12 | (arg->alpha_offset & 0xfff);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_ALPHA);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_ALPHA, id);
 
 	value = (arg->edge_scale & 0xfffff) << 12 | (arg->edge_offset & 0xfff);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_EDGE);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_EDGE, id);
 
 	value = (arg->wgtslope & 0xfff) << 16 | (arg->exp_shift & 0x3f) << 8 | (arg->ce_sgm & 0xff);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_IIR_0);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_IIR_0, id);
 
 	value = (arg->wet_ghost & 0x3f) << 8 | (arg->wet_clip & 0x7f);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_IIR_1);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_IIR_1, id);
 
 	value = (arg->bf_curwgt & 0x7f) << 24 | (arg->bf_clip & 0x7f) << 16 | (arg->bf_sgm & 0xffff);
-	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_BF);
+	isp3_param_write(params_vdev, value, ISP39_DEBAYER_C_FILTER_BF, id);
 }
 
 static void
-isp_debayer_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_debayer_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	if (en)
-		isp3_param_set_bits(params_vdev, ISP3X_DEBAYER_CONTROL, ISP39_MODULE_EN);
+		isp3_param_set_bits(params_vdev,
+				    ISP3X_DEBAYER_CONTROL, ISP39_MODULE_EN, id);
 	else
-		isp3_param_clear_bits(params_vdev, ISP3X_DEBAYER_CONTROL, ISP39_MODULE_EN);
+		isp3_param_clear_bits(params_vdev,
+				      ISP3X_DEBAYER_CONTROL, ISP39_MODULE_EN, id);
 }
 
 static void
 isp_awbgain_config(struct rkisp_isp_params_vdev *params_vdev,
-		   const struct isp32_awb_gain_cfg *arg)
+		   const struct isp32_awb_gain_cfg *arg, u32 id)
 {
 	struct rkisp_device *dev = params_vdev->dev;
 
@@ -702,210 +711,227 @@ isp_awbgain_config(struct rkisp_isp_params_vdev *params_vdev,
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->gain0_green_b, arg->gain0_green_r),
-			 ISP3X_ISP_AWB_GAIN0_G);
+			 ISP3X_ISP_AWB_GAIN0_G, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->gain0_blue, arg->gain0_red),
-			 ISP3X_ISP_AWB_GAIN0_RB);
+			 ISP3X_ISP_AWB_GAIN0_RB, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->gain1_green_b, arg->gain1_green_r),
-			 ISP3X_ISP_AWB_GAIN1_G);
+			 ISP3X_ISP_AWB_GAIN1_G, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->gain1_blue, arg->gain1_red),
-			 ISP3X_ISP_AWB_GAIN1_RB);
+			 ISP3X_ISP_AWB_GAIN1_RB, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->gain2_green_b, arg->gain2_green_r),
-			 ISP3X_ISP_AWB_GAIN2_G);
+			 ISP3X_ISP_AWB_GAIN2_G, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->gain2_blue, arg->gain2_red),
-			 ISP3X_ISP_AWB_GAIN2_RB);
+			 ISP3X_ISP_AWB_GAIN2_RB, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->awb1_gain_gb, arg->awb1_gain_gr),
-			 ISP32_ISP_AWB1_GAIN_G);
+			 ISP32_ISP_AWB1_GAIN_G, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->awb1_gain_b, arg->awb1_gain_r),
-			 ISP32_ISP_AWB1_GAIN_RB);
+			 ISP32_ISP_AWB1_GAIN_RB, id);
 }
 
 static void
-isp_awbgain_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_awbgain_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 val;
 
-	val = isp3_param_read_cache(params_vdev, ISP3X_ISP_CTRL0);
+	val = isp3_param_read_cache(params_vdev, ISP3X_ISP_CTRL0, id);
 	if (en)
-		isp3_param_write(params_vdev, val | CIF_ISP_CTRL_ISP_AWB_ENA, ISP3X_ISP_CTRL0);
+		isp3_param_write(params_vdev, val | CIF_ISP_CTRL_ISP_AWB_ENA,
+				 ISP3X_ISP_CTRL0, id);
 	else
-		isp3_param_write(params_vdev, val & ~CIF_ISP_CTRL_ISP_AWB_ENA, ISP3X_ISP_CTRL0);
+		isp3_param_write(params_vdev, val & ~CIF_ISP_CTRL_ISP_AWB_ENA,
+				 ISP3X_ISP_CTRL0, id);
 }
 
 static void
 isp_ccm_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp39_ccm_cfg *arg)
+	       const struct isp39_ccm_cfg *arg, u32 id)
 {
 	u32 value;
 	u32 i;
 
-	value = isp3_param_read(params_vdev, ISP3X_CCM_CTRL);
+	value = isp3_param_read(params_vdev, ISP3X_CCM_CTRL, id);
 	value &= ISP_CCM_EN;
 
 	value |= !!arg->sat_decay_en << 4 | !!arg->asym_adj_en << 3 |
 		 !!arg->enh_adj_en << 2 | !!arg->highy_adjust_dis << 1;
-	isp3_param_write(params_vdev, value, ISP3X_CCM_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_CCM_CTRL, id);
 
 	value = ISP_PACK_2SHORT(arg->coeff0_r, arg->coeff1_r);
-	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF0_R);
+	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF0_R, id);
 
 	value = ISP_PACK_2SHORT(arg->coeff2_r, arg->offset_r);
-	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF1_R);
+	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF1_R, id);
 
 	value = ISP_PACK_2SHORT(arg->coeff0_g, arg->coeff1_g);
-	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF0_G);
+	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF0_G, id);
 
 	value = ISP_PACK_2SHORT(arg->coeff2_g, arg->offset_g);
-	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF1_G);
+	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF1_G, id);
 
 	value = ISP_PACK_2SHORT(arg->coeff0_b, arg->coeff1_b);
-	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF0_B);
+	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF0_B, id);
 
 	value = ISP_PACK_2SHORT(arg->coeff2_b, arg->offset_b);
-	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF1_B);
+	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF1_B, id);
 
 	value = ISP_PACK_2SHORT(arg->coeff0_y, arg->coeff1_y);
-	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF0_Y);
+	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF0_Y, id);
 
 	value = ISP_PACK_2SHORT(arg->coeff2_y, 0);
-	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF1_Y);
+	isp3_param_write(params_vdev, value, ISP3X_CCM_COEFF1_Y, id);
 
 	for (i = 0; i < ISP39_CCM_CURVE_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->alp_y[2 * i], arg->alp_y[2 * i + 1]);
-		isp3_param_write(params_vdev, value, ISP3X_CCM_ALP_Y0 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP3X_CCM_ALP_Y0 + 4 * i, id);
 	}
 
 	value = (arg->right_bit & 0xf) << 4 | (arg->bound_bit & 0xf);
-	isp3_param_write(params_vdev, value, ISP3X_CCM_BOUND_BIT);
+	isp3_param_write(params_vdev, value, ISP3X_CCM_BOUND_BIT, id);
 
 	value = (arg->color_coef1_g2y & 0x7ff) << 16 |
 		(arg->color_coef0_r2y & 0x7ff);
-	isp3_param_write(params_vdev, value, ISP32_CCM_ENHANCE0);
+	isp3_param_write(params_vdev, value, ISP32_CCM_ENHANCE0, id);
 
 	value = (arg->color_enh_rat_max & 0x3fff) << 16 |
 		(arg->color_coef2_b2y & 0x7ff);
-	isp3_param_write(params_vdev, value, ISP32_CCM_ENHANCE1);
+	isp3_param_write(params_vdev, value, ISP32_CCM_ENHANCE1, id);
 
 	value = (arg->hf_scale & 0x3fff) << 16 | (arg->hf_up & 0xff) << 8 | (arg->hf_low & 0xff);
-	isp3_param_write(params_vdev, value, ISP39_CCM_HF_THD);
+	isp3_param_write(params_vdev, value, ISP39_CCM_HF_THD, id);
 
 	for (i = 0; i < ISP39_CCM_HF_FACTOR_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->hf_factor[i * 2], arg->hf_factor[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP39_HF_FACTOR0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_HF_FACTOR0 + i * 4, id);
 	}
 	value = ISP_PACK_2SHORT(arg->hf_factor[i * 2], 0);
-	isp3_param_write(params_vdev, value, ISP39_HF_FACTOR0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_HF_FACTOR0 + i * 4, id);
 }
 
 static void
-isp_ccm_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_ccm_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	if (en)
-		isp3_param_set_bits(params_vdev, ISP3X_CCM_CTRL, ISP_CCM_EN);
+		isp3_param_set_bits(params_vdev, ISP3X_CCM_CTRL, ISP_CCM_EN, id);
 	else
-		isp3_param_clear_bits(params_vdev, ISP3X_CCM_CTRL, ISP_CCM_EN);
+		isp3_param_clear_bits(params_vdev, ISP3X_CCM_CTRL, ISP_CCM_EN, id);
 }
 
 static void
 isp_goc_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp3x_gammaout_cfg *arg)
+	       const struct isp3x_gammaout_cfg *arg, u32 id)
 {
 	int i;
 	u32 value;
 
-	value = isp3_param_read(params_vdev, ISP3X_GAMMA_OUT_CTRL);
+	value = isp3_param_read(params_vdev, ISP3X_GAMMA_OUT_CTRL, id);
 	value &= ISP3X_GAMMA_OUT_EN;
 	value |= !!arg->equ_segm << 1 | !!arg->finalx4_dense_en << 2;
-	isp3_param_write(params_vdev, value, ISP3X_GAMMA_OUT_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_GAMMA_OUT_CTRL, id);
 
-	isp3_param_write(params_vdev, arg->offset, ISP3X_GAMMA_OUT_OFFSET);
+	isp3_param_write(params_vdev, arg->offset, ISP3X_GAMMA_OUT_OFFSET, id);
 	for (i = 0; i < ISP39_GAMMA_OUT_MAX_SAMPLES / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->gamma_y[2 * i],
 					arg->gamma_y[2 * i + 1]);
-		isp3_param_write(params_vdev, value, ISP3X_GAMMA_OUT_Y0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP3X_GAMMA_OUT_Y0 + i * 4, id);
 	}
-	isp3_param_write(params_vdev, arg->gamma_y[2 * i], ISP3X_GAMMA_OUT_Y0 + i * 4);
+	isp3_param_write(params_vdev, arg->gamma_y[2 * i], ISP3X_GAMMA_OUT_Y0 + i * 4, id);
 }
 
 static void
-isp_goc_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_goc_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	if (en)
-		isp3_param_set_bits(params_vdev, ISP3X_GAMMA_OUT_CTRL, ISP3X_GAMMA_OUT_EN);
+		isp3_param_set_bits(params_vdev,
+				    ISP3X_GAMMA_OUT_CTRL, ISP3X_GAMMA_OUT_EN, id);
 	else
-		isp3_param_clear_bits(params_vdev, ISP3X_GAMMA_OUT_CTRL, ISP3X_GAMMA_OUT_EN);
+		isp3_param_clear_bits(params_vdev,
+				      ISP3X_GAMMA_OUT_CTRL, ISP3X_GAMMA_OUT_EN, id);
 }
 
 static void
 isp_cproc_config(struct rkisp_isp_params_vdev *params_vdev,
-		 const struct isp2x_cproc_cfg *arg)
+		 const struct isp2x_cproc_cfg *arg, u32 id)
 {
 	u32 quantization = params_vdev->quantization;
 
-	isp3_param_write(params_vdev, arg->contrast, ISP3X_CPROC_CONTRAST);
-	isp3_param_write(params_vdev, arg->hue, ISP3X_CPROC_HUE);
-	isp3_param_write(params_vdev, arg->sat, ISP3X_CPROC_SATURATION);
-	isp3_param_write(params_vdev, arg->brightness, ISP3X_CPROC_BRIGHTNESS);
+	isp3_param_write(params_vdev, arg->contrast, ISP3X_CPROC_CONTRAST, id);
+	isp3_param_write(params_vdev, arg->hue, ISP3X_CPROC_HUE, id);
+	isp3_param_write(params_vdev, arg->sat, ISP3X_CPROC_SATURATION, id);
+	isp3_param_write(params_vdev, arg->brightness, ISP3X_CPROC_BRIGHTNESS, id);
 
 	if (quantization != V4L2_QUANTIZATION_FULL_RANGE) {
 		isp3_param_clear_bits(params_vdev, ISP3X_CPROC_CTRL,
 				      CIF_C_PROC_YOUT_FULL |
 				      CIF_C_PROC_YIN_FULL |
-				      CIF_C_PROC_COUT_FULL);
+				      CIF_C_PROC_COUT_FULL, id);
 	} else {
 		isp3_param_set_bits(params_vdev, ISP3X_CPROC_CTRL,
 				    CIF_C_PROC_YOUT_FULL |
 				    CIF_C_PROC_YIN_FULL |
-				    CIF_C_PROC_COUT_FULL);
+				    CIF_C_PROC_COUT_FULL, id);
 	}
 }
 
 static void
-isp_cproc_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_cproc_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	if (en)
 		isp3_param_set_bits(params_vdev, ISP3X_CPROC_CTRL,
-				    CIF_C_PROC_CTR_ENABLE);
+				    CIF_C_PROC_CTR_ENABLE, id);
 	else
 		isp3_param_clear_bits(params_vdev, ISP3X_CPROC_CTRL,
-				      CIF_C_PROC_CTR_ENABLE);
+				      CIF_C_PROC_CTR_ENABLE, id);
 }
 
 static void
-isp_ie_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_ie_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 val = 0;
 
 	if (en)
-		isp3_param_write(params_vdev, val, ISP3X_IMG_EFF_CTRL);
-	isp3_param_clear_bits(params_vdev, val, ISP3X_IMG_EFF_CTRL);
+		val =  CIF_IMG_EFF_CTRL_ENABLE;
+	isp3_param_write(params_vdev, val, ISP3X_IMG_EFF_CTRL, id);
 }
 
 static void
 isp_rawaf_config(struct rkisp_isp_params_vdev *params_vdev,
-		 const struct isp39_rawaf_meas_cfg *arg)
+		 const struct isp39_rawaf_meas_cfg *arg, u32 id)
 {
+	struct rkisp_device *dev = params_vdev->dev;
+	struct v4l2_rect *out_crop = &dev->isp_sdev.out_crop;
+	u32 width = out_crop->width, height = out_crop->height;
 	u32 i, var, ctrl;
 	u16 h_size, v_size;
 	u16 h_offs, v_offs;
 	u8 gaus_en, viir_en;
 	size_t num_of_win = min_t(size_t, ARRAY_SIZE(arg->win), arg->num_afm_win);
 
+	if (dev->unite_div > ISP_UNITE_DIV1)
+		width = width / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
+	if (dev->unite_div == ISP_UNITE_DIV4)
+		height = height / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
+
 	for (i = 0; i < num_of_win; i++) {
 		h_size = arg->win[i].h_size;
 		v_size = arg->win[i].v_size;
 		h_offs = arg->win[i].h_offs < 2 ? 2 : arg->win[i].h_offs;
 		v_offs = arg->win[i].v_offs < 1 ? 1 : arg->win[i].v_offs;
 
+		if (!v_size || v_size + v_offs - 2 > height)
+			v_size = height - v_offs - 2;
+		if (!h_size || h_size + h_offs - 2 > width)
+			h_size = width - h_offs - 2;
+
 		if (i == 0) {
 			h_size = h_size / 15 * 15;
 			v_size = v_size / 15 * 15;
@@ -917,7 +943,7 @@ isp_rawaf_config(struct rkisp_isp_params_vdev *params_vdev,
 		 */
 		isp3_param_write(params_vdev,
 				 ISP_PACK_2SHORT(v_offs, h_offs),
-				 ISP3X_RAWAF_OFFSET_WINA + i * 8);
+				 ISP3X_RAWAF_OFFSET_WINA + i * 8, id);
 
 		/*
 		 * value must be smaller than [width of picture -2]
@@ -925,75 +951,75 @@ isp_rawaf_config(struct rkisp_isp_params_vdev *params_vdev,
 		 */
 		isp3_param_write(params_vdev,
 				 ISP_PACK_2SHORT(v_size, h_size),
-				 ISP3X_RAWAF_SIZE_WINA + i * 8);
+				 ISP3X_RAWAF_SIZE_WINA + i * 8, id);
 	}
 
 	var = (arg->tnrin_shift & 0xf) << 20 |
 	      (arg->hldg_dilate_num & 0x7) << 16 |
 	      !!arg->aehgl_en << 13 | !!arg->bls_en << 12 |
 	      (arg->bls_offset & 0x1FF);
-	isp3_param_write(params_vdev, var, ISP32L_RAWAF_CTRL1);
+	isp3_param_write(params_vdev, var, ISP32L_RAWAF_CTRL1, id);
 
 	for (i = 0; i < ISP39_RAWAF_GAMMA_NUM / 2; i++) {
 		var = ISP_PACK_2SHORT(arg->gamma_y[2 * i], arg->gamma_y[2 * i + 1]);
-		isp3_param_write(params_vdev, var, ISP3X_RAWAF_GAMMA_Y0 + i * 4);
+		isp3_param_write(params_vdev, var, ISP3X_RAWAF_GAMMA_Y0 + i * 4, id);
 	}
 	var = ISP_PACK_2SHORT(arg->gamma_y[16], 0);
-	isp3_param_write(params_vdev, var, ISP3X_RAWAF_GAMMA_Y8);
+	isp3_param_write(params_vdev, var, ISP3X_RAWAF_GAMMA_Y8, id);
 
 	var = (arg->v2iir_shift_winb & 0xf) << 28 | (arg->v1iir_shift_winb & 0xf) << 24 |
 	      (arg->h2iir_shift_winb & 0xf) << 20 | (arg->h1iir_shift_winb & 0xf) << 16 |
 	      (arg->v2iir_shift_wina & 0x7) << 12 | (arg->v1iir_shift_wina & 0x7) << 8 |
 	      (arg->h2iir_shift_wina & 0x7) << 4 | (arg->h1iir_shift_wina & 0x7);
-	isp3_param_write(params_vdev, var, ISP39_RAWAF_HVIIR_VAR_SHIFT);
+	isp3_param_write(params_vdev, var, ISP39_RAWAF_HVIIR_VAR_SHIFT, id);
 
 	var = ISP_PACK_2SHORT(arg->h_fv_thresh, arg->v_fv_thresh);
-	isp3_param_write(params_vdev, var, ISP3X_RAWAF_HIIR_THRESH);
+	isp3_param_write(params_vdev, var, ISP3X_RAWAF_HIIR_THRESH, id);
 
 	for (i = 0; i < ISP39_RAWAF_VFIR_COE_NUM; i++) {
 		var = ISP_PACK_2SHORT(arg->v1fir_coe[i], arg->v2fir_coe[i]);
-		isp3_param_write(params_vdev, var, ISP32_RAWAF_V_FIR_COE0 + i * 4);
+		isp3_param_write(params_vdev, var, ISP32_RAWAF_V_FIR_COE0 + i * 4, id);
 	}
 
 	for (i = 0; i < ISP39_RAWAF_GAUS_COE_NUM / 4; i++) {
 		var = ISP_PACK_4BYTE(arg->gaus_coe[i * 4], arg->gaus_coe[i * 4 + 1],
 				     arg->gaus_coe[i * 4 + 2], arg->gaus_coe[i * 4 + 3]);
-		isp3_param_write(params_vdev, var, ISP32_RAWAF_GAUS_COE03 + i * 4);
+		isp3_param_write(params_vdev, var, ISP32_RAWAF_GAUS_COE03 + i * 4, id);
 	}
 	var = ISP_PACK_4BYTE(arg->gaus_coe[ISP32_RAWAF_GAUS_COE_NUM - 1], 0, 0, 0);
-	isp3_param_write(params_vdev, var, ISP32_RAWAF_GAUS_COE8);
+	isp3_param_write(params_vdev, var, ISP32_RAWAF_GAUS_COE8, id);
 
-	isp3_param_write(params_vdev, arg->highlit_thresh, ISP3X_RAWAF_HIGHLIT_THRESH);
+	isp3_param_write(params_vdev, arg->highlit_thresh, ISP3X_RAWAF_HIGHLIT_THRESH, id);
 
 	var = ISP_PACK_2SHORT(arg->h_fv_limit, arg->h_fv_slope);
-	isp3_param_write(params_vdev, var, ISP32L_RAWAF_CORING_H);
+	isp3_param_write(params_vdev, var, ISP32L_RAWAF_CORING_H, id);
 	var = ISP_PACK_2SHORT(arg->v_fv_limit, arg->v_fv_slope);
-	isp3_param_write(params_vdev, var, ISP32L_RAWAF_CORING_V);
+	isp3_param_write(params_vdev, var, ISP32L_RAWAF_CORING_V, id);
 
 	viir_en = arg->viir_en;
 	gaus_en = arg->gaus_en;
 
-	ctrl = isp3_param_read(params_vdev, ISP3X_RAWAF_CTRL);
+	ctrl = isp3_param_read(params_vdev, ISP3X_RAWAF_CTRL, id);
 	ctrl &= ISP3X_RAWAF_EN;
 	if (arg->hiir_en) {
 		ctrl |= ISP3X_RAWAF_HIIR_EN;
 		for (i = 0; i < ISP39_RAWAF_HIIR_COE_NUM / 2; i++) {
 			var = ISP_PACK_2SHORT(arg->h1iir1_coe[i * 2], arg->h1iir1_coe[i * 2 + 1]);
-			isp3_param_write(params_vdev, var, ISP3X_RAWAF_H1_IIR1_COE01 + i * 4);
+			isp3_param_write(params_vdev, var, ISP3X_RAWAF_H1_IIR1_COE01 + i * 4, id);
 			var = ISP_PACK_2SHORT(arg->h1iir2_coe[i * 2], arg->h1iir2_coe[i * 2 + 1]);
-			isp3_param_write(params_vdev, var, ISP3X_RAWAF_H1_IIR2_COE01 + i * 4);
+			isp3_param_write(params_vdev, var, ISP3X_RAWAF_H1_IIR2_COE01 + i * 4, id);
 
 			var = ISP_PACK_2SHORT(arg->h2iir1_coe[i * 2], arg->h2iir1_coe[i * 2 + 1]);
-			isp3_param_write(params_vdev, var, ISP3X_RAWAF_H2_IIR1_COE01 + i * 4);
+			isp3_param_write(params_vdev, var, ISP3X_RAWAF_H2_IIR1_COE01 + i * 4, id);
 			var = ISP_PACK_2SHORT(arg->h2iir2_coe[i * 2], arg->h2iir2_coe[i * 2 + 1]);
-			isp3_param_write(params_vdev, var, ISP3X_RAWAF_H2_IIR2_COE01 + i * 4);
+			isp3_param_write(params_vdev, var, ISP3X_RAWAF_H2_IIR2_COE01 + i * 4, id);
 		}
 	}
 	if (viir_en) {
 		ctrl |= ISP3X_RAWAF_VIIR_EN;
 		for (i = 0; i < ISP39_RAWAF_VIIR_COE_NUM; i++) {
 			var = ISP_PACK_2SHORT(arg->v1iir_coe[i], arg->v2iir_coe[i]);
-			isp3_param_write(params_vdev, var, ISP3X_RAWAF_V_IIR_COE0 + i * 4);
+			isp3_param_write(params_vdev, var, ISP3X_RAWAF_V_IIR_COE0 + i * 4, id);
 		}
 	}
 	if (arg->ldg_en) {
@@ -1003,12 +1029,12 @@ isp_rawaf_config(struct rkisp_isp_params_vdev *params_vdev,
 					 arg->curve_h[i].ldg_lumth |
 					 arg->curve_h[i].ldg_gain << 8 |
 					 arg->curve_h[i].ldg_gslp << 16,
-					 ISP3X_RAWAF_H_CURVEL + i * 16);
+					 ISP3X_RAWAF_H_CURVEL + i * 16, id);
 			isp3_param_write(params_vdev,
 					 arg->curve_v[i].ldg_lumth |
 					 arg->curve_v[i].ldg_gain << 8 |
 					 arg->curve_v[i].ldg_gslp << 16,
-					 ISP3X_RAWAF_V_CURVEL + i * 16);
+					 ISP3X_RAWAF_V_CURVEL + i * 16, id);
 		}
 	}
 
@@ -1022,18 +1048,18 @@ isp_rawaf_config(struct rkisp_isp_params_vdev *params_vdev,
 		!!arg->avg_ds_mode << 23 | !!arg->h1_acc_mode << 24 |
 		!!arg->h2_acc_mode << 25 | !!arg->v1_acc_mode << 26 |
 		!!arg->v2_acc_mode << 27;
-	isp3_param_write(params_vdev, ctrl, ISP3X_RAWAF_CTRL);
+	isp3_param_write(params_vdev, ctrl, ISP3X_RAWAF_CTRL, id);
 
-	ctrl = isp3_param_read(params_vdev, ISP3X_VI_ISP_PATH);
+	ctrl = isp3_param_read(params_vdev, ISP3X_VI_ISP_PATH, id);
 	ctrl &= ~(ISP3X_RAWAF_SEL(3) | ISP32L_BNR2AF_SEL);
 	ctrl |= ISP3X_RAWAF_SEL(arg->rawaf_sel) | !!arg->bnr2af_sel << 28;
-	isp3_param_write(params_vdev, ctrl, ISP3X_VI_ISP_PATH);
+	isp3_param_write(params_vdev, ctrl, ISP3X_VI_ISP_PATH, id);
 }
 
 static void
-isp_rawaf_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_rawaf_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
-	u32 afm_ctrl = isp3_param_read(params_vdev, ISP3X_RAWAF_CTRL);
+	u32 afm_ctrl = isp3_param_read(params_vdev, ISP3X_RAWAF_CTRL, id);
 
 	afm_ctrl &= ~ISP39_REG_WR_MASK;
 	if (en)
@@ -1041,26 +1067,25 @@ isp_rawaf_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
 	else
 		afm_ctrl &= ~ISP3X_RAWAF_EN;
 
-	isp3_param_write(params_vdev, afm_ctrl, ISP3X_RAWAF_CTRL);
+	isp3_param_write(params_vdev, afm_ctrl, ISP3X_RAWAF_CTRL, id);
 }
 
 static void
 isp_rawaebig_config(struct rkisp_isp_params_vdev *params_vdev,
 		    const struct isp2x_rawaebig_meas_cfg *arg,
-		    u32 addr)
+		    u32 addr, u32 id)
 {
 	struct rkisp_device *ispdev = params_vdev->dev;
 	struct v4l2_rect *out_crop = &ispdev->isp_sdev.out_crop;
-	u32 width = out_crop->width;
-	u32 block_hsize, block_vsize;
-	u32 i, value, h_size, v_size;
-	u32 wnd_num_idx = 0;
+	u32 width = out_crop->width, height = out_crop->height;
+	u32 i, value, h_size, v_size, h_offs, v_offs;
+	u32 block_hsize, block_vsize, wnd_num_idx = 0;
 	const u32 ae_wnd_num[] = {
 		1, 5, 15, 15
 	};
 
 	/* avoid to override the old enable value */
-	value = isp3_param_read(params_vdev, addr + ISP3X_RAWAE_BIG_CTRL);
+	value = isp3_param_read(params_vdev, addr + ISP3X_RAWAE_BIG_CTRL, id);
 	value &= ISP3X_RAWAE_BIG_EN;
 
 	wnd_num_idx = arg->wnd_num;
@@ -1080,102 +1105,114 @@ isp_rawaebig_config(struct rkisp_isp_params_vdev *params_vdev,
 		value |= ISP3X_RAWAE_BIG_WND3_EN;
 	if (arg->subwin_en[3])
 		value |= ISP3X_RAWAE_BIG_WND4_EN;
-	isp3_param_write(params_vdev, value, addr + ISP3X_RAWAE_BIG_CTRL);
+	isp3_param_write(params_vdev, value, addr + ISP3X_RAWAE_BIG_CTRL, id);
 
+	h_offs = arg->win.h_offs & ~0x1;
+	v_offs = arg->win.v_offs & ~0x1;
 	isp3_param_write(params_vdev,
-			 ISP_PACK_2SHORT(arg->win.h_offs, arg->win.v_offs),
-			 addr + ISP3X_RAWAE_BIG_OFFSET);
+			 ISP_PACK_2SHORT(h_offs, v_offs),
+			 addr + ISP3X_RAWAE_BIG_OFFSET, id);
 
-	block_hsize = arg->win.h_size / ae_wnd_num[wnd_num_idx];
-	value = block_hsize * ae_wnd_num[wnd_num_idx] + arg->win.h_offs;
-	if (value + 1 > width)
-		block_hsize -= 1;
-	block_vsize = arg->win.v_size / ae_wnd_num[wnd_num_idx];
-	value = block_vsize * ae_wnd_num[wnd_num_idx] + arg->win.v_offs;
-	if (value + 2 > out_crop->height)
-		block_vsize -= 1;
-	if (block_vsize % 2)
-		block_vsize -= 1;
+	if (ispdev->unite_div > ISP_UNITE_DIV1)
+		width = width / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
+	if (ispdev->unite_div == ISP_UNITE_DIV4)
+		height = height / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
+
+	h_size = arg->win.h_size;
+	v_size = arg->win.v_size;
+	if (!h_size || h_size + h_offs + 1 > width)
+		h_size = width - h_offs - 1;
+	if (!v_size || v_size + v_offs + 2 > height)
+		v_size = height - v_offs - 2;
+	block_hsize = (h_size / ae_wnd_num[wnd_num_idx]) & ~0x1;
+	block_vsize = (v_size / ae_wnd_num[wnd_num_idx]) & ~0x1;
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(block_hsize, block_vsize),
-			 addr + ISP3X_RAWAE_BIG_BLK_SIZE);
+			 addr + ISP3X_RAWAE_BIG_BLK_SIZE, id);
 
 	for (i = 0; i < ISP39_RAWAEBIG_SUBWIN_NUM; i++) {
-		value = ISP_PACK_2SHORT(arg->subwin[i].h_offs, arg->subwin[i].v_offs);
-		isp3_param_write(params_vdev, value,
-				 addr + ISP3X_RAWAE_BIG_WND1_OFFSET + 8 * i);
+		h_offs = arg->subwin[i].h_offs & ~0x1;
+		v_offs = arg->subwin[i].v_offs & ~0x1;
+		isp3_param_write(params_vdev, ISP_PACK_2SHORT(h_offs, v_offs),
+				 addr + ISP3X_RAWAE_BIG_WND1_OFFSET + 8 * i, id);
 
-		v_size = arg->subwin[i].v_size + arg->subwin[i].v_offs;
-		h_size = arg->subwin[i].h_size + arg->subwin[i].h_offs;
+		v_size = arg->subwin[i].v_size;
+		h_size = arg->subwin[i].h_size;
+		if (!h_size || h_size + h_offs > width)
+			h_size = width - h_offs;
+		if (!v_size || v_size + v_offs > height)
+			v_size = height - v_offs;
+		h_size = (h_size + h_offs) & ~0x1;
+		v_size = (v_size + v_offs) & ~0x1;
 		isp3_param_write(params_vdev, ISP_PACK_2SHORT(h_size, v_size),
-				 addr + ISP3X_RAWAE_BIG_WND1_SIZE + 8 * i);
+				 addr + ISP3X_RAWAE_BIG_WND1_SIZE + 8 * i, id);
 	}
 
-	value = isp3_param_read(params_vdev, ISP3X_VI_ISP_PATH);
+	value = isp3_param_read(params_vdev, ISP3X_VI_ISP_PATH, id);
 	if (addr == ISP3X_RAWAE_BIG1_BASE) {
 		value &= ~(ISP3X_RAWAE3_SEL(3) | BIT(29));
 		value |= ISP3X_RAWAE3_SEL(arg->rawae_sel & 0xf);
 		if (arg->rawae_sel & ISP39_BNR2AEBIG_SEL_EN)
 			value |= BIT(29);
-		isp3_param_write(params_vdev, value, ISP3X_VI_ISP_PATH);
+		isp3_param_write(params_vdev, value, ISP3X_VI_ISP_PATH, id);
 	} else {
 		value &= ~(ISP3X_RAWAE012_SEL(3) | BIT(30));
 		value |= ISP3X_RAWAE012_SEL(arg->rawae_sel & 0xf);
 		if (arg->rawae_sel & ISP39_BNR2AE0_SEL_EN)
 			value |= BIT(30);
-		isp3_param_write(params_vdev, value, ISP3X_VI_ISP_PATH);
+		isp3_param_write(params_vdev, value, ISP3X_VI_ISP_PATH, id);
 	}
 }
 
 static void
 isp_rawaebig_enable(struct rkisp_isp_params_vdev *params_vdev,
-		    bool en, u32 addr)
+		    bool en, u32 addr, u32 id)
 {
 	u32 exp_ctrl;
 
-	exp_ctrl = isp3_param_read(params_vdev, addr + ISP3X_RAWAE_BIG_CTRL);
+	exp_ctrl = isp3_param_read(params_vdev, addr + ISP3X_RAWAE_BIG_CTRL, id);
 	exp_ctrl &= ~ISP39_REG_WR_MASK;
 	if (en)
 		exp_ctrl |= ISP39_MODULE_EN;
 	else
 		exp_ctrl &= ~ISP39_MODULE_EN;
 
-	isp3_param_write(params_vdev, exp_ctrl, addr + ISP3X_RAWAE_BIG_CTRL);
+	isp3_param_write(params_vdev, exp_ctrl, addr + ISP3X_RAWAE_BIG_CTRL, id);
 }
 
 static void
 isp_rawae0_config(struct rkisp_isp_params_vdev *params_vdev,
-		  const struct isp2x_rawaebig_meas_cfg *arg)
+		  const struct isp2x_rawaebig_meas_cfg *arg, u32 id)
 {
-	isp_rawaebig_config(params_vdev, arg, ISP3X_RAWAE_LITE_BASE);
+	isp_rawaebig_config(params_vdev, arg, ISP3X_RAWAE_LITE_BASE, id);
 }
 
 static void
-isp_rawae0_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_rawae0_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
-	isp_rawaebig_enable(params_vdev, en, ISP3X_RAWAE_LITE_BASE);
+	isp_rawaebig_enable(params_vdev, en, ISP3X_RAWAE_LITE_BASE, id);
 }
 
 static void
 isp_rawae3_config(struct rkisp_isp_params_vdev *params_vdev,
-		  const struct isp2x_rawaebig_meas_cfg *arg)
+		  const struct isp2x_rawaebig_meas_cfg *arg, u32 id)
 {
-	isp_rawaebig_config(params_vdev, arg, ISP3X_RAWAE_BIG1_BASE);
+	isp_rawaebig_config(params_vdev, arg, ISP3X_RAWAE_BIG1_BASE, id);
 }
 
 static void
-isp_rawae3_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_rawae3_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
-	isp_rawaebig_enable(params_vdev, en, ISP3X_RAWAE_BIG1_BASE);
+	isp_rawaebig_enable(params_vdev, en, ISP3X_RAWAE_BIG1_BASE, id);
 }
 
 static void
 isp_rawawb_cfg_sram(struct rkisp_isp_params_vdev *params_vdev,
-		    const struct isp39_rawawb_meas_cfg *arg, bool is_check)
+		    const struct isp39_rawawb_meas_cfg *arg, bool is_check, u32 id)
 {
-	u32 i, val = ISP39_MODULE_EN;
+	u32 i, val = isp3_param_read(params_vdev, ISP3X_RAWAWB_CTRL, id);
 
-	if (is_check && !(isp3_param_read(params_vdev, ISP3X_RAWAWB_CTRL) & val))
+	if (is_check && !(val & ISP39_MODULE_EN))
 		return;
 
 	for (i = 0; i < ISP39_RAWAWB_WEIGHT_NUM / 5; i++) {
@@ -1185,51 +1222,54 @@ isp_rawawb_cfg_sram(struct rkisp_isp_params_vdev *params_vdev,
 				 (arg->wp_blk_wei_w[5 * i + 2] & 0x3f) << 12 |
 				 (arg->wp_blk_wei_w[5 * i + 3] & 0x3f) << 18 |
 				 (arg->wp_blk_wei_w[5 * i + 4] & 0x3f) << 24,
-				 ISP3X_RAWAWB_WRAM_DATA_BASE);
+				 ISP3X_RAWAWB_WRAM_DATA_BASE, id);
 	}
 }
 
 static void
 isp_rawawb_config(struct rkisp_isp_params_vdev *params_vdev,
-		  const struct isp39_rawawb_meas_cfg *arg)
+		  const struct isp39_rawawb_meas_cfg *arg, u32 id)
 {
-	struct isp39_isp_params_cfg *params_rec = params_vdev->isp39_params;
+	struct rkisp_device *dev = params_vdev->dev;
+	struct v4l2_rect *out_crop = &dev->isp_sdev.out_crop;
+	struct isp39_isp_params_cfg *params_rec = params_vdev->isp39_params + id;
 	struct isp39_rawawb_meas_cfg *arg_rec = &params_rec->meas.rawawb;
 	const struct isp2x_bls_fixed_val *pval = &arg->bls2_val;
-	u32 value, val, mask;
+	u32 width = out_crop->width, height = out_crop->height;
+	u32 value, val, mask, h_size, v_size, h_offs, v_offs;
 
-	value = isp3_param_read(params_vdev, ISP3X_BLS_CTRL);
+	value = isp3_param_read(params_vdev, ISP3X_BLS_CTRL, id);
 	value &= ~ISP32_BLS_BLS2_EN;
 	if (arg->bls2_en) {
 		switch (params_vdev->raw_type) {
 		case RAW_BGGR:
-			isp3_param_write(params_vdev, pval->r, ISP32_BLS2_D_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP32_BLS2_C_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP32_BLS2_B_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP32_BLS2_A_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP32_BLS2_D_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP32_BLS2_C_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP32_BLS2_B_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP32_BLS2_A_FIXED, id);
 			break;
 		case RAW_GBRG:
-			isp3_param_write(params_vdev, pval->r, ISP32_BLS2_C_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP32_BLS2_D_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP32_BLS2_A_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP32_BLS2_B_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP32_BLS2_C_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP32_BLS2_D_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP32_BLS2_A_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP32_BLS2_B_FIXED, id);
 			break;
 		case RAW_GRBG:
-			isp3_param_write(params_vdev, pval->r, ISP32_BLS2_B_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP32_BLS2_A_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP32_BLS2_D_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP32_BLS2_C_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP32_BLS2_B_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP32_BLS2_A_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP32_BLS2_D_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP32_BLS2_C_FIXED, id);
 			break;
 		case RAW_RGGB:
 		default:
-			isp3_param_write(params_vdev, pval->r, ISP32_BLS2_A_FIXED);
-			isp3_param_write(params_vdev, pval->gr, ISP32_BLS2_B_FIXED);
-			isp3_param_write(params_vdev, pval->gb, ISP32_BLS2_C_FIXED);
-			isp3_param_write(params_vdev, pval->b, ISP32_BLS2_D_FIXED);
+			isp3_param_write(params_vdev, pval->r, ISP32_BLS2_A_FIXED, id);
+			isp3_param_write(params_vdev, pval->gr, ISP32_BLS2_B_FIXED, id);
+			isp3_param_write(params_vdev, pval->gb, ISP32_BLS2_C_FIXED, id);
+			isp3_param_write(params_vdev, pval->b, ISP32_BLS2_D_FIXED, id);
 		}
 		value |= ISP32_BLS_BLS2_EN;
 	}
-	isp3_param_write(params_vdev, value, ISP3X_BLS_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_BLS_CTRL, id);
 
 	value = arg->in_overexposure_threshold << 16 |
 		!!arg->blk_with_luma_wei_en << 8 |
@@ -1239,455 +1279,468 @@ isp_rawawb_config(struct rkisp_isp_params_vdev *params_vdev,
 		!!arg->blk_measure_xytype << 2 |
 		!!arg->blk_measure_mode << 1 |
 		!!arg->blk_measure_enable;
-	isp3_param_write(params_vdev, value, ISP3X_RAWAWB_BLK_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_RAWAWB_BLK_CTRL, id);
 
+	h_offs = arg->h_offs & ~0x1;
+	v_offs = arg->v_offs & ~0x1;
 	isp3_param_write(params_vdev,
-			 ISP_PACK_2SHORT(arg->h_offs, arg->v_offs),
-			 ISP3X_RAWAWB_WIN_OFFS);
+			 ISP_PACK_2SHORT(h_offs, v_offs),
+			 ISP3X_RAWAWB_WIN_OFFS, id);
 
+	if (dev->unite_div > ISP_UNITE_DIV1)
+		width = width / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
+	if (dev->unite_div == ISP_UNITE_DIV4)
+		height = height / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
+
+	h_size = arg->h_size;
+	v_size = arg->v_size;
+	if (!h_size || h_size + h_offs > width)
+		h_size = width - h_offs;
+	if (!v_size || v_size + v_offs > height)
+		v_size = height - v_offs;
 	isp3_param_write(params_vdev,
-			 ISP_PACK_2SHORT(arg->h_size, arg->v_size),
-			 ISP3X_RAWAWB_WIN_SIZE);
+			 ISP_PACK_2SHORT(h_size, v_size),
+			 ISP3X_RAWAWB_WIN_SIZE, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->r_max, arg->g_max),
-			 ISP3X_RAWAWB_LIMIT_RG_MAX);
+			 ISP3X_RAWAWB_LIMIT_RG_MAX, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->b_max, arg->y_max),
-			 ISP3X_RAWAWB_LIMIT_BY_MAX);
+			 ISP3X_RAWAWB_LIMIT_BY_MAX, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->r_min, arg->g_min),
-			 ISP3X_RAWAWB_LIMIT_RG_MIN);
+			 ISP3X_RAWAWB_LIMIT_RG_MIN, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->b_min, arg->y_min),
-			 ISP3X_RAWAWB_LIMIT_BY_MIN);
+			 ISP3X_RAWAWB_LIMIT_BY_MIN, id);
 
 	value = !!arg->wp_hist_xytype << 4 |
 		!!arg->wp_blk_wei_en1 << 3 |
 		!!arg->wp_blk_wei_en0 << 2 |
 		!!arg->wp_luma_wei_en1 << 1 |
 		!!arg->wp_luma_wei_en0;
-	isp3_param_write(params_vdev, value, ISP3X_RAWAWB_WEIGHT_CURVE_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_RAWAWB_WEIGHT_CURVE_CTRL, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->wp_luma_weicurve_y0,
 					arg->wp_luma_weicurve_y1,
 					arg->wp_luma_weicurve_y2,
 					arg->wp_luma_weicurve_y3),
-			 ISP3X_RAWAWB_YWEIGHT_CURVE_XCOOR03);
+			 ISP3X_RAWAWB_YWEIGHT_CURVE_XCOOR03, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->wp_luma_weicurve_y4,
 					arg->wp_luma_weicurve_y5,
 					arg->wp_luma_weicurve_y6,
 					arg->wp_luma_weicurve_y7),
-			 ISP3X_RAWAWB_YWEIGHT_CURVE_XCOOR47);
+			 ISP3X_RAWAWB_YWEIGHT_CURVE_XCOOR47, id);
 
 	isp3_param_write(params_vdev,
 			 arg->wp_luma_weicurve_y8,
-			 ISP3X_RAWAWB_YWEIGHT_CURVE_XCOOR8);
+			 ISP3X_RAWAWB_YWEIGHT_CURVE_XCOOR8, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->wp_luma_weicurve_w0,
 					arg->wp_luma_weicurve_w1,
 					arg->wp_luma_weicurve_w2,
 					arg->wp_luma_weicurve_w3),
-			 ISP3X_RAWAWB_YWEIGHT_CURVE_YCOOR03);
+			 ISP3X_RAWAWB_YWEIGHT_CURVE_YCOOR03, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->wp_luma_weicurve_w4,
 					arg->wp_luma_weicurve_w5,
 					arg->wp_luma_weicurve_w6,
 					arg->wp_luma_weicurve_w7),
-			 ISP3X_RAWAWB_YWEIGHT_CURVE_YCOOR47);
+			 ISP3X_RAWAWB_YWEIGHT_CURVE_YCOOR47, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->wp_luma_weicurve_w8,
 					 arg->pre_wbgain_inv_r),
-			 ISP3X_RAWAWB_YWEIGHT_CURVE_YCOOR8);
+			 ISP3X_RAWAWB_YWEIGHT_CURVE_YCOOR8, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->pre_wbgain_inv_g,
 					 arg->pre_wbgain_inv_b),
-			 ISP3X_RAWAWB_PRE_WBGAIN_INV);
+			 ISP3X_RAWAWB_PRE_WBGAIN_INV, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex0_u_0, arg->vertex0_v_0),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX0_0);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX0_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex1_u_0, arg->vertex1_v_0),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX1_0);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX1_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex2_u_0, arg->vertex2_v_0),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX2_0);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX2_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex3_u_0, arg->vertex3_v_0),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX3_0);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX3_0, id);
 
 	isp3_param_write(params_vdev, arg->islope01_0,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE01_0);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE01_0, id);
 
 	isp3_param_write(params_vdev, arg->islope12_0,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE12_0);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE12_0, id);
 
 	isp3_param_write(params_vdev, arg->islope23_0,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE23_0);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE23_0, id);
 
 	isp3_param_write(params_vdev, arg->islope30_0,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE30_0);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE30_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex0_u_1,
 					 arg->vertex0_v_1),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX0_1);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX0_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex1_u_1,
 					 arg->vertex1_v_1),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX1_1);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX1_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex2_u_1,
 					 arg->vertex2_v_1),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX2_1);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX2_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex3_u_1,
 					 arg->vertex3_v_1),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX3_1);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX3_1, id);
 
 	isp3_param_write(params_vdev, arg->islope01_1,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE01_1);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE01_1, id);
 
 	isp3_param_write(params_vdev, arg->islope12_1,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE12_1);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE12_1, id);
 
 	isp3_param_write(params_vdev, arg->islope23_1,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE23_1);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE23_1, id);
 
 	isp3_param_write(params_vdev, arg->islope30_1,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE30_1);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE30_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex0_u_2,
 					 arg->vertex0_v_2),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX0_2);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX0_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex1_u_2,
 					 arg->vertex1_v_2),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX1_2);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX1_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex2_u_2,
 					 arg->vertex2_v_2),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX2_2);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX2_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex3_u_2,
 					 arg->vertex3_v_2),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX3_2);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX3_2, id);
 
 	isp3_param_write(params_vdev, arg->islope01_2,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE01_2);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE01_2, id);
 
 	isp3_param_write(params_vdev, arg->islope12_2,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE12_2);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE12_2, id);
 
 	isp3_param_write(params_vdev, arg->islope23_2,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE23_2);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE23_2, id);
 
 	isp3_param_write(params_vdev, arg->islope30_2,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE30_2);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE30_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex0_u_3,
 					 arg->vertex0_v_3),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX0_3);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX0_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex1_u_3,
 					 arg->vertex1_v_3),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX1_3);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX1_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex2_u_3,
 					 arg->vertex2_v_3),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX2_3);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX2_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->vertex3_u_3,
 					 arg->vertex3_v_3),
-			 ISP3X_RAWAWB_UV_DETC_VERTEX3_3);
+			 ISP3X_RAWAWB_UV_DETC_VERTEX3_3, id);
 
 	isp3_param_write(params_vdev, arg->islope01_3,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE01_3);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE01_3, id);
 
 	isp3_param_write(params_vdev, arg->islope12_3,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE12_3);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE12_3, id);
 
 	isp3_param_write(params_vdev, arg->islope23_3,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE23_3);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE23_3, id);
 
 	isp3_param_write(params_vdev, arg->islope30_3,
-			 ISP3X_RAWAWB_UV_DETC_ISLOPE30_3);
+			 ISP3X_RAWAWB_UV_DETC_ISLOPE30_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->rgb2ryuvmat0_y,
 					 arg->rgb2ryuvmat1_y),
-			 ISP3X_RAWAWB_YUV_RGB2ROTY_0);
+			 ISP3X_RAWAWB_YUV_RGB2ROTY_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->rgb2ryuvmat2_y,
 					 arg->rgb2ryuvofs_y),
-			 ISP3X_RAWAWB_YUV_RGB2ROTY_1);
+			 ISP3X_RAWAWB_YUV_RGB2ROTY_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->rgb2ryuvmat0_u,
 					 arg->rgb2ryuvmat1_u),
-			 ISP3X_RAWAWB_YUV_RGB2ROTU_0);
+			 ISP3X_RAWAWB_YUV_RGB2ROTU_0, id);
 
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->rgb2ryuvmat2_u,
 					 arg->rgb2ryuvofs_u),
-			 ISP3X_RAWAWB_YUV_RGB2ROTU_1);
+			 ISP3X_RAWAWB_YUV_RGB2ROTU_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->rgb2ryuvmat0_v,
 					 arg->rgb2ryuvmat1_v),
-			 ISP3X_RAWAWB_YUV_RGB2ROTV_0);
+			 ISP3X_RAWAWB_YUV_RGB2ROTV_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->rgb2ryuvmat2_v,
 					 arg->rgb2ryuvofs_v),
-			 ISP3X_RAWAWB_YUV_RGB2ROTV_1);
+			 ISP3X_RAWAWB_YUV_RGB2ROTV_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls0_y,
 					 arg->vec_x21_ls0_y),
-			 ISP3X_RAWAWB_YUV_X_COOR_Y_0);
+			 ISP3X_RAWAWB_YUV_X_COOR_Y_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls0_u,
 					 arg->vec_x21_ls0_u),
-			 ISP3X_RAWAWB_YUV_X_COOR_U_0);
+			 ISP3X_RAWAWB_YUV_X_COOR_U_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls0_v,
 					 arg->vec_x21_ls0_v),
-			 ISP3X_RAWAWB_YUV_X_COOR_V_0);
+			 ISP3X_RAWAWB_YUV_X_COOR_V_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->dis_x1x2_ls0, 0,
 					arg->rotu0_ls0, arg->rotu1_ls0),
-			 ISP3X_RAWAWB_YUV_X1X2_DIS_0);
+			 ISP3X_RAWAWB_YUV_X1X2_DIS_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->rotu2_ls0, arg->rotu3_ls0,
 					arg->rotu4_ls0, arg->rotu5_ls0),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_UCOOR_0);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_UCOOR_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th0_ls0, arg->th1_ls0),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH0_0);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH0_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th2_ls0, arg->th3_ls0),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH1_0);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH1_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th4_ls0, arg->th5_ls0),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH2_0);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH2_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls1_y, arg->vec_x21_ls1_y),
-			 ISP3X_RAWAWB_YUV_X_COOR_Y_1);
+			 ISP3X_RAWAWB_YUV_X_COOR_Y_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls1_u, arg->vec_x21_ls1_u),
-			 ISP3X_RAWAWB_YUV_X_COOR_U_1);
+			 ISP3X_RAWAWB_YUV_X_COOR_U_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls1_v, arg->vec_x21_ls1_v),
-			 ISP3X_RAWAWB_YUV_X_COOR_V_1);
+			 ISP3X_RAWAWB_YUV_X_COOR_V_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->dis_x1x2_ls1, 0, arg->rotu0_ls1, arg->rotu1_ls1),
-			 ISP3X_RAWAWB_YUV_X1X2_DIS_1);
+			 ISP3X_RAWAWB_YUV_X1X2_DIS_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->rotu2_ls1, arg->rotu3_ls1,
 					arg->rotu4_ls1, arg->rotu5_ls1),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_UCOOR_1);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_UCOOR_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th0_ls1, arg->th1_ls1),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH0_1);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH0_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th2_ls1, arg->th3_ls1),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH1_1);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH1_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th4_ls1, arg->th5_ls1),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH2_1);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH2_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls2_y, arg->vec_x21_ls2_y),
-			 ISP3X_RAWAWB_YUV_X_COOR_Y_2);
+			 ISP3X_RAWAWB_YUV_X_COOR_Y_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls2_u, arg->vec_x21_ls2_u),
-			 ISP3X_RAWAWB_YUV_X_COOR_U_2);
+			 ISP3X_RAWAWB_YUV_X_COOR_U_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls2_v, arg->vec_x21_ls2_v),
-			 ISP3X_RAWAWB_YUV_X_COOR_V_2);
+			 ISP3X_RAWAWB_YUV_X_COOR_V_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->dis_x1x2_ls2, 0, arg->rotu0_ls2, arg->rotu1_ls2),
-			 ISP3X_RAWAWB_YUV_X1X2_DIS_2);
+			 ISP3X_RAWAWB_YUV_X1X2_DIS_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->rotu2_ls2, arg->rotu3_ls2,
 					arg->rotu4_ls2, arg->rotu5_ls2),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_UCOOR_2);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_UCOOR_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th0_ls2, arg->th1_ls2),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH0_2);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH0_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th2_ls2, arg->th3_ls2),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH1_2);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH1_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th4_ls2, arg->th5_ls2),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH2_2);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH2_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls3_y, arg->vec_x21_ls3_y),
-			 ISP3X_RAWAWB_YUV_X_COOR_Y_3);
+			 ISP3X_RAWAWB_YUV_X_COOR_Y_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls3_u, arg->vec_x21_ls3_u),
-			 ISP3X_RAWAWB_YUV_X_COOR_U_3);
+			 ISP3X_RAWAWB_YUV_X_COOR_U_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->coor_x1_ls3_v, arg->vec_x21_ls3_v),
-			 ISP3X_RAWAWB_YUV_X_COOR_V_3);
+			 ISP3X_RAWAWB_YUV_X_COOR_V_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->dis_x1x2_ls3, 0,
 					arg->rotu0_ls3, arg->rotu1_ls3),
-			 ISP3X_RAWAWB_YUV_X1X2_DIS_3);
+			 ISP3X_RAWAWB_YUV_X1X2_DIS_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->rotu2_ls3, arg->rotu3_ls3,
 					arg->rotu4_ls3, arg->rotu5_ls3),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_UCOOR_3);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_UCOOR_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th0_ls3, arg->th1_ls3),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH0_3);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH0_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th2_ls3, arg->th3_ls3),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH1_3);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH1_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->th4_ls3, arg->th5_ls3),
-			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH2_3);
+			 ISP3X_RAWAWB_YUV_INTERP_CURVE_TH2_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->wt0, arg->wt1),
-			 ISP3X_RAWAWB_RGB2XY_WT01);
+			 ISP3X_RAWAWB_RGB2XY_WT01, id);
 
 	isp3_param_write(params_vdev, arg->wt2,
-			 ISP3X_RAWAWB_RGB2XY_WT2);
+			 ISP3X_RAWAWB_RGB2XY_WT2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->mat0_x, arg->mat0_y),
-			 ISP3X_RAWAWB_RGB2XY_MAT0_XY);
+			 ISP3X_RAWAWB_RGB2XY_MAT0_XY, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->mat1_x, arg->mat1_y),
-			 ISP3X_RAWAWB_RGB2XY_MAT1_XY);
+			 ISP3X_RAWAWB_RGB2XY_MAT1_XY, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->mat2_x, arg->mat2_y),
-			 ISP3X_RAWAWB_RGB2XY_MAT2_XY);
+			 ISP3X_RAWAWB_RGB2XY_MAT2_XY, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->nor_x0_0, arg->nor_x1_0),
-			 ISP3X_RAWAWB_XY_DETC_NOR_X_0);
+			 ISP3X_RAWAWB_XY_DETC_NOR_X_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->nor_y0_0, arg->nor_y1_0),
-			 ISP3X_RAWAWB_XY_DETC_NOR_Y_0);
+			 ISP3X_RAWAWB_XY_DETC_NOR_Y_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->big_x0_0, arg->big_x1_0),
-			 ISP3X_RAWAWB_XY_DETC_BIG_X_0);
+			 ISP3X_RAWAWB_XY_DETC_BIG_X_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->big_y0_0, arg->big_y1_0),
-			 ISP3X_RAWAWB_XY_DETC_BIG_Y_0);
+			 ISP3X_RAWAWB_XY_DETC_BIG_Y_0, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->nor_x0_1, arg->nor_x1_1),
-			 ISP3X_RAWAWB_XY_DETC_NOR_X_1);
+			 ISP3X_RAWAWB_XY_DETC_NOR_X_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->nor_y0_1, arg->nor_y1_1),
-			 ISP3X_RAWAWB_XY_DETC_NOR_Y_1);
+			 ISP3X_RAWAWB_XY_DETC_NOR_Y_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->big_x0_1, arg->big_x1_1),
-			 ISP3X_RAWAWB_XY_DETC_BIG_X_1);
+			 ISP3X_RAWAWB_XY_DETC_BIG_X_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->big_y0_1, arg->big_y1_1),
-			 ISP3X_RAWAWB_XY_DETC_BIG_Y_1);
+			 ISP3X_RAWAWB_XY_DETC_BIG_Y_1, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->nor_x0_2, arg->nor_x1_2),
-			 ISP3X_RAWAWB_XY_DETC_NOR_X_2);
+			 ISP3X_RAWAWB_XY_DETC_NOR_X_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->nor_y0_2, arg->nor_y1_2),
-			 ISP3X_RAWAWB_XY_DETC_NOR_Y_2);
+			 ISP3X_RAWAWB_XY_DETC_NOR_Y_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->big_x0_2, arg->big_x1_2),
-			 ISP3X_RAWAWB_XY_DETC_BIG_X_2);
+			 ISP3X_RAWAWB_XY_DETC_BIG_X_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->big_y0_2, arg->big_y1_2),
-			 ISP3X_RAWAWB_XY_DETC_BIG_Y_2);
+			 ISP3X_RAWAWB_XY_DETC_BIG_Y_2, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->nor_x0_3, arg->nor_x1_3),
-			 ISP3X_RAWAWB_XY_DETC_NOR_X_3);
+			 ISP3X_RAWAWB_XY_DETC_NOR_X_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->nor_y0_3, arg->nor_y1_3),
-			 ISP3X_RAWAWB_XY_DETC_NOR_Y_3);
+			 ISP3X_RAWAWB_XY_DETC_NOR_Y_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->big_x0_3, arg->big_x1_3),
-			 ISP3X_RAWAWB_XY_DETC_BIG_X_3);
+			 ISP3X_RAWAWB_XY_DETC_BIG_X_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->big_y0_3, arg->big_y1_3),
-			 ISP3X_RAWAWB_XY_DETC_BIG_Y_3);
+			 ISP3X_RAWAWB_XY_DETC_BIG_Y_3, id);
 
 	value = (arg->exc_wp_region0_excen & 0x3) |
 		!!arg->exc_wp_region0_measen << 2 |
@@ -1708,131 +1761,131 @@ isp_rawawb_config(struct rkisp_isp_params_vdev *params_vdev,
 		(arg->exc_wp_region6_excen & 0x3) << 24 |
 		!!arg->exc_wp_region6_domain << 27 |
 		!!arg->multiwindow_en << 31;
-	isp3_param_write(params_vdev, value, ISP3X_RAWAWB_MULTIWINDOW_EXC_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_RAWAWB_MULTIWINDOW_EXC_CTRL, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->multiwindow0_h_offs,
 					 arg->multiwindow0_v_offs),
-			 ISP3X_RAWAWB_MULTIWINDOW0_OFFS);
+			 ISP3X_RAWAWB_MULTIWINDOW0_OFFS, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->multiwindow0_h_size,
 					 arg->multiwindow0_v_size),
-			 ISP3X_RAWAWB_MULTIWINDOW0_SIZE);
+			 ISP3X_RAWAWB_MULTIWINDOW0_SIZE, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->multiwindow1_h_offs,
 					 arg->multiwindow1_v_offs),
-			 ISP3X_RAWAWB_MULTIWINDOW1_OFFS);
+			 ISP3X_RAWAWB_MULTIWINDOW1_OFFS, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->multiwindow1_h_size,
 					 arg->multiwindow1_v_size),
-			 ISP3X_RAWAWB_MULTIWINDOW1_SIZE);
+			 ISP3X_RAWAWB_MULTIWINDOW1_SIZE, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->multiwindow2_h_offs,
 					 arg->multiwindow2_v_offs),
-			 ISP3X_RAWAWB_MULTIWINDOW2_OFFS);
+			 ISP3X_RAWAWB_MULTIWINDOW2_OFFS, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->multiwindow2_h_size,
 					 arg->multiwindow2_v_size),
-			 ISP3X_RAWAWB_MULTIWINDOW2_SIZE);
+			 ISP3X_RAWAWB_MULTIWINDOW2_SIZE, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->multiwindow3_h_offs,
 					 arg->multiwindow3_v_offs),
-			 ISP3X_RAWAWB_MULTIWINDOW3_OFFS);
+			 ISP3X_RAWAWB_MULTIWINDOW3_OFFS, id);
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->multiwindow3_h_size,
 					 arg->multiwindow3_v_size),
-			 ISP3X_RAWAWB_MULTIWINDOW3_SIZE);
+			 ISP3X_RAWAWB_MULTIWINDOW3_SIZE, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region0_xu0,
 					 arg->exc_wp_region0_xu1),
-			 ISP3X_RAWAWB_EXC_WP_REGION0_XU);
+			 ISP3X_RAWAWB_EXC_WP_REGION0_XU, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region0_yv0,
 					 arg->exc_wp_region0_yv1),
-			 ISP3X_RAWAWB_EXC_WP_REGION0_YV);
+			 ISP3X_RAWAWB_EXC_WP_REGION0_YV, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region1_xu0,
 					 arg->exc_wp_region1_xu1),
-			 ISP3X_RAWAWB_EXC_WP_REGION1_XU);
+			 ISP3X_RAWAWB_EXC_WP_REGION1_XU, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region1_yv0,
 					 arg->exc_wp_region1_yv1),
-			 ISP3X_RAWAWB_EXC_WP_REGION1_YV);
+			 ISP3X_RAWAWB_EXC_WP_REGION1_YV, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region2_xu0,
 					 arg->exc_wp_region2_xu1),
-			 ISP3X_RAWAWB_EXC_WP_REGION2_XU);
+			 ISP3X_RAWAWB_EXC_WP_REGION2_XU, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region2_yv0,
 					 arg->exc_wp_region2_yv1),
-			 ISP3X_RAWAWB_EXC_WP_REGION2_YV);
+			 ISP3X_RAWAWB_EXC_WP_REGION2_YV, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region3_xu0,
 					 arg->exc_wp_region3_xu1),
-			 ISP3X_RAWAWB_EXC_WP_REGION3_XU);
+			 ISP3X_RAWAWB_EXC_WP_REGION3_XU, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region3_yv0,
 					 arg->exc_wp_region3_yv1),
-			 ISP3X_RAWAWB_EXC_WP_REGION3_YV);
+			 ISP3X_RAWAWB_EXC_WP_REGION3_YV, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region4_xu0,
 					 arg->exc_wp_region4_xu1),
-			 ISP3X_RAWAWB_EXC_WP_REGION4_XU);
+			 ISP3X_RAWAWB_EXC_WP_REGION4_XU, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region4_yv0,
 					 arg->exc_wp_region4_yv1),
-			 ISP3X_RAWAWB_EXC_WP_REGION4_YV);
+			 ISP3X_RAWAWB_EXC_WP_REGION4_YV, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region5_xu0,
 					 arg->exc_wp_region5_xu1),
-			 ISP3X_RAWAWB_EXC_WP_REGION5_XU);
+			 ISP3X_RAWAWB_EXC_WP_REGION5_XU, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region5_yv0,
 					 arg->exc_wp_region5_yv1),
-			 ISP3X_RAWAWB_EXC_WP_REGION5_YV);
+			 ISP3X_RAWAWB_EXC_WP_REGION5_YV, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region6_xu0,
 					 arg->exc_wp_region6_xu1),
-			 ISP3X_RAWAWB_EXC_WP_REGION6_XU);
+			 ISP3X_RAWAWB_EXC_WP_REGION6_XU, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(arg->exc_wp_region6_yv0,
 					 arg->exc_wp_region6_yv1),
-			 ISP3X_RAWAWB_EXC_WP_REGION6_YV);
+			 ISP3X_RAWAWB_EXC_WP_REGION6_YV, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->exc_wp_region0_weight,
 					arg->exc_wp_region1_weight,
 					arg->exc_wp_region2_weight,
 					arg->exc_wp_region3_weight),
-			 ISP32_RAWAWB_EXC_WP_WEIGHT0_3);
+			 ISP32_RAWAWB_EXC_WP_WEIGHT0_3, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->exc_wp_region4_weight,
 					arg->exc_wp_region5_weight,
 					arg->exc_wp_region6_weight, 0),
-			 ISP32_RAWAWB_EXC_WP_WEIGHT4_6);
+			 ISP32_RAWAWB_EXC_WP_WEIGHT4_6, id);
 
 	if (params_vdev->dev->hw_dev->is_single)
-		isp_rawawb_cfg_sram(params_vdev, arg, false);
+		isp_rawawb_cfg_sram(params_vdev, arg, false, id);
 	else
 		memcpy(arg_rec->wp_blk_wei_w, arg->wp_blk_wei_w, ISP39_RAWAWB_WEIGHT_NUM);
 
 	/* avoid to override the old enable value */
-	value = isp3_param_read_cache(params_vdev, ISP3X_RAWAWB_CTRL);
+	value = isp3_param_read_cache(params_vdev, ISP3X_RAWAWB_CTRL, id);
 	value &= (ISP39_MODULE_EN |
 		  ISP32_RAWAWB_2DDR_PATH_EN |
 		  ISP32_RAWAWB_2DDR_PATH_DS);
@@ -1852,46 +1905,45 @@ isp_rawawb_config(struct rkisp_isp_params_vdev *params_vdev,
 		 !!arg->yuv3d_en0 << 3 |
 		 !!arg->xy_en0 << 2 |
 		 !!arg->uv_en0 << 1;
-	isp3_param_write(params_vdev, value, ISP3X_RAWAWB_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_RAWAWB_CTRL, id);
 
 	mask = ISP32_DRC2AWB_SEL | ISP32_BNR2AWB_SEL | ISP3X_RAWAWB_SEL(3);
 	val = ISP3X_RAWAWB_SEL(arg->rawawb_sel) |
 	      (arg->bnr2awb_sel & 0x1) << 26 | (arg->drc2awb_sel & 0x1) << 27;
-	value = isp3_param_read(params_vdev, ISP3X_VI_ISP_PATH);
+	value = isp3_param_read(params_vdev, ISP3X_VI_ISP_PATH, id);
 	if ((value & mask) != val) {
 		value &= ~mask;
 		value |= val;
-		isp3_param_write(params_vdev, value, ISP3X_VI_ISP_PATH);
+		isp3_param_write(params_vdev, value, ISP3X_VI_ISP_PATH, id);
 	}
 }
 
 static void
-isp_rawawb_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_rawawb_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 awb_ctrl;
 
-	awb_ctrl = isp3_param_read_cache(params_vdev, ISP3X_RAWAWB_CTRL);
+	awb_ctrl = isp3_param_read_cache(params_vdev, ISP3X_RAWAWB_CTRL, id);
 	awb_ctrl &= ~ISP39_REG_WR_MASK;
 	if (en)
 		awb_ctrl |= ISP39_MODULE_EN;
 	else
 		awb_ctrl &= ~ISP39_MODULE_EN;
 
-	isp3_param_write(params_vdev, awb_ctrl, ISP3X_RAWAWB_CTRL);
+	isp3_param_write(params_vdev, awb_ctrl, ISP3X_RAWAWB_CTRL, id);
 }
 
 static void
 isp_rawhstbig_cfg_sram(struct rkisp_isp_params_vdev *params_vdev,
 		       const struct isp2x_rawhistbig_cfg *arg,
-		       u32 addr, bool is_check)
+		       u32 addr, bool is_check, u32 id)
 {
 	u32 i, j, wnd_num_idx, value;
 	u8 weight15x15[ISP39_RAWHISTBIG_WEIGHT_REG_SIZE];
 	const u32 hist_wnd_num[] = {5, 5, 15, 15};
 
-	value = ISP3X_RAWHIST_EN;
-	if (is_check &&
-	    !(isp3_param_read(params_vdev, addr + ISP3X_RAWHIST_BIG_CTRL) & value))
+	value = isp3_param_read(params_vdev, addr + ISP3X_RAWHIST_BIG_CTRL, id);
+	if (is_check && !(value & ISP3X_RAWHIST_EN))
 		return;
 
 	wnd_num_idx = arg->wnd_num;
@@ -1922,12 +1974,15 @@ isp_rawhstbig_cfg_sram(struct rkisp_isp_params_vdev *params_vdev,
 
 static void
 isp_rawhstbig_config(struct rkisp_isp_params_vdev *params_vdev,
-		     const struct isp2x_rawhistbig_cfg *arg, u32 addr)
+		     const struct isp2x_rawhistbig_cfg *arg, u32 addr, u32 id)
 {
-	struct isp39_isp_params_cfg *params_rec = params_vdev->isp39_params;
+	struct isp39_isp_params_cfg *params_rec = params_vdev->isp39_params + id;
 	struct rkisp_device *dev = params_vdev->dev;
+	struct v4l2_rect *out_crop = &dev->isp_sdev.out_crop;
+	u32 width = out_crop->width, height = out_crop->height;
 	struct isp2x_rawhistbig_cfg *arg_rec;
 	u32 hist_ctrl, block_hsize, block_vsize, wnd_num_idx;
+	u32 h_size, v_size, h_offs, v_offs;
 	const u32 hist_wnd_num[] = {5, 5, 15, 15};
 
 	wnd_num_idx = arg->wnd_num;
@@ -1938,7 +1993,7 @@ isp_rawhstbig_config(struct rkisp_isp_params_vdev *params_vdev,
 			__func__, arg->wnd_num, wnd_num_idx);
 	}
 	/* avoid to override the old enable value */
-	hist_ctrl = isp3_param_read(params_vdev, addr + ISP3X_RAWHIST_BIG_CTRL);
+	hist_ctrl = isp3_param_read(params_vdev, addr + ISP3X_RAWHIST_BIG_CTRL, id);
 	hist_ctrl &= ISP3X_RAWHIST_EN;
 	hist_ctrl = hist_ctrl |
 		    ISP3X_RAWHIST_MODE(arg->mode) |
@@ -1946,92 +2001,101 @@ isp_rawhstbig_config(struct rkisp_isp_params_vdev *params_vdev,
 		    ISP3X_RAWHIST_STEPSIZE(arg->stepsize) |
 		    ISP3X_RAWHIST_DATASEL(arg->data_sel) |
 		    ISP3X_RAWHIST_WATERLINE(arg->waterline);
-	isp3_param_write(params_vdev, hist_ctrl, addr + ISP3X_RAWHIST_BIG_CTRL);
+	isp3_param_write(params_vdev, hist_ctrl, addr + ISP3X_RAWHIST_BIG_CTRL, id);
 
+	h_offs = arg->win.h_offs & ~0x1;
+	v_offs = arg->win.v_offs & ~0x1;
 	isp3_param_write(params_vdev,
-			 ISP_PACK_2SHORT(arg->win.h_offs, arg->win.v_offs),
-			 addr + ISP3X_RAWHIST_BIG_OFFS);
+			 ISP_PACK_2SHORT(h_offs, v_offs),
+			 addr + ISP3X_RAWHIST_BIG_OFFS, id);
 
-	block_hsize = arg->win.h_size / hist_wnd_num[wnd_num_idx] - 1;
-	block_vsize = arg->win.v_size / hist_wnd_num[wnd_num_idx] - 1;
-	block_hsize &= 0xFFFE;
-	block_vsize &= 0xFFFE;
+	if (dev->unite_div > ISP_UNITE_DIV1)
+		width = width / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
+	if (dev->unite_div == ISP_UNITE_DIV4)
+		height = height / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
+
+	h_size = arg->win.h_size;
+	v_size = arg->win.v_size;
+	if (!h_size || h_size + h_offs + 1 > width)
+		h_size = width - h_offs - 1;
+	if (!v_size || v_size + v_offs + 1 > height)
+		v_size = height - v_offs - 1;
+	block_hsize = (h_size / hist_wnd_num[wnd_num_idx]) & ~0x1;
+	block_vsize = (v_size / hist_wnd_num[wnd_num_idx]) & ~0x1;
 	isp3_param_write(params_vdev,
 			 ISP_PACK_2SHORT(block_hsize, block_vsize),
-			 addr + ISP3X_RAWHIST_BIG_SIZE);
+			 addr + ISP3X_RAWHIST_BIG_SIZE, id);
 
 	isp3_param_write(params_vdev,
 			 ISP_PACK_4BYTE(arg->rcc, arg->gcc, arg->bcc, arg->off),
-			 addr + ISP3X_RAWHIST_BIG_RAW2Y_CC);
+			 addr + ISP3X_RAWHIST_BIG_RAW2Y_CC, id);
 
 	if (dev->hw_dev->is_single) {
-		isp_rawhstbig_cfg_sram(params_vdev, arg, addr, false);
-	} else {
-		arg_rec = (addr == ISP3X_RAWHIST_LITE_BASE) ?
-			&params_rec->meas.rawhist0 : &params_rec->meas.rawhist3;
-		*arg_rec = *arg;
+		isp_rawhstbig_cfg_sram(params_vdev, arg, addr, false, id);
 	}
+	arg_rec = (addr == ISP3X_RAWHIST_LITE_BASE) ?
+		  &params_rec->meas.rawhist0 : &params_rec->meas.rawhist3;
+	*arg_rec = *arg;
 }
 
 static void
 isp_rawhstbig_enable(struct rkisp_isp_params_vdev *params_vdev,
-		     bool en, u32 addr)
+		     bool en, u32 addr, u32 id)
 {
 	u32 hist_ctrl;
 
-	hist_ctrl = isp3_param_read(params_vdev, addr + ISP3X_RAWHIST_BIG_CTRL);
+	hist_ctrl = isp3_param_read(params_vdev, addr + ISP3X_RAWHIST_BIG_CTRL, id);
 	hist_ctrl &= ~(ISP3X_RAWHIST_EN | ISP39_REG_WR_MASK);
 	if (en)
 		hist_ctrl |= ISP3X_RAWHIST_EN;
-
-	isp3_param_write(params_vdev, hist_ctrl, addr + ISP3X_RAWHIST_BIG_CTRL);
+	isp3_param_write(params_vdev, hist_ctrl, addr + ISP3X_RAWHIST_BIG_CTRL, id);
 }
 
 static void
 isp_rawhst0_config(struct rkisp_isp_params_vdev *params_vdev,
-		   const struct isp2x_rawhistbig_cfg *arg)
+		   const struct isp2x_rawhistbig_cfg *arg, u32 id)
 {
-	isp_rawhstbig_config(params_vdev, arg, ISP3X_RAWHIST_LITE_BASE);
+	isp_rawhstbig_config(params_vdev, arg, ISP3X_RAWHIST_LITE_BASE, id);
 }
 
 static void
-isp_rawhst0_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_rawhst0_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
-	isp_rawhstbig_enable(params_vdev, en, ISP3X_RAWHIST_LITE_BASE);
+	isp_rawhstbig_enable(params_vdev, en, ISP3X_RAWHIST_LITE_BASE, id);
 }
 
 static void
 isp_rawhst3_config(struct rkisp_isp_params_vdev *params_vdev,
-		   const struct isp2x_rawhistbig_cfg *arg)
+		   const struct isp2x_rawhistbig_cfg *arg, u32 id)
 {
-	isp_rawhstbig_config(params_vdev, arg, ISP3X_RAWHIST_BIG1_BASE);
+	isp_rawhstbig_config(params_vdev, arg, ISP3X_RAWHIST_BIG1_BASE, id);
 }
 
 static void
-isp_rawhst3_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_rawhst3_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
-	isp_rawhstbig_enable(params_vdev, en, ISP3X_RAWHIST_BIG1_BASE);
+	isp_rawhstbig_enable(params_vdev, en, ISP3X_RAWHIST_BIG1_BASE, id);
 }
 
 static void
 isp_hdrmge_config(struct rkisp_isp_params_vdev *params_vdev,
 		  const struct isp32_hdrmge_cfg *arg,
-		  enum rkisp_params_type type)
+		  enum rkisp_params_type type, u32 id)
 {
 	u32 value;
 	int i;
 
 	if (type == RKISP_PARAMS_SHD || type == RKISP_PARAMS_ALL) {
 		value = ISP_PACK_2SHORT(arg->gain0, arg->gain0_inv);
-		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_GAIN0);
+		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_GAIN0, id);
 
 		value = ISP_PACK_2SHORT(arg->gain1, arg->gain1_inv);
-		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_GAIN1);
+		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_GAIN1, id);
 
 		value = arg->gain2;
-		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_GAIN2);
+		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_GAIN2, id);
 
-		value = isp3_param_read_cache(params_vdev, ISP3X_HDRMGE_CTRL);
+		value = isp3_param_read_cache(params_vdev, ISP3X_HDRMGE_CTRL, id);
 		if (arg->s_base)
 			value |= BIT(1);
 		else
@@ -2040,56 +2104,56 @@ isp_hdrmge_config(struct rkisp_isp_params_vdev *params_vdev,
 			value |= BIT(6);
 		else
 			value &= ~BIT(6);
-		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_CTRL);
+		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_CTRL, id);
 	}
 
 	if (type == RKISP_PARAMS_IMD || type == RKISP_PARAMS_ALL) {
 		value = ISP_PACK_4BYTE(arg->ms_dif_0p8, arg->ms_diff_0p15,
 				       arg->lm_dif_0p9, arg->lm_dif_0p15);
-		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_LIGHTZ);
+		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_LIGHTZ, id);
 		value = (arg->ms_scl & 0x7ff) |
 			(arg->ms_thd0 & 0x3ff) << 12 |
 			(arg->ms_thd1 & 0x3ff) << 22;
-		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_MS_DIFF);
+		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_MS_DIFF, id);
 		value = (arg->lm_scl & 0x7ff) |
 			(arg->lm_thd0 & 0x3ff) << 12 |
 			(arg->lm_thd1 & 0x3ff) << 22;
-		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_LM_DIFF);
+		isp3_param_write(params_vdev, value, ISP3X_HDRMGE_LM_DIFF, id);
 
 		for (i = 0; i < ISP39_HDRMGE_L_CURVE_NUM; i++) {
 			value = ISP_PACK_2SHORT(arg->curve.curve_0[i], arg->curve.curve_1[i]);
-			isp3_param_write(params_vdev, value, ISP3X_HDRMGE_DIFF_Y0 + 4 * i);
+			isp3_param_write(params_vdev, value, ISP3X_HDRMGE_DIFF_Y0 + 4 * i, id);
 		}
 
 		for (i = 0; i < ISP39_HDRMGE_E_CURVE_NUM; i++) {
 			value = (arg->l_raw1[i] & 0x3ff) << 20 |
 				(arg->l_raw0[i] & 0x3ff) << 10 |
 				(arg->e_y[i] & 0x3ff);
-			isp3_param_write(params_vdev, value, ISP3X_HDRMGE_OVER_Y0 + 4 * i);
+			isp3_param_write(params_vdev, value, ISP3X_HDRMGE_OVER_Y0 + 4 * i, id);
 		}
 
 		value = ISP_PACK_2SHORT(arg->each_raw_gain0, arg->each_raw_gain1);
-		isp3_param_write(params_vdev, value, ISP32_HDRMGE_EACH_GAIN);
+		isp3_param_write(params_vdev, value, ISP32_HDRMGE_EACH_GAIN, id);
 	}
 }
 
 static void
-isp_hdrmge_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_hdrmge_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 }
 
 static void
 isp_hdrdrc_config(struct rkisp_isp_params_vdev *params_vdev,
 		  const struct isp39_drc_cfg *arg,
-		  enum rkisp_params_type type)
+		  enum rkisp_params_type type, u32 id)
 {
 	u32 i, value;
 
-	value = isp3_param_read(params_vdev, ISP3X_DRC_CTRL0);
+	value = isp3_param_read(params_vdev, ISP3X_DRC_CTRL0, id);
 	value &= ISP39_MODULE_EN;
 	value |= !!arg->raw_dly_dis << 29 | !!arg->gainx32_en << 3 |
 		 !!arg->cmps_byp_en << 2 | !!arg->bypass_en << 1;
-	isp3_param_write(params_vdev, value, ISP3X_DRC_CTRL0);
+	isp3_param_write(params_vdev, value, ISP3X_DRC_CTRL0, id);
 
 	if (type == RKISP_PARAMS_IMD)
 		return;
@@ -2097,90 +2161,90 @@ isp_hdrdrc_config(struct rkisp_isp_params_vdev *params_vdev,
 	value = (arg->offset_pow2 & 0x0F) << 28 |
 		(arg->compres_scl & 0x1FFF) << 14 |
 		(arg->position & 0x03FFF);
-	isp3_param_write(params_vdev, value, ISP3X_DRC_CTRL1);
+	isp3_param_write(params_vdev, value, ISP3X_DRC_CTRL1, id);
 
 	value = arg->delta_scalein << 24 |
 		(arg->hpdetail_ratio & 0xFFF) << 12 |
 		(arg->lpdetail_ratio & 0xFFF);
-	isp3_param_write(params_vdev, value, ISP3X_DRC_LPRATIO);
+	isp3_param_write(params_vdev, value, ISP3X_DRC_LPRATIO, id);
 
 	value = arg->weicur_pix << 24 | !!arg->thumb_thd_enable |
 		(arg->thumb_thd_neg & 0x1ff) << 8 | arg->bilat_wt_off;
-	isp3_param_write(params_vdev, value, ISP39_DRC_BILAT0);
+	isp3_param_write(params_vdev, value, ISP39_DRC_BILAT0, id);
 
 	value = (arg->drc_gas_t & 0x3ff) << 16 | !!arg->cmps_fixbit_mode |
 		(arg->cmps_offset_bits_int & 0xf);
-	isp3_param_write(params_vdev, value, ISP39_DRC_BILAT1);
+	isp3_param_write(params_vdev, value, ISP39_DRC_BILAT1, id);
 
 	value = arg->thumb_scale << 16 | (arg->thumb_clip & 0xfff);
-	isp3_param_write(params_vdev, value, ISP39_DRC_BILAT2);
+	isp3_param_write(params_vdev, value, ISP39_DRC_BILAT2, id);
 
 	value = (arg->range_sgm_inv1 & 0x3ff) << 16 | (arg->range_sgm_inv0 & 0x3ff);
-	isp3_param_write(params_vdev, value, ISP39_DRC_BILAT3);
+	isp3_param_write(params_vdev, value, ISP39_DRC_BILAT3, id);
 
 	value = !!arg->enable_soft_thd << 31 | (arg->bilat_soft_thd & 0x7ff) << 16 |
 		arg->weight_8x8thumb << 8 | (arg->weig_bilat & 0x1f);
-	isp3_param_write(params_vdev, value, ISP39_DRC_BILAT4);
+	isp3_param_write(params_vdev, value, ISP39_DRC_BILAT4, id);
 
 	for (i = 0; i < ISP39_DRC_Y_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->gain_y[2 * i],
 					arg->gain_y[2 * i + 1]);
-		isp3_param_write(params_vdev, value, ISP3X_DRC_GAIN_Y0 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP3X_DRC_GAIN_Y0 + 4 * i, id);
 	}
 	value = ISP_PACK_2SHORT(arg->gain_y[2 * i], 0);
-	isp3_param_write(params_vdev, value, ISP3X_DRC_GAIN_Y0 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP3X_DRC_GAIN_Y0 + 4 * i, id);
 
 	for (i = 0; i < ISP39_DRC_Y_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->compres_y[2 * i],
 					arg->compres_y[2 * i + 1]);
-		isp3_param_write(params_vdev, value, ISP3X_DRC_COMPRES_Y0 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP3X_DRC_COMPRES_Y0 + 4 * i, id);
 	}
 	value = ISP_PACK_2SHORT(arg->compres_y[2 * i], 0);
-	isp3_param_write(params_vdev, value, ISP3X_DRC_COMPRES_Y0 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP3X_DRC_COMPRES_Y0 + 4 * i, id);
 
 	for (i = 0; i < ISP39_DRC_Y_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->scale_y[2 * i],
 					arg->scale_y[2 * i + 1]);
-		isp3_param_write(params_vdev, value, ISP3X_DRC_SCALE_Y0 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP3X_DRC_SCALE_Y0 + 4 * i, id);
 	}
 	value = ISP_PACK_2SHORT(arg->scale_y[2 * i], 0);
-	isp3_param_write(params_vdev, value, ISP3X_DRC_SCALE_Y0 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP3X_DRC_SCALE_Y0 + 4 * i, id);
 
 	value = ISP_PACK_2SHORT(arg->min_ogain, 0);
-	isp3_param_write(params_vdev, value, ISP3X_DRC_IIRWG_GAIN);
+	isp3_param_write(params_vdev, value, ISP3X_DRC_IIRWG_GAIN, id);
 
 	for (i = 0; i < ISP39_DRC_Y_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->sfthd_y[2 * i], arg->sfthd_y[2 * i + 1]);
-		isp3_param_write(params_vdev, value, ISP39_DRC_SFTHD_Y0 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP39_DRC_SFTHD_Y0 + 4 * i, id);
 	}
 	value = ISP_PACK_2SHORT(arg->sfthd_y[2 * i], 0);
-	isp3_param_write(params_vdev, value, ISP39_DRC_SFTHD_Y0 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP39_DRC_SFTHD_Y0 + 4 * i, id);
 }
 
 static void
-isp_hdrdrc_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_hdrdrc_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 value;
 	bool real_en;
 
-	value = isp3_param_read(params_vdev, ISP3X_DRC_CTRL0);
+	value = isp3_param_read(params_vdev, ISP3X_DRC_CTRL0, id);
 	real_en = !!(value & ISP39_MODULE_EN);
 	if ((en && real_en) || (!en && !real_en))
 		return;
 
 	if (en) {
 		value |= ISP39_MODULE_EN;
-		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1, ISP3X_ADRC_FST_FRAME);
+		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1, ISP3X_ADRC_FST_FRAME, id);
 	} else {
 		value &= ~(ISP39_MODULE_EN | ISP39_SELF_FORCE_UPD);
-		isp3_param_clear_bits(params_vdev, ISP3X_GAIN_CTRL, BIT(12));
+		isp3_param_clear_bits(params_vdev, ISP3X_GAIN_CTRL, BIT(12), id);
 	}
-	isp3_param_write(params_vdev, value, ISP3X_DRC_CTRL0);
+	isp3_param_write(params_vdev, value, ISP3X_DRC_CTRL0, id);
 }
 
 static void
 isp_gic_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp21_gic_cfg *arg)
+	       const struct isp21_gic_cfg *arg, u32 id)
 {
 	u32 value;
 	s32 i;
@@ -2188,12 +2252,12 @@ isp_gic_config(struct rkisp_isp_params_vdev *params_vdev,
 	value = (arg->regmingradthrdark2 & 0x03FF) << 20 |
 		(arg->regmingradthrdark1 & 0x03FF) << 10 |
 		(arg->regminbusythre & 0x03FF);
-	isp3_param_write(params_vdev, value, ISP3X_GIC_DIFF_PARA1);
+	isp3_param_write(params_vdev, value, ISP3X_GIC_DIFF_PARA1, id);
 
 	value = (arg->regdarkthre & 0x07FF) << 21 |
 		(arg->regmaxcorvboth & 0x03FF) << 11 |
 		(arg->regdarktthrehi & 0x07FF);
-	isp3_param_write(params_vdev, value, ISP3X_GIC_DIFF_PARA2);
+	isp3_param_write(params_vdev, value, ISP3X_GIC_DIFF_PARA2, id);
 
 	value = (arg->regkgrad2dark & 0x0F) << 28 |
 		(arg->regkgrad1dark & 0x0F) << 24 |
@@ -2202,45 +2266,45 @@ isp_gic_config(struct rkisp_isp_params_vdev *params_vdev,
 		(arg->regkgrad2 & 0x0F) << 8 |
 		(arg->regkgrad1 & 0x0F) << 4 |
 		(arg->reggbthre & 0x0F);
-	isp3_param_write(params_vdev, value, ISP3X_GIC_DIFF_PARA3);
+	isp3_param_write(params_vdev, value, ISP3X_GIC_DIFF_PARA3, id);
 
 	value = (arg->regmaxcorv & 0x03FF) << 20 |
 		(arg->regmingradthr2 & 0x03FF) << 10 |
 		(arg->regmingradthr1 & 0x03FF);
-	isp3_param_write(params_vdev, value, ISP3X_GIC_DIFF_PARA4);
+	isp3_param_write(params_vdev, value, ISP3X_GIC_DIFF_PARA4, id);
 
 	value = (arg->gr_ratio & 0x03) << 28 |
 		(arg->noise_scale & 0x7F) << 12 |
 		(arg->noise_base & 0xFFF);
-	isp3_param_write(params_vdev, value, ISP3X_GIC_NOISE_PARA1);
+	isp3_param_write(params_vdev, value, ISP3X_GIC_NOISE_PARA1, id);
 
 	value = arg->diff_clip & 0x7fff;
-	isp3_param_write(params_vdev, value, ISP3X_GIC_NOISE_PARA2);
+	isp3_param_write(params_vdev, value, ISP3X_GIC_NOISE_PARA2, id);
 
 	for (i = 0; i < ISP39_GIC_SIGMA_Y_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->sigma_y[2 * i], arg->sigma_y[2 * i + 1]);
-		isp3_param_write(params_vdev, value, ISP3X_GIC_SIGMA_VALUE0 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP3X_GIC_SIGMA_VALUE0 + 4 * i, id);
 	}
 	value = ISP_PACK_2SHORT(arg->sigma_y[2 * i], 0);
-	isp3_param_write(params_vdev, value, ISP3X_GIC_SIGMA_VALUE0 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP3X_GIC_SIGMA_VALUE0 + 4 * i, id);
 }
 
 static void
-isp_gic_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_gic_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 value = 0;
 
 	if (en)
 		value |= ISP39_MODULE_EN;
-	isp3_param_write(params_vdev, value, ISP3X_GIC_CONTROL);
+	isp3_param_write(params_vdev, value, ISP3X_GIC_CONTROL, id);
 }
 
 static void
 isp_dhaz_cfg_sram(struct rkisp_isp_params_vdev *params_vdev,
-		  const struct isp39_dhaz_cfg *arg, bool is_check)
+		  const struct isp39_dhaz_cfg *arg, bool is_check, u32 id)
 {
 	struct rkisp_isp_params_val_v39 *priv_val = params_vdev->priv_val;
-	u32 i, j, val, ctrl = isp3_param_read(params_vdev, ISP3X_DHAZ_CTRL);
+	u32 i, j, val, ctrl = isp3_param_read(params_vdev, ISP3X_DHAZ_CTRL, id);
 
 	if (is_check && (ctrl & ISP3X_DHAZ_ENMUX))
 		return;
@@ -2261,17 +2325,17 @@ isp_dhaz_cfg_sram(struct rkisp_isp_params_vdev *params_vdev,
 
 static void
 isp_dhaz_config(struct rkisp_isp_params_vdev *params_vdev,
-		const struct isp39_dhaz_cfg *arg)
+		const struct isp39_dhaz_cfg *arg, u32 id)
 {
 	struct rkisp_device *dev = params_vdev->dev;
 	struct v4l2_rect *out_crop = &dev->isp_sdev.out_crop;
-	struct isp39_isp_params_cfg *params_rec = params_vdev->isp39_params;
+	struct isp39_isp_params_cfg *params_rec = params_vdev->isp39_params + id;
 	struct isp39_dhaz_cfg *arg_rec = &params_rec->others.dhaz_cfg;
 	struct rkisp_isp_params_val_v39 *priv_val = params_vdev->priv_val;
 	u32 w = out_crop->width, h =  out_crop->height;
 	u32 i, value, ctrl, thumb_row, thumb_col, blk_het, blk_wid;
 
-	ctrl = isp3_param_read(params_vdev, ISP3X_DHAZ_CTRL);
+	ctrl = isp3_param_read(params_vdev, ISP3X_DHAZ_CTRL, id);
 	ctrl &= ISP3X_DHAZ_ENMUX;
 
 	ctrl |= !!arg->dc_en << 4 | !!arg->hist_en << 8 |
@@ -2280,113 +2344,113 @@ isp_dhaz_config(struct rkisp_isp_params_vdev *params_vdev,
 		!!arg->enhance_en << 20 | !!arg->soft_wr_en << 25 |
 		!!arg->round_en << 26 | !!arg->color_deviate_en << 27 |
 		!!arg->enh_luma_en << 28;
-	isp3_param_write(params_vdev, ctrl, ISP3X_DHAZ_CTRL);
+	isp3_param_write(params_vdev, ctrl, ISP3X_DHAZ_CTRL, id);
 
 	value = ISP_PACK_4BYTE(arg->dc_min_th, arg->dc_max_th,
 			       arg->yhist_th, arg->yblk_th);
-	isp3_param_write(params_vdev, value, ISP3X_DHAZ_ADP0);
+	isp3_param_write(params_vdev, value, ISP3X_DHAZ_ADP0, id);
 
 	value = (arg->wt_max & 0x1ff) << 16 | arg->bright_max << 8 |
 		arg->bright_min;
-	isp3_param_write(params_vdev, value, ISP3X_DHAZ_ADP1);
+	isp3_param_write(params_vdev, value, ISP3X_DHAZ_ADP1, id);
 
 	value = ISP_PACK_4BYTE(arg->air_min, arg->air_max,
 			       arg->dark_th, arg->tmax_base);
-	isp3_param_write(params_vdev, value, ISP3X_DHAZ_ADP2);
+	isp3_param_write(params_vdev, value, ISP3X_DHAZ_ADP2, id);
 
 	value = ISP_PACK_2SHORT(arg->tmax_off, arg->tmax_max);
-	isp3_param_write(params_vdev, value, ISP3X_DHAZ_ADP_TMAX);
+	isp3_param_write(params_vdev, value, ISP3X_DHAZ_ADP_TMAX, id);
 
 	value = ISP_PACK_2SHORT(arg->enhance_chroma, arg->enhance_value);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_ENHANCE);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_ENHANCE, id);
 
 	value = (arg->iir_wt_sigma & 0x07FF) << 16 | arg->iir_sigma << 8 |
 		(arg->stab_fnum & 0x1F);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_IIR0);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_IIR0, id);
 
 	value = (arg->iir_pre_wet & 0x0F) << 24 |
 		(arg->iir_tmax_sigma & 0x7FF) << 8 |
 		arg->iir_air_sigma;
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_IIR1);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_IIR1, id);
 
 	value = (arg->cfg_wt & 0x01FF) << 16 | arg->cfg_air << 8 |
 		arg->cfg_alpha;
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_SOFT_CFG0);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_SOFT_CFG0, id);
 
 	value = arg->cfg_tmax & 0x3ff;
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_SOFT_CFG1);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_SOFT_CFG1, id);
 
 	value = (arg->range_sima & 0x01FF) << 16 | arg->space_sigma_pre << 8 |
 		arg->space_sigma_cur;
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_BF_SIGMA);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_BF_SIGMA, id);
 
 	value = ISP_PACK_2SHORT(arg->bf_weight, arg->dc_weitcur);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_BF_WET);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_BF_WET, id);
 
 	for (i = 0; i < ISP39_DHAZ_ENH_CURVE_NUM / 3; i++) {
 		value = (arg->enh_curve[3 * i + 2] & 0x3ff) << 20 |
 			(arg->enh_curve[3 * i + 1] & 0x3ff) << 10 |
 			(arg->enh_curve[3 * i] & 0x3ff);
-		isp3_param_write(params_vdev, value, ISP39_DHAZ_ENH_CURVE0 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP39_DHAZ_ENH_CURVE0 + 4 * i, id);
 	}
 	value = (arg->enh_curve[3 * i + 1] & 0x3ff) << 10 | (arg->enh_curve[3 * i] & 0x3ff);
-	isp3_param_write(params_vdev, value, ISP3X_DHAZ_ENH_CURVE0 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP3X_DHAZ_ENH_CURVE0 + 4 * i, id);
 
 	value = (arg->gaus_h2 & 0x3f) << 16 | (arg->gaus_h1 & 0x3f) << 8 | (arg->gaus_h0 & 0x3f);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_GAUS);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_GAUS, id);
 
 	for (i = 0; i < ISP39_DHAZ_ENH_LUMA_NUM / 3; i++) {
 		value = (arg->enh_luma[3 * i + 2] & 0x3ff) << 20 |
 			(arg->enh_luma[3 * i + 1] & 0x3ff) << 10 |
 			(arg->enh_luma[3 * i] & 0x3ff);
-		isp3_param_write(params_vdev, value, ISP39_DHAZ_ENH_LUMA0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_DHAZ_ENH_LUMA0 + i * 4, id);
 	}
 	value = (arg->enh_luma[3 * i + 1] & 0x3ff) << 10 | (arg->enh_luma[3 * i] & 0x3ff);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_ENH_LUMA0 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_ENH_LUMA0 + 4 * i, id);
 
 	value = arg->adp_air_wr << 16 | (arg->adp_wt_wr & 0x1ff);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_ADP_WR0);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_ADP_WR0, id);
 	value = arg->adp_tmax_wr & 0x1fff;
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_ADP_WR1);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_ADP_WR1, id);
 
 	for (i = 0; i < ISP39_DHAZ_SIGMA_IDX_NUM / 4; i++) {
 		value = ISP_PACK_4BYTE(arg->sigma_idx[i * 4], arg->sigma_idx[i * 4 + 1],
 				       arg->sigma_idx[i * 4 + 2], arg->sigma_idx[i * 4 + 3]);
-		isp3_param_write(params_vdev, value, ISP39_DHAZ_GAIN_IDX0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_DHAZ_GAIN_IDX0 + i * 4, id);
 	}
 	value = ISP_PACK_4BYTE(arg->sigma_idx[i * 4], arg->sigma_idx[i * 4 + 1],
 			       arg->sigma_idx[i * 4 + 2], 0);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_GAIN_IDX0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_GAIN_IDX0 + i * 4, id);
 
 	for (i = 0; i < ISP39_DHAZ_SIGMA_LUT_NUM / 3; i++) {
 		value = (arg->sigma_lut[3 * i + 2] & 0x3ff) << 20 |
 			(arg->sigma_lut[3 * i + 1] & 0x3ff) << 10 |
 			(arg->sigma_lut[3 * i] & 0x3ff);
-		isp3_param_write(params_vdev, value, ISP39_DHAZ_GAIN_LUT0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_DHAZ_GAIN_LUT0 + i * 4, id);
 	}
 	value = (arg->sigma_lut[3 * i + 1] & 0x3ff) << 10 | (arg->sigma_lut[3 * i] & 0x3ff);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_GAIN_LUT0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_GAIN_LUT0 + i * 4, id);
 
 	value = arg->gain_fuse_alpha & 0x1ff;
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_GAIN_FUSE);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_GAIN_FUSE, id);
 
 	value = (arg->hist_min & 0x1ff) << 16 | arg->hist_th_off << 8 | (arg->hist_k & 0x1f);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_ADP_HF);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_ADP_HF, id);
 
 	value = (arg->cfg_k & 0x1ff) << 16 | (arg->cfg_k_alpha & 0x1ff);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_HIST_CFG);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_HIST_CFG, id);
 
 	value = arg->k_gain & 0x7ff;
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_HIST_GAIN);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_HIST_GAIN, id);
 
 	for (i = 0; i < ISP39_DHAZ_BLEND_WET_NUM / 3; i++) {
 		value = (arg->blend_wet[3 * i + 2] & 0x1ff) << 18 |
 			(arg->blend_wet[3 * i + 1] & 0x1ff) << 9 |
 			(arg->blend_wet[3 * i] & 0x1ff);
-		isp3_param_write(params_vdev, value, ISP39_DHAZ_BLEND_WET0 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP39_DHAZ_BLEND_WET0 + 4 * i, id);
 	}
 	value = (arg->blend_wet[3 * i + 1] & 0x1ff) << 9 | (arg->blend_wet[3 * i] & 0x1ff);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_BLEND_WET0 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_BLEND_WET0 + 4 * i, id);
 
 	thumb_row = arg->thumb_row > ISP39_DHAZ_THUMB_ROW_MAX ?
 				ISP39_DHAZ_THUMB_ROW_MAX : arg->thumb_row & ~1;
@@ -2396,24 +2460,24 @@ isp_dhaz_config(struct rkisp_isp_params_vdev *params_vdev,
 	blk_wid = ALIGN(w / thumb_col, 2);
 	priv_val->dhaz_blk_num = thumb_row * thumb_col;
 	value = ISP_PACK_2SHORT(blk_het, blk_wid);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_BLOCK_SIZE);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_BLOCK_SIZE, id);
 
 	value = ISP_PACK_4BYTE(thumb_row, thumb_col, 0, 0);
-	isp3_param_write(params_vdev, value, ISP39_DHAZ_THUMB_SIZE);
+	isp3_param_write(params_vdev, value, ISP39_DHAZ_THUMB_SIZE, id);
 
 	if (dev->hw_dev->is_single && arg->hist_iir_wr)
-		isp_dhaz_cfg_sram(params_vdev, arg, false);
+		isp_dhaz_cfg_sram(params_vdev, arg, false, id);
 	else if (arg->hist_iir_wr)
 		memcpy(arg_rec, arg, sizeof(struct isp39_dhaz_cfg));
 }
 
 static void
-isp_dhaz_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_dhaz_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 value;
 	bool real_en;
 
-	value = isp3_param_read(params_vdev, ISP3X_DHAZ_CTRL);
+	value = isp3_param_read(params_vdev, ISP3X_DHAZ_CTRL, id);
 	real_en = !!(value & ISP3X_DHAZ_ENMUX);
 	if ((en && real_en) || (!en && !real_en))
 		return;
@@ -2421,17 +2485,17 @@ isp_dhaz_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
 	if (en) {
 		value |= ISP39_SELF_FORCE_UPD | ISP3X_DHAZ_ENMUX;
 		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1,
-				    ISP3X_DHAZ_FST_FRAME);
+				    ISP3X_DHAZ_FST_FRAME, id);
 	} else {
 		value &= ~ISP3X_DHAZ_ENMUX;
-		isp3_param_clear_bits(params_vdev, ISP3X_GAIN_CTRL, BIT(16));
+		isp3_param_clear_bits(params_vdev, ISP3X_GAIN_CTRL, BIT(16), id);
 	}
-	isp3_param_write(params_vdev, value, ISP3X_DHAZ_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_DHAZ_CTRL, id);
 }
 
 static void
 isp_3dlut_config(struct rkisp_isp_params_vdev *params_vdev,
-		 const struct isp2x_3dlut_cfg *arg)
+		 const struct isp2x_3dlut_cfg *arg, u32 id)
 {
 	struct rkisp_device *dev = params_vdev->dev;
 	struct rkisp_isp_params_val_v39 *priv_val;
@@ -2439,58 +2503,58 @@ isp_3dlut_config(struct rkisp_isp_params_vdev *params_vdev,
 	u32 *data;
 
 	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
-	buf_idx = (priv_val->buf_3dlut_idx++) % ISP39_3DLUT_BUF_NUM;
+	buf_idx = (priv_val->buf_3dlut_idx[id]++) % ISP39_3DLUT_BUF_NUM;
 
-	if (!priv_val->buf_3dlut[buf_idx].vaddr) {
+	if (!priv_val->buf_3dlut[id][buf_idx].vaddr) {
 		dev_err(dev->dev, "no find 3dlut buf\n");
 		return;
 	}
-	data = (u32 *)priv_val->buf_3dlut[buf_idx].vaddr;
+	data = (u32 *)priv_val->buf_3dlut[id][buf_idx].vaddr;
 	for (i = 0; i < arg->actual_size; i++)
 		data[i] = (arg->lut_b[i] & 0x3FF) |
 			  (arg->lut_g[i] & 0xFFF) << 10 |
 			  (arg->lut_r[i] & 0x3FF) << 22;
-	rkisp_prepare_buffer(params_vdev->dev, &priv_val->buf_3dlut[buf_idx]);
-	value = priv_val->buf_3dlut[buf_idx].dma_addr;
-	isp3_param_write(params_vdev, value, ISP3X_MI_LUT_3D_RD_BASE);
-	isp3_param_write(params_vdev, arg->actual_size, ISP3X_MI_LUT_3D_RD_WSIZE);
+	rkisp_prepare_buffer(params_vdev->dev, &priv_val->buf_3dlut[id][buf_idx]);
+	value = priv_val->buf_3dlut[id][buf_idx].dma_addr;
+	isp3_param_write(params_vdev, value, ISP3X_MI_LUT_3D_RD_BASE, id);
+	isp3_param_write(params_vdev, arg->actual_size, ISP3X_MI_LUT_3D_RD_WSIZE, id);
 
-	value = isp3_param_read(params_vdev, ISP3X_3DLUT_CTRL);
+	value = isp3_param_read(params_vdev, ISP3X_3DLUT_CTRL, id);
 	value &= ISP3X_3DLUT_EN;
 
 	if (value)
-		isp3_param_set_bits(params_vdev, ISP3X_3DLUT_UPDATE, 0x01);
+		isp3_param_set_bits(params_vdev, ISP3X_3DLUT_UPDATE, 0x01, id);
 
-	isp3_param_write(params_vdev, value, ISP3X_3DLUT_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_3DLUT_CTRL, id);
 }
 
 static void
-isp_3dlut_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_3dlut_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 value;
 	bool en_state;
 	struct rkisp_isp_params_val_v39 *priv_val;
 
-	value = isp3_param_read(params_vdev, ISP3X_3DLUT_CTRL);
+	value = isp3_param_read(params_vdev, ISP3X_3DLUT_CTRL, id);
 	en_state = (value & ISP3X_3DLUT_EN) ? true : false;
 
 	if (en == en_state)
 		return;
 
 	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
-	if (en && priv_val->buf_3dlut[0].vaddr) {
-		isp3_param_set_bits(params_vdev, ISP3X_3DLUT_CTRL, 0x01);
-		isp3_param_set_bits(params_vdev, ISP3X_3DLUT_UPDATE, 0x01);
+	if (en && priv_val->buf_3dlut[id][0].vaddr) {
+		isp3_param_set_bits(params_vdev, ISP3X_3DLUT_CTRL, 0x01, id);
+		isp3_param_set_bits(params_vdev, ISP3X_3DLUT_UPDATE, 0x01, id);
 	} else {
-		isp3_param_clear_bits(params_vdev, ISP3X_3DLUT_CTRL, 0x01);
-		isp3_param_clear_bits(params_vdev, ISP3X_3DLUT_UPDATE, 0x01);
-		isp3_param_clear_bits(params_vdev, ISP3X_GAIN_CTRL, BIT(20));
+		isp3_param_clear_bits(params_vdev, ISP3X_3DLUT_CTRL, 0x01, id);
+		isp3_param_clear_bits(params_vdev, ISP3X_3DLUT_UPDATE, 0x01, id);
+		isp3_param_clear_bits(params_vdev, ISP3X_GAIN_CTRL, BIT(20), id);
 	}
 }
 
 static void
 isp_ldch_config(struct rkisp_isp_params_vdev *params_vdev,
-		const struct isp39_ldch_cfg *arg)
+		const struct isp39_ldch_cfg *arg, u32 id)
 {
 	struct rkisp_device *dev = params_vdev->dev;
 	struct rkisp_isp_params_val_v39 *priv_val;
@@ -2501,26 +2565,26 @@ isp_ldch_config(struct rkisp_isp_params_vdev *params_vdev,
 	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
 	priv_val->ldch_out_hsize = arg->out_hsize;
 
-	value = isp3_param_read(params_vdev, ISP3X_LDCH_STS);
+	value = isp3_param_read(params_vdev, ISP3X_LDCH_STS, id);
 	value &= ISP39_MODULE_EN;
 	value |= !!arg->map13p3_en << 7 |
 		 !!arg->force_map_en << 6 |
 		 !!arg->bic_mode_en << 4 |
 		 !!arg->sample_avr_en << 3 |
 		 !!arg->frm_end_dis << 1;
-	isp3_param_write(params_vdev, value, ISP3X_LDCH_STS);
+	isp3_param_write(params_vdev, value, ISP3X_LDCH_STS, id);
 	if (arg->bic_mode_en) {
 		for (i = 0; i < ISP39_LDCH_BIC_NUM / 4; i++) {
 			value = ISP_PACK_4BYTE(arg->bicubic[i * 4], arg->bicubic[i * 4 + 1],
 					       arg->bicubic[i * 4 + 2], arg->bicubic[i * 4 + 3]);
-			isp3_param_write(params_vdev, value, ISP32_LDCH_BIC_TABLE0 + i * 4);
+			isp3_param_write(params_vdev, value, ISP32_LDCH_BIC_TABLE0 + i * 4, id);
 		}
 	}
 
 	for (i = 0; i < ISP39_MESH_BUF_NUM; i++) {
-		if (!priv_val->buf_ldch[i].mem_priv)
+		if (!priv_val->buf_ldch[id][i].mem_priv)
 			continue;
-		if (arg->buf_fd == priv_val->buf_ldch[i].dma_fd)
+		if (arg->buf_fd == priv_val->buf_ldch[id][i].dma_fd)
 			break;
 	}
 	if (i == ISP39_MESH_BUF_NUM) {
@@ -2528,28 +2592,28 @@ isp_ldch_config(struct rkisp_isp_params_vdev *params_vdev,
 		return;
 	}
 
-	if (!priv_val->buf_ldch[i].vaddr) {
+	if (!priv_val->buf_ldch[id][i].vaddr) {
 		dev_err(dev->dev, "no ldch buffer allocated\n");
 		return;
 	}
 
-	buf_idx = priv_val->buf_ldch_idx;
-	head = (struct isp2x_mesh_head *)priv_val->buf_ldch[buf_idx].vaddr;
+	buf_idx = priv_val->buf_ldch_idx[id];
+	head = (struct isp2x_mesh_head *)priv_val->buf_ldch[id][buf_idx].vaddr;
 	head->stat = MESH_BUF_INIT;
 
 	buf_idx = i;
-	head = (struct isp2x_mesh_head *)priv_val->buf_ldch[buf_idx].vaddr;
+	head = (struct isp2x_mesh_head *)priv_val->buf_ldch[id][buf_idx].vaddr;
 	head->stat = MESH_BUF_CHIPINUSE;
-	priv_val->buf_ldch_idx = buf_idx;
-	rkisp_prepare_buffer(dev, &priv_val->buf_ldch[buf_idx]);
-	value = priv_val->buf_ldch[buf_idx].dma_addr + head->data_oft;
-	isp3_param_write(params_vdev, value, ISP3X_MI_LUT_LDCH_RD_BASE);
-	isp3_param_write(params_vdev, arg->hsize, ISP3X_MI_LUT_LDCH_RD_H_WSIZE);
-	isp3_param_write(params_vdev, arg->vsize, ISP3X_MI_LUT_LDCH_RD_V_SIZE);
+	priv_val->buf_ldch_idx[id] = buf_idx;
+	rkisp_prepare_buffer(dev, &priv_val->buf_ldch[id][buf_idx]);
+	value = priv_val->buf_ldch[id][buf_idx].dma_addr + head->data_oft;
+	isp3_param_write(params_vdev, value, ISP3X_MI_LUT_LDCH_RD_BASE, id);
+	isp3_param_write(params_vdev, arg->hsize, ISP3X_MI_LUT_LDCH_RD_H_WSIZE, id);
+	isp3_param_write(params_vdev, arg->vsize, ISP3X_MI_LUT_LDCH_RD_V_SIZE, id);
 }
 
 static void
-isp_ldch_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_ldch_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	struct rkisp_device *dev = params_vdev->dev;
 	struct rkisp_isp_params_val_v39 *priv_val;
@@ -2557,25 +2621,25 @@ isp_ldch_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
 
 	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
 	if (en) {
-		buf_idx = priv_val->buf_ldch_idx;
-		if (!priv_val->buf_ldch[buf_idx].vaddr) {
+		buf_idx = priv_val->buf_ldch_idx[id];
+		if (!priv_val->buf_ldch[id][buf_idx].vaddr) {
 			dev_err(dev->dev, "no ldch buffer allocated\n");
-			isp3_param_clear_bits(params_vdev, ISP3X_LDCH_STS, 0x01);
+			isp3_param_clear_bits(params_vdev, ISP3X_LDCH_STS, 0x01, id);
 			return;
 		}
-		isp3_param_set_bits(params_vdev, ISP3X_LDCH_STS, 0x01);
+		isp3_param_set_bits(params_vdev, ISP3X_LDCH_STS, 0x01, id);
 	} else {
-		isp3_param_clear_bits(params_vdev, ISP3X_LDCH_STS, 0x01);
+		isp3_param_clear_bits(params_vdev, ISP3X_LDCH_STS, 0x01, id);
 	}
 }
 
 static void
 isp_ynr_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp39_ynr_cfg *arg)
+	       const struct isp39_ynr_cfg *arg, u32 id)
 {
 	u32 i, value;
 
-	value = isp3_param_read(params_vdev, ISP3X_YNR_GLOBAL_CTRL);
+	value = isp3_param_read(params_vdev, ISP3X_YNR_GLOBAL_CTRL, id);
 	value &= ISP39_MODULE_EN;
 
 	value |= !!arg->rnr_en << 26 |
@@ -2584,123 +2648,123 @@ isp_ynr_config(struct rkisp_isp_params_vdev *params_vdev,
 		 !!arg->exgain_bypass << 3 |
 		 !!arg->hispnr_bypass << 2 |
 		 !!arg->lospnr_bypass << 1;
-	isp3_param_write(params_vdev, value, ISP3X_YNR_GLOBAL_CTRL);
+	isp3_param_write(params_vdev, value, ISP3X_YNR_GLOBAL_CTRL, id);
 
 	value = ISP_PACK_2SHORT(arg->rnr_max_radius, arg->local_gain_scale);
-	isp3_param_write(params_vdev, value, ISP3X_YNR_RNR_MAX_R);
+	isp3_param_write(params_vdev, value, ISP3X_YNR_RNR_MAX_R, id);
 
 	value = ISP_PACK_2SHORT(arg->rnr_center_coorh, arg->rnr_center_coorv);
-	isp3_param_write(params_vdev, value, ISP3X_YNR_RNR_CENTER_COOR);
+	isp3_param_write(params_vdev, value, ISP3X_YNR_RNR_CENTER_COOR, id);
 
 	value = (arg->ds_filt_wgt_thred_scale & 0x1ff) << 16 |
 		(arg->ds_img_edge_scale & 0x1f) << 10 |
 		(arg->ds_filt_soft_thred_scale & 0x1ff);
-	isp3_param_write(params_vdev, value, ISP3X_YNR_LOWNR_CTRL0);
+	isp3_param_write(params_vdev, value, ISP3X_YNR_LOWNR_CTRL0, id);
 
 	value = (arg->ds_filt_center_wgt & 0x7ff) << 16 |
 		(arg->ds_iir_init_wgt_scale & 0x3f) << 8 |
 		(arg->ds_filt_local_gain_alpha & 0x1f);
-	isp3_param_write(params_vdev, value, ISP3X_YNR_LOWNR_CTRL1);
+	isp3_param_write(params_vdev, value, ISP3X_YNR_LOWNR_CTRL1, id);
 
 	value = ISP_PACK_2SHORT(arg->ds_filt_inv_strg, arg->lospnr_wgt);
-	isp3_param_write(params_vdev, value, ISP3X_YNR_LOWNR_CTRL2);
+	isp3_param_write(params_vdev, value, ISP3X_YNR_LOWNR_CTRL2, id);
 
 	value = ISP_PACK_2SHORT(arg->lospnr_center_wgt, arg->lospnr_strg);
-	isp3_param_write(params_vdev, value, ISP3X_YNR_LOWNR_CTRL3);
+	isp3_param_write(params_vdev, value, ISP3X_YNR_LOWNR_CTRL3, id);
 
 	value = ISP_PACK_2SHORT(arg->lospnr_dist_vstrg_scale, arg->lospnr_dist_hstrg_scale);
-	isp3_param_write(params_vdev, value, ISP3X_YNR_LOWNR_CTRL4);
+	isp3_param_write(params_vdev, value, ISP3X_YNR_LOWNR_CTRL4, id);
 
 	value = arg->pre_filt_coeff2 << 16 |
 		arg->pre_filt_coeff1 << 8 |
 		arg->pre_filt_coeff0;
-	isp3_param_write(params_vdev, value, ISP39_YNR_GAUSS_COEFF);
+	isp3_param_write(params_vdev, value, ISP39_YNR_GAUSS_COEFF, id);
 
 	for (i = 0; i < ISP39_YNR_LOW_GAIN_ADJ_NUM / 4; i++) {
 		value = ISP_PACK_4BYTE(arg->lospnr_gain2strg_val[i * 4],
 				       arg->lospnr_gain2strg_val[i * 4 + 1],
 				       arg->lospnr_gain2strg_val[i * 4 + 2],
 				       arg->lospnr_gain2strg_val[i * 4 + 3]);
-		isp3_param_write(params_vdev, value, ISP39_YNR_LOW_GAIN_ADJ_0_3 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_YNR_LOW_GAIN_ADJ_0_3 + i * 4, id);
 	}
 	value = arg->lospnr_gain2strg_val[i * 4];
-	isp3_param_write(params_vdev, value, ISP39_YNR_LOW_GAIN_ADJ_0_3 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_YNR_LOW_GAIN_ADJ_0_3 + i * 4, id);
 
 	for (i = 0; i < ISP39_YNR_XY_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->luma2sima_idx[2 * i],
 					arg->luma2sima_idx[2 * i + 1]);
-		isp3_param_write(params_vdev, value, ISP39_YNR_SGM_DX_0_1 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP39_YNR_SGM_DX_0_1 + 4 * i, id);
 	}
 	value = arg->luma2sima_idx[2 * i];
-	isp3_param_write(params_vdev, value, ISP39_YNR_SGM_DX_0_1 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP39_YNR_SGM_DX_0_1 + 4 * i, id);
 
 	for (i = 0; i < ISP39_YNR_XY_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->luma2sima_val[2 * i],
 					arg->luma2sima_val[2 * i + 1]);
-		isp3_param_write(params_vdev, value, ISP39_YNR_LSGM_Y_0_1 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP39_YNR_LSGM_Y_0_1 + 4 * i, id);
 	}
 	value = arg->luma2sima_val[2 * i];
-	isp3_param_write(params_vdev, value, ISP39_YNR_LSGM_Y_0_1 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP39_YNR_LSGM_Y_0_1 + 4 * i, id);
 
 	for (i = 0; i < ISP39_YNR_XY_NUM / 4; i++) {
 		value = ISP_PACK_4BYTE(arg->radius2strg_val[4 * i],
 				       arg->radius2strg_val[4 * i + 1],
 				       arg->radius2strg_val[4 * i + 2],
 				       arg->radius2strg_val[4 * i + 3]);
-		isp3_param_write(params_vdev, value, ISP39_YNR_RNR_STRENGTH03 + 4 * i);
+		isp3_param_write(params_vdev, value, ISP39_YNR_RNR_STRENGTH03 + 4 * i, id);
 	}
 	value = arg->radius2strg_val[4 * i];
-	isp3_param_write(params_vdev, value, ISP39_YNR_RNR_STRENGTH03 + 4 * i);
+	isp3_param_write(params_vdev, value, ISP39_YNR_RNR_STRENGTH03 + 4 * i, id);
 
 	value = arg->hispnr_strong_edge;
-	isp3_param_write(params_vdev, value, ISP39_YNR_NLM_STRONG_EDGE);
+	isp3_param_write(params_vdev, value, ISP39_YNR_NLM_STRONG_EDGE, id);
 
 	value = (arg->hispnr_strg & 0x3ff) << 16 |
 		(arg->hispnr_local_gain_alpha & 0x1f) << 11 |
 		(arg->hispnr_sigma_min_limit & 0x7ff);
-	isp3_param_write(params_vdev, value, ISP39_YNR_NLM_SIGMA_GAIN);
+	isp3_param_write(params_vdev, value, ISP39_YNR_NLM_SIGMA_GAIN, id);
 
 	value = (arg->hispnr_filt_coeff[5] & 0xf) << 20 | (arg->hispnr_filt_coeff[4] & 0xf) << 16 |
 		(arg->hispnr_filt_coeff[3] & 0xf) << 12 | (arg->hispnr_filt_coeff[2] & 0xf) << 8 |
 		(arg->hispnr_filt_coeff[1] & 0xf) << 4 | (arg->hispnr_filt_coeff[0] & 0xf);
-	isp3_param_write(params_vdev, value, ISP39_YNR_NLM_COE);
+	isp3_param_write(params_vdev, value, ISP39_YNR_NLM_COE, id);
 
 	value = (arg->hispnr_filt_center_wgt & 0x3ffff) << 10 | (arg->hispnr_filt_wgt_offset & 0x3ff);
-	isp3_param_write(params_vdev, value, ISP39_YNR_NLM_WEIGHT);
+	isp3_param_write(params_vdev, value, ISP39_YNR_NLM_WEIGHT, id);
 
 	value = (arg->hispnr_gain_thred & 0x3ff) << 16 | (arg->hispnr_filt_wgt & 0x7ff);
-	isp3_param_write(params_vdev, value, ISP39_YNR_NLM_NR_WEIGHT);
+	isp3_param_write(params_vdev, value, ISP39_YNR_NLM_NR_WEIGHT, id);
 }
 
 static void
-isp_ynr_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_ynr_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 ynr_ctrl;
 	bool real_en;
 
-	ynr_ctrl = isp3_param_read_cache(params_vdev, ISP3X_YNR_GLOBAL_CTRL);
+	ynr_ctrl = isp3_param_read_cache(params_vdev, ISP3X_YNR_GLOBAL_CTRL, id);
 	real_en = !!(ynr_ctrl & ISP39_MODULE_EN);
 	if ((en && real_en) || (!en && !real_en))
 		return;
 
 	if (en) {
 		ynr_ctrl |= ISP39_MODULE_EN;
-		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1, ISP3X_YNR_FST_FRAME);
+		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1, ISP3X_YNR_FST_FRAME, id);
 	} else {
 		ynr_ctrl &= ~ISP39_MODULE_EN;
 	}
 
-	isp3_param_write(params_vdev, ynr_ctrl, ISP3X_YNR_GLOBAL_CTRL);
+	isp3_param_write(params_vdev, ynr_ctrl, ISP3X_YNR_GLOBAL_CTRL, id);
 }
 
 static void
 isp_cnr_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp39_cnr_cfg *arg)
+	       const struct isp39_cnr_cfg *arg, u32 id)
 {
 	u32 i, value, ctrl, gain_ctrl;
 
-	gain_ctrl = isp3_param_read(params_vdev, ISP3X_GAIN_CTRL);
-	ctrl = isp3_param_read(params_vdev, ISP3X_CNR_CTRL);
+	gain_ctrl = isp3_param_read(params_vdev, ISP3X_GAIN_CTRL, id);
+	ctrl = isp3_param_read(params_vdev, ISP3X_CNR_CTRL, id);
 	ctrl &= ISP39_MODULE_EN;
 
 	ctrl |= (arg->loflt_coeff & 0x3f) << 12 |
@@ -2717,91 +2781,91 @@ isp_cnr_config(struct rkisp_isp_params_vdev *params_vdev,
 		value &= ~ISP3X_CNR_GLOBAL_GAIN_ALPHA_MAX;
 		value |= BIT(15);
 	}
-	isp3_param_write(params_vdev, ctrl, ISP3X_CNR_CTRL);
-	isp3_param_write(params_vdev, value, ISP3X_CNR_EXGAIN);
+	isp3_param_write(params_vdev, ctrl, ISP3X_CNR_CTRL, id);
+	isp3_param_write(params_vdev, value, ISP3X_CNR_EXGAIN, id);
 
 	value = ISP_PACK_2SHORT(arg->lobfflt_vsigma_uv, arg->lobfflt_vsigma_y);
-	isp3_param_write(params_vdev, value, ISP32_CNR_THUMB1);
+	isp3_param_write(params_vdev, value, ISP32_CNR_THUMB1, id);
 
 	value = arg->lobfflt_alpha & 0x7ff;
-	isp3_param_write(params_vdev, value, ISP32_CNR_THUMB_BF_RATIO);
+	isp3_param_write(params_vdev, value, ISP32_CNR_THUMB_BF_RATIO, id);
 
 	value = ISP_PACK_4BYTE(arg->thumb_bf_coeff0, arg->thumb_bf_coeff1,
 			       arg->thumb_bf_coeff2, arg->thumb_bf_coeff3);
-	isp3_param_write(params_vdev, value, ISP32_CNR_LBF_WEITD);
+	isp3_param_write(params_vdev, value, ISP32_CNR_LBF_WEITD, id);
 
 	value = (arg->loflt_wgt_slope & 0x3ff) << 20 |
 		(arg->exp_x_shift_bit & 0x3f) << 12 |
 		arg->loflt_vsigma << 4 | (arg->loflt_uv_gain & 0xf);
-	isp3_param_write(params_vdev, value, ISP32_CNR_IIR_PARA1);
+	isp3_param_write(params_vdev, value, ISP32_CNR_IIR_PARA1, id);
 
 	value = (arg->loflt_wgt_max_limit & 0x7f) << 8 |
 		(arg->loflt_wgt_min_thred & 0x3f);
-	isp3_param_write(params_vdev, value, ISP32_CNR_IIR_PARA2);
+	isp3_param_write(params_vdev, value, ISP32_CNR_IIR_PARA2, id);
 
 	value = ISP_PACK_4BYTE(arg->gaus_flt_coeff[0], arg->gaus_flt_coeff[1],
 			       arg->gaus_flt_coeff[2], arg->gaus_flt_coeff[3]);
-	isp3_param_write(params_vdev, value, ISP32_CNR_GAUS_COE1);
+	isp3_param_write(params_vdev, value, ISP32_CNR_GAUS_COE1, id);
 
 	value = ISP_PACK_4BYTE(arg->gaus_flt_coeff[4], arg->gaus_flt_coeff[5], 0, 0);
-	isp3_param_write(params_vdev, value, ISP32_CNR_GAUS_COE2);
+	isp3_param_write(params_vdev, value, ISP32_CNR_GAUS_COE2, id);
 
 	value = (arg->hiflt_alpha & 0x7ff) << 20 |
 		arg->hiflt_wgt_min_limit << 12 |
 		(arg->gaus_flt_alpha & 0x7ff);
-	isp3_param_write(params_vdev, value, ISP32_CNR_GAUS_RATIO);
+	isp3_param_write(params_vdev, value, ISP32_CNR_GAUS_RATIO, id);
 
 	value = arg->hiflt_cur_wgt << 24 |
 		(arg->hiflt_global_vsigma & 0x3fff) << 8 |
 		(arg->hiflt_uv_gain & 0x7f);
-	isp3_param_write(params_vdev, value, ISP32_CNR_BF_PARA1);
+	isp3_param_write(params_vdev, value, ISP32_CNR_BF_PARA1, id);
 
 	value = (arg->adj_scale & 0x7fff) << 16 | (arg->adj_offset & 0x1ff);
-	isp3_param_write(params_vdev, value, ISP32_CNR_BF_PARA2);
+	isp3_param_write(params_vdev, value, ISP32_CNR_BF_PARA2, id);
 
 	for (i = 0; i < ISP39_CNR_SIGMA_Y_NUM / 4; i++) {
 		value = ISP_PACK_4BYTE(arg->sgm_ratio[i * 4], arg->sgm_ratio[i * 4 + 1],
 				       arg->sgm_ratio[i * 4 + 2], arg->sgm_ratio[i * 4 + 3]);
-		isp3_param_write(params_vdev, value, ISP32_CNR_SIGMA0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP32_CNR_SIGMA0 + i * 4, id);
 	}
 	value = arg->sgm_ratio[i * 4];
-	isp3_param_write(params_vdev, value, ISP32_CNR_SIGMA0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP32_CNR_SIGMA0 + i * 4, id);
 
 	value = (arg->loflt_global_sgm_ratio_alpha & 0xf) << 8 |
 		arg->loflt_global_sgm_ratio;
-	isp3_param_write(params_vdev, value, ISP32_CNR_IIR_GLOBAL_GAIN);
+	isp3_param_write(params_vdev, value, ISP32_CNR_IIR_GLOBAL_GAIN, id);
 
 	for (i = 0; i < ISP39_CNR_WGT_SIGMA_Y_NUM / 4; i++) {
 		value = ISP_PACK_4BYTE(arg->cur_wgt[i * 4], arg->cur_wgt[i * 4 + 1],
 				       arg->cur_wgt[i * 4 + 2], arg->cur_wgt[i * 4 + 3]);
-		isp3_param_write(params_vdev, value, ISP39_CNR_WGT_SIGMA0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_CNR_WGT_SIGMA0 + i * 4, id);
 	}
 	value = arg->cur_wgt[i * 4];
-	isp3_param_write(params_vdev, value, ISP39_CNR_WGT_SIGMA0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_CNR_WGT_SIGMA0 + i * 4, id);
 
 	for (i = 0; i < ISP39_CNR_GAUS_SIGMAR_NUM / 3; i++) {
 		value = (arg->hiflt_vsigma_idx[i * 3 + 2] & 0x3ff) << 20 |
 			(arg->hiflt_vsigma_idx[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->hiflt_vsigma_idx[i * 3] & 0x3ff);
-		isp3_param_write(params_vdev, value, ISP39_CNR_GAUS_X_SIGMAR0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_CNR_GAUS_X_SIGMAR0 + i * 4, id);
 	}
 	value = (arg->hiflt_vsigma_idx[i * 3 + 1] & 0x3ff) << 20 |
 		(arg->hiflt_vsigma_idx[i * 3] & 0x3ff);
-	isp3_param_write(params_vdev, value, ISP39_CNR_GAUS_X_SIGMAR0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_CNR_GAUS_X_SIGMAR0 + i * 4, id);
 
 	for (i = 0; i < ISP39_CNR_GAUS_SIGMAR_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->hiflt_vsigma[i * 2], arg->hiflt_vsigma[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP39_CNR_GAUS_Y_SIGMAR0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_CNR_GAUS_Y_SIGMAR0 + i * 4, id);
 	}
 }
 
 static void
-isp_cnr_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_cnr_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 cnr_ctrl;
 	bool real_en;
 
-	cnr_ctrl = isp3_param_read_cache(params_vdev, ISP3X_CNR_CTRL);
+	cnr_ctrl = isp3_param_read_cache(params_vdev, ISP3X_CNR_CTRL, id);
 	real_en = !!(cnr_ctrl & ISP39_MODULE_EN);
 	if ((en && real_en) || (!en && !real_en))
 		return;
@@ -2809,21 +2873,21 @@ isp_cnr_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
 	if (en) {
 		cnr_ctrl |= ISP39_MODULE_EN;
 		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1,
-				    ISP3X_CNR_FST_FRAME);
+				    ISP3X_CNR_FST_FRAME, id);
 	} else {
 		cnr_ctrl &= ~ISP39_MODULE_EN;
 	}
 
-	isp3_param_write(params_vdev, cnr_ctrl, ISP3X_CNR_CTRL);
+	isp3_param_write(params_vdev, cnr_ctrl, ISP3X_CNR_CTRL, id);
 }
 
 static void
 isp_sharp_config(struct rkisp_isp_params_vdev *params_vdev,
-		 const struct isp39_sharp_cfg *arg)
+		 const struct isp39_sharp_cfg *arg, u32 id)
 {
 	u32 i, value;
 
-	value = isp3_param_read(params_vdev, ISP3X_SHARP_EN);
+	value = isp3_param_read(params_vdev, ISP3X_SHARP_EN, id);
 	value &= ISP39_MODULE_EN;
 
 	value |= !!arg->bypass << 1 |
@@ -2835,11 +2899,11 @@ isp_sharp_config(struct rkisp_isp_params_vdev *params_vdev,
 		 !!arg->baselmg_sel << 7 |
 		 !!arg->noise_filt_sel << 8 |
 		 !!arg->tex2wgt_en << 9;
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_EN);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_EN, id);
 
 	value = ISP_PACK_4BYTE(arg->pre_bifilt_alpha, arg->guide_filt_alpha,
 			       arg->detail_bifilt_alpha, arg->global_sharp_strg);
-	isp3_param_write(params_vdev, value, ISP39_SHARP_ALPHA);
+	isp3_param_write(params_vdev, value, ISP39_SHARP_ALPHA, id);
 
 	value = (arg->luma2table_idx[6] & 0x0F) << 24 |
 		(arg->luma2table_idx[5] & 0x0F) << 20 |
@@ -2848,158 +2912,158 @@ isp_sharp_config(struct rkisp_isp_params_vdev *params_vdev,
 		(arg->luma2table_idx[2] & 0x0F) << 8 |
 		(arg->luma2table_idx[1] & 0x0F) << 4 |
 		(arg->luma2table_idx[0] & 0x0F);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_LUMA_DX);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_LUMA_DX, id);
 
 	value = (arg->pbf_sigma_inv[2] & 0x3FF) << 20 |
 		(arg->pbf_sigma_inv[1] & 0x3FF) << 10 |
 		(arg->pbf_sigma_inv[0] & 0x3FF);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_PBF_SIGMA_INV_0);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_PBF_SIGMA_INV_0, id);
 
 	value = (arg->pbf_sigma_inv[5] & 0x3FF) << 20 |
 		(arg->pbf_sigma_inv[4] & 0x3FF) << 10 |
 		(arg->pbf_sigma_inv[3] & 0x3FF);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_PBF_SIGMA_INV_1);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_PBF_SIGMA_INV_1, id);
 
 	value = (arg->pbf_sigma_inv[7] & 0x3FF) << 10 |
 		(arg->pbf_sigma_inv[6] & 0x3FF);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_PBF_SIGMA_INV_2);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_PBF_SIGMA_INV_2, id);
 
 	value = (arg->bf_sigma_inv[2] & 0x3FF) << 20 |
 		(arg->bf_sigma_inv[1] & 0x3FF) << 10 |
 		(arg->bf_sigma_inv[0] & 0x3FF);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_BF_SIGMA_INV_0);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_BF_SIGMA_INV_0, id);
 
 	value = (arg->bf_sigma_inv[5] & 0x3FF) << 20 |
 		(arg->bf_sigma_inv[4] & 0x3FF) << 10 |
 		(arg->bf_sigma_inv[3] & 0x3FF);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_BF_SIGMA_INV_1);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_BF_SIGMA_INV_1, id);
 
 	value = (arg->bf_sigma_inv[7] & 0x3FF) << 10 |
 		(arg->bf_sigma_inv[6] & 0x3FF);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_BF_SIGMA_INV_2);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_BF_SIGMA_INV_2, id);
 
 	value = (arg->bf_sigma_shift & 0x0F) << 4 |
 		(arg->pbf_sigma_shift & 0x0F);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_SIGMA_SHIFT);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_SIGMA_SHIFT, id);
 
 	for (i = 0; i < ISP39_SHARP_Y_NUM / 3; i++) {
 		value = (arg->luma2strg_val[i * 3] & 0x3ff) |
 			(arg->luma2strg_val[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->luma2strg_val[i * 3 + 2] & 0x3ff) << 20;
-		isp3_param_write(params_vdev, value, ISP39_SHARP_LOCAL_STRG_0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_SHARP_LOCAL_STRG_0 + i * 4, id);
 	}
 	value = (arg->luma2strg_val[i * 3] & 0x3ff) |
 		(arg->luma2strg_val[i * 3 + 1] & 0x3ff) << 10;
-	isp3_param_write(params_vdev, value, ISP39_SHARP_LOCAL_STRG_2);
+	isp3_param_write(params_vdev, value, ISP39_SHARP_LOCAL_STRG_2, id);
 
 	for (i = 0; i < ISP39_SHARP_Y_NUM / 3; i++) {
 		value = (arg->luma2posclip_val[i * 3] & 0x3ff) |
 			(arg->luma2posclip_val[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->luma2posclip_val[i * 3 + 2] & 0x3ff) << 20;
-		isp3_param_write(params_vdev, value, ISP39_SHARP_POS_CLIP_0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_SHARP_POS_CLIP_0 + i * 4, id);
 	}
 	value = (arg->luma2posclip_val[i * 3] & 0x3ff) |
 		(arg->luma2posclip_val[i * 3 + 1] & 0x3ff) << 10;
-	isp3_param_write(params_vdev, value, ISP39_SHARP_POS_CLIP_2);
+	isp3_param_write(params_vdev, value, ISP39_SHARP_POS_CLIP_2, id);
 
 	value = ISP_PACK_4BYTE(arg->pbf_coef0, arg->pbf_coef1, arg->pbf_coef2, 0);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_PBF_COEF);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_PBF_COEF, id);
 
 	value = ISP_PACK_4BYTE(arg->bf_coef0, arg->bf_coef1, arg->bf_coef2, 0);
-	isp3_param_write(params_vdev, value, ISP39_SHARP_DETAILBF_COEF);
+	isp3_param_write(params_vdev, value, ISP39_SHARP_DETAILBF_COEF, id);
 
 	value = ISP_PACK_4BYTE(arg->img_lpf_coeff[0], arg->img_lpf_coeff[1], arg->img_lpf_coeff[2], 0);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_IMGLPF_COEF_0);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_IMGLPF_COEF_0, id);
 
 	value = ISP_PACK_4BYTE(arg->img_lpf_coeff[3], arg->img_lpf_coeff[4], arg->img_lpf_coeff[5], 0);
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_IMGLPF_COEF_1);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_IMGLPF_COEF_1, id);
 
 	value = arg->local_gain_scale << 24 | (arg->gain_merge_alpha & 0xf) << 16 |
 		(arg->global_gain & 0x3ff);
-	isp3_param_write(params_vdev, value, ISP32_SHARP_GAIN);
+	isp3_param_write(params_vdev, value, ISP32_SHARP_GAIN, id);
 
 	for (i = 0; i < ISP39_SHARP_GAIN_ADJ_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->gain2strg_val[i * 2], arg->gain2strg_val[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP32_SHARP_GAIN_ADJUST0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP32_SHARP_GAIN_ADJUST0 + i * 4, id);
 	}
 
 	value = ISP_PACK_2SHORT(arg->center_x, arg->center_y);
-	isp3_param_write(params_vdev, value, ISP32_SHARP_CENTER);
+	isp3_param_write(params_vdev, value, ISP32_SHARP_CENTER, id);
 
 	for (i = 0; i < ISP39_SHARP_STRENGTH_NUM / 4; i++) {
 		value = ISP_PACK_4BYTE(arg->distance2strg_val[i * 4], arg->distance2strg_val[i * 4 + 1],
 				       arg->distance2strg_val[i * 4 + 2], arg->distance2strg_val[i * 4 + 3]);
-		isp3_param_write(params_vdev, value, ISP32_SHARP_GAIN_DIS_STRENGTH0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP32_SHARP_GAIN_DIS_STRENGTH0 + i * 4, id);
 	}
 	value = ISP_PACK_4BYTE(arg->distance2strg_val[i * 4], arg->distance2strg_val[i * 4 + 1], 0, 0);
-	isp3_param_write(params_vdev, value, ISP32_SHARP_GAIN_DIS_STRENGTH0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP32_SHARP_GAIN_DIS_STRENGTH0 + i * 4, id);
 
 	for (i = 0; i < ISP39_SHARP_Y_NUM / 3; i++) {
 		value = (arg->luma2neg_clip_val[i * 3 + 2] & 0x3ff) << 20 |
 			(arg->luma2neg_clip_val[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->luma2neg_clip_val[i * 3] & 0x3ff);
-		isp3_param_write(params_vdev, value, ISP39_SHARP_CLIP_NEG_0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_SHARP_CLIP_NEG_0 + i * 4, id);
 	}
 	value = (arg->luma2neg_clip_val[i * 3 + 1] & 0x3ff) << 10 | (arg->luma2neg_clip_val[i * 3] & 0x3ff);
-	isp3_param_write(params_vdev, value, ISP39_SHARP_CLIP_NEG_0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_SHARP_CLIP_NEG_0 + i * 4, id);
 
 	value = (arg->tex_reserve_level & 0xf) << 12 | (arg->noise_max_limit & 0x3ff);
-	isp3_param_write(params_vdev, value, ISP39_SHARP_TEXTURE0);
+	isp3_param_write(params_vdev, value, ISP39_SHARP_TEXTURE0, id);
 
 	value = (arg->tex_wgt_mode & 0x3) << 20 |
 		(arg->noise_norm_bit & 0xf) << 16 |
 		(arg->tex_wet_scale & 0x7fff);
-	isp3_param_write(params_vdev, value, ISP39_SHARP_TEXTURE1);
+	isp3_param_write(params_vdev, value, ISP39_SHARP_TEXTURE1, id);
 
 	for (i = 0; i < ISP39_SHARP_TEX_WET_LUT_NUM / 3; i++) {
 		value = (arg->tex2wgt_val[i * 3 + 2] & 0x3ff) << 20 |
 			(arg->tex2wgt_val[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->tex2wgt_val[i * 3] & 0x3ff);
-		isp3_param_write(params_vdev, value, ISP39_SHARP_TEXTURE_LUT0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_SHARP_TEXTURE_LUT0 + i * 4, id);
 	}
 	value = (arg->tex2wgt_val[i * 3 + 1] & 0x3ff) << 10 | (arg->tex2wgt_val[i * 3] & 0x3ff);
-	isp3_param_write(params_vdev, value, ISP39_SHARP_TEXTURE_LUT0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_SHARP_TEXTURE_LUT0 + i * 4, id);
 
 	value = arg->noise_strg;
-	isp3_param_write(params_vdev, value, ISP39_SHARP_TEXTURE2);
+	isp3_param_write(params_vdev, value, ISP39_SHARP_TEXTURE2, id);
 
 	for (i = 0; i < ISP39_SHARP_DETAIL_STRG_NUM / 2; i++) {
 		value = (arg->detail2strg_val[i * 2] & 0x7ff) |
 			(arg->detail2strg_val[i * 2 + 1] & 0x7ff) << 16;
-		isp3_param_write(params_vdev, value, ISP39_SHARP_DETAIL_STRG_LUT0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_SHARP_DETAIL_STRG_LUT0 + i * 4, id);
 	}
 	value = arg->detail2strg_val[i * 2] & 0x7ff;
-	isp3_param_write(params_vdev, value, ISP39_SHARP_DETAIL_STRG_LUT8);
+	isp3_param_write(params_vdev, value, ISP39_SHARP_DETAIL_STRG_LUT8, id);
 }
 
 static void
-isp_sharp_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_sharp_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 value;
 
-	value = isp3_param_read_cache(params_vdev, ISP3X_SHARP_EN);
+	value = isp3_param_read_cache(params_vdev, ISP3X_SHARP_EN, id);
 	if ((en && (value & ISP39_MODULE_EN)) || (!en && !(value & ISP39_MODULE_EN)))
 		return;
 
 	value &= ~ISP39_MODULE_EN;
 	if (en) {
-		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1, ISP32_SHP_FST_FRAME);
+		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1, ISP32_SHP_FST_FRAME, id);
 		value |= ISP39_MODULE_EN;
 	}
-	isp3_param_write(params_vdev, value, ISP3X_SHARP_EN);
+	isp3_param_write(params_vdev, value, ISP3X_SHARP_EN, id);
 }
 
 static void
 isp_bay3d_config(struct rkisp_isp_params_vdev *params_vdev,
-		 const struct isp39_bay3d_cfg *arg)
+		 const struct isp39_bay3d_cfg *arg, u32 id)
 {
 	u32 i, value, ctrl;
 
-	ctrl = isp3_param_read(params_vdev, ISP3X_BAY3D_CTRL);
+	ctrl = isp3_param_read(params_vdev, ISP3X_BAY3D_CTRL, id);
 	ctrl &= ISP39_MODULE_EN;
 
 	ctrl |= !!arg->bypass_en << 1 | !!arg->iirsparse_en << 2;
-	isp3_param_write(params_vdev, ctrl, ISP3X_BAY3D_CTRL);
+	isp3_param_write(params_vdev, ctrl, ISP3X_BAY3D_CTRL, id);
 
 	value = !!arg->noisebal_mode << 23 |
 		!!arg->curdbg_out_en << 22 |
@@ -3023,7 +3087,7 @@ isp_bay3d_config(struct rkisp_isp_params_vdev *params_vdev,
 		!!arg->cur_spnr_bypass_en << 2 |
 		!!arg->sigma_curve_double_en << 1 |
 		!!arg->transf_bypass_en;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_CTRL1);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_CTRL1, id);
 
 	value = (arg->sigma_calc_mge_wgt_hdr_sht_thred & 0x3f) << 24 |
 		(arg->mge_wgt_hdr_sht_thred & 0x3f) << 16 |
@@ -3031,205 +3095,205 @@ isp_bay3d_config(struct rkisp_isp_params_vdev *params_vdev,
 		!!arg->mge_wgt_ds_mode << 2 |
 		!!arg->wgt_cal_mode << 1 |
 		!!arg->transf_mode;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_CTRL2);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_CTRL2, id);
 
 	value = (arg->transf_mode_offset & 0x1fff) |
 		!!arg->transf_mode_scale << 15 |
 		arg->itransf_mode_offset << 16;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TRANS0);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TRANS0, id);
 
 	value = arg->transf_data_max_limit & 0xfffff;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TRANS1);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TRANS1, id);
 
 	value = ISP_PACK_2SHORT(arg->cur_spnr_sigma_hdr_sht_scale,
 				arg->cur_spnr_sigma_scale);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_CURDGAIN);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_CURDGAIN, id);
 
 	for (i = 0; i < ISP39_BAY3D_XY_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->cur_spnr_luma_sigma_x[i * 2],
 					arg->cur_spnr_luma_sigma_x[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_CURSIG_X0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_CURSIG_X0 + i * 4, id);
 
 		value = ISP_PACK_2SHORT(arg->cur_spnr_luma_sigma_y[i * 2],
 					arg->cur_spnr_luma_sigma_y[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_CURSIG_Y0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_CURSIG_Y0 + i * 4, id);
 	}
 
 	value = ISP_PACK_2SHORT(arg->cur_spnr_sigma_rgain_offset,
 				arg->cur_spnr_sigma_bgain_offset);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_CURGAIN_OFF);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_CURGAIN_OFF, id);
 
 	value = ISP_PACK_2SHORT(arg->cur_spnr_sigma_hdr_sht_offset,
 				arg->cur_spnr_sigma_offset);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_CURSIG_OFF);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_CURSIG_OFF, id);
 
 	value = ISP_PACK_2SHORT(arg->cur_spnr_pix_diff_max_limit,
 				arg->cur_spnr_wgt_cal_offset);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_CURWTH);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_CURWTH, id);
 
 	value = ISP_PACK_2SHORT(arg->cur_spnr_wgt, arg->pre_spnr_wgt);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_CURBFALP);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_CURBFALP, id);
 
 	for (i = 0; i < ISP39_BAY3D_WD_NUM / 3; i++) {
 		value = (arg->cur_spnr_space_rb_wgt[i * 3] & 0x3ff) |
 			(arg->cur_spnr_space_rb_wgt[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->cur_spnr_space_rb_wgt[i * 3 + 2] & 0x3ff) << 20;
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_CURWDC0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_CURWDC0 + i * 4, id);
 
 		value = (arg->cur_spnr_space_gg_wgt[i * 3] & 0x3ff) |
 			(arg->cur_spnr_space_gg_wgt[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->cur_spnr_space_gg_wgt[i * 3 + 2] & 0x3ff) << 20;
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_CURWDY0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_CURWDY0 + i * 4, id);
 	}
 
 	value = ISP_PACK_2SHORT(arg->pre_spnr_sigma_hdr_sht_scale, arg->pre_spnr_sigma_scale);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRDGAIN);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRDGAIN, id);
 
 	for (i = 0; i < ISP39_BAY3D_XY_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->pre_spnr_luma_sigma_x[i * 2],
 					arg->pre_spnr_luma_sigma_x[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRSIG_X0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRSIG_X0 + i * 4, id);
 
 		value = ISP_PACK_2SHORT(arg->cur_spnr_luma_sigma_y[i * 2],
 					arg->cur_spnr_luma_sigma_y[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRSIG_Y0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRSIG_Y0 + i * 4, id);
 	}
 
 	value = ISP_PACK_2SHORT(arg->pre_spnr_sigma_rgain_offset,
 				arg->pre_spnr_sigma_bgain_offset);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRGAIN_OFF);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRGAIN_OFF, id);
 
 	value = ISP_PACK_2SHORT(arg->pre_spnr_sigma_hdr_sht_offset,
 				arg->pre_spnr_sigma_offset);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRSIG_OFF);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRSIG_OFF, id);
 
 	value = ISP_PACK_2SHORT(arg->pre_spnr_pix_diff_max_limit,
 				arg->pre_spnr_wgt_cal_offset);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRWTH);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRWTH, id);
 
 	for (i = 0; i < ISP39_BAY3D_WD_NUM / 3; i++) {
 		value = (arg->pre_spnr_space_rb_wgt[i * 3] & 0x3ff) |
 			(arg->pre_spnr_space_rb_wgt[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->pre_spnr_space_rb_wgt[i * 3 + 2] & 0x3ff) << 20;
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRWDC0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRWDC0 + i * 4, id);
 
 		value = (arg->pre_spnr_space_gg_wgt[i * 3] & 0x3ff) |
 			(arg->pre_spnr_space_gg_wgt[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->pre_spnr_space_gg_wgt[i * 3 + 2] & 0x3ff) << 20;
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRWDY0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_IIRWDY0 + i * 4, id);
 	}
 
 	value = ISP_PACK_2SHORT(arg->cur_spnr_wgt_cal_scale,
 				arg->pre_spnr_wgt_cal_scale);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_BFCOEF);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_BFCOEF, id);
 
 	for (i = 0; i < ISP39_BAY3D_TNRSIG_NUM / 2; i++) {
 		value = ISP_PACK_2SHORT(arg->tnr_luma_sigma_x[i * 2],
 					arg->tnr_luma_sigma_x[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRSIG_X0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRSIG_X0 + i * 4, id);
 
 		value = ISP_PACK_2SHORT(arg->tnr_luma_sigma_y[i * 2],
 					arg->tnr_luma_sigma_y[i * 2 + 1]);
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRSIG_Y0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRSIG_Y0 + i * 4, id);
 	}
 
 	for (i = 0; i < ISP39_BAY3D_COEFF_NUM / 3; i++) {
 		value = (arg->tnr_lpf_hi_coeff[i * 3] & 0x3ff) |
 			(arg->tnr_lpf_hi_coeff[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->tnr_lpf_hi_coeff[i * 3 + 2] & 0x3ff) << 20;
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRHIW0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRHIW0 + i * 4, id);
 
 		value = (arg->tnr_lpf_lo_coeff[i * 3] & 0x3ff) |
 			(arg->tnr_lpf_lo_coeff[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->tnr_lpf_lo_coeff[i * 3 + 2] & 0x3ff) << 20;
-		isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRLOW0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRLOW0 + i * 4, id);
 	}
 
 	value = (arg->tnr_wgt_filt_coeff0 & 0x3ff) |
 		(arg->tnr_wgt_filt_coeff1 & 0x3ff) << 10 |
 		(arg->tnr_wgt_filt_coeff2 & 0x3ff) << 20;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRGF3);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRGF3, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_sigma_scale, arg->tnr_sigma_hdr_sht_scale);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRSIGSCL);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRSIGSCL, id);
 
 	value = (arg->tnr_sig_vfilt_wgt & 0xf) |
 		(arg->tnr_lo_diff_vfilt_wgt & 0xf) << 4 |
 		(arg->tnr_lo_wgt_vfilt_wgt & 0xf) << 8 |
 		(arg->tnr_sig_first_line_scale & 0x1f) << 16 |
 		(arg->tnr_lo_diff_first_line_scale & 0x1f) << 24;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRVIIR);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRVIIR, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_lo_wgt_cal_offset, arg->tnr_lo_wgt_cal_scale);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRLFSCL);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRLFSCL, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_low_wgt_cal_max_limit, arg->tnr_mode0_base_ratio);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRLFSCLTH);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRLFSCLTH, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_lo_diff_wgt_cal_offset, arg->tnr_lo_diff_wgt_cal_scale);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRDSWGTSCL);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRDSWGTSCL, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_lo_mge_pre_wgt_offset, arg->tnr_lo_mge_pre_wgt_scale);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWLSTSCL);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWLSTSCL, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_mode0_lo_wgt_scale, arg->tnr_mode0_lo_wgt_hdr_sht_scale);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWGT0SCL0);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWGT0SCL0, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_mode1_lo_wgt_scale, arg->tnr_mode1_lo_wgt_hdr_sht_scale);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWGT1SCL1);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWGT1SCL1, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_mode1_wgt_scale, arg->tnr_mode1_wgt_hdr_sht_scale);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWGT1SCL2);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWGT1SCL2, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_mode1_lo_wgt_offset, arg->tnr_mode1_lo_wgt_hdr_sht_offset);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWGTOFF);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWGTOFF, id);
 
 	value = (arg->tnr_auto_sigma_count_wgt_thred & 0x3ff) |
 		(arg->tnr_mode1_wgt_min_limit & 0x3ff) << 10 |
 		(arg->tnr_mode1_wgt_offset & 0xfff) << 20;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWGT1OFF);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWGT1OFF, id);
 
 	value = arg->tnr_out_sigma_sq;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRSIGORG);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRSIGORG, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_lo_wgt_clip_min_limit, arg->tnr_lo_wgt_clip_hdr_sht_min_limit);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWLO_THL);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWLO_THL, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_lo_wgt_clip_max_limit, arg->tnr_lo_wgt_clip_hdr_sht_max_limit);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWLO_THH);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWLO_THH, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_hi_wgt_clip_min_limit, arg->tnr_hi_wgt_clip_hdr_sht_min_limit);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWHI_THL);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWHI_THL, id);
 
 	value = ISP_PACK_2SHORT(arg->tnr_hi_wgt_clip_max_limit, arg->tnr_hi_wgt_clip_hdr_sht_max_limit);
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWHI_THH);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRWHI_THH, id);
 
 	value = arg->tnr_cur_spnr_hi_wgt_min_limit | arg->tnr_pre_spnr_hi_wgt_min_limit << 16;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRKEEP);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRKEEP, id);
 
 	value = (arg->tnr_pix_max & 0xfff) | (arg->lowgt_ctrl & 0x3) << 16 |
 			(arg->lowgt_offint & 0x3ff) << 18;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_PIXMAX);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_PIXMAX, id);
 
 	value = arg->tnr_auto_sigma_count_th;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_SIGNUMTH);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_SIGNUMTH, id);
 
 	value = (arg->tnr_motion_nr_strg & 0x7ff) | arg->tnr_gain_max << 16;
-	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRMO_STR);
+	isp3_param_write(params_vdev, value, ISP39_BAY3D_TNRMO_STR, id);
 
 	if (params_vdev->dev->hw_dev->is_single && ctrl & ISP39_MODULE_EN)
-		isp3_param_write(params_vdev, ctrl | ISP39_SELF_FORCE_UPD, ISP3X_BAY3D_CTRL);
+		isp3_param_write(params_vdev, ctrl | ISP39_SELF_FORCE_UPD, ISP3X_BAY3D_CTRL, id);
 }
 
 static void
-isp_bay3d_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_bay3d_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	struct rkisp_device *ispdev = params_vdev->dev;
 	struct rkisp_isp_params_val_v39 *priv_val;
 	u32 value, bay3d_ctrl;
 
 	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
-	bay3d_ctrl = isp3_param_read_cache(params_vdev, ISP3X_BAY3D_CTRL);
+	bay3d_ctrl = isp3_param_read_cache(params_vdev, ISP3X_BAY3D_CTRL, id);
 	if ((en && (bay3d_ctrl & ISP39_MODULE_EN)) ||
 	    (!en && !(bay3d_ctrl & ISP39_MODULE_EN)))
 		return;
@@ -3240,66 +3304,66 @@ isp_bay3d_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
 			return;
 		}
 
-		value = priv_val->buf_3dnr_iir.size;
-		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_IIR_WR_SIZE);
-		value = priv_val->buf_3dnr_iir.dma_addr;
-		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_IIR_WR_BASE);
-		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_IIR_RD_BASE);
-		isp3_param_write(params_vdev, value, ISP39_AIISP_RD_BASE);
+		value = priv_val->bay3d_iir_size;
+		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_IIR_WR_SIZE, id);
+		value = priv_val->buf_3dnr_iir.dma_addr + value * id;
+		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_IIR_WR_BASE, id);
+		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_IIR_RD_BASE, id);
+		isp3_param_write(params_vdev, value, ISP39_AIISP_RD_BASE, id);
 		if (priv_val->buf_gain.mem_priv) {
-			value = priv_val->buf_gain.size;
-			isp3_param_write(params_vdev, value, ISP3X_MI_GAIN_WR_SIZE);
-			isp3_param_write(params_vdev, value, ISP32_MI_RAW0_RD_SIZE);
-			value = priv_val->buf_gain.dma_addr;
-			isp3_param_write(params_vdev, value, ISP3X_MI_GAIN_WR_BASE);
-			isp3_param_write(params_vdev, value, ISP3X_MI_RAW0_RD_BASE);
+			value = priv_val->gain_size;
+			isp3_param_write(params_vdev, value, ISP3X_MI_GAIN_WR_SIZE, id);
+			isp3_param_write(params_vdev, value, ISP32_MI_RAW0_RD_SIZE, id);
+			value = priv_val->buf_gain.dma_addr + value * id;
+			isp3_param_write(params_vdev, value, ISP3X_MI_GAIN_WR_BASE, id);
+			isp3_param_write(params_vdev, value, ISP3X_MI_RAW0_RD_BASE, id);
 
-			value = isp3_param_read_cache(params_vdev, ISP3X_GAIN_CTRL);
+			value = isp3_param_read_cache(params_vdev, ISP3X_GAIN_CTRL, id);
 			value |= ISP3X_GAIN_2DDR_MODE(1) | ISP3X_GAIN_2DDR_EN;
-			isp3_param_write(params_vdev, value, ISP3X_GAIN_CTRL);
+			isp3_param_write(params_vdev, value, ISP3X_GAIN_CTRL, id);
 		}
 
 		bay3d_ctrl |= ISP39_MODULE_EN;
-		isp3_param_write(params_vdev, bay3d_ctrl, ISP3X_BAY3D_CTRL);
+		isp3_param_write(params_vdev, bay3d_ctrl, ISP3X_BAY3D_CTRL, id);
 
 		value = ISP3X_BAY3D_IIR_WR_AUTO_UPD | ISP3X_BAY3D_IIRSELF_UPD |
 			ISP3X_BAY3D_RDSELF_UPD | ISP3X_GAIN_WR_AUTO_UPD | ISP3X_GAINSELF_UPD;
-		isp3_param_set_bits(params_vdev, MI_WR_CTRL2, value);
+		isp3_param_set_bits(params_vdev, MI_WR_CTRL2, value, id);
 
-		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1, ISP3X_RAW3D_FST_FRAME);
+		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1, ISP3X_RAW3D_FST_FRAME, id);
 	} else {
 		bay3d_ctrl &= ~ISP39_MODULE_EN;
-		isp3_param_write(params_vdev, bay3d_ctrl, ISP3X_BAY3D_CTRL);
-		isp3_param_clear_bits(params_vdev, ISP3X_GAIN_CTRL, BIT(4));
+		isp3_param_write(params_vdev, bay3d_ctrl, ISP3X_BAY3D_CTRL, id);
+		isp3_param_clear_bits(params_vdev, ISP3X_GAIN_CTRL, BIT(4), id);
 	}
 }
 
 static void
 isp_gain_config(struct rkisp_isp_params_vdev *params_vdev,
-		const struct isp3x_gain_cfg *arg)
+		const struct isp3x_gain_cfg *arg, u32 id)
 {
 	u32 val = arg->g0 & 0x3ffff;
 
-	isp3_param_write(params_vdev, val, ISP3X_GAIN_G0);
+	isp3_param_write(params_vdev, val, ISP3X_GAIN_G0, id);
 	val = ISP_PACK_2SHORT(arg->g1, arg->g2);
-	isp3_param_write(params_vdev, val, ISP3X_GAIN_G1_G2);
+	isp3_param_write(params_vdev, val, ISP3X_GAIN_G1_G2, id);
 }
 
 static void
-isp_gain_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_gain_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
-	u32 val = isp3_param_read_cache(params_vdev, ISP3X_GAIN_CTRL);
+	u32 val = isp3_param_read_cache(params_vdev, ISP3X_GAIN_CTRL, id);
 
 	if (en)
 		val |= ISP39_MODULE_EN;
 	else
 		val &= ~ISP39_MODULE_EN;
-	isp3_param_write(params_vdev, val, ISP3X_GAIN_CTRL);
+	isp3_param_write(params_vdev, val, ISP3X_GAIN_CTRL, id);
 }
 
 static void
 isp_cac_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp32_cac_cfg *arg)
+	       const struct isp32_cac_cfg *arg, u32 id)
 {
 	struct rkisp_device *dev = params_vdev->dev;
 	struct rkisp_isp_params_val_v39 *priv_val;
@@ -3308,45 +3372,45 @@ isp_cac_config(struct rkisp_isp_params_vdev *params_vdev,
 
 	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
 
-	ctrl = isp3_param_read(params_vdev, ISP3X_CAC_CTRL);
+	ctrl = isp3_param_read(params_vdev, ISP3X_CAC_CTRL, id);
 	ctrl &= ISP3X_CAC_EN;
 	ctrl |= !!arg->bypass_en << 1 | !!arg->center_en << 3 |
 		(arg->clip_g_mode & 0x3) << 5 | !!arg->edge_detect_en << 7 |
 		!!arg->neg_clip0_en << 9;
 
 	val = (arg->psf_sft_bit & 0xff) | (arg->cfg_num & 0x7ff) << 8;
-	isp3_param_write(params_vdev, val, ISP3X_CAC_PSF_PARA);
+	isp3_param_write(params_vdev, val, ISP3X_CAC_PSF_PARA, id);
 
 	val = ISP_PACK_2SHORT(arg->center_width, arg->center_height);
-	isp3_param_write(params_vdev, val, ISP3X_CAC_STRENGTH_CENTER);
+	isp3_param_write(params_vdev, val, ISP3X_CAC_STRENGTH_CENTER, id);
 
 	for (i = 0; i < ISP39_CAC_STRENGTH_NUM / 2; i++) {
 		val = ISP_PACK_2SHORT(arg->strength[2 * i], arg->strength[2 * i + 1]);
-		isp3_param_write(params_vdev, val, ISP3X_CAC_STRENGTH0 + i * 4);
+		isp3_param_write(params_vdev, val, ISP3X_CAC_STRENGTH0 + i * 4, id);
 	}
 
 	val = (arg->flat_thed_r & 0x1f) << 8 | (arg->flat_thed_b & 0x1f);
-	isp3_param_write(params_vdev, val, ISP32_CAC_FLAT_THED);
+	isp3_param_write(params_vdev, val, ISP32_CAC_FLAT_THED, id);
 
 	val = ISP_PACK_2SHORT(arg->offset_b, arg->offset_r);
-	isp3_param_write(params_vdev, val, ISP32_CAC_OFFSET);
+	isp3_param_write(params_vdev, val, ISP32_CAC_OFFSET, id);
 
 	val = arg->expo_thed_b & 0x1fffff;
-	isp3_param_write(params_vdev, val, ISP32_CAC_EXPO_THED_B);
+	isp3_param_write(params_vdev, val, ISP32_CAC_EXPO_THED_B, id);
 
 	val = arg->expo_thed_r & 0x1fffff;
-	isp3_param_write(params_vdev, val, ISP32_CAC_EXPO_THED_R);
+	isp3_param_write(params_vdev, val, ISP32_CAC_EXPO_THED_R, id);
 
 	val = arg->expo_adj_b & 0xfffff;
-	isp3_param_write(params_vdev, val, ISP32_CAC_EXPO_ADJ_B);
+	isp3_param_write(params_vdev, val, ISP32_CAC_EXPO_ADJ_B, id);
 
 	val = arg->expo_adj_r & 0xfffff;
-	isp3_param_write(params_vdev, val, ISP32_CAC_EXPO_ADJ_R);
+	isp3_param_write(params_vdev, val, ISP32_CAC_EXPO_ADJ_R, id);
 
 	for (i = 0; i < ISP39_MESH_BUF_NUM; i++) {
-		if (!priv_val->buf_cac[i].mem_priv)
+		if (!priv_val->buf_cac[id][i].mem_priv)
 			continue;
-		if (arg->buf_fd == priv_val->buf_cac[i].dma_fd)
+		if (arg->buf_fd == priv_val->buf_cac[id][i].dma_fd)
 			break;
 	}
 
@@ -3355,44 +3419,44 @@ isp_cac_config(struct rkisp_isp_params_vdev *params_vdev,
 		return;
 	}
 
-	if (!priv_val->buf_cac[i].vaddr) {
+	if (!priv_val->buf_cac[id][i].vaddr) {
 		dev_err(dev->dev, "no cac buffer allocated\n");
 		return;
 	}
 
-	val = priv_val->buf_cac_idx;
-	head = (struct isp2x_mesh_head *)priv_val->buf_cac[val].vaddr;
+	val = priv_val->buf_cac_idx[id];
+	head = (struct isp2x_mesh_head *)priv_val->buf_cac[id][val].vaddr;
 	head->stat = MESH_BUF_INIT;
 
-	head = (struct isp2x_mesh_head *)priv_val->buf_cac[i].vaddr;
+	head = (struct isp2x_mesh_head *)priv_val->buf_cac[id][i].vaddr;
 	head->stat = MESH_BUF_CHIPINUSE;
-	priv_val->buf_cac_idx = i;
-	rkisp_prepare_buffer(dev, &priv_val->buf_cac[i]);
-	val = priv_val->buf_cac[i].dma_addr + head->data_oft;
-	isp3_param_write(params_vdev, val, ISP3X_MI_LUT_CAC_RD_BASE);
-	isp3_param_write(params_vdev, arg->hsize, ISP3X_MI_LUT_CAC_RD_H_WSIZE);
-	isp3_param_write(params_vdev, arg->vsize, ISP3X_MI_LUT_CAC_RD_V_SIZE);
+	priv_val->buf_cac_idx[id] = i;
+	rkisp_prepare_buffer(dev, &priv_val->buf_cac[id][i]);
+	val = priv_val->buf_cac[id][i].dma_addr + head->data_oft;
+	isp3_param_write(params_vdev, val, ISP3X_MI_LUT_CAC_RD_BASE, id);
+	isp3_param_write(params_vdev, arg->hsize, ISP3X_MI_LUT_CAC_RD_H_WSIZE, id);
+	isp3_param_write(params_vdev, arg->vsize, ISP3X_MI_LUT_CAC_RD_V_SIZE, id);
 	if (ctrl & ISP3X_CAC_EN)
 		ctrl |= ISP3X_CAC_LUT_EN | ISP39_SELF_FORCE_UPD | ISP3X_CAC_LUT_MODE(3);
-	isp3_param_write(params_vdev, ctrl, ISP3X_CAC_CTRL);
+	isp3_param_write(params_vdev, ctrl, ISP3X_CAC_CTRL, id);
 }
 
 static void
-isp_cac_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_cac_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 val;
 
-	val = isp3_param_read(params_vdev, ISP3X_CAC_CTRL);
+	val = isp3_param_read(params_vdev, ISP3X_CAC_CTRL, id);
 	val &= ~(ISP3X_CAC_EN | ISP3X_CAC_LUT_EN | ISP39_SELF_FORCE_UPD);
 	if (en)
 		val |= ISP3X_CAC_EN | ISP3X_CAC_LUT_EN |
 		       ISP39_SELF_FORCE_UPD | ISP3X_CAC_LUT_MODE(3);
-	isp3_param_write(params_vdev, val, ISP3X_CAC_CTRL);
+	isp3_param_write(params_vdev, val, ISP3X_CAC_CTRL, id);
 }
 
 static void
 isp_csm_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp21_csm_cfg *arg)
+	       const struct isp21_csm_cfg *arg, u32 id)
 {
 	u32 i, val;
 
@@ -3403,19 +3467,19 @@ isp_csm_config(struct rkisp_isp_params_vdev *params_vdev,
 			      (arg->csm_coeff[i] & 0x1ff);
 		else
 			val = arg->csm_coeff[i] & 0x1ff;
-		isp3_param_write(params_vdev, val, ISP3X_ISP_CC_COEFF_0 + i * 4);
+		isp3_param_write(params_vdev, val, ISP3X_ISP_CC_COEFF_0 + i * 4, id);
 	}
 
-	val = isp3_param_read_cache(params_vdev, ISP3X_ISP_CTRL0);
+	val = isp3_param_read_cache(params_vdev, ISP3X_ISP_CTRL0, id);
 	val |= CIF_ISP_CTRL_ISP_CSM_Y_FULL_ENA | CIF_ISP_CTRL_ISP_CSM_C_FULL_ENA;
-	isp3_param_write(params_vdev, val, ISP3X_ISP_CTRL0);
+	isp3_param_write(params_vdev, val, ISP3X_ISP_CTRL0, id);
 }
 
 static void
 isp_cgc_config(struct rkisp_isp_params_vdev *params_vdev,
-	       const struct isp21_cgc_cfg *arg)
+	       const struct isp21_cgc_cfg *arg, u32 id)
 {
-	u32 val = isp3_param_read_cache(params_vdev, ISP3X_ISP_CTRL0);
+	u32 val = isp3_param_read_cache(params_vdev, ISP3X_ISP_CTRL0, id);
 	u32 eff_ctrl, cproc_ctrl;
 
 	params_vdev->quantization = V4L2_QUANTIZATION_FULL_RANGE;
@@ -3426,73 +3490,73 @@ isp_cgc_config(struct rkisp_isp_params_vdev *params_vdev,
 	}
 	if (arg->ratio_en)
 		val |= ISP3X_SW_CGC_RATIO_EN;
-	isp3_param_write(params_vdev, val, ISP3X_ISP_CTRL0);
+	isp3_param_write(params_vdev, val, ISP3X_ISP_CTRL0, id);
 
-	cproc_ctrl = isp3_param_read(params_vdev, ISP3X_CPROC_CTRL);
+	cproc_ctrl = isp3_param_read(params_vdev, ISP3X_CPROC_CTRL, id);
 	if (cproc_ctrl & CIF_C_PROC_CTR_ENABLE) {
 		val = CIF_C_PROC_YOUT_FULL | CIF_C_PROC_YIN_FULL | CIF_C_PROC_COUT_FULL;
 		if (arg->yuv_limit)
 			cproc_ctrl &= ~val;
 		else
 			cproc_ctrl |= val;
-		isp3_param_write(params_vdev, cproc_ctrl, ISP3X_CPROC_CTRL);
+		isp3_param_write(params_vdev, cproc_ctrl, ISP3X_CPROC_CTRL, id);
 	}
 
-	eff_ctrl = isp3_param_read(params_vdev, ISP3X_IMG_EFF_CTRL);
+	eff_ctrl = isp3_param_read(params_vdev, ISP3X_IMG_EFF_CTRL, id);
 	if (eff_ctrl & CIF_IMG_EFF_CTRL_ENABLE) {
 		if (arg->yuv_limit)
 			eff_ctrl &= ~CIF_IMG_EFF_CTRL_YCBCR_FULL;
 		else
 			eff_ctrl |= CIF_IMG_EFF_CTRL_YCBCR_FULL;
-		isp3_param_write(params_vdev, eff_ctrl, ISP3X_IMG_EFF_CTRL);
+		isp3_param_write(params_vdev, eff_ctrl, ISP3X_IMG_EFF_CTRL, id);
 	}
 }
 
 static void
 isp_yuvme_config(struct rkisp_isp_params_vdev *params_vdev,
-		 const struct isp39_yuvme_cfg *arg)
+		 const struct isp39_yuvme_cfg *arg, u32 id)
 {
-	u32 i, value = isp3_param_read(params_vdev, ISP39_YUVME_CTRL);
+	u32 i, value = isp3_param_read(params_vdev, ISP39_YUVME_CTRL, id);
 
 	value &= ISP39_MODULE_EN;
 	value |= !!arg->bypass << 1 | !!arg->tnr_wgt0_en << 4;
-	isp3_param_write(params_vdev, value, ISP39_YUVME_CTRL);
+	isp3_param_write(params_vdev, value, ISP39_YUVME_CTRL, id);
 
 	value = arg->global_nr_strg |
 		arg->wgt_fact3 << 8 |
 		(arg->search_range_mode & 0xf) << 16 |
 		(arg->static_detect_thred & 0x3f) << 20;
-	isp3_param_write(params_vdev, value, ISP39_YUVME_PARA0);
+	isp3_param_write(params_vdev, value, ISP39_YUVME_PARA0, id);
 
 	value = (arg->time_relevance_offset & 0xf) |
 		(arg->space_relevance_offset & 0xf) << 4 |
 		arg->nr_diff_scale << 8 |
 		(arg->nr_fusion_limit & 0x3ff) << 20;
-	isp3_param_write(params_vdev, value, ISP39_YUVME_PARA1);
+	isp3_param_write(params_vdev, value, ISP39_YUVME_PARA1, id);
 
 	value = arg->nr_static_scale | (arg->nr_motion_scale & 0x1ff) << 8 |
 		(arg->nr_fusion_mode & 0x3) << 17 | (arg->cur_weight_limit & 0x7ff) << 20;
-	isp3_param_write(params_vdev, value, ISP39_YUVME_PARA2);
+	isp3_param_write(params_vdev, value, ISP39_YUVME_PARA2, id);
 
 	for (i = 0; i < ISP39_YUVME_SIGMA_NUM / 3; i++) {
 		value = (arg->nr_luma2sigma_val[i * 3] & 0x3ff) |
 			(arg->nr_luma2sigma_val[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->nr_luma2sigma_val[i * 3 + 2] & 0x3ff) << 20;
-		isp3_param_write(params_vdev, value, ISP39_YUVME_SIGMA0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_YUVME_SIGMA0 + i * 4, id);
 	}
 	value = arg->nr_luma2sigma_val[i * 3] & 0x3ff;
-	isp3_param_write(params_vdev, value, ISP39_YUVME_SIGMA0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_YUVME_SIGMA0 + i * 4, id);
 }
 
 static void
-isp_yuvme_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_yuvme_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	struct rkisp_device *ispdev = params_vdev->dev;
 	struct rkisp_isp_params_val_v39 *priv_val;
 	u32 value, ctrl;
 
 	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
-	ctrl = isp3_param_read_cache(params_vdev, ISP39_YUVME_CTRL);
+	ctrl = isp3_param_read_cache(params_vdev, ISP39_YUVME_CTRL, id);
 	if ((en && (ctrl & ISP39_MODULE_EN)) || (!en && !(ctrl & ISP39_MODULE_EN)))
 		return;
 
@@ -3501,24 +3565,24 @@ isp_yuvme_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
 			dev_err(ispdev->dev, "no yuvme cur buffer available\n");
 			return;
 		}
-		value = priv_val->buf_3dnr_cur.size;
-		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_CUR_WR_SIZE);
-		isp3_param_write(params_vdev, value, ISP32_MI_BAY3D_CUR_RD_SIZE);
-		value = priv_val->buf_3dnr_cur.dma_addr;
-		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_CUR_WR_BASE);
-		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_CUR_RD_BASE);
+		value = priv_val->bay3d_cur_size;
+		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_CUR_WR_SIZE, id);
+		isp3_param_write(params_vdev, value, ISP32_MI_BAY3D_CUR_RD_SIZE, id);
+		value = priv_val->buf_3dnr_cur.dma_addr + value * id;
+		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_CUR_WR_BASE, id);
+		isp3_param_write(params_vdev, value, ISP3X_MI_BAY3D_CUR_RD_BASE, id);
 
-		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1, ISP39_YUVME_FST_FRAME);
+		isp3_param_set_bits(params_vdev, ISP3X_ISP_CTRL1, ISP39_YUVME_FST_FRAME, id);
 		ctrl |= ISP39_MODULE_EN;
 	} else {
 		ctrl &= ~ISP39_MODULE_EN;
 	}
-	isp3_param_write(params_vdev, ctrl, ISP39_YUVME_CTRL);
+	isp3_param_write(params_vdev, ctrl, ISP39_YUVME_CTRL, id);
 }
 
 static void
 isp_ldcv_config(struct rkisp_isp_params_vdev *params_vdev,
-		const struct isp39_ldcv_cfg *arg)
+		const struct isp39_ldcv_cfg *arg, u32 id)
 {
 	struct rkisp_device *dev = params_vdev->dev;
 	struct rkisp_isp_params_val_v39 *priv_val;
@@ -3529,22 +3593,22 @@ isp_ldcv_config(struct rkisp_isp_params_vdev *params_vdev,
 	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
 	priv_val->ldcv_out_vsize = arg->out_vsize;
 
-	value = isp3_param_read(params_vdev, ISP39_LDCV_CTRL);
+	value = isp3_param_read(params_vdev, ISP39_LDCV_CTRL, id);
 	value &= (ISP39_MODULE_EN | ISP39_LDCV_OUTPUT_YUV420 | ISP39_LDCV_UV_SWAP);
 	value |= !!arg->thumb_mode << 1 | !!arg->dth_bypass << 6 |
 		 !!arg->force_map_en << 8 | !!arg->map13p3_en << 9;
-	isp3_param_write(params_vdev, value, ISP39_LDCV_CTRL);
+	isp3_param_write(params_vdev, value, ISP39_LDCV_CTRL, id);
 
 	for (i = 0; i < ISP39_LDCV_BIC_NUM / 4; i++) {
 		value = ISP_PACK_4BYTE(arg->bicubic[i * 4], arg->bicubic[i * 4 + 1],
 				       arg->bicubic[i * 4 + 2], arg->bicubic[i * 4 + 3]);
-		isp3_param_write(params_vdev, value, ISP39_LDCV_BIC_TABLE0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_LDCV_BIC_TABLE0 + i * 4, id);
 	}
 
 	for (i = 0; i < ISP39_MESH_BUF_NUM; i++) {
-		if (!priv_val->buf_ldcv[i].mem_priv)
+		if (!priv_val->buf_ldcv[id][i].mem_priv)
 			continue;
-		if (arg->buf_fd == priv_val->buf_ldcv[i].dma_fd)
+		if (arg->buf_fd == priv_val->buf_ldcv[id][i].dma_fd)
 			break;
 	}
 	if (i == ISP39_MESH_BUF_NUM) {
@@ -3552,42 +3616,41 @@ isp_ldcv_config(struct rkisp_isp_params_vdev *params_vdev,
 		return;
 	}
 
-	if (!priv_val->buf_ldcv[i].vaddr) {
+	if (!priv_val->buf_ldcv[id][i].vaddr) {
 		dev_err(dev->dev, "no ldcv buffer allocated\n");
 		return;
 	}
 
-	buf_idx = priv_val->buf_ldcv_idx;
-	head = (struct isp2x_mesh_head *)priv_val->buf_ldcv[buf_idx].vaddr;
+	buf_idx = priv_val->buf_ldcv_idx[id];
+	head = (struct isp2x_mesh_head *)priv_val->buf_ldcv[id][buf_idx].vaddr;
 	head->stat = MESH_BUF_INIT;
 
 	buf_idx = i;
-	head = (struct isp2x_mesh_head *)priv_val->buf_ldcv[buf_idx].vaddr;
+	head = (struct isp2x_mesh_head *)priv_val->buf_ldcv[id][buf_idx].vaddr;
 	head->stat = MESH_BUF_CHIPINUSE;
-	priv_val->buf_ldcv_idx = buf_idx;
-	rkisp_prepare_buffer(dev, &priv_val->buf_ldcv[buf_idx]);
-	value = priv_val->buf_ldcv[buf_idx].dma_addr + head->data_oft;
-	isp3_param_write(params_vdev, value, ISP32L_IRLDCV_RD_BASE);
-	isp3_param_write(params_vdev, arg->hsize, ISP32L_IRLDCV_RD_H_WSIZE);
-	isp3_param_write(params_vdev, arg->vsize, ISP32L_IRLDCV_RD_V_SIZE);
+	priv_val->buf_ldcv_idx[id] = buf_idx;
+	rkisp_prepare_buffer(dev, &priv_val->buf_ldcv[id][buf_idx]);
+	value = priv_val->buf_ldcv[id][buf_idx].dma_addr + head->data_oft;
+	isp3_param_write(params_vdev, value, ISP32L_IRLDCV_RD_BASE, id);
+	isp3_param_write(params_vdev, arg->hsize, ISP32L_IRLDCV_RD_H_WSIZE, id);
+	isp3_param_write(params_vdev, arg->vsize, ISP32L_IRLDCV_RD_V_SIZE, id);
 }
 
 static void
-isp_ldcv_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_ldcv_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	struct rkisp_device *dev = params_vdev->dev;
 	struct rkisp_stream *stream = &dev->cap_dev.stream[RKISP_STREAM_LDC];
-	struct rkisp_isp_params_val_v39 *priv_val;
-	u32 value = isp3_param_read(params_vdev, ISP39_LDCV_CTRL);
+	struct rkisp_isp_params_val_v39 *priv_val = params_vdev->priv_val;
+	u32 value = isp3_param_read(params_vdev, ISP39_LDCV_CTRL, id);
 	u32 buf_idx;
 
-	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
 	value &= ~(ISP39_LDCV_EN | ISP39_LDCV_FORCE_UPD);
 	if (en) {
-		buf_idx = priv_val->buf_ldcv_idx;
-		if (!stream->streaming || !priv_val->buf_ldcv[buf_idx].vaddr) {
+		buf_idx = priv_val->buf_ldcv_idx[id];
+		if (!stream->streaming || !priv_val->buf_ldcv[id][buf_idx].vaddr) {
 			dev_err(dev->dev, "output stream en:%d, ldcv map buf:%p\n",
-				stream->streaming, priv_val->buf_ldcv[buf_idx].vaddr);
+				stream->streaming, priv_val->buf_ldcv[id][buf_idx].vaddr);
 			goto end;
 		}
 		if (stream->out_fmt.width != priv_val->ldch_out_hsize ||
@@ -3600,53 +3663,53 @@ isp_ldcv_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
 		value |= ISP39_MODULE_EN;
 	}
 end:
-	isp3_param_write(params_vdev, value, ISP39_LDCV_CTRL);
+	isp3_param_write(params_vdev, value, ISP39_LDCV_CTRL, id);
 }
 
 static void
 isp_rgbir_config(struct rkisp_isp_params_vdev *params_vdev,
-		 const struct isp39_rgbir_cfg *arg)
+		 const struct isp39_rgbir_cfg *arg, u32 id)
 {
 	u32 i, value;
 
 	value = arg->coe_theta & 0xfff;
-	isp3_param_write(params_vdev, value, ISP39_RGBIR_THETA);
+	isp3_param_write(params_vdev, value, ISP39_RGBIR_THETA, id);
 
 	value = arg->coe_delta & 0x3fff;
-	isp3_param_write(params_vdev, value, ISP39_RGBIR_DELTA);
+	isp3_param_write(params_vdev, value, ISP39_RGBIR_DELTA, id);
 
 	for (i = 0; i < ISP39_RGBIR_SCALE_NUM; i++) {
 		value = arg->scale[i] & 0x1ff;
-		isp3_param_write(params_vdev, value, ISP39_RGBIR_SCALE0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_RGBIR_SCALE0 + i * 4, id);
 	}
 
 	for (i = 0; i < ISP39_RGBIR_LUMA_POINT_NUM / 3; i++) {
 		value = (arg->luma_point[i * 3] & 0x3ff) |
 			(arg->luma_point[i * 3 + 1] & 0x3ff) << 10 |
 			(arg->luma_point[i * 3 + 2] & 0x3ff) << 20;
-		isp3_param_write(params_vdev, value, ISP39_RGBIR_LUMA_POINT0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_RGBIR_LUMA_POINT0 + i * 4, id);
 	}
 	value = (arg->luma_point[i * 3] & 0x3ff) | (arg->luma_point[i * 3 + 1] & 0x3ff) << 10;
-	isp3_param_write(params_vdev, value, ISP39_RGBIR_LUMA_POINT0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_RGBIR_LUMA_POINT0 + i * 4, id);
 
 	for (i = 0; i < ISP39_RGBIR_SCALE_MAP_NUM / 3; i++) {
 		value = (arg->scale_map[i * 3] & 0x1ff) |
 			(arg->scale_map[i * 3 + 1] & 0x1ff) << 9 |
 			(arg->scale_map[i * 3 + 2] & 0x1ff) << 18;
-		isp3_param_write(params_vdev, value, ISP39_RGBIR_SCALE_MAP0 + i * 4);
+		isp3_param_write(params_vdev, value, ISP39_RGBIR_SCALE_MAP0 + i * 4, id);
 	}
 	value = (arg->scale_map[i * 3] & 0x1ff) | (arg->scale_map[i * 3 + 1] & 0x1ff) << 9;
-	isp3_param_write(params_vdev, value, ISP39_RGBIR_SCALE_MAP0 + i * 4);
+	isp3_param_write(params_vdev, value, ISP39_RGBIR_SCALE_MAP0 + i * 4, id);
 }
 
 static void
-isp_rgbir_enable(struct rkisp_isp_params_vdev *params_vdev, bool en)
+isp_rgbir_enable(struct rkisp_isp_params_vdev *params_vdev, bool en, u32 id)
 {
 	u32 value = 0;
 
 	if (en)
 		value = ISP39_MODULE_EN;
-	isp3_param_write(params_vdev, value, ISP39_RGBIR_CTRL);
+	isp3_param_write(params_vdev, value, ISP39_RGBIR_CTRL, id);
 }
 
 struct rkisp_isp_params_ops_v39 isp_params_ops_v39 = {
@@ -3718,114 +3781,111 @@ struct rkisp_isp_params_ops_v39 isp_params_ops_v39 = {
 static __maybe_unused
 void __isp_isr_other_config(struct rkisp_isp_params_vdev *params_vdev,
 			    const struct isp39_isp_params_cfg *new_params,
-			    enum rkisp_params_type type)
+			    enum rkisp_params_type type, u32 id)
 {
-	struct rkisp_isp_params_ops_v39 *ops =
-		(struct rkisp_isp_params_ops_v39 *)params_vdev->priv_ops;
+	struct rkisp_isp_params_ops_v39 *ops = params_vdev->priv_ops;
 	u64 module_cfg_update = new_params->module_cfg_update;
 
 	if (type == RKISP_PARAMS_SHD) {
 		if ((module_cfg_update & ISP39_MODULE_HDRMGE))
-			ops->hdrmge_config(params_vdev, &new_params->others.hdrmge_cfg, type);
+			ops->hdrmge_config(params_vdev, &new_params->others.hdrmge_cfg, type, id);
 
 		if ((module_cfg_update & ISP39_MODULE_DRC))
-			ops->hdrdrc_config(params_vdev, &new_params->others.drc_cfg, type);
+			ops->hdrdrc_config(params_vdev, &new_params->others.drc_cfg, type, id);
 		return;
 	}
 
 	v4l2_dbg(4, rkisp_debug, &params_vdev->dev->v4l2_dev,
-		 "%s seq:%d module_cfg_update:0x%llx\n",
-		 __func__, new_params->frame_id, module_cfg_update);
+		 "%s id:%d seq:%d module_cfg_update:0x%llx\n",
+		 __func__, id, new_params->frame_id, module_cfg_update);
 
 	if (module_cfg_update & ISP39_MODULE_LSC)
-		ops->lsc_config(params_vdev, &new_params->others.lsc_cfg);
+		ops->lsc_config(params_vdev, &new_params->others.lsc_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_DPCC)
-		ops->dpcc_config(params_vdev, &new_params->others.dpcc_cfg);
+		ops->dpcc_config(params_vdev, &new_params->others.dpcc_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_BLS)
-		ops->bls_config(params_vdev, &new_params->others.bls_cfg);
+		ops->bls_config(params_vdev, &new_params->others.bls_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_SDG)
-		ops->sdg_config(params_vdev, &new_params->others.sdg_cfg);
+		ops->sdg_config(params_vdev, &new_params->others.sdg_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_AWB_GAIN)
-		ops->awbgain_config(params_vdev, &new_params->others.awb_gain_cfg);
+		ops->awbgain_config(params_vdev, &new_params->others.awb_gain_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_DEBAYER)
-		ops->debayer_config(params_vdev, &new_params->others.debayer_cfg);
+		ops->debayer_config(params_vdev, &new_params->others.debayer_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_CCM)
-		ops->ccm_config(params_vdev, &new_params->others.ccm_cfg);
+		ops->ccm_config(params_vdev, &new_params->others.ccm_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_GOC)
-		ops->goc_config(params_vdev, &new_params->others.gammaout_cfg);
+		ops->goc_config(params_vdev, &new_params->others.gammaout_cfg, id);
 
 	/* range csm->cgc->cproc->ie */
 	if (module_cfg_update & ISP39_MODULE_CSM)
-		ops->csm_config(params_vdev, &new_params->others.csm_cfg);
+		ops->csm_config(params_vdev, &new_params->others.csm_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_CGC)
-		ops->cgc_config(params_vdev, &new_params->others.cgc_cfg);
+		ops->cgc_config(params_vdev, &new_params->others.cgc_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_CPROC)
-		ops->cproc_config(params_vdev, &new_params->others.cproc_cfg);
+		ops->cproc_config(params_vdev, &new_params->others.cproc_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_HDRMGE)
-		ops->hdrmge_config(params_vdev, &new_params->others.hdrmge_cfg, type);
+		ops->hdrmge_config(params_vdev, &new_params->others.hdrmge_cfg, type, id);
 
 	if (module_cfg_update & ISP39_MODULE_DRC)
-		ops->hdrdrc_config(params_vdev, &new_params->others.drc_cfg, type);
+		ops->hdrdrc_config(params_vdev, &new_params->others.drc_cfg, type, id);
 
 	if (module_cfg_update & ISP39_MODULE_GIC)
-		ops->gic_config(params_vdev, &new_params->others.gic_cfg);
+		ops->gic_config(params_vdev, &new_params->others.gic_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_DHAZ)
-		ops->dhaz_config(params_vdev, &new_params->others.dhaz_cfg);
+		ops->dhaz_config(params_vdev, &new_params->others.dhaz_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_3DLUT)
-		ops->isp3dlut_config(params_vdev, &new_params->others.isp3dlut_cfg);
+		ops->isp3dlut_config(params_vdev, &new_params->others.isp3dlut_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_LDCH)
-		ops->ldch_config(params_vdev, &new_params->others.ldch_cfg);
+		ops->ldch_config(params_vdev, &new_params->others.ldch_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_LDCV)
-		ops->ldcv_config(params_vdev, &new_params->others.ldcv_cfg);
+		ops->ldcv_config(params_vdev, &new_params->others.ldcv_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_YNR)
-		ops->ynr_config(params_vdev, &new_params->others.ynr_cfg);
+		ops->ynr_config(params_vdev, &new_params->others.ynr_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_CNR)
-		ops->cnr_config(params_vdev, &new_params->others.cnr_cfg);
+		ops->cnr_config(params_vdev, &new_params->others.cnr_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_SHARP)
-		ops->sharp_config(params_vdev, &new_params->others.sharp_cfg);
+		ops->sharp_config(params_vdev, &new_params->others.sharp_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_BAY3D)
-		ops->bay3d_config(params_vdev, &new_params->others.bay3d_cfg);
+		ops->bay3d_config(params_vdev, &new_params->others.bay3d_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_YUVME)
-		ops->yuvme_config(params_vdev, &new_params->others.yuvme_cfg);
+		ops->yuvme_config(params_vdev, &new_params->others.yuvme_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_RGBIR)
-		ops->rgbir_config(params_vdev, &new_params->others.rgbir_cfg);
+		ops->rgbir_config(params_vdev, &new_params->others.rgbir_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_CAC)
-		ops->cac_config(params_vdev, &new_params->others.cac_cfg);
+		ops->cac_config(params_vdev, &new_params->others.cac_cfg, id);
 
 	if (module_cfg_update & ISP39_MODULE_GAIN)
-		ops->gain_config(params_vdev, &new_params->others.gain_cfg);
+		ops->gain_config(params_vdev, &new_params->others.gain_cfg, id);
 }
 
 static __maybe_unused
 void __isp_isr_other_en(struct rkisp_isp_params_vdev *params_vdev,
 			const struct isp39_isp_params_cfg *new_params,
-			enum rkisp_params_type type)
+			enum rkisp_params_type type, u32 id)
 {
-	struct rkisp_isp_params_ops_v39 *ops =
-		(struct rkisp_isp_params_ops_v39 *)params_vdev->priv_ops;
-	struct rkisp_isp_params_val_v39 *priv_val =
-		(struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
+	struct rkisp_isp_params_ops_v39 *ops = params_vdev->priv_ops;
+	struct rkisp_isp_params_val_v39 *priv_val = params_vdev->priv_val;
 	u64 module_en_update = new_params->module_en_update;
 	u64 module_ens = new_params->module_ens;
 	u32 gain_ctrl, cnr_ctrl, val;
@@ -3834,118 +3894,115 @@ void __isp_isr_other_en(struct rkisp_isp_params_vdev *params_vdev,
 		return;
 
 	v4l2_dbg(4, rkisp_debug, &params_vdev->dev->v4l2_dev,
-		 "%s seq:%d module_en_update:0x%llx module_ens:0x%llx\n",
-		 __func__, new_params->frame_id, module_en_update, module_ens);
+		 "%s id:%d seq:%d module_en_update:0x%llx module_ens:0x%llx\n",
+		 __func__, id, new_params->frame_id, module_en_update, module_ens);
 
 	if (module_en_update & ISP39_MODULE_DPCC)
-		ops->dpcc_enable(params_vdev, !!(module_ens & ISP39_MODULE_DPCC));
+		ops->dpcc_enable(params_vdev, !!(module_ens & ISP39_MODULE_DPCC), id);
 
 	if (module_en_update & ISP39_MODULE_BLS)
-		ops->bls_enable(params_vdev, !!(module_ens & ISP39_MODULE_BLS));
+		ops->bls_enable(params_vdev, !!(module_ens & ISP39_MODULE_BLS), id);
 
 	if (module_en_update & ISP39_MODULE_SDG)
-		ops->sdg_enable(params_vdev, !!(module_ens & ISP39_MODULE_SDG));
+		ops->sdg_enable(params_vdev, !!(module_ens & ISP39_MODULE_SDG), id);
 
 	if (module_en_update & ISP39_MODULE_LSC) {
-		ops->lsc_enable(params_vdev, !!(module_ens & ISP39_MODULE_LSC));
+		ops->lsc_enable(params_vdev, !!(module_ens & ISP39_MODULE_LSC), id);
 		priv_val->lsc_en = !!(module_ens & ISP39_MODULE_LSC);
 	}
 
 	if (module_en_update & ISP39_MODULE_AWB_GAIN)
-		ops->awbgain_enable(params_vdev, !!(module_ens & ISP39_MODULE_AWB_GAIN));
+		ops->awbgain_enable(params_vdev, !!(module_ens & ISP39_MODULE_AWB_GAIN), id);
 
 	if (module_en_update & ISP39_MODULE_DEBAYER)
-		ops->debayer_enable(params_vdev, !!(module_ens & ISP39_MODULE_DEBAYER));
+		ops->debayer_enable(params_vdev, !!(module_ens & ISP39_MODULE_DEBAYER), id);
 
 	if (module_en_update & ISP39_MODULE_CCM)
-		ops->ccm_enable(params_vdev, !!(module_ens & ISP39_MODULE_CCM));
+		ops->ccm_enable(params_vdev, !!(module_ens & ISP39_MODULE_CCM), id);
 
 	if (module_en_update & ISP39_MODULE_GOC)
-		ops->goc_enable(params_vdev, !!(module_ens & ISP39_MODULE_GOC));
+		ops->goc_enable(params_vdev, !!(module_ens & ISP39_MODULE_GOC), id);
 
 	if (module_en_update & ISP39_MODULE_CPROC)
-		ops->cproc_enable(params_vdev, !!(module_ens & ISP39_MODULE_CPROC));
+		ops->cproc_enable(params_vdev, !!(module_ens & ISP39_MODULE_CPROC), id);
 
 	if (module_en_update & ISP39_MODULE_IE)
-		ops->ie_enable(params_vdev, !!(module_ens & ISP39_MODULE_IE));
+		ops->ie_enable(params_vdev, !!(module_ens & ISP39_MODULE_IE), id);
 
 	if (module_en_update & ISP39_MODULE_HDRMGE) {
-		ops->hdrmge_enable(params_vdev, !!(module_ens & ISP39_MODULE_HDRMGE));
+		ops->hdrmge_enable(params_vdev, !!(module_ens & ISP39_MODULE_HDRMGE), id);
 		priv_val->mge_en = !!(module_ens & ISP39_MODULE_HDRMGE);
 	}
 
 	if (module_en_update & ISP39_MODULE_DRC) {
-		ops->hdrdrc_enable(params_vdev, !!(module_ens & ISP39_MODULE_DRC));
+		ops->hdrdrc_enable(params_vdev, !!(module_ens & ISP39_MODULE_DRC), id);
 		priv_val->drc_en = !!(module_ens & ISP39_MODULE_DRC);
 	}
 
 	if (module_en_update & ISP39_MODULE_GIC)
-		ops->gic_enable(params_vdev, !!(module_ens & ISP39_MODULE_GIC));
+		ops->gic_enable(params_vdev, !!(module_ens & ISP39_MODULE_GIC), id);
 
 	if (module_en_update & ISP39_MODULE_DHAZ) {
-		ops->dhaz_enable(params_vdev, !!(module_ens & ISP39_MODULE_DHAZ));
+		ops->dhaz_enable(params_vdev, !!(module_ens & ISP39_MODULE_DHAZ), id);
 		priv_val->dhaz_en = !!(module_ens & ISP39_MODULE_DHAZ);
 	}
 
 	if (module_en_update & ISP39_MODULE_3DLUT) {
-		ops->isp3dlut_enable(params_vdev, !!(module_ens & ISP39_MODULE_3DLUT));
+		ops->isp3dlut_enable(params_vdev, !!(module_ens & ISP39_MODULE_3DLUT), id);
 		priv_val->lut3d_en = !!(module_ens & ISP39_MODULE_3DLUT);
 	}
 
 	if (module_en_update & ISP39_MODULE_LDCH)
-		ops->ldch_enable(params_vdev, !!(module_ens & ISP39_MODULE_LDCH));
+		ops->ldch_enable(params_vdev, !!(module_ens & ISP39_MODULE_LDCH), id);
 
 	if (module_en_update & ISP39_MODULE_LDCV)
-		ops->ldcv_enable(params_vdev, !!(module_ens & ISP39_MODULE_LDCV));
+		ops->ldcv_enable(params_vdev, !!(module_ens & ISP39_MODULE_LDCV), id);
 
 	if (module_en_update & ISP39_MODULE_YNR)
-		ops->ynr_enable(params_vdev, !!(module_ens & ISP39_MODULE_YNR));
+		ops->ynr_enable(params_vdev, !!(module_ens & ISP39_MODULE_YNR), id);
 
 	if (module_en_update & ISP39_MODULE_CNR)
-		ops->cnr_enable(params_vdev, !!(module_ens & ISP39_MODULE_CNR));
+		ops->cnr_enable(params_vdev, !!(module_ens & ISP39_MODULE_CNR), id);
 
 	if (module_en_update & ISP39_MODULE_SHARP)
-		ops->sharp_enable(params_vdev, !!(module_ens & ISP39_MODULE_SHARP));
+		ops->sharp_enable(params_vdev, !!(module_ens & ISP39_MODULE_SHARP), id);
 
 	if (module_en_update & ISP39_MODULE_BAY3D) {
-		ops->bay3d_enable(params_vdev, !!(module_ens & ISP39_MODULE_BAY3D));
+		ops->bay3d_enable(params_vdev, !!(module_ens & ISP39_MODULE_BAY3D), id);
 		priv_val->bay3d_en = !!(module_ens & ISP39_MODULE_BAY3D);
 	}
 
 	if (module_en_update & ISP39_MODULE_YUVME)
-		ops->yuvme_enable(params_vdev, !!(module_ens & ISP39_MODULE_YUVME));
+		ops->yuvme_enable(params_vdev, !!(module_ens & ISP39_MODULE_YUVME), id);
 
 	if (module_en_update & ISP39_MODULE_RGBIR)
-		ops->rgbir_enable(params_vdev, !!(module_ens & ISP39_MODULE_RGBIR));
+		ops->rgbir_enable(params_vdev, !!(module_ens & ISP39_MODULE_RGBIR), id);
 
 	if (module_en_update & ISP39_MODULE_CAC)
-		ops->cac_enable(params_vdev, !!(module_ens & ISP39_MODULE_CAC));
+		ops->cac_enable(params_vdev, !!(module_ens & ISP39_MODULE_CAC), id);
 
 	if (module_en_update & ISP39_MODULE_GAIN ||
 	    ((priv_val->buf_info_owner == RKISP_INFO2DRR_OWNER_GAIN) &&
-	     !(isp3_param_read(params_vdev, ISP3X_GAIN_CTRL) & ISP3X_GAIN_2DDR_EN)))
-		ops->gain_enable(params_vdev, !!(module_ens & ISP39_MODULE_GAIN));
+	     !(isp3_param_read(params_vdev, ISP3X_GAIN_CTRL, id) & ISP3X_GAIN_2DDR_EN)))
+		ops->gain_enable(params_vdev, !!(module_ens & ISP39_MODULE_GAIN), id);
 
 	/* gain disable, using global gain for cnr */
-	gain_ctrl = isp3_param_read_cache(params_vdev, ISP3X_GAIN_CTRL);
-	cnr_ctrl = isp3_param_read_cache(params_vdev, ISP3X_CNR_CTRL);
+	gain_ctrl = isp3_param_read_cache(params_vdev, ISP3X_GAIN_CTRL, id);
+	cnr_ctrl = isp3_param_read_cache(params_vdev, ISP3X_CNR_CTRL, id);
 	if (!(gain_ctrl & ISP39_MODULE_EN) && cnr_ctrl & ISP39_MODULE_EN) {
 		cnr_ctrl |= BIT(1);
-		isp3_param_write(params_vdev, cnr_ctrl, ISP3X_CNR_CTRL);
-		val = isp3_param_read(params_vdev, ISP3X_CNR_EXGAIN) & 0x3ff;
-		isp3_param_write(params_vdev, val | 0x8000, ISP3X_CNR_EXGAIN);
+		isp3_param_write(params_vdev, cnr_ctrl, ISP3X_CNR_CTRL, id);
+		val = isp3_param_read(params_vdev, ISP3X_CNR_EXGAIN, id) & 0x3ff;
+		isp3_param_write(params_vdev, val | 0x8000, ISP3X_CNR_EXGAIN, id);
 	}
 }
 
 static __maybe_unused
 void __isp_isr_meas_config(struct rkisp_isp_params_vdev *params_vdev,
 			   struct isp39_isp_params_cfg *new_params,
-			   enum rkisp_params_type type)
+			   enum rkisp_params_type type, u32 id)
 {
-	struct rkisp_isp_params_ops_v39 *ops =
-		(struct rkisp_isp_params_ops_v39 *)params_vdev->priv_ops;
-	struct rkisp_isp_params_val_v39 *priv_val =
-		(struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
+	struct rkisp_isp_params_ops_v39 *ops = params_vdev->priv_ops;
 	u64 module_cfg_update = new_params->module_cfg_update;
 
 	params_vdev->cur_frame_id = new_params->frame_id;
@@ -3954,37 +4011,34 @@ void __isp_isr_meas_config(struct rkisp_isp_params_vdev *params_vdev,
 		return;
 
 	v4l2_dbg(4, rkisp_debug, &params_vdev->dev->v4l2_dev,
-		 "%s seq:%d module_cfg_update:0x%llx\n",
-		 __func__, new_params->frame_id, module_cfg_update);
+		 "%s id:%d seq:%d module_cfg_update:0x%llx\n",
+		 __func__, id, new_params->frame_id, module_cfg_update);
 
 	if ((module_cfg_update & ISP39_MODULE_RAWAF))
-		ops->rawaf_config(params_vdev, &new_params->meas.rawaf);
+		ops->rawaf_config(params_vdev, &new_params->meas.rawaf, id);
 
 	if (module_cfg_update & ISP39_MODULE_RAWAE0)
-		ops->rawae0_config(params_vdev, &new_params->meas.rawae0);
+		ops->rawae0_config(params_vdev, &new_params->meas.rawae0, id);
 
 	if (module_cfg_update & ISP39_MODULE_RAWAE3)
-		ops->rawae3_config(params_vdev, &new_params->meas.rawae3);
+		ops->rawae3_config(params_vdev, &new_params->meas.rawae3, id);
 
 	if (module_cfg_update & ISP39_MODULE_RAWHIST0)
-		ops->rawhst0_config(params_vdev, &new_params->meas.rawhist0);
+		ops->rawhst0_config(params_vdev, &new_params->meas.rawhist0, id);
 
 	if (module_cfg_update & ISP39_MODULE_RAWHIST3)
-		ops->rawhst3_config(params_vdev, &new_params->meas.rawhist3);
+		ops->rawhst3_config(params_vdev, &new_params->meas.rawhist3, id);
 
-	if ((module_cfg_update & ISP39_MODULE_RAWAWB) ||
-	    ((priv_val->buf_info_owner == RKISP_INFO2DRR_OWNER_AWB) &&
-	     !(isp3_param_read(params_vdev, ISP3X_RAWAWB_CTRL) & ISP32_RAWAWB_2DDR_PATH_EN)))
-		ops->rawawb_config(params_vdev, &new_params->meas.rawawb);
+	if (module_cfg_update & ISP39_MODULE_RAWAWB)
+		ops->rawawb_config(params_vdev, &new_params->meas.rawawb, id);
 }
 
 static __maybe_unused
 void __isp_isr_meas_en(struct rkisp_isp_params_vdev *params_vdev,
 		       struct isp39_isp_params_cfg *new_params,
-		       enum rkisp_params_type type)
+		       enum rkisp_params_type type, u32 id)
 {
-	struct rkisp_isp_params_ops_v39 *ops =
-		(struct rkisp_isp_params_ops_v39 *)params_vdev->priv_ops;
+	struct rkisp_isp_params_ops_v39 *ops = params_vdev->priv_ops;
 	u64 module_en_update = new_params->module_en_update;
 	u64 module_ens = new_params->module_ens;
 
@@ -3992,52 +4046,41 @@ void __isp_isr_meas_en(struct rkisp_isp_params_vdev *params_vdev,
 		return;
 
 	v4l2_dbg(4, rkisp_debug, &params_vdev->dev->v4l2_dev,
-		 "%s seq:%d module_en_update:0x%llx module_ens:0x%llx\n",
-		 __func__, new_params->frame_id, module_en_update, module_ens);
+		 "%s id:%d seq:%d module_en_update:0x%llx module_ens:0x%llx\n",
+		 __func__, id, new_params->frame_id, module_en_update, module_ens);
 
 	if (module_en_update & ISP39_MODULE_RAWAF)
-		ops->rawaf_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWAF));
+		ops->rawaf_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWAF), id);
 
 	if (module_en_update & ISP39_MODULE_RAWAE0)
-		ops->rawae0_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWAE0));
+		ops->rawae0_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWAE0), id);
 
 	if (module_en_update & ISP39_MODULE_RAWAE3)
-		ops->rawae3_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWAE3));
+		ops->rawae3_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWAE3), id);
 
 	if (module_en_update & ISP39_MODULE_RAWHIST0)
-		ops->rawhst0_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWHIST0));
+		ops->rawhst0_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWHIST0), id);
 
 	if (module_en_update & ISP39_MODULE_RAWHIST3)
-		ops->rawhst3_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWHIST3));
+		ops->rawhst3_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWHIST3), id);
 
 	if (module_en_update & ISP39_MODULE_RAWAWB)
-		ops->rawawb_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWAWB));
-}
-
-static __maybe_unused
-void __isp_config_hdrshd(struct rkisp_isp_params_vdev *params_vdev)
-{
-	struct rkisp_isp_params_ops_v39 *ops =
-		(struct rkisp_isp_params_ops_v39 *)params_vdev->priv_ops;
-	struct rkisp_isp_params_val_v39 *priv_val =
-		(struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
-
-	ops->hdrmge_config(params_vdev, &priv_val->last_hdrmge, RKISP_PARAMS_SHD);
-	ops->hdrdrc_config(params_vdev, &priv_val->last_hdrdrc, RKISP_PARAMS_SHD);
+		ops->rawawb_enable(params_vdev, !!(module_ens & ISP39_MODULE_RAWAWB), id);
 }
 
 static
 void rkisp_params_cfgsram_v39(struct rkisp_isp_params_vdev *params_vdev)
 {
-	struct isp39_isp_params_cfg *params = params_vdev->isp39_params;
+	u32 id = params_vdev->dev->unite_index;
+	struct isp39_isp_params_cfg *params = params_vdev->isp39_params + id;
 
-	isp_dhaz_cfg_sram(params_vdev, &params->others.dhaz_cfg, true);
-	isp_lsc_matrix_cfg_sram(params_vdev, &params->others.lsc_cfg, true);
+	isp_dhaz_cfg_sram(params_vdev, &params->others.dhaz_cfg, true, id);
+	isp_lsc_matrix_cfg_sram(params_vdev, &params->others.lsc_cfg, true, id);
 	isp_rawhstbig_cfg_sram(params_vdev, &params->meas.rawhist0,
-			       ISP3X_RAWHIST_LITE_BASE, true);
+			       ISP3X_RAWHIST_LITE_BASE, true, id);
 	isp_rawhstbig_cfg_sram(params_vdev, &params->meas.rawhist3,
-			       ISP3X_RAWHIST_BIG1_BASE, true);
-	isp_rawawb_cfg_sram(params_vdev, &params->meas.rawawb, true);
+			       ISP3X_RAWHIST_BIG1_BASE, true, id);
+	isp_rawawb_cfg_sram(params_vdev, &params->meas.rawawb, true, id);
 }
 
 static int
@@ -4048,36 +4091,45 @@ rkisp_alloc_internal_buf(struct rkisp_isp_params_vdev *params_vdev,
 	struct rkisp_isp_subdev *isp_sdev = &dev->isp_sdev;
 	struct rkisp_isp_params_val_v39 *priv_val;
 	u64 module_en_update, module_ens;
-	int ret, i;
+	int ret, i, id;
 
 	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
 	module_en_update = new_params->module_en_update;
 	module_ens = new_params->module_ens;
 
-	priv_val->buf_3dlut_idx = 0;
-	for (i = 0; i < ISP39_3DLUT_BUF_NUM; i++) {
-		if (priv_val->buf_3dlut[i].mem_priv)
-			continue;
-		priv_val->buf_3dlut[i].is_need_vaddr = true;
-		priv_val->buf_3dlut[i].size = ISP39_3DLUT_BUF_SIZE;
-		ret = rkisp_alloc_buffer(dev, &priv_val->buf_3dlut[i]);
-		if (ret) {
-			dev_err(dev->dev, "alloc 3dlut buf fail:%d\n", ret);
-			goto err_3dlut;
+	for (id = 0; id < dev->unite_div; id++) {
+		priv_val->buf_3dlut_idx[id] = 0;
+		for (i = 0; i < ISP39_3DLUT_BUF_NUM; i++) {
+			if (priv_val->buf_3dlut[id][i].mem_priv)
+				continue;
+			priv_val->buf_3dlut[id][i].is_need_vaddr = true;
+			priv_val->buf_3dlut[id][i].size = ISP39_3DLUT_BUF_SIZE;
+			ret = rkisp_alloc_buffer(dev, &priv_val->buf_3dlut[id][i]);
+			if (ret) {
+				dev_err(dev->dev, "alloc 3dlut buf fail:%d\n", ret);
+				goto err_3dlut;
+			}
 		}
 	}
-
 	if ((module_en_update & ISP39_MODULE_BAY3D) && (module_ens & ISP39_MODULE_BAY3D)) {
 		bool iirsparse_en = !!new_params->others.bay3d_cfg.iirsparse_en;
 		u32 w = ALIGN(isp_sdev->in_crop.width, 16);
 		u32 h = isp_sdev->in_crop.height, val;
 		bool is_alloc;
 
+		if (dev->unite_div > ISP_UNITE_DIV1)
+			w = ALIGN(isp_sdev->in_crop.width / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL, 16);
+		if (dev->unite_div == ISP_UNITE_DIV4)
+			h = ALIGN(isp_sdev->in_crop.height / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL, 16);
+
 		if (!iirsparse_en) {
 			w = w * 3 / 2 + w / 4;
 			h /= 2;
 		}
 		val = ALIGN(w * h * 2, 16);
+		priv_val->bay3d_iir_size = val;
+		if (dev->unite_div > ISP_UNITE_DIV1)
+			val *= dev->unite_div;
 		is_alloc = true;
 		if (priv_val->buf_3dnr_iir.mem_priv) {
 			if (val > priv_val->buf_3dnr_iir.size)
@@ -4095,6 +4147,9 @@ rkisp_alloc_internal_buf(struct rkisp_isp_params_vdev *params_vdev,
 		}
 
 		val = ALIGN(w * h / 4, 16);
+		priv_val->gain_size = val;
+		if (dev->unite_div > ISP_UNITE_DIV1)
+			val *= dev->unite_div;
 		is_alloc = iirsparse_en ? true : false;
 		if (priv_val->buf_gain.mem_priv) {
 			if (val > priv_val->buf_gain.size)
@@ -4115,9 +4170,17 @@ rkisp_alloc_internal_buf(struct rkisp_isp_params_vdev *params_vdev,
 	if ((module_en_update & ISP39_MODULE_YUVME) && (module_ens & ISP39_MODULE_YUVME)) {
 		u32 w = isp_sdev->in_crop.width;
 		u32 h = isp_sdev->in_crop.height;
-		u32 size = (w / 2 * 80 + (w + 7) / 8 * 9 + 31) / 32 * ((h + 7) / 8) * 4;
+		u32 size;
 		bool is_alloc = true;
 
+		if (dev->unite_div > ISP_UNITE_DIV1)
+			w = w / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
+		if (dev->unite_div == ISP_UNITE_DIV4)
+			h = h / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
+		size = (w / 2 * 80 + (w + 7) / 8 * 9 + 31) / 32 * ((h + 7) / 8) * 4;
+		priv_val->bay3d_cur_size = size;
+		if (dev->unite_div > ISP_UNITE_DIV1)
+			size *= dev->unite_div;
 		if (priv_val->buf_3dnr_cur.mem_priv) {
 			if (size > priv_val->buf_3dnr_cur.size)
 				rkisp_free_buffer(dev, &priv_val->buf_3dnr_cur);
@@ -4137,6 +4200,7 @@ rkisp_alloc_internal_buf(struct rkisp_isp_params_vdev *params_vdev,
 
 	if (dev->hw_dev->is_frm_buf && !priv_val->buf_frm.mem_priv) {
 		priv_val->buf_frm.size = ISP39_FRM_BUF_SIZE;
+		priv_val->buf_frm.size *= dev->unite_div;
 		ret = rkisp_alloc_buffer(dev, &priv_val->buf_frm);
 		if (ret) {
 			dev->hw_dev->is_frm_buf = false;
@@ -4152,10 +4216,14 @@ free_gain:
 free_3dnr_iir:
 	rkisp_free_buffer(dev, &priv_val->buf_3dnr_iir);
 err_3dnr_iir:
+	id = dev->unite_div - 1;
 	i = ISP39_3DLUT_BUF_NUM;
 err_3dlut:
-	for (i -= 1; i >= 0; i--)
-		rkisp_free_buffer(dev, &priv_val->buf_3dlut[i]);
+	for (; id >= 0; id--) {
+		for (i -= 1; i >= 0; i--)
+			rkisp_free_buffer(dev, &priv_val->buf_3dlut[id][i]);
+		i = ISP39_3DLUT_BUF_NUM;
+	}
 	return ret;
 }
 
@@ -4175,7 +4243,7 @@ rkisp_params_check_bigmode_v39(struct rkisp_isp_params_vdev *params_vdev)
 
 	ispdev->multi_mode = 0;
 	ispdev->multi_index = ispdev->dev_id;
-	if (hw->dev_link_num == 5)
+	if (hw->dev_link_num == 5 || hw->unite == ISP_UNITE_ONE)
 		hw->is_frm_buf = true;
 using_frm_buf:
 	if (hw->is_frm_buf) {
@@ -4322,23 +4390,12 @@ rkisp_params_first_cfg_v39(struct rkisp_isp_params_vdev *params_vdev)
 {
 	struct rkisp_device *dev = params_vdev->dev;
 	struct rkisp_stream *stream = &dev->cap_dev.stream[RKISP_STREAM_LDC];
-	struct rkisp_isp_params_val_v39 *priv_val =
-		(struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
-	u64 module_cfg_update = params_vdev->isp39_params->module_cfg_update;
-	u64 module_en_update = params_vdev->isp39_params->module_en_update;
+	struct rkisp_isp_params_val_v39 *priv_val = params_vdev->priv_val;
+	struct isp39_isp_params_cfg *params = params_vdev->isp39_params;
+	int i;
 
 	rkisp_params_check_bigmode_v39(params_vdev);
 	spin_lock(&params_vdev->config_lock);
-	/* override the default things */
-	if (!module_cfg_update && !module_en_update)
-		dev_warn(dev->dev, "can not get first iq setting in stream on\n");
-	if (stream->streaming &&
-	    (!(module_en_update & ISP39_MODULE_LDCH) || !(module_en_update & ISP39_MODULE_LDCV))) {
-		dev_err(dev->dev, "no enable ldch and ldcv for first iq\n");
-		isp3_param_clear_bits(params_vdev, ISP3X_LDCH_STS, 0x01);
-		isp3_param_clear_bits(params_vdev, ISP39_LDCV_CTRL, 0x01);
-	}
-
 	priv_val->bay3d_en = 0;
 	priv_val->dhaz_en = 0;
 	priv_val->drc_en = 0;
@@ -4346,24 +4403,46 @@ rkisp_params_first_cfg_v39(struct rkisp_isp_params_vdev *params_vdev)
 	priv_val->mge_en = 0;
 	priv_val->lut3d_en = 0;
 	if (dev->is_bigmode)
-		rkisp_set_bits(params_vdev->dev, ISP3X_ISP_CTRL1, 0,
-			       ISP3X_BIGMODE_MANUAL | ISP3X_BIGMODE_FORCE_EN, false);
+		rkisp_unite_set_bits(dev, ISP3X_ISP_CTRL1, 0,
+				     ISP3X_BIGMODE_MANUAL | ISP3X_BIGMODE_FORCE_EN, false);
 
-	__isp_isr_meas_config(params_vdev, params_vdev->isp39_params, RKISP_PARAMS_ALL);
-	__isp_isr_other_config(params_vdev, params_vdev->isp39_params, RKISP_PARAMS_ALL);
-	__isp_isr_other_en(params_vdev, params_vdev->isp39_params, RKISP_PARAMS_ALL);
-	__isp_isr_meas_en(params_vdev, params_vdev->isp39_params, RKISP_PARAMS_ALL);
+	for (i = 0; i < dev->unite_div; i++) {
+		u64 module_cfg_update = params->module_cfg_update;
+		u64 module_en_update = params->module_en_update;
+		u64 module_ens = params->module_ens;
 
-	priv_val->cur_hdrmge = params_vdev->isp39_params->others.hdrmge_cfg;
-	priv_val->cur_hdrdrc = params_vdev->isp39_params->others.drc_cfg;
-	priv_val->last_hdrmge = priv_val->cur_hdrmge;
-	priv_val->last_hdrdrc = priv_val->cur_hdrdrc;
+		if (!module_cfg_update || !module_en_update || !module_ens)
+			dev_warn(dev->dev,
+				 "id:%d no first iq setting cfg_upd:%llx en_upd:%llx ens:%llx\n",
+				 i, module_cfg_update, module_en_update, module_ens);
+
+		if (stream->streaming &&
+		    (!(module_en_update & ISP39_MODULE_LDCH) ||
+		     !(module_en_update & ISP39_MODULE_LDCV))) {
+			dev_err(dev->dev,
+				"id:%d ldch or ldcv no enable for first iq\n", i);
+			isp3_param_clear_bits(params_vdev, ISP3X_LDCH_STS, 0x01, i);
+			isp3_param_clear_bits(params_vdev, ISP39_LDCV_CTRL, 0x01, i);
+		}
+		__isp_isr_meas_config(params_vdev, params, RKISP_PARAMS_ALL, i);
+		__isp_isr_other_config(params_vdev, params, RKISP_PARAMS_ALL, i);
+		__isp_isr_other_en(params_vdev, params, RKISP_PARAMS_ALL, i);
+		__isp_isr_meas_en(params_vdev, params, RKISP_PARAMS_ALL, i);
+		params++;
+	}
 	spin_unlock(&params_vdev->config_lock);
 
 	if (dev->hw_dev->is_frm_buf && priv_val->buf_frm.mem_priv) {
-		isp3_param_write(params_vdev, priv_val->buf_frm.size, ISP32L_FRM_BUF_WR_SIZE);
-		isp3_param_write(params_vdev, priv_val->buf_frm.dma_addr, ISP32L_FRM_BUF_WR_BASE);
-		isp3_param_write(params_vdev, priv_val->buf_frm.dma_addr, ISP32L_FRM_BUF_RD_BASE);
+		u32 size = priv_val->buf_frm.size;
+		u32 addr = priv_val->buf_frm.dma_addr;
+
+		if (dev->unite_div)
+			size /= dev->unite_div;
+		for (i = 0; i < dev->unite_div; i++) {
+			isp3_param_write(params_vdev, size, ISP32L_FRM_BUF_WR_SIZE, i);
+			isp3_param_write(params_vdev, addr + size * i, ISP32L_FRM_BUF_WR_BASE, i);
+			isp3_param_write(params_vdev, addr + size * i, ISP32L_FRM_BUF_RD_BASE, i);
+		}
 	}
 	if (dev->hw_dev->is_single && (dev->isp_state & ISP_START))
 		rkisp_set_bits(dev, ISP3X_ISP_CTRL0, 0, CIF_ISP_CTRL_ISP_CFG_UPD, true);
@@ -4377,11 +4456,14 @@ static void rkisp_save_first_param_v39(struct rkisp_isp_params_vdev *params_vdev
 
 static void rkisp_clear_first_param_v39(struct rkisp_isp_params_vdev *params_vdev)
 {
-	memset(params_vdev->isp39_params, 0, sizeof(struct isp39_isp_params_cfg));
+	u32 mult = params_vdev->dev->hw_dev->unite ? ISP_UNITE_MAX : 1;
+	u32 size = sizeof(struct isp39_isp_params_cfg) * mult;
+
+	memset(params_vdev->isp39_params, 0, size);
 }
 
 static void rkisp_deinit_mesh_buf(struct rkisp_isp_params_vdev *params_vdev,
-				  u64 module_id)
+				  u64 module_id, u32 id)
 {
 	struct rkisp_isp_params_val_v39 *priv_val;
 	struct rkisp_dummy_buffer *buf;
@@ -4393,14 +4475,14 @@ static void rkisp_deinit_mesh_buf(struct rkisp_isp_params_vdev *params_vdev,
 
 	switch (module_id) {
 	case ISP39_MODULE_CAC:
-		buf = priv_val->buf_cac;
+		buf = priv_val->buf_cac[id];
 		break;
 	case ISP39_MODULE_LDCV:
-		buf = priv_val->buf_ldcv;
+		buf = priv_val->buf_ldcv[id];
 		break;
 	case ISP39_MODULE_LDCH:
 	default:
-		buf = priv_val->buf_ldch;
+		buf = priv_val->buf_ldch[id];
 		break;
 	}
 
@@ -4420,6 +4502,7 @@ static int rkisp_init_mesh_buf(struct rkisp_isp_params_vdev *params_vdev,
 	u32 mesh_h = meshsize->meas_height;
 	u32 mesh_size, buf_size;
 	int i, ret, buf_cnt = meshsize->buf_cnt;
+	int id = meshsize->unite_isp_id;
 	bool is_alloc;
 
 	priv_val = params_vdev->priv_val;
@@ -4430,23 +4513,23 @@ static int rkisp_init_mesh_buf(struct rkisp_isp_params_vdev *params_vdev,
 
 	switch (meshsize->module_id) {
 	case ISP39_MODULE_CAC:
-		priv_val->buf_cac_idx = 0;
-		buf = priv_val->buf_cac;
+		priv_val->buf_cac_idx[id] = 0;
+		buf = priv_val->buf_cac[id];
 		mesh_w = (mesh_w + 62) / 64 * 9;
 		mesh_h = (mesh_h + 62) / 64 * 2;
 		mesh_size = mesh_w * 4 * mesh_h;
 		break;
 	case ISP39_MODULE_LDCV:
-		priv_val->buf_ldcv_idx = 0;
-		buf = priv_val->buf_ldcv;
+		priv_val->buf_ldcv_idx[id] = 0;
+		buf = priv_val->buf_ldcv[id];
 		mesh_w = (((mesh_w + 15) / 16 + 1) + 1) / 2 * 2;
 		mesh_h = (mesh_h + 7) / 8 + 1;
 		mesh_size = (mesh_w * mesh_h + 3) / 4 * 4 * 2;
 		break;
 	case ISP39_MODULE_LDCH:
 	default:
-		priv_val->buf_ldch_idx = 0;
-		buf = priv_val->buf_ldch;
+		priv_val->buf_ldch_idx[id] = 0;
+		buf = priv_val->buf_ldch[id];
 		mesh_w = ((mesh_w + 15) / 16 + 2) / 2;
 		mesh_h = (mesh_h + 7) / 8 + 1;
 		mesh_size = mesh_w * 4 * mesh_h;
@@ -4487,7 +4570,7 @@ static int rkisp_init_mesh_buf(struct rkisp_isp_params_vdev *params_vdev,
 
 	return 0;
 err:
-	rkisp_deinit_mesh_buf(params_vdev, meshsize->module_id);
+	rkisp_deinit_mesh_buf(params_vdev, meshsize->module_id, id);
 	return -ENOMEM;
 }
 
@@ -4495,7 +4578,10 @@ static void
 rkisp_get_param_size_v39(struct rkisp_isp_params_vdev *params_vdev,
 			 unsigned int sizes[])
 {
-	sizes[0] = sizeof(struct isp39_isp_params_cfg);
+	u32 mult = params_vdev->dev->unite_div;
+
+	sizes[0] = sizeof(struct isp39_isp_params_cfg) * mult;
+	params_vdev->vdev_fmt.fmt.meta.buffersize = sizes[0];
 }
 
 static void
@@ -4505,22 +4591,22 @@ rkisp_params_get_meshbuf_inf_v39(struct rkisp_isp_params_vdev *params_vdev,
 	struct rkisp_isp_params_val_v39 *priv_val;
 	struct rkisp_meshbuf_info *meshbuf = meshbuf_inf;
 	struct rkisp_dummy_buffer *buf;
-	int i;
+	int i, id = meshbuf->unite_isp_id;
 
 	priv_val = params_vdev->priv_val;
 	switch (meshbuf->module_id) {
 	case ISP39_MODULE_CAC:
-		priv_val->buf_cac_idx = 0;
-		buf = priv_val->buf_cac;
+		priv_val->buf_cac_idx[id] = 0;
+		buf = priv_val->buf_cac[id];
 		break;
 	case ISP39_MODULE_LDCV:
-		priv_val->buf_ldcv_idx = 0;
-		buf = priv_val->buf_ldcv;
+		priv_val->buf_ldcv_idx[id] = 0;
+		buf = priv_val->buf_ldcv[id];
 		break;
 	case ISP39_MODULE_LDCH:
 	default:
-		priv_val->buf_ldch_idx = 0;
-		buf = priv_val->buf_ldch;
+		priv_val->buf_ldch_idx[id] = 0;
+		buf = priv_val->buf_ldch[id];
 		break;
 	}
 
@@ -4542,6 +4628,8 @@ rkisp_params_set_meshbuf_size_v39(struct rkisp_isp_params_vdev *params_vdev,
 {
 	struct rkisp_meshbuf_size *meshsize = size;
 
+	if (!params_vdev->dev->hw_dev->unite)
+		meshsize->unite_isp_id = 0;
 	return rkisp_init_mesh_buf(params_vdev, meshsize);
 }
 
@@ -4549,7 +4637,10 @@ static void
 rkisp_params_free_meshbuf_v39(struct rkisp_isp_params_vdev *params_vdev,
 			      u64 module_id)
 {
-	rkisp_deinit_mesh_buf(params_vdev, module_id);
+	int id;
+
+	for (id = 0; id < params_vdev->dev->unite_div; id++)
+		rkisp_deinit_mesh_buf(params_vdev, module_id, id);
 }
 
 static int
@@ -4646,9 +4737,9 @@ rkisp_params_info2ddr_cfg_v39(struct rkisp_isp_params_vdev *params_vdev, void *a
 		cfg->buf_fd[i] = buf->dma_fd;
 	}
 	buf = &priv_val->buf_info[0];
-	isp3_param_write(params_vdev, buf->dma_addr, ISP3X_MI_GAIN_WR_BASE);
-	isp3_param_write(params_vdev, buf->size, ISP3X_MI_GAIN_WR_SIZE);
-	isp3_param_write(params_vdev, wsize, ISP3X_MI_GAIN_WR_LENGTH);
+	isp3_param_write(params_vdev, buf->dma_addr, ISP3X_MI_GAIN_WR_BASE, 0);
+	isp3_param_write(params_vdev, buf->size, ISP3X_MI_GAIN_WR_SIZE, 0);
+	isp3_param_write(params_vdev, wsize, ISP3X_MI_GAIN_WR_LENGTH, 0);
 	if (dev->hw_dev->is_single)
 		rkisp_write(dev, ISP3X_MI_WR_CTRL2, ISP3X_GAINSELF_UPD, true);
 	rkisp_set_reg_cache_bits(dev, reg, mask, ctrl);
@@ -4696,17 +4787,19 @@ rkisp_params_stream_stop_v39(struct rkisp_isp_params_vdev *params_vdev)
 {
 	struct rkisp_device *ispdev = params_vdev->dev;
 	struct rkisp_isp_params_val_v39 *priv_val;
-	int i;
+	int i, id;
 
 	priv_val = (struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
 	rkisp_free_buffer(ispdev, &priv_val->buf_frm);
 	rkisp_free_buffer(ispdev, &priv_val->buf_gain);
 	rkisp_free_buffer(ispdev, &priv_val->buf_3dnr_iir);
 	rkisp_free_buffer(ispdev, &priv_val->buf_3dnr_cur);
-	for (i = 0; i < ISP39_3DLUT_BUF_NUM; i++)
-		rkisp_free_buffer(ispdev, &priv_val->buf_3dlut[i]);
 	for (i = 0; i < RKISP_STATS_DDR_BUF_NUM; i++)
 		rkisp_free_buffer(ispdev, &ispdev->stats_vdev.stats_buf[i]);
+	for (id = 0; id < ispdev->unite_div; id++) {
+		for (i = 0; i < ISP39_3DLUT_BUF_NUM; i++)
+			rkisp_free_buffer(ispdev, &priv_val->buf_3dlut[id][i]);
+	}
 	priv_val->buf_info_owner = 0;
 	priv_val->buf_info_cnt = 0;
 	priv_val->buf_info_idx = -1;
@@ -4717,25 +4810,33 @@ rkisp_params_stream_stop_v39(struct rkisp_isp_params_vdev *params_vdev)
 static void
 rkisp_params_fop_release_v39(struct rkisp_isp_params_vdev *params_vdev)
 {
-	rkisp_deinit_mesh_buf(params_vdev, ISP39_MODULE_LDCH);
-	rkisp_deinit_mesh_buf(params_vdev, ISP39_MODULE_LDCV);
-	rkisp_deinit_mesh_buf(params_vdev, ISP39_MODULE_CAC);
+	int id;
+
+	for (id = 0; id < params_vdev->dev->unite_div; id++) {
+		rkisp_deinit_mesh_buf(params_vdev, ISP39_MODULE_LDCH, id);
+		rkisp_deinit_mesh_buf(params_vdev, ISP39_MODULE_LDCV, id);
+		rkisp_deinit_mesh_buf(params_vdev, ISP39_MODULE_CAC, id);
+	}
 }
 
 /* Not called when the camera active, thus not isr protection. */
 static void
 rkisp_params_disable_isp_v39(struct rkisp_isp_params_vdev *params_vdev)
 {
+	int i;
+
 	params_vdev->isp39_params->module_ens = 0;
 	params_vdev->isp39_params->module_en_update = 0x7ffffffffff;
 
-	__isp_isr_other_en(params_vdev, params_vdev->isp39_params, RKISP_PARAMS_ALL);
-	__isp_isr_meas_en(params_vdev, params_vdev->isp39_params, RKISP_PARAMS_ALL);
+	for (i = 0; i < params_vdev->dev->unite_div; i++) {
+		__isp_isr_other_en(params_vdev, params_vdev->isp39_params, RKISP_PARAMS_ALL, i);
+		__isp_isr_meas_en(params_vdev, params_vdev->isp39_params, RKISP_PARAMS_ALL, i);
+	}
 }
 
 static void
 module_data_abandon(struct rkisp_isp_params_vdev *params_vdev,
-		    struct isp39_isp_params_cfg *params)
+		    struct isp39_isp_params_cfg *params, u32 id)
 {
 	struct rkisp_isp_params_val_v39 *priv_val;
 	struct isp2x_mesh_head *mesh_head;
@@ -4746,9 +4847,9 @@ module_data_abandon(struct rkisp_isp_params_vdev *params_vdev,
 		const struct isp39_ldch_cfg *arg = &params->others.ldch_cfg;
 
 		for (i = 0; i < ISP39_MESH_BUF_NUM; i++) {
-			if (priv_val->buf_ldch[i].vaddr &&
-			    arg->buf_fd == priv_val->buf_ldch[i].dma_fd) {
-				mesh_head = (struct isp2x_mesh_head *)priv_val->buf_ldch[i].vaddr;
+			if (priv_val->buf_ldch[id][i].vaddr &&
+			    arg->buf_fd == priv_val->buf_ldch[id][i].dma_fd) {
+				mesh_head = priv_val->buf_ldch[id][i].vaddr;
 				mesh_head->stat = MESH_BUF_CHIPINUSE;
 				break;
 			}
@@ -4759,9 +4860,9 @@ module_data_abandon(struct rkisp_isp_params_vdev *params_vdev,
 		const struct isp39_ldcv_cfg *arg = &params->others.ldcv_cfg;
 
 		for (i = 0; i < ISP39_MESH_BUF_NUM; i++) {
-			if (priv_val->buf_ldcv[i].vaddr &&
-			    arg->buf_fd == priv_val->buf_ldcv[i].dma_fd) {
-				mesh_head = (struct isp2x_mesh_head *)priv_val->buf_ldcv[i].vaddr;
+			if (priv_val->buf_ldcv[id][i].vaddr &&
+			    arg->buf_fd == priv_val->buf_ldcv[id][i].dma_fd) {
+				mesh_head = priv_val->buf_ldcv[id][i].vaddr;
 				mesh_head->stat = MESH_BUF_CHIPINUSE;
 				break;
 			}
@@ -4772,9 +4873,9 @@ module_data_abandon(struct rkisp_isp_params_vdev *params_vdev,
 		const struct isp32_cac_cfg *arg = &params->others.cac_cfg;
 
 		for (i = 0; i < ISP39_MESH_BUF_NUM; i++) {
-			if (priv_val->buf_cac[i].vaddr &&
-			    arg->buf_fd == priv_val->buf_cac[i].dma_fd) {
-				mesh_head = (struct isp2x_mesh_head *)priv_val->buf_cac[i].vaddr;
+			if (priv_val->buf_cac[id][i].vaddr &&
+			    arg->buf_fd == priv_val->buf_cac[id][i].dma_fd) {
+				mesh_head = priv_val->buf_cac[id][i].vaddr;
 				mesh_head->stat = MESH_BUF_CHIPINUSE;
 				break;
 			}
@@ -4786,10 +4887,10 @@ static void
 rkisp_params_cfg_v39(struct rkisp_isp_params_vdev *params_vdev,
 		     u32 frame_id, enum rkisp_params_type type)
 {
+	struct rkisp_device *dev = params_vdev->dev;
 	struct isp39_isp_params_cfg *new_params = NULL;
 	struct rkisp_buffer *cur_buf = params_vdev->cur_buf;
-	struct rkisp_device *dev = params_vdev->dev;
-	struct rkisp_hw_dev *hw_dev = dev->hw_dev;
+	int i;
 
 	spin_lock(&params_vdev->config_lock);
 	if (!params_vdev->streamon)
@@ -4805,18 +4906,24 @@ rkisp_params_cfg_v39(struct rkisp_isp_params_vdev *params_vdev,
 			list_del(&cur_buf->queue);
 			if (list_empty(&params_vdev->params))
 				break;
-			else if (new_params->module_en_update ||
-				 (new_params->module_cfg_update & ISP39_MODULE_FORCE)) {
+			for (i = 0; i < dev->unite_div; i++) {
 				/* update en immediately */
-				__isp_isr_meas_config(params_vdev, new_params, RKISP_PARAMS_ALL);
-				__isp_isr_other_config(params_vdev, new_params, RKISP_PARAMS_ALL);
-				__isp_isr_other_en(params_vdev, new_params, RKISP_PARAMS_ALL);
-				__isp_isr_meas_en(params_vdev, new_params, RKISP_PARAMS_ALL);
-				new_params->module_cfg_update = 0;
-			}
-			if (new_params->module_cfg_update &
-			    (ISP39_MODULE_LDCH | ISP39_MODULE_CAC | ISP39_MODULE_LDCV)) {
-				module_data_abandon(params_vdev, new_params);
+				if (new_params->module_en_update ||
+				    (new_params->module_cfg_update & ISP39_MODULE_FORCE)) {
+					__isp_isr_meas_config(params_vdev,
+							      new_params, RKISP_PARAMS_ALL, i);
+					__isp_isr_other_config(params_vdev,
+							       new_params, RKISP_PARAMS_ALL, i);
+					__isp_isr_other_en(params_vdev,
+							   new_params, RKISP_PARAMS_ALL, i);
+					__isp_isr_meas_en(params_vdev,
+							  new_params, RKISP_PARAMS_ALL, i);
+					new_params->module_cfg_update = 0;
+				}
+				if (new_params->module_cfg_update &
+				    (ISP39_MODULE_LDCH | ISP39_MODULE_CAC | ISP39_MODULE_LDCV))
+					module_data_abandon(params_vdev, new_params, i);
+				new_params++;
 			}
 			vb2_buffer_done(&cur_buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
 			cur_buf = NULL;
@@ -4833,22 +4940,16 @@ rkisp_params_cfg_v39(struct rkisp_isp_params_vdev *params_vdev,
 		goto unlock;
 
 	new_params = (struct isp39_isp_params_cfg *)(cur_buf->vaddr[0]);
-	__isp_isr_meas_config(params_vdev, new_params, type);
-	__isp_isr_other_config(params_vdev, new_params, type);
-	__isp_isr_other_en(params_vdev, new_params, type);
-	__isp_isr_meas_en(params_vdev, new_params, type);
-	if (!hw_dev->is_single && type != RKISP_PARAMS_SHD)
-		__isp_config_hdrshd(params_vdev);
-
+	for (i = 0; i < dev->unite_div; i++) {
+		__isp_isr_meas_config(params_vdev, new_params, type, i);
+		__isp_isr_other_config(params_vdev, new_params, type, i);
+		__isp_isr_other_en(params_vdev, new_params, type, i);
+		__isp_isr_meas_en(params_vdev, new_params, type, i);
+		if (type != RKISP_PARAMS_IMD)
+			new_params->module_cfg_update = 0;
+		new_params++;
+	}
 	if (type != RKISP_PARAMS_IMD) {
-		struct rkisp_isp_params_val_v39 *priv_val =
-			(struct rkisp_isp_params_val_v39 *)params_vdev->priv_val;
-
-		priv_val->last_hdrmge = priv_val->cur_hdrmge;
-		priv_val->last_hdrdrc = priv_val->cur_hdrdrc;
-		priv_val->cur_hdrmge = new_params->others.hdrmge_cfg;
-		priv_val->cur_hdrdrc = new_params->others.drc_cfg;
-		new_params->module_cfg_update = 0;
 		vb2_buffer_done(&cur_buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
 		cur_buf = NULL;
 	}
@@ -4861,14 +4962,15 @@ unlock:
 static void
 rkisp_params_clear_fstflg(struct rkisp_isp_params_vdev *params_vdev)
 {
-	u32 value = isp3_param_read(params_vdev, ISP3X_ISP_CTRL1);
+	u32 value = isp3_param_read(params_vdev, ISP3X_ISP_CTRL1, 0);
+	int i;
 
 	value &= (ISP3X_YNR_FST_FRAME | ISP3X_ADRC_FST_FRAME |
 		  ISP3X_DHAZ_FST_FRAME | ISP3X_CNR_FST_FRAME |
 		  ISP3X_RAW3D_FST_FRAME | ISP39_YUVME_FST_FRAME |
 		  ISP32_SHP_FST_FRAME);
-	if (value)
-		isp3_param_clear_bits(params_vdev, ISP3X_ISP_CTRL1, value);
+	for (i = 0; i < params_vdev->dev->unite_div && value; i++)
+		isp3_param_clear_bits(params_vdev, ISP3X_ISP_CTRL1, value, i);
 }
 
 static void
@@ -4926,6 +5028,8 @@ int rkisp_init_params_vdev_v39(struct rkisp_isp_params_vdev *params_vdev)
 		return -ENOMEM;
 
 	size = sizeof(struct isp39_isp_params_cfg);
+	if (params_vdev->dev->hw_dev->unite)
+		size *= ISP_UNITE_MAX;
 	params_vdev->isp39_params = vmalloc(size);
 	if (!params_vdev->isp39_params) {
 		kfree(priv_val);
diff --git a/drivers/media/platform/rockchip/isp/isp_params_v39.h b/drivers/media/platform/rockchip/isp/isp_params_v39.h
index cb6edbeee5ae..7b76d9a5f064 100644
--- a/drivers/media/platform/rockchip/isp/isp_params_v39.h
+++ b/drivers/media/platform/rockchip/isp/isp_params_v39.h
@@ -22,137 +22,166 @@
 struct rkisp_isp_params_vdev;
 struct rkisp_isp_params_ops_v39 {
 	void (*dpcc_config)(struct rkisp_isp_params_vdev *params_vdev,
-			    const struct isp2x_dpcc_cfg *arg);
-	void (*dpcc_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			    const struct isp2x_dpcc_cfg *arg, u32 id);
+	void (*dpcc_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			    bool en, u32 id);
 	void (*bls_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp32_bls_cfg *arg);
-	void (*bls_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			   const struct isp32_bls_cfg *arg, u32 id);
+	void (*bls_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			   bool en, u32 id);
 	void (*sdg_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp2x_sdg_cfg *arg);
-	void (*sdg_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			   const struct isp2x_sdg_cfg *arg, u32 id);
+	void (*sdg_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			   bool en, u32 id);
 	void (*lsc_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp3x_lsc_cfg *arg);
-	void (*lsc_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			   const struct isp3x_lsc_cfg *arg, u32 id);
+	void (*lsc_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			   bool en, u32 id);
 	void (*awbgain_config)(struct rkisp_isp_params_vdev *params_vdev,
-			       const struct isp32_awb_gain_cfg *arg);
-	void (*awbgain_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			       const struct isp32_awb_gain_cfg *arg, u32 id);
+	void (*awbgain_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			       bool en, u32 id);
 	void (*debayer_config)(struct rkisp_isp_params_vdev *params_vdev,
-			       const struct isp39_debayer_cfg *arg);
-	void (*debayer_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			       const struct isp39_debayer_cfg *arg, u32 id);
+	void (*debayer_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			       bool en, u32 id);
 	void (*ccm_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp39_ccm_cfg *arg);
-	void (*ccm_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			   const struct isp39_ccm_cfg *arg,  u32 id);
+	void (*ccm_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			   bool en, u32 id);
 	void (*goc_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp3x_gammaout_cfg *arg);
-	void (*goc_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			   const struct isp3x_gammaout_cfg *arg,  u32 id);
+	void (*goc_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			   bool en, u32 id);
 	void (*cproc_config)(struct rkisp_isp_params_vdev *params_vdev,
-			     const struct isp2x_cproc_cfg *arg);
-	void (*cproc_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			     const struct isp2x_cproc_cfg *arg, u32 id);
+	void (*cproc_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			     bool en, u32 id);
 	void (*rawaf_config)(struct rkisp_isp_params_vdev *params_vdev,
-			     const struct isp39_rawaf_meas_cfg *arg);
-	void (*rawaf_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			     const struct isp39_rawaf_meas_cfg *arg, u32 id);
+	void (*rawaf_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			     bool en, u32 id);
 	void (*rawae0_config)(struct rkisp_isp_params_vdev *params_vdev,
-			      const struct isp2x_rawaebig_meas_cfg *arg);
-	void (*rawae0_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			      const struct isp2x_rawaebig_meas_cfg *arg, u32 id);
+	void (*rawae0_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			      bool en, u32 id);
 	void (*rawae3_config)(struct rkisp_isp_params_vdev *params_vdev,
-			      const struct isp2x_rawaebig_meas_cfg *arg);
-	void (*rawae3_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			      const struct isp2x_rawaebig_meas_cfg *arg, u32 id);
+	void (*rawae3_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			      bool en, u32 id);
 	void (*rawawb_config)(struct rkisp_isp_params_vdev *params_vdev,
-			      const struct isp39_rawawb_meas_cfg *arg);
-	void (*rawawb_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			      const struct isp39_rawawb_meas_cfg *arg, u32 id);
+	void (*rawawb_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			      bool en, u32 id);
 	void (*rawhst0_config)(struct rkisp_isp_params_vdev *params_vdev,
-			       const struct isp2x_rawhistbig_cfg *arg);
-	void (*rawhst0_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			       const struct isp2x_rawhistbig_cfg *arg, u32 id);
+	void (*rawhst0_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			       bool en, u32 id);
 	void (*rawhst3_config)(struct rkisp_isp_params_vdev *params_vdev,
-			       const struct isp2x_rawhistbig_cfg *arg);
-	void (*rawhst3_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			       const struct isp2x_rawhistbig_cfg *arg, u32 id);
+	void (*rawhst3_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			       bool en, u32 id);
 	void (*hdrdrc_config)(struct rkisp_isp_params_vdev *params_vdev,
 			      const struct isp39_drc_cfg *arg,
-			      enum rkisp_params_type type);
-	void (*hdrdrc_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			      enum rkisp_params_type type, u32 id);
+	void (*hdrdrc_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			      bool en, u32 id);
 	void (*hdrmge_config)(struct rkisp_isp_params_vdev *params_vdev,
 			      const struct isp32_hdrmge_cfg *arg,
-			      enum rkisp_params_type type);
-	void (*hdrmge_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			      enum rkisp_params_type type, u32 id);
+	void (*hdrmge_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			      bool en, u32 id);
 	void (*gic_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp21_gic_cfg *arg);
-	void (*gic_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			   const struct isp21_gic_cfg *arg, u32 id);
+	void (*gic_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			   bool en, u32 id);
 	void (*dhaz_config)(struct rkisp_isp_params_vdev *params_vdev,
-			    const struct isp39_dhaz_cfg *arg);
-	void (*dhaz_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			    const struct isp39_dhaz_cfg *arg, u32 id);
+	void (*dhaz_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			    bool en, u32 id);
 	void (*isp3dlut_config)(struct rkisp_isp_params_vdev *params_vdev,
-				const struct isp2x_3dlut_cfg *arg);
-	void (*isp3dlut_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+				const struct isp2x_3dlut_cfg *arg, u32 id);
+	void (*isp3dlut_enable)(struct rkisp_isp_params_vdev *params_vdev,
+				bool en, u32 id);
 	void (*ldch_config)(struct rkisp_isp_params_vdev *params_vdev,
-			    const struct isp39_ldch_cfg *arg);
-	void (*ldch_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			    const struct isp39_ldch_cfg *arg, u32 id);
+	void (*ldch_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			    bool en, u32 id);
 	void (*ynr_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp39_ynr_cfg *arg);
-	void (*ynr_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			   const struct isp39_ynr_cfg *arg, u32 id);
+	void (*ynr_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			   bool en, u32 id);
 	void (*cnr_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp39_cnr_cfg *arg);
-	void (*cnr_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			   const struct isp39_cnr_cfg *arg, u32 id);
+	void (*cnr_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			   bool en, u32 id);
 	void (*sharp_config)(struct rkisp_isp_params_vdev *params_vdev,
-			     const struct isp39_sharp_cfg *arg);
-	void (*sharp_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			     const struct isp39_sharp_cfg *arg, u32 id);
+	void (*sharp_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			     bool en, u32 id);
 	void (*bay3d_config)(struct rkisp_isp_params_vdev *params_vdev,
-			     const struct isp39_bay3d_cfg *arg);
-	void (*bay3d_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			     const struct isp39_bay3d_cfg *arg, u32 id);
+	void (*bay3d_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			     bool en, u32 id);
 	void (*gain_config)(struct rkisp_isp_params_vdev *params_vdev,
-			    const struct isp3x_gain_cfg *arg);
-	void (*gain_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			    const struct isp3x_gain_cfg *arg, u32 id);
+	void (*gain_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			    bool en, u32 id);
 	void (*cac_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp32_cac_cfg *arg);
-	void (*cac_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			   const struct isp32_cac_cfg *arg, u32 id);
+	void (*cac_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			   bool en, u32 id);
 	void (*csm_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp21_csm_cfg *arg);
+			   const struct isp21_csm_cfg *arg, u32 id);
 	void (*cgc_config)(struct rkisp_isp_params_vdev *params_vdev,
-			   const struct isp21_cgc_cfg *arg);
-	void (*ie_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			   const struct isp21_cgc_cfg *arg, u32 id);
+	void (*ie_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			  bool en, u32 id);
 	void (*yuvme_config)(struct rkisp_isp_params_vdev *params_vdev,
-			     const struct isp39_yuvme_cfg *arg);
-	void (*yuvme_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			     const struct isp39_yuvme_cfg *arg, u32 id);
+	void (*yuvme_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			     bool en, u32 id);
 	void (*ldcv_config)(struct rkisp_isp_params_vdev *params_vdev,
-			    const struct isp39_ldcv_cfg *arg);
-	void (*ldcv_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			    const struct isp39_ldcv_cfg *arg, u32 id);
+	void (*ldcv_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			    bool en, u32 id);
 	void (*rgbir_config)(struct rkisp_isp_params_vdev *params_vdev,
-			     const struct isp39_rgbir_cfg *arg);
-	void (*rgbir_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
+			     const struct isp39_rgbir_cfg *arg, u32 id);
+	void (*rgbir_enable)(struct rkisp_isp_params_vdev *params_vdev,
+			     bool en, u32 id);
 };
 
 struct rkisp_isp_params_val_v39 {
 	struct tasklet_struct lsc_tasklet;
 
-	struct rkisp_dummy_buffer buf_3dlut[ISP39_3DLUT_BUF_NUM];
-	u32 buf_3dlut_idx;
+	struct rkisp_dummy_buffer buf_3dlut[ISP_UNITE_MAX][ISP39_3DLUT_BUF_NUM];
+	u32 buf_3dlut_idx[ISP_UNITE_MAX];
 
-	struct rkisp_dummy_buffer buf_ldch[ISP39_MESH_BUF_NUM];
-	u32 buf_ldch_idx;
+	struct rkisp_dummy_buffer buf_ldch[ISP_UNITE_MAX][ISP39_MESH_BUF_NUM];
+	u32 buf_ldch_idx[ISP_UNITE_MAX];
 	u32 ldch_out_hsize;
 
-	struct rkisp_dummy_buffer buf_ldcv[ISP39_MESH_BUF_NUM];
-	u32 buf_ldcv_idx;
+	struct rkisp_dummy_buffer buf_ldcv[ISP_UNITE_MAX][ISP39_MESH_BUF_NUM];
+	u32 buf_ldcv_idx[ISP_UNITE_MAX];
 	u32 ldcv_out_vsize;
 
-	struct rkisp_dummy_buffer buf_cac[ISP39_MESH_BUF_NUM];
-	u32 buf_cac_idx;
+	struct rkisp_dummy_buffer buf_cac[ISP_UNITE_MAX][ISP39_MESH_BUF_NUM];
+	u32 buf_cac_idx[ISP_UNITE_MAX];
 
 	struct rkisp_dummy_buffer buf_info[RKISP_INFO2DDR_BUF_MAX];
 	u32 buf_info_owner;
 	u32 buf_info_cnt;
 	int buf_info_idx;
 
+	u32 gain_size;
+	u32 bay3d_iir_size;
+	u32 bay3d_cur_size;
 	struct rkisp_dummy_buffer buf_gain;
 	struct rkisp_dummy_buffer buf_3dnr_iir;
 	struct rkisp_dummy_buffer buf_3dnr_cur;
 
 	struct rkisp_dummy_buffer buf_frm;
 
-	struct isp32_hdrmge_cfg last_hdrmge;
-	struct isp32_hdrmge_cfg cur_hdrmge;
-	struct isp39_drc_cfg last_hdrdrc;
-	struct isp39_drc_cfg cur_hdrdrc;
-
 	u32 dhaz_blk_num;
 
 	bool dhaz_en;
diff --git a/drivers/media/platform/rockchip/isp/isp_stats_v39.c b/drivers/media/platform/rockchip/isp/isp_stats_v39.c
index 3e3555dacb1c..c164f96244f8 100644
--- a/drivers/media/platform/rockchip/isp/isp_stats_v39.c
+++ b/drivers/media/platform/rockchip/isp/isp_stats_v39.c
@@ -111,8 +111,9 @@ rkisp_stats_update_buf(struct rkisp_isp_stats_vdev *stats_vdev)
 	struct rkisp_device *dev = stats_vdev->dev;
 	struct rkisp_buffer *buf;
 	unsigned long flags;
+	u32 size = stats_vdev->vdev_fmt.fmt.meta.buffersize / dev->unite_div;
 	u32 val, addr = 0, offset = 0;
-	int ret = 0;
+	int i, ret = 0;
 
 	spin_lock_irqsave(&stats_vdev->rd_lock, flags);
 	if (!stats_vdev->nxt_buf && !list_empty(&stats_vdev->stat)) {
@@ -125,44 +126,34 @@ rkisp_stats_update_buf(struct rkisp_isp_stats_vdev *stats_vdev)
 
 	if (stats_vdev->nxt_buf) {
 		addr = stats_vdev->nxt_buf->buff_addr[0];
-		val = stats_vdev->nxt_buf->buff_addr[0];
-		rkisp_write(dev, ISP39_W3A_AEBIG_ADDR, val, false);
-
-		offset = sizeof(struct isp39_rawae_stat) + sizeof(struct isp39_rawhist_stat);
-		val += offset;
-		rkisp_write(dev, ISP39_W3A_AE0_ADDR, val, false);
-
-		val += offset;
-		rkisp_write(dev, ISP39_W3A_AF_ADDR, val, false);
-
-		offset = sizeof(struct isp39_rawaf_stat);
-		val += offset;
-		rkisp_write(dev, ISP39_W3A_AWB_ADDR, val, false);
-
 		if (!dev->hw_dev->is_single) {
 			stats_vdev->cur_buf = stats_vdev->nxt_buf;
 			stats_vdev->nxt_buf = NULL;
 		}
 	} else if (stats_vdev->stats_buf[0].mem_priv) {
 		addr = stats_vdev->stats_buf[0].dma_addr;
-		val = stats_vdev->stats_buf[0].dma_addr;
-		rkisp_write(dev, ISP39_W3A_AEBIG_ADDR, val, false);
-
-		offset = sizeof(struct isp39_rawae_stat) + sizeof(struct isp39_rawhist_stat);
-		val += offset;
-		rkisp_write(dev, ISP39_W3A_AE0_ADDR, val, false);
-
-		val += offset;
-		rkisp_write(dev, ISP39_W3A_AF_ADDR, val, false);
-
-		offset = sizeof(struct isp39_rawaf_stat);
-		val += offset;
-		rkisp_write(dev, ISP39_W3A_AWB_ADDR, val, false);
 	} else {
 		ret = -EINVAL;
 	}
 
-	if (addr)
+	if (addr) {
+		for (i = 0; i < dev->unite_div; i++) {
+			val = addr + i * size;
+
+			rkisp_idx_write(dev, ISP39_W3A_AEBIG_ADDR, val, i, false);
+
+			offset = sizeof(struct isp39_rawae_stat) +
+				 sizeof(struct isp39_rawhist_stat);
+			val += offset;
+			rkisp_idx_write(dev, ISP39_W3A_AE0_ADDR, val, i, false);
+
+			val += offset;
+			rkisp_idx_write(dev, ISP39_W3A_AF_ADDR, val, i, false);
+
+			offset = sizeof(struct isp39_rawaf_stat);
+			val += offset;
+			rkisp_idx_write(dev, ISP39_W3A_AWB_ADDR, val, i, false);
+		}
 		v4l2_dbg(4, rkisp_debug, &dev->v4l2_dev,
 			 "%s BASE:0x%x SHD AEBIG:0x%x AE0:0x%x AF:0x%x AWB:0x%x\n",
 			 __func__, addr,
@@ -170,6 +161,7 @@ rkisp_stats_update_buf(struct rkisp_isp_stats_vdev *stats_vdev)
 			 isp3_stats_read(stats_vdev, ISP39_W3A_AE0_ADDR_SHD),
 			 isp3_stats_read(stats_vdev, ISP39_W3A_AF_ADDR_SHD),
 			 isp3_stats_read(stats_vdev, ISP39_W3A_AWB_ADDR_SHD));
+	}
 	return ret;
 }
 
@@ -255,6 +247,7 @@ rkisp_stats_send_meas_v39(struct rkisp_isp_stats_vdev *stats_vdev,
 			  struct rkisp_isp_readout_work *meas_work)
 {
 	struct rkisp_isp_params_vdev *params_vdev = &stats_vdev->dev->params_vdev;
+	struct rkisp_device *dev = stats_vdev->dev;
 	struct rkisp_buffer *cur_buf = stats_vdev->cur_buf;
 	struct rkisp39_stat_buffer *cur_stat_buf = NULL;
 	u32 size = stats_vdev->vdev_fmt.fmt.meta.buffersize;
@@ -271,14 +264,28 @@ rkisp_stats_send_meas_v39(struct rkisp_isp_stats_vdev *stats_vdev,
 		} else if (cur_buf) {
 			cur_stat_buf = cur_buf->vaddr[0];
 		}
-		/* config buf for next frame */
-		stats_vdev->cur_buf = NULL;
-		if (stats_vdev->nxt_buf) {
-			stats_vdev->cur_buf = stats_vdev->nxt_buf;
-			stats_vdev->nxt_buf = NULL;
+
+		/* buffer done when frame of right handle */
+		if (dev->unite_div > ISP_UNITE_DIV1) {
+			if (dev->unite_index == ISP_UNITE_LEFT) {
+				cur_buf = NULL;
+				is_dummy = false;
+			} else if (cur_stat_buf) {
+				cur_stat_buf = (void *)cur_stat_buf + size / dev->unite_div;
+				cur_stat_buf->frame_id = cur_frame_id;
+				cur_stat_buf->params_id = params_vdev->cur_frame_id;
+			}
+		}
+
+		if (dev->unite_div < ISP_UNITE_DIV2 || dev->unite_index == ISP_UNITE_RIGHT) {
+			/* config buf for next frame */
+			stats_vdev->cur_buf = NULL;
+			if (stats_vdev->nxt_buf) {
+				stats_vdev->cur_buf = stats_vdev->nxt_buf;
+				stats_vdev->nxt_buf = NULL;
+			}
+			rkisp_stats_update_buf(stats_vdev);
 		}
-		rkisp_stats_update_buf(stats_vdev);
-		cur_frame_id = meas_work->frame_id;
 	} else {
 		cur_buf = NULL;
 	}
@@ -395,7 +402,7 @@ void rkisp_stats_first_ddr_config_v39(struct rkisp_isp_stats_vdev *stats_vdev)
 {
 	struct rkisp_device *dev = stats_vdev->dev;
 	struct rkisp_pdaf_vdev *pdaf_vdev = &dev->pdaf_vdev;
-	u32 val, size = 0;
+	u32 val, size = 0, div = dev->unite_div;
 
 	if (!stats_vdev->streamon || dev->isp_sdev.in_fmt.fmt_type == FMT_YUV)
 		return;
@@ -411,7 +418,7 @@ void rkisp_stats_first_ddr_config_v39(struct rkisp_isp_stats_vdev *stats_vdev)
 		v4l2_err(&dev->v4l2_dev, "no stats buf to enable w3a\n");
 		return;
 	}
-	rkisp_set_bits(dev, ISP3X_SWS_CFG, 0, ISP3X_3A_DDR_WRITE_EN, false);
+	rkisp_unite_set_bits(dev, ISP3X_SWS_CFG, 0, ISP3X_3A_DDR_WRITE_EN, false);
 	val = ISP39_W3A_EN | ISP39_W3A_AUTO_CLR_EN | ISP39_W3A_FORCE_UPD;
 	if (pdaf_vdev->streaming) {
 		val |= ISP39_W3A_PDAF_EN;
@@ -421,8 +428,8 @@ void rkisp_stats_first_ddr_config_v39(struct rkisp_isp_stats_vdev *stats_vdev)
 			pdaf_vdev->next_buf = NULL;
 		}
 	}
-	rkisp_write(dev, ISP39_W3A_CTRL0, val, false);
-	rkisp_write(dev, ISP39_W3A_WR_SIZE, size, false);
+	rkisp_unite_write(dev, ISP39_W3A_CTRL0, val, false);
+	rkisp_unite_write(dev, ISP39_W3A_WR_SIZE, size / div, false);
 	if (stats_vdev->nxt_buf) {
 		stats_vdev->cur_buf = stats_vdev->nxt_buf;
 		stats_vdev->nxt_buf = NULL;
diff --git a/drivers/media/platform/rockchip/isp/rkisp.h b/drivers/media/platform/rockchip/isp/rkisp.h
index 1831a52968f7..f024403f091b 100644
--- a/drivers/media/platform/rockchip/isp/rkisp.h
+++ b/drivers/media/platform/rockchip/isp/rkisp.h
@@ -65,6 +65,8 @@
 #define CIF_ISP_INPUT_H_MAX_V32_L_UNITE	6144
 #define CIF_ISP_INPUT_W_MAX_V39		4672
 #define CIF_ISP_INPUT_H_MAX_V39		3504
+#define CIF_ISP_INPUT_W_MAX_V39_UNITE	8192
+#define CIF_ISP_INPUT_H_MAX_V39_UNITE	6144
 #define CIF_ISP_INPUT_W_MIN		272
 #define CIF_ISP_INPUT_H_MIN		272
 #define CIF_ISP_OUTPUT_W_MAX		CIF_ISP_INPUT_W_MAX