~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,47 +1,60 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* Analogix DP (Display Port) core interface driver.
3	4	*
4	5	* Copyright (C) 2012 Samsung Electronics Co., Ltd.
5	6	* Author: Jingoo Han <jg1.han@samsung.com>
6		-*
7		-* This program is free software; you can redistribute it and/or modify it
8		-* under the terms of the GNU General Public License as published by the
9		-* Free Software Foundation; either version 2 of the License, or (at your
10		-* option) any later version.
11	7	*/
12	8
13		-#include <linux/module.h>
14		-#include <linux/platform_device.h>
15		-#include <linux/err.h>
16	9	#include <linux/clk.h>
	10	+#include <linux/component.h>
	11	+#include <linux/extcon-provider.h>
	12	+#include <linux/err.h>
	13	+#include <linux/gpio/consumer.h>
	14	+#include <linux/interrupt.h>
17	15	#include <linux/io.h>
18	16	#include <linux/iopoll.h>
19		-#include <linux/interrupt.h>
	17	+#include <linux/irq.h>
	18	+#include <linux/module.h>
20	19	#include <linux/of.h>
21		-#include <linux/of_gpio.h>
22		-#include <linux/gpio/consumer.h>
23		-#include <linux/component.h>
24	20	#include <linux/phy/phy.h>
25		-
26		-#include <drm/drmP.h>
27		-#include <drm/drm_atomic_helper.h>
28		-#include <drm/drm_crtc.h>
29		-#include <drm/drm_crtc_helper.h>
30		-#include <drm/drm_panel.h>
	21	+#include <linux/platform_device.h>
31	22
32	23	#include <drm/bridge/analogix_dp.h>
	24	+#include <drm/drm_atomic.h>
	25	+#include <drm/drm_atomic_helper.h>
	26	+#include <drm/drm_bridge.h>
	27	+#include <drm/drm_crtc.h>
	28	+#include <drm/drm_device.h>
	29	+#include <drm/drm_panel.h>
	30	+#include <drm/drm_print.h>
	31	+#include <drm/drm_probe_helper.h>
33	32
34	33	#include "analogix_dp_core.h"
35	34	#include "analogix_dp_reg.h"
	35	+#include "../../rockchip/rockchip_drm_drv.h"
36	36
37	37	#define to_dp(nm) container_of(nm, struct analogix_dp_device, nm)
38	38
39	39	static const bool verify_fast_training;
40	40
	41	+#ifdef CONFIG_NO_GKI
	42	+#undef EXTCON_DISP_DP
	43	+#define EXTCON_DISP_DP EXTCON_DISP_EDP
	44	+#endif
	45	+
	46	+static const unsigned int analogix_dp_cable[] = {
	47	+ EXTCON_DISP_DP,
	48	+ EXTCON_NONE,
	49	+};
	50	+
41	51	struct bridge_init {
42	52	struct i2c_client *client;
43	53	struct device_node *node;
44	54	};
	55	+
	56	+static void analogix_dp_bridge_mode_set(struct drm_bridge *bridge,
	57	+ const struct drm_display_mode *adj_mode);
45	58
46	59	static bool analogix_dp_bandwidth_ok(struct analogix_dp_device *dp,
47	60	const struct drm_display_mode *mode,
..	..	@@ -89,143 +102,75 @@
89	102	return 0;
90	103	}
91	104
92		-static int analogix_dp_prepare_panel(struct analogix_dp_device *dp,
93		- bool prepare)
	105	+static int analogix_dp_panel_prepare(struct analogix_dp_device *dp)
94	106	{
95		- int ret = 0;
	107	+ int ret;
96	108
97	109	mutex_lock(&dp->panel_lock);
98	110
99		- if (prepare == dp->panel_is_prepared)
	111	+ if (dp->panel_is_prepared)
100	112	goto out;
101	113
102		- if (prepare)
103		- ret = drm_panel_prepare(dp->plat_data->panel);
104		- else
105		- ret = drm_panel_unprepare(dp->plat_data->panel);
	114	+ ret = drm_panel_prepare(dp->plat_data->panel);
106	115	if (ret)
107	116	goto out;
108	117
109		- dp->panel_is_prepared = prepare;
	118	+ dp->panel_is_prepared = true;
	119	+
110	120	out:
111	121	mutex_unlock(&dp->panel_lock);
112		- return ret;
	122	+ return 0;
	123	+}
	124	+
	125	+static int analogix_dp_panel_unprepare(struct analogix_dp_device *dp)
	126	+{
	127	+ int ret;
	128	+
	129	+ mutex_lock(&dp->panel_lock);
	130	+
	131	+ if (!dp->panel_is_prepared)
	132	+ goto out;
	133	+
	134	+ ret = drm_panel_unprepare(dp->plat_data->panel);
	135	+ if (ret)
	136	+ goto out;
	137	+
	138	+ dp->panel_is_prepared = false;
	139	+
	140	+out:
	141	+ mutex_unlock(&dp->panel_lock);
	142	+ return 0;
113	143	}
114	144
115	145	static int analogix_dp_detect_hpd(struct analogix_dp_device *dp)
116	146	{
117		- int timeout_loop = 0;
118		-
119		- while (timeout_loop < DP_TIMEOUT_LOOP_COUNT) {
120		- if (analogix_dp_get_plug_in_status(dp) == 0)
121		- return 0;
122		-
123		- timeout_loop++;
124		- usleep_range(1000, 1100);
125		- }
126		-
127		- /*
128		- * Some edp screen do not have hpd signal, so we can't just
129		- * return failed when hpd plug in detect failed, DT property
130		- * "force-hpd" would indicate whether driver need this.
131		- */
132		- if (!dp->force_hpd)
133		- return -ETIMEDOUT;
134		-
135		- /*
136		- * The eDP TRM indicate that if HPD_STATUS(RO) is 0, AUX CH
137		- * will not work, so we need to give a force hpd action to
138		- * set HPD_STATUS manually.
139		- */
140		- dev_dbg(dp->dev, "failed to get hpd plug status, try to force hpd\n");
141		-
142		- analogix_dp_force_hpd(dp);
	147	+ if (dp->force_hpd)
	148	+ analogix_dp_force_hpd(dp);
143	149
144	150	if (analogix_dp_get_plug_in_status(dp) != 0) {
145	151	dev_err(dp->dev, "failed to get hpd plug in status\n");
146	152	return -EINVAL;
147	153	}
148	154
149		- dev_dbg(dp->dev, "success to get plug in status after force hpd\n");
150		-
151	155	return 0;
152	156	}
153	157
154		-int analogix_dp_psr_enabled(struct analogix_dp_device *dp)
155		-{
156		-
157		- return dp->psr_enable;
158		-}
159		-EXPORT_SYMBOL_GPL(analogix_dp_psr_enabled);
160		-
161		-int analogix_dp_enable_psr(struct analogix_dp_device *dp)
162		-{
163		- struct edp_vsc_psr psr_vsc;
164		-
165		- if (!dp->psr_enable)
166		- return 0;
167		-
168		- /* Prepare VSC packet as per EDP 1.4 spec, Table 6.9 */
169		- memset(&psr_vsc, 0, sizeof(psr_vsc));
170		- psr_vsc.sdp_header.HB0 = 0;
171		- psr_vsc.sdp_header.HB1 = 0x7;
172		- psr_vsc.sdp_header.HB2 = 0x2;
173		- psr_vsc.sdp_header.HB3 = 0x8;
174		-
175		- psr_vsc.DB0 = 0;
176		- psr_vsc.DB1 = EDP_VSC_PSR_STATE_ACTIVE \| EDP_VSC_PSR_CRC_VALUES_VALID;
177		-
178		- return analogix_dp_send_psr_spd(dp, &psr_vsc, true);
179		-}
180		-EXPORT_SYMBOL_GPL(analogix_dp_enable_psr);
181		-
182		-int analogix_dp_disable_psr(struct analogix_dp_device *dp)
183		-{
184		- struct edp_vsc_psr psr_vsc;
185		- int ret;
186		-
187		- if (!dp->psr_enable)
188		- return 0;
189		-
190		- /* Prepare VSC packet as per EDP 1.4 spec, Table 6.9 */
191		- memset(&psr_vsc, 0, sizeof(psr_vsc));
192		- psr_vsc.sdp_header.HB0 = 0;
193		- psr_vsc.sdp_header.HB1 = 0x7;
194		- psr_vsc.sdp_header.HB2 = 0x2;
195		- psr_vsc.sdp_header.HB3 = 0x8;
196		-
197		- psr_vsc.DB0 = 0;
198		- psr_vsc.DB1 = 0;
199		-
200		- ret = drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER, DP_SET_POWER_D0);
201		- if (ret != 1) {
202		- dev_err(dp->dev, "Failed to set DP Power0 %d\n", ret);
203		- return ret;
204		- }
205		-
206		- return analogix_dp_send_psr_spd(dp, &psr_vsc, false);
207		-}
208		-EXPORT_SYMBOL_GPL(analogix_dp_disable_psr);
209		-
210		-static int analogix_dp_detect_sink_psr(struct analogix_dp_device *dp)
	158	+static bool analogix_dp_detect_sink_psr(struct analogix_dp_device *dp)
211	159	{
212	160	unsigned char psr_version;
213	161	int ret;
214	162
215		- if (!of_property_read_bool(dp->dev->of_node, "support-psr"))
	163	+ if (!device_property_read_bool(dp->dev, "support-psr"))
216	164	return 0;
217	165
218	166	ret = drm_dp_dpcd_readb(&dp->aux, DP_PSR_SUPPORT, &psr_version);
219	167	if (ret != 1) {
220	168	dev_err(dp->dev, "failed to get PSR version, disable it\n");
221		- return ret;
	169	+ return false;
222	170	}
223	171
224	172	dev_dbg(dp->dev, "Panel PSR version : %x\n", psr_version);
225		-
226		- dp->psr_enable = (psr_version & DP_PSR_IS_SUPPORTED) ? true : false;
227		-
228		- return 0;
	173	+ return psr_version & DP_PSR_IS_SUPPORTED;
229	174	}
230	175
231	176	static int analogix_dp_enable_sink_psr(struct analogix_dp_device *dp)
..	..	@@ -248,7 +193,7 @@
248	193	}
249	194
250	195	/* Main-Link transmitter remains active during PSR active states */
251		- psr_en = DP_PSR_MAIN_LINK_ACTIVE \| DP_PSR_CRC_VERIFICATION;
	196	+ psr_en = DP_PSR_CRC_VERIFICATION;
252	197	ret = drm_dp_dpcd_writeb(&dp->aux, DP_PSR_EN_CFG, psr_en);
253	198	if (ret != 1) {
254	199	dev_err(dp->dev, "failed to set panel psr\n");
..	..	@@ -256,8 +201,7 @@
256	201	}
257	202
258	203	/* Enable psr function */
259		- psr_en = DP_PSR_ENABLE \| DP_PSR_MAIN_LINK_ACTIVE \|
260		- DP_PSR_CRC_VERIFICATION;
	204	+ psr_en = DP_PSR_ENABLE \| DP_PSR_CRC_VERIFICATION;
