~hc/RK356X_SDK_RELEASE.git

..	..	@@ -33,6 +33,7 @@
33	33	*/
34	34
35	35	#include <linux/clk.h>
	36	+#include <linux/compat.h>
36	37	#include <linux/iopoll.h>
37	38	#include <linux/pm_runtime.h>
38	39	#include <linux/regmap.h>
..	..	@@ -42,12 +43,13 @@
42	43	#include <linux/kfifo.h>
43	44	#include <linux/interrupt.h>
44	45	#include <linux/rk-preisp.h>
45		-#include <linux/rkisp21-config.h>
	46	+#include <linux/rk-isp21-config.h>
46	47	#include <linux/iommu.h>
47	48	#include <media/v4l2-event.h>
48	49	#include <media/media-entity.h>
49	50
50	51	#include "common.h"
	52	+#include "isp_external.h"
51	53	#include "regs.h"
52	54	#include "rkisp_tb_helper.h"
53	55
..	..	@@ -82,6 +84,8 @@
82	84	* \| +---------------------------------------------------+ \|
83	85	* +---------------------------------------------------------+
84	86	*/
	87	+
	88	+static void rkisp_config_cmsk(struct rkisp_device *dev);
85	89
86	90	struct backup_reg {
87	91	const u32 base;
..	..	@@ -188,41 +192,51 @@
188	192	u32 code = dev->isp_sdev.in_frm.code;
189	193	u32 src_w = dev->isp_sdev.in_frm.width;
190	194	u32 src_h = dev->isp_sdev.in_frm.height;
191		- u32 dest_w, dest_h, w, h;
	195	+ u32 dest_w, dest_h, w, h, max_size, max_h, max_w;
192	196	int ret = 0;
193	197
194	198	if (!crop)
195	199	return -EINVAL;
196	200
197		- if (dev->isp_ver == ISP_V12) {
198		- w = clamp_t(u32, src_w,
199		- CIF_ISP_INPUT_W_MIN,
200		- CIF_ISP_INPUT_W_MAX_V12);
201		- h = clamp_t(u32, src_h,
202		- CIF_ISP_INPUT_H_MIN,
203		- CIF_ISP_INPUT_H_MAX_V12);
204		- } else if (dev->isp_ver == ISP_V13) {
205		- w = clamp_t(u32, src_w,
206		- CIF_ISP_INPUT_W_MIN,
207		- CIF_ISP_INPUT_W_MAX_V13);
208		- h = clamp_t(u32, src_h,
209		- CIF_ISP_INPUT_H_MIN,
210		- CIF_ISP_INPUT_H_MAX_V13);
211		- } else if (dev->isp_ver == ISP_V21) {
212		- w = clamp_t(u32, src_w,
213		- CIF_ISP_INPUT_W_MIN,
214		- CIF_ISP_INPUT_W_MAX_V21);
215		- h = clamp_t(u32, src_h,
216		- CIF_ISP_INPUT_H_MIN,
217		- CIF_ISP_INPUT_H_MAX_V21);
218		- } else {
219		- w = clamp_t(u32, src_w,
220		- CIF_ISP_INPUT_W_MIN,
221		- CIF_ISP_INPUT_W_MAX);
222		- h = clamp_t(u32, src_h,
223		- CIF_ISP_INPUT_H_MIN,
224		- CIF_ISP_INPUT_H_MAX);
	201	+ memset(&sel, 0, sizeof(sel));
	202	+ switch (dev->isp_ver) {
	203	+ case ISP_V12:
	204	+ max_w = CIF_ISP_INPUT_W_MAX_V12;
	205	+ max_h = CIF_ISP_INPUT_H_MAX_V12;
	206	+ break;
	207	+ case ISP_V13:
	208	+ max_w = CIF_ISP_INPUT_W_MAX_V13;
	209	+ max_h = CIF_ISP_INPUT_H_MAX_V13;
	210	+ break;
	211	+ case ISP_V21:
	212	+ max_w = CIF_ISP_INPUT_W_MAX_V21;
	213	+ max_h = CIF_ISP_INPUT_H_MAX_V21;
	214	+ break;
	215	+ case ISP_V30:
	216	+ if (dev->hw_dev->is_unite) {
	217	+ max_w = CIF_ISP_INPUT_W_MAX_V30_UNITE;
	218	+ max_h = CIF_ISP_INPUT_H_MAX_V30_UNITE;
	219	+ } else {
	220	+ max_w = CIF_ISP_INPUT_W_MAX_V30;
	221	+ max_h = CIF_ISP_INPUT_H_MAX_V30;
	222	+ }
	223	+ break;
	224	+ case ISP_V32:
	225	+ max_w = CIF_ISP_INPUT_W_MAX_V32;
	226	+ max_h = CIF_ISP_INPUT_H_MAX_V32;
	227	+ break;
	228	+ case ISP_V32_L:
	229	+ max_w = CIF_ISP_INPUT_W_MAX_V32_L;
	230	+ max_h = CIF_ISP_INPUT_H_MAX_V32_L;
	231	+ break;
	232	+ default:
	233	+ max_w = CIF_ISP_INPUT_W_MAX;
	234	+ max_h = CIF_ISP_INPUT_H_MAX;
225	235	}
	236	+ max_size = max_w * max_h;
	237	+ w = clamp_t(u32, src_w, CIF_ISP_INPUT_W_MIN, max_w);
	238	+ max_h = max_size / w;
	239	+ h = clamp_t(u32, src_h, CIF_ISP_INPUT_H_MIN, max_h);
226	240
227	241	if (dev->active_sensor)
228	242	sensor = dev->active_sensor->sd;
..	..	@@ -343,35 +357,51 @@
343	357	return -ENODEV;
344	358
345	359	sensor = sd_to_sensor(dev, sensor_sd);
346		- ret = v4l2_subdev_call(sensor->sd, video, g_mbus_config,
347		- &sensor->mbus);
	360	+ if (!sensor)
	361	+ return -ENODEV;
	362	+ ret = v4l2_subdev_call(sensor->sd, pad, get_mbus_config,
	363	+ 0, &sensor->mbus);
348	364	if (ret && ret != -ENOIOCTLCMD)
349	365	return ret;
350	366
351		- if (sensor->mbus.type == V4L2_MBUS_CSI2) {
	367	+ sensor->fmt[0].pad = 0;
	368	+ sensor->fmt[0].which = V4L2_SUBDEV_FORMAT_ACTIVE;
	369	+ ret = v4l2_subdev_call(sensor->sd, pad, get_fmt,
	370	+ &sensor->cfg, &sensor->fmt[0]);
	371	+ if (ret && ret != -ENOIOCTLCMD)
	372	+ return ret;
	373	+
	374	+ if (sensor->mbus.type == V4L2_MBUS_CSI2_DPHY &&
	375	+ dev->isp_ver < ISP_V30) {
352	376	u8 vc = 0;
353	377
354		- memset(dev->csi_dev.mipi_di, 0,
355		- sizeof(dev->csi_dev.mipi_di));
356		- memset(sensor->fmt, 0, sizeof(sensor->fmt));
	378	+ sensor_sd = get_remote_sensor(sensor->sd);
	379	+ if (!sensor_sd)
	380	+ return -ENODEV;
	381	+ memset(dev->csi_dev.mipi_di, 0, sizeof(dev->csi_dev.mipi_di));
357	382	for (i = 0; i < dev->csi_dev.max_pad - 1; i++) {
	383	+ struct rkmodule_channel_info ch = { 0 };
	384	+
358	385	fmt = &sensor->fmt[i];
359		- fmt->pad = i;
360		- fmt->which = V4L2_SUBDEV_FORMAT_ACTIVE;
361		- ret = v4l2_subdev_call(sensor->sd, pad, get_fmt,
362		- &sensor->cfg, fmt);
363		- if (ret && ret != -ENOIOCTLCMD)
364		- return ret;
	386	+ ch.index = i;
	387	+ ret = v4l2_subdev_call(sensor_sd, core, ioctl,
	388	+ RKMODULE_GET_CHANNEL_INFO, &ch);
	389	+ if (ret) {
	390	+ if (i)
	391	+ *fmt = sensor->fmt[0];
	392	+ } else {
	393	+ fmt->format.width = ch.width;
	394	+ fmt->format.height = ch.height;
	395	+ fmt->format.code = ch.bus_fmt;
	396	+ }
365	397	ret = mbus_pixelcode_to_mipi_dt(fmt->format.code);
366	398	if (ret < 0) {
367	399	v4l2_err(&dev->v4l2_dev,
368	400	"Invalid mipi data type\n");
369	401	return ret;
370	402	}
371		- /* v4l2_subdev_format reserved[0]
372		- * using as mipi virtual channel
373		- */
374		- switch (fmt->reserved[0]) {
	403	+
	404	+ switch (ch.vc) {
375	405	case V4L2_MBUS_CSI2_CHANNEL_3:
376	406	vc = 3;
377	407	break;
..	..	@@ -393,18 +423,14 @@
393	423	fmt->format.width,
394	424	fmt->format.height);
395	425	}
396		- } else {
397		- sensor->fmt[0].pad = 0;
398		- sensor->fmt[0].which = V4L2_SUBDEV_FORMAT_ACTIVE;
399		- ret = v4l2_subdev_call(sensor->sd, pad, get_fmt,
400		- &sensor->cfg, &sensor->fmt[0]);
401		- if (ret && ret != -ENOIOCTLCMD)
402		- return ret;
403	426	}
404	427
405	428	v4l2_subdev_call(sensor->sd, video, g_frame_interval, &sensor->fi);
406	429	dev->active_sensor = sensor;
407		-
	430	+ i = dev->dev_id;
	431	+ if (sensor->fi.interval.numerator)
	432	+ dev->hw_dev->isp_size[i].fps =
	433	+ sensor->fi.interval.denominator / sensor->fi.interval.numerator;
408	434	return ret;
409	435	}
410	436
..	..	@@ -471,6 +497,93 @@
471	497	return pixelformat;
472	498	}
473	499
	500	+static void rkisp_dvfs(struct rkisp_device *dev)
	501	+{
	502	+ struct rkisp_hw_dev *hw = dev->hw_dev;
	503	+ u64 data_rate = 0;
	504	+ int i, fps, num = 0;
	505	+
	506	+ if (!hw->is_dvfs)
	507	+ return;
	508	+ hw->is_dvfs = false;
	509	+ for (i = 0; i < hw->dev_num; i++) {
	510	+ if (!hw->isp_size[i].is_on)
	511	+ continue;
	512	+ fps = hw->isp_size[i].fps;
	513	+ if (!fps)
	514	+ fps = 30;
	515	+ data_rate += (fps * hw->isp_size[i].size);
	516	+ num++;
	517	+ }
	518	+ do_div(data_rate, 1000 * 1000);
	519	+ /* increase margin: 25% * num */
	520	+ data_rate += (data_rate >> 2) * num;
	521	+
	522	+ /* compare with isp clock adjustment table */
	523	+ for (i = 0; i < hw->num_clk_rate_tbl; i++)
	524	+ if (data_rate <= hw->clk_rate_tbl[i].clk_rate)
	525	+ break;
	526	+ if (i == hw->num_clk_rate_tbl)
	527	+ i--;
	528	+
	529	+ /* set isp clock rate */
	530	+ rkisp_set_clk_rate(hw->clks[0], hw->clk_rate_tbl[i].clk_rate * 1000000UL);
	531	+ if (hw->is_unite)
	532	+ rkisp_set_clk_rate(hw->clks[5], hw->clk_rate_tbl[i].clk_rate * 1000000UL);
	533	+ /* aclk equal to core clk */
	534	+ if (dev->isp_ver == ISP_V32)
	535	+ rkisp_set_clk_rate(hw->clks[1], hw->clk_rate_tbl[i].clk_rate * 1000000UL);
	536	+ dev_info(hw->dev, "set isp clk = %luHz\n", clk_get_rate(hw->clks[0]));
	537	+}
	538	+
	539	+static void rkisp_multi_overflow_hdl(struct rkisp_device *dev, bool on)
	540	+{
	541	+ struct rkisp_hw_dev *hw = dev->hw_dev;
	542	+
	543	+ if (on) {
	544	+ /* enable bay3d and mi */
	545	+ rkisp_update_regs(dev, ISP3X_MI_WR_CTRL, ISP3X_MI_WR_CTRL);
	546	+ rkisp_update_regs(dev, ISP3X_ISP_CTRL1, ISP3X_ISP_CTRL1);
	547	+ if (dev->isp_ver == ISP_V21) {
	548	+ rkisp_update_regs(dev, ISP21_BAY3D_CTRL, ISP21_BAY3D_CTRL);
	549	+ } else if (dev->isp_ver == ISP_V30) {
	550	+ rkisp_update_regs(dev, ISP3X_MPFBC_CTRL, ISP3X_MPFBC_CTRL);
	551	+ rkisp_update_regs(dev, ISP3X_MI_BP_WR_CTRL, ISP3X_MI_BP_WR_CTRL);
	552	+ rkisp_update_regs(dev, ISP3X_BAY3D_CTRL, ISP3X_BAY3D_CTRL);
	553	+ rkisp_update_regs(dev, ISP3X_SWS_CFG, ISP3X_SWS_CFG);
	554	+ } else if (dev->isp_ver == ISP_V32) {
	555	+ rkisp_update_regs(dev, ISP3X_MI_BP_WR_CTRL, ISP3X_MI_BP_WR_CTRL);
	556	+ rkisp_update_regs(dev, ISP32_MI_BPDS_WR_CTRL, ISP32_MI_BPDS_WR_CTRL);
	557	+ rkisp_update_regs(dev, ISP32_MI_MPDS_WR_CTRL, ISP32_MI_MPDS_WR_CTRL);
	558	+ rkisp_update_regs(dev, ISP3X_BAY3D_CTRL, ISP3X_BAY3D_CTRL);
	559	+ }
	560	+ } else {
	561	+ /* disabled bay3d and mi. rv1106 sdmmc workaround, 3a_wr no close */
	562	+ writel(CIF_MI_CTRL_INIT_OFFSET_EN \| CIF_MI_CTRL_INIT_BASE_EN,
	563	+ hw->base_addr + ISP3X_MI_WR_CTRL);
	564	+ if (dev->isp_ver == ISP_V21) {
	565	+ writel(0, hw->base_addr + ISP21_BAY3D_CTRL);
	566	+ } else if (dev->isp_ver == ISP_V30) {
	567	+ writel(0, hw->base_addr + ISP3X_MPFBC_CTRL);
	568	+ writel(0, hw->base_addr + ISP3X_MI_BP_WR_CTRL);
	569	+ writel(0, hw->base_addr + ISP3X_BAY3D_CTRL);
	570	+ writel(0xc, hw->base_addr + ISP3X_SWS_CFG);
	571	+ if (hw->is_unite) {
	572	+ writel(0, hw->base_next_addr + ISP3X_MI_WR_CTRL);
	573	+ writel(0, hw->base_next_addr + ISP3X_MPFBC_CTRL);
	574	+ writel(0, hw->base_next_addr + ISP3X_MI_BP_WR_CTRL);
	575	+ writel(0, hw->base_next_addr + ISP3X_BAY3D_CTRL);
	576	+ writel(0xc, hw->base_next_addr + ISP3X_SWS_CFG);
	577	+ }
	578	+ } else if (dev->isp_ver == ISP_V32) {
	579	+ writel(0, hw->base_addr + ISP3X_MI_BP_WR_CTRL);
	580	+ writel(0, hw->base_addr + ISP32_MI_BPDS_WR_CTRL);
	581	+ writel(0, hw->base_addr + ISP32_MI_MPDS_WR_CTRL);
	582	+ writel(0, hw->base_addr + ISP3X_BAY3D_CTRL);
	583	+ }
	584	+ }
	585	+ rkisp_unite_write(dev, ISP3X_MI_WR_INIT, CIF_MI_INIT_SOFT_UPD, true, hw->is_unite);
	586	+}
474	587
475	588	/*
476	589	* for hdr read back mode, rawrd read back data
..	..	@@ -479,6 +592,7 @@
479	592	void rkisp_trigger_read_back(struct rkisp_device *dev, u8 dma2frm, u32 mode, bool is_try)
480	593	{
481	594	struct rkisp_isp_params_vdev *params_vdev = &dev->params_vdev;
	595	+ struct rkisp_isp_stats_vdev *stats_vdev = &dev->stats_vdev;
482	596	struct rkisp_hw_dev *hw = dev->hw_dev;
483	597	u32 val, cur_frame_id, tmp, rd_mode;
484	598	u64 iq_feature = hw->iq_feature;
..	..	@@ -488,8 +602,11 @@
488	602	hw->cur_dev_id = dev->dev_id;
489	603	rkisp_dmarx_get_frame(dev, &cur_frame_id, NULL, NULL, true);
490	604
	605	+ if (hw->is_multi_overflow && is_try)
	606	+ goto run_next;
	607	+
491	608	val = 0;
492		- if (mode & T_START_X1) {
	609	+ if (mode & (T_START_X1 \| T_START_C)) {
493	610	rd_mode = HDR_RDBK_FRAME1;
494	611	} else if (mode & T_START_X2) {
495	612	rd_mode = HDR_RDBK_FRAME2;
..	..	@@ -502,6 +619,11 @@
502	619	val = rkisp_read(dev, ISP_HDRMGE_BASE, false) & 0xf;
503	620	}
504	621
	622	+ if (mode & T_START_C)
	623	+ rkisp_expander_config(dev, NULL, true);
	624	+ else
	625	+ rkisp_expander_config(dev, NULL, false);
	626	+
505	627	if (is_feature_on) {
506	628	if ((ISP2X_MODULE_HDRMGE & ~iq_feature) && (val & SW_HDRMGE_EN)) {
507	629	v4l2_err(&dev->v4l2_dev, "hdrmge is not supported\n");
..	..	@@ -509,24 +631,23 @@
509	631	}
510	632	}
511	633
512		- tmp = rkisp_read(dev, ISP_HDRMGE_BASE, false) & 0xf;
513		- if (val != tmp) {
514		- rkisp_write(dev, ISP_HDRMGE_BASE, val, false);
	634	+ if (rd_mode != dev->rd_mode) {
	635	+ rkisp_unite_set_bits(dev, ISP_HDRMGE_BASE, ISP_HDRMGE_MODE_MASK,
	636	+ val, false, hw->is_unite);
515	637	dev->skip_frame = 2;
516	638	is_upd = true;
517	639	}
518	640
519	641	if (dev->isp_ver == ISP_V20 && dev->dmarx_dev.trigger == T_MANUAL && !is_try) {
520		- if (dev->rd_mode != rd_mode && RKMODULE_EXTEND_LINE != 0) {
	642	+ if (dev->rd_mode != rd_mode && dev->br_dev.en) {
521	643	tmp = dev->isp_sdev.in_crop.height;
522	644	val = rkisp_read(dev, CIF_DUAL_CROP_CTRL, false);
523	645	if (rd_mode == HDR_RDBK_FRAME1) {
524		- val \|= CIF_DUAL_CROP_MP_MODE_YUV \| CIF_DUAL_CROP_SP_MODE_YUV;
	646	+ val \|= CIF_DUAL_CROP_MP_MODE_YUV;
525	647	tmp += RKMODULE_EXTEND_LINE;
526	648	} else {
527		- val &= ~(CIF_DUAL_CROP_MP_MODE_YUV \| CIF_DUAL_CROP_SP_MODE_YUV);
	649	+ val &= ~CIF_DUAL_CROP_MP_MODE_YUV;
528	650	}
529		- val \|= CIF_DUAL_CROP_CFG_UPD;
530	651	rkisp_write(dev, CIF_DUAL_CROP_CTRL, val, false);
531	652	rkisp_write(dev, CIF_ISP_ACQ_V_SIZE, tmp, false);
532	653	rkisp_write(dev, CIF_ISP_OUT_V_SIZE, tmp, false);
..	..	@@ -541,16 +662,32 @@
541	662	rkisp_params_first_cfg(&dev->params_vdev, &dev->isp_sdev.in_fmt,
542	663	dev->isp_sdev.quantization);
543	664	rkisp_params_cfg(params_vdev, cur_frame_id);
544		-
	665	+ rkisp_config_cmsk(dev);
	666	+ rkisp_stream_frame_start(dev, 0);
545	667	if (!hw->is_single && !is_try) {
	668	+ /* multi sensor need to reset isp resize mode if scale up */
	669	+ val = 0;
	670	+ if (rkisp_read(dev, ISP3X_MAIN_RESIZE_CTRL, true) & 0xf0)
	671	+ val \|= BIT(3);
	672	+ if (dev->isp_ver != ISP_V32_L &&
	673	+ rkisp_read(dev, ISP3X_SELF_RESIZE_CTRL, true) & 0xf0)
	674	+ val \|= BIT(4);
	675	+ if (rkisp_read(dev, ISP32_BP_RESIZE_CTRL, true) & 0xf0)
	676	+ val \|= BIT(12);
	677	+ if (val) {
	678	+ writel(val, hw->base_addr + CIF_IRCL);
	679	+ writel(0, hw->base_addr + CIF_IRCL);
	680	+ }
	681	+
546	682	rkisp_update_regs(dev, CTRL_VI_ISP_PATH, SUPER_IMP_COLOR_CR);
547		- rkisp_update_regs(dev, DUAL_CROP_M_H_OFFS, DUAL_CROP_S_V_SIZE);
548		- rkisp_update_regs(dev, ISP_ACQ_PROP, DUAL_CROP_CTRL);
549		- rkisp_update_regs(dev, MAIN_RESIZE_SCALE_HY, MI_WR_CTRL);
550		- rkisp_update_regs(dev, SELF_RESIZE_SCALE_HY, MAIN_RESIZE_CTRL);
551		- rkisp_update_regs(dev, ISP_GAMMA_OUT_CTRL, SELF_RESIZE_CTRL);
	683	+ rkisp_update_regs(dev, DUAL_CROP_M_H_OFFS, ISP3X_DUAL_CROP_FBC_V_SIZE);
	684	+ rkisp_update_regs(dev, ISP_ACQ_H_OFFS, DUAL_CROP_CTRL);
	685	+ rkisp_update_regs(dev, SELF_RESIZE_SCALE_HY, MI_WR_CTRL);
	686	+ rkisp_update_regs(dev, ISP32_BP_RESIZE_SCALE_HY, SELF_RESIZE_CTRL);
	687	+ rkisp_update_regs(dev, MAIN_RESIZE_SCALE_HY, ISP32_BP_RESIZE_CTRL);
	688	+ rkisp_update_regs(dev, ISP_GAMMA_OUT_CTRL, MAIN_RESIZE_CTRL);
552	689	rkisp_update_regs(dev, MI_RD_CTRL2, ISP_LSC_CTRL);
553		- rkisp_update_regs(dev, MI_MP_WR_Y_BASE, MI_MP_WR_Y_LLENGTH);
	690	+ rkisp_update_regs(dev, MI_MP_WR_Y_BASE, MI_WR_CTRL2 - 4);
554	691	rkisp_update_regs(dev, ISP_LSC_XGRAD_01, ISP_RAWAWB_RAM_DATA);
555	692	if (dev->isp_ver == ISP_V20 &&
556	693	(rkisp_read(dev, ISP_DHAZ_CTRL, false) & ISP_DHAZ_ENMUX \|\|
..	..	@@ -560,22 +697,36 @@
560	697	val = rkisp_read(dev, MI_WR_CTRL2, false);
561	698	rkisp_set_bits(dev, MI_WR_CTRL2, 0, val, true);
562	699	rkisp_write(dev, MI_WR_INIT, ISP21_SP_FORCE_UPD \| ISP21_MP_FORCE_UPD, true);
563		- /* sensor mode & index */
	700	+ } else {
	701	+ if (dev->isp_ver == ISP_V32_L)
	702	+ rkisp_write(dev, ISP32_SELF_SCALE_UPDATE, ISP32_SCALE_FORCE_UPD, true);
	703	+ rkisp_unite_write(dev, ISP3X_MI_WR_INIT, CIF_MI_INIT_SOFT_UPD, true, hw->is_unite);
	704	+ }
	705	+ /* sensor mode & index */
	706	+ if (dev->isp_ver >= ISP_V21) {
564	707	val = rkisp_read_reg_cache(dev, ISP_ACQ_H_OFFS);
565		- val \|= ISP21_SENSOR_MODE(hw->dev_num >= 3 ? 2 : hw->dev_num - 1) \|
566		- ISP21_SENSOR_INDEX(dev->dev_id);
	708	+ val \|= ISP21_SENSOR_INDEX(dev->multi_index);
	709	+ if (dev->isp_ver == ISP_V32_L)
	710	+ val \|= ISP32L_SENSOR_MODE(dev->multi_mode);
	711	+ else
	712	+ val \|= ISP21_SENSOR_MODE(dev->multi_mode);
567	713	writel(val, hw->base_addr + ISP_ACQ_H_OFFS);
	714	+ if (hw->is_unite)
	715	+ writel(val, hw->base_next_addr + ISP_ACQ_H_OFFS);
	716	+ v4l2_dbg(2, rkisp_debug, &dev->v4l2_dev,
	717	+ "sensor mode:%d index:%d \| 0x%x\n",
	718	+ dev->multi_mode, dev->multi_index, val);
568	719	}
569	720	is_upd = true;
570	721	}
571	722
572		- if (dev->isp_ver == ISP_V21)
	723	+ if (dev->isp_ver > ISP_V20)
573	724	dma2frm = 0;
574	725	if (dma2frm > 2)
575	726	dma2frm = 2;
576	727	if (dma2frm == 2)
577	728	dev->rdbk_cnt_x3++;
578		- else if (dma2frm == 1)
	729	+ else if (dma2frm == 1 \|\| dev->sw_rd_cnt)
579	730	dev->rdbk_cnt_x2++;
580	731	else
581	732	dev->rdbk_cnt_x1++;
..	..	@@ -584,32 +735,73 @@
584	735	rkisp_params_cfgsram(params_vdev);
585	736	params_vdev->rdbk_times = dma2frm + 1;
586	737
	738	+run_next:
	739	+ if (hw->is_multi_overflow && !dev->is_first_double) {
	740	+ stats_vdev->rdbk_drop = false;
	741	+ if (dev->sw_rd_cnt) {
	742	+ rkisp_multi_overflow_hdl(dev, false);
	743	+ params_vdev->rdbk_times += dev->sw_rd_cnt;
	744	+ stats_vdev->rdbk_drop = true;
	745	+ is_upd = true;
	746	+ } else if (is_try) {
	747	+ rkisp_multi_overflow_hdl(dev, true);
	748	+ is_upd = true;
	749	+ }
	750	+ }
	751	+
587	752	/* read 3d lut at frame end */
588	753	if (hw->is_single && is_upd &&
589	754	rkisp_read_reg_cache(dev, ISP_3DLUT_UPDATE) & 0x1) {
590		- rkisp_write(dev, ISP_3DLUT_UPDATE, 0, true);
	755	+ rkisp_unite_write(dev, ISP_3DLUT_UPDATE, 0, true, hw->is_unite);
591	756	is_3dlut_upd = true;
592	757	}
593	758	if (is_upd) {
594	759	val = rkisp_read(dev, ISP_CTRL, false);
595	760	val \|= CIF_ISP_CTRL_ISP_CFG_UPD;
596		- rkisp_write(dev, ISP_CTRL, val, true);
	761	+ rkisp_unite_write(dev, ISP_CTRL, val, true, hw->is_unite);
	762	+ /* bayer pat after ISP_CFG_UPD for multi sensor to read lsc r/g/b table */
	763	+ rkisp_update_regs(dev, ISP_ACQ_PROP, ISP_ACQ_PROP);
597	764	/* fix ldch multi sensor case:
598	765	* ldch will pre-read data when en and isp force upd or frame end,
599	766	* udelay for ldch pre-read data.
600	767	* ldch en=0 before start for frame end to stop ldch read data.
601	768	*/
602		- if (!hw->is_single &&
603		- (rkisp_read(dev, ISP_LDCH_BASE, true) & 0x1)) {
	769	+ val = rkisp_read(dev, ISP_LDCH_BASE, true);
	770	+ if (!hw->is_single && val & BIT(0)) {
604	771	udelay(50);
605		- writel(0, hw->base_addr + ISP_LDCH_BASE);
	772	+ val &= ~(BIT(0) \| BIT(31));
	773	+ writel(val, hw->base_addr + ISP_LDCH_BASE);
	774	+ if (hw->is_unite)
	775	+ writel(val, hw->base_next_addr + ISP_LDCH_BASE);
606	776	}
607	777	}
608	778	if (is_3dlut_upd)
609		- rkisp_write(dev, ISP_3DLUT_UPDATE, 1, true);
	779	+ rkisp_unite_write(dev, ISP_3DLUT_UPDATE, 1, true, hw->is_unite);
610	780
611		- memset(dev->filt_state, 0, sizeof(dev->filt_state));
612		- dev->filt_state[RDBK_F_VS] = dma2frm;
	781	+ /* if output stream enable, wait it end */
	782	+ val = rkisp_read(dev, CIF_MI_CTRL_SHD, true);
	783	+ if (val & CIF_MI_CTRL_SHD_MP_OUT_ENABLED)
	784	+ dev->irq_ends_mask \|= ISP_FRAME_MP;
	785	+ else
	786	+ dev->irq_ends_mask &= ~ISP_FRAME_MP;
	787	+ if (val & CIF_MI_CTRL_SHD_SP_OUT_ENABLED)
	788	+ dev->irq_ends_mask \|= ISP_FRAME_SP;
	789	+ else
	790	+ dev->irq_ends_mask &= ~ISP_FRAME_SP;
	791	+ if ((dev->isp_ver == ISP_V20 &&
	792	+ rkisp_read(dev, ISP_MPFBC_CTRL, true) & SW_MPFBC_EN) \|\|
	793	+ (dev->isp_ver == ISP_V30 &&
	794	+ rkisp_read(dev, ISP3X_MPFBC_CTRL, true) & ISP3X_MPFBC_EN_SHD))
	795	+ dev->irq_ends_mask \|= ISP_FRAME_MPFBC;
	796	+ else
	797	+ dev->irq_ends_mask &= ~ISP_FRAME_MPFBC;
	798	+ if ((dev->isp_ver == ISP_V30 &&
	799	+ rkisp_read(dev, ISP3X_MI_BP_WR_CTRL, true) & ISP3X_BP_ENABLE) \|\|
	800	+ (dev->isp_ver == ISP_V32 &&
	801	+ rkisp_read(dev, ISP32_MI_WR_CTRL2_SHD, true) & ISP32_BP_EN_OUT_SHD))
	802	+ dev->irq_ends_mask \|= ISP_FRAME_BP;
	803	+ else
	804	+ dev->irq_ends_mask &= ~ISP_FRAME_BP;
613	805
614	806	val = rkisp_read(dev, CSI2RX_CTRL0, true);
615	807	val &= ~SW_IBUF_OP_MODE(0xf);
..	..	@@ -618,10 +810,41 @@
618	810	v4l2_dbg(2, rkisp_debug, &dev->v4l2_dev,
619	811	"readback frame:%d time:%d 0x%x\n",
620	812	cur_frame_id, dma2frm + 1, val);
621		- if (!dma2frm)
622		- rkisp_bridge_update_mi(dev, 0);
623	813	if (!hw->is_shutdown)
624		- rkisp_write(dev, CSI2RX_CTRL0, val, true);
	814	+ rkisp_unite_write(dev, CSI2RX_CTRL0, val, true, hw->is_unite);
	815	+}
	816	+
	817	+static void rkisp_fast_switch_rx_buf(struct rkisp_device *dev, bool is_current)
	818	+{
	819	+ struct rkisp_stream *stream;
	820	+ struct rkisp_buffer *buf;
	821	+ u32 i, val;
	822	+
	823	+ for (i = RKISP_STREAM_RAWRD0; i < RKISP_MAX_DMARX_STREAM; i++) {
	824	+ stream = &dev->dmarx_dev.stream[i];
	825	+ if (!stream->ops)
	826	+ continue;
	827	+ buf = NULL;
	828	+ if (is_current)
	829	+ buf = stream->curr_buf;
	830	+ else if (!list_empty(&stream->buf_queue))
	831	+ buf = list_first_entry(&stream->buf_queue,
	832	+ struct rkisp_buffer, queue);
	833	+ if (!buf)
	834	+ continue;
	835	+ val = buf->buff_addr[RKISP_PLANE_Y];
	836	+ /* f1 -> f0 -> f1 for normal
	837	+ * L:f1 L:f1 -> L:f0 S:f0 -> L:f1 S:f1 for hdr2
	838	+ */
	839	+ if (dev->rd_mode == HDR_RDBK_FRAME2 && !is_current &&
	840	+ rkisp_read_reg_cache(dev, ISP3X_HDRMGE_GAIN0) == 0xfff0040) {
	841	+ if (i == RKISP_STREAM_RAWRD2)
	842	+ continue;
	843	+ else
	844	+ rkisp_write(dev, ISP3X_MI_RAWS_RD_BASE, val, false);
	845	+ }
	846	+ rkisp_write(dev, stream->config->mi.y_base_ad_init, val, false);
	847	+ }
625	848	}
626	849
627	850	static void rkisp_rdbk_trigger_handle(struct rkisp_device *dev, u32 cmd)
..	..	@@ -633,20 +856,33 @@
633	856	int i, times = -1, max = 0, id = 0;
634	857	int len[DEV_MAX] = { 0 };
635	858	u32 mode = 0;
	859	+ bool is_try = false;
636	860
637	861	spin_lock_irqsave(&hw->rdbk_lock, lock_flags);
638		- if (cmd == T_CMD_END)
	862	+ if (cmd == T_CMD_END) {
	863	+ if (dev->sw_rd_cnt) {
	864	+ dev->sw_rd_cnt--;
	865	+ isp = dev;
	866	+ is_try = true;
	867	+ times = 0;
	868	+ goto end;
	869	+ }
639	870	hw->is_idle = true;
	871	+ hw->pre_dev_id = dev->dev_id;
	872	+ }
640	873	if (hw->is_shutdown)
641	874	hw->is_idle = false;
642	875	if (!hw->is_idle)
643	876	goto end;
644	877	if (hw->monitor.state & ISP_MIPI_ERROR && hw->monitor.is_en)
645	878	goto end;
	879	+ if (!IS_HDR_RDBK(dev->rd_mode))
	880	+ goto end;
646	881
647	882	for (i = 0; i < hw->dev_num; i++) {
648	883	isp = hw->isp[i];
649		- if (!(isp->isp_state & ISP_START))
	884	+ if (!isp \|\|
	885	+ (isp && !(isp->isp_state & ISP_START)))
650	886	continue;
651	887	rkisp_rdbk_trigger_event(isp, T_CMD_LEN, &len[i]);
652	888	if (max < len[i]) {
..	..	@@ -655,10 +891,14 @@
655	891	}
656	892	}
657	893
	894	+ /* wait 2 frame to start isp for fast */
	895	+ if (dev->is_pre_on && max == 1 && !atomic_read(&dev->isp_sdev.frm_sync_seq))
	896	+ goto end;
	897	+
658	898	if (max) {
659		- v4l2_dbg(2, rkisp_debug, &dev->v4l2_dev,
660		- "trigger fifo len:%d\n", max);
661	899	isp = hw->isp[id];
	900	+ v4l2_dbg(2, rkisp_debug, &isp->v4l2_dev,
	901	+ "trigger fifo len:%d\n", max);
662	902	rkisp_rdbk_trigger_event(isp, T_CMD_DEQUEUE, &t);
663	903	isp->dmarx_dev.pre_frame = isp->dmarx_dev.cur_frame;
664	904	if (t.frame_id > isp->dmarx_dev.pre_frame.id &&
..	..	@@ -669,15 +909,27 @@
669	909	isp->dmarx_dev.cur_frame.sof_timestamp = t.sof_timestamp;
670	910	isp->dmarx_dev.cur_frame.timestamp = t.frame_timestamp;
671	911	isp->isp_sdev.frm_timestamp = t.sof_timestamp;
	912	+ atomic_set(&isp->isp_sdev.frm_sync_seq, t.frame_id + 1);
672	913	mode = t.mode;
673	914	times = t.times;
674	915	hw->cur_dev_id = id;
675	916	hw->is_idle = false;
	917	+ isp->sw_rd_cnt = 0;
	918	+ if (hw->is_multi_overflow && (hw->pre_dev_id != id)) {
	919	+ isp->sw_rd_cnt = 1;
	920	+ times = 0;
	921	+ }
	922	+ if (isp->is_pre_on && t.frame_id == 0) {
	923	+ isp->is_first_double = true;
	924	+ isp->skip_frame = 1;
	925	+ isp->sw_rd_cnt = 0;
	926	+ rkisp_fast_switch_rx_buf(isp, false);
	927	+ }
676	928	}
677	929	end:
678	930	spin_unlock_irqrestore(&hw->rdbk_lock, lock_flags);
679	931	if (times >= 0)
680		- rkisp_trigger_read_back(isp, times, mode, false);
	932	+ rkisp_trigger_read_back(isp, times, mode, is_try);
681	933	}
682	934
683	935	int rkisp_rdbk_trigger_event(struct rkisp_device dev, u32 cmd, void arg)
..	..	@@ -686,9 +938,6 @@
686	938	struct isp2x_csi_trigger *trigger = NULL;
687	939	unsigned long lock_flags = 0;
688	940	int val, ret = 0;
689		-
690		- if (dev->dmarx_dev.trigger != T_MANUAL)
691		- return 0;
692	941
693	942	spin_lock_irqsave(&dev->rdbk_lock, lock_flags);
694	943	switch (cmd) {
..	..	@@ -721,9 +970,23 @@
721	970	return ret;
722	971	}
723	972
	973	+static void rkisp_rdbk_work(struct work_struct *work)
	974	+{
	975	+ struct rkisp_device *dev = container_of(work, struct rkisp_device, rdbk_work);
	976	+
	977	+ rkisp_dvfs(dev);
	978	+ rkisp_rdbk_trigger_event(dev, T_CMD_END, NULL);
	979	+}
	980	+
724	981	void rkisp_check_idle(struct rkisp_device *dev, u32 irq)
725	982	{
726	983	u32 val = 0;
	984	+
	985	+ if (dev->hw_dev->is_multi_overflow &&
	986	+ dev->sw_rd_cnt &&
	987	+ irq & ISP_FRAME_END &&
	988	+ !dev->is_first_double)
	989	+ goto end;
727	990
728	991	dev->irq_ends \|= (irq & dev->irq_ends_mask);
729	992	v4l2_dbg(3, rkisp_debug, &dev->v4l2_dev,
..	..	@@ -735,13 +998,34 @@
735	998	if (!completion_done(&dev->hw_dev->monitor.cmpl))
736	999	complete(&dev->hw_dev->monitor.cmpl);
737	1000	}
738		- if (dev->irq_ends != dev->irq_ends_mask \|\| !IS_HDR_RDBK(dev->rd_mode))
	1001	+ if ((dev->irq_ends & dev->irq_ends_mask) != dev->irq_ends_mask \|\|
	1002	+ !IS_HDR_RDBK(dev->rd_mode))
739	1003	return;
740	1004
741		- if (!(dev->irq_ends_mask & (ISP_FRAME_MP \| ISP_FRAME_SP \| ISP_FRAME_MPFBC)))
742		- dev->isp_state = ISP_STOP;
	1005	+ if (dev->is_first_double) {
	1006	+ rkisp_fast_switch_rx_buf(dev, true);
	1007	+ dev->skip_frame = 0;
	1008	+ dev->irq_ends = 0;
	1009	+ return;
	1010	+ }
743	1011
744		- dev->irq_ends = 0;
	1012	+ /* check output stream is off */
	1013	+ val = ISP_FRAME_MP \| ISP_FRAME_SP \| ISP_FRAME_MPFBC \| ISP_FRAME_BP;
	1014	+ if (!(dev->irq_ends_mask & val)) {
	1015	+ u32 state = dev->isp_state;
	1016	+ struct rkisp_stream *s;
	1017	+
	1018	+ for (val = 0; val < RKISP_STREAM_VIR; val++) {
	1019	+ s = &dev->cap_dev.stream[val];
	1020	+ dev->isp_state = ISP_STOP;
	1021	+ if (s->streaming) {
	1022	+ dev->isp_state = state;
	1023	+ break;
	1024	+ }
	1025	+ }
	1026	+ }
	1027	+
	1028	+ val = 0;
745	1029	switch (dev->rd_mode) {
746	1030	case HDR_RDBK_FRAME3://for rd1 rd0 rd2
747	1031	val \|= RAW1_RD_FRAME;
..	..	@@ -754,9 +1038,12 @@
754	1038	/* FALLTHROUGH */
755	1039	}
756	1040	rkisp2_rawrd_isr(val, dev);
757		- if (!(dev->irq_ends_mask & (ISP_FRAME_MP \| ISP_FRAME_SP \| ISP_FRAME_MPFBC)))
758		- dev->isp_state = ISP_STOP;
759		- if (dev->dmarx_dev.trigger == T_MANUAL)
	1041	+
	1042	+end:
	1043	+ dev->irq_ends = 0;
	1044	+ if (dev->hw_dev->is_dvfs)
	1045	+ schedule_work(&dev->rdbk_work);
	1046	+ else
760	1047	rkisp_rdbk_trigger_event(dev, T_CMD_END, NULL);
761	1048	if (dev->isp_state == ISP_STOP)
762	1049	wake_up(&dev->sync_onoff);
..	..	@@ -779,31 +1066,34 @@
779	1066	*/
780	1067	static void rkisp_config_ism(struct rkisp_device *dev)
781	1068	{
782		- void __iomem *base = dev->base_addr;
783	1069	struct v4l2_rect *out_crop = &dev->isp_sdev.out_crop;
784		- u32 val;
	1070	+ u32 width = out_crop->width, mult = 1;
	1071	+ bool is_unite = dev->hw_dev->is_unite;
785	1072
786	1073	/* isp2.0 no ism */
787		- if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21)
	1074	+ if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21 \|\|
	1075	+ dev->isp_ver == ISP_V32_L)
788	1076	return;
789	1077
790		- writel(0, base + CIF_ISP_IS_RECENTER);
791		- writel(0, base + CIF_ISP_IS_MAX_DX);
792		- writel(0, base + CIF_ISP_IS_MAX_DY);
793		- writel(0, base + CIF_ISP_IS_DISPLACE);
794		- writel(out_crop->left, base + CIF_ISP_IS_H_OFFS);
795		- writel(out_crop->top, base + CIF_ISP_IS_V_OFFS);
796		- writel(out_crop->width, base + CIF_ISP_IS_H_SIZE);
	1078	+ if (is_unite)
	1079	+ width = width / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
	1080	+ rkisp_unite_write(dev, CIF_ISP_IS_RECENTER, 0, false, is_unite);
	1081	+ rkisp_unite_write(dev, CIF_ISP_IS_MAX_DX, 0, false, is_unite);
	1082	+ rkisp_unite_write(dev, CIF_ISP_IS_MAX_DY, 0, false, is_unite);
	1083	+ rkisp_unite_write(dev, CIF_ISP_IS_DISPLACE, 0, false, is_unite);
	1084	+ rkisp_unite_write(dev, CIF_ISP_IS_H_OFFS, out_crop->left, false, is_unite);
	1085	+ rkisp_unite_write(dev, CIF_ISP_IS_V_OFFS, out_crop->top, false, is_unite);
	1086	+ rkisp_unite_write(dev, CIF_ISP_IS_H_SIZE, width, false, is_unite);
797	1087	if (dev->cap_dev.stream[RKISP_STREAM_SP].interlaced)
798		- writel(out_crop->height / 2, base + CIF_ISP_IS_V_SIZE);
799		- else
800		- writel(out_crop->height, base + CIF_ISP_IS_V_SIZE);
	1088	+ mult = 2;
	1089	+ rkisp_unite_write(dev, CIF_ISP_IS_V_SIZE, out_crop->height / mult,
	1090	+ false, is_unite);
	1091	+
	1092	+ if (dev->isp_ver == ISP_V30 \|\| dev->isp_ver == ISP_V32)
	1093	+ return;
801	1094
802	1095	/* IS(Image Stabilization) is always on, working as output crop */
803		- writel(1, base + CIF_ISP_IS_CTRL);
804		- val = readl(base + CIF_ISP_CTRL);
805		- val \|= CIF_ISP_CTRL_ISP_CFG_UPD;
806		- writel(val, base + CIF_ISP_CTRL);
	1096	+ rkisp_write(dev, CIF_ISP_IS_CTRL, 1, false);
807	1097	}
808	1098
809	1099	static int rkisp_reset_handle_v2x(struct rkisp_device *dev)
..	..	@@ -960,7 +1250,7 @@
960	1250	!(monitor->state & ISP_MIPI_ERROR))) {
961	1251	for (i = 0; i < hw->dev_num; i++) {
962	1252	isp = hw->isp[i];
963		- if (!(isp->isp_inp & INP_CSI))
	1253	+ if (!isp \|\| (isp && !(isp->isp_inp & INP_CSI)))
964	1254	continue;
965	1255	if (!(isp->isp_state & ISP_START))
966	1256	break;
..	..	@@ -982,6 +1272,8 @@
982	1272	}
983	1273	for (i = 0; i < hw->dev_num; i++) {
984	1274	isp = hw->isp[i];
	1275	+ if (!isp)
	1276	+ continue;
985	1277	if (isp->isp_inp & INP_CSI \|\|
986	1278	isp->isp_inp & INP_DVP \|\|
987	1279	isp->isp_inp & INP_LVDS) {
..	..	@@ -1008,6 +1300,8 @@
1008	1300
1009	1301	for (i = 0; i < hw->dev_num; i++) {
1010	1302	isp = hw->isp[i];
	1303	+ if (!isp)
	1304	+ continue;
1011	1305	if (isp->isp_inp & INP_CSI \|\|
1012	1306	isp->isp_inp & INP_DVP \|\|
1013	1307	isp->isp_inp & INP_LVDS) {
..	..	@@ -1061,6 +1355,8 @@
1061	1355	*/
1062	1356	static void rkisp_config_color_space(struct rkisp_device *dev)
1063	1357	{
	1358	+ u32 val = 0;
	1359	+
1064	1360	u16 bt601_coeff[] = {
1065	1361	0x0026, 0x004b, 0x000f,
1066	1362	0x01ea, 0x01d6, 0x0040,
..	..	@@ -1092,16 +1388,223 @@
1092	1388	}
1093	1389
1094	1390	for (i = 0; i < 9; i++)
1095		- rkisp_write(dev, CIF_ISP_CC_COEFF_0 + i * 4, *(coeff + i), false);
	1391	+ rkisp_unite_write(dev, CIF_ISP_CC_COEFF_0 + i * 4,
	1392	+ *(coeff + i), false, dev->hw_dev->is_unite);
	1393	+
	1394	+ val = rkisp_read_reg_cache(dev, CIF_ISP_CTRL);
1096	1395
1097	1396	if (dev->isp_sdev.quantization == V4L2_QUANTIZATION_FULL_RANGE)
1098		- rkisp_set_bits(dev, CIF_ISP_CTRL, 0,
1099		- CIF_ISP_CTRL_ISP_CSM_Y_FULL_ENA \|
1100		- CIF_ISP_CTRL_ISP_CSM_C_FULL_ENA, false);
	1397	+ rkisp_unite_write(dev, CIF_ISP_CTRL, val \|
	1398	+ CIF_ISP_CTRL_ISP_CSM_Y_FULL_ENA \|
	1399	+ CIF_ISP_CTRL_ISP_CSM_C_FULL_ENA,
	1400	+ false, dev->hw_dev->is_unite);
1101	1401	else
1102		- rkisp_clear_bits(dev, CIF_ISP_CTRL,
1103		- CIF_ISP_CTRL_ISP_CSM_Y_FULL_ENA \|
1104		- CIF_ISP_CTRL_ISP_CSM_C_FULL_ENA, false);
	1402	+ rkisp_unite_write(dev, CIF_ISP_CTRL, val &
	1403	+ ~(CIF_ISP_CTRL_ISP_CSM_Y_FULL_ENA \|
	1404	+ CIF_ISP_CTRL_ISP_CSM_C_FULL_ENA),
	1405	+ false, dev->hw_dev->is_unite);
	1406	+}
	1407	+
	1408	+static void rkisp_config_cmsk_single(struct rkisp_device *dev,
	1409	+ struct rkisp_cmsk_cfg *cfg)
	1410	+{
	1411	+ u32 i, val, ctrl = 0;
	1412	+ u32 mp_en = cfg->win[0].win_en;
	1413	+ u32 sp_en = cfg->win[1].win_en;
	1414	+ u32 bp_en = cfg->win[2].win_en;
	1415	+ u32 win_max = (dev->isp_ver == ISP_V30) ?
	1416	+ RKISP_CMSK_WIN_MAX_V30 : RKISP_CMSK_WIN_MAX;
	1417	+
	1418	+ if (mp_en) {
	1419	+ ctrl \|= ISP3X_SW_CMSK_EN_MP;
	1420	+ rkisp_write(dev, ISP3X_CMSK_CTRL1, mp_en, false);
	1421	+ val = cfg->win[0].mode;
	1422	+ rkisp_write(dev, ISP3X_CMSK_CTRL4, val, false);
	1423	+ }
	1424	+
	1425	+ if (sp_en) {
	1426	+ ctrl \|= ISP3X_SW_CMSK_EN_SP;
	1427	+ rkisp_write(dev, ISP3X_CMSK_CTRL2, sp_en, false);
	1428	+ val = cfg->win[1].mode;
	1429	+ rkisp_write(dev, ISP3X_CMSK_CTRL5, val, false);
	1430	+ }
	1431	+
	1432	+ if (bp_en) {
	1433	+ ctrl \|= ISP3X_SW_CMSK_EN_BP;
	1434	+ rkisp_write(dev, ISP3X_CMSK_CTRL3, bp_en, false);
	1435	+ val = cfg->win[2].mode;
	1436	+ rkisp_write(dev, ISP3X_CMSK_CTRL6, val, false);
	1437	+ }
	1438	+
	1439	+ for (i = 0; i < win_max; i++) {
	1440	+ if (!(mp_en & BIT(i)) && !(sp_en & BIT(i)) && !(bp_en & BIT(i)))
	1441	+ continue;
	1442	+
	1443	+ val = ISP3X_SW_CMSK_YUV(cfg->win[i].cover_color_y,
	1444	+ cfg->win[i].cover_color_u,
	1445	+ cfg->win[i].cover_color_v);
	1446	+ rkisp_write(dev, ISP3X_CMSK_YUV0 + i * 4, val, false);
	1447	+
	1448	+ val = ISP_PACK_2SHORT(cfg->win[i].h_offs, cfg->win[i].v_offs);
	1449	+ rkisp_write(dev, ISP3X_CMSK_OFFS0 + i * 8, val, false);
	1450	+
	1451	+ val = ISP_PACK_2SHORT(cfg->win[i].h_size, cfg->win[i].v_size);
	1452	+ rkisp_write(dev, ISP3X_CMSK_SIZE0 + i * 8, val, false);
	1453	+ }
	1454	+
	1455	+ if (ctrl) {
	1456	+ val = ISP_PACK_2SHORT(dev->isp_sdev.out_crop.width,
	1457	+ dev->isp_sdev.out_crop.height);
	1458	+ rkisp_write(dev, ISP3X_CMSK_PIC_SIZE, val, false);
	1459	+ ctrl \|= ISP3X_SW_CMSK_EN \| ISP3X_SW_CMSK_ORDER_MODE;
	1460	+ ctrl \|= ISP3X_SW_CMSK_BLKSIZE(cfg->mosaic_block);
	1461	+ }
	1462	+ rkisp_write(dev, ISP3X_CMSK_CTRL0, ctrl, false);
	1463	+
	1464	+ val = rkisp_read(dev, ISP3X_CMSK_CTRL0, true);
	1465	+ if (dev->hw_dev->is_single &&
	1466	+ ((val & ISP32_SW_CMSK_EN_PATH) != (val & ISP32_SW_CMSK_EN_PATH_SHD)))
	1467	+ rkisp_write(dev, ISP3X_CMSK_CTRL0, val \| ISP3X_SW_CMSK_FORCE_UPD, true);
	1468	+}
	1469	+
	1470	+static void rkisp_config_cmsk_dual(struct rkisp_device *dev,
	1471	+ struct rkisp_cmsk_cfg *cfg)
	1472	+{
	1473	+ struct rkisp_cmsk_cfg left = *cfg;
	1474	+ struct rkisp_cmsk_cfg right = *cfg;
	1475	+ u32 width = dev->isp_sdev.out_crop.width;
	1476	+ u32 height = dev->isp_sdev.out_crop.height;
	1477	+ u32 w = width / 2;
	1478	+ u32 i, val, h_offs, h_size, ctrl;
	1479	+ u8 mp_en = cfg->win[0].win_en;
	1480	+ u8 sp_en = cfg->win[1].win_en;
	1481	+ u8 bp_en = cfg->win[2].win_en;
	1482	+ u32 win_max = (dev->isp_ver == ISP_V30) ?
	1483	+ RKISP_CMSK_WIN_MAX_V30 : RKISP_CMSK_WIN_MAX;
	1484	+
	1485	+ for (i = 0; i < win_max; i++) {
	1486	+ if (!(mp_en & BIT(i)) && !(sp_en & BIT(i)) && !(bp_en & BIT(i)))
	1487	+ continue;
	1488	+
	1489	+ h_offs = cfg->win[i].h_offs;
	1490	+ h_size = cfg->win[i].h_size;
	1491	+ if (h_offs + h_size <= w) {
	1492	+ /* cmsk window at left isp */
	1493	+ right.win[0].win_en &= ~BIT(i);
	1494	+ right.win[1].win_en &= ~BIT(i);
	1495	+ right.win[2].win_en &= ~BIT(i);
	1496	+ } else if (h_offs >= w) {
	1497	+ /* cmsk window at right isp */
	1498	+ left.win[0].win_en &= ~BIT(i);
	1499	+ left.win[1].win_en &= ~BIT(i);
	1500	+ left.win[2].win_en &= ~BIT(i);
	1501	+ } else {
	1502	+ /* cmsk window at dual isp */
	1503	+ left.win[i].h_size = ALIGN(w - h_offs, 8);
	1504	+
	1505	+ right.win[i].h_offs = RKMOUDLE_UNITE_EXTEND_PIXEL;
	1506	+ val = h_offs + h_size - w;
	1507	+ right.win[i].h_size = ALIGN(val, 8);
	1508	+ right.win[i].h_offs -= right.win[i].h_size - val;
	1509	+ }
	1510	+
	1511	+ val = ISP3X_SW_CMSK_YUV(left.win[i].cover_color_y,
	1512	+ left.win[i].cover_color_u,
	1513	+ left.win[i].cover_color_v);
	1514	+ rkisp_write(dev, ISP3X_CMSK_YUV0 + i * 4, val, false);
	1515	+ rkisp_next_write(dev, ISP3X_CMSK_YUV0 + i * 4, val, false);
	1516	+
	1517	+ val = ISP_PACK_2SHORT(left.win[i].h_offs, left.win[i].v_offs);
	1518	+ rkisp_write(dev, ISP3X_CMSK_OFFS0 + i * 8, val, false);
	1519	+ val = ISP_PACK_2SHORT(left.win[i].h_size, left.win[i].v_size);
	1520	+ rkisp_write(dev, ISP3X_CMSK_SIZE0 + i * 8, val, false);
	1521	+
	1522	+ val = ISP_PACK_2SHORT(right.win[i].h_offs, right.win[i].v_offs);
	1523	+ rkisp_next_write(dev, ISP3X_CMSK_OFFS0 + i * 8, val, false);
	1524	+ val = ISP_PACK_2SHORT(right.win[i].h_size, right.win[i].v_size);
	1525	+ rkisp_next_write(dev, ISP3X_CMSK_SIZE0 + i * 8, val, false);
	1526	+ }
	1527	+
	1528	+ w += RKMOUDLE_UNITE_EXTEND_PIXEL;
	1529	+ ctrl = 0;
	1530	+ if (left.win[0].win_en) {
	1531	+ ctrl \|= ISP3X_SW_CMSK_EN_MP;
	1532	+ rkisp_write(dev, ISP3X_CMSK_CTRL1, left.win[0].win_en, false);
	1533	+ val = left.win[0].mode;
	1534	+ rkisp_write(dev, ISP3X_CMSK_CTRL4, val, false);
	1535	+ }
	1536	+ if (left.win[1].win_en) {
	1537	+ ctrl \|= ISP3X_SW_CMSK_EN_SP;
	1538	+ rkisp_write(dev, ISP3X_CMSK_CTRL2, left.win[1].win_en, false);
	1539	+ val = left.win[1].mode;
	1540	+ rkisp_write(dev, ISP3X_CMSK_CTRL5, val, false);
	1541	+ }
	1542	+ if (left.win[2].win_en) {
	1543	+ ctrl \|= ISP3X_SW_CMSK_EN_BP;
	1544	+ rkisp_write(dev, ISP3X_CMSK_CTRL3, left.win[2].win_en, false);
	1545	+ val = left.win[2].mode;
	1546	+ rkisp_write(dev, ISP3X_CMSK_CTRL6, val, false);
	1547	+ }
	1548	+ if (ctrl) {
	1549	+ val = ISP_PACK_2SHORT(w, height);
	1550	+ rkisp_write(dev, ISP3X_CMSK_PIC_SIZE, val, false);
	1551	+ ctrl \|= ISP3X_SW_CMSK_EN \| ISP3X_SW_CMSK_ORDER_MODE;
	1552	+ }
	1553	+ rkisp_write(dev, ISP3X_CMSK_CTRL0, ctrl, false);
	1554	+
	1555	+ ctrl = 0;
	1556	+ if (right.win[0].win_en) {
	1557	+ ctrl \|= ISP3X_SW_CMSK_EN_MP;
	1558	+ rkisp_next_write(dev, ISP3X_CMSK_CTRL1, right.win[0].win_en, false);
	1559	+ val = right.win[0].mode;
	1560	+ rkisp_next_write(dev, ISP3X_CMSK_CTRL4, val, false);
	1561	+ }
	1562	+ if (right.win[1].win_en) {
	1563	+ ctrl \|= ISP3X_SW_CMSK_EN_SP;
	1564	+ rkisp_next_write(dev, ISP3X_CMSK_CTRL2, right.win[1].win_en, false);
	1565	+ val = right.win[1].mode;
	1566	+ rkisp_next_write(dev, ISP3X_CMSK_CTRL5, val, false);
	1567	+ }
	1568	+ if (right.win[2].win_en) {
	1569	+ ctrl \|= ISP3X_SW_CMSK_EN_BP;
	1570	+ rkisp_next_write(dev, ISP3X_CMSK_CTRL3, right.win[2].win_en, false);
	1571	+ val = right.win[2].mode;
	1572	+ rkisp_next_write(dev, ISP3X_CMSK_CTRL6, val, false);
	1573	+ }
	1574	+ if (ctrl) {
	1575	+ val = ISP_PACK_2SHORT(w, height);
	1576	+ rkisp_next_write(dev, ISP3X_CMSK_PIC_SIZE, val, false);
	1577	+ ctrl \|= ISP3X_SW_CMSK_EN \| ISP3X_SW_CMSK_ORDER_MODE;
	1578	+ }
	1579	+ rkisp_next_write(dev, ISP3X_CMSK_CTRL0, ctrl, false);
	1580	+
	1581	+ val = rkisp_next_read(dev, ISP3X_CMSK_CTRL0, true);
	1582	+ if (dev->hw_dev->is_single &&
	1583	+ ((val & ISP32_SW_CMSK_EN_PATH) != (val & ISP32_SW_CMSK_EN_PATH_SHD)))
	1584	+ rkisp_next_write(dev, ISP3X_CMSK_CTRL0, val \| ISP3X_SW_CMSK_FORCE_UPD, false);
	1585	+}
	1586	+
	1587	+static void rkisp_config_cmsk(struct rkisp_device *dev)
	1588	+{
	1589	+ unsigned long lock_flags = 0;
	1590	+ struct rkisp_cmsk_cfg cfg;
	1591	+
	1592	+ if (dev->isp_ver != ISP_V30 && dev->isp_ver != ISP_V32)
	1593	+ return;
	1594	+
	1595	+ spin_lock_irqsave(&dev->cmsk_lock, lock_flags);
	1596	+ if (!dev->is_cmsk_upd) {
	1597	+ spin_unlock_irqrestore(&dev->cmsk_lock, lock_flags);
	1598	+ return;
	1599	+ }
	1600	+ dev->is_cmsk_upd = false;
	1601	+ cfg = dev->cmsk_cfg;
	1602	+ spin_unlock_irqrestore(&dev->cmsk_lock, lock_flags);
	1603	+
	1604	+ if (!dev->hw_dev->is_unite)
	1605	+ rkisp_config_cmsk_single(dev, &cfg);
	1606	+ else
	1607	+ rkisp_config_cmsk_dual(dev, &cfg);
1105	1608	}
1106	1609
1107	1610	/*
..	..	@@ -1113,17 +1616,20 @@
1113	1616	struct ispsd_out_fmt *out_fmt;
1114	1617	struct v4l2_rect *in_crop;
1115	1618	struct rkisp_sensor_info *sensor;
	1619	+ bool is_unite = dev->hw_dev->is_unite;
1116	1620	u32 isp_ctrl = 0;
1117	1621	u32 irq_mask = 0;
1118	1622	u32 signal = 0;
1119	1623	u32 acq_mult = 0;
1120	1624	u32 acq_prop = 0;
1121	1625	u32 extend_line = 0;
	1626	+ u32 width;
1122	1627
1123	1628	sensor = dev->active_sensor;
1124	1629	in_fmt = &dev->isp_sdev.in_fmt;
1125	1630	out_fmt = &dev->isp_sdev.out_fmt;
1126	1631	in_crop = &dev->isp_sdev.in_crop;
	1632	+ width = in_crop->width;
1127	1633
1128	1634	if (in_fmt->fmt_type == FMT_BAYER) {
1129	1635	acq_mult = 1;
..	..	@@ -1139,18 +1645,20 @@
1139	1645	if (in_fmt->mbus_code == MEDIA_BUS_FMT_Y8_1X8 \|\|
1140	1646	in_fmt->mbus_code == MEDIA_BUS_FMT_Y10_1X10 \|\|
1141	1647	in_fmt->mbus_code == MEDIA_BUS_FMT_Y12_1X12) {
1142		- if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21)
1143		- rkisp_write(dev, ISP_DEBAYER_CONTROL, 0, false);
	1648	+ if (dev->isp_ver >= ISP_V20)
	1649	+ rkisp_unite_write(dev, ISP_DEBAYER_CONTROL,
	1650	+ 0, false, is_unite);
1144	1651	else
1145	1652	rkisp_write(dev, CIF_ISP_DEMOSAIC,
1146	1653	CIF_ISP_DEMOSAIC_BYPASS \|
1147	1654	CIF_ISP_DEMOSAIC_TH(0xc), false);
1148	1655	} else {
1149		- if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21)
1150		- rkisp_write(dev, ISP_DEBAYER_CONTROL,
1151		- SW_DEBAYER_EN \|
1152		- SW_DEBAYER_FILTER_G_EN \|
1153		- SW_DEBAYER_FILTER_C_EN, false);
	1656	+ if (dev->isp_ver >= ISP_V20)
	1657	+ rkisp_unite_write(dev, ISP_DEBAYER_CONTROL,
	1658	+ SW_DEBAYER_EN \|
	1659	+ SW_DEBAYER_FILTER_G_EN \|
	1660	+ SW_DEBAYER_FILTER_C_EN,
	1661	+ false, is_unite);
1154	1662	else
1155	1663	rkisp_write(dev, CIF_ISP_DEMOSAIC,
1156	1664	CIF_ISP_DEMOSAIC_TH(0xc), false);
..	..	@@ -1171,7 +1679,7 @@
1171	1679	} else if (in_fmt->fmt_type == FMT_YUV) {
1172	1680	acq_mult = 2;
1173	1681	if (sensor &&
1174		- (sensor->mbus.type == V4L2_MBUS_CSI2 \|\|
	1682	+ (sensor->mbus.type == V4L2_MBUS_CSI2_DPHY \|\|
1175	1683	sensor->mbus.type == V4L2_MBUS_CCP2)) {
1176	1684	isp_ctrl = CIF_ISP_CTRL_ISP_MODE_ITU601;
1177	1685	} else {
..	..	@@ -1203,39 +1711,53 @@
1203	1711	signal \|= CIF_ISP_ACQ_PROP_HSYNC_LOW;
1204	1712	}
1205	1713
1206		- rkisp_write(dev, CIF_ISP_CTRL, isp_ctrl, false);
	1714	+ if (rkisp_read_reg_cache(dev, CIF_ISP_CTRL) & ISP32_MIR_ENABLE)
	1715	+ isp_ctrl \|= ISP32_MIR_ENABLE;
	1716	+
	1717	+ rkisp_unite_write(dev, CIF_ISP_CTRL, isp_ctrl, false, is_unite);
1207	1718	acq_prop \|= signal \| in_fmt->yuv_seq \|
1208	1719	CIF_ISP_ACQ_PROP_BAYER_PAT(in_fmt->bayer_pat) \|
1209	1720	CIF_ISP_ACQ_PROP_FIELD_SEL_ALL;
1210		- rkisp_write(dev, CIF_ISP_ACQ_PROP, acq_prop, false);
1211		- rkisp_write(dev, CIF_ISP_ACQ_NR_FRAMES, 0, true);
	1721	+ rkisp_unite_write(dev, CIF_ISP_ACQ_PROP, acq_prop, false, is_unite);
	1722	+ rkisp_unite_write(dev, CIF_ISP_ACQ_NR_FRAMES, 0, true, is_unite);
1212	1723
	1724	+ if (is_unite)
	1725	+ width = width / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
1213	1726	/* Acquisition Size */
1214		- rkisp_write(dev, CIF_ISP_ACQ_H_OFFS, acq_mult * in_crop->left, false);
1215		- rkisp_write(dev, CIF_ISP_ACQ_V_OFFS, in_crop->top, false);
1216		- rkisp_write(dev, CIF_ISP_ACQ_H_SIZE, acq_mult * in_crop->width, false);
	1727	+ rkisp_unite_write(dev, CIF_ISP_ACQ_H_OFFS, acq_mult * in_crop->left,
	1728	+ false, is_unite);
	1729	+ rkisp_unite_write(dev, CIF_ISP_ACQ_V_OFFS, in_crop->top,
	1730	+ false, is_unite);
	1731	+ rkisp_unite_write(dev, CIF_ISP_ACQ_H_SIZE, acq_mult * width,
	1732	+ false, is_unite);
1217	1733
1218	1734	/* ISP Out Area differ with ACQ is only FIFO, so don't crop in this */
1219		- rkisp_write(dev, CIF_ISP_OUT_H_OFFS, 0, true);
1220		- rkisp_write(dev, CIF_ISP_OUT_V_OFFS, 0, true);
1221		- rkisp_write(dev, CIF_ISP_OUT_H_SIZE, in_crop->width, false);
	1735	+ rkisp_unite_write(dev, CIF_ISP_OUT_H_OFFS, 0, true, is_unite);
	1736	+ rkisp_unite_write(dev, CIF_ISP_OUT_V_OFFS, 0, true, is_unite);
	1737	+ rkisp_unite_write(dev, CIF_ISP_OUT_H_SIZE, width, false, is_unite);
1222	1738
1223	1739	if (dev->cap_dev.stream[RKISP_STREAM_SP].interlaced) {
1224		- rkisp_write(dev, CIF_ISP_ACQ_V_SIZE, in_crop->height / 2, false);
1225		- rkisp_write(dev, CIF_ISP_OUT_V_SIZE, in_crop->height / 2, false);
	1740	+ rkisp_unite_write(dev, CIF_ISP_ACQ_V_SIZE, in_crop->height / 2,
	1741	+ false, is_unite);
	1742	+ rkisp_unite_write(dev, CIF_ISP_OUT_V_SIZE, in_crop->height / 2,
	1743	+ false, is_unite);
1226	1744	} else {
1227		- rkisp_write(dev, CIF_ISP_ACQ_V_SIZE, in_crop->height + extend_line, false);
1228		- rkisp_write(dev, CIF_ISP_OUT_V_SIZE, in_crop->height + extend_line, false);
	1745	+ rkisp_unite_write(dev, CIF_ISP_ACQ_V_SIZE, in_crop->height + extend_line,
	1746	+ false, is_unite);
	1747	+ rkisp_unite_write(dev, CIF_ISP_OUT_V_SIZE, in_crop->height + extend_line,
	1748	+ false, is_unite);
1229	1749	}
1230	1750
1231	1751	/* interrupt mask */
1232		- irq_mask \|= CIF_ISP_FRAME \| CIF_ISP_V_START \| CIF_ISP_PIC_SIZE_ERROR \|
1233		- CIF_ISP_FRAME_IN;
1234		- if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21)
	1752	+ irq_mask \|= CIF_ISP_FRAME \| CIF_ISP_V_START \| CIF_ISP_PIC_SIZE_ERROR;
	1753	+ if (dev->isp_ver >= ISP_V20)
1235	1754	irq_mask \|= ISP2X_LSC_LUT_ERR;
1236		- rkisp_write(dev, CIF_ISP_IMSC, irq_mask, true);
	1755	+ if (dev->is_pre_on)
	1756	+ irq_mask \|= CIF_ISP_FRAME_IN;
	1757	+ rkisp_unite_write(dev, CIF_ISP_IMSC, irq_mask, true, is_unite);
1237	1758
1238		- if ((dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21) &&
	1759	+ if ((dev->isp_ver == ISP_V20 \|\|
	1760	+ dev->isp_ver == ISP_V21) &&
1239	1761	IS_HDR_RDBK(dev->hdr.op_mode)) {
1240	1762	irq_mask = ISP2X_3A_RAWAE_BIG;
1241	1763	rkisp_write(dev, ISP_ISP3A_IMSC, irq_mask, true);
..	..	@@ -1252,6 +1774,8 @@
1252	1774	rkisp_update_regs(dev, CIF_ISP_ACQ_H_OFFS, CIF_ISP_ACQ_V_SIZE);
1253	1775	rkisp_update_regs(dev, CIF_ISP_OUT_H_SIZE, CIF_ISP_OUT_V_SIZE);
1254	1776	}
	1777	+
	1778	+ rkisp_config_cmsk(dev);
1255	1779	return 0;
1256	1780	}
1257	1781
..	..	@@ -1355,12 +1879,12 @@
1355	1879	/* Configure MUX */
1356	1880	static int rkisp_config_path(struct rkisp_device *dev)
1357	1881	{
1358		- int ret = 0;
1359	1882	struct rkisp_sensor_info *sensor = dev->active_sensor;
1360		- u32 dpcl = readl(dev->base_addr + CIF_VI_DPCL);
	1883	+ int ret = 0;
	1884	+ u32 dpcl = 0;
1361	1885
1362	1886	/* isp input interface selects */
1363		- if ((sensor && sensor->mbus.type == V4L2_MBUS_CSI2) \|\|
	1887	+ if ((sensor && sensor->mbus.type == V4L2_MBUS_CSI2_DPHY) \|\|
1364	1888	dev->isp_inp & (INP_RAWRD0 \| INP_RAWRD1 \| INP_RAWRD2 \| INP_CIF)) {
1365	1889	/* mipi sensor->isp or isp read from ddr */
1366	1890	dpcl \|= CIF_VI_DPCL_IF_SEL_MIPI;
..	..	@@ -1382,8 +1906,11 @@
1382	1906	ret = -EINVAL;
1383	1907	}
1384	1908
1385		- writel(dpcl, dev->base_addr + CIF_VI_DPCL);
	1909	+ if (dev->isp_ver == ISP_V32)
	1910	+ dpcl \|= BIT(0);
1386	1911
	1912	+ rkisp_unite_set_bits(dev, CIF_VI_DPCL, 0, dpcl, true,
	1913	+ dev->hw_dev->is_unite);
1387	1914	return ret;
1388	1915	}
1389	1916
..	..	@@ -1455,7 +1982,7 @@
1455	1982	int ret = 1000;
1456	1983
1457	1984	if (!rkisp_is_need_3a(dev) \|\| dev->isp_ver == ISP_V20 \|\|
1458		- !params_vdev->is_subs_evt)
	1985	+ !params_vdev->is_subs_evt \|\| dev->hw_dev->is_shutdown)
1459	1986	return;
1460	1987
1461	1988	v4l2_event_queue(vdev, &ev);
..	..	@@ -1472,6 +1999,7 @@
1472	1999	/* Mess register operations to stop isp */
1473	2000	static int rkisp_isp_stop(struct rkisp_device *dev)
1474	2001	{
	2002	+ struct rkisp_hw_dev *hw = dev->hw_dev;
1475	2003	void __iomem *base = dev->base_addr;
1476	2004	unsigned long old_rate, safe_rate;
1477	2005	u32 val;
..	..	@@ -1483,13 +2011,6 @@
1483	2011
1484	2012	if (atomic_read(&dev->hw_dev->refcnt) > 1)
1485	2013	goto end;
1486		-
1487		- if (dev->hw_dev->monitor.is_en) {
1488		- dev->hw_dev->monitor.is_en = 0;
1489		- dev->hw_dev->monitor.state = ISP_STOP;
1490		- if (!completion_done(&dev->hw_dev->monitor.cmpl))
1491		- complete(&dev->hw_dev->monitor.cmpl);
1492		- }
1493	2014	/*
1494	2015	* ISP(mi) stop in mi frame end -> Stop ISP(mipi) ->
1495	2016	* Stop ISP(isp) ->wait for ISP isp off
..	..	@@ -1502,7 +2023,7 @@
1502	2023	readl(base + CIF_ISP_CSI0_ERR1);
1503	2024	readl(base + CIF_ISP_CSI0_ERR2);
1504	2025	readl(base + CIF_ISP_CSI0_ERR3);
1505		- } else if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21) {
	2026	+ } else if (dev->isp_ver >= ISP_V20) {
1506	2027	writel(0, base + CSI2RX_MASK_PHY);
1507	2028	writel(0, base + CSI2RX_MASK_PACKET);
1508	2029	writel(0, base + CSI2RX_MASK_OVERFLOW);
..	..	@@ -1519,7 +2040,7 @@
1519	2040	writel(0, base + CIF_ISP_IMSC);
1520	2041	writel(~0, base + CIF_ISP_ICR);
1521	2042
1522		- if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21) {
	2043	+ if (dev->isp_ver >= ISP_V20) {
1523	2044	writel(0, base + ISP_ISP3A_IMSC);
1524	2045	writel(~0, base + ISP_ISP3A_ICR);
1525	2046	}
..	..	@@ -1535,7 +2056,7 @@
1535	2056	udelay(20);
1536	2057	}
1537	2058	/* stop lsc to avoid lsclut error */
1538		- if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21)
	2059	+ if (dev->isp_ver >= ISP_V20)
1539	2060	writel(0, base + ISP_LSC_CTRL);
1540	2061	/* stop ISP */
1541	2062	val = readl(base + CIF_ISP_CTRL);
..	..	@@ -1544,6 +2065,9 @@
1544	2065
1545	2066	val = readl(base + CIF_ISP_CTRL);
1546	2067	writel(val \| CIF_ISP_CTRL_ISP_CFG_UPD, base + CIF_ISP_CTRL);
	2068	+ if (hw->is_unite)
	2069	+ rkisp_next_write(dev, CIF_ISP_CTRL,
	2070	+ val \| CIF_ISP_CTRL_ISP_CFG_UPD, true);
1547	2071
1548	2072	readx_poll_timeout_atomic(readl, base + CIF_ISP_RIS,
1549	2073	val, val & CIF_ISP_OFF, 20, 100);
..	..	@@ -1551,19 +2075,19 @@
1551	2075	"MI_CTRL:%x, ISP_CTRL:%x\n",
1552	2076	readl(base + CIF_MI_CTRL), readl(base + CIF_ISP_CTRL));
1553	2077
1554		- val = rkisp_read(dev, CTRL_VI_ISP_CLK_CTRL, true);
1555	2078	if (!in_interrupt()) {
1556	2079	/* normal case */
1557	2080	/* check the isp_clk before isp reset operation */
1558		- old_rate = clk_get_rate(dev->hw_dev->clks[0]);
1559		- safe_rate = dev->hw_dev->clk_rate_tbl[0].clk_rate * 1000000UL;
	2081	+ old_rate = clk_get_rate(hw->clks[0]);
	2082	+ safe_rate = hw->clk_rate_tbl[0].clk_rate * 1000000UL;
1560	2083	if (old_rate > safe_rate) {
1561		- rkisp_set_clk_rate(dev->hw_dev->clks[0], safe_rate);
	2084	+ rkisp_set_clk_rate(hw->clks[0], safe_rate);
	2085	+ if (hw->is_unite)
	2086	+ rkisp_set_clk_rate(hw->clks[5], safe_rate);
1562	2087	udelay(100);
1563	2088	}
1564	2089	rkisp_soft_reset(dev->hw_dev, false);
1565	2090	}
1566		- rkisp_write(dev, CTRL_VI_ISP_CLK_CTRL, val, true);
1567	2091
1568	2092	if (dev->isp_ver == ISP_V12 \|\| dev->isp_ver == ISP_V13) {
1569	2093	writel(0, base + CIF_ISP_CSI0_CSI2_RESETN);
..	..	@@ -1571,19 +2095,26 @@
1571	2095	writel(0, base + CIF_ISP_CSI0_MASK1);
1572	2096	writel(0, base + CIF_ISP_CSI0_MASK2);
1573	2097	writel(0, base + CIF_ISP_CSI0_MASK3);
1574		- } else if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21) {
	2098	+ } else if (dev->isp_ver >= ISP_V20) {
1575	2099	writel(0, base + CSI2RX_CSI2_RESETN);
	2100	+ if (hw->is_unite)
	2101	+ rkisp_next_write(dev, CSI2RX_CSI2_RESETN, 0, true);
1576	2102	}
1577	2103
	2104	+ hw->is_dvfs = false;
	2105	+ hw->is_runing = false;
1578	2106	dev->hw_dev->is_idle = true;
1579	2107	dev->hw_dev->is_mi_update = false;
1580	2108	end:
1581	2109	dev->irq_ends_mask = 0;
1582	2110	dev->hdr.op_mode = 0;
	2111	+ dev->sw_rd_cnt = 0;
1583	2112	rkisp_set_state(&dev->isp_state, ISP_STOP);
1584	2113
1585		- if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21)
	2114	+ if (dev->isp_ver >= ISP_V20)
1586	2115	kfifo_reset(&dev->rdbk_kfifo);
	2116	+ if (dev->isp_ver == ISP_V30 \|\| dev->isp_ver == ISP_V32)
	2117	+ memset(&dev->cmsk_cfg, 0, sizeof(dev->cmsk_cfg));
1587	2118	if (dev->emd_vc <= CIF_ISP_ADD_DATA_VC_MAX) {
1588	2119	for (i = 0; i < RKISP_EMDDATA_FIFO_MAX; i++)
1589	2120	kfifo_free(&dev->emd_data_fifo[i].mipi_kfifo);
..	..	@@ -1601,15 +2132,40 @@
1601	2132	{
1602	2133	struct rkisp_sensor_info *sensor = dev->active_sensor;
1603	2134	void __iomem *base = dev->base_addr;
1604		- u32 val;
1605	2135	bool is_direct = true;
	2136	+ u32 val;
1606	2137
1607	2138	v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
1608		- "%s refcnt:%d\n", __func__,
1609		- atomic_read(&dev->hw_dev->refcnt));
	2139	+ "%s refcnt:%d link_num:%d\n", __func__,
	2140	+ atomic_read(&dev->hw_dev->refcnt),
	2141	+ dev->hw_dev->dev_link_num);
	2142	+
	2143	+ dev->cap_dev.is_done_early = false;
	2144	+ if (dev->cap_dev.wait_line >= dev->isp_sdev.out_crop.height)
	2145	+ dev->cap_dev.wait_line = 0;
	2146	+ if (dev->cap_dev.wait_line) {
	2147	+ dev->cap_dev.is_done_early = true;
	2148	+ if (dev->isp_ver >= ISP_V32) {
	2149	+ val = dev->cap_dev.wait_line;
	2150	+ rkisp_write(dev, ISP32_ISP_IRQ_CFG0, val << 16, false);
	2151	+ rkisp_set_bits(dev, CIF_ISP_IMSC, 0, ISP3X_OUT_FRM_HALF, false);
	2152	+ } else {
	2153	+ /* using AF 15x15 block */
	2154	+ val = dev->isp_sdev.out_crop.height / 15;
	2155	+ val = dev->cap_dev.wait_line / val;
	2156	+ val = ISP3X_RAWAF_INELINE0(val) \| ISP3X_RAWAF_INTLINE0_EN;
	2157	+ rkisp_unite_write(dev, ISP3X_RAWAF_INT_LINE,
	2158	+ val, false, dev->hw_dev->is_unite);
	2159	+ rkisp_unite_set_bits(dev, ISP_ISP3A_IMSC, 0,
	2160	+ ISP2X_3A_RAWAF, false, dev->hw_dev->is_unite);
	2161	+ rkisp_unite_clear_bits(dev, CIF_ISP_IMSC,
	2162	+ ISP2X_LSC_LUT_ERR, false, dev->hw_dev->is_unite);
	2163	+ dev->rawaf_irq_cnt = 0;
	2164	+ }
	2165	+ }
1610	2166
1611	2167	/* Activate MIPI */
1612		- if (sensor && sensor->mbus.type == V4L2_MBUS_CSI2) {
	2168	+ if (sensor && sensor->mbus.type == V4L2_MBUS_CSI2_DPHY) {
1613	2169	if (dev->isp_ver == ISP_V12 \|\| dev->isp_ver == ISP_V13) {
1614	2170	/* clear interrupts state */
1615	2171	readl(base + CIF_ISP_CSI0_ERR1);
..	..	@@ -1624,19 +2180,20 @@
1624	2180	}
1625	2181	}
1626	2182	/* Activate ISP */
1627		- val = rkisp_read(dev, CIF_ISP_CTRL, false);
	2183	+ val = rkisp_read_reg_cache(dev, CIF_ISP_CTRL);
1628	2184	val \|= CIF_ISP_CTRL_ISP_CFG_UPD \| CIF_ISP_CTRL_ISP_ENABLE \|
1629	2185	CIF_ISP_CTRL_ISP_INFORM_ENABLE \| CIF_ISP_CTRL_ISP_CFG_UPD_PERMANENT;
1630	2186	if (dev->isp_ver == ISP_V20)
1631	2187	val \|= NOC_HURRY_PRIORITY(2) \| NOC_HURRY_W_MODE(2) \| NOC_HURRY_R_MODE(1);
1632	2188	if (atomic_read(&dev->hw_dev->refcnt) > 1)
1633	2189	is_direct = false;
1634		- rkisp_write(dev, CIF_ISP_CTRL, val, is_direct);
	2190	+ rkisp_unite_write(dev, CIF_ISP_CTRL, val, is_direct, dev->hw_dev->is_unite);
	2191	+ rkisp_clear_reg_cache_bits(dev, CIF_ISP_CTRL, CIF_ISP_CTRL_ISP_CFG_UPD);
1635	2192
1636	2193	dev->isp_err_cnt = 0;
1637	2194	dev->isp_isr_cnt = 0;
1638	2195	dev->isp_state = ISP_START \| ISP_FRAME_END;
1639		- dev->irq_ends_mask \|= ISP_FRAME_END \| ISP_FRAME_IN;
	2196	+ dev->irq_ends_mask \|= ISP_FRAME_END;
1640	2197	dev->irq_ends = 0;
1641	2198
1642	2199	/* XXX: Is the 1000us too long?
..	..	@@ -2076,7 +2633,7 @@
2076	2633	struct rkisp_isp_subdev *isp_sd = sd_to_isp_sd(sd);
2077	2634	struct rkisp_device *dev = sd_to_isp_dev(sd);
2078	2635	struct v4l2_rect *crop;
2079		- u32 max_w, max_h;
	2636	+ u32 max_w, max_h, max_size;
2080	2637
2081	2638	if (!sel)
2082	2639	goto err;
..	..	@@ -2097,19 +2654,40 @@
2097	2654	crop->left = 0;
2098	2655	crop->top = 0;
2099	2656	if (sel->pad == RKISP_ISP_PAD_SINK) {
2100		- if (dev->isp_ver == ISP_V12) {
	2657	+ switch (dev->isp_ver) {
	2658	+ case ISP_V12:
2101	2659	max_w = CIF_ISP_INPUT_W_MAX_V12;
2102	2660	max_h = CIF_ISP_INPUT_H_MAX_V12;
2103		- } else if (dev->isp_ver == ISP_V13) {
	2661	+ break;
	2662	+ case ISP_V13:
2104	2663	max_w = CIF_ISP_INPUT_W_MAX_V13;
2105	2664	max_h = CIF_ISP_INPUT_H_MAX_V13;
2106		- } else if (dev->isp_ver == ISP_V21) {
	2665	+ break;
	2666	+ case ISP_V21:
2107	2667	max_w = CIF_ISP_INPUT_W_MAX_V21;
2108	2668	max_h = CIF_ISP_INPUT_H_MAX_V21;
2109		- } else {
	2669	+ break;
	2670	+ case ISP_V30:
	2671	+ max_w = dev->hw_dev->is_unite ?
	2672	+ CIF_ISP_INPUT_W_MAX_V30_UNITE : CIF_ISP_INPUT_W_MAX_V30;
	2673	+ max_h = dev->hw_dev->is_unite ?
	2674	+ CIF_ISP_INPUT_H_MAX_V30_UNITE : CIF_ISP_INPUT_H_MAX_V30;
	2675	+ break;
	2676	+ case ISP_V32:
	2677	+ max_w = CIF_ISP_INPUT_W_MAX_V32;
	2678	+ max_h = CIF_ISP_INPUT_H_MAX_V32;
	2679	+ break;
	2680	+ case ISP_V32_L:
	2681	+ max_w = CIF_ISP_INPUT_W_MAX_V32_L;
	2682	+ max_h = CIF_ISP_INPUT_H_MAX_V32_L;
	2683	+ break;
	2684	+ default:
2110	2685	max_w = CIF_ISP_INPUT_W_MAX;
2111	2686	max_h = CIF_ISP_INPUT_H_MAX;
2112	2687	}
	2688	+ max_size = max_w * max_h;
	2689	+ max_h = max_size / isp_sd->in_frm.width;
	2690	+
2113	2691	crop->width = min_t(u32, isp_sd->in_frm.width, max_w);
2114	2692	crop->height = min_t(u32, isp_sd->in_frm.height, max_h);
2115	2693	}
..	..	@@ -2125,6 +2703,40 @@
2125	2703	return 0;
2126	2704	err:
2127	2705	return -EINVAL;
	2706	+}
	2707	+
	2708	+static void rkisp_check_stream_dcrop(struct rkisp_device *dev,
	2709	+ struct v4l2_rect *crop)
	2710	+{
	2711	+ struct rkisp_stream *stream;
	2712	+ struct v4l2_rect *dcrop;
	2713	+ u32 i;
	2714	+
	2715	+ for (i = 0; i < RKISP_MAX_STREAM; i++) {
	2716	+ if (i != RKISP_STREAM_MP && i != RKISP_STREAM_SP &&
	2717	+ i != RKISP_STREAM_FBC && i != RKISP_STREAM_BP)
	2718	+ continue;
	2719	+ stream = &dev->cap_dev.stream[i];
	2720	+ dcrop = &stream->dcrop;
	2721	+ v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
	2722	+ "%s id:%d %dx%d(%d %d) from %dx%d(%d %d)\n",
	2723	+ __func__, i,
	2724	+ dcrop->width, dcrop->height, dcrop->left, dcrop->top,
	2725	+ crop->width, crop->height, crop->left, crop->top);
	2726	+ /* make sure dcrop window in isp output window */
	2727	+ if (dcrop->width > crop->width) {
	2728	+ dcrop->width = crop->width;
	2729	+ dcrop->left = 0;
	2730	+ } else if ((dcrop->left + dcrop->width) > crop->width) {
	2731	+ dcrop->left = crop->width - dcrop->width;
	2732	+ }
	2733	+ if (dcrop->height > crop->height) {
	2734	+ dcrop->height = crop->height;
	2735	+ dcrop->top = 0;
	2736	+ } else if ((dcrop->top + dcrop->height) > crop->height) {
	2737	+ dcrop->top = crop->height - dcrop->height;
	2738	+ }
	2739	+ }
2128	2740	}
2129	2741
2130	2742	static int rkisp_isp_sd_set_selection(struct v4l2_subdev *sd,
..	..	@@ -2158,18 +2770,20 @@
2158	2770
2159	2771	if (sel->pad == RKISP_ISP_PAD_SINK) {
2160	2772	isp_sd->in_crop = *crop;
2161		- /* ISP20 don't have out crop */
2162		- if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21) {
	2773	+ /* don't have out crop */
	2774	+ if (dev->isp_ver >= ISP_V20) {
2163	2775	isp_sd->out_crop = *crop;
2164	2776	isp_sd->out_crop.left = 0;
2165	2777	isp_sd->out_crop.top = 0;
2166	2778	dev->br_dev.crop = isp_sd->out_crop;
2167	2779	}
2168	2780	} else {
2169		- if (dev->isp_ver == ISP_V20 \|\| dev->isp_ver == ISP_V21)
	2781	+ if (dev->isp_ver >= ISP_V20)
2170	2782	*crop = isp_sd->out_crop;
2171	2783	isp_sd->out_crop = *crop;
2172	2784	}
	2785	+
	2786	+ rkisp_check_stream_dcrop(dev, crop);
2173	2787
2174	2788	return 0;
2175	2789	err:
..	..	@@ -2225,53 +2839,295 @@
2225	2839	struct rkisp_stream *stream;
2226	2840	int i;
2227	2841
	2842	+ rkisp_stats_first_ddr_config(&dev->stats_vdev);
2228	2843	if (dev->hw_dev->is_mi_update)
2229	2844	return;
2230	2845
2231		- rkisp_stats_first_ddr_config(&dev->stats_vdev);
2232	2846	rkisp_config_dmatx_valid_buf(dev);
2233	2847
2234	2848	force_cfg_update(dev);
2235	2849
2236	2850	hdr_update_dmatx_buf(dev);
2237		- if (dev->br_dev.en && dev->isp_ver == ISP_V20) {
2238		- stream = &dev->cap_dev.stream[RKISP_STREAM_SP];
2239		- rkisp_update_spstream_buf(stream);
2240		- }
2241	2851	if (dev->hw_dev->is_single) {
2242	2852	for (i = 0; i < RKISP_MAX_STREAM; i++) {
2243	2853	stream = &dev->cap_dev.stream[i];
2244		- if (stream->streaming)
2245		- stream->ops->frame_end(stream);
	2854	+ if (stream->id == RKISP_STREAM_VIR \|\|
	2855	+ stream->id == RKISP_STREAM_LUMA)
	2856	+ continue;
	2857	+ if (stream->streaming && !stream->curr_buf)
	2858	+ stream->ops->frame_end(stream, FRAME_INIT);
2246	2859	}
2247	2860	}
	2861	+ rkisp_stats_next_ddr_config(&dev->stats_vdev);
2248	2862	}
2249	2863
2250	2864	static int rkisp_isp_sd_s_stream(struct v4l2_subdev *sd, int on)
2251	2865	{
2252	2866	struct rkisp_device *isp_dev = sd_to_isp_dev(sd);
	2867	+ struct rkisp_hw_dev *hw_dev = isp_dev->hw_dev;
2253	2868
2254	2869	if (!on) {
2255		- rkisp_stop_3a_run(isp_dev);
	2870	+ if (IS_HDR_RDBK(isp_dev->rd_mode)) {
	2871	+ struct rkisp_stream *s;
	2872	+ int i;
	2873	+
	2874	+ for (i = RKISP_STREAM_RAWRD0; i <= RKISP_STREAM_RAWRD2; i++) {
	2875	+ s = &isp_dev->dmarx_dev.stream[i];
	2876	+ if (s->stopping)
	2877	+ wake_up(&s->done);
	2878	+ }
	2879	+ }
2256	2880	wait_event_timeout(isp_dev->sync_onoff,
2257		- isp_dev->irq_ends_mask == (ISP_FRAME_END \| ISP_FRAME_IN) &&
2258		- (!IS_HDR_RDBK(isp_dev->rd_mode) \|\|
2259		- isp_dev->isp_state & ISP_STOP), msecs_to_jiffies(5));
	2881	+ isp_dev->isp_state & ISP_STOP \|\|
	2882	+ !IS_HDR_RDBK(isp_dev->rd_mode),
	2883	+ msecs_to_jiffies(50));
2260	2884	rkisp_isp_stop(isp_dev);
2261		- atomic_dec(&isp_dev->hw_dev->refcnt);
	2885	+ atomic_dec(&hw_dev->refcnt);
2262	2886	rkisp_params_stream_stop(&isp_dev->params_vdev);
	2887	+ atomic_set(&isp_dev->isp_sdev.frm_sync_seq, 0);
	2888	+ rkisp_stop_3a_run(isp_dev);
2263	2889	return 0;
2264	2890	}
2265	2891
	2892	+ hw_dev->is_runing = true;
