From f792fcee7ddb8752ee9af1fc9ef1960d0c8ddf11 Mon Sep 17 00:00:00 2001
From: Zheng Zhiqi <looper.zheng@rock-chips.com>
Date: Thu, 1 Feb 2024 17:17:45 +0800
Subject: [PATCH 01/10] ASoC: rockchip-spi-codec: fix kctonrol mute case crash

fix kcontrol mute case crash, tested by `dumpsys car_service inject-vhal-event 289475072 1,0`.

[  136.260357][  T632] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000010
[  136.262328][  T632] Mem abort info:
[  136.264924][  T632]   ESR = 0x96000005
[  136.265362][  T632]   EC = 0x25: DABT (current EL), IL = 32 bits
[  136.266072][  T632]   SET = 0, FnV = 0
[  136.266406][  T632]   EA = 0, S1PTW = 0
[  136.266772][  T632] Data abort info:
[  136.267094][  T632]   ISV = 0, ISS = 0x00000005
[  136.267518][  T632]   CM = 0, WnR = 0
[  136.267853][  T632] user pgtable: 4k pages, 39-bit VAs, pgdp=000000012871b000
[  136.268492][  T632] [0000000000000010] pgd=0000000000000000, p4d=0000000000000000, pud=0000000000000000
[  136.269342][  T632] Internal error: Oops: 96000005 [#1] PREEMPT SMP
[  136.269899][  T632] Modules linked in: ahci_platform libahci_platform himax_mmi ohci_platform ili210x ohci_hcd
[  136.270788][  T632] CPU: 2 PID: 632 Comm: android.hardwar Not tainted 5.10.198 #46
[  136.271453][  T632] Hardware name: Rockchip RK3588 VEHICLE EVB V22 Board (DT)
[  136.272077][  T632] pstate: 80400009 (Nzcv daif +PAN -UAO -TCO BTYPE=--)
[  136.272673][  T632] pc : spi_codec_ext_ch_mute_put+0x14/0x40
[  136.273178][  T632] lr : snd_ctl_elem_write+0x128/0x16c
[  136.273636][  T632] sp : ffffffc00e44bc10
[  136.273987][  T632] x29: ffffffc00e44bc10 x28: ffffff811e293900
[  136.274514][  T632] x27: 0000000000000000 x26: 0000000000000000
[  136.275040][  T632] x25: 0000000000000000 x24: ffffff81006024a0
[  136.275566][  T632] x23: ffffff8100602000 x22: 00000000c4c85513
[  136.276092][  T632] x21: ffffff8110838b00 x20: ffffff811cf0f000
[  136.276618][  T632] x19: ffffff8100602000 x18: ffffffc00dc45040
[  136.277144][  T632] x17: 0000000020000000 x16: 0000000000000001
[  136.277669][  T632] x15: 0000000000000000 x14: 000000020000001a
[  136.278195][  T632] x13: 754d206b63616279 x12: 0000000000000000
[  136.278722][  T632] x11: 0000000000006574 x10: 0000000000000000
[  136.279249][  T632] x9 : 0000000000000004 x8 : ffffff81038eb000
[  136.279781][  T632] x7 : 0000000000000000 x6 : ffffff811cf0f4c8
[  136.280311][  T632] x5 : ffffff811cf0f4c8 x4 : 0000000000000000
[  136.280840][  T632] x3 : 0000000000000000 x2 : ffffff811cf0f000
[  136.281367][  T632] x1 : ffffff811cf0f000 x0 : ffffff8107260c00
[  136.281894][  T632] Call trace:
[  136.282184][  T632]  spi_codec_ext_ch_mute_put+0x14/0x40
[  136.282655][  T632]  snd_ctl_elem_write+0x128/0x16c
[  136.283083][  T632]  snd_ctl_ioctl+0x7dc/0xb48
[  136.283479][  T632]  __arm64_sys_ioctl+0x90/0xc8
[  136.283888][  T632]  el0_svc_common+0xac/0x1ac
[  136.284283][  T632]  do_el0_svc+0x1c/0x28
[  136.284637][  T632]  el0_svc+0x10/0x1c
[  136.284968][  T632]  el0_sync_handler+0x68/0xac
[  136.285374][  T632]  el0_sync+0x164/0x180

Change-Id: I35ec1fb0974b8dd9b58bd6d8b2b362a414cb4cd7
Signed-off-by: Zheng Zhiqi <looper.zheng@rock-chips.com>
---
 sound/soc/codecs/rockchip-spi-codec.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/sound/soc/codecs/rockchip-spi-codec.c b/sound/soc/codecs/rockchip-spi-codec.c
index 6011e9451ff3..262e51a0f9e3 100644
--- a/sound/soc/codecs/rockchip-spi-codec.c
+++ b/sound/soc/codecs/rockchip-spi-codec.c
@@ -148,8 +148,7 @@ static int spi_codec_ext_ch_mute_get(struct snd_kcontrol *kcontrol,
 {
 	struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 	struct spi_codec_private *priv = snd_soc_component_get_drvdata(component);
-	struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value;
-	unsigned int ch = mc->reg;
+	unsigned int ch = (unsigned int)kcontrol->private_value;
 
 	ucontrol->value.integer.value[0] = priv->tdm_mute[ch];
 
@@ -161,8 +160,7 @@ static int spi_codec_ext_ch_mute_put(struct snd_kcontrol *kcontrol,
 {
 	struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 	struct spi_codec_private *priv = snd_soc_component_get_drvdata(component);
-	struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value;
-	unsigned int ch = mc->reg;
+	unsigned int ch = (unsigned int)kcontrol->private_value;
 
 	priv->tdm_mute[ch] = ucontrol->value.integer.value[0];
 

From 497d03d9a278624a1869cceeae26fde5f7c4338d Mon Sep 17 00:00:00 2001
From: Zefa Chen <zefa.chen@rock-chips.com>
Date: Wed, 31 Jan 2024 21:01:12 +0800
Subject: [PATCH 02/10] media: rockchip: vicap fixes dma_en logic err with
 constrant electricity and readback mode

Signed-off-by: Zefa Chen <zefa.chen@rock-chips.com>
Change-Id: I39c407234d07803f5880ed378f05814e510b528b
---
 drivers/media/platform/rockchip/cif/capture.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/drivers/media/platform/rockchip/cif/capture.c b/drivers/media/platform/rockchip/cif/capture.c
index 781028938897..b68234830445 100644
--- a/drivers/media/platform/rockchip/cif/capture.c
+++ b/drivers/media/platform/rockchip/cif/capture.c
@@ -4535,7 +4535,8 @@ static void rkcif_check_buffer_update_pingpong(struct rkcif_stream *stream,
 				stream->to_stop_dma = 0;
 				wake_up(&stream->wq_stopped);
 			} else {
-				stream->to_en_dma = RKCIF_DMAEN_BY_VICAP;
+				if (stream->cifdev->resume_mode != RKISP_RTT_MODE_ONE_FRAME)
+					stream->to_en_dma = RKCIF_DMAEN_BY_VICAP;
 				v4l2_dbg(3, rkcif_debug, &stream->cifdev->v4l2_dev,
 					 "%s stream[%d] start dma capture, frame cnt %d\n",
 					 __func__, stream->id, stream->frame_idx);
@@ -7516,6 +7517,7 @@ static long rkcif_ioctl_default(struct file *file, void *fh,
 			rkcif_dphy_quick_stream(dev, stream_param->on);
 			v4l2_subdev_call(dev->terminal_sensor.sd, core, ioctl,
 					 RKMODULE_SET_QUICK_STREAM, &stream_param->on);
+			dev->resume_mode = RKISP_RTT_MODE_MULTI_FRAME;
 		} else {
 			if (dev->sditf[0]->mode.rdbk_mode == RKISP_VICAP_ONLINE) {
 				for (i = 0; i < stream_num - 1; i++) {

From 3258128cd9dd2e61e37edfb17388a265da5d9d8c Mon Sep 17 00:00:00 2001
From: Lin Jinhan <troy.lin@rock-chips.com>
Date: Thu, 25 Jan 2024 16:11:36 +0800
Subject: [PATCH 03/10] crypto: rockchip: cryptodev: add
 akcipher_request_set_callback for rsa

Missing akcipher_request_set_callback will cause a process exception
 when rsa works in asynchronous mode.

Signed-off-by: Lin Jinhan <troy.lin@rock-chips.com>
Change-Id: I99d3ffde471269528f42869d052004a25a6c14b0
---
 drivers/crypto/rockchip/cryptodev_linux/rk_cryptodev.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/drivers/crypto/rockchip/cryptodev_linux/rk_cryptodev.c b/drivers/crypto/rockchip/cryptodev_linux/rk_cryptodev.c
index bf85f657e619..b2073fcb2721 100644
--- a/drivers/crypto/rockchip/cryptodev_linux/rk_cryptodev.c
+++ b/drivers/crypto/rockchip/cryptodev_linux/rk_cryptodev.c
@@ -708,6 +708,9 @@ static int crypto_rsa_run(struct fcrypt *fcr, struct kernel_crypt_rsa_op *krop)
 	crypto_init_wait(&wait);
 	akcipher_request_set_crypt(req, &src, &dst, rop->in_len, out_len_max);
 
+	akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
+				      crypto_req_done, &wait);
+
 	switch (rop->op) {
 	case AOP_ENCRYPT:
 		ret = crypto_wait_req(crypto_akcipher_encrypt(req), &wait);

From ad8ec7ddd07dce6569af1542102b51de09206a07 Mon Sep 17 00:00:00 2001
From: Lin Jinhan <troy.lin@rock-chips.com>
Date: Wed, 31 Jan 2024 10:39:32 +0800
Subject: [PATCH 04/10] crypto: rockchip: cryptodev: cipher support
 multithreading

Only HASH multithreading is restricted by the hardware. Therefore,
cipher removes the restriction on multithreading.

Signed-off-by: Lin Jinhan <troy.lin@rock-chips.com>
Change-Id: I8ec0cb31cd51e6acfa5582cd7778d6482674f1de
---
 .../crypto/rockchip/cryptodev_linux/ioctl.c   | 39 ++++++-------------
 1 file changed, 11 insertions(+), 28 deletions(-)

diff --git a/drivers/crypto/rockchip/cryptodev_linux/ioctl.c b/drivers/crypto/rockchip/cryptodev_linux/ioctl.c
index 032b016e476b..58d89a882295 100644
--- a/drivers/crypto/rockchip/cryptodev_linux/ioctl.c
+++ b/drivers/crypto/rockchip/cryptodev_linux/ioctl.c
@@ -324,8 +324,9 @@ crypto_create_session(struct fcrypt *fcr, struct session_op *sop)
 		goto session_error;
 	}
 
-	/* Non-multithreaded can only create one session */
-	if (!rk_cryptodev_multi_thread(NULL) &&
+	/* Non-multithreaded can only create one session for hash */
+	if (ses_new->hdata.init &&
+	    !rk_cryptodev_multi_thread(NULL) &&
 	    !atomic_dec_and_test(&cryptodev_sess)) {
 		atomic_inc(&cryptodev_sess);
 		ddebug(2, "Non-multithreaded can only create one session. sess = %d",
@@ -379,6 +380,14 @@ crypto_destroy_session(struct csession *ses_ptr)
 		mutex_lock(&ses_ptr->sem);
 	}
 	ddebug(2, "Removed session 0x%08X", ses_ptr->sid);
+
+	/* Non-multithreaded can only create one session for hash */
+	if (ses_ptr->hdata.init &&
+	    !rk_cryptodev_multi_thread(NULL)) {
+		atomic_inc(&cryptodev_sess);
+		ddebug(2, "Release cryptodev_sess = %d", atomic_read(&cryptodev_sess));
+	}
+
 	cryptodev_cipher_deinit(&ses_ptr->cdata);
 	cryptodev_hash_deinit(&ses_ptr->hdata);
 	ddebug(2, "freeing space for %d user pages", ses_ptr->array_size);
@@ -387,12 +396,6 @@ crypto_destroy_session(struct csession *ses_ptr)
 	mutex_unlock(&ses_ptr->sem);
 	mutex_destroy(&ses_ptr->sem);
 	kfree(ses_ptr);
-
-	/* Non-multithreaded can only create one session */
-	if (!rk_cryptodev_multi_thread(NULL)) {
-		atomic_inc(&cryptodev_sess);
-		ddebug(2, "Release cryptodev_sess = %d", atomic_read(&cryptodev_sess));
-	}
 }
 
 /* Look up a session by ID and remove. */
@@ -567,8 +570,6 @@ static void cryptask_routine(struct work_struct *work)
 }
 
 /* ====== /dev/crypto ====== */
-static atomic_t cryptodev_node = ATOMIC_INIT(1);
-
 static int
 cryptodev_open(struct inode *inode, struct file *filp)
 {
@@ -576,18 +577,6 @@ cryptodev_open(struct inode *inode, struct file *filp)
 	struct crypt_priv *pcr;
 	int i;
 
-	/* Non-multithreaded can only be opened once */
-	if (!rk_cryptodev_multi_thread(NULL) &&
-	    !atomic_dec_and_test(&cryptodev_node)) {
-		atomic_inc(&cryptodev_node);
-		ddebug(2, "Non-multithreaded can only be opened once. node = %d",
-		       atomic_read(&cryptodev_node));
-		return -EBUSY;
-	}
-
-	/* make sure sess == 1 after open */
-	atomic_set(&cryptodev_sess, 1);
-
 	pcr = kzalloc(sizeof(*pcr), GFP_KERNEL);
 	if (!pcr)
 		return -ENOMEM;
@@ -646,12 +635,6 @@ cryptodev_release(struct inode *inode, struct file *filp)
 	if (!pcr)
 		return 0;
 
-	/* Non-multithreaded can only be opened once */
-	if (!rk_cryptodev_multi_thread(NULL)) {
-		atomic_inc(&cryptodev_node);
-		ddebug(2, "Release cryptodev_node = %d", atomic_read(&cryptodev_node));
-	}
-
 	cancel_work_sync(&pcr->cryptask);
 
 	list_splice_tail(&pcr->todo.list, &pcr->free.list);

From b2cdfdd52ad0ab0f5b079dd014fcf327159bb9d6 Mon Sep 17 00:00:00 2001
From: Cai YiWei <cyw@rock-chips.com>
Date: Wed, 31 Jan 2024 14:16:02 +0800
Subject: [PATCH 05/10] media: rockchip: isp: fix isp32 bp min output

Change-Id: Ic711a9b668cc6f832d4752700e63db54a50ed594
Signed-off-by: Cai YiWei <cyw@rock-chips.com>
---
 drivers/media/platform/rockchip/isp/capture.c     | 8 --------
 drivers/media/platform/rockchip/isp/capture.h     | 8 ++++++++
 drivers/media/platform/rockchip/isp/capture_v32.c | 4 ++--
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/drivers/media/platform/rockchip/isp/capture.c b/drivers/media/platform/rockchip/isp/capture.c
index bad561885b92..76165eb4ba92 100644
--- a/drivers/media/platform/rockchip/isp/capture.c
+++ b/drivers/media/platform/rockchip/isp/capture.c
@@ -13,14 +13,6 @@
 #include "regs.h"
 #include "rkisp_tb_helper.h"
 
-#define STREAM_MAX_MP_RSZ_OUTPUT_WIDTH		4416
-#define STREAM_MAX_MP_RSZ_OUTPUT_HEIGHT		3312
-#define STREAM_MAX_SP_RSZ_OUTPUT_WIDTH		1920
-#define STREAM_MAX_SP_RSZ_OUTPUT_HEIGHT		1080
-#define STREAM_MIN_RSZ_OUTPUT_WIDTH		32
-#define STREAM_MIN_RSZ_OUTPUT_HEIGHT		32
-#define STREAM_OUTPUT_STEP_WISE			8
-
 #define STREAM_MIN_MP_SP_INPUT_WIDTH		STREAM_MIN_RSZ_OUTPUT_WIDTH
 #define STREAM_MIN_MP_SP_INPUT_HEIGHT		STREAM_MIN_RSZ_OUTPUT_HEIGHT
 
diff --git a/drivers/media/platform/rockchip/isp/capture.h b/drivers/media/platform/rockchip/isp/capture.h
index d382f6cd888c..26b9ee90aa6c 100644
--- a/drivers/media/platform/rockchip/isp/capture.h
+++ b/drivers/media/platform/rockchip/isp/capture.h
@@ -57,6 +57,14 @@
 #define DMATX2_VDEV_NAME DRIVER_NAME	"_rawwr2"
 #define DMATX3_VDEV_NAME DRIVER_NAME	"_rawwr3"
 
+#define STREAM_MAX_MP_RSZ_OUTPUT_WIDTH		4416
+#define STREAM_MAX_MP_RSZ_OUTPUT_HEIGHT		3312
+#define STREAM_MAX_SP_RSZ_OUTPUT_WIDTH		1920
+#define STREAM_MAX_SP_RSZ_OUTPUT_HEIGHT		1080
+#define STREAM_MIN_RSZ_OUTPUT_WIDTH		32
+#define STREAM_MIN_RSZ_OUTPUT_HEIGHT		32
+#define STREAM_OUTPUT_STEP_WISE			8
+
 struct rkisp_stream;
 
 enum {
diff --git a/drivers/media/platform/rockchip/isp/capture_v32.c b/drivers/media/platform/rockchip/isp/capture_v32.c
index e33313869ce1..a0d60cbd16e6 100644
--- a/drivers/media/platform/rockchip/isp/capture_v32.c
+++ b/drivers/media/platform/rockchip/isp/capture_v32.c
@@ -359,8 +359,8 @@ static struct stream_config rkisp_bp_stream_config = {
 	.fmt_size = ARRAY_SIZE(bp_fmts),
 	.max_rsz_width = CIF_ISP_INPUT_W_MAX_V32,
 	.max_rsz_height = CIF_ISP_INPUT_H_MAX_V32,
-	.min_rsz_width = CIF_ISP_INPUT_W_MIN,
-	.min_rsz_height = CIF_ISP_INPUT_H_MIN,
+	.min_rsz_width = STREAM_MIN_RSZ_OUTPUT_WIDTH,
+	.min_rsz_height = STREAM_MIN_RSZ_OUTPUT_HEIGHT,
 	.frame_end_id = ISP3X_MI_BP_FRAME,
 	.rsz = {
 		.ctrl = ISP32_BP_RESIZE_CTRL,

From ecb73404914e56776ce78cb0bdeae6a3ec6665aa Mon Sep 17 00:00:00 2001
From: Jianwei Fan <jianwei.fan@rock-chips.com>
Date: Mon, 29 Jan 2024 09:58:01 +0000
Subject: [PATCH 06/10] video: rockchip: vehicle: fix errors of get cif rst and
 irq

Signed-off-by: Jianwei Fan <jianwei.fan@rock-chips.com>
Change-Id: Ib84dbf242bb6611ed1ccbacf1b66e7ba23861cca
---
 drivers/video/rockchip/vehicle/vehicle_cif.c | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/drivers/video/rockchip/vehicle/vehicle_cif.c b/drivers/video/rockchip/vehicle/vehicle_cif.c
index ca9f092075fd..2671d9bc1394 100644
--- a/drivers/video/rockchip/vehicle/vehicle_cif.c
+++ b/drivers/video/rockchip/vehicle/vehicle_cif.c
@@ -5136,7 +5136,7 @@ int vehicle_cif_init(struct vehicle_cif *cif)
 		for (i = 0; i < clk->rsts_num; i++) {
 			struct reset_control *rst = NULL;
 
-			if (rk3568_cif_rsts[i])
+			if (rk3588_cif_rsts[i])
 				rst = devm_reset_control_get(dev, rk3588_cif_rsts[i]);
 			if (IS_ERR(rst)) {
 				dev_err(dev, "failed to get %s\n", rk3588_cif_rsts[i]);
@@ -5148,7 +5148,7 @@ int vehicle_cif_init(struct vehicle_cif *cif)
 		for (i = 0; i < clk->rsts_num; i++) {
 			struct reset_control *rst = NULL;
 
-			if (rk3568_cif_rsts[i])
+			if (rk3562_cif_rsts[i])
 				rst = devm_reset_control_get(dev, rk3562_cif_rsts[i]);
 			if (IS_ERR(rst)) {
 				dev_err(dev, "failed to get %s\n", rk3562_cif_rsts[i]);
@@ -5181,13 +5181,15 @@ int vehicle_cif_init(struct vehicle_cif *cif)
 
 	/*  3. request cif irq & mipi csi irq1-2 */
 	if (cif->chip_id >= CHIP_RK3588_VEHICLE_CIF) {
-		ret = request_irq(cif->irq, rk_camera_irq_v1, IRQF_SHARED, "vehicle_cif", cif);
+		ret = devm_request_irq(dev, cif->irq,
+				rk_camera_irq_v1, IRQF_SHARED, "vehicle_cif", cif);
 		if (ret < 0) {
 			VEHICLE_DGERR("request cif irq failed!\n");
 			return -EINVAL;
 		}
 	} else {
-		ret = request_irq(cif->irq, rk_camera_irq, IRQF_SHARED, "vehicle_cif", cif);
+		ret = devm_request_irq(dev, cif->irq,
+				rk_camera_irq, IRQF_SHARED, "vehicle_cif", cif);
 		if (ret < 0) {
 			VEHICLE_DGERR("request cif irq failed!\n");
 			return -EINVAL;
@@ -5197,14 +5199,14 @@ int vehicle_cif_init(struct vehicle_cif *cif)
 	VEHICLE_DG("%s(%d):\n", __func__, __LINE__);
 
 	if (inf_id == RKCIF_MIPI_LVDS) {
-		ret = request_irq(cif->csi2_irq1, vehicle_csirx_irq1,
+		ret = devm_request_irq(dev, cif->csi2_irq1, vehicle_csirx_irq1,
 				IRQF_SHARED, "vehicle_csi_intr1", cif);
 		if (ret < 0) {
 			VEHICLE_DGERR("request csirx irq1 failed!\n");
 			return -EINVAL;
 		}
 
-		ret = request_irq(cif->csi2_irq2, vehicle_csirx_irq2,
+		ret = devm_request_irq(dev, cif->csi2_irq2, vehicle_csirx_irq2,
 				IRQF_SHARED, "vehicle_csi_intr2", cif);
 		if (ret < 0) {
 			VEHICLE_DGERR("request csirx irq2 failed!\n");
@@ -5318,10 +5320,10 @@ int vehicle_cif_deinit(struct vehicle_cif *cif)
 		mutex_destroy(&dphy_hw->mutex);
 	}
 
-	free_irq(cif->irq, cif);
+	devm_free_irq(dev, cif->irq, cif);
 	if (inf_id == RKCIF_MIPI_LVDS) {
-		free_irq(cif->csi2_irq1, cif);
-		free_irq(cif->csi2_irq2, cif);
+		devm_free_irq(dev, cif->csi2_irq1, cif);
+		devm_free_irq(dev, cif->csi2_irq2, cif);
 	}
 	if (cif->err_state.err_print_wq) {
 		flush_workqueue(cif->err_state.err_print_wq);

From 270a72866c410811f779cf4c95328a801f72633f Mon Sep 17 00:00:00 2001
From: Jianwei Fan <jianwei.fan@rock-chips.com>
Date: Sat, 13 Jan 2024 02:31:35 +0000
Subject: [PATCH 07/10] media: i2c: rk628: add signal lost event report

Change-Id: I0cc2f643486ef3eebd3503d71e1aa5fdadaef0c2
Signed-off-by: Jianwei Fan <jianwei.fan@rock-chips.com>
---
 drivers/media/i2c/rk628/rk628_csi_v4l2.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/drivers/media/i2c/rk628/rk628_csi_v4l2.c b/drivers/media/i2c/rk628/rk628_csi_v4l2.c
index 303e92c77168..d9225e0eb89b 100644
--- a/drivers/media/i2c/rk628/rk628_csi_v4l2.c
+++ b/drivers/media/i2c/rk628/rk628_csi_v4l2.c
@@ -34,6 +34,7 @@
 #include <media/v4l2-event.h>
 #include <media/v4l2-fwnode.h>
 #include <video/videomode.h>
+#include <linux/rk_hdmirx_config.h>
 
 #include "rk628.h"
 #include "rk628_combrxphy.h"
@@ -1530,6 +1531,9 @@ static void rk628_work_isr(struct work_struct *work)
 	bool handled = false;
 	u32 csi0_raw_ints, csi1_raw_ints = 0x0;
 	u32 int0_status;
+	const struct v4l2_event evt_signal_lost = {
+		.type = RK_HDMIRX_V4L2_EVENT_SIGNAL_LOST,
+	};
 
 	mutex_lock(&csi->rk628->rst_lock);
 	rk628_i2c_read(csi->rk628, GRF_INTR0_STATUS, &int0_status);
@@ -1579,6 +1583,7 @@ static void rk628_work_isr(struct work_struct *work)
 				enable_stream(sd, false);
 				csi->nosignal = true;
 			}
+			v4l2_event_queue(sd->devnode, &evt_signal_lost);
 			schedule_delayed_work(&csi->delayed_work_res_change, msecs_to_jiffies(100));
 
 			v4l2_dbg(1, debug, sd, "%s: hact/vact change, md_ints: %#x\n",
@@ -1681,6 +1686,8 @@ static int rk628_csi_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
 		return v4l2_src_change_event_subdev_subscribe(sd, fh, sub);
 	case V4L2_EVENT_CTRL:
 		return v4l2_ctrl_subdev_subscribe_event(sd, fh, sub);
+	case RK_HDMIRX_V4L2_EVENT_SIGNAL_LOST:
+		return v4l2_event_subscribe(fh, sub, 0, NULL);
 	default:
 		return -EINVAL;
 	}
@@ -2488,10 +2495,13 @@ static irqreturn_t plugin_detect_irq(int irq, void *dev_id)
 {
 	struct rk628_csi *csi = dev_id;
 	struct v4l2_subdev *sd = &csi->sd;
+	const struct v4l2_event evt_signal_lost = {
+		.type = RK_HDMIRX_V4L2_EVENT_SIGNAL_LOST,
+	};
 
 	/* control hpd after 50ms */
 	schedule_delayed_work(&csi->delayed_work_enable_hotplug, HZ / 20);
-	tx_5v_power_present(sd);
+	v4l2_event_queue(sd->devnode, &evt_signal_lost);
 
 	return IRQ_HANDLED;
 }

From 2db9f54300bcd98854a4ec4774516d280f749d4d Mon Sep 17 00:00:00 2001
From: Ye Zhang <ye.zhang@rock-chips.com>
Date: Mon, 8 Jan 2024 16:56:44 +0800
Subject: [PATCH 08/10] thermal: rockchip: Round up code in
 rk_tsadcv2_temp_to_code

rk_tsadcv2_temp_to_code rounds down, so the temperature that triggers the
high temperature interrupt may be lower than the temperature we configured
in dts. Therefore, it may not be possible to update the trip when the high
temperature interrupt occurs, resulting in continuous interruptions.

Signed-off-by: Ye Zhang <ye.zhang@rock-chips.com>
Change-Id: I84511a612421b42a130c938b4573bddb6156dff6
---
 drivers/thermal/rockchip_thermal.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/drivers/thermal/rockchip_thermal.c b/drivers/thermal/rockchip_thermal.c
index c116277fea5a..10c078ccf1b2 100644
--- a/drivers/thermal/rockchip_thermal.c
+++ b/drivers/thermal/rockchip_thermal.c
@@ -786,7 +786,7 @@ static u32 rk_tsadcv2_temp_to_code(const struct chip_tsadc_table *table,
 	u32 error = table->data_mask;
 
 	if (table->kNum)
-		return (((temp / 1000) * table->kNum) / 1000 + table->bNum);
+		return DIV_ROUND_UP(temp / 100 * table->kNum, 10000) + table->bNum;
 
 	low = 0;
 	high = (table->length - 1) - 1; /* ignore the last check for table */
@@ -818,9 +818,9 @@ static u32 rk_tsadcv2_temp_to_code(const struct chip_tsadc_table *table,
 
 	switch (table->mode) {
 	case ADC_DECREMENT:
-		return table->id[mid].code - (num / denom);
+		return table->id[mid].code - DIV_ROUND_UP(num, denom);
 	case ADC_INCREMENT:
-		return table->id[mid].code + (num / denom);
+		return table->id[mid].code + DIV_ROUND_UP(num, denom);
 	default:
 		pr_err("%s: unknown table mode: %d\n", __func__, table->mode);
 		return error;

From 28d832ed84db51fdc6956bedb2d99bcb54b7809b Mon Sep 17 00:00:00 2001
From: Wangqiang Guo <kay.guo@rock-chips.com>
Date: Wed, 31 Jan 2024 01:30:13 +0000
Subject: [PATCH 09/10] arm64: dts: rockchip: rk3588-evb: reserve more CMA
 memory for HDMIRX.

HDMI-IN app require up to 5 buffers, about 118M.
The system may borrows some CMA memory cause errors.
Add more CMA memory to avoid problems.

Change-Id: Ifa03edef13604fc8ca1d26cd00f7fe4fce81b6da
Signed-off-by: Wangqiang Guo <kay.guo@rock-chips.com>
---
 arch/arm64/boot/dts/rockchip/rk3588-evb1-lp4.dtsi    | 4 ++--
 arch/arm64/boot/dts/rockchip/rk3588-evb7-lp4.dtsi    | 4 ++--
 arch/arm64/boot/dts/rockchip/rk3588-evb7-v11.dtsi    | 4 ++--
 arch/arm64/boot/dts/rockchip/rk3588-toybrick-x0.dtsi | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/arch/arm64/boot/dts/rockchip/rk3588-evb1-lp4.dtsi b/arch/arm64/boot/dts/rockchip/rk3588-evb1-lp4.dtsi
index a10dad37f9cf..9eabd7bb6c59 100644
--- a/arch/arm64/boot/dts/rockchip/rk3588-evb1-lp4.dtsi
+++ b/arch/arm64/boot/dts/rockchip/rk3588-evb1-lp4.dtsi
@@ -16,11 +16,11 @@
 		#size-cells = <2>;
 		ranges;
 
-		/* Reserve 128MB memory for hdmirx-controller@fdee0000 */
+		/* Reserve 256MB memory for hdmirx-controller@fdee0000 */
 		cma {
 			compatible = "shared-dma-pool";
 			reusable;
-			reg = <0x0 (256 * 0x100000) 0x0 (128 * 0x100000)>;
+			reg = <0x0 (256 * 0x100000) 0x0 (256 * 0x100000)>;
 			linux,cma-default;
 		};
 	};
diff --git a/arch/arm64/boot/dts/rockchip/rk3588-evb7-lp4.dtsi b/arch/arm64/boot/dts/rockchip/rk3588-evb7-lp4.dtsi
index 9e41ea8cfabf..d69b8ab52d6a 100644
--- a/arch/arm64/boot/dts/rockchip/rk3588-evb7-lp4.dtsi
+++ b/arch/arm64/boot/dts/rockchip/rk3588-evb7-lp4.dtsi
@@ -16,11 +16,11 @@
 		#size-cells = <2>;
 		ranges;
 
-		/* Reserve 128MB memory for hdmirx-controller@fdee0000 */
+		/* Reserve 256MB memory for hdmirx-controller@fdee0000 */
 		cma {
 			compatible = "shared-dma-pool";
 			reusable;
-			reg = <0x0 (256 * 0x100000) 0x0 (128 * 0x100000)>;
+			reg = <0x0 (256 * 0x100000) 0x0 (256 * 0x100000)>;
 			linux,cma-default;
 		};
 	};
diff --git a/arch/arm64/boot/dts/rockchip/rk3588-evb7-v11.dtsi b/arch/arm64/boot/dts/rockchip/rk3588-evb7-v11.dtsi
index 5bef2102f9dd..665346baf0b8 100644
--- a/arch/arm64/boot/dts/rockchip/rk3588-evb7-v11.dtsi
+++ b/arch/arm64/boot/dts/rockchip/rk3588-evb7-v11.dtsi
@@ -16,11 +16,11 @@
 		#size-cells = <2>;
 		ranges;
 
-		/* Reserve 128MB memory for hdmirx-controller@fdee0000 */
+		/* Reserve 256MB memory for hdmirx-controller@fdee0000 */
 		cma {
 			compatible = "shared-dma-pool";
 			reusable;
-			reg = <0x0 (256 * 0x100000) 0x0 (128 * 0x100000)>;
+			reg = <0x0 (256 * 0x100000) 0x0 (256 * 0x100000)>;
 			linux,cma-default;
 		};
 	};
diff --git a/arch/arm64/boot/dts/rockchip/rk3588-toybrick-x0.dtsi b/arch/arm64/boot/dts/rockchip/rk3588-toybrick-x0.dtsi
index b404fd1398f9..a1f264097f3e 100644
--- a/arch/arm64/boot/dts/rockchip/rk3588-toybrick-x0.dtsi
+++ b/arch/arm64/boot/dts/rockchip/rk3588-toybrick-x0.dtsi
@@ -16,11 +16,11 @@
 		#size-cells = <2>;
 		ranges;
 
-		/* Reserve 128MB memory for hdmirx-controller@fdee0000 */
+		/* Reserve 256MB memory for hdmirx-controller@fdee0000 */
 		cma {
 			compatible = "shared-dma-pool";
 			reusable;
-			reg = <0x0 (256 * 0x100000) 0x0 (128 * 0x100000)>;
+			reg = <0x0 (256 * 0x100000) 0x0 (256 * 0x100000)>;
 			linux,cma-default;
 		};
 	};

From 18b58076972c32dd56a9f6125bbafbb80c52ae33 Mon Sep 17 00:00:00 2001
From: Jianwei Fan <jianwei.fan@rock-chips.com>
Date: Thu, 12 May 2022 09:22:09 +0000
Subject: [PATCH 10/10] media: i2c: lt6911c: add lt6911c HDMI to MIPI-CSI2
 bridge driver

Signed-off-by: Jianwei Fan <jianwei.fan@rock-chips.com>
Change-Id: I1cce568db23a791291d06fcad096ece9e75047d4
---
 drivers/media/i2c/Kconfig   |   11 +
 drivers/media/i2c/Makefile  |    1 +
 drivers/media/i2c/lt6911c.c | 1465 +++++++++++++++++++++++++++++++++++
 3 files changed, 1477 insertions(+)
 create mode 100644 drivers/media/i2c/lt6911c.c

diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig
index 06c22f463328..9185d980e2bf 100644
--- a/drivers/media/i2c/Kconfig
+++ b/drivers/media/i2c/Kconfig
@@ -364,6 +364,17 @@ config VIDEO_IT6616
 	  To compile this driver as a module, choose M here: the
 	  module will be called IT6616.
 
+config VIDEO_LT6911C
+	tristate "Lontium LT6911UXC decoder"
+	depends on VIDEO_V4L2 && I2C && VIDEO_V4L2_SUBDEV_API
+	select HDMI
+	select V4L2_FWNODE
+	help
+	  Support for the Lontium LT6911C series HDMI to MIPI CSI-2 bridge.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called lt6911c.
+
 config VIDEO_LT6911UXC
 	tristate "Lontium LT6911UXC decoder"
 	depends on VIDEO_V4L2 && I2C && VIDEO_V4L2_SUBDEV_API
diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile
index 23975ba24d74..99a67255a5ed 100644
--- a/drivers/media/i2c/Makefile
+++ b/drivers/media/i2c/Makefile
@@ -177,6 +177,7 @@ obj-$(CONFIG_VIDEO_AW36518)	+= aw36518.o
 obj-$(CONFIG_VIDEO_LM3560)	+= lm3560.o
 obj-$(CONFIG_VIDEO_LM3646)	+= lm3646.o
 obj-$(CONFIG_VIDEO_SGM3784)	+= sgm3784.o
+obj-$(CONFIG_VIDEO_LT6911C)	+= lt6911c.o
 obj-$(CONFIG_VIDEO_LT6911UXC)	+= lt6911uxc.o
 obj-$(CONFIG_VIDEO_LT6911UXE)	+= lt6911uxe.o
 obj-$(CONFIG_VIDEO_IT6616)	+= it6616.o
diff --git a/drivers/media/i2c/lt6911c.c b/drivers/media/i2c/lt6911c.c
new file mode 100644
index 000000000000..5854a217cc9c
--- /dev/null
+++ b/drivers/media/i2c/lt6911c.c
@@ -0,0 +1,1465 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2024 Rockchip Electronics Co. Ltd.
+ *
+ * lt6911c HDMI to MIPI CSI-2 bridge driver.
+ *
+ * Author: Jianwei Fan <jianwei.fan@rock-chips.com>
+ *
+ * V0.0X01.0X00 first version.
+ *
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/gpio/consumer.h>
+#include <linux/hdmi.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of_graph.h>
+#include <linux/rk-camera-module.h>
+#include <linux/slab.h>
+#include <linux/timer.h>
+#include <linux/v4l2-dv-timings.h>
+#include <linux/version.h>
+#include <linux/videodev2.h>
+#include <linux/workqueue.h>
+#include <linux/compat.h>
+#include <media/v4l2-controls_rockchip.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-dv-timings.h>
+#include <media/v4l2-event.h>
+#include <media/v4l2-fwnode.h>
+
+#define DRIVER_VERSION			KERNEL_VERSION(0, 0x01, 0x00)
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "debug level (0-3)");
+
+#define I2C_MAX_XFER_SIZE	128
+#define POLL_INTERVAL_MS	1000
+
+#define LT6911C_LINK_FREQ	400000000
+#define LT6911C_PIXEL_RATE	400000000
+
+#define LT6911C_CHIPID	0x0516
+#define CHIPID_REGH	0xA001
+#define CHIPID_REGL	0xA000
+#define I2C_EN_REG	0x80EE
+#define I2C_ENABLE	0x1
+#define I2C_DISABLE	0x0
+
+#define AD_HALF_PIX_CLK         0x21
+#define SOURCE_DP_RX            0x10
+#define RECEIVED_INT		1
+
+#define HTOTAL_H		0xd289
+#define HTOTAL_L		0xd28a
+#define HACT_H			0xd28b
+#define HACT_L			0xd28c
+#define HFP_H			0xd29c
+#define HFP_L			0xd29d
+#define HS_H			0xd294
+#define HS_L			0xd295
+#define HBP_H			0xd298
+#define HBP_L			0xd299
+
+#define VTOTAL_H		0xd29e
+#define VTOTAL_L		0xd29f
+#define VACT_H			0xd296
+#define VACT_L			0xd297
+#define VBP			0xd287
+#define VFP			0xd288
+#define VS			0xd286
+
+#define FM_CLK_SEL              0xa034
+#define FREQ_METER_H		0xb8b1
+#define FREQ_METER_M		0xb8b2
+#define FREQ_METER_L		0xb8b3
+#define RG_MK_PRESET_SEL        0xd283
+
+#define STREAM_CTL		0x900a
+#define ENABLE_STREAM		0xbf
+#define DISABLE_STREAM		0xbe
+
+#define LT6911C_NAME			"LT6911C"
+
+static const s64 link_freq_menu_items[] = {
+	LT6911C_LINK_FREQ,
+};
+
+struct lt6911c_state {
+	struct v4l2_fwnode_bus_mipi_csi2 bus;
+	struct v4l2_subdev sd;
+	struct media_pad pad;
+	struct v4l2_ctrl_handler hdl;
+	struct i2c_client *i2c_client;
+	struct mutex confctl_mutex;
+	struct v4l2_ctrl *detect_tx_5v_ctrl;
+	struct v4l2_ctrl *audio_sampling_rate_ctrl;
+	struct v4l2_ctrl *audio_present_ctrl;
+	struct v4l2_ctrl *link_freq;
+	struct v4l2_ctrl *pixel_rate;
+	struct delayed_work delayed_work_enable_hotplug;
+	struct delayed_work delayed_work_res_change;
+	struct v4l2_dv_timings timings;
+	struct clk *xvclk;
+	struct gpio_desc *reset_gpio;
+	struct gpio_desc *plugin_det_gpio;
+	struct gpio_desc *hpd_ctl_gpio;
+	struct gpio_desc *power_gpio;
+	struct work_struct work_i2c_poll;
+	struct timer_list timer;
+	const char *module_facing;
+	const char *module_name;
+	const char *len_name;
+	const struct lt6911c_mode *cur_mode;
+	bool nosignal;
+	bool enable_hdcp;
+	bool is_audio_present;
+	int plugin_irq;
+	u32 mbus_fmt_code;
+	u8 csi_lanes_in_use;
+	u32 module_index;
+	u32 audio_sampling_rate;
+};
+
+static const struct v4l2_dv_timings_cap lt6911c_timings_cap = {
+	.type = V4L2_DV_BT_656_1120,
+	.reserved = { 0 },
+	V4L2_INIT_BT_TIMINGS(1, 10000, 1, 10000, 0, 400000000,
+			V4L2_DV_BT_STD_CEA861 | V4L2_DV_BT_STD_DMT |
+			V4L2_DV_BT_STD_GTF | V4L2_DV_BT_STD_CVT,
+			V4L2_DV_BT_CAP_PROGRESSIVE | V4L2_DV_BT_CAP_INTERLACED |
+			V4L2_DV_BT_CAP_REDUCED_BLANKING |
+			V4L2_DV_BT_CAP_CUSTOM)
+};
+
+struct lt6911c_mode {
+	u32 width;
+	u32 height;
+	struct v4l2_fract max_fps;
+	u32 hts_def;
+	u32 vts_def;
+	u32 exp_def;
+};
+
+static const struct lt6911c_mode supported_modes[] = {
+	{
+		.width = 1920,
+		.height = 1080,
+		.max_fps = {
+			.numerator = 10000,
+			.denominator = 600000,
+		},
+		.hts_def = 2200,
+		.vts_def = 1125,
+	}, {
+		.width = 1280,
+		.height = 720,
+		.max_fps = {
+			.numerator = 10000,
+			.denominator = 600000,
+		},
+		.hts_def = 1650,
+		.vts_def = 750,
+	}, {
+		.width = 720,
+		.height = 576,
+		.max_fps = {
+			.numerator = 10000,
+			.denominator = 500000,
+		},
+		.hts_def = 864,
+		.vts_def = 625,
+	}, {
+		.width = 720,
+		.height = 480,
+		.max_fps = {
+			.numerator = 10000,
+			.denominator = 600000,
+		},
+		.hts_def = 858,
+		.vts_def = 525,
+	},
+};
+
+static void lt6911c_format_change(struct v4l2_subdev *sd);
+static int lt6911c_s_ctrl_detect_tx_5v(struct v4l2_subdev *sd);
+static int lt6911c_s_dv_timings(struct v4l2_subdev *sd,
+				struct v4l2_dv_timings *timings);
+
+static inline struct lt6911c_state *to_state(struct v4l2_subdev *sd)
+{
+	return container_of(sd, struct lt6911c_state, sd);
+}
+
+static void i2c_rd(struct v4l2_subdev *sd, u16 reg, u8 *values, u32 n)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+	struct i2c_client *client = lt6911c->i2c_client;
+	int err;
+	u8 buf[2] = { 0xFF, reg >> 8};
+	u8 reg_addr = reg & 0xFF;
+	struct i2c_msg msgs[3];
+
+	msgs[0].addr = client->addr;
+	msgs[0].flags = 0;
+	msgs[0].len = 2;
+	msgs[0].buf = buf;
+
+	msgs[1].addr = client->addr;
+	msgs[1].flags = 0;
+	msgs[1].len = 1;
+	msgs[1].buf = &reg_addr;
+
+	msgs[2].addr = client->addr;
+	msgs[2].flags = I2C_M_RD;
+	msgs[2].len = n;
+	msgs[2].buf = values;
+
+	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
+	if (err != ARRAY_SIZE(msgs)) {
+		v4l2_err(sd, "%s: reading register 0x%x from 0x%x failed\n",
+				__func__, reg, client->addr);
+	}
+
+	if (!debug)
+		return;
+
+	switch (n) {
+	case 1:
+		v4l2_info(sd, "I2C read 0x%04x = 0x%02x\n",
+			reg, values[0]);
+		break;
+	case 2:
+		v4l2_info(sd, "I2C read 0x%04x = 0x%02x%02x\n",
+			reg, values[1], values[0]);
+		break;
+	case 4:
+		v4l2_info(sd, "I2C read 0x%04x = 0x%02x%02x%02x%02x\n",
+			reg, values[3], values[2], values[1], values[0]);
+		break;
+	default:
+		v4l2_info(sd, "I2C read %d bytes from address 0x%04x\n",
+			n, reg);
+	}
+}
+
+static void i2c_wr(struct v4l2_subdev *sd, u16 reg, u8 *values, u32 n)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+	struct i2c_client *client = lt6911c->i2c_client;
+	int err, i;
+	struct i2c_msg msgs[2];
+	u8 data[I2C_MAX_XFER_SIZE];
+	u8 buf[2] = { 0xFF, reg >> 8};
+
+	if ((1 + n) > I2C_MAX_XFER_SIZE) {
+		n = I2C_MAX_XFER_SIZE - 1;
+		v4l2_warn(sd, "i2c wr reg=%04x: len=%d is too big!\n",
+			  reg, 1 + n);
+	}
+
+	msgs[0].addr = client->addr;
+	msgs[0].flags = 0;
+	msgs[0].len = 2;
+	msgs[0].buf = buf;
+
+	msgs[1].addr = client->addr;
+	msgs[1].flags = 0;
+	msgs[1].len = 1 + n;
+	msgs[1].buf = data;
+
+	data[0] = reg & 0xff;
+	for (i = 0; i < n; i++)
+		data[1 + i] = values[i];
+
+	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
+	if (err < 0) {
+		v4l2_err(sd, "%s: writing register 0x%x from 0x%x failed\n",
+				__func__, reg, client->addr);
+		return;
+	}
+
+	if (!debug)
+		return;
+
+	switch (n) {
+	case 1:
+		v4l2_info(sd, "I2C write 0x%04x = 0x%02x\n",
+				reg, data[1]);
+		break;
+	case 2:
+		v4l2_info(sd, "I2C write 0x%04x = 0x%02x%02x\n",
+				reg, data[2], data[1]);
+		break;
+	case 4:
+		v4l2_info(sd, "I2C write 0x%04x = 0x%02x%02x%02x%02x\n",
+				reg, data[4], data[3], data[2], data[1]);
+		break;
+	default:
+		v4l2_info(sd, "I2C write %d bytes from address 0x%04x\n",
+				n, reg);
+	}
+}
+
+static u8 i2c_rd8(struct v4l2_subdev *sd, u16 reg)
+{
+	u32 val;
+
+	i2c_rd(sd, reg, (u8 __force *)&val, 1);
+	return val;
+}
+
+static void i2c_wr8(struct v4l2_subdev *sd, u16 reg, u8 val)
+{
+	i2c_wr(sd, reg, &val, 1);
+}
+
+static void lt6911c_i2c_enable(struct v4l2_subdev *sd)
+{
+	i2c_wr8(sd, I2C_EN_REG, I2C_ENABLE);
+}
+
+static void lt6911c_i2c_disable(struct v4l2_subdev *sd)
+{
+	i2c_wr8(sd, I2C_EN_REG, I2C_DISABLE);
+}
+
+static inline bool tx_5v_power_present(struct v4l2_subdev *sd)
+{
+	bool ret;
+	int val, i, cnt;
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	/* if not use plugin det gpio */
+	if (!lt6911c->plugin_det_gpio)
+		return true;
+
+	cnt = 0;
+	for (i = 0; i < 5; i++) {
+		val = gpiod_get_value(lt6911c->plugin_det_gpio);
+		if (val > 0)
+			cnt++;
+		usleep_range(500, 600);
+	}
+
+	ret = (cnt >= 3) ? true : false;
+	v4l2_dbg(1, debug, sd, "%s: %d\n", __func__, ret);
+
+	return ret;
+}
+
+static inline bool no_signal(struct v4l2_subdev *sd)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	v4l2_dbg(1, debug, sd, "%s no signal:%d\n", __func__,
+			lt6911c->nosignal);
+
+	return lt6911c->nosignal;
+}
+
+static inline bool audio_present(struct v4l2_subdev *sd)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	return lt6911c->is_audio_present;
+}
+
+static int get_audio_sampling_rate(struct v4l2_subdev *sd)
+{
+	static const int code_to_rate[] = {
+		44100, 0, 48000, 32000, 22050, 384000, 24000, 352800,
+		88200, 768000, 96000, 705600, 176400, 0, 192000, 0
+	};
+
+	if (no_signal(sd))
+		return 0;
+
+	return code_to_rate[2];
+}
+
+static inline unsigned int fps_calc(const struct v4l2_bt_timings *t)
+{
+	if (!V4L2_DV_BT_FRAME_HEIGHT(t) || !V4L2_DV_BT_FRAME_WIDTH(t))
+		return 0;
+
+	return DIV_ROUND_CLOSEST((unsigned int)t->pixelclock,
+			V4L2_DV_BT_FRAME_HEIGHT(t) * V4L2_DV_BT_FRAME_WIDTH(t));
+}
+
+static bool lt6911c_rcv_supported_res(struct v4l2_subdev *sd, u32 width,
+		u32 height)
+{
+	u32 i;
+
+	for (i = 0; i < ARRAY_SIZE(supported_modes); i++) {
+		if ((supported_modes[i].width == width) &&
+		    (supported_modes[i].height == height)) {
+			break;
+		}
+	}
+
+	if (i == ARRAY_SIZE(supported_modes)) {
+		v4l2_err(sd, "%s do not support res wxh: %dx%d\n", __func__,
+				width, height);
+		return false;
+	} else {
+		return true;
+	}
+}
+
+static int lt6911c_get_detected_timings(struct v4l2_subdev *sd,
+				     struct v4l2_dv_timings *timings)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+	struct v4l2_bt_timings *bt = &timings->bt;
+	u32 hact, vact, htotal, vtotal;
+	u32 hbp, hs, hfp, vbp, vs, vfp;
+	u32 pixel_clock, fps, halt_pix_clk;
+	u8 clk_h, clk_m, clk_l;
+	u8 value, val_h, val_l;
+
+	memset(timings, 0, sizeof(struct v4l2_dv_timings));
+
+	lt6911c_i2c_enable(sd);
+	i2c_wr8(sd, FM_CLK_SEL, AD_HALF_PIX_CLK);
+	mdelay(10);
+	clk_h = i2c_rd8(sd, FREQ_METER_H);
+	clk_m = i2c_rd8(sd, FREQ_METER_M);
+	clk_l = i2c_rd8(sd, FREQ_METER_L);
+	halt_pix_clk = (((clk_h & 0xf) << 16) | (clk_m << 8) | clk_l);
+	pixel_clock = halt_pix_clk * 2 * 1000;
+
+	i2c_wr8(sd, RG_MK_PRESET_SEL, SOURCE_DP_RX);
+	mdelay(10);
+	val_h = i2c_rd8(sd, HTOTAL_H);
+	val_l = i2c_rd8(sd, HTOTAL_L);
+	htotal = ((val_h << 8) | val_l) * 2;
+	val_h = i2c_rd8(sd, VTOTAL_H);
+	val_l = i2c_rd8(sd, VTOTAL_L);
+	vtotal = (val_h << 8) | val_l;
+	val_h = i2c_rd8(sd, HACT_H);
+	val_l = i2c_rd8(sd, HACT_L);
+	hact = ((val_h << 8) | val_l) * 2;
+	val_h = i2c_rd8(sd, VACT_H);
+	val_l = i2c_rd8(sd, VACT_L);
+	vact = (val_h << 8) | val_l;
+	val_h = i2c_rd8(sd, HS_H);
+	val_l = i2c_rd8(sd, HS_L);
+	hs = ((val_h << 8) | val_l) * 2;
+	value = i2c_rd8(sd, VS);
+	vs = value;
+	val_h = i2c_rd8(sd, HFP_H);
+	val_l = i2c_rd8(sd, HFP_L);
+	hfp = ((val_h << 8) | val_l) * 2;
+	value = i2c_rd8(sd, VFP);
+	vfp = value;
+	val_h = i2c_rd8(sd, HBP_H);
+	val_l = i2c_rd8(sd, HBP_L);
+	hbp = ((val_h << 8) | val_l) * 2;
+	value = i2c_rd8(sd, VBP);
+	vbp = value;
+
+	lt6911c_i2c_disable(sd);
+
+	if (!lt6911c_rcv_supported_res(sd, hact, vact)) {
+		lt6911c->nosignal = true;
+		v4l2_err(sd, "%s: rcv err res, return no signal!\n", __func__);
+		return -EINVAL;
+	}
+
+	lt6911c->nosignal = false;
+	lt6911c->is_audio_present = true;
+	timings->type = V4L2_DV_BT_656_1120;
+	bt->interlaced = V4L2_DV_PROGRESSIVE;
+	bt->width = hact;
+	bt->height = vact;
+	bt->vsync = vs;
+	bt->hsync = hs;
+	bt->pixelclock = pixel_clock;
+	bt->hfrontporch = hfp;
+	bt->vfrontporch = vfp;
+	bt->hbackporch = hbp;
+	bt->vbackporch = vbp;
+	fps = fps_calc(bt);
+
+	v4l2_info(sd, "act:%dx%d, total:%dx%d, pixclk:%d, fps:%d\n",
+			hact, vact, htotal, vtotal, pixel_clock, fps);
+	v4l2_info(sd, "hfp:%d, hs:%d, hbp:%d, vfp:%d, vs:%d, vbp:%d\n",
+			bt->hfrontporch, bt->hsync, bt->hbackporch,
+			bt->vfrontporch, bt->vsync, bt->vbackporch);
+	v4l2_info(sd, "inerlaced:%d,\n", bt->interlaced);
+
+	return 0;
+}
+
+static void lt6911c_config_hpd(struct v4l2_subdev *sd)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+	bool plugin;
+
+	plugin = tx_5v_power_present(sd);
+	v4l2_dbg(2, debug, sd, "%s: plugin: %d\n", __func__, plugin);
+
+	if (plugin) {
+		gpiod_set_value(lt6911c->hpd_ctl_gpio, 1);
+	} else {
+		lt6911c->nosignal = true;
+		gpiod_set_value(lt6911c->hpd_ctl_gpio, 0);
+	}
+}
+
+static void lt6911c_delayed_work_enable_hotplug(struct work_struct *work)
+{
+	struct delayed_work *dwork = to_delayed_work(work);
+	struct lt6911c_state *lt6911c = container_of(dwork,
+			struct lt6911c_state, delayed_work_enable_hotplug);
+	struct v4l2_subdev *sd = &lt6911c->sd;
+
+	lt6911c_config_hpd(sd);
+}
+
+static void lt6911c_delayed_work_res_change(struct work_struct *work)
+{
+	struct delayed_work *dwork = to_delayed_work(work);
+	struct lt6911c_state *lt6911c = container_of(dwork,
+			struct lt6911c_state, delayed_work_res_change);
+	struct v4l2_subdev *sd = &lt6911c->sd;
+
+	lt6911c_format_change(sd);
+}
+
+static int lt6911c_s_ctrl_detect_tx_5v(struct v4l2_subdev *sd)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	return v4l2_ctrl_s_ctrl(lt6911c->detect_tx_5v_ctrl,
+			tx_5v_power_present(sd));
+}
+
+static int lt6911c_s_ctrl_audio_sampling_rate(struct v4l2_subdev *sd)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	return v4l2_ctrl_s_ctrl(lt6911c->audio_sampling_rate_ctrl,
+			get_audio_sampling_rate(sd));
+}
+
+static int lt6911c_s_ctrl_audio_present(struct v4l2_subdev *sd)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	return v4l2_ctrl_s_ctrl(lt6911c->audio_present_ctrl,
+			audio_present(sd));
+}
+
+static int lt6911c_update_controls(struct v4l2_subdev *sd)
+{
+	int ret = 0;
+
+	ret |= lt6911c_s_ctrl_detect_tx_5v(sd);
+	ret |= lt6911c_s_ctrl_audio_sampling_rate(sd);
+	ret |= lt6911c_s_ctrl_audio_present(sd);
+
+	return ret;
+}
+
+static inline void enable_stream(struct v4l2_subdev *sd, bool enable)
+{
+	v4l2_dbg(2, debug, sd, "%s: %sable\n",
+			__func__, enable ? "en" : "dis");
+}
+
+static void lt6911c_format_change(struct v4l2_subdev *sd)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+	struct v4l2_dv_timings timings;
+	const struct v4l2_event lt6911c_ev_fmt = {
+		.type = V4L2_EVENT_SOURCE_CHANGE,
+		.u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION,
+	};
+
+	if (lt6911c_get_detected_timings(sd, &timings)) {
+		enable_stream(sd, false);
+
+		v4l2_dbg(1, debug, sd, "%s: No signal\n", __func__);
+	} else {
+		if (!v4l2_match_dv_timings(&lt6911c->timings, &timings, 0, false)) {
+			enable_stream(sd, false);
+			/* automatically set timing rather than set by user */
+			lt6911c_s_dv_timings(sd, &timings);
+			v4l2_print_dv_timings(sd->name,
+					"Format_change: New format: ",
+					&timings, false);
+		}
+	}
+
+	if (sd->devnode)
+		v4l2_subdev_notify_event(sd, &lt6911c_ev_fmt);
+}
+
+static int lt6911c_get_ctrl(struct v4l2_ctrl *ctrl)
+{
+	int ret = -1;
+	struct lt6911c_state *lt6911c = container_of(ctrl->handler,
+			struct lt6911c_state, hdl);
+	struct v4l2_subdev *sd = &(lt6911c->sd);
+
+	if (ctrl->id == V4L2_CID_DV_RX_POWER_PRESENT) {
+		ret = tx_5v_power_present(sd);
+		*ctrl->p_new.p_s32 = ret;
+	}
+
+	return ret;
+}
+
+static int lt6911c_isr(struct v4l2_subdev *sd, u32 status, bool *handled)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	schedule_delayed_work(&lt6911c->delayed_work_res_change, HZ / 20);
+	*handled = true;
+
+	return 0;
+}
+
+static irqreturn_t lt6911c_res_change_irq_handler(int irq, void *dev_id)
+{
+	struct lt6911c_state *lt6911c = dev_id;
+	bool handled;
+
+	lt6911c_isr(&lt6911c->sd, 0, &handled);
+
+	return handled ? IRQ_HANDLED : IRQ_NONE;
+}
+
+static irqreturn_t plugin_detect_irq_handler(int irq, void *dev_id)
+{
+	struct lt6911c_state *lt6911c = dev_id;
+	struct v4l2_subdev *sd = &lt6911c->sd;
+
+	/* control hpd output level after 25ms */
+	schedule_delayed_work(&lt6911c->delayed_work_enable_hotplug,
+			HZ / 40);
+	tx_5v_power_present(sd);
+
+	return IRQ_HANDLED;
+}
+
+static void lt6911c_irq_poll_timer(struct timer_list *t)
+{
+	struct lt6911c_state *lt6911c = from_timer(lt6911c, t, timer);
+
+	schedule_work(&lt6911c->work_i2c_poll);
+	mod_timer(&lt6911c->timer, jiffies + msecs_to_jiffies(POLL_INTERVAL_MS));
+}
+
+static void lt6911c_work_i2c_poll(struct work_struct *work)
+{
+	struct lt6911c_state *lt6911c = container_of(work,
+			struct lt6911c_state, work_i2c_poll);
+	struct v4l2_subdev *sd = &lt6911c->sd;
+
+	lt6911c_format_change(sd);
+}
+
+static int lt6911c_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
+				    struct v4l2_event_subscription *sub)
+{
+	switch (sub->type) {
+	case V4L2_EVENT_SOURCE_CHANGE:
+		return v4l2_src_change_event_subdev_subscribe(sd, fh, sub);
+	case V4L2_EVENT_CTRL:
+		return v4l2_ctrl_subdev_subscribe_event(sd, fh, sub);
+	default:
+		return -EINVAL;
+	}
+}
+
+static int lt6911c_g_input_status(struct v4l2_subdev *sd, u32 *status)
+{
+	*status = 0;
+	*status |= no_signal(sd) ? V4L2_IN_ST_NO_SIGNAL : 0;
+
+	v4l2_dbg(1, debug, sd, "%s: status = 0x%x\n", __func__, *status);
+
+	return 0;
+}
+
+static int lt6911c_s_dv_timings(struct v4l2_subdev *sd,
+				 struct v4l2_dv_timings *timings)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	if (!timings)
+		return -EINVAL;
+
+	if (debug)
+		v4l2_print_dv_timings(sd->name, "s_dv_timings: ",
+				timings, false);
+
+	if (v4l2_match_dv_timings(&lt6911c->timings, timings, 0, false)) {
+		v4l2_dbg(1, debug, sd, "%s: no change\n", __func__);
+		return 0;
+	}
+
+	if (!v4l2_valid_dv_timings(timings,
+				&lt6911c_timings_cap, NULL, NULL)) {
+		v4l2_dbg(1, debug, sd, "%s: timings out of range\n", __func__);
+		return -ERANGE;
+	}
+
+	lt6911c->timings = *timings;
+
+	enable_stream(sd, false);
+
+	return 0;
+}
+
+static int lt6911c_g_dv_timings(struct v4l2_subdev *sd,
+				struct v4l2_dv_timings *timings)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	*timings = lt6911c->timings;
+
+	return 0;
+}
+
+static int lt6911c_enum_dv_timings(struct v4l2_subdev *sd,
+				struct v4l2_enum_dv_timings *timings)
+{
+	if (timings->pad != 0)
+		return -EINVAL;
+
+	return v4l2_enum_dv_timings_cap(timings,
+			&lt6911c_timings_cap, NULL, NULL);
+}
+
+static int lt6911c_query_dv_timings(struct v4l2_subdev *sd,
+				struct v4l2_dv_timings *timings)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	*timings = lt6911c->timings;
+	if (debug)
+		v4l2_print_dv_timings(sd->name,
+				"query_dv_timings: ", timings, false);
+
+	if (!v4l2_valid_dv_timings(timings, &lt6911c_timings_cap, NULL,
+				NULL)) {
+		v4l2_dbg(1, debug, sd, "%s: timings out of range\n",
+				__func__);
+
+		return -ERANGE;
+	}
+
+	return 0;
+}
+
+static int lt6911c_dv_timings_cap(struct v4l2_subdev *sd,
+				struct v4l2_dv_timings_cap *cap)
+{
+	if (cap->pad != 0)
+		return -EINVAL;
+
+	*cap = lt6911c_timings_cap;
+
+	return 0;
+}
+
+static int lt6911c_g_mbus_config(struct v4l2_subdev *sd,
+			unsigned int pad, struct v4l2_mbus_config *cfg)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	cfg->type = V4L2_MBUS_CSI2_DPHY;
+	cfg->flags = V4L2_MBUS_CSI2_NONCONTINUOUS_CLOCK |
+			V4L2_MBUS_CSI2_CHANNEL_0;
+
+	switch (lt6911c->csi_lanes_in_use) {
+	case 1:
+		cfg->flags |= V4L2_MBUS_CSI2_1_LANE;
+		break;
+	case 2:
+		cfg->flags |= V4L2_MBUS_CSI2_2_LANE;
+		break;
+	case 3:
+		cfg->flags |= V4L2_MBUS_CSI2_3_LANE;
+		break;
+	case 4:
+		cfg->flags |= V4L2_MBUS_CSI2_4_LANE;
+		break;
+
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int lt6911c_s_stream(struct v4l2_subdev *sd, int enable)
+{
+	enable_stream(sd, enable);
+
+	return 0;
+}
+
+static int lt6911c_enum_mbus_code(struct v4l2_subdev *sd,
+			struct v4l2_subdev_pad_config *cfg,
+			struct v4l2_subdev_mbus_code_enum *code)
+{
+	switch (code->index) {
+	case 0:
+		code->code = MEDIA_BUS_FMT_UYVY8_2X8;
+		break;
+
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int lt6911c_enum_frame_sizes(struct v4l2_subdev *sd,
+				   struct v4l2_subdev_pad_config *cfg,
+				   struct v4l2_subdev_frame_size_enum *fse)
+{
+	if (fse->index >= ARRAY_SIZE(supported_modes))
+		return -EINVAL;
+
+	if (fse->code != MEDIA_BUS_FMT_UYVY8_2X8)
+		return -EINVAL;
+
+	fse->min_width  = supported_modes[fse->index].width;
+	fse->max_width  = supported_modes[fse->index].width;
+	fse->max_height = supported_modes[fse->index].height;
+	fse->min_height = supported_modes[fse->index].height;
+
+	return 0;
+}
+
+static int lt6911c_get_fmt(struct v4l2_subdev *sd,
+			struct v4l2_subdev_pad_config *cfg,
+			struct v4l2_subdev_format *format)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	mutex_lock(&lt6911c->confctl_mutex);
+	format->format.code = lt6911c->mbus_fmt_code;
+	format->format.width = lt6911c->timings.bt.width;
+	format->format.height = lt6911c->timings.bt.height;
+	format->format.field =
+		lt6911c->timings.bt.interlaced ?
+		V4L2_FIELD_INTERLACED : V4L2_FIELD_NONE;
+	format->format.colorspace = V4L2_COLORSPACE_SRGB;
+	mutex_unlock(&lt6911c->confctl_mutex);
+
+	v4l2_dbg(1, debug, sd, "%s: fmt code:%d, w:%d, h:%d, field code:%d\n",
+			__func__, format->format.code, format->format.width,
+			format->format.height, format->format.field);
+
+	return 0;
+}
+
+static int lt6911c_enum_frame_interval(struct v4l2_subdev *sd,
+				struct v4l2_subdev_pad_config *cfg,
+				struct v4l2_subdev_frame_interval_enum *fie)
+{
+	if (fie->index >= ARRAY_SIZE(supported_modes))
+		return -EINVAL;
+
+	if (fie->code != MEDIA_BUS_FMT_UYVY8_2X8)
+		return -EINVAL;
+
+	fie->width = supported_modes[fie->index].width;
+	fie->height = supported_modes[fie->index].height;
+	fie->interval = supported_modes[fie->index].max_fps;
+
+	return 0;
+}
+
+static int lt6911c_get_reso_dist(const struct lt6911c_mode *mode,
+				struct v4l2_mbus_framefmt *framefmt)
+{
+	return abs(mode->width - framefmt->width) +
+		abs(mode->height - framefmt->height);
+}
+
+static const struct lt6911c_mode *
+lt6911c_find_best_fit(struct v4l2_subdev_format *fmt)
+{
+	struct v4l2_mbus_framefmt *framefmt = &fmt->format;
+	int dist;
+	int cur_best_fit = 0;
+	int cur_best_fit_dist = -1;
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(supported_modes); i++) {
+		dist = lt6911c_get_reso_dist(&supported_modes[i], framefmt);
+		if (cur_best_fit_dist == -1 || dist < cur_best_fit_dist) {
+			cur_best_fit_dist = dist;
+			cur_best_fit = i;
+		}
+	}
+
+	return &supported_modes[cur_best_fit];
+}
+
+static int lt6911c_set_fmt(struct v4l2_subdev *sd,
+			struct v4l2_subdev_pad_config *cfg,
+			struct v4l2_subdev_format *format)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+	const struct lt6911c_mode *mode;
+
+	/* is overwritten by get_fmt */
+	u32 code = format->format.code;
+	int ret = lt6911c_get_fmt(sd, cfg, format);
+
+	format->format.code = code;
+
+	if (ret)
+		return ret;
+
+	switch (code) {
+	case MEDIA_BUS_FMT_UYVY8_2X8:
+		break;
+
+	default:
+		return -EINVAL;
+	}
+
+	if (format->which == V4L2_SUBDEV_FORMAT_TRY)
+		return 0;
+
+	lt6911c->mbus_fmt_code = format->format.code;
+	mode = lt6911c_find_best_fit(format);
+	lt6911c->cur_mode = mode;
+	enable_stream(sd, false);
+
+	return 0;
+}
+
+static int lt6911c_g_frame_interval(struct v4l2_subdev *sd,
+			struct v4l2_subdev_frame_interval *fi)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+	const struct lt6911c_mode *mode = lt6911c->cur_mode;
+
+	mutex_lock(&lt6911c->confctl_mutex);
+	fi->interval = mode->max_fps;
+	mutex_unlock(&lt6911c->confctl_mutex);
+
+	return 0;
+}
+
+static void lt6911c_get_module_inf(struct lt6911c_state *lt6911c,
+				  struct rkmodule_inf *inf)
+{
+	memset(inf, 0, sizeof(*inf));
+	strscpy(inf->base.sensor, LT6911C_NAME, sizeof(inf->base.sensor));
+	strscpy(inf->base.module, lt6911c->module_name, sizeof(inf->base.module));
+	strscpy(inf->base.lens, lt6911c->len_name, sizeof(inf->base.lens));
+}
+
+static long lt6911c_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
+{
+	struct lt6911c_state *lt6911c = to_state(sd);
+	long ret = 0;
+
+	switch (cmd) {
+	case RKMODULE_GET_MODULE_INFO:
+		lt6911c_get_module_inf(lt6911c, (struct rkmodule_inf *)arg);
+		break;
+	default:
+		ret = -ENOIOCTLCMD;
+		break;
+	}
+
+	return ret;
+}
+
+#ifdef CONFIG_COMPAT
+static long lt6911c_compat_ioctl32(struct v4l2_subdev *sd,
+				  unsigned int cmd, unsigned long arg)
+{
+	void __user *up = compat_ptr(arg);
+	struct rkmodule_inf *inf;
+	long ret;
+
+	switch (cmd) {
+	case RKMODULE_GET_MODULE_INFO:
+		inf = kzalloc(sizeof(*inf), GFP_KERNEL);
+		if (!inf) {
+			ret = -ENOMEM;
+			return ret;
+		}
+
+		ret = lt6911c_ioctl(sd, cmd, inf);
+		if (!ret) {
+			ret = copy_to_user(up, inf, sizeof(*inf));
+			if (ret)
+				ret = -EFAULT;
+		}
+		kfree(inf);
+		break;
+
+	default:
+		ret = -ENOIOCTLCMD;
+		break;
+	}
+
+	return ret;
+}
+#endif
+
+static const struct v4l2_ctrl_ops lt6911c_ctrl_ops = {
+	.g_volatile_ctrl = lt6911c_get_ctrl,
+};
+
+static const struct v4l2_subdev_core_ops lt6911c_core_ops = {
+	.interrupt_service_routine = lt6911c_isr,
+	.subscribe_event = lt6911c_subscribe_event,
+	.unsubscribe_event = v4l2_event_subdev_unsubscribe,
+	.ioctl = lt6911c_ioctl,
+#ifdef CONFIG_COMPAT
+	.compat_ioctl32 = lt6911c_compat_ioctl32,
+#endif
+};
+
+static const struct v4l2_subdev_video_ops lt6911c_video_ops = {
+	.g_input_status = lt6911c_g_input_status,
+	.s_dv_timings = lt6911c_s_dv_timings,
+	.g_dv_timings = lt6911c_g_dv_timings,
+	.query_dv_timings = lt6911c_query_dv_timings,
+	.s_stream = lt6911c_s_stream,
+	.g_frame_interval = lt6911c_g_frame_interval,
+};
+
+static const struct v4l2_subdev_pad_ops lt6911c_pad_ops = {
+	.enum_mbus_code = lt6911c_enum_mbus_code,
+	.enum_frame_size = lt6911c_enum_frame_sizes,
+	.enum_frame_interval = lt6911c_enum_frame_interval,
+	.set_fmt = lt6911c_set_fmt,
+	.get_fmt = lt6911c_get_fmt,
+	.enum_dv_timings = lt6911c_enum_dv_timings,
+	.dv_timings_cap = lt6911c_dv_timings_cap,
+	.get_mbus_config = lt6911c_g_mbus_config,
+};
+
+static const struct v4l2_subdev_ops lt6911c_ops = {
+	.core = &lt6911c_core_ops,
+	.video = &lt6911c_video_ops,
+	.pad = &lt6911c_pad_ops,
+};
+
+static const struct v4l2_ctrl_config lt6911c_ctrl_audio_sampling_rate = {
+	.id = RK_V4L2_CID_AUDIO_SAMPLING_RATE,
+	.name = "Audio sampling rate",
+	.type = V4L2_CTRL_TYPE_INTEGER,
+	.min = 0,
+	.max = 768000,
+	.step = 1,
+	.def = 0,
+	.flags = V4L2_CTRL_FLAG_READ_ONLY,
+};
+
+static const struct v4l2_ctrl_config lt6911c_ctrl_audio_present = {
+	.id = RK_V4L2_CID_AUDIO_PRESENT,
+	.name = "Audio present",
+	.type = V4L2_CTRL_TYPE_BOOLEAN,
+	.min = 0,
+	.max = 1,
+	.step = 1,
+	.def = 0,
+	.flags = V4L2_CTRL_FLAG_READ_ONLY,
+};
+
+static void lt6911c_reset(struct lt6911c_state *lt6911c)
+{
+	gpiod_set_value(lt6911c->reset_gpio, 0);
+	usleep_range(2000, 2100);
+	gpiod_set_value(lt6911c->reset_gpio, 1);
+	usleep_range(120*1000, 121*1000);
+	gpiod_set_value(lt6911c->reset_gpio, 0);
+	usleep_range(300*1000, 310*1000);
+}
+
+static int lt6911c_init_v4l2_ctrls(struct lt6911c_state *lt6911c)
+{
+	struct v4l2_subdev *sd;
+	int ret;
+
+	sd = &lt6911c->sd;
+	ret = v4l2_ctrl_handler_init(&lt6911c->hdl, 5);
+	if (ret)
+		return ret;
+
+	lt6911c->link_freq = v4l2_ctrl_new_int_menu(&lt6911c->hdl, NULL,
+			V4L2_CID_LINK_FREQ,
+			ARRAY_SIZE(link_freq_menu_items) - 1, 0,
+			link_freq_menu_items);
+	lt6911c->pixel_rate = v4l2_ctrl_new_std(&lt6911c->hdl, NULL,
+			V4L2_CID_PIXEL_RATE,
+			0, LT6911C_PIXEL_RATE, 1, LT6911C_PIXEL_RATE);
+
+	lt6911c->detect_tx_5v_ctrl = v4l2_ctrl_new_std(&lt6911c->hdl,
+			&lt6911c_ctrl_ops, V4L2_CID_DV_RX_POWER_PRESENT,
+			0, 1, 0, 0);
+	if (lt6911c->detect_tx_5v_ctrl)
+		lt6911c->detect_tx_5v_ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
+
+	lt6911c->audio_sampling_rate_ctrl =
+		v4l2_ctrl_new_custom(&lt6911c->hdl,
+				&lt6911c_ctrl_audio_sampling_rate, NULL);
+	lt6911c->audio_present_ctrl = v4l2_ctrl_new_custom(&lt6911c->hdl,
+			&lt6911c_ctrl_audio_present, NULL);
+
+	sd->ctrl_handler = &lt6911c->hdl;
+	if (lt6911c->hdl.error) {
+		ret = lt6911c->hdl.error;
+		v4l2_err(sd, "cfg v4l2 ctrls failed! ret:%d\n", ret);
+		return ret;
+	}
+
+	__v4l2_ctrl_s_ctrl(lt6911c->link_freq, link_freq_menu_items[0]);
+	__v4l2_ctrl_s_ctrl_int64(lt6911c->pixel_rate, LT6911C_PIXEL_RATE);
+
+	if (lt6911c_update_controls(sd)) {
+		ret = -ENODEV;
+		v4l2_err(sd, "update v4l2 ctrls failed! ret:%d\n", ret);
+		return ret;
+	}
+
+	return 0;
+}
+
+#ifdef CONFIG_OF
+static int lt6911c_probe_of(struct lt6911c_state *lt6911c)
+{
+	struct device *dev = &lt6911c->i2c_client->dev;
+	struct device_node *node = dev->of_node;
+	struct v4l2_fwnode_endpoint endpoint = { .bus_type = 0 };
+	struct device_node *ep;
+	int ret;
+
+	ret = of_property_read_u32(node, RKMODULE_CAMERA_MODULE_INDEX,
+			&lt6911c->module_index);
+	ret |= of_property_read_string(node, RKMODULE_CAMERA_MODULE_FACING,
+			&lt6911c->module_facing);
+	ret |= of_property_read_string(node, RKMODULE_CAMERA_MODULE_NAME,
+			&lt6911c->module_name);
+	ret |= of_property_read_string(node, RKMODULE_CAMERA_LENS_NAME,
+			&lt6911c->len_name);
+	if (ret) {
+		dev_err(dev, "could not get module information!\n");
+		return -EINVAL;
+	}
+
+	lt6911c->power_gpio = devm_gpiod_get_optional(dev, "power",
+			GPIOD_OUT_LOW);
+	if (IS_ERR(lt6911c->power_gpio)) {
+		dev_err(dev, "failed to get power gpio\n");
+		ret = PTR_ERR(lt6911c->power_gpio);
+		return ret;
+	}
+
+	lt6911c->reset_gpio = devm_gpiod_get_optional(dev, "reset",
+			GPIOD_OUT_HIGH);
+	if (IS_ERR(lt6911c->reset_gpio)) {
+		dev_err(dev, "failed to get reset gpio\n");
+		ret = PTR_ERR(lt6911c->reset_gpio);
+		return ret;
+	}
+
+	lt6911c->plugin_det_gpio = devm_gpiod_get_optional(dev, "plugin-det",
+			GPIOD_IN);
+	if (IS_ERR(lt6911c->plugin_det_gpio)) {
+		dev_err(dev, "failed to get plugin det gpio\n");
+		ret = PTR_ERR(lt6911c->plugin_det_gpio);
+		return ret;
+	}
+
+	lt6911c->hpd_ctl_gpio = devm_gpiod_get_optional(dev, "hpd-ctl",
+			GPIOD_OUT_HIGH);
+	if (IS_ERR(lt6911c->hpd_ctl_gpio)) {
+		dev_err(dev, "failed to get hpd ctl gpio\n");
+		ret = PTR_ERR(lt6911c->hpd_ctl_gpio);
+		return ret;
+	}
+
+	ep = of_graph_get_next_endpoint(dev->of_node, NULL);
+	if (!ep) {
+		dev_err(dev, "missing endpoint node\n");
+		return -EINVAL;
+	}
+
+	ret = v4l2_fwnode_endpoint_alloc_parse(of_fwnode_handle(ep), &endpoint);
+	if (ret) {
+		dev_err(dev, "failed to parse endpoint\n");
+		goto put_node;
+	}
+
+	if (endpoint.bus_type != V4L2_MBUS_CSI2_DPHY ||
+			endpoint.bus.mipi_csi2.num_data_lanes == 0) {
+		dev_err(dev, "missing CSI-2 properties in endpoint\n");
+		ret = -EINVAL;
+		goto free_endpoint;
+	}
+
+	lt6911c->xvclk = devm_clk_get(dev, "xvclk");
+	if (IS_ERR(lt6911c->xvclk)) {
+		dev_err(dev, "failed to get xvclk\n");
+		ret = -EINVAL;
+		goto free_endpoint;
+	}
+
+	ret = clk_prepare_enable(lt6911c->xvclk);
+	if (ret) {
+		dev_err(dev, "Failed! to enable xvclk\n");
+		goto free_endpoint;
+	}
+
+	lt6911c->csi_lanes_in_use = endpoint.bus.mipi_csi2.num_data_lanes;
+	lt6911c->bus = endpoint.bus.mipi_csi2;
+	lt6911c->enable_hdcp = false;
+
+	gpiod_set_value(lt6911c->hpd_ctl_gpio, 0);
+	gpiod_set_value(lt6911c->power_gpio, 1);
+	lt6911c_reset(lt6911c);
+
+	ret = 0;
+
+free_endpoint:
+	v4l2_fwnode_endpoint_free(&endpoint);
+put_node:
+	of_node_put(ep);
+	return ret;
+}
+#else
+static inline int lt6911c_probe_of(struct lt6911c_state *state)
+{
+	return -ENODEV;
+}
+#endif
+static int lt6911c_check_chip_id(struct lt6911c_state *lt6911c)
+{
+	struct device *dev = &lt6911c->i2c_client->dev;
+	struct v4l2_subdev *sd = &lt6911c->sd;
+	u8 id_h, id_l;
+	u32 chipid;
+	int ret = 0;
+
+	lt6911c_i2c_enable(sd);
+	id_l  = i2c_rd8(sd, CHIPID_REGL);
+	id_h  = i2c_rd8(sd, CHIPID_REGH);
+	lt6911c_i2c_disable(sd);
+
+	chipid = (id_h << 8) | id_l;
+	if (chipid != LT6911C_CHIPID) {
+		dev_err(dev, "chipid err, read:%#x, expect:%#x\n",
+				chipid, LT6911C_CHIPID);
+		return -EINVAL;
+	}
+	dev_info(dev, "check chipid ok, id:%#x", chipid);
+
+	return ret;
+}
+
+static int lt6911c_probe(struct i2c_client *client,
+			  const struct i2c_device_id *id)
+{
+	struct lt6911c_state *lt6911c;
+	struct v4l2_subdev *sd;
+	struct device *dev = &client->dev;
+	char facing[2];
+	int err;
+
+	dev_info(dev, "driver version: %02x.%02x.%02x",
+		DRIVER_VERSION >> 16,
+		(DRIVER_VERSION & 0xff00) >> 8,
+		DRIVER_VERSION & 0x00ff);
+
+	lt6911c = devm_kzalloc(dev, sizeof(struct lt6911c_state), GFP_KERNEL);
+	if (!lt6911c)
+		return -ENOMEM;
+
+	sd = &lt6911c->sd;
+	lt6911c->i2c_client = client;
+	lt6911c->cur_mode = &supported_modes[0];
+	lt6911c->mbus_fmt_code = MEDIA_BUS_FMT_UYVY8_2X8;
+
+	err = lt6911c_probe_of(lt6911c);
+	if (err) {
+		v4l2_err(sd, "lt6911c_parse_of failed! err:%d\n", err);
+		return err;
+	}
+
+	err = lt6911c_check_chip_id(lt6911c);
+	if (err < 0)
+		return err;
+
+	lt6911c_reset(lt6911c);
+
+	mutex_init(&lt6911c->confctl_mutex);
+	err = lt6911c_init_v4l2_ctrls(lt6911c);
+	if (err)
+		goto err_free_hdl;
+
+	client->flags |= I2C_CLIENT_SCCB;
+#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
+	v4l2_i2c_subdev_init(sd, client, &lt6911c_ops);
+	sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS;
+#endif
+
+#if defined(CONFIG_MEDIA_CONTROLLER)
+	lt6911c->pad.flags = MEDIA_PAD_FL_SOURCE;
+	sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
+	err = media_entity_pads_init(&sd->entity, 1, &lt6911c->pad);
+	if (err < 0) {
+		v4l2_err(sd, "media entity init failed! err:%d\n", err);
+		goto err_free_hdl;
+	}
+#endif
+	memset(facing, 0, sizeof(facing));
+	if (strcmp(lt6911c->module_facing, "back") == 0)
+		facing[0] = 'b';
+	else
+		facing[0] = 'f';
+
+	snprintf(sd->name, sizeof(sd->name), "m%02d_%s_%s %s",
+		 lt6911c->module_index, facing,
+		 LT6911C_NAME, dev_name(sd->dev));
+	err = v4l2_async_register_subdev_sensor_common(sd);
+	if (err < 0) {
+		v4l2_err(sd, "v4l2 register subdev failed! err:%d\n", err);
+		goto err_clean_entity;
+	}
+
+	INIT_DELAYED_WORK(&lt6911c->delayed_work_enable_hotplug,
+			lt6911c_delayed_work_enable_hotplug);
+	INIT_DELAYED_WORK(&lt6911c->delayed_work_res_change,
+			lt6911c_delayed_work_res_change);
+
+	if (lt6911c->i2c_client->irq) {
+		v4l2_dbg(1, debug, sd, "cfg lt6911c irq!\n");
+		err = devm_request_threaded_irq(dev,
+				lt6911c->i2c_client->irq,
+				NULL, lt6911c_res_change_irq_handler,
+				IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+				"lt6911c", lt6911c);
+		if (err) {
+			v4l2_err(sd, "request irq failed! err:%d\n", err);
+			goto err_work_queues;
+		}
+	} else {
+		v4l2_dbg(1, debug, sd, "no irq, cfg poll!\n");
+		INIT_WORK(&lt6911c->work_i2c_poll, lt6911c_work_i2c_poll);
+		timer_setup(&lt6911c->timer, lt6911c_irq_poll_timer, 0);
+		lt6911c->timer.expires = jiffies +
+				       msecs_to_jiffies(POLL_INTERVAL_MS);
+		add_timer(&lt6911c->timer);
+	}
+
+	lt6911c->plugin_irq = gpiod_to_irq(lt6911c->plugin_det_gpio);
+	if (lt6911c->plugin_irq < 0)
+		dev_err(dev, "failed to get plugin det irq, maybe no use\n");
+
+	err = devm_request_threaded_irq(dev, lt6911c->plugin_irq, NULL,
+			plugin_detect_irq_handler, IRQF_TRIGGER_FALLING |
+			IRQF_TRIGGER_RISING | IRQF_ONESHOT, "lt6911c",
+			lt6911c);
+	if (err)
+		dev_err(dev, "failed to register plugin det irq (%d), maybe no use\n", err);
+
+	err = v4l2_ctrl_handler_setup(sd->ctrl_handler);
+	if (err) {
+		v4l2_err(sd, "v4l2 ctrl handler setup failed! err:%d\n", err);
+		goto err_work_queues;
+	}
+
+	lt6911c_config_hpd(sd);
+	v4l2_info(sd, "%s found @ 0x%x (%s)\n", client->name,
+			client->addr << 1, client->adapter->name);
+
+	return 0;
+
+err_work_queues:
+	if (!lt6911c->i2c_client->irq)
+		flush_work(&lt6911c->work_i2c_poll);
+	cancel_delayed_work(&lt6911c->delayed_work_enable_hotplug);
+	cancel_delayed_work(&lt6911c->delayed_work_res_change);
+err_clean_entity:
+#if defined(CONFIG_MEDIA_CONTROLLER)
+	media_entity_cleanup(&sd->entity);
+#endif
+err_free_hdl:
+	v4l2_ctrl_handler_free(&lt6911c->hdl);
+	mutex_destroy(&lt6911c->confctl_mutex);
+	return err;
+}
+
+static int lt6911c_remove(struct i2c_client *client)
+{
+	struct v4l2_subdev *sd = i2c_get_clientdata(client);
+	struct lt6911c_state *lt6911c = to_state(sd);
+
+	if (!lt6911c->i2c_client->irq) {
+		del_timer_sync(&lt6911c->timer);
+		flush_work(&lt6911c->work_i2c_poll);
+	}
+	cancel_delayed_work_sync(&lt6911c->delayed_work_enable_hotplug);
+	cancel_delayed_work_sync(&lt6911c->delayed_work_res_change);
+	v4l2_async_unregister_subdev(sd);
+	v4l2_device_unregister_subdev(sd);
+#if defined(CONFIG_MEDIA_CONTROLLER)
+	media_entity_cleanup(&sd->entity);
+#endif
+	v4l2_ctrl_handler_free(&lt6911c->hdl);
+	mutex_destroy(&lt6911c->confctl_mutex);
+	clk_disable_unprepare(lt6911c->xvclk);
+
+	return 0;
+}
+
+#if IS_ENABLED(CONFIG_OF)
+static const struct of_device_id lt6911c_of_match[] = {
+	{ .compatible = "lontium,lt6911c" },
+	{},
+};
+MODULE_DEVICE_TABLE(of, lt6911c_of_match);
+#endif
+
+static struct i2c_driver lt6911c_driver = {
+	.driver = {
+		.name = LT6911C_NAME,
+		.of_match_table = of_match_ptr(lt6911c_of_match),
+	},
+	.probe = lt6911c_probe,
+	.remove = lt6911c_remove,
+};
+
+static int __init lt6911c_driver_init(void)
+{
+	return i2c_add_driver(&lt6911c_driver);
+}
+
+static void __exit lt6911c_driver_exit(void)
+{
+	i2c_del_driver(&lt6911c_driver);
+}
+
+device_initcall_sync(lt6911c_driver_init);
+module_exit(lt6911c_driver_exit);
+
+MODULE_DESCRIPTION("Lontium lt6911c HDMI to CSI-2 bridge driver");
+MODULE_AUTHOR("Jianwei Fan <jianwei.fan@rock-chips.com>");
+MODULE_LICENSE("GPL");