261	205	ret = drm_dp_dpcd_writeb(&dp->aux, DP_PSR_EN_CFG, psr_en);
262	206	if (ret != 1) {
263	207	dev_err(dp->dev, "failed to set panel psr\n");
..	..	@@ -266,10 +210,11 @@
266	210
267	211	analogix_dp_enable_psr_crc(dp);
268	212
	213	+ dp->psr_supported = true;
	214	+
269	215	return 0;
270	216	end:
271	217	dev_err(dp->dev, "enable psr fail, force to disable psr\n");
272		- dp->psr_enable = false;
273	218
274	219	return ret;
275	220	}
..	..	@@ -359,6 +304,23 @@
359	304	return ret < 0 ? ret : 0;
360	305	}
361	306
	307	+static bool analogix_dp_get_vrr_capable(struct analogix_dp_device *dp)
	308	+{
	309	+ struct drm_connector *connector = &dp->connector;
	310	+ struct drm_display_info *info = &connector->display_info;
	311	+
	312	+ if (!info->monitor_range.max_vfreq)
	313	+ return false;
	314	+ if (!info->monitor_range.min_vfreq)
	315	+ return false;
	316	+ if (info->monitor_range.max_vfreq < info->monitor_range.min_vfreq)
	317	+ return false;
	318	+ if (!drm_dp_sink_can_do_video_without_timing_msa(dp->dpcd))
	319	+ return false;
	320	+
	321	+ return true;
	322	+}
	323	+
362	324	static int analogix_dp_link_start(struct analogix_dp_device *dp)
363	325	{
364	326	u8 buf[4];
..	..	@@ -385,6 +347,8 @@
385	347
386	348	/* Spread AMP if required, enable 8b/10b coding */
387	349	buf[0] = analogix_dp_ssc_supported(dp) ? DP_SPREAD_AMP_0_5 : 0;
	350	+ if (analogix_dp_get_vrr_capable(dp))
	351	+ buf[0] \|= DP_MSA_TIMING_PAR_IGNORE_EN;
388	352	buf[1] = DP_SET_ANSI_8B10B;
389	353	retval = drm_dp_dpcd_write(&dp->aux, DP_DOWNSPREAD_CTRL, buf, 2);
390	354	if (retval < 0)
..	..	@@ -537,16 +501,11 @@
537	501	u8 link_status[2], adjust_request[2];
538	502	u8 training_pattern = TRAINING_PTN2;
539	503
540		- usleep_range(100, 101);
	504	+ drm_dp_link_train_clock_recovery_delay(dp->dpcd);
541	505
542	506	lane_count = dp->link_train.lane_count;
543	507
544	508	retval = drm_dp_dpcd_read(&dp->aux, DP_LANE0_1_STATUS, link_status, 2);
545		- if (retval < 0)
546		- return retval;
547		-
548		- retval = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1,
549		- adjust_request, 2);
550	509	if (retval < 0)
551	510	return retval;
552	511
..	..	@@ -564,9 +523,16 @@
564	523	if (retval < 0)
565	524	return retval;
566	525
567		- dev_info(dp->dev, "Link Training Clock Recovery success\n");
	526	+ dev_dbg(dp->dev, "Link Training Clock Recovery success\n");
568	527	dp->link_train.lt_state = EQUALIZER_TRAINING;
	528	+
	529	+ return 0;
569	530	} else {
	531	+ retval = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1,
	532	+ adjust_request, 2);
	533	+ if (retval < 0)
	534	+ return retval;
	535	+
570	536	for (lane = 0; lane < lane_count; lane++) {
571	537	training_lane = analogix_dp_get_lane_link_training(
572	538	dp, lane);
..	..	@@ -591,16 +557,15 @@
591	557	return -EIO;
592	558	}
593	559	}
594		-
595		- analogix_dp_get_adjust_training_lane(dp, adjust_request);
596		- analogix_dp_set_lane_link_training(dp);
597		-
598		- retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET,
599		- dp->link_train.training_lane,
600		- lane_count);
601		- if (retval < 0)
602		- return retval;
603	560	}
	561	+
	562	+ analogix_dp_get_adjust_training_lane(dp, adjust_request);
	563	+ analogix_dp_set_lane_link_training(dp);
	564	+
	565	+ retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET,
	566	+ dp->link_train.training_lane, lane_count);
	567	+ if (retval < 0)
	568	+ return retval;
604	569
605	570	return 0;
606	571	}
..	..	@@ -611,7 +576,7 @@
611	576	u32 reg;
612	577	u8 link_align, link_status[2], adjust_request[2];
613	578
614		- usleep_range(400, 401);
	579	+ drm_dp_link_train_channel_eq_delay(dp->dpcd);
615	580
616	581	lane_count = dp->link_train.lane_count;
617	582
..	..	@@ -624,17 +589,10 @@
624	589	return -EIO;
625	590	}
626	591
627		- retval = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1,
628		- adjust_request, 2);
629		- if (retval < 0)
630		- return retval;
631		-
632	592	retval = drm_dp_dpcd_readb(&dp->aux, DP_LANE_ALIGN_STATUS_UPDATED,
633	593	&link_align);
634	594	if (retval < 0)
635	595	return retval;
636		-
637		- analogix_dp_get_adjust_training_lane(dp, adjust_request);
638	596
639	597	if (!analogix_dp_channel_eq_ok(link_status, link_align, lane_count)) {
640	598	/* traing pattern Set to Normal */
..	..	@@ -642,7 +600,7 @@
642	600	if (retval < 0)
643	601	return retval;
644	602
645		- dev_info(dp->dev, "Link Training success!\n");
	603	+ dev_dbg(dp->dev, "Link Training success!\n");
646	604	analogix_dp_get_link_bandwidth(dp, &reg);
647	605	dp->link_train.link_rate = reg;
648	606	dev_dbg(dp->dev, "final bandwidth = %.2x\n",
..	..	@@ -667,6 +625,12 @@
667	625	return -EIO;
668	626	}
669	627
	628	+ retval = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1,
	629	+ adjust_request, 2);
	630	+ if (retval < 0)
	631	+ return retval;
	632	+
	633	+ analogix_dp_get_adjust_training_lane(dp, adjust_request);
670	634	analogix_dp_set_lane_link_training(dp);
671	635
672	636	retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET,
..	..	@@ -677,10 +641,11 @@
677	641	return 0;
678	642	}
679	643
680		-static void analogix_dp_get_max_rx_bandwidth(struct analogix_dp_device *dp,
681		- u8 *bandwidth)
	644	+static int analogix_dp_get_max_rx_bandwidth(struct analogix_dp_device *dp,
	645	+ u8 *bandwidth)
682	646	{
683	647	u8 data;
	648	+ int ret;
684	649
685	650	/*
686	651	* For DP rev.1.1, Maximum link rate of Main Link lanes
..	..	@@ -688,26 +653,38 @@
688	653	* For DP rev.1.2, Maximum link rate of Main Link lanes
689	654	* 0x06 = 1.62 Gbps, 0x0a = 2.7 Gbps, 0x14 = 5.4Gbps
690	655	*/
691		- drm_dp_dpcd_readb(&dp->aux, DP_MAX_LINK_RATE, &data);
	656	+ ret = drm_dp_dpcd_readb(&dp->aux, DP_MAX_LINK_RATE, &data);
	657	+ if (ret < 0)
	658	+ return ret;
	659	+
692	660	*bandwidth = data;
	661	+
	662	+ return 0;
693	663	}
694	664
695		-static void analogix_dp_get_max_rx_lane_count(struct analogix_dp_device *dp,
696		- u8 *lane_count)
	665	+static int analogix_dp_get_max_rx_lane_count(struct analogix_dp_device *dp,
	666	+ u8 *lane_count)