2266	2893	rkisp_start_3a_run(isp_dev);
2267	2894	memset(&isp_dev->isp_sdev.dbg, 0, sizeof(isp_dev->isp_sdev.dbg));
2268		- atomic_inc(&isp_dev->hw_dev->refcnt);
2269		- atomic_set(&isp_dev->isp_sdev.frm_sync_seq, 0);
2270		- rkisp_global_update_mi(isp_dev);
	2895	+ if (atomic_inc_return(&hw_dev->refcnt) > hw_dev->dev_link_num) {
	2896	+ dev_err(isp_dev->dev, "%s fail: input link before hw start\n", __func__);
	2897	+ atomic_dec(&hw_dev->refcnt);
	2898	+ return -EINVAL;
	2899	+ }
	2900	+
2271	2901	rkisp_config_cif(isp_dev);
2272	2902	rkisp_isp_start(isp_dev);
	2903	+ rkisp_global_update_mi(isp_dev);
2273	2904	rkisp_rdbk_trigger_event(isp_dev, T_CMD_QUEUE, NULL);
2274	2905	return 0;
	2906	+}
	2907	+
	2908	+static void rkisp_rx_buf_free(struct rkisp_device dev, struct rkisp_rx_buf dbufs)
	2909	+{
	2910	+ const struct vb2_mem_ops *g_ops = dev->hw_dev->mem_ops;
	2911	+ struct rkisp_rx_buf_pool *pool;
	2912	+ int i = 0;
	2913	+
	2914	+ if (!dbufs)
	2915	+ return;
	2916	+
	2917	+ for (i = 0; i < RKISP_RX_BUF_POOL_MAX; i++) {
	2918	+ pool = &dev->pv_pool[i];
	2919	+ if (dbufs == pool->dbufs) {
	2920	+ if (pool->mem_priv) {
	2921	+ g_ops->unmap_dmabuf(pool->mem_priv);
	2922	+ g_ops->detach_dmabuf(pool->mem_priv);
	2923	+ dma_buf_put(pool->dbufs->dbuf);
	2924	+ pool->mem_priv = NULL;
	2925	+ }
	2926	+ pool->dbufs = NULL;
	2927	+ break;
	2928	+ }
	2929	+ }
	2930	+}
	2931	+
	2932	+static void rkisp_rx_qbuf_online(struct rkisp_stream *stream,
	2933	+ struct rkisp_rx_buf_pool *pool)
	2934	+{
	2935	+ struct rkisp_device *dev = stream->ispdev;
	2936	+ u32 val = pool->buf.buff_addr[RKISP_PLANE_Y];
	2937	+
	2938	+ rkisp_write(dev, stream->config->mi.y_base_ad_init, val, false);
	2939	+ if (dev->hw_dev->is_unite) {
	2940	+ u32 offs = stream->out_fmt.width / 2 - RKMOUDLE_UNITE_EXTEND_PIXEL;
	2941	+
	2942	+ if (stream->memory)
	2943	+ offs *= DIV_ROUND_UP(stream->out_isp_fmt.bpp[0], 8);
	2944	+ else
	2945	+ offs = offs * stream->out_isp_fmt.bpp[0] / 8;
	2946	+ val += offs;
	2947	+ rkisp_next_write(dev, stream->config->mi.y_base_ad_init, val, false);
	2948	+ }
	2949	+}
	2950	+
	2951	+static void rkisp_rx_qbuf_rdbk(struct rkisp_stream *stream,
	2952	+ struct rkisp_rx_buf_pool *pool)
	2953	+{
	2954	+ struct rkisp_device *dev = stream->ispdev;
	2955	+ unsigned long lock_flags = 0;
	2956	+ struct rkisp_buffer *ispbuf = &pool->buf;
	2957	+ struct isp2x_csi_trigger trigger = {
	2958	+ .frame_timestamp = ispbuf->vb.vb2_buf.timestamp,
	2959	+ .sof_timestamp = ispbuf->vb.vb2_buf.timestamp,
	2960	+ .frame_id = ispbuf->vb.sequence,
	2961	+ .mode = 0,
	2962	+ .times = 0,
	2963	+ };
	2964	+ spin_lock_irqsave(&stream->vbq_lock, lock_flags);
	2965	+ if (list_empty(&stream->buf_queue) && !stream->curr_buf) {
	2966	+ stream->curr_buf = ispbuf;
	2967	+ stream->ops->update_mi(stream);
	2968	+ } else {
	2969	+ list_add_tail(&ispbuf->queue, &stream->buf_queue);
	2970	+ }
	2971	+ spin_unlock_irqrestore(&stream->vbq_lock, lock_flags);
	2972	+ if (stream->id == RKISP_STREAM_RAWRD2)
	2973	+ rkisp_rdbk_trigger_event(dev, T_CMD_QUEUE, &trigger);
	2974	+}
	2975	+
	2976	+static int rkisp_rx_qbuf(struct rkisp_device *dev,
	2977	+ struct rkisp_rx_buf *dbufs)
	2978	+{
	2979	+ struct rkisp_stream *stream;
	2980	+ struct rkisp_rx_buf_pool *pool;
	2981	+ int i;
	2982	+
	2983	+ for (i = 0; i < RKISP_RX_BUF_POOL_MAX; i++) {
	2984	+ pool = &dev->pv_pool[i];
	2985	+ if (dbufs == pool->dbufs)
	2986	+ break;
	2987	+ }
	2988	+
	2989	+ if (pool->dbufs == NULL \|\| pool->dbufs != dbufs)
	2990	+ return -EINVAL;
	2991	+ switch (dbufs->type) {
	2992	+ case BUF_SHORT:
	2993	+ stream = &dev->dmarx_dev.stream[RKISP_STREAM_RAWRD2];
	2994	+ break;
	2995	+ case BUF_MIDDLE:
	2996	+ stream = &dev->dmarx_dev.stream[RKISP_STREAM_RAWRD0];
	2997	+ break;
	2998	+ case BUF_LONG:
	2999	+ default:
	3000	+ stream = &dev->dmarx_dev.stream[RKISP_STREAM_RAWRD1];
	3001	+ }
	3002	+
	3003	+ v4l2_dbg(2, rkisp_debug, &dev->v4l2_dev,
	3004	+ "%s rd_mode:%d seq:%d dma:0x%x\n",
	3005	+ __func__, dev->rd_mode, dbufs->sequence,
	3006	+ pool->buf.buff_addr[RKISP_PLANE_Y]);
	3007	+
	3008	+ if (!IS_HDR_RDBK(dev->rd_mode)) {
	3009	+ rkisp_rx_qbuf_online(stream, pool);
	3010	+ } else {
	3011	+ pool->buf.vb.vb2_buf.timestamp = dbufs->timestamp;
	3012	+ pool->buf.vb.sequence = dbufs->sequence;
	3013	+ rkisp_rx_qbuf_rdbk(stream, pool);
	3014	+ }
	3015	+ return 0;
	3016	+}
	3017	+
	3018	+void rkisp_rx_buf_pool_free(struct rkisp_device *dev)
	3019	+{
	3020	+ const struct vb2_mem_ops *g_ops = dev->hw_dev->mem_ops;
	3021	+ struct rkisp_rx_buf_pool *pool;
	3022	+ int i;
	3023	+
	3024	+ for (i = 0; i < RKISP_RX_BUF_POOL_MAX; i++) {
	3025	+ pool = &dev->pv_pool[i];
	3026	+ if (!pool->dbufs)
	3027	+ break;
	3028	+ if (pool->mem_priv) {
	3029	+ g_ops->unmap_dmabuf(pool->mem_priv);
	3030	+ g_ops->detach_dmabuf(pool->mem_priv);
	3031	+ dma_buf_put(pool->dbufs->dbuf);
	3032	+ pool->mem_priv = NULL;
	3033	+ }
	3034	+ pool->dbufs = NULL;
	3035	+ }
	3036	+}
	3037	+
	3038	+static int rkisp_rx_buf_pool_init(struct rkisp_device *dev,
	3039	+ struct rkisp_rx_buf *dbufs)
	3040	+{
	3041	+ const struct vb2_mem_ops *g_ops = dev->hw_dev->mem_ops;
	3042	+ struct rkisp_stream *stream;
	3043	+ struct rkisp_rx_buf_pool *pool;
	3044	+ struct sg_table *sg_tbl;
	3045	+ dma_addr_t dma;
	3046	+ int i, ret;
	3047	+ void mem, vaddr = NULL;
	3048	+
	3049	+ for (i = 0; i < RKISP_RX_BUF_POOL_MAX; i++) {
	3050	+ pool = &dev->pv_pool[i];
	3051	+ if (!pool->dbufs)
	3052	+ break;
	3053	+ }
	3054	+
	3055	+ pool->dbufs = dbufs;
	3056	+ v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
	3057	+ "%s type:0x%x dbufs[%d]:%p", __func__, dbufs->type, i, dbufs);
	3058	+
	3059	+ if (dbufs->is_resmem) {
	3060	+ dma = dbufs->dma;
	3061	+ goto end;
	3062	+ }
	3063	+ mem = g_ops->attach_dmabuf(dev->hw_dev->dev, dbufs->dbuf,
	3064	+ dbufs->dbuf->size, DMA_BIDIRECTIONAL);
	3065	+ if (IS_ERR(mem)) {
	3066	+ ret = PTR_ERR(mem);
	3067	+ goto err;
	3068	+ }
	3069	+ pool->mem_priv = mem;
	3070	+ ret = g_ops->map_dmabuf(mem);
	3071	+ if (ret)
	3072	+ goto err;
	3073	+ if (dev->hw_dev->is_dma_sg_ops) {
	3074	+ sg_tbl = (struct sg_table *)g_ops->cookie(mem);
	3075	+ dma = sg_dma_address(sg_tbl->sgl);
	3076	+ } else {
	3077	+ dma = ((dma_addr_t )g_ops->cookie(mem));
	3078	+ }
	3079	+ get_dma_buf(dbufs->dbuf);
	3080	+ vaddr = g_ops->vaddr(mem);
	3081	+end:
	3082	+ dbufs->is_init = true;
	3083	+ pool->buf.other = dbufs;
	3084	+ pool->buf.buff_addr[RKISP_PLANE_Y] = dma;
	3085	+ pool->buf.vaddr[RKISP_PLANE_Y] = vaddr;
	3086	+
	3087	+ switch (dbufs->type) {
	3088	+ case BUF_SHORT:
	3089	+ stream = &dev->dmarx_dev.stream[RKISP_STREAM_RAWRD2];
	3090	+ break;
	3091	+ case BUF_MIDDLE:
	3092	+ stream = &dev->dmarx_dev.stream[RKISP_STREAM_RAWRD0];
	3093	+ break;
	3094	+ case BUF_LONG:
	3095	+ default:
	3096	+ stream = &dev->dmarx_dev.stream[RKISP_STREAM_RAWRD1];
	3097	+ }
	3098	+ if (dbufs->is_first) {
	3099	+ stream->memory = 0;
	3100	+ if (dbufs->is_uncompact)
	3101	+ stream->memory = SW_CSI_RAW_WR_SIMG_MODE;
	3102	+ rkisp_dmarx_set_fmt(stream, stream->out_fmt);
	3103	+ stream->ops->config_mi(stream);
	3104	+ dbufs->is_first = false;
	3105	+ }
	3106	+ v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
	3107	+ "%s dma:0x%x vaddr:%p", __func__, (u32)dma, vaddr);
	3108	+ return 0;
	3109	+err:
	3110	+ rkisp_rx_buf_pool_free(dev);
	3111	+ return ret;
	3112	+}
	3113	+
	3114	+static int rkisp_sd_s_rx_buffer(struct v4l2_subdev *sd,
	3115	+ void buf, unsigned int size)
	3116	+{
	3117	+ struct rkisp_device *dev = sd_to_isp_dev(sd);
	3118	+ struct rkisp_rx_buf *dbufs;
	3119	+ int ret = 0;
	3120	+
	3121	+ if (!buf)
	3122	+ return -EINVAL;
	3123	+
	3124	+ dbufs = buf;
	3125	+ if (!dbufs->is_init)
	3126	+ ret = rkisp_rx_buf_pool_init(dev, dbufs);
	3127	+ if (!ret)
	3128	+ ret = rkisp_rx_qbuf(dev, dbufs);
	3129	+
	3130	+ return ret;
2275	3131	}
2276	3132
2277	3133	static int rkisp_isp_sd_s_power(struct v4l2_subdev *sd, int on)
..	..	@@ -2279,14 +3135,11 @@
2279	3135	struct rkisp_device *isp_dev = sd_to_isp_dev(sd);
2280	3136	int ret;
2281	3137
2282		- if (isp_dev->hw_dev->is_thunderboot)
2283		- return 0;
2284		-
2285	3138	v4l2_dbg(1, rkisp_debug, &isp_dev->v4l2_dev,
2286	3139	"%s on:%d\n", __func__, on);
2287	3140
2288	3141	if (on) {
2289		- if (isp_dev->isp_ver == ISP_V20 \|\| isp_dev->isp_ver == ISP_V21)
	3142	+ if (isp_dev->isp_ver >= ISP_V20)
2290	3143	kfifo_reset(&isp_dev->rdbk_kfifo);
2291	3144	ret = pm_runtime_get_sync(isp_dev->dev);
2292	3145	} else {
..	..	@@ -2316,6 +3169,15 @@
2316	3169	dev = sd_to_isp_dev(sd);
2317	3170	if (!dev)
2318	3171	return -ENODEV;
	3172	+
	3173	+ if (dev->hw_dev->is_runing &&
	3174	+ (!dev->isp_inp \|\|
	3175	+ !(dev->isp_inp & ~rawrd) \|\|
	3176	+ !strcmp(remote->entity->name, CSI_DEV_NAME) \|\|
	3177	+ strstr(remote->entity->name, "rkcif"))) {
	3178	+ v4l2_err(sd, "no support link for isp hw working\n");
	3179	+ return -EINVAL;
	3180	+ }
2319	3181
2320	3182	if (!strcmp(remote->entity->name, DMA_VDEV_NAME)) {
2321	3183	stream = &dev->dmarx_dev.stream[RKISP_STREAM_DMARX];
..	..	@@ -2365,6 +3227,18 @@
2365	3227	} else {
2366	3228	dev->isp_inp &= ~INP_RAWRD2;
2367	3229	}
	3230	+ } else if (!strcmp(remote->entity->name, FBC_VDEV_NAME)) {
	3231	+ stream = &dev->cap_dev.stream[RKISP_STREAM_FBC];
	3232	+ } else if (!strcmp(remote->entity->name, BP_VDEV_NAME)) {
	3233	+ stream = &dev->cap_dev.stream[RKISP_STREAM_BP];
	3234	+ } else if (!strcmp(remote->entity->name, MPDS_VDEV_NAME)) {
	3235	+ stream = &dev->cap_dev.stream[RKISP_STREAM_MPDS];
	3236	+ } else if (!strcmp(remote->entity->name, BPDS_VDEV_NAME)) {
	3237	+ stream = &dev->cap_dev.stream[RKISP_STREAM_BPDS];
	3238	+ } else if (!strcmp(remote->entity->name, LUMA_VDEV_NAME)) {
	3239	+ stream = &dev->cap_dev.stream[RKISP_STREAM_LUMA];
	3240	+ } else if (!strcmp(remote->entity->name, VIR_VDEV_NAME)) {
	3241	+ stream = &dev->cap_dev.stream[RKISP_STREAM_VIR];
2368	3242	} else if (!strcmp(remote->entity->name, SP_VDEV_NAME)) {
2369	3243	stream = &dev->cap_dev.stream[RKISP_STREAM_SP];
2370	3244	} else if (!strcmp(remote->entity->name, MP_VDEV_NAME)) {
..	..	@@ -2409,11 +3283,31 @@
2409	3283
2410	3284	if (stream)
2411	3285	stream->linked = flags & MEDIA_LNK_FL_ENABLED;
2412		- if (dev->isp_inp & rawrd)
	3286	+ if (dev->isp_inp & rawrd) {
2413	3287	dev->dmarx_dev.trigger = T_MANUAL;
2414		- else
	3288	+ dev->is_rdbk_auto = false;
	3289	+ } else {
2415	3290	dev->dmarx_dev.trigger = T_AUTO;
	3291	+ }
	3292	+ if (dev->isp_inp & INP_CIF) {
	3293	+ struct v4l2_subdev *remote = get_remote_sensor(sd);
	3294	+ struct rkisp_vicap_mode mode;
2416	3295
	3296	+ memset(&mode, 0, sizeof(mode));
	3297	+ mode.name = dev->name;
	3298	+ mode.rdbk_mode = !!(dev->isp_inp & rawrd);
	3299	+ /* read back mode only */
	3300	+ if (dev->isp_ver < ISP_V30 \|\| !dev->hw_dev->is_single)
	3301	+ mode.rdbk_mode = RKISP_VICAP_RDBK_AIQ;
	3302	+ v4l2_subdev_call(remote, core, ioctl,
	3303	+ RKISP_VICAP_CMD_MODE, &mode);
	3304	+ dev->vicap_in = mode.input;
	3305	+ }
	3306	+
	3307	+ if (!dev->isp_inp)
	3308	+ dev->is_hw_link = false;
	3309	+ else
	3310	+ dev->is_hw_link = true;
2417	3311	v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
2418	3312	"isp input:0x%x\n", dev->isp_inp);
2419	3313	return 0;
..	..	@@ -2461,7 +3355,6 @@
2461	3355	atomic_inc_return(&isp->frm_sync_seq) - 1,
2462	3356	};
2463	3357
2464		- event.timestamp = ns_to_timespec(ktime_get_ns());
2465	3358	v4l2_event_queue(isp->sd.devnode, &event);
2466	3359	}
2467	3360
..	..	@@ -2478,24 +3371,95 @@
2478	3371	return v4l2_event_subscribe(fh, sub, ISP_V4L2_EVENT_ELEMS, NULL);
2479	3372	}
2480	3373
	3374	+static int rkisp_get_info(struct rkisp_device dev, struct rkisp_isp_info info)
	3375	+{
	3376	+ struct v4l2_rect *in_crop = &dev->isp_sdev.in_crop;
	3377	+ u32 rd_mode, mode = 0, bit = 0;
	3378	+ int ret;
	3379	+
	3380	+ if (!(dev->isp_state & ISP_START)) {
	3381	+ struct rkmodule_hdr_cfg cfg;
	3382	+
	3383	+ ret = rkisp_csi_get_hdr_cfg(dev, &cfg);
	3384	+ if (ret)
	3385	+ return ret;
	3386	+ rd_mode = cfg.hdr_mode;
	3387	+ if (rd_mode == HDR_COMPR)
	3388	+ bit = cfg.compr.bit > 20 ? 20 : cfg.compr.bit;
	3389	+ } else {
	3390	+ rd_mode = dev->rd_mode;
	3391	+ bit = dev->hdr.compr_bit;
	3392	+ }
	3393	+
	3394	+ switch (rd_mode) {
	3395	+ case HDR_RDBK_FRAME2:
	3396	+ case HDR_FRAMEX2_DDR:
	3397	+ case HDR_LINEX2_DDR:
	3398	+ mode = RKISP_ISP_HDR2;
	3399	+ break;
	3400	+ case HDR_RDBK_FRAME3:
	3401	+ case HDR_FRAMEX3_DDR:
	3402	+ case HDR_LINEX3_DDR:
	3403	+ mode = RKISP_ISP_HDR3;
	3404	+ break;
	3405	+ default:
	3406	+ mode = RKISP_ISP_NORMAL;
	3407	+ }
	3408	+ if (bit)
	3409	+ mode = RKISP_ISP_COMPR;
	3410	+ info->compr_bit = bit;
	3411	+
	3412	+ if (dev->is_bigmode)
	3413	+ mode \|= RKISP_ISP_BIGMODE;
	3414	+ info->mode = mode;
	3415	+ if (dev->hw_dev->is_unite)
	3416	+ info->act_width = in_crop->width / 2 + RKMOUDLE_UNITE_EXTEND_PIXEL;
	3417	+ else
	3418	+ info->act_width = in_crop->width;
	3419	+ info->act_height = in_crop->height;
	3420	+ return 0;
	3421	+}
	3422	+
