~hc/RK356X_SDK_RELEASE.git

..	..	@@ -13,12 +13,12 @@
13	13	#include <linux/module.h>
14	14	#include <linux/of.h>
15	15	#include <linux/of_graph.h>
	16	+#include <linux/of_platform.h>
16	17	#include <linux/platform_device.h>
17	18	#include <linux/reset.h>
18	19	#include <linux/rk-camera-module.h>
19	20	#include <media/v4l2-ioctl.h>
20	21	#include "mipi-csi2.h"
21		-#include <linux/rkcif-config.h>
22	22	#include <linux/regulator/consumer.h>
23	23
24	24	static int csi2_debug;
..	..	@@ -141,53 +141,61 @@
141	141	break;
142	142	default:
143	143	v4l2_warn(&csi2->sd, "lane num is invalid\n");
144		- csi2->bus.num_data_lanes = 0;
	144	+ csi2->bus.num_data_lanes = 4;
145	145	break;
146	146	}
147	147
148	148	}
149	149
150		-static void csi2_hw_do_reset(struct csi2_dev *csi2)
	150	+static void csi2_hw_do_reset(struct csi2_hw *csi2_hw)
151	151	{
152		- reset_control_assert(csi2->rsts_bulk);
	152	+
	153	+ if (!csi2_hw->rsts_bulk)
	154	+ return;
	155	+
	156	+ reset_control_assert(csi2_hw->rsts_bulk);
153	157
154	158	udelay(5);
155	159
156		- reset_control_deassert(csi2->rsts_bulk);
	160	+ reset_control_deassert(csi2_hw->rsts_bulk);
157	161	}
158	162
159		-static int csi2_enable_clks(struct csi2_dev *csi2)
	163	+static int csi2_enable_clks(struct csi2_hw *csi2_hw)
160	164	{
161	165	int ret = 0;
162	166
163		- ret = clk_bulk_prepare_enable(csi2->clks_num, csi2->clks_bulk);
	167	+ if (!csi2_hw->clks_bulk)
	168	+ return -EINVAL;
	169	+
	170	+ ret = clk_bulk_prepare_enable(csi2_hw->clks_num, csi2_hw->clks_bulk);
164	171	if (ret)
165		- dev_err(csi2->dev, "failed to enable clks\n");
	172	+ dev_err(csi2_hw->dev, "failed to enable clks\n");
166	173
167	174	return ret;
168	175	}
169	176
170		-static void csi2_disable_clks(struct csi2_dev *csi2)
	177	+static void csi2_disable_clks(struct csi2_hw *csi2_hw)
171	178	{
172		- clk_bulk_disable_unprepare(csi2->clks_num, csi2->clks_bulk);
	179	+ if (!csi2_hw->clks_bulk)
	180	+ return;
	181	+ clk_bulk_disable_unprepare(csi2_hw->clks_num, csi2_hw->clks_bulk);
173	182	}
174	183
175		-static void csi2_disable(struct csi2_dev *csi2)
	184	+static void csi2_disable(struct csi2_hw *csi2_hw)