697	667	{
698	668	u8 data;
	669	+ int ret;
699	670
700	671	/*
701	672	* For DP rev.1.1, Maximum number of Main Link lanes
702	673	* 0x01 = 1 lane, 0x02 = 2 lanes, 0x04 = 4 lanes
703	674	*/
704		- drm_dp_dpcd_readb(&dp->aux, DP_MAX_LANE_COUNT, &data);
	675	+ ret = drm_dp_dpcd_readb(&dp->aux, DP_MAX_LANE_COUNT, &data);
	676	+ if (ret < 0)
	677	+ return ret;
	678	+
705	679	*lane_count = DPCD_MAX_LANE_COUNT(data);
	680	+
	681	+ return 0;
706	682	}
707	683
708	684	static int analogix_dp_full_link_train(struct analogix_dp_device *dp,
709	685	u32 max_lanes, u32 max_rate)
710	686	{
	687	+ struct video_info *video = &dp->video_info;
711	688	int retval = 0;
712	689	bool training_finished = false;
713	690	u8 dpcd;
..	..	@@ -722,28 +699,19 @@
722	699	analogix_dp_get_max_rx_bandwidth(dp, &dp->link_train.link_rate);
723	700	analogix_dp_get_max_rx_lane_count(dp, &dp->link_train.lane_count);
724	701
725		- if ((dp->link_train.link_rate != DP_LINK_BW_1_62) &&
726		- (dp->link_train.link_rate != DP_LINK_BW_2_7) &&
727		- (dp->link_train.link_rate != DP_LINK_BW_5_4)) {
728		- dev_err(dp->dev, "Rx Max Link Rate is abnormal :%x !\n",
729		- dp->link_train.link_rate);
730		- dp->link_train.link_rate = DP_LINK_BW_1_62;
731		- }
	702	+ /* Setup TX lane count & rate */
	703	+ dp->link_train.lane_count = min_t(u32, dp->link_train.lane_count, max_lanes);
	704	+ dp->link_train.link_rate = min_t(u32, dp->link_train.link_rate, max_rate);
732	705
733		- if (dp->link_train.lane_count == 0) {
734		- dev_err(dp->dev, "Rx Max Lane count is abnormal :%x !\n",
735		- dp->link_train.lane_count);
736		- dp->link_train.lane_count = (u8)LANE_COUNT1;
	706	+ if (!analogix_dp_bandwidth_ok(dp, &video->mode,
	707	+ drm_dp_bw_code_to_link_rate(dp->link_train.link_rate),
	708	+ dp->link_train.lane_count)) {
	709	+ dev_err(dp->dev, "bandwidth overflow\n");
	710	+ return -EINVAL;
737	711	}
738	712
739	713	drm_dp_dpcd_readb(&dp->aux, DP_MAX_DOWNSPREAD, &dpcd);
740	714	dp->link_train.ssc = !!(dpcd & DP_MAX_DOWNSPREAD_0_5);
741		-
742		- /* Setup TX lane count & rate */
743		- if (dp->link_train.lane_count > max_lanes)
744		- dp->link_train.lane_count = max_lanes;
745		- if (dp->link_train.link_rate > max_rate)
746		- dp->link_train.link_rate = max_rate;
747	715
748	716	/* All DP analog module power up */
749	717	analogix_dp_set_analog_power_down(dp, POWER_ALL, 0);
..	..	@@ -881,7 +849,7 @@
881	849	analogix_dp_set_video_cr_mn(dp, CALCULATED_M, 0, 0);
882	850
883	851	/* For video bist, Video timing must be generated by register */
884		- analogix_dp_set_video_timing_mode(dp, VIDEO_TIMING_FROM_CAPTURE);
	852	+ analogix_dp_set_video_timing_mode(dp, VIDEO_TIMING_FROM_REGISTER);
885	853
886	854	/* Disable video mute */
887	855	analogix_dp_enable_video_mute(dp, 0);
..	..	@@ -943,6 +911,156 @@
943	911	return ret < 0 ? ret : 0;
944	912	}
945	913
	914	+static u8 analogix_dp_autotest_phy_pattern(struct analogix_dp_device *dp)
	915	+{
	916	+ struct drm_dp_phy_test_params *data = &dp->compliance.phytest;
	917	+
	918	+ if (drm_dp_get_phy_test_pattern(&dp->aux, data)) {
	919	+ dev_err(dp->dev, "DP Phy Test pattern AUX read failure\n");
	920	+ return DP_TEST_NAK;
	921	+ }
	922	+
	923	+ if (data->link_rate > drm_dp_bw_code_to_link_rate(dp->video_info.max_link_rate)) {
	924	+ dev_err(dp->dev, "invalid link rate = 0x%x\n", data->link_rate);
	925	+ return DP_TEST_NAK;
	926	+ }
	927	+
	928	+ /* Set test active flag here so userspace doesn't interrupt things */
	929	+ dp->compliance.test_active = true;
	930	+
	931	+ return DP_TEST_ACK;
	932	+}
	933	+
	934	+static void analogix_dp_handle_test_request(struct analogix_dp_device *dp)
	935	+{
	936	+ u8 response = DP_TEST_NAK;
	937	+ u8 request = 0;
	938	+ int ret;
	939	+
	940	+ ret = drm_dp_dpcd_readb(&dp->aux, DP_TEST_REQUEST, &request);
	941	+ if (ret < 0) {
	942	+ dev_err(dp->dev, "Could not read test request from sink\n");
	943	+ goto update_status;
	944	+ }
	945	+
	946	+ switch (request) {
	947	+ case DP_TEST_LINK_PHY_TEST_PATTERN:
	948	+ dev_info(dp->dev, "PHY_PATTERN test requested\n");
	949	+ response = analogix_dp_autotest_phy_pattern(dp);
	950	+ break;
	951	+ default:
	952	+ dev_err(dp->dev, "Invalid test request '%02x'\n", request);
	953	+ break;
	954	+ }
	955	+
	956	+ if (response & DP_TEST_ACK)
	957	+ dp->compliance.test_type = request;
	958	+
	959	+update_status:
	960	+ ret = drm_dp_dpcd_writeb(&dp->aux, DP_TEST_RESPONSE, response);
	961	+ if (ret < 0)
	962	+ dev_err(dp->dev, "Could not write test response to sink\n");
	963	+}
	964	+
	965	+void analogix_dp_check_device_service_irq(struct analogix_dp_device *dp)
	966	+{
	967	+ u8 val;
	968	+ int ret;
	969	+
	970	+ ret = drm_dp_dpcd_readb(&dp->aux, DP_DEVICE_SERVICE_IRQ_VECTOR, &val);
	971	+ if (ret < 0 \|\| !val)
	972	+ return;
	973	+
	974	+ ret = drm_dp_dpcd_writeb(&dp->aux, DP_DEVICE_SERVICE_IRQ_VECTOR, val);
	975	+ if (ret < 0)
	976	+ return;
	977	+
	978	+ if (val & DP_AUTOMATED_TEST_REQUEST)
	979	+ analogix_dp_handle_test_request(dp);
	980	+}
	981	+EXPORT_SYMBOL_GPL(analogix_dp_check_device_service_irq);
	982	+
	983	+static void analogix_dp_process_phy_request(struct analogix_dp_device *dp)
	984	+{
	985	+ struct drm_dp_phy_test_params *data = &dp->compliance.phytest;
	986	+ u8 spread, adjust_request[2];
	987	+ int ret;
	988	+
	989	+ dp->link_train.link_rate = drm_dp_link_rate_to_bw_code(data->link_rate);
	990	+ dp->link_train.lane_count = data->num_lanes;
	991	+
	992	+ ret = drm_dp_dpcd_readb(&dp->aux, DP_MAX_DOWNSPREAD, &spread);
	993	+ if (ret < 0) {
	994	+ dev_err(dp->dev, "Could not read ssc from sink\n");
	995	+ return;
	996	+ }
	997	+
	998	+ dp->link_train.ssc = !!(spread & DP_MAX_DOWNSPREAD_0_5);
	999	+
	1000	+ ret = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1,
	1001	+ adjust_request, 2);
	1002	+ if (ret < 0) {
	1003	+ dev_err(dp->dev, "Could not read swing/pre-emphasis\n");
	1004	+ return;
	1005	+ }
	1006	+
	1007	+ analogix_dp_set_link_bandwidth(dp, dp->link_train.link_rate);
	1008	+ analogix_dp_set_lane_count(dp, dp->link_train.lane_count);
	1009	+ analogix_dp_get_adjust_training_lane(dp, adjust_request);
	1010	+ analogix_dp_set_lane_link_training(dp);
	1011	+
	1012	+ switch (data->phy_pattern) {
	1013	+ case DP_PHY_TEST_PATTERN_NONE:
	1014	+ dev_info(dp->dev, "Disable Phy Test Pattern\n");
	1015	+ analogix_dp_set_training_pattern(dp, DP_NONE);
	1016	+ break;
	1017	+ case DP_PHY_TEST_PATTERN_D10_2:
	1018	+ dev_info(dp->dev, "Set D10.2 Phy Test Pattern\n");
	1019	+ analogix_dp_set_training_pattern(dp, D10_2);
	1020	+ break;
	1021	+ case DP_PHY_TEST_PATTERN_PRBS7:
	1022	+ dev_info(dp->dev, "Set PRBS7 Phy Test Pattern\n");
	1023	+ analogix_dp_set_training_pattern(dp, PRBS7);
	1024	+ break;
	1025	+ case DP_PHY_TEST_PATTERN_80BIT_CUSTOM:
	1026	+ dev_info(dp->dev, "Set 80Bit Custom Phy Test Pattern\n");
	1027	+ analogix_dp_set_training_pattern(dp, TEST_PATTERN_80BIT);
	1028	+ break;
	1029	+ case DP_PHY_TEST_PATTERN_CP2520:
	1030	+ dev_info(dp->dev, "Set HBR2 compliance Phy Test Pattern\n");
	1031	+ analogix_dp_set_training_pattern(dp, TEST_PATTERN_HBR2);
	1032	+ break;
	1033	+ default:
	1034	+ dev_err(dp->dev, "Invalid Phy Test Pattern: %d\n", data->phy_pattern);
	1035	+ return;
	1036	+ }
	1037	+
	1038	+ drm_dp_set_phy_test_pattern(&dp->aux, data, 0x11);
	1039	+}
	1040	+
	1041	+void analogix_dp_phy_test(struct analogix_dp_device *dp)
	1042	+{
	1043	+ struct drm_device *dev = dp->drm_dev;
	1044	+ struct drm_modeset_acquire_ctx ctx;
	1045	+ int ret;
	1046	+
	1047	+ DRM_DEV_INFO(dp->dev, "PHY test\n");
	1048	+
	1049	+ drm_modeset_acquire_init(&ctx, 0);
	1050	+ for (;;) {
	1051	+ ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx);
	1052	+ if (ret != -EDEADLK)
	1053	+ break;
	1054	+
	1055	+ drm_modeset_backoff(&ctx);
	1056	+ }
	1057	+
	1058	+ analogix_dp_process_phy_request(dp);
	1059	+ drm_modeset_drop_locks(&ctx);
	1060	+ drm_modeset_acquire_fini(&ctx);
	1061	+}
	1062	+EXPORT_SYMBOL_GPL(analogix_dp_phy_test);
	1063	+
946	1064	static irqreturn_t analogix_dp_hpd_irq_handler(int irq, void *arg)
947	1065	{
948	1066	struct analogix_dp_device *dp = arg;
..	..	@@ -953,38 +1071,11 @@
953	1071	return IRQ_HANDLED;
954	1072	}
955	1073
956		-static irqreturn_t analogix_dp_hardirq(int irq, void *arg)
957		-{
958		- struct analogix_dp_device *dp = arg;
959		- irqreturn_t ret = IRQ_NONE;
960		- enum dp_irq_type irq_type;
961		-
962		- irq_type = analogix_dp_get_irq_type(dp);
963		- if (irq_type != DP_IRQ_TYPE_UNKNOWN) {
964		- analogix_dp_mute_hpd_interrupt(dp);
965		- ret = IRQ_WAKE_THREAD;
966		- }
967		-
968		- return ret;
969		-}
970		-
971	1074	static irqreturn_t analogix_dp_irq_thread(int irq, void *arg)
972	1075	{
973	1076	struct analogix_dp_device *dp = arg;
974		- enum dp_irq_type irq_type;
975	1077
976		- irq_type = analogix_dp_get_irq_type(dp);
977		- if (irq_type & DP_IRQ_TYPE_HP_CABLE_IN \|\|
978		- irq_type & DP_IRQ_TYPE_HP_CABLE_OUT) {
979		- dev_dbg(dp->dev, "Detected cable status changed!\n");
980		- if (dp->drm_dev)
981		- drm_helper_hpd_irq_event(dp->drm_dev);
982		- }
983		-
984		- if (irq_type != DP_IRQ_TYPE_UNKNOWN) {
985		- analogix_dp_clear_hotplug_interrupts(dp);
986		- analogix_dp_unmute_hpd_interrupt(dp);
987		- }
	1078	+ analogix_dp_irq_handler(dp);
988	1079
989	1080	return IRQ_HANDLED;
990	1081	}
..	..	@@ -1005,10 +1096,68 @@
1005	1096	return 0;
1006	1097	}
1007	1098
	1099	+static int analogix_dp_link_power_up(struct analogix_dp_device *dp)
	1100	+{
	1101	+ u8 value;
	1102	+ int ret;
	1103	+
	1104	+ if (dp->dpcd[DP_DPCD_REV] < 0x11)
	1105	+ return 0;
	1106	+
	1107	+ ret = drm_dp_dpcd_readb(&dp->aux, DP_SET_POWER, &value);
	1108	+ if (ret < 0)
	1109	+ return ret;
	1110	+
	1111	+ value &= ~DP_SET_POWER_MASK;
	1112	+ value \|= DP_SET_POWER_D0;
	1113	+
	1114	+ ret = drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER, value);
	1115	+ if (ret < 0)
	1116	+ return ret;
	1117	+
	1118	+ usleep_range(1000, 2000);
	1119	+
	1120	+ return 0;
	1121	+}
	1122	+
	1123	+static int analogix_dp_link_power_down(struct analogix_dp_device *dp)
	1124	+{
	1125	+ u8 value;
	1126	+ int ret;
	1127	+
	1128	+ if (dp->dpcd[DP_DPCD_REV] < 0x11)
	1129	+ return 0;
	1130	+
	1131	+ ret = drm_dp_dpcd_readb(&dp->aux, DP_SET_POWER, &value);
	1132	+ if (ret < 0)
	1133	+ return ret;
	1134	+
	1135	+ value &= ~DP_SET_POWER_MASK;
	1136	+ value \|= DP_SET_POWER_D3;
	1137	+
	1138	+ ret = drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER, value);
	1139	+ if (ret < 0)
	1140	+ return ret;
	1141	+
	1142	+ return 0;
	1143	+}
	1144	+