2481	3423	static long rkisp_ioctl(struct v4l2_subdev sd, unsigned int cmd, void arg)
2482	3424	{
2483	3425	struct rkisp_device *isp_dev = sd_to_isp_dev(sd);
2484	3426	struct rkisp_thunderboot_resmem *resmem;
	3427	+ struct rkisp32_thunderboot_resmem_head *tb_head_v32;
2485	3428	struct rkisp_thunderboot_resmem_head *head;
2486	3429	struct rkisp_thunderboot_shmem *shmem;
2487	3430	struct isp2x_buf_idxfd *idxfd;
	3431	+ struct rkisp_rx_buf *dbufs;
2488	3432	void *resmem_va;
2489	3433	long ret = 0;
2490	3434
2491		- if (!arg && cmd != RKISP_CMD_FREE_SHARED_BUF)
	3435	+ if (!arg &&
	3436	+ (cmd != RKISP_CMD_FREE_SHARED_BUF &&
	3437	+ cmd != RKISP_CMD_MULTI_DEV_FORCE_ENUM))
2492	3438	return -EINVAL;
2493	3439
2494	3440	switch (cmd) {
2495	3441	case RKISP_CMD_TRIGGER_READ_BACK:
2496	3442	rkisp_rdbk_trigger_event(isp_dev, T_CMD_QUEUE, arg);
2497	3443	break;
	3444	+ case RKISP_CMD_GET_ISP_INFO:
	3445	+ rkisp_get_info(isp_dev, arg);
	3446	+ break;
	3447	+ case RKISP_CMD_GET_TB_HEAD_V32:
	3448	+ if (isp_dev->tb_head.complete != RKISP_TB_OK \|\| !isp_dev->is_pre_on) {
	3449	+ ret = -EINVAL;
	3450	+ break;
	3451	+ }
	3452	+ tb_head_v32 = arg;
	3453	+ memcpy(tb_head_v32, &isp_dev->tb_head,
	3454	+ sizeof(struct rkisp_thunderboot_resmem_head));
	3455	+ memcpy(&tb_head_v32->cfg, isp_dev->params_vdev.isp32_params,
	3456	+ sizeof(struct isp32_isp_params_cfg));
	3457	+ break;
2498	3458	case RKISP_CMD_GET_SHARED_BUF:
	3459	+ if (!IS_ENABLED(CONFIG_VIDEO_ROCKCHIP_THUNDER_BOOT_ISP)) {
	3460	+ ret = -ENOIOCTLCMD;
	3461	+ break;
	3462	+ }
2499	3463	resmem = (struct rkisp_thunderboot_resmem *)arg;
2500	3464	resmem->resmem_padr = isp_dev->resmem_pa;
2501	3465	resmem->resmem_size = isp_dev->resmem_size;
..	..	@@ -2525,6 +3489,10 @@
2525	3489	}
2526	3490	break;
2527	3491	case RKISP_CMD_FREE_SHARED_BUF:
	3492	+ if (!IS_ENABLED(CONFIG_VIDEO_ROCKCHIP_THUNDER_BOOT_ISP)) {
	3493	+ ret = -ENOIOCTLCMD;
	3494	+ break;
	3495	+ }
2528	3496	if (isp_dev->resmem_pa && isp_dev->resmem_size) {
2529	3497	dma_unmap_single(isp_dev->dev, isp_dev->resmem_pa,
2530	3498	sizeof(struct rkisp_thunderboot_resmem_head),
..	..	@@ -2543,15 +3511,38 @@
2543	3511	break;
2544	3512	case RKISP_CMD_SET_LDCHBUF_SIZE:
2545	3513	case RKISP_CMD_SET_MESHBUF_SIZE:
2546		- rkisp_params_set_meshbuf_size(&isp_dev->params_vdev, arg);
	3514	+ ret = rkisp_params_set_meshbuf_size(&isp_dev->params_vdev, arg);
2547	3515	break;
2548	3516	case RKISP_CMD_GET_SHM_BUFFD:
	3517	+ if (!IS_ENABLED(CONFIG_VIDEO_ROCKCHIP_THUNDER_BOOT_ISP)) {
	3518	+ ret = -ENOIOCTLCMD;
	3519	+ break;
	3520	+ }
2549	3521	shmem = (struct rkisp_thunderboot_shmem *)arg;
2550	3522	ret = rkisp_tb_shm_ioctl(shmem);
2551	3523	break;
2552	3524	case RKISP_CMD_GET_FBCBUF_FD:
2553	3525	idxfd = (struct isp2x_buf_idxfd *)arg;
2554	3526	ret = rkisp_bridge_get_fbcbuf_fd(isp_dev, idxfd);
	3527	+ break;
	3528	+ case RKISP_CMD_INFO2DDR:
	3529	+ ret = rkisp_params_info2ddr_cfg(&isp_dev->params_vdev, arg);
	3530	+ break;
	3531	+ case RKISP_CMD_MESHBUF_FREE:
	3532	+ rkisp_params_meshbuf_free(&isp_dev->params_vdev, (u64 )arg);
	3533	+ break;
	3534	+ case RKISP_VICAP_CMD_RX_BUFFER_FREE:
	3535	+ dbufs = (struct rkisp_rx_buf *)arg;
	3536	+ rkisp_rx_buf_free(isp_dev, dbufs);
	3537	+ break;
	3538	+ case RKISP_CMD_MULTI_DEV_FORCE_ENUM:
	3539	+ if (isp_dev->hw_dev->is_runing) {
	3540	+ ret = -EINVAL;
	3541	+ } else {
	3542	+ isp_dev->hw_dev->is_single = true;
	3543	+ isp_dev->hw_dev->is_multi_overflow = false;
	3544	+ rkisp_hw_enum_isp_size(isp_dev->hw_dev);
	3545	+ }
2555	3546	break;
2556	3547	default:
2557	3548	ret = -ENOIOCTLCMD;
..	..	@@ -2573,7 +3564,9 @@
2573	3564	struct rkisp_meshbuf_size meshsize;
2574	3565	struct rkisp_thunderboot_shmem shmem;
2575	3566	struct isp2x_buf_idxfd idxfd;
	3567	+ struct rkisp_info2ddr info2ddr;
2576	3568	long ret = 0;
	3569	+ u64 module_id;
2577	3570
2578	3571	if (!up && cmd != RKISP_CMD_FREE_SHARED_BUF)
2579	3572	return -EINVAL;
..	..	@@ -2585,11 +3578,19 @@
2585	3578	ret = rkisp_ioctl(sd, cmd, &trigger);
2586	3579	break;
2587	3580	case RKISP_CMD_GET_SHARED_BUF:
	3581	+ if (!IS_ENABLED(CONFIG_VIDEO_ROCKCHIP_THUNDER_BOOT_ISP)) {
	3582	+ ret = -ENOIOCTLCMD;
	3583	+ break;
	3584	+ }
2588	3585	ret = rkisp_ioctl(sd, cmd, &resmem);
2589	3586	if (!ret && copy_to_user(up, &resmem, sizeof(resmem)))
2590	3587	ret = -EFAULT;
2591	3588	break;
2592	3589	case RKISP_CMD_FREE_SHARED_BUF:
	3590	+ if (!IS_ENABLED(CONFIG_VIDEO_ROCKCHIP_THUNDER_BOOT_ISP)) {
	3591	+ ret = -ENOIOCTLCMD;
	3592	+ break;
	3593	+ }
2593	3594	ret = rkisp_ioctl(sd, cmd, NULL);
2594	3595	break;
2595	3596	case RKISP_CMD_GET_LDCHBUF_INFO:
..	..	@@ -2603,7 +3604,7 @@
2603	3604	ret = rkisp_ioctl(sd, cmd, &ldchsize);
2604	3605	break;
2605	3606	case RKISP_CMD_GET_MESHBUF_INFO:
2606		- if (copy_from_user(&meshsize, up, sizeof(meshsize)))
	3607	+ if (copy_from_user(&meshbuf, up, sizeof(meshbuf)))
2607	3608	return -EFAULT;
2608	3609	ret = rkisp_ioctl(sd, cmd, &meshbuf);
2609	3610	if (!ret && copy_to_user(up, &meshbuf, sizeof(meshbuf)))
..	..	@@ -2615,6 +3616,10 @@
2615	3616	ret = rkisp_ioctl(sd, cmd, &meshsize);
2616	3617	break;
2617	3618	case RKISP_CMD_GET_SHM_BUFFD:
	3619	+ if (!IS_ENABLED(CONFIG_VIDEO_ROCKCHIP_THUNDER_BOOT_ISP)) {
	3620	+ ret = -ENOIOCTLCMD;
	3621	+ break;
	3622	+ }
2618	3623	if (copy_from_user(&shmem, up, sizeof(shmem)))
2619	3624	return -EFAULT;
2620	3625	ret = rkisp_ioctl(sd, cmd, &shmem);
..	..	@@ -2625,6 +3630,21 @@
2625	3630	ret = rkisp_ioctl(sd, cmd, &idxfd);
2626	3631	if (!ret && copy_to_user(up, &idxfd, sizeof(idxfd)))
2627	3632	ret = -EFAULT;
	3633	+ break;
	3634	+ case RKISP_CMD_INFO2DDR:
	3635	+ if (copy_from_user(&info2ddr, up, sizeof(info2ddr)))
	3636	+ return -EFAULT;
	3637	+ ret = rkisp_ioctl(sd, cmd, &info2ddr);
	3638	+ if (!ret && copy_to_user(up, &info2ddr, sizeof(info2ddr)))
	3639	+ ret = -EFAULT;
	3640	+ break;
	3641	+ case RKISP_CMD_MESHBUF_FREE:
	3642	+ if (copy_from_user(&module_id, up, sizeof(module_id)))
	3643	+ return -EFAULT;
	3644	+ ret = rkisp_ioctl(sd, cmd, &module_id);
	3645	+ break;
	3646	+ case RKISP_CMD_MULTI_DEV_FORCE_ENUM:
	3647	+ ret = rkisp_ioctl(sd, cmd, NULL);
2628	3648	break;
2629	3649	default:
2630	3650	ret = -ENOIOCTLCMD;
..	..	@@ -2652,6 +3672,7 @@
2652	3672
2653	3673	static const struct v4l2_subdev_video_ops rkisp_isp_sd_video_ops = {
2654	3674	.s_stream = rkisp_isp_sd_s_stream,
	3675	+ .s_rx_buffer = rkisp_sd_s_rx_buffer,
2655	3676	};
2656	3677
2657	3678	static const struct v4l2_subdev_core_ops rkisp_isp_core_ops = {
..	..	@@ -2702,6 +3723,8 @@
2702	3723	struct v4l2_subdev *sd = &isp_sdev->sd;
2703	3724	int ret;
2704	3725
	3726	+ mutex_init(&isp_dev->buf_lock);
	3727	+ spin_lock_init(&isp_dev->cmsk_lock);
2705	3728	spin_lock_init(&isp_dev->rdbk_lock);
2706	3729	ret = kfifo_alloc(&isp_dev->rdbk_kfifo,
2707	3730	16 * sizeof(struct isp2x_csi_trigger), GFP_KERNEL);
..	..	@@ -2739,8 +3762,9 @@
2739	3762	rkisp_isp_sd_init_default_fmt(isp_sdev);
2740	3763	isp_dev->hdr.sensor = NULL;
2741	3764	isp_dev->isp_state = ISP_STOP;
2742		-
	3765	+ atomic_set(&isp_sdev->frm_sync_seq, 0);
2743	3766	rkisp_monitor_init(isp_dev);
	3767	+ INIT_WORK(&isp_dev->rdbk_work, rkisp_rdbk_work);
2744	3768	return 0;
2745	3769	err_cleanup_media_entity:
2746	3770	media_entity_cleanup(&sd->entity);
..	..	@@ -2783,53 +3807,96 @@
2783	3807	#ifdef CONFIG_VIDEO_ROCKCHIP_THUNDER_BOOT_ISP
2784	3808	void rkisp_chk_tb_over(struct rkisp_device *isp_dev)
2785	3809	{
	3810	+ struct rkisp_hw_dev *hw = isp_dev->hw_dev;
2786	3811	struct rkisp_thunderboot_resmem_head *head;
2787	3812	enum rkisp_tb_state tb_state;
2788	3813	void *resmem_va;
2789	3814
2790		- if (!isp_dev->hw_dev->is_thunderboot)
	3815	+ if (!isp_dev->is_thunderboot)
2791	3816	return;
2792		-
2793		- if (!atomic_read(&isp_dev->hw_dev->tb_ref)) {
2794		- rkisp_tb_set_state(RKISP_TB_NG);
2795		- rkisp_tb_unprotect_clk();
2796		- rkisp_register_irq(isp_dev->hw_dev);
2797		- isp_dev->hw_dev->is_thunderboot = false;
2798		- return;
2799		- }
2800	3817
2801	3818	resmem_va = phys_to_virt(isp_dev->resmem_pa);
2802	3819	head = (struct rkisp_thunderboot_resmem_head *)resmem_va;
2803		- if (isp_dev->is_thunderboot) {
2804		- shm_head_poll_timeout(isp_dev, !!head->enable, 2000, 200 * USEC_PER_MSEC);
2805		- shm_head_poll_timeout(isp_dev, !!head->complete, 5000, 600 * USEC_PER_MSEC);
2806		- if (head->complete != RKISP_TB_OK)
2807		- v4l2_info(&isp_dev->v4l2_dev,
2808		- "wait thunderboot over timeout\n");
	3820	+ dma_sync_single_for_cpu(isp_dev->dev, isp_dev->resmem_addr,
	3821	+ sizeof(struct rkisp_thunderboot_resmem_head),
	3822	+ DMA_FROM_DEVICE);
2809	3823
2810		- v4l2_info(&isp_dev->v4l2_dev,
2811		- "thunderboot info: %d, %d, %d, %d, %d, %d, 0x%x\n",
2812		- head->enable,
2813		- head->complete,
2814		- head->frm_total,
2815		- head->hdr_mode,
2816		- head->width,
2817		- head->height,
2818		- head->bus_fmt);
	3824	+ shm_head_poll_timeout(isp_dev, !!head->complete, 5000, 200 * USEC_PER_MSEC);
	3825	+ if (head->complete != RKISP_TB_OK) {
	3826	+ v4l2_err(&isp_dev->v4l2_dev, "wait thunderboot over timeout\n");
	3827	+ } else {
	3828	+ struct rkisp_isp_params_vdev *params_vdev = &isp_dev->params_vdev;
	3829	+ void *param = NULL;
	3830	+ u32 size = 0, offset = 0, timeout = 50;
2819	3831
2820		- tb_state = RKISP_TB_OK;
2821		- if (head->complete != RKISP_TB_OK) {
2822		- head->frm_total = 0;
2823		- tb_state = RKISP_TB_NG;
	3832	+ /* wait for all isp dev to register */
	3833	+ if (head->camera_num > 1) {
	3834	+ while (timeout--) {
	3835	+ if (hw->dev_num >= head->camera_num &&
	3836	+ hw->isp[hw->dev_num - 1]->is_probe_end)
	3837	+ break;
	3838	+ usleep_range(200, 210);
	3839	+ }
2824	3840	}
	3841	+
	3842	+ switch (isp_dev->isp_ver) {
	3843	+ case ISP_V32:
	3844	+ size = sizeof(struct rkisp32_thunderboot_resmem_head);
	3845	+ offset = size * isp_dev->dev_id;
	3846	+ break;
	3847	+ default:
	3848	+ break;
	3849	+ }
	3850	+
	3851	+ if (size && size < isp_dev->resmem_size) {
	3852	+ dma_sync_single_for_cpu(isp_dev->dev, isp_dev->resmem_addr + offset,
	3853	+ size, DMA_FROM_DEVICE);
	3854	+ params_vdev->is_first_cfg = true;
	3855	+ if (isp_dev->isp_ver == ISP_V32) {
	3856	+ struct rkisp32_thunderboot_resmem_head *tmp = resmem_va + offset;
	3857	+
	3858	+ param = &tmp->cfg;
	3859	+ head = &tmp->head;
	3860	+ v4l2_info(&isp_dev->v4l2_dev,
	3861	+ "tb param module en:0x%llx upd:0x%llx cfg upd:0x%llx\n",
	3862	+ tmp->cfg.module_en_update,
	3863	+ tmp->cfg.module_ens,
	3864	+ tmp->cfg.module_cfg_update);
	3865	+ }
	3866	+ if (param)
	3867	+ params_vdev->ops->save_first_param(params_vdev, param);
	3868	+ } else if (size > isp_dev->resmem_size) {
	3869	+ v4l2_err(&isp_dev->v4l2_dev,
	3870	+ "resmem size:%zu no enough for head:%d\n",
	3871	+ isp_dev->resmem_size, size);
	3872	+ head->complete = RKISP_TB_NG;
	3873	+ }
	3874	+ }
	3875	+ memcpy(&isp_dev->tb_head, head, sizeof(*head));
	3876	+ v4l2_info(&isp_dev->v4l2_dev,
	3877	+ "thunderboot info: %d, %d, %d, %d, %d, %d \| %d %d\n",
	3878	+ head->enable,
	3879	+ head->complete,
	3880	+ head->frm_total,
	3881	+ head->hdr_mode,
	3882	+ head->width,
	3883	+ head->height,
	3884	+ head->camera_num,
	3885	+ head->camera_index);
	3886	+
	3887	+ tb_state = RKISP_TB_OK;
	3888	+ if (head->complete != RKISP_TB_OK) {
	3889	+ head->frm_total = 0;
	3890	+ tb_state = RKISP_TB_NG;
	3891	+ }
	3892	+
	3893	+ if (hw->is_thunderboot) {
	3894	+ rkisp_register_irq(hw);
2825	3895	rkisp_tb_set_state(tb_state);
2826	3896	rkisp_tb_unprotect_clk();
2827		- rkisp_register_irq(isp_dev->hw_dev);
2828		- pm_runtime_put(isp_dev->hw_dev->dev);
2829		- isp_dev->hw_dev->is_thunderboot = false;
2830		- isp_dev->is_thunderboot = false;
2831		- atomic_dec(&isp_dev->hw_dev->tb_ref);
	3897	+ hw->is_thunderboot = false;
2832	3898	}
	3899	+ isp_dev->is_thunderboot = false;
2833	3900	}
2834	3901	#endif
2835	3902
..	..	@@ -2937,7 +4004,9 @@
2937	4004	unsigned int isp3a_mis,
2938	4005	struct rkisp_device *dev)
2939	4006	{
2940		- void __iomem *base = dev->base_addr;
	4007	+ struct rkisp_hw_dev *hw = dev->hw_dev;
	4008	+ void __iomem *base = !hw->is_unite ?
	4009	+ hw->base_addr : hw->base_next_addr;
2941	4010	unsigned int isp_mis_tmp = 0;
2942	4011	unsigned int isp_err = 0;
2943	4012	u32 si3a_isr_mask = ISP2X_SIAWB_DONE \| ISP2X_SIAF_FIN \|
..	..	@@ -2947,7 +4016,7 @@
2947	4016	ISP2X_3A_RAWHIST_BIG \| ISP2X_3A_RAWHIST_CH0 \|
2948	4017	ISP2X_3A_RAWHIST_CH1 \| ISP2X_3A_RAWHIST_CH2 \|
2949	4018	ISP2X_3A_RAWAF_SUM \| ISP2X_3A_RAWAF_LUM \|
2950		- ISP2X_3A_RAWAF \| ISP2X_3A_RAWAWB;
	4019	+ ISP2X_3A_RAWAWB;
2951	4020	bool sof_event_later = false;
2952	4021
2953	4022	/*
..	..	@@ -2957,30 +4026,36 @@
2957	4026	if (isp3a_mis & ISP2X_3A_RAWAE_BIG && dev->params_vdev.rdbk_times > 0)
2958	4027	writel(BIT(31), base + RAWAE_BIG1_BASE + RAWAE_BIG_CTRL);
2959	4028
	4029	+ if (hw->is_unite) {
	4030	+ u32 val = rkisp_read(dev, ISP3X_ISP_RIS, true);
	4031	+
	4032	+ if (val) {
	4033	+ rkisp_write(dev, ISP3X_ISP_ICR, val, true);
	4034	+ v4l2_dbg(3, rkisp_debug, &dev->v4l2_dev,
	4035	+ "left isp isr:0x%x\n", val);
	4036	+ if (isp_mis & CIF_ISP_FRAME && !(val & CIF_ISP_FRAME)) {
	4037	+ /* wait isp0 frame end */
	4038	+ int timeout = read_poll_timeout_atomic(rkisp_read,
	4039	+ val, val & CIF_ISP_FRAME, 20, 20 * 50, true, dev, ISP3X_ISP_RIS, true);
	4040	+
	4041	+ if (val)
	4042	+ rkisp_write(dev, ISP3X_ISP_ICR, val, true);
	4043	+ if (timeout)
	4044	+ dev_err(dev->dev, "wait isp end timeout\n");
	4045	+ }
	4046	+ }
	4047	+ }
2960	4048	v4l2_dbg(3, rkisp_debug, &dev->v4l2_dev,
2961	4049	"isp isr:0x%x, 0x%x\n", isp_mis, isp3a_mis);
2962	4050	dev->isp_isr_cnt++;
2963	4051	/* start edge of v_sync */
2964	4052	if (isp_mis & CIF_ISP_V_START) {
2965		- if (dev->isp_state & ISP_FRAME_END) {
2966		- u64 tmp = dev->isp_sdev.dbg.interval +
2967		- dev->isp_sdev.dbg.timestamp;
2968		-
2969		- dev->isp_sdev.dbg.timestamp = ktime_get_ns();
2970		- /* v-blank: frame_end - frame_start */
2971		- dev->isp_sdev.dbg.delay = dev->isp_sdev.dbg.timestamp - tmp;
2972		- }
2973		- rkisp_set_state(&dev->isp_state, ISP_FRAME_VS);
2974	4053	if (dev->hw_dev->monitor.is_en) {
2975	4054	rkisp_set_state(&dev->hw_dev->monitor.state, ISP_FRAME_VS);
2976	4055	if (!completion_done(&dev->hw_dev->monitor.cmpl))
2977	4056	complete(&dev->hw_dev->monitor.cmpl);
2978	4057	}
2979		- /* last vsync to config next buf */
2980		- if (!dev->filt_state[RDBK_F_VS])
2981		- rkisp_bridge_update_mi(dev, isp_mis);
2982		- else
2983		- dev->filt_state[RDBK_F_VS]--;
	4058	+
2984	4059	if (IS_HDR_RDBK(dev->hdr.op_mode)) {
2985	4060	/* read 3d lut at isp readback */
2986	4061	if (!dev->hw_dev->is_single)
..	..	@@ -2990,7 +4065,7 @@
2990	4065	}
2991	4066	if (dev->cap_dev.stream[RKISP_STREAM_SP].interlaced) {
2992	4067	/* 0 = ODD 1 = EVEN */
2993		- if (dev->active_sensor->mbus.type == V4L2_MBUS_CSI2) {
	4068	+ if (dev->active_sensor->mbus.type == V4L2_MBUS_CSI2_DPHY) {
2994	4069	void __iomem *addr = NULL;
2995	4070
2996	4071	if (dev->isp_ver == ISP_V10 \|\|
..	..	@@ -3014,6 +4089,7 @@
3014	4089	if (dev->vs_irq < 0 && !sof_event_later) {
3015	4090	dev->isp_sdev.frm_timestamp = ktime_get_ns();
3016	4091	rkisp_isp_queue_event_sof(&dev->isp_sdev);
	4092	+ rkisp_stream_frame_start(dev, isp_mis);
3017	4093	}
3018	4094	vs_skip:
3019	4095	writel(CIF_ISP_V_START, base + CIF_ISP_ICR);
..	..	@@ -3057,6 +4133,16 @@
3057	4133	}
3058	4134	}
3059	4135
	4136	+ if (isp3a_mis & ISP2X_3A_RAWAF) {
	4137	+ writel(ISP3X_3A_RAWAF, base + ISP3X_ISP_3A_ICR);
	4138	+ /* 3a irq will with lsc_lut_err irq if isp version below isp32 */
	4139	+ if (isp_mis & ISP2X_LSC_LUT_ERR)
	4140	+ isp_mis &= ~ISP2X_LSC_LUT_ERR;
	4141	+ if (dev->rawaf_irq_cnt == 0)
	4142	+ rkisp_stream_buf_done_early(dev);
	4143	+ dev->rawaf_irq_cnt++;
	4144	+ }
	4145	+
3060	4146	if (isp_mis & ISP2X_LSC_LUT_ERR) {
3061	4147	writel(ISP2X_LSC_LUT_ERR, base + CIF_ISP_ICR);
3062	4148
..	..	@@ -3068,21 +4154,22 @@
3068	4154
3069	4155	/* sampled input frame is complete */
3070	4156	if (isp_mis & CIF_ISP_FRAME_IN) {
	4157	+ dev->isp_sdev.dbg.interval =
	4158	+ ktime_get_ns() - dev->isp_sdev.dbg.timestamp;
3071	4159	rkisp_set_state(&dev->isp_state, ISP_FRAME_IN);
3072	4160	writel(CIF_ISP_FRAME_IN, base + CIF_ISP_ICR);
3073	4161	isp_mis_tmp = readl(base + CIF_ISP_MIS);
3074	4162	if (isp_mis_tmp & CIF_ISP_FRAME_IN)
3075	4163	v4l2_err(&dev->v4l2_dev, "isp icr frame_in err: 0x%x\n",
3076	4164	isp_mis_tmp);
3077		-
3078		- dev->isp_err_cnt = 0;
3079		- dev->isp_state &= ~ISP_ERROR;
3080	4165	}
3081	4166
3082	4167	/* frame was completely put out */
3083	4168	if (isp_mis & CIF_ISP_FRAME) {
3084		- dev->isp_sdev.dbg.interval =
3085		- ktime_get_ns() - dev->isp_sdev.dbg.timestamp;
	4169	+ dev->rawaf_irq_cnt = 0;
	4170	+ if (!dev->is_pre_on \|\| !IS_HDR_RDBK(dev->rd_mode))
	4171	+ dev->isp_sdev.dbg.interval =
	4172	+ ktime_get_ns() - dev->isp_sdev.dbg.timestamp;
3086	4173	/* Clear Frame In (ISP) */
3087	4174	rkisp_set_state(&dev->isp_state, ISP_FRAME_END);
3088	4175	writel(CIF_ISP_FRAME, base + CIF_ISP_ICR);
..	..	@@ -3092,6 +4179,25 @@
3092	4179	"isp icr frame end err: 0x%x\n", isp_mis_tmp);
3093	4180	rkisp_dmarx_get_frame(dev, &dev->isp_sdev.dbg.id, NULL, NULL, true);
3094	4181	rkisp_isp_read_add_fifo_data(dev);
	4182	+
	4183	+ dev->isp_err_cnt = 0;
	4184	+ dev->isp_state &= ~ISP_ERROR;
	4185	+ }
	4186	+
	4187	+ if (isp_mis & CIF_ISP_V_START) {
	4188	+ if (dev->isp_state & ISP_FRAME_END) {
	4189	+ u64 tmp = dev->isp_sdev.dbg.interval +
	4190	+ dev->isp_sdev.dbg.timestamp;
	4191	+
	4192	+ dev->isp_sdev.dbg.timestamp = ktime_get_ns();
	4193	+ /* v-blank: frame(N)start - frame(N-1)end */
	4194	+ dev->isp_sdev.dbg.delay = dev->isp_sdev.dbg.timestamp - tmp;
	4195	+ }
	4196	+ rkisp_set_state(&dev->isp_state, ISP_FRAME_VS);
	4197	+ if (dev->procfs.is_fs_wait) {
	4198	+ dev->procfs.is_fs_wait = false;
	4199	+ wake_up(&dev->procfs.fs_wait);
	4200	+ }
3095	4201	}
3096	4202
3097	4203	if ((isp_mis & (CIF_ISP_FRAME \| si3a_isr_mask)) \|\|
..	..	@@ -3108,6 +4214,21 @@
3108	4214
3109	4215	if ((isp_mis & CIF_ISP_FRAME) && dev->stats_vdev.rdbk_mode)
3110	4216	rkisp_stats_rdbk_enable(&dev->stats_vdev, false);
	4217	+
	4218	+ if (!IS_HDR_RDBK(dev->hdr.op_mode))
	4219	+ rkisp_config_cmsk(dev);
	4220	+ }
	4221	+
	4222	+ if (isp_mis & CIF_ISP_FRAME) {
	4223	+ if (dev->hw_dev->isp_ver == ISP_V32) {
	4224	+ struct rkisp_stream *s = &dev->cap_dev.stream[RKISP_STREAM_LUMA];
	4225	+
	4226	+ s->ops->frame_end(s, FRAME_IRQ);
	4227	+ }
	4228	+ if (dev->procfs.is_fe_wait) {
	4229	+ dev->procfs.is_fe_wait = false;
	4230	+ wake_up(&dev->procfs.fe_wait);
	4231	+ }
3111	4232	}
3112	4233
3113	4234	/*
..	..	@@ -3115,16 +4236,30 @@
3115	4236	* lot of register writes. Do those only one per frame.
3116	4237	* Do the updates in the order of the processing flow.
3117	4238	*/
3118		- rkisp_params_isr(&dev->params_vdev, isp_mis);
	4239	+ if (isp_mis & (CIF_ISP_V_START \| CIF_ISP_FRAME))
	4240	+ rkisp_params_isr(&dev->params_vdev, isp_mis);
3119	4241
3120	4242	/* cur frame end and next frame start irq togeter */
3121	4243	if (dev->vs_irq < 0 && sof_event_later) {
3122	4244	dev->isp_sdev.frm_timestamp = ktime_get_ns();
3123	4245	rkisp_isp_queue_event_sof(&dev->isp_sdev);
	4246	+ rkisp_stream_frame_start(dev, isp_mis);
3124	4247	}
3125	4248
3126		- if (isp_mis & CIF_ISP_FRAME_IN)
3127		- rkisp_check_idle(dev, ISP_FRAME_IN);
	4249	+ if (isp_mis & ISP3X_OUT_FRM_QUARTER) {
	4250	+ writel(ISP3X_OUT_FRM_QUARTER, base + CIF_ISP_ICR);
	4251	+ rkisp_dvbm_event(dev, ISP3X_OUT_FRM_QUARTER);
	4252	+ }
	4253	+ if (isp_mis & ISP3X_OUT_FRM_HALF) {
	4254	+ writel(ISP3X_OUT_FRM_HALF, base + CIF_ISP_ICR);
	4255	+ rkisp_dvbm_event(dev, ISP3X_OUT_FRM_HALF);
	4256	+ rkisp_stream_buf_done_early(dev);
	4257	+ }
	4258	+ if (isp_mis & ISP3X_OUT_FRM_END) {
	4259	+ writel(ISP3X_OUT_FRM_END, base + CIF_ISP_ICR);
	4260	+ rkisp_dvbm_event(dev, ISP3X_OUT_FRM_END);
	4261	+ }
	4262	+
3128	4263	if (isp_mis & CIF_ISP_FRAME)
3129	4264	rkisp_check_idle(dev, ISP_FRAME_END);
3130	4265	}