176	185	{
177		- void __iomem *base = csi2->base;
178		-
179		- write_csihost_reg(base, CSIHOST_RESETN, 0);
180		- write_csihost_reg(base, CSIHOST_MSK1, 0xffffffff);
181		- write_csihost_reg(base, CSIHOST_MSK2, 0xffffffff);
	186	+ write_csihost_reg(csi2_hw->base, CSIHOST_RESETN, 0);
	187	+ write_csihost_reg(csi2_hw->base, CSIHOST_MSK1, 0xffffffff);
	188	+ write_csihost_reg(csi2_hw->base, CSIHOST_MSK2, 0xffffffff);
182	189	}
183	190
184	191	static int csi2_g_mbus_config(struct v4l2_subdev *sd, unsigned int pad_id,
185	192	struct v4l2_mbus_config *mbus);
186	193
187		-static void csi2_enable(struct csi2_dev *csi2,
	194	+static void csi2_enable(struct csi2_hw *csi2_hw,
188	195	enum host_type_t host_type)
189	196	{
190		- void __iomem *base = csi2->base;
	197	+ void __iomem *base = csi2_hw->base;
	198	+ struct csi2_dev *csi2 = csi2_hw->csi2;
191	199	int lanes = csi2->bus.num_data_lanes;
192	200	struct v4l2_mbus_config mbus;
193	201	u32 val = 0;
..	..	@@ -225,15 +233,9 @@
225	233	{
226	234	enum host_type_t host_type;
227	235	int ret, i;
	236	+ int csi_idx = 0;
228	237
229	238	atomic_set(&csi2->frm_sync_seq, 0);
230		-
231		- csi2_hw_do_reset(csi2);
232		- ret = csi2_enable_clks(csi2);
233		- if (ret) {
234		- v4l2_err(&csi2->sd, "%s: enable clks failed\n", __func__);
235		- return ret;
236		- }
237	239
238	240	csi2_update_sensor_info(csi2);
239	241
..	..	@@ -242,7 +244,18 @@
242	244	else
243	245	host_type = RK_CSI_RXHOST;
244	246
245		- csi2_enable(csi2, host_type);
	247	+ for (i = 0; i < csi2->csi_info.csi_num; i++) {
	248	+ csi_idx = csi2->csi_info.csi_idx[i];
	249	+ csi2_hw_do_reset(csi2->csi2_hw[csi_idx]);
	250	+ ret = csi2_enable_clks(csi2->csi2_hw[csi_idx]);
	251	+ if (ret) {
	252	+ v4l2_err(&csi2->sd, "%s: enable clks failed\n", __func__);
	253	+ return ret;
	254	+ }
	255	+ enable_irq(csi2->csi2_hw[csi_idx]->irq1);
	256	+ enable_irq(csi2->csi2_hw[csi_idx]->irq2);
	257	+ csi2_enable(csi2->csi2_hw[csi_idx], host_type);
	258	+ }
246	259
247	260	pr_debug("stream sd: %s\n", csi2->src_sd->name);
248	261	ret = v4l2_subdev_call(csi2->src_sd, video, s_stream, 1);
..	..	@@ -256,20 +269,33 @@
256	269	return 0;
257	270
258	271	err_assert_reset:
259		- csi2_disable(csi2);
260		- csi2_disable_clks(csi2);
	272	+ for (i = 0; i < csi2->csi_info.csi_num; i++) {
	273	+ csi_idx = csi2->csi_info.csi_idx[i];
	274	+ disable_irq(csi2->csi2_hw[csi_idx]->irq1);
	275	+ disable_irq(csi2->csi2_hw[csi_idx]->irq2);
	276	+ csi2_disable(csi2->csi2_hw[csi_idx]);
	277	+ csi2_disable_clks(csi2->csi2_hw[csi_idx]);
	278	+ }
261	279
262	280	return ret;
263	281	}
264	282
265	283	static void csi2_stop(struct csi2_dev *csi2)
266	284	{
	285	+ int i = 0;
	286	+ int csi_idx = 0;
	287	+
267	288	/* stop upstream */
268	289	v4l2_subdev_call(csi2->src_sd, video, s_stream, 0);
269	290
270		- csi2_disable(csi2);
271		- csi2_hw_do_reset(csi2);
272		- csi2_disable_clks(csi2);
	291	+ for (i = 0; i < csi2->csi_info.csi_num; i++) {
	292	+ csi_idx = csi2->csi_info.csi_idx[i];
	293	+ disable_irq(csi2->csi2_hw[csi_idx]->irq1);
	294	+ disable_irq(csi2->csi2_hw[csi_idx]->irq2);
	295	+ csi2_disable(csi2->csi2_hw[csi_idx]);
	296	+ csi2_hw_do_reset(csi2->csi2_hw[csi_idx]);
	297	+ csi2_disable_clks(csi2->csi2_hw[csi_idx]);
	298	+ }
273	299	}
274	300
275	301	/*
..	..	@@ -379,7 +405,7 @@
379	405	csi2->crop.left = 0;
380	406	csi2->crop.width = RKCIF_DEFAULT_WIDTH;
381	407	csi2->crop.height = RKCIF_DEFAULT_HEIGHT;
382		- csi2->csi_idx = 0;
	408	+ csi2->bus.num_data_lanes = 4;
383	409
384	410	return media_entity_pads_init(&sd->entity, num_pads, csi2->pad);
385	411	}
..	..	@@ -567,11 +593,19 @@
567	593	static long rkcif_csi2_ioctl(struct v4l2_subdev sd, unsigned int cmd, void arg)
568	594	{
569	595	struct csi2_dev *csi2 = sd_to_dev(sd);
	596	+ struct v4l2_subdev *sensor = get_remote_sensor(sd);
570	597	long ret = 0;
	598	+ int i = 0;
571	599
572	600	switch (cmd) {
573	601	case RKCIF_CMD_SET_CSI_IDX:
574		- csi2->csi_idx = ((u32 )arg);
	602	+ csi2->csi_info = ((struct rkcif_csi_info )arg);
	603	+ for (i = 0; i < csi2->csi_info.csi_num; i++)
	604	+ csi2->csi2_hw[csi2->csi_info.csi_idx[i]]->csi2 = csi2;
	605	+ if (csi2->match_data->chip_id > CHIP_RV1126_CSI2)
	606	+ ret = v4l2_subdev_call(sensor, core, ioctl,
	607	+ RKCIF_CMD_SET_CSI_IDX,
	608	+ arg);
575	609	break;
576	610	default:
577	611	ret = -ENOIOCTLCMD;
..	..	@@ -586,15 +620,15 @@
586	620	unsigned int cmd, unsigned long arg)
587	621	{
588	622	void __user *up = compat_ptr(arg);
589		- u32 csi_idx = 0;
	623	+ struct rkcif_csi_info csi_info;
590	624	long ret;
591	625
592	626	switch (cmd) {
593	627	case RKCIF_CMD_SET_CSI_IDX:
594		- if (copy_from_user(&csi_idx, up, sizeof(u32)))
	628	+ if (copy_from_user(&csi_info, up, sizeof(struct rkcif_csi_info)))
595	629	return -EFAULT;
596	630
597		- ret = rkcif_csi2_ioctl(sd, cmd, &csi_idx);
	631	+ ret = rkcif_csi2_ioctl(sd, cmd, &csi_info);
598	632	break;
599	633	default:
600	634	ret = -ENOIOCTLCMD;
..	..	@@ -637,15 +671,10 @@
637	671	struct v4l2_fwnode_endpoint *vep,
638	672	struct v4l2_async_subdev *asd)
639	673	{
640		- struct v4l2_subdev *sd = dev_get_drvdata(dev);
641		- struct csi2_dev *csi2 = sd_to_dev(sd);
642		-
643	674	if (vep->base.port != 0) {
644	675	dev_err(dev, "The csi host node needs to parse port 0\n");
645	676	return -EINVAL;
646	677	}
647		-
648		- csi2->bus = vep->bus.mipi_csi2;
649	678
650	679	return 0;
651	680	}
..	..	@@ -749,7 +778,8 @@
749	778	static irqreturn_t rk_csirx_irq1_handler(int irq, void *ctx)
750	779	{
751	780	struct device *dev = ctx;
752		- struct csi2_dev *csi2 = sd_to_dev(dev_get_drvdata(dev));
	781	+ struct csi2_hw *csi2_hw = dev_get_drvdata(dev);
	782	+ struct csi2_dev *csi2 = NULL;
753	783	struct csi2_err_stats *err_list = NULL;
754	784	unsigned long err_stat = 0;
755	785	u32 val;
..	..	@@ -758,7 +788,17 @@
758	788	char vc_info[CSI_VCINFO_LEN] = {0};
759	789	bool is_add_cnt = false;
760	790
761		- val = read_csihost_reg(csi2->base, CSIHOST_ERR1);
	791	+ if (!csi2_hw) {
	792	+ disable_irq_nosync(irq);
	793	+ return IRQ_HANDLED;
	794	+ }
	795	+
	796	+ csi2 = csi2_hw->csi2;
	797	+ if (!csi2) {
	798	+ disable_irq_nosync(irq);
	799	+ return IRQ_HANDLED;
	800	+ }
	801	+ val = read_csihost_reg(csi2_hw->base, CSIHOST_ERR1);
762	802	if (val) {
763	803	if (val & CSIHOST_ERR1_PHYERR_SPTSYNCHS) {
764	804	err_list = &csi2->err_list[RK_CSI2_ERR_SOTSYN];
..	..	@@ -767,7 +807,7 @@
767	807	if (err_list->cnt > 3 &&
768	808	csi2->err_list[RK_CSI2_ERR_ALL].cnt <= err_list->cnt) {
769	809	csi2->is_check_sot_sync = false;
770		- write_csihost_reg(csi2->base, CSIHOST_MSK1, 0xf);
	810	+ write_csihost_reg(csi2_hw->base, CSIHOST_MSK1, 0xf);
771	811	}
772	812	if (csi2->is_check_sot_sync) {
773	813	csi2_find_err_vc(val & 0xf, vc_info);
..	..	@@ -832,7 +872,7 @@
832	872	csi2_err_strncat(err_str, cur_str);
833	873	}
834	874
835		- pr_err("%s ERR1:0x%x %s\n", csi2->dev_name, val, err_str);
	875	+ pr_err("%s ERR1:0x%x %s\n", csi2_hw->dev_name, val, err_str);
836	876
837	877	if (is_add_cnt) {
838	878	csi2->err_list[RK_CSI2_ERR_ALL].cnt++;
..	..	@@ -841,7 +881,7 @@
841	881
842	882	atomic_notifier_call_chain(&g_csi_host_chain,
843	883	err_stat,
844		- &csi2->csi_idx);
	884	+ &csi2->csi_info.csi_idx[csi2->csi_info.csi_num - 1]);
845	885	}
846	886
847	887	}
..	..	@@ -852,13 +892,18 @@
852	892	static irqreturn_t rk_csirx_irq2_handler(int irq, void *ctx)
853	893	{
854	894	struct device *dev = ctx;
855		- struct csi2_dev *csi2 = sd_to_dev(dev_get_drvdata(dev));
	895	+ struct csi2_hw *csi2_hw = dev_get_drvdata(dev);
856	896	u32 val;
857	897	char cur_str[CSI_ERRSTR_LEN] = {0};
858	898	char err_str[CSI_ERRSTR_LEN] = {0};
859	899	char vc_info[CSI_VCINFO_LEN] = {0};
860	900
861		- val = read_csihost_reg(csi2->base, CSIHOST_ERR2);
	901	+ if (!csi2_hw) {
	902	+ disable_irq_nosync(irq);
	903	+ return IRQ_HANDLED;
	904	+ }
	905	+
	906	+ val = read_csihost_reg(csi2_hw->base, CSIHOST_ERR2);
862	907	if (val) {
863	908	if (val & CSIHOST_ERR2_PHYERR_ESC) {
864	909	csi2_find_err_vc(val & 0xf, vc_info);
..	..	@@ -885,7 +930,7 @@
885	930	csi2_err_strncat(err_str, cur_str);
886	931	}
887	932
888		- pr_err("%s ERR2:0x%x %s\n", csi2->dev_name, val, err_str);
	933	+ pr_err("%s ERR2:0x%x %s\n", csi2_hw->dev_name, val, err_str);
889	934	}
890	935
891	936	return IRQ_HANDLED;
..	..	@@ -924,31 +969,43 @@
924	969	static const struct csi2_match_data rk1808_csi2_match_data = {
925	970	.chip_id = CHIP_RK1808_CSI2,
926	971	.num_pads = CSI2_NUM_PADS,
	972	+ .num_hw = 1,
927	973	};
928	974
929	975	static const struct csi2_match_data rk3288_csi2_match_data = {
930	976	.chip_id = CHIP_RK3288_CSI2,
931	977	.num_pads = CSI2_NUM_PADS_SINGLE_LINK,
	978	+ .num_hw = 1,
932	979	};
933	980
934	981	static const struct csi2_match_data rv1126_csi2_match_data = {
935	982	.chip_id = CHIP_RV1126_CSI2,
936	983	.num_pads = CSI2_NUM_PADS,
	984	+ .num_hw = 1,
937	985	};
938	986
939	987	static const struct csi2_match_data rk3568_csi2_match_data = {
940	988	.chip_id = CHIP_RK3568_CSI2,
941	989	.num_pads = CSI2_NUM_PADS,
	990	+ .num_hw = 1,
942	991	};
943	992
944	993	static const struct csi2_match_data rk3588_csi2_match_data = {
945	994	.chip_id = CHIP_RK3588_CSI2,
946	995	.num_pads = CSI2_NUM_PADS_MAX,
	996	+ .num_hw = 6,
	997	+};
	998	+
	999	+static const struct csi2_match_data rv1106_csi2_match_data = {
	1000	+ .chip_id = CHIP_RV1106_CSI2,
	1001	+ .num_pads = CSI2_NUM_PADS_MAX,
	1002	+ .num_hw = 2,
947	1003	};
948	1004
949	1005	static const struct csi2_match_data rk3562_csi2_match_data = {
950	1006	.chip_id = CHIP_RK3562_CSI2,
951	1007	.num_pads = CSI2_NUM_PADS_MAX,
	1008	+ .num_hw = 4,
952	1009	};
953	1010
954	1011	static const struct of_device_id csi2_dt_ids[] = {
..	..	@@ -973,6 +1030,10 @@
973	1030	.data = &rk3588_csi2_match_data,
974	1031	},
975	1032	{
	1033	+ .compatible = "rockchip,rv1106-mipi-csi2",
	1034	+ .data = &rv1106_csi2_match_data,
	1035	+ },
	1036	+ {
976	1037	.compatible = "rockchip,rk3562-mipi-csi2",
977	1038	.data = &rk3562_csi2_match_data,
978	1039	},
..	..	@@ -980,15 +1041,48 @@
980	1041	};
981	1042	MODULE_DEVICE_TABLE(of, csi2_dt_ids);
982	1043
	1044	+static int csi2_attach_hw(struct csi2_dev *csi2)
	1045	+{
	1046	+ struct device_node *np;
	1047	+ struct platform_device *pdev;
	1048	+ struct csi2_hw *hw;
	1049	+ int i = 0;
	1050	+
	1051	+ for (i = 0; i < csi2->match_data->num_hw; i++) {
	1052	+ np = of_parse_phandle(csi2->dev->of_node, "rockchip,hw", i);
	1053	+ if (!np \|\| !of_device_is_available(np)) {
	1054	+ dev_err(csi2->dev, "failed to get csi2 hw node\n");
	1055	+ return -ENODEV;
	1056	+ }
	1057	+
	1058	+ pdev = of_find_device_by_node(np);
	1059	+ of_node_put(np);
	1060	+ if (!pdev) {
	1061	+ dev_err(csi2->dev, "failed to get csi2 hw from node\n");
	1062	+ return -ENODEV;
	1063	+ }
	1064	+
	1065	+ hw = platform_get_drvdata(pdev);
	1066	+ if (!hw) {
	1067	+ dev_err(csi2->dev, "failed attach csi2 hw\n");
	1068	+ return -EINVAL;
	1069	+ }
	1070	+
	1071	+ hw->csi2 = csi2;
	1072	+ csi2->csi2_hw[i] = hw;
	1073	+ }
	1074	+ dev_info(csi2->dev, "attach to csi2 hw node\n");
	1075	+
	1076	+ return 0;
	1077	+}
	1078	+
983	1079	static int csi2_probe(struct platform_device *pdev)
984	1080	{
985	1081	const struct of_device_id *match;
986		- struct device *dev = &pdev->dev;
987	1082	struct device_node *node = pdev->dev.of_node;
988	1083	struct csi2_dev *csi2 = NULL;
989		- struct resource *res;
990	1084	const struct csi2_match_data *data;
991		- int ret, irq;
	1085	+ int ret;
992	1086
993	1087	match = of_match_node(csi2_dt_ids, node);
994	1088	if (IS_ERR(match))
..	..	@@ -1014,63 +1108,11 @@
1014	1108	v4l2_err(&csi2->sd, "failed to copy name\n");
1015	1109	platform_set_drvdata(pdev, &csi2->sd);
1016	1110
1017		- csi2->clks_num = devm_clk_bulk_get_all(dev, &csi2->clks_bulk);
1018		- if (csi2->clks_num < 0) {
1019		- csi2->clks_num = 0;
1020		- dev_err(dev, "failed to get csi2 clks\n");
	1111	+ ret = csi2_attach_hw(csi2);
	1112	+ if (ret) {
	1113	+ v4l2_err(&csi2->sd, "must enable all mipi csi2 hw node\n");
	1114	+ return -EINVAL;
1021	1115	}
1022		-
1023		- csi2->rsts_bulk = devm_reset_control_array_get_optional_exclusive(dev);
1024		- if (IS_ERR(csi2->rsts_bulk)) {
1025		- if (PTR_ERR(csi2->rsts_bulk) != -EPROBE_DEFER)
1026		- dev_err(dev, "failed to get csi2 reset\n");
1027		- csi2->rsts_bulk = NULL;
1028		- }
1029		-
1030		- res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1031		- csi2->base = devm_ioremap_resource(&pdev->dev, res);
1032		- if (IS_ERR(csi2->base)) {
1033		- resource_size_t offset = res->start;
1034		- resource_size_t size = resource_size(res);
1035		-
1036		- dev_warn(&pdev->dev, "avoid secondary mipi resource check!\n");
1037		-
1038		- csi2->base = devm_ioremap(&pdev->dev, offset, size);
1039		- if (IS_ERR(csi2->base)) {
1040		- dev_err(&pdev->dev, "Failed to ioremap resource\n");
1041		-
1042		- return PTR_ERR(csi2->base);
1043		- }
1044		- }
1045		-
1046		- irq = platform_get_irq_byname(pdev, "csi-intr1");
1047		- if (irq > 0) {
1048		- ret = devm_request_irq(&pdev->dev, irq,
1049		- rk_csirx_irq1_handler, 0,
1050		- dev_driver_string(&pdev->dev),
1051		- &pdev->dev);
1052		- if (ret < 0)
1053		- v4l2_err(&csi2->sd, "request csi-intr1 irq failed: %d\n",
1054		- ret);
1055		- csi2->irq1 = irq;
1056		- } else {
1057		- v4l2_err(&csi2->sd, "No found irq csi-intr1\n");
1058		- }
1059		-
1060		- irq = platform_get_irq_byname(pdev, "csi-intr2");
1061		- if (irq > 0) {
1062		- ret = devm_request_irq(&pdev->dev, irq,
1063		- rk_csirx_irq2_handler, 0,
1064		- dev_driver_string(&pdev->dev),
1065		- &pdev->dev);
1066		- if (ret < 0)
1067		- v4l2_err(&csi2->sd, "request csi-intr2 failed: %d\n",
1068		- ret);
1069		- csi2->irq2 = irq;
1070		- } else {
1071		- v4l2_err(&csi2->sd, "No found irq csi-intr2\n");
1072		- }
1073		-
1074	1116	mutex_init(&csi2->lock);
1075	1117
1076	1118	ret = csi2_media_init(&csi2->sd);
..	..	@@ -1115,11 +1157,185 @@
1115	1157	return platform_driver_register(&csi2_driver);
1116	1158	}
1117	1159
1118		-void __exit rkcif_csi2_plat_drv_exit(void)
	1160	+void rkcif_csi2_plat_drv_exit(void)
1119	1161	{
1120	1162	platform_driver_unregister(&csi2_driver);
1121	1163	}
1122	1164
	1165	+static const struct csi2_hw_match_data rk1808_csi2_hw_match_data = {
	1166	+ .chip_id = CHIP_RK1808_CSI2,
	1167	+};
	1168	+
	1169	+static const struct csi2_hw_match_data rk3288_csi2_hw_match_data = {
	1170	+ .chip_id = CHIP_RK3288_CSI2,
	1171	+};
	1172	+
	1173	+static const struct csi2_hw_match_data rv1126_csi2_hw_match_data = {
	1174	+ .chip_id = CHIP_RV1126_CSI2,
	1175	+};
	1176	+
	1177	+static const struct csi2_hw_match_data rk3568_csi2_hw_match_data = {
	1178	+ .chip_id = CHIP_RK3568_CSI2,
	1179	+};
	1180	+
	1181	+static const struct csi2_hw_match_data rk3588_csi2_hw_match_data = {
	1182	+ .chip_id = CHIP_RK3588_CSI2,
	1183	+};
	1184	+
	1185	+static const struct csi2_hw_match_data rv1106_csi2_hw_match_data = {
	1186	+ .chip_id = CHIP_RV1106_CSI2,
	1187	+};
	1188	+
	1189	+static const struct csi2_hw_match_data rk3562_csi2_hw_match_data = {
	1190	+ .chip_id = CHIP_RK3562_CSI2,
	1191	+};
	1192	+
	1193	+static const struct of_device_id csi2_hw_ids[] = {
	1194	+ {
	1195	+ .compatible = "rockchip,rk1808-mipi-csi2-hw",
	1196	+ .data = &rk1808_csi2_hw_match_data,
	1197	+ },
	1198	+ {
	1199	+ .compatible = "rockchip,rk3288-mipi-csi2-hw",
	1200	+ .data = &rk3288_csi2_hw_match_data,
	1201	+ },
	1202	+ {
	1203	+ .compatible = "rockchip,rk3568-mipi-csi2-hw",
	1204	+ .data = &rk3568_csi2_hw_match_data,
	1205	+ },
	1206	+ {
	1207	+ .compatible = "rockchip,rv1126-mipi-csi2-hw",
	1208	+ .data = &rv1126_csi2_hw_match_data,
	1209	+ },
	1210	+ {
	1211	+ .compatible = "rockchip,rk3588-mipi-csi2-hw",
	1212	+ .data = &rk3588_csi2_hw_match_data,
	1213	+ },
	1214	+ {
	1215	+ .compatible = "rockchip,rv1106-mipi-csi2-hw",
	1216	+ .data = &rv1106_csi2_hw_match_data,
	1217	+ },
	1218	+ {
	1219	+ .compatible = "rockchip,rk3562-mipi-csi2-hw",
	1220	+ .data = &rk3588_csi2_hw_match_data,
	1221	+ },
	1222	+ { /* sentinel */ }
	1223	+};
	1224	+MODULE_DEVICE_TABLE(of, csi2_hw_ids);
	1225	+
	1226	+static int csi2_hw_probe(struct platform_device *pdev)
	1227	+{
	1228	+ const struct of_device_id *match;
	1229	+ struct device *dev = &pdev->dev;
	1230	+ struct device_node *node = pdev->dev.of_node;
	1231	+ struct csi2_hw *csi2_hw = NULL;
	1232	+ struct resource *res;
	1233	+ const struct csi2_hw_match_data *data;
	1234	+ int ret, irq;
	1235	+
	1236	+ dev_info(&pdev->dev, "enter mipi csi2 hw probe!\n");
	1237	+ match = of_match_node(csi2_hw_ids, node);
	1238	+ if (IS_ERR(match))
	1239	+ return PTR_ERR(match);
	1240	+ data = match->data;
	1241	+
	1242	+ csi2_hw = devm_kzalloc(&pdev->dev, sizeof(*csi2_hw), GFP_KERNEL);
	1243	+ if (!csi2_hw)
	1244	+ return -ENOMEM;
	1245	+
	1246	+ csi2_hw->dev = &pdev->dev;
	1247	+ csi2_hw->match_data = data;
	1248	+
	1249	+ csi2_hw->dev_name = node->name;
	1250	+
	1251	+ csi2_hw->clks_num = devm_clk_bulk_get_all(dev, &csi2_hw->clks_bulk);
	1252	+ if (csi2_hw->clks_num < 0) {
	1253	+ csi2_hw->clks_num = 0;
	1254	+ dev_err(dev, "failed to get csi2 clks\n");
	1255	+ }
	1256	+
	1257	+ csi2_hw->rsts_bulk = devm_reset_control_array_get_optional_exclusive(dev);
	1258	+ if (IS_ERR(csi2_hw->rsts_bulk)) {
	1259	+ if (PTR_ERR(csi2_hw->rsts_bulk) != -EPROBE_DEFER)
	1260	+ dev_err(dev, "failed to get csi2 reset\n");
	1261	+ csi2_hw->rsts_bulk = NULL;
	1262	+ }
	1263	+
	1264	+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	1265	+ csi2_hw->base = devm_ioremap_resource(&pdev->dev, res);
	1266	+ if (IS_ERR(csi2_hw->base)) {
	1267	+ resource_size_t offset = res->start;
	1268	+ resource_size_t size = resource_size(res);
	1269	+
	1270	+ dev_warn(&pdev->dev, "avoid secondary mipi resource check!\n");
	1271	+
	1272	+ csi2_hw->base = devm_ioremap(&pdev->dev, offset, size);
	1273	+ if (IS_ERR(csi2_hw->base)) {
	1274	+ dev_err(&pdev->dev, "Failed to ioremap resource\n");
	1275	+
	1276	+ return PTR_ERR(csi2_hw->base);
	1277	+ }
	1278	+ }
	1279	+
	1280	+ irq = platform_get_irq_byname(pdev, "csi-intr1");
	1281	+ if (irq > 0) {
	1282	+ irq_set_status_flags(irq, IRQ_NOAUTOEN);
	1283	+ ret = devm_request_irq(&pdev->dev, irq,
	1284	+ rk_csirx_irq1_handler, 0,
	1285	+ dev_driver_string(&pdev->dev),
	1286	+ &pdev->dev);
	1287	+ if (ret < 0)
	1288	+ dev_err(&pdev->dev, "request csi-intr1 irq failed: %d\n",
	1289	+ ret);
	1290	+ csi2_hw->irq1 = irq;
	1291	+ } else {
	1292	+ dev_err(&pdev->dev, "No found irq csi-intr1\n");
	1293	+ }
	1294	+
	1295	+ irq = platform_get_irq_byname(pdev, "csi-intr2");
	1296	+ if (irq > 0) {
	1297	+ irq_set_status_flags(irq, IRQ_NOAUTOEN);
	1298	+ ret = devm_request_irq(&pdev->dev, irq,
	1299	+ rk_csirx_irq2_handler, 0,
	1300	+ dev_driver_string(&pdev->dev),
	1301	+ &pdev->dev);
	1302	+ if (ret < 0)
	1303	+ dev_err(&pdev->dev, "request csi-intr2 failed: %d\n",
	1304	+ ret);
	1305	+ csi2_hw->irq2 = irq;
	1306	+ } else {
	1307	+ dev_err(&pdev->dev, "No found irq csi-intr2\n");
	1308	+ }
	1309	+ platform_set_drvdata(pdev, csi2_hw);
	1310	+ dev_info(&pdev->dev, "probe success, v4l2_dev:%s!\n", csi2_hw->dev_name);
	1311	+
	1312	+ return 0;
	1313	+}
	1314	+
	1315	+static int csi2_hw_remove(struct platform_device *pdev)
	1316	+{
	1317	+ return 0;
	1318	+}
	1319	+
	1320	+static struct platform_driver csi2_hw_driver = {
	1321	+ .driver = {
	1322	+ .name = DEVICE_NAME_HW,
	1323	+ .of_match_table = csi2_hw_ids,
	1324	+ },
	1325	+ .probe = csi2_hw_probe,
	1326	+ .remove = csi2_hw_remove,
	1327	+};
	1328	+
	1329	+int rkcif_csi2_hw_plat_drv_init(void)
	1330	+{
	1331	+ return platform_driver_register(&csi2_hw_driver);
	1332	+}
	1333	+
	1334	+void rkcif_csi2_hw_plat_drv_exit(void)
	1335	+{
	1336	+ platform_driver_unregister(&csi2_hw_driver);
	1337	+}
	1338	+
1123	1339	MODULE_DESCRIPTION("Rockchip MIPI CSI2 driver");
1124	1340	MODULE_AUTHOR("Macrofly.xu <xuhf@rock-chips.com>");
1125	1341	MODULE_LICENSE("GPL");