1008	1145	static int analogix_dp_commit(struct analogix_dp_device *dp)
1009	1146	{
1010	1147	struct video_info *video = &dp->video_info;
1011	1148	int ret;
	1149	+
	1150	+ ret = drm_dp_read_dpcd_caps(&dp->aux, dp->dpcd);
	1151	+ if (ret < 0) {
	1152	+ dev_err(dp->dev, "failed to read dpcd caps: %d\n", ret);
	1153	+ return ret;
	1154	+ }
	1155	+
	1156	+ ret = analogix_dp_link_power_up(dp);
	1157	+ if (ret) {
	1158	+ dev_err(dp->dev, "failed to power up link: %d\n", ret);
	1159	+ return ret;
	1160	+ }
1012	1161
1013	1162	if (device_property_read_bool(dp->dev, "panel-self-test"))
1014	1163	return drm_dp_dpcd_writeb(&dp->aux, DP_EDP_CONFIGURATION_SET,
..	..	@@ -1018,13 +1167,6 @@
1018	1167	if (ret) {
1019	1168	dev_err(dp->dev, "unable to do link train, ret=%d\n", ret);
1020	1169	return ret;
1021		- }
1022		-
1023		- if (!analogix_dp_bandwidth_ok(dp, &video->mode,
1024		- drm_dp_bw_code_to_link_rate(dp->link_train.link_rate),
1025		- dp->link_train.lane_count)) {
1026		- dev_err(dp->dev, "bandwidth overflow\n");
1027		- return -EINVAL;
1028	1170	}
1029	1171
1030	1172	ret = analogix_dp_enable_scramble(dp, 1);
..	..	@@ -1045,23 +1187,99 @@
1045	1187	return ret;
1046	1188	}
1047	1189
1048		- ret = analogix_dp_detect_sink_psr(dp);
1049		- if (ret)
1050		- return ret;
1051		-
1052	1190	/* Check whether panel supports fast training */
1053	1191	ret = analogix_dp_fast_link_train_detection(dp);
1054	1192	if (ret)
1055		- dp->psr_enable = false;
	1193	+ return ret;
1056	1194
1057		- if (dp->psr_enable) {
	1195	+ if (analogix_dp_detect_sink_psr(dp)) {
1058	1196	ret = analogix_dp_enable_sink_psr(dp);
1059	1197	if (ret)
1060	1198	return ret;
1061	1199	}
1062	1200
	1201	+ return ret;
	1202	+}
	1203	+
	1204	+static int analogix_dp_enable_psr(struct analogix_dp_device *dp)
	1205	+{
	1206	+ struct dp_sdp psr_vsc;
	1207	+ int ret;
	1208	+ u8 sink;
	1209	+
	1210	+ ret = drm_dp_dpcd_readb(&dp->aux, DP_PSR_STATUS, &sink);
	1211	+ if (ret != 1)
	1212	+ DRM_DEV_ERROR(dp->dev, "Failed to read psr status %d\n", ret);
	1213	+ else if (sink == DP_PSR_SINK_ACTIVE_RFB)
	1214	+ return 0;
	1215	+
	1216	+ /* Prepare VSC packet as per EDP 1.4 spec, Table 6.9 */
	1217	+ memset(&psr_vsc, 0, sizeof(psr_vsc));
	1218	+ psr_vsc.sdp_header.HB0 = 0;
	1219	+ psr_vsc.sdp_header.HB1 = 0x7;
	1220	+ psr_vsc.sdp_header.HB2 = 0x2;
	1221	+ psr_vsc.sdp_header.HB3 = 0x8;
	1222	+ psr_vsc.db[0] = 0;
	1223	+ psr_vsc.db[1] = EDP_VSC_PSR_STATE_ACTIVE \| EDP_VSC_PSR_CRC_VALUES_VALID;
	1224	+
	1225	+ ret = analogix_dp_send_psr_spd(dp, &psr_vsc, true);
	1226	+ if (!ret) {
	1227	+ analogix_dp_set_analog_power_down(dp, POWER_ALL, true);
	1228	+
	1229	+ if (dp->phy) {
	1230	+ union phy_configure_opts phy_cfg = {0};
	1231	+
	1232	+ phy_cfg.dp.lanes = 0;
	1233	+ phy_cfg.dp.set_lanes = true;
	1234	+ ret = phy_configure(dp->phy, &phy_cfg);
	1235	+ if (ret)
	1236	+ return ret;
	1237	+ }
	1238	+ }
1063	1239
1064	1240	return ret;
	1241	+}
	1242	+
	1243	+static int analogix_dp_disable_psr(struct analogix_dp_device *dp)
	1244	+{
	1245	+ struct dp_sdp psr_vsc;
	1246	+ int ret;
	1247	+ u8 sink;
	1248	+
	1249	+ analogix_dp_set_analog_power_down(dp, POWER_ALL, false);
	1250	+
	1251	+ ret = drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER, DP_SET_POWER_D0);
	1252	+ if (ret != 1) {
	1253	+ DRM_DEV_ERROR(dp->dev, "Failed to set DP Power0 %d\n", ret);
	1254	+ return ret;
	1255	+ }
	1256	+
	1257	+ ret = drm_dp_dpcd_readb(&dp->aux, DP_PSR_STATUS, &sink);
	1258	+ if (ret != 1) {
	1259	+ DRM_DEV_ERROR(dp->dev, "Failed to read psr status %d\n", ret);
	1260	+ return ret;
	1261	+ } else if (sink == DP_PSR_SINK_INACTIVE) {
	1262	+ DRM_DEV_ERROR(dp->dev, "sink inactive, skip disable psr");
	1263	+ return 0;
	1264	+ }
	1265	+
	1266	+ ret = analogix_dp_train_link(dp);
	1267	+ if (ret) {
	1268	+ DRM_DEV_ERROR(dp->dev, "Failed to train the link %d\n", ret);
	1269	+ return ret;
	1270	+ }
	1271	+
	1272	+ /* Prepare VSC packet as per EDP 1.4 spec, Table 6.9 */
	1273	+ memset(&psr_vsc, 0, sizeof(psr_vsc));
	1274	+ psr_vsc.sdp_header.HB0 = 0;
	1275	+ psr_vsc.sdp_header.HB1 = 0x7;
	1276	+ psr_vsc.sdp_header.HB2 = 0x2;
	1277	+ psr_vsc.sdp_header.HB3 = 0x8;
	1278	+
	1279	+ psr_vsc.db[0] = 0;
	1280	+ psr_vsc.db[1] = 0;
	1281	+
	1282	+ return analogix_dp_send_psr_spd(dp, &psr_vsc, true);
1065	1283	}
1066	1284
1067	1285	static int analogix_dp_get_modes(struct drm_connector *connector)
..	..	@@ -1070,31 +1288,49 @@
1070	1288	struct edid *edid;
1071	1289	int ret, num_modes = 0;
1072	1290
	1291	+ if (dp->plat_data->right && dp->plat_data->right->plat_data->bridge) {
	1292	+ struct drm_bridge *bridge = dp->plat_data->right->plat_data->bridge;
	1293	+
	1294	+ if (bridge->ops & DRM_BRIDGE_OP_MODES) {
	1295	+ if (!drm_bridge_get_modes(bridge, connector))
	1296	+ return 0;
	1297	+ }
	1298	+ }
	1299	+
1073	1300	if (dp->plat_data->panel)
1074		- num_modes += drm_panel_get_modes(dp->plat_data->panel);
	1301	+ num_modes += drm_panel_get_modes(dp->plat_data->panel, connector);
	1302	+
	1303	+ if (dp->plat_data->bridge)
	1304	+ num_modes += drm_bridge_get_modes(dp->plat_data->bridge, connector);
1075	1305
1076	1306	if (!num_modes) {
1077		- if (dp->plat_data->panel) {
1078		- ret = analogix_dp_prepare_panel(dp, true);
1079		- if (ret) {
1080		- DRM_ERROR("Failed to prepare panel (%d)\n", ret);
1081		- return 0;
1082		- }
1083		- }
	1307	+ ret = analogix_dp_phy_power_on(dp);
	1308	+ if (ret)
	1309	+ return 0;
1084	1310
1085		- pm_runtime_get_sync(dp->dev);
	1311	+ if (dp->plat_data->panel)
	1312	+ analogix_dp_panel_prepare(dp);
	1313	+
1086	1314	edid = drm_get_edid(connector, &dp->aux.ddc);
1087		- pm_runtime_put(dp->dev);
1088	1315	if (edid) {
1089	1316	drm_connector_update_edid_property(&dp->connector,
1090	1317	edid);
1091	1318	num_modes += drm_add_edid_modes(&dp->connector, edid);
1092	1319	kfree(edid);
1093	1320	}
	1321	+
	1322	+ analogix_dp_phy_power_off(dp);
1094	1323	}
1095	1324
1096	1325	if (dp->plat_data->get_modes)
1097	1326	num_modes += dp->plat_data->get_modes(dp->plat_data, connector);
	1327	+
	1328	+ if (num_modes > 0 && dp->plat_data->split_mode) {
	1329	+ struct drm_display_mode *mode;
	1330	+
	1331	+ list_for_each_entry(mode, &connector->probed_modes, head)
	1332	+ dp->plat_data->convert_to_split_mode(mode);
	1333	+ }
1098	1334
1099	1335	return num_modes;
1100	1336	}
..	..	@@ -1107,91 +1343,148 @@
1107	1343	return dp->encoder;
1108	1344	}
1109	1345
1110		-static int analogix_dp_loader_protect(struct drm_connector *connector, bool on)
	1346	+
	1347	+static int analogix_dp_atomic_check(struct drm_connector *connector,
	1348	+ struct drm_atomic_state *state)
1111	1349	{
1112	1350	struct analogix_dp_device *dp = to_dp(connector);
	1351	+ struct drm_connector_state *conn_state;
	1352	+ struct drm_crtc_state *crtc_state;
	1353	+
	1354	+ conn_state = drm_atomic_get_new_connector_state(state, connector);
	1355	+ if (WARN_ON(!conn_state))
	1356	+ return -ENODEV;
	1357	+
	1358	+ conn_state->self_refresh_aware = true;
	1359	+
	1360	+ if (!conn_state->crtc)
	1361	+ return 0;
	1362	+
	1363	+ crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);
	1364	+ if (!crtc_state)
	1365	+ return 0;
	1366	+
	1367	+ if (crtc_state->self_refresh_active && !dp->psr_supported)
	1368	+ return -EINVAL;
	1369	+
	1370	+ return 0;
	1371	+}
	1372	+
	1373	+static const struct drm_connector_helper_funcs analogix_dp_connector_helper_funcs = {
	1374	+ .get_modes = analogix_dp_get_modes,
	1375	+ .best_encoder = analogix_dp_best_encoder,
	1376	+ .atomic_check = analogix_dp_atomic_check,
	1377	+};
	1378	+
	1379	+static enum drm_connector_status
	1380	+analogix_dp_detect(struct analogix_dp_device *dp)
	1381	+{
	1382	+ enum drm_connector_status status = connector_status_disconnected;
1113	1383	int ret;
1114	1384
	1385	+ ret = analogix_dp_phy_power_on(dp);
	1386	+ if (ret) {
	1387	+ extcon_set_state_sync(dp->extcon, EXTCON_DISP_DP, false);
	1388	+ return connector_status_disconnected;
	1389	+ }
	1390	+
1115	1391	if (dp->plat_data->panel)
1116		- drm_panel_loader_protect(dp->plat_data->panel, on);
	1392	+ analogix_dp_panel_prepare(dp);
1117	1393
1118		- if (on) {
1119		- dp->dpms_mode = DRM_MODE_DPMS_ON;
	1394	+ if (!analogix_dp_detect_hpd(dp)) {
	1395	+ ret = analogix_dp_get_max_rx_bandwidth(dp, &dp->link_train.link_rate);
	1396	+ if (ret) {
	1397	+ dev_err(dp->dev, "failed to read max link rate\n");
	1398	+ goto out;
	1399	+ }
1120	1400
1121		- pm_runtime_get_sync(dp->dev);
	1401	+ ret = analogix_dp_get_max_rx_lane_count(dp, &dp->link_train.lane_count);
	1402	+ if (ret) {
	1403	+ dev_err(dp->dev, "failed to read max lane count\n");
	1404	+ goto out;
	1405	+ }
1122	1406
1123		- analogix_dp_phy_power_on(dp);
	1407	+ status = connector_status_connected;
	1408	+ }
1124	1409
1125		- ret = analogix_dp_detect_sink_psr(dp);
1126		- if (ret)
1127		- return ret;
	1410	+ if (dp->plat_data->bridge) {
	1411	+ struct drm_bridge *next_bridge = dp->plat_data->bridge;
1128	1412
1129		- if (dp->psr_enable) {
1130		- ret = analogix_dp_enable_sink_psr(dp);
1131		- if (ret)
1132		- return ret;
	1413	+ if (next_bridge->ops & DRM_BRIDGE_OP_DETECT)
	1414	+ status = drm_bridge_detect(next_bridge);
	1415	+ }
	1416	+
	1417	+out:
	1418	+ analogix_dp_phy_power_off(dp);
	1419	+
	1420	+ if (status == connector_status_connected)
	1421	+ extcon_set_state_sync(dp->extcon, EXTCON_DISP_DP, true);
	1422	+ else
	1423	+ extcon_set_state_sync(dp->extcon, EXTCON_DISP_DP, false);
	1424	+
	1425	+ return status;
	1426	+}
	1427	+
	1428	+static enum drm_connector_status
	1429	+analogix_dp_connector_detect(struct drm_connector *connector, bool force)
	1430	+{
	1431	+ struct analogix_dp_device *dp = to_dp(connector);
	1432	+
	1433	+ if (dp->plat_data->right && analogix_dp_detect(dp->plat_data->right) != connector_status_connected)
	1434	+ return connector_status_disconnected;
	1435	+
	1436	+ return analogix_dp_detect(dp);
	1437	+}
	1438	+
	1439	+static void analogix_dp_connector_force(struct drm_connector *connector)
	1440	+{
	1441	+ struct analogix_dp_device *dp = to_dp(connector);
	1442	+
	1443	+ if (connector->status == connector_status_connected)
	1444	+ extcon_set_state_sync(dp->extcon, EXTCON_DISP_DP, true);
	1445	+ else
	1446	+ extcon_set_state_sync(dp->extcon, EXTCON_DISP_DP, false);
	1447	+}
	1448	+
	1449	+static int
	1450	+analogix_dp_atomic_connector_get_property(struct drm_connector *connector,
	1451	+ const struct drm_connector_state *state,
	1452	+ struct drm_property *property,
	1453	+ uint64_t *val)
	1454	+{
	1455	+ struct rockchip_drm_private *private = connector->dev->dev_private;
	1456	+ struct analogix_dp_device *dp = to_dp(connector);
	1457	+
	1458	+ if (property == private->split_area_prop) {
	1459	+ switch (dp->split_area) {
	1460	+ case 1:
	1461	+ *val = ROCKCHIP_DRM_SPLIT_LEFT_SIDE;
	1462	+ break;
	1463	+ case 2:
	1464	+ *val = ROCKCHIP_DRM_SPLIT_RIGHT_SIDE;
	1465	+ break;
	1466	+ default:
	1467	+ *val = ROCKCHIP_DRM_SPLIT_UNSET;
	1468	+ break;
1133	1469	}
1134	1470	}
1135	1471
1136	1472	return 0;
1137	1473	}
1138	1474
1139		-static const struct drm_connector_helper_funcs analogix_dp_connector_helper_funcs = {
1140		- .loader_protect = analogix_dp_loader_protect,
1141		- .get_modes = analogix_dp_get_modes,
1142		- .best_encoder = analogix_dp_best_encoder,
1143		-};
1144		-
1145		-static enum drm_connector_status
1146		-analogix_dp_detect(struct drm_connector *connector, bool force)
1147		-{
1148		- struct analogix_dp_device *dp = to_dp(connector);
1149		- enum drm_connector_status status = connector_status_disconnected;
1150		- int ret;
1151		-
1152		- if (dp->plat_data->panel) {
1153		- ret = analogix_dp_prepare_panel(dp, true);
1154		- if (ret) {
1155		- DRM_ERROR("Failed to prepare panel (%d)\n", ret);
1156		- return ret;
1157		- }
1158		- }
1159		-
1160		- pm_runtime_get_sync(dp->dev);
1161		- if (!analogix_dp_detect_hpd(dp))
1162		- status = connector_status_connected;
1163		- pm_runtime_put(dp->dev);
1164		-
1165		- return status;
1166		-}
1167		-
1168		-static int
1169		-analogix_dp_atomic_connector_get_property(struct drm_connector *connector,
1170		- const struct drm_connector_state *state,
1171		- struct drm_property *property,
1172		- uint64_t *val)
1173		-{
1174		- struct analogix_dp_device *dp = to_dp(connector);
1175		- const struct analogix_dp_property_ops *ops = dp->plat_data->property_ops;
1176		-
1177		- if (ops && ops->get_property)
1178		- return ops->get_property(connector, state, property,
1179		- val, dp->plat_data);
1180		- else
1181		- return -EINVAL;
1182		-}
1183		-
1184	1475	static const struct drm_connector_funcs analogix_dp_connector_funcs = {
1185	1476	.fill_modes = drm_helper_probe_single_connector_modes,
1186		- .detect = analogix_dp_detect,
	1477	+ .detect = analogix_dp_connector_detect,
1187	1478	.destroy = drm_connector_cleanup,
1188	1479	.reset = drm_atomic_helper_connector_reset,
1189	1480	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
1190	1481	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
	1482	+ .force = analogix_dp_connector_force,
1191	1483	.atomic_get_property = analogix_dp_atomic_connector_get_property,
1192	1484	};
1193	1485
1194		-static int analogix_dp_bridge_attach(struct drm_bridge *bridge)
	1486	+static int analogix_dp_bridge_attach(struct drm_bridge *bridge,
	1487	+ enum drm_bridge_attach_flags flags)
1195	1488	{
1196	1489	struct analogix_dp_device *dp = bridge->driver_private;
1197	1490	struct drm_encoder *encoder = dp->encoder;
..	..	@@ -1203,26 +1496,51 @@
1203	1496	return -ENODEV;
1204	1497	}
1205	1498
	1499	+ if (dp->plat_data->bridge) {
	1500	+ ret = drm_bridge_attach(bridge->encoder, dp->plat_data->bridge, bridge,
	1501	+ dp->plat_data->skip_connector ?
	1502	+ 0 : DRM_BRIDGE_ATTACH_NO_CONNECTOR);
	1503	+ if (ret) {
	1504	+ DRM_ERROR("Failed to attach external bridge: %d\n", ret);
	1505	+ return ret;
	1506	+ }
	1507	+ }
	1508	+
	1509	+ if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
	1510	+ return 0;
	1511	+
1206	1512	if (!dp->plat_data->skip_connector) {
1207		- const struct analogix_dp_property_ops *ops = dp->plat_data->property_ops;
	1513	+ int connector_type = DRM_MODE_CONNECTOR_eDP;
	1514	+ struct rockchip_drm_private *private;
	1515	+
	1516	+ if (dp->plat_data->bridge &&
	1517	+ dp->plat_data->bridge->type != DRM_MODE_CONNECTOR_Unknown)
	1518	+ connector_type = dp->plat_data->bridge->type;
1208	1519
1209	1520	connector = &dp->connector;
1210	1521	connector->polled = DRM_CONNECTOR_POLL_HPD;
	1522	+ if (dp->plat_data->bridge && dp->plat_data->bridge->ops & DRM_BRIDGE_OP_DETECT)
	1523	+ connector->polled = DRM_CONNECTOR_POLL_CONNECT \|
	1524	+ DRM_CONNECTOR_POLL_DISCONNECT;
1211	1525
1212	1526	ret = drm_connector_init(dp->drm_dev, connector,
1213	1527	&analogix_dp_connector_funcs,
1214		- DRM_MODE_CONNECTOR_eDP);
	1528	+ connector_type);
1215	1529	if (ret) {
1216	1530	DRM_ERROR("Failed to initialize connector with drm\n");
1217	1531	return ret;
1218	1532	}
1219	1533
	1534	+ private = connector->dev->dev_private;
	1535	+
	1536	+ if (dp->split_area)
	1537	+ drm_object_attach_property(&connector->base,
	1538	+ private->split_area_prop,
	1539	+ dp->split_area);
	1540	+
1220	1541	drm_connector_helper_add(connector,
1221	1542	&analogix_dp_connector_helper_funcs);
1222	1543	drm_connector_attach_encoder(connector, encoder);
1223		-
1224		- if (ops && ops->attach_properties)
1225		- ops->attach_properties(connector);
1226	1544	}
1227	1545
1228	1546	/*
..	..	@@ -1231,18 +1549,10 @@
1231	1549	* plat_data->attch return, that's why we record the connector
1232	1550	* point after plat attached.
1233	1551	*/
1234		- if (dp->plat_data->attach) {
1235		- ret = dp->plat_data->attach(dp->plat_data, bridge, connector);
1236		- if (ret) {
1237		- DRM_ERROR("Failed at platform attch func\n");
1238		- return ret;
1239		- }
1240		- }
1241		-
1242		- if (dp->plat_data->panel) {
1243		- ret = drm_panel_attach(dp->plat_data->panel, &dp->connector);
	1552	+ if (dp->plat_data->attach) {
	1553	+ ret = dp->plat_data->attach(dp->plat_data, bridge, connector);
1244	1554	if (ret) {
1245		- DRM_ERROR("Failed to attach panel\n");
	1555	+ DRM_ERROR("Failed at platform attach func\n");
1246	1556	return ret;
1247	1557	}
1248	1558	}
..	..	@@ -1250,28 +1560,89 @@
1250	1560	return 0;
1251	1561	}
1252	1562
1253		-static void analogix_dp_bridge_pre_enable(struct drm_bridge *bridge)
	1563	+static void analogix_dp_bridge_detach(struct drm_bridge *bridge)
1254	1564	{
1255	1565	struct analogix_dp_device *dp = bridge->driver_private;
1256		- int ret;
1257	1566
1258		- if (dp->plat_data->panel) {
1259		- ret = analogix_dp_prepare_panel(dp, true);
1260		- if (ret)
1261		- DRM_ERROR("failed to setup the panel ret = %d\n", ret);
1262		- }
	1567	+ if (dp->plat_data->detach)
	1568	+ dp->plat_data->detach(dp->plat_data, bridge);
	1569	+}
	1570	+
	1571	+static
	1572	+struct drm_crtc analogix_dp_get_old_crtc(struct analogix_dp_device dp,
	1573	+ struct drm_atomic_state *state)
	1574	+{
	1575	+ struct drm_encoder *encoder = dp->encoder;
	1576	+ struct drm_connector *connector;
	1577	+ struct drm_connector_state *conn_state;
	1578	+
	1579	+ connector = drm_atomic_get_old_connector_for_encoder(state, encoder);
	1580	+ if (!connector)
	1581	+ return NULL;
	1582	+
	1583	+ conn_state = drm_atomic_get_old_connector_state(state, connector);
	1584	+ if (!conn_state)
	1585	+ return NULL;
	1586	+
	1587	+ return conn_state->crtc;
	1588	+}
	1589	+
	1590	+static
	1591	+struct drm_crtc analogix_dp_get_new_crtc(struct analogix_dp_device dp,
	1592	+ struct drm_atomic_state *state)
	1593	+{
	1594	+ struct drm_bridge *bridge = &dp->bridge;
	1595	+ struct drm_encoder *encoder = bridge->encoder;
	1596	+ struct drm_connector *connector;
	1597	+ struct drm_connector_state *conn_state;
	1598	+
	1599	+ connector = drm_atomic_get_new_connector_for_encoder(state, encoder);
	1600	+ if (!connector)
	1601	+ return NULL;
	1602	+
	1603	+ conn_state = drm_atomic_get_new_connector_state(state, connector);
	1604	+ if (!conn_state)
	1605	+ return NULL;
	1606	+
	1607	+ return conn_state->crtc;
	1608	+}
	1609	+
	1610	+static void
	1611	+analogix_dp_bridge_atomic_pre_enable(struct drm_bridge *bridge,
	1612	+ struct drm_bridge_state *old_bridge_state)
	1613	+{
	1614	+ struct drm_atomic_state *old_state = old_bridge_state->base.state;
	1615	+ struct analogix_dp_device *dp = bridge->driver_private;
	1616	+ struct drm_crtc *crtc;
	1617	+ struct drm_crtc_state old_crtc_state, new_crtc_state;
	1618	+
	1619	+ crtc = analogix_dp_get_new_crtc(dp, old_state);
	1620	+ if (!crtc)
	1621	+ return;
	1622	+
	1623	+ old_crtc_state = drm_atomic_get_old_crtc_state(old_state, crtc);
	1624	+
	1625	+ new_crtc_state = drm_atomic_get_new_crtc_state(old_state, crtc);
	1626	+ analogix_dp_bridge_mode_set(bridge, &new_crtc_state->adjusted_mode);
	1627	+
	1628	+ /* Don't touch the panel if we're coming back from PSR */
	1629	+ if (old_crtc_state && old_crtc_state->self_refresh_active)
	1630	+ return;
	1631	+
	1632	+ if (dp->plat_data->panel)
	1633	+ analogix_dp_panel_prepare(dp);
1263	1634	}
1264	1635
1265	1636	static int analogix_dp_set_bridge(struct analogix_dp_device *dp)
1266	1637	{
1267	1638	int ret;
1268	1639
1269		- pm_runtime_get_sync(dp->dev);
1270		-
1271	1640	if (dp->plat_data->power_on_start)
1272	1641	dp->plat_data->power_on_start(dp->plat_data);
1273	1642
1274		- analogix_dp_phy_power_on(dp);
	1643	+ ret = analogix_dp_phy_power_on(dp);
	1644	+ if (ret)
	1645	+ return ret;
1275	1646
1276	1647	ret = analogix_dp_init_dp(dp);
1277	1648	if (ret)
..	..	@@ -1300,22 +1671,47 @@
1300	1671	if (dp->plat_data->power_on_end)
1301	1672	dp->plat_data->power_on_end(dp->plat_data);
1302	1673
1303		- enable_irq(dp->irq);
1304	1674	return 0;
1305	1675
1306	1676	out_dp_init:
1307	1677	analogix_dp_phy_power_off(dp);
1308	1678	if (dp->plat_data->power_off)
1309	1679	dp->plat_data->power_off(dp->plat_data);
1310		- pm_runtime_put_sync(dp->dev);
1311		-
1312	1680	return ret;
1313	1681	}
1314	1682
1315		-static void analogix_dp_bridge_enable(struct drm_bridge *bridge)
	1683	+static void analogix_dp_modeset_retry_work_fn(struct work_struct *work)
1316	1684	{
	1685	+ struct analogix_dp_device *dp =
	1686	+ container_of(work, typeof(*dp), modeset_retry_work);
	1687	+
	1688	+ /* Send Hotplug uevent so userspace can reprobe */
	1689	+ drm_kms_helper_hotplug_event(dp->bridge.dev);
	1690	+}
	1691	+
	1692	+static void
	1693	+analogix_dp_bridge_atomic_enable(struct drm_bridge *bridge,
	1694	+ struct drm_bridge_state *old_bridge_state)
	1695	+{
	1696	+ struct drm_atomic_state *old_state = old_bridge_state->base.state;
1317	1697	struct analogix_dp_device *dp = bridge->driver_private;
	1698	+ struct drm_crtc *crtc;
	1699	+ struct drm_crtc_state *old_crtc_state;
1318	1700	int timeout_loop = 0;
	1701	+ int ret;
	1702	+
	1703	+ crtc = analogix_dp_get_new_crtc(dp, old_state);
	1704	+ if (!crtc)
	1705	+ return;
	1706	+
	1707	+ old_crtc_state = drm_atomic_get_old_crtc_state(old_state, crtc);
	1708	+ /* Not a full enable, just disable PSR and continue */
	1709	+ if (old_crtc_state && old_crtc_state->self_refresh_active) {
	1710	+ ret = analogix_dp_disable_psr(dp);
	1711	+ if (ret)
	1712	+ DRM_ERROR("Failed to disable psr %d\n", ret);
	1713	+ return;
	1714	+ }
1319	1715
1320	1716	if (dp->dpms_mode == DRM_MODE_DPMS_ON)
1321	1717	return;
..	..	@@ -1331,12 +1727,14 @@
1331	1727	usleep_range(10, 11);
1332	1728	}
1333	1729	dev_err(dp->dev, "too many times retry set bridge, give it up\n");
	1730	+
	1731	+ /* Schedule a Hotplug Uevent to userspace to start modeset */
	1732	+ schedule_work(&dp->modeset_retry_work);
1334	1733	}
1335	1734
1336	1735	static void analogix_dp_bridge_disable(struct drm_bridge *bridge)
1337	1736	{
1338	1737	struct analogix_dp_device *dp = bridge->driver_private;
1339		- int ret;
1340	1738
1341	1739	if (dp->dpms_mode != DRM_MODE_DPMS_ON)
1342	1740	return;
..	..	@@ -1348,44 +1746,115 @@
1348	1746	}
1349	1747	}
1350	1748
1351		- disable_irq(dp->irq);
	1749	+ if (!analogix_dp_get_plug_in_status(dp))
	1750	+ analogix_dp_link_power_down(dp);
1352	1751
1353	1752	if (dp->plat_data->power_off)
1354	1753	dp->plat_data->power_off(dp->plat_data);
1355	1754
1356		- analogix_dp_reset_aux(dp);
1357	1755	analogix_dp_set_analog_power_down(dp, POWER_ALL, 1);
1358	1756	analogix_dp_phy_power_off(dp);
1359	1757
1360		- pm_runtime_put_sync(dp->dev);
	1758	+ if (dp->plat_data->panel)
	1759	+ analogix_dp_panel_unprepare(dp);
1361	1760
1362		- if (dp->plat_data->panel) {
1363		- ret = analogix_dp_prepare_panel(dp, false);
1364		- if (ret)
1365		- DRM_ERROR("failed to setup the panel ret = %d\n", ret);
1366		- }
1367		-
1368		- dp->psr_enable = false;
1369	1761	dp->fast_train_enable = false;
	1762	+ dp->psr_supported = false;
1370	1763	dp->dpms_mode = DRM_MODE_DPMS_OFF;
1371	1764	}
1372	1765
	1766	+void analogix_dp_disable(struct analogix_dp_device *dp)
	1767	+{
	1768	+ analogix_dp_bridge_disable(&dp->bridge);
	1769	+}
	1770	+EXPORT_SYMBOL_GPL(analogix_dp_disable);
	1771	+
	1772	+static void
	1773	+analogix_dp_bridge_atomic_disable(struct drm_bridge *bridge,
	1774	+ struct drm_bridge_state *old_bridge_state)
	1775	+{
	1776	+ struct drm_atomic_state *old_state = old_bridge_state->base.state;
	1777	+ struct analogix_dp_device *dp = bridge->driver_private;
	1778	+ struct drm_crtc old_crtc, new_crtc;
	1779	+ struct drm_crtc_state *old_crtc_state = NULL;
	1780	+ struct drm_crtc_state *new_crtc_state = NULL;
	1781	+ int ret;
	1782	+
	1783	+ new_crtc = analogix_dp_get_new_crtc(dp, old_state);
	1784	+ if (!new_crtc)
	1785	+ goto out;
	1786	+
	1787	+ new_crtc_state = drm_atomic_get_new_crtc_state(old_state, new_crtc);
	1788	+ if (!new_crtc_state)
	1789	+ goto out;
	1790	+
	1791	+ /* Don't do a full disable on PSR transitions */
	1792	+ if (new_crtc_state->self_refresh_active)
	1793	+ return;
	1794	+
	1795	+out:
	1796	+ old_crtc = analogix_dp_get_old_crtc(dp, old_state);
	1797	+ if (old_crtc) {
	1798	+ old_crtc_state = drm_atomic_get_old_crtc_state(old_state,
	1799	+ old_crtc);
	1800	+
	1801	+ /* When moving from PSR to fully disabled, exit PSR first. */
	1802	+ if (old_crtc_state && old_crtc_state->self_refresh_active) {
	1803	+ ret = analogix_dp_disable_psr(dp);
	1804	+ if (ret)
	1805	+ DRM_ERROR("Failed to disable psr (%d)\n", ret);
	1806	+ }
	1807	+ }
	1808	+
	1809	+ analogix_dp_bridge_disable(bridge);
	1810	+}
	1811	+
	1812	+static void
	1813	+analogix_dp_bridge_atomic_post_disable(struct drm_bridge *bridge,
	1814	+ struct drm_bridge_state *old_bridge_state)
	1815	+{
	1816	+ struct drm_atomic_state *old_state = old_bridge_state->base.state;
	1817	+ struct analogix_dp_device *dp = bridge->driver_private;
	1818	+ struct drm_crtc *crtc;
	1819	+ struct drm_crtc_state *new_crtc_state;
	1820	+ int ret;
	1821	+
	1822	+ crtc = analogix_dp_get_new_crtc(dp, old_state);
	1823	+ if (!crtc)
	1824	+ return;
	1825	+
	1826	+ new_crtc_state = drm_atomic_get_new_crtc_state(old_state, crtc);
	1827	+ if (!new_crtc_state \|\| !new_crtc_state->self_refresh_active)
	1828	+ return;
	1829	+
	1830	+ ret = analogix_dp_enable_psr(dp);
	1831	+ if (ret)
	1832	+ DRM_ERROR("Failed to enable psr (%d)\n", ret);
	1833	+}
	1834	+
1373	1835	static void analogix_dp_bridge_mode_set(struct drm_bridge *bridge,
1374		- struct drm_display_mode *orig_mode,
1375		- struct drm_display_mode *mode)
	1836	+ const struct drm_display_mode *adj_mode)
1376	1837	{
1377	1838	struct analogix_dp_device *dp = bridge->driver_private;
1378	1839	struct drm_display_info *display_info = &dp->connector.display_info;
1379	1840	struct video_info *video = &dp->video_info;
	1841	+ struct drm_display_mode *mode = &video->mode;
1380	1842	struct device_node *dp_node = dp->dev->of_node;
1381	1843	int vic;
1382	1844
1383		- drm_mode_copy(&video->mode, mode);
	1845	+ drm_mode_copy(mode, adj_mode);
	1846	+ if (dp->plat_data->split_mode)
	1847	+ dp->plat_data->convert_to_origin_mode(mode);
1384	1848
1385	1849	/* Input video interlaces & hsync pol & vsync pol */
1386	1850	video->interlaced = !!(mode->flags & DRM_MODE_FLAG_INTERLACE);
1387		- video->v_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NVSYNC);
1388		- video->h_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NHSYNC);
	1851	+ if (dp->plat_data->dev_type == RK3588_EDP) {
	1852	+ video->v_sync_polarity = true;
	1853	+ video->h_sync_polarity = true;
	1854	+ } else {
	1855	+ video->v_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NVSYNC);
	1856	+ video->h_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NHSYNC);
	1857	+ }
1389	1858
1390	1859	/* Input video dynamic_range & colorimetry */
1391	1860	vic = drm_match_cea_mode(mode);
..	..	@@ -1449,74 +1918,152 @@
1449	1918	video->interlaced = true;
1450	1919	}
1451	1920
	1921	+static bool analogix_dp_link_config_validate(u8 link_rate, u8 lane_count)
	1922	+{
	1923	+ switch (link_rate) {
	1924	+ case DP_LINK_BW_1_62:
	1925	+ case DP_LINK_BW_2_7:
	1926	+ case DP_LINK_BW_5_4:
	1927	+ break;
	1928	+ default:
	1929	+ return false;
	1930	+ }
	1931	+
	1932	+ switch (lane_count) {
	1933	+ case 1:
	1934	+ case 2:
	1935	+ case 4:
	1936	+ break;
	1937	+ default:
	1938	+ return false;
	1939	+ }
	1940	+
	1941	+ return true;
	1942	+}
	1943	+
1452	1944	static enum drm_mode_status
1453	1945	analogix_dp_bridge_mode_valid(struct drm_bridge *bridge,
	1946	+ const struct drm_display_info *info,
1454	1947	const struct drm_display_mode *mode)
1455	1948	{
1456	1949	struct analogix_dp_device *dp = bridge->driver_private;
	1950	+ struct drm_display_mode m;
	1951	+ u32 max_link_rate, max_lane_count;
1457	1952
1458		- if (!analogix_dp_bandwidth_ok(dp, mode,
1459		- drm_dp_bw_code_to_link_rate(dp->video_info.max_link_rate),
1460		- dp->video_info.max_lane_count))
	1953	+ drm_mode_copy(&m, mode);
	1954	+
	1955	+ if (dp->plat_data->split_mode \|\| dp->plat_data->dual_connector_split)
	1956	+ dp->plat_data->convert_to_origin_mode(&m);
	1957	+
	1958	+ max_link_rate = min_t(u32, dp->video_info.max_link_rate,
	1959	+ dp->link_train.link_rate);
	1960	+ max_lane_count = min_t(u32, dp->video_info.max_lane_count,
	1961	+ dp->link_train.lane_count);
	1962	+ if (analogix_dp_link_config_validate(max_link_rate, max_lane_count) &&
	1963	+ !analogix_dp_bandwidth_ok(dp, &m,
	1964	+ drm_dp_bw_code_to_link_rate(max_link_rate),
	1965	+ max_lane_count))
1461	1966	return MODE_BAD;
1462	1967
1463	1968	return MODE_OK;
1464	1969	}
1465	1970
1466		-static void analogix_dp_bridge_nop(struct drm_bridge *bridge)
1467		-{
1468		- /* do nothing */
1469		-}
1470		-
1471	1971	static const struct drm_bridge_funcs analogix_dp_bridge_funcs = {
1472		- .pre_enable = analogix_dp_bridge_pre_enable,
1473		- .enable = analogix_dp_bridge_enable,
1474		- .disable = analogix_dp_bridge_disable,
1475		- .post_disable = analogix_dp_bridge_nop,
1476		- .mode_set = analogix_dp_bridge_mode_set,
	1972	+ .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
	1973	+ .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
	1974	+ .atomic_reset = drm_atomic_helper_bridge_reset,
	1975	+ .atomic_pre_enable = analogix_dp_bridge_atomic_pre_enable,
	1976	+ .atomic_enable = analogix_dp_bridge_atomic_enable,
	1977	+ .atomic_disable = analogix_dp_bridge_atomic_disable,
	1978	+ .atomic_post_disable = analogix_dp_bridge_atomic_post_disable,
1477	1979	.attach = analogix_dp_bridge_attach,
	1980	+ .detach = analogix_dp_bridge_detach,
1478	1981	.mode_valid = analogix_dp_bridge_mode_valid,
1479	1982	};
1480	1983
1481		-static int analogix_dp_create_bridge(struct drm_device *drm_dev,
1482		- struct analogix_dp_device *dp)
	1984	+static int analogix_dp_bridge_init(struct analogix_dp_device *dp)
1483	1985	{
1484		- struct drm_bridge *bridge;
	1986	+ struct drm_bridge *bridge = &dp->bridge;
1485	1987	int ret;
1486	1988
1487		- bridge = devm_kzalloc(drm_dev->dev, sizeof(*bridge), GFP_KERNEL);
1488		- if (!bridge) {
1489		- DRM_ERROR("failed to allocate for drm bridge\n");
1490		- return -ENOMEM;
	1989	+ if (!dp->plat_data->left) {
	1990	+ ret = drm_bridge_attach(dp->encoder, bridge, NULL, 0);
	1991	+ if (ret) {
	1992	+ DRM_ERROR("failed to attach drm bridge\n");
	1993	+ return ret;
	1994	+ }
1491	1995	}
1492	1996
1493		- dp->bridge = bridge;
	1997	+ if (dp->plat_data->right) {
	1998	+ struct analogix_dp_device *secondary = dp->plat_data->right;
	1999	+ struct drm_bridge *last_bridge =
	2000	+ list_last_entry(&bridge->encoder->bridge_chain,
	2001	+ struct drm_bridge, chain_node);
1494	2002
1495		- bridge->driver_private = dp;
1496		- bridge->funcs = &analogix_dp_bridge_funcs;
1497		-
1498		- ret = drm_bridge_attach(dp->encoder, bridge, NULL);
1499		- if (ret) {
1500		- DRM_ERROR("failed to attach drm bridge\n");
1501		- return -EINVAL;
	2003	+ ret = drm_bridge_attach(dp->encoder, &secondary->bridge, last_bridge,
	2004	+ DRM_BRIDGE_ATTACH_NO_CONNECTOR);
	2005	+ if (ret)
	2006	+ return ret;
1502	2007	}
1503	2008
1504	2009	return 0;
	2010	+}
	2011	+
	2012	+static u32 analogix_dp_parse_link_frequencies(struct analogix_dp_device *dp)
	2013	+{
	2014	+ struct device_node *node = dp->dev->of_node;
	2015	+ struct device_node *endpoint;
	2016	+ u64 frequency = 0;
	2017	+ int cnt;
	2018	+
	2019	+ endpoint = of_graph_get_endpoint_by_regs(node, 1, 0);
	2020	+ if (!endpoint)
	2021	+ return 0;
	2022	+
	2023	+ cnt = of_property_count_u64_elems(endpoint, "link-frequencies");
	2024	+ if (cnt > 0)
	2025	+ of_property_read_u64_index(endpoint, "link-frequencies",
	2026	+ cnt - 1, &frequency);
	2027	+ of_node_put(endpoint);
	2028	+
	2029	+ if (!frequency)
	2030	+ return 0;
	2031	+
	2032	+ do_div(frequency, 10 * 1000); /* symbol rate kbytes */
	2033	+
	2034	+ switch (frequency) {
	2035	+ case 162000:
	2036	+ case 270000:
	2037	+ case 540000:
	2038	+ break;
	2039	+ default:
	2040	+ dev_err(dp->dev, "invalid link frequency value: %lld\n", frequency);
	2041	+ return 0;
	2042	+ }
	2043	+
	2044	+ return frequency;
1505	2045	}
1506	2046
1507	2047	static int analogix_dp_dt_parse_pdata(struct analogix_dp_device *dp)
1508	2048	{
1509	2049	struct device_node *dp_node = dp->dev->of_node;
1510	2050	struct video_info *video_info = &dp->video_info;
	2051	+ struct property *prop;
	2052	+ int ret, len, num_lanes;
	2053	+ u32 max_link_rate;
1511	2054
1512	2055	switch (dp->plat_data->dev_type) {
1513	2056	case RK3288_DP:
1514		- case RK3368_EDP:
1515	2057	case RK3568_EDP:
	2058	+ /*
	2059	+ * Like Rk3288 DisplayPort TRM indicate that "Main link
	2060	+ * containing 4 physical lanes of 2.7/1.62 Gbps/lane".
	2061	+ */
1516	2062	video_info->max_link_rate = 0x0A;
1517	2063	video_info->max_lane_count = 0x04;
1518	2064	break;
1519	2065	case RK3399_EDP:
	2066	+ case RK3588_EDP:
1520	2067	video_info->max_link_rate = 0x14;
1521	2068	video_info->max_lane_count = 0x04;
1522	2069	break;
..	..	@@ -1532,8 +2079,43 @@
1532	2079	break;
1533	2080	}
1534	2081
	2082	+ max_link_rate = analogix_dp_parse_link_frequencies(dp);
	2083	+ if (max_link_rate && max_link_rate < drm_dp_bw_code_to_link_rate(video_info->max_link_rate))
	2084	+ video_info->max_link_rate = drm_dp_link_rate_to_bw_code(max_link_rate);
	2085	+
1535	2086	video_info->video_bist_enable =
1536	2087	of_property_read_bool(dp_node, "analogix,video-bist-enable");
	2088	+ video_info->force_stream_valid =
	2089	+ of_property_read_bool(dp_node, "analogix,force-stream-valid");
	2090	+
	2091	+ prop = of_find_property(dp_node, "data-lanes", &len);
	2092	+ if (!prop) {
	2093	+ video_info->lane_map[0] = 0;
	2094	+ video_info->lane_map[1] = 1;
	2095	+ video_info->lane_map[2] = 2;
	2096	+ video_info->lane_map[3] = 3;
	2097	+ DRM_DEV_DEBUG(dp->dev, "failed to find data lane mapping, using default\n");
	2098	+ return 0;
	2099	+ }
	2100	+
	2101	+ num_lanes = len / sizeof(u32);
	2102	+
	2103	+ if (num_lanes < 1 \|\| num_lanes > 4 \|\| num_lanes == 3) {
	2104	+ DRM_DEV_ERROR(dp->dev, "bad number of data lanes\n");
	2105	+ return -EINVAL;
	2106	+ }
	2107	+
	2108	+ video_info->max_lane_count = num_lanes;
	2109	+
	2110	+ ret = of_property_read_u32_array(dp_node, "data-lanes",
	2111	+ video_info->lane_map, num_lanes);
	2112	+ if (ret) {
	2113	+ DRM_DEV_ERROR(dp->dev, "failed to read lane data\n");
	2114	+ return ret;
	2115	+ }
	2116	+
	2117	+ if (device_property_read_u32(dp->dev, "split-area", &dp->split_area))
	2118	+ dp->split_area = 0;
1537	2119
1538	2120	return 0;
1539	2121	}
..	..	@@ -1542,8 +2124,19 @@
1542	2124	struct drm_dp_aux_msg *msg)
1543	2125	{
1544	2126	struct analogix_dp_device *dp = to_dp(aux);
	2127	+ int ret;
1545	2128
1546		- return analogix_dp_transfer(dp, msg);
	2129	+ pm_runtime_get_sync(dp->dev);
	2130	+
	2131	+ ret = analogix_dp_detect_hpd(dp);
	2132	+ if (ret)
	2133	+ goto out;
	2134	+
	2135	+ ret = analogix_dp_transfer(dp, msg);
	2136	+out:
	2137	+ pm_runtime_put(dp->dev);
	2138	+
	2139	+ return ret;
1547	2140	}
1548	2141
1549	2142	int analogix_dp_audio_hw_params(struct analogix_dp_device *dp,
..	..	@@ -1588,9 +2181,70 @@
1588	2181	}
1589	2182	EXPORT_SYMBOL_GPL(analogix_dp_audio_get_eld);
1590	2183
	2184	+static void analogix_dp_link_train_restore(struct analogix_dp_device *dp)
	2185	+{
	2186	+ u32 link_rate, lane_count;
	2187	+ u8 lane, spread;
	2188	+
	2189	+ analogix_dp_get_link_bandwidth(dp, &link_rate);
	2190	+ analogix_dp_get_lane_count(dp, &lane_count);
	2191	+ drm_dp_dpcd_readb(&dp->aux, DP_MAX_DOWNSPREAD, &spread);
	2192	+
	2193	+ dp->link_train.link_rate = link_rate;
	2194	+ dp->link_train.lane_count = lane_count;
	2195	+ dp->link_train.enhanced_framing = analogix_dp_get_enhanced_mode(dp);
	2196	+ dp->link_train.ssc = !!(spread & DP_MAX_DOWNSPREAD_0_5);
	2197	+
	2198	+ for (lane = 0; lane < 4; lane++)
	2199	+ dp->link_train.training_lane[lane] =
	2200	+ analogix_dp_get_lane_link_training(dp, lane);
	2201	+}
	2202	+
	2203	+int analogix_dp_loader_protect(struct analogix_dp_device *dp)
	2204	+{
	2205	+ u8 link_status[DP_LINK_STATUS_SIZE];
	2206	+ int ret;
	2207	+
	2208	+ ret = analogix_dp_phy_power_on(dp);
	2209	+ if (ret)
	2210	+ return ret;
	2211	+
	2212	+ dp->dpms_mode = DRM_MODE_DPMS_ON;
	2213	+
	2214	+ analogix_dp_link_train_restore(dp);
	2215	+
	2216	+ ret = analogix_dp_fast_link_train_detection(dp);
	2217	+ if (ret)
	2218	+ goto err_disable;
	2219	+
	2220	+ if (analogix_dp_detect_sink_psr(dp)) {
	2221	+ ret = analogix_dp_enable_sink_psr(dp);
	2222	+ if (ret)
	2223	+ goto err_disable;
	2224	+ }
	2225	+
	2226	+ ret = drm_dp_dpcd_read_link_status(&dp->aux, link_status);
	2227	+ if (ret < 0) {
	2228	+ dev_err(dp->dev, "Failed to read link status\n");
	2229	+ goto err_disable;
	2230	+ }
	2231	+
	2232	+ if (!drm_dp_channel_eq_ok(link_status, dp->link_train.lane_count)) {
	2233	+ dev_err(dp->dev, "Channel EQ or CR not ok\n");
	2234	+ ret = -EINVAL;
	2235	+ goto err_disable;
	2236	+ }
	2237	+
	2238	+ return 0;
	2239	+
	2240	+err_disable:
	2241	+ analogix_dp_disable(dp);
	2242	+ return ret;
	2243	+}
	2244	+EXPORT_SYMBOL_GPL(analogix_dp_loader_protect);
	2245	+
1591	2246	struct analogix_dp_device *
1592		-analogix_dp_bind(struct device dev, struct drm_device drm_dev,
1593		- struct analogix_dp_plat_data *plat_data)
	2247	+analogix_dp_probe(struct device dev, struct analogix_dp_plat_data plat_data)
1594	2248	{
1595	2249	struct platform_device *pdev = to_platform_device(dev);
1596	2250	struct analogix_dp_device *dp;
..	..	@@ -1608,6 +2262,7 @@
1608	2262
1609	2263	dp->dev = &pdev->dev;
1610	2264	dp->dpms_mode = DRM_MODE_DPMS_OFF;
	2265	+ INIT_WORK(&dp->modeset_retry_work, analogix_dp_modeset_retry_work_fn);
1611	2266
1612	2267	mutex_init(&dp->panel_lock);
1613	2268	dp->panel_is_prepared = false;
..	..	@@ -1639,6 +2294,14 @@
1639	2294	}
1640	2295	}
1641	2296
	2297	+ ret = devm_clk_bulk_get_all(dev, &dp->clks);
	2298	+ if (ret < 0) {
	2299	+ dev_err(dev, "failed to get clocks %d\n", ret);
	2300	+ return ERR_PTR(ret);
	2301	+ }
	2302	+
	2303	+ dp->nr_clks = ret;
	2304	+
1642	2305	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1643	2306
1644	2307	dp->reg_base = devm_ioremap_resource(&pdev->dev, res);
..	..	@@ -1659,11 +2322,9 @@
1659	2322	}
1660	2323
1661	2324	if (dp->hpd_gpiod) {
1662		- dp->hpd_irq = gpiod_to_irq(dp->hpd_gpiod);
1663		- if (dp->hpd_irq < 0)
1664		- return ERR_PTR(-EINVAL);
1665		-
1666		- ret = devm_request_threaded_irq(dev, dp->hpd_irq, NULL,
	2325	+ ret = devm_request_threaded_irq(dev,
	2326	+ gpiod_to_irq(dp->hpd_gpiod),
	2327	+ NULL,
1667	2328	analogix_dp_hpd_irq_handler,
1668	2329	IRQF_TRIGGER_RISING \|
1669	2330	IRQF_TRIGGER_FALLING \|
..	..	@@ -1682,71 +2343,91 @@
1682	2343	}
1683	2344
1684	2345	irq_set_status_flags(dp->irq, IRQ_NOAUTOEN);
1685		- ret = devm_request_threaded_irq(&pdev->dev, dp->irq,
1686		- analogix_dp_hardirq,
	2346	+ ret = devm_request_threaded_irq(dev, dp->irq, NULL,
1687	2347	analogix_dp_irq_thread,
1688		- 0, "analogix-dp", dp);
	2348	+ IRQF_ONESHOT, dev_name(dev), dp);
1689	2349	if (ret) {
1690	2350	dev_err(&pdev->dev, "failed to request irq\n");
1691		- goto err_disable_pm_runtime;
	2351	+ return ERR_PTR(ret);
1692	2352	}
	2353	+
	2354	+ dp->extcon = devm_extcon_dev_allocate(dev, analogix_dp_cable);
	2355	+ if (IS_ERR(dp->extcon)) {
	2356	+ dev_err(dev, "failed to allocate extcon device\n");
	2357	+ return ERR_CAST(dp->extcon);
	2358	+ }
	2359	+
	2360	+ ret = devm_extcon_dev_register(dev, dp->extcon);
	2361	+ if (ret) {
	2362	+ dev_err(dev, "failed to register extcon device\n");
	2363	+ return ERR_PTR(ret);
	2364	+ }
	2365	+
	2366	+ dp->bridge.driver_private = dp;
	2367	+ dp->bridge.funcs = &analogix_dp_bridge_funcs;
	2368	+
	2369	+ return dp;
	2370	+}
	2371	+EXPORT_SYMBOL_GPL(analogix_dp_probe);
	2372	+
	2373	+int analogix_dp_bind(struct analogix_dp_device dp, struct drm_device drm_dev)
	2374	+{
	2375	+ int ret;
1693	2376
1694	2377	dp->drm_dev = drm_dev;
1695	2378	dp->encoder = dp->plat_data->encoder;
1696	2379
1697	2380	dp->aux.name = "DP-AUX";
1698	2381	dp->aux.transfer = analogix_dpaux_transfer;
1699		- dp->aux.dev = &pdev->dev;
	2382	+ dp->aux.dev = dp->dev;
1700	2383
1701	2384	ret = drm_dp_aux_register(&dp->aux);
1702	2385	if (ret)
1703		- return ERR_PTR(ret);
	2386	+ return ret;
1704	2387
1705		- pm_runtime_enable(dev);
	2388	+ pm_runtime_enable(dp->dev);
	2389	+ pm_runtime_get_sync(dp->dev);
	2390	+ analogix_dp_init(dp);
1706	2391
1707		- ret = analogix_dp_create_bridge(drm_dev, dp);
	2392	+ ret = analogix_dp_bridge_init(dp);
1708	2393	if (ret) {
1709		- DRM_ERROR("failed to create bridge (%d)\n", ret);
	2394	+ DRM_ERROR("failed to init bridge (%d)\n", ret);
1710	2395	goto err_disable_pm_runtime;
1711	2396	}
1712	2397
1713		- return dp;
	2398	+ enable_irq(dp->irq);
	2399	+
	2400	+ return 0;
1714	2401
1715	2402	err_disable_pm_runtime:
	2403	+ pm_runtime_put(dp->dev);
	2404	+ pm_runtime_disable(dp->dev);
	2405	+ drm_dp_aux_unregister(&dp->aux);
1716	2406
1717		- pm_runtime_disable(dev);
1718		-
1719		- return ERR_PTR(ret);
	2407	+ return ret;
1720	2408	}
1721	2409	EXPORT_SYMBOL_GPL(analogix_dp_bind);
1722	2410
1723	2411	void analogix_dp_unbind(struct analogix_dp_device *dp)
1724	2412	{
1725		- analogix_dp_bridge_disable(dp->bridge);
1726		- dp->connector.funcs->destroy(&dp->connector);
1727		-
1728		- if (dp->plat_data->panel) {
1729		- if (drm_panel_unprepare(dp->plat_data->panel))
1730		- DRM_ERROR("failed to turnoff the panel\n");
1731		- if (drm_panel_detach(dp->plat_data->panel))
1732		- DRM_ERROR("failed to detach the panel\n");
1733		- }
1734		-
	2413	+ disable_irq(dp->irq);
	2414	+ if (dp->connector.funcs->destroy)
	2415	+ dp->connector.funcs->destroy(&dp->connector);
1735	2416	drm_dp_aux_unregister(&dp->aux);
	2417	+ pm_runtime_put(dp->dev);
1736	2418	pm_runtime_disable(dp->dev);
1737	2419	}
1738	2420	EXPORT_SYMBOL_GPL(analogix_dp_unbind);
1739	2421
1740		-#ifdef CONFIG_PM
	2422	+void analogix_dp_remove(struct analogix_dp_device *dp)
	2423	+{
	2424	+ cancel_work_sync(&dp->modeset_retry_work);
	2425	+}
	2426	+EXPORT_SYMBOL_GPL(analogix_dp_remove);
	2427	+
1741	2428	int analogix_dp_suspend(struct analogix_dp_device *dp)
1742	2429	{
1743		- if (dp->hpd_gpiod)
1744		- disable_irq(dp->hpd_irq);
1745		-
1746		- if (dp->plat_data->panel) {
1747		- if (drm_panel_unprepare(dp->plat_data->panel))
1748		- DRM_ERROR("failed to turnoff the panel\n");
1749		- }
	2430	+ pm_runtime_force_suspend(dp->dev);
1750	2431
1751	2432	return 0;
1752	2433	}
..	..	@@ -1754,20 +2435,26 @@
1754	2435
1755	2436	int analogix_dp_resume(struct analogix_dp_device *dp)
1756	2437	{
1757		- if (dp->plat_data->panel) {
1758		- if (drm_panel_prepare(dp->plat_data->panel)) {
1759		- DRM_ERROR("failed to setup the panel\n");
1760		- return -EBUSY;
1761		- }
1762		- }
1763		-
1764		- if (dp->hpd_gpiod)
1765		- enable_irq(dp->hpd_irq);
	2438	+ pm_runtime_force_resume(dp->dev);
	2439	+ analogix_dp_init(dp);
1766	2440
1767	2441	return 0;
1768	2442	}
1769	2443	EXPORT_SYMBOL_GPL(analogix_dp_resume);
1770		-#endif
	2444	+
	2445	+int analogix_dp_runtime_suspend(struct analogix_dp_device *dp)
	2446	+{
	2447	+ clk_bulk_disable_unprepare(dp->nr_clks, dp->clks);
	2448	+
	2449	+ return 0;
	2450	+}
	2451	+EXPORT_SYMBOL_GPL(analogix_dp_runtime_suspend);
	2452	+
	2453	+int analogix_dp_runtime_resume(struct analogix_dp_device *dp)
	2454	+{
	2455	+ return clk_bulk_prepare_enable(dp->nr_clks, dp->clks);
	2456	+}
	2457	+EXPORT_SYMBOL_GPL(analogix_dp_runtime_resume);
1771	2458
1772	2459	int analogix_dp_start_crc(struct drm_connector *connector)
1773	2460	{