~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,53 +1,74 @@
	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	+
	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	+};
40	50
41	51	struct bridge_init {
42	52	struct i2c_client *client;
43	53	struct device_node *node;
44	54	};
45	55
	56	+static void analogix_dp_bridge_mode_set(struct drm_bridge *bridge,
	57	+ const struct drm_display_mode *adj_mode);
	58	+
46	59	static bool analogix_dp_bandwidth_ok(struct analogix_dp_device *dp,
47	60	const struct drm_display_mode *mode,
48	61	unsigned int rate, unsigned int lanes)
49	62	{
	63	+ const struct drm_display_info *info;
50	64	u32 max_bw, req_bw, bpp = 24;
	65	+
	66	+ if (dp->plat_data->skip_connector)
	67	+ return true;
	68	+
	69	+ info = &dp->connector.display_info;
	70	+ if (info->bpc)
	71	+ bpp = 3 * info->bpc;
51	72
52	73	req_bw = mode->clock * bpp / 8;
53	74	max_bw = lanes * rate;
..	..	@@ -81,143 +102,75 @@
81	102	return 0;
82	103	}
83	104
84		-static int analogix_dp_prepare_panel(struct analogix_dp_device *dp,
85		- bool prepare)
	105	+static int analogix_dp_panel_prepare(struct analogix_dp_device *dp)
86	106	{
87		- int ret = 0;
	107	+ int ret;
88	108
89	109	mutex_lock(&dp->panel_lock);
90	110
91		- if (prepare == dp->panel_is_prepared)
	111	+ if (dp->panel_is_prepared)
92	112	goto out;
93	113
94		- if (prepare)
95		- ret = drm_panel_prepare(dp->plat_data->panel);
96		- else
97		- ret = drm_panel_unprepare(dp->plat_data->panel);
	114	+ ret = drm_panel_prepare(dp->plat_data->panel);
98	115	if (ret)
99	116	goto out;
100	117
101		- dp->panel_is_prepared = prepare;
	118	+ dp->panel_is_prepared = true;
	119	+
102	120	out:
103	121	mutex_unlock(&dp->panel_lock);
104		- 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;
105	143	}
106	144
107	145	static int analogix_dp_detect_hpd(struct analogix_dp_device *dp)
108	146	{
109		- int timeout_loop = 0;
110		-
111		- while (timeout_loop < DP_TIMEOUT_LOOP_COUNT) {
112		- if (analogix_dp_get_plug_in_status(dp) == 0)
113		- return 0;
114		-
115		- timeout_loop++;
116		- usleep_range(1000, 1100);
117		- }
118		-
119		- /*
120		- * Some edp screen do not have hpd signal, so we can't just
121		- * return failed when hpd plug in detect failed, DT property
122		- * "force-hpd" would indicate whether driver need this.
123		- */
124		- if (!dp->force_hpd)
125		- return -ETIMEDOUT;
126		-
127		- /*
128		- * The eDP TRM indicate that if HPD_STATUS(RO) is 0, AUX CH
129		- * will not work, so we need to give a force hpd action to
130		- * set HPD_STATUS manually.
131		- */
132		- dev_dbg(dp->dev, "failed to get hpd plug status, try to force hpd\n");
133		-
134		- analogix_dp_force_hpd(dp);
	147	+ if (dp->force_hpd)
	148	+ analogix_dp_force_hpd(dp);
135	149
136	150	if (analogix_dp_get_plug_in_status(dp) != 0) {
137	151	dev_err(dp->dev, "failed to get hpd plug in status\n");
138	152	return -EINVAL;
139	153	}
140	154
141		- dev_dbg(dp->dev, "success to get plug in status after force hpd\n");
142		-
143	155	return 0;
144	156	}
145	157
146		-int analogix_dp_psr_enabled(struct analogix_dp_device *dp)
147		-{
148		-
149		- return dp->psr_enable;
150		-}
151		-EXPORT_SYMBOL_GPL(analogix_dp_psr_enabled);
152		-
153		-int analogix_dp_enable_psr(struct analogix_dp_device *dp)
154		-{
155		- struct edp_vsc_psr psr_vsc;
156		-
157		- if (!dp->psr_enable)
158		- return 0;
159		-
160		- /* Prepare VSC packet as per EDP 1.4 spec, Table 6.9 */
161		- memset(&psr_vsc, 0, sizeof(psr_vsc));
162		- psr_vsc.sdp_header.HB0 = 0;
163		- psr_vsc.sdp_header.HB1 = 0x7;
164		- psr_vsc.sdp_header.HB2 = 0x2;
165		- psr_vsc.sdp_header.HB3 = 0x8;
166		-
167		- psr_vsc.DB0 = 0;
168		- psr_vsc.DB1 = EDP_VSC_PSR_STATE_ACTIVE \| EDP_VSC_PSR_CRC_VALUES_VALID;
169		-
170		- return analogix_dp_send_psr_spd(dp, &psr_vsc, true);
171		-}
172		-EXPORT_SYMBOL_GPL(analogix_dp_enable_psr);
173		-
174		-int analogix_dp_disable_psr(struct analogix_dp_device *dp)
175		-{
176		- struct edp_vsc_psr psr_vsc;
177		- int ret;
178		-
179		- if (!dp->psr_enable)
180		- return 0;
181		-
182		- /* Prepare VSC packet as per EDP 1.4 spec, Table 6.9 */
183		- memset(&psr_vsc, 0, sizeof(psr_vsc));
184		- psr_vsc.sdp_header.HB0 = 0;
185		- psr_vsc.sdp_header.HB1 = 0x7;
186		- psr_vsc.sdp_header.HB2 = 0x2;
187		- psr_vsc.sdp_header.HB3 = 0x8;
188		-
189		- psr_vsc.DB0 = 0;
190		- psr_vsc.DB1 = 0;
191		-
192		- ret = drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER, DP_SET_POWER_D0);
193		- if (ret != 1) {
194		- dev_err(dp->dev, "Failed to set DP Power0 %d\n", ret);
195		- return ret;
196		- }
197		-
198		- return analogix_dp_send_psr_spd(dp, &psr_vsc, false);
199		-}
200		-EXPORT_SYMBOL_GPL(analogix_dp_disable_psr);
201		-
202		-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)
203	159	{
204	160	unsigned char psr_version;
205	161	int ret;
206	162
207		- if (!of_property_read_bool(dp->dev->of_node, "support-psr"))
	163	+ if (!device_property_read_bool(dp->dev, "support-psr"))
208	164	return 0;
209	165
210	166	ret = drm_dp_dpcd_readb(&dp->aux, DP_PSR_SUPPORT, &psr_version);
211	167	if (ret != 1) {
212	168	dev_err(dp->dev, "failed to get PSR version, disable it\n");
213		- return ret;
	169	+ return false;
214	170	}
215	171
216	172	dev_dbg(dp->dev, "Panel PSR version : %x\n", psr_version);
217		-
218		- dp->psr_enable = (psr_version & DP_PSR_IS_SUPPORTED) ? true : false;
219		-
220		- return 0;
	173	+ return psr_version & DP_PSR_IS_SUPPORTED;
221	174	}
222	175
223	176	static int analogix_dp_enable_sink_psr(struct analogix_dp_device *dp)
..	..	@@ -240,7 +193,7 @@
240	193	}
241	194
242	195	/* Main-Link transmitter remains active during PSR active states */
243		- psr_en = DP_PSR_MAIN_LINK_ACTIVE \| DP_PSR_CRC_VERIFICATION;
	196	+ psr_en = DP_PSR_CRC_VERIFICATION;
244	197	ret = drm_dp_dpcd_writeb(&dp->aux, DP_PSR_EN_CFG, psr_en);
245	198	if (ret != 1) {
246	199	dev_err(dp->dev, "failed to set panel psr\n");
..	..	@@ -248,8 +201,7 @@
248	201	}
249	202
250	203	/* Enable psr function */
251		- psr_en = DP_PSR_ENABLE \| DP_PSR_MAIN_LINK_ACTIVE \|
252		- DP_PSR_CRC_VERIFICATION;
	204	+ psr_en = DP_PSR_ENABLE \| DP_PSR_CRC_VERIFICATION;
253	205	ret = drm_dp_dpcd_writeb(&dp->aux, DP_PSR_EN_CFG, psr_en);
254	206	if (ret != 1) {
255	207	dev_err(dp->dev, "failed to set panel psr\n");
..	..	@@ -258,10 +210,11 @@
258	210
259	211	analogix_dp_enable_psr_crc(dp);
260	212
	213	+ dp->psr_supported = true;
	214	+
261	215	return 0;
262	216	end:
263	217	dev_err(dp->dev, "enable psr fail, force to disable psr\n");
264		- dp->psr_enable = false;
265	218
266	219	return ret;
267	220	}
..	..	@@ -351,6 +304,23 @@
351	304	return ret < 0 ? ret : 0;
352	305	}
353	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	+
354	324	static int analogix_dp_link_start(struct analogix_dp_device *dp)
355	325	{
356	326	u8 buf[4];
..	..	@@ -377,6 +347,8 @@
377	347
378	348	/* Spread AMP if required, enable 8b/10b coding */
379	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;
380	352	buf[1] = DP_SET_ANSI_8B10B;
381	353	retval = drm_dp_dpcd_write(&dp->aux, DP_DOWNSPREAD_CTRL, buf, 2);
382	354	if (retval < 0)
..	..	@@ -529,16 +501,11 @@
529	501	u8 link_status[2], adjust_request[2];
530	502	u8 training_pattern = TRAINING_PTN2;
531	503
532		- usleep_range(100, 101);
	504	+ drm_dp_link_train_clock_recovery_delay(dp->dpcd);
533	505
534	506	lane_count = dp->link_train.lane_count;
535	507
536	508	retval = drm_dp_dpcd_read(&dp->aux, DP_LANE0_1_STATUS, link_status, 2);
537		- if (retval < 0)
538		- return retval;
539		-
540		- retval = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1,
541		- adjust_request, 2);
542	509	if (retval < 0)
543	510	return retval;
544	511
..	..	@@ -556,9 +523,16 @@
556	523	if (retval < 0)
557	524	return retval;
558	525
559		- dev_info(dp->dev, "Link Training Clock Recovery success\n");
	526	+ dev_dbg(dp->dev, "Link Training Clock Recovery success\n");
560	527	dp->link_train.lt_state = EQUALIZER_TRAINING;
	528	+
	529	+ return 0;
561	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	+
562	536	for (lane = 0; lane < lane_count; lane++) {
563	537	training_lane = analogix_dp_get_lane_link_training(
564	538	dp, lane);
..	..	@@ -583,16 +557,15 @@
583	557	return -EIO;
584	558	}
585	559	}
586		-
587		- analogix_dp_get_adjust_training_lane(dp, adjust_request);
588		- analogix_dp_set_lane_link_training(dp);
589		-
590		- retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET,
591		- dp->link_train.training_lane,
592		- lane_count);
593		- if (retval < 0)
594		- return retval;
595	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;
596	569
597	570	return 0;
598	571	}
..	..	@@ -603,7 +576,7 @@
603	576	u32 reg;
604	577	u8 link_align, link_status[2], adjust_request[2];
605	578
606		- usleep_range(400, 401);
	579	+ drm_dp_link_train_channel_eq_delay(dp->dpcd);
607	580
608	581	lane_count = dp->link_train.lane_count;
609	582
..	..	@@ -616,17 +589,10 @@
616	589	return -EIO;
617	590	}
618	591
619		- retval = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1,
620		- adjust_request, 2);
621		- if (retval < 0)
622		- return retval;
623		-
624	592	retval = drm_dp_dpcd_readb(&dp->aux, DP_LANE_ALIGN_STATUS_UPDATED,
625	593	&link_align);
626	594	if (retval < 0)
627	595	return retval;
628		-
629		- analogix_dp_get_adjust_training_lane(dp, adjust_request);
630	596
631	597	if (!analogix_dp_channel_eq_ok(link_status, link_align, lane_count)) {
632	598	/* traing pattern Set to Normal */
..	..	@@ -634,7 +600,7 @@
634	600	if (retval < 0)
635	601	return retval;
636	602
637		- dev_info(dp->dev, "Link Training success!\n");
	603	+ dev_dbg(dp->dev, "Link Training success!\n");
638	604	analogix_dp_get_link_bandwidth(dp, &reg);
639	605	dp->link_train.link_rate = reg;
640	606	dev_dbg(dp->dev, "final bandwidth = %.2x\n",
..	..	@@ -659,6 +625,12 @@
659	625	return -EIO;
660	626	}
661	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);
662	634	analogix_dp_set_lane_link_training(dp);
663	635
664	636	retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET,
..	..	@@ -669,10 +641,11 @@
669	641	return 0;
670	642	}
671	643
672		-static void analogix_dp_get_max_rx_bandwidth(struct analogix_dp_device *dp,
673		- u8 *bandwidth)
	644	+static int analogix_dp_get_max_rx_bandwidth(struct analogix_dp_device *dp,
	645	+ u8 *bandwidth)
674	646	{
675	647	u8 data;
	648	+ int ret;
676	649
677	650	/*
678	651	* For DP rev.1.1, Maximum link rate of Main Link lanes
..	..	@@ -680,26 +653,38 @@
680	653	* For DP rev.1.2, Maximum link rate of Main Link lanes
681	654	* 0x06 = 1.62 Gbps, 0x0a = 2.7 Gbps, 0x14 = 5.4Gbps
682	655	*/
683		- 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	+
684	660	*bandwidth = data;
	661	+
	662	+ return 0;
685	663	}
686	664
687		-static void analogix_dp_get_max_rx_lane_count(struct analogix_dp_device *dp,
688		- u8 *lane_count)
	665	+static int analogix_dp_get_max_rx_lane_count(struct analogix_dp_device *dp,
	666	+ u8 *lane_count)
689	667	{
690	668	u8 data;
	669	+ int ret;
691	670
692	671	/*
693	672	* For DP rev.1.1, Maximum number of Main Link lanes
694	673	* 0x01 = 1 lane, 0x02 = 2 lanes, 0x04 = 4 lanes
695	674	*/
696		- 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	+
697	679	*lane_count = DPCD_MAX_LANE_COUNT(data);
	680	+
	681	+ return 0;
698	682	}
699	683
700	684	static int analogix_dp_full_link_train(struct analogix_dp_device *dp,
701	685	u32 max_lanes, u32 max_rate)
702	686	{
	687	+ struct video_info *video = &dp->video_info;
703	688	int retval = 0;
704	689	bool training_finished = false;
705	690	u8 dpcd;
..	..	@@ -714,28 +699,19 @@
714	699	analogix_dp_get_max_rx_bandwidth(dp, &dp->link_train.link_rate);
715	700	analogix_dp_get_max_rx_lane_count(dp, &dp->link_train.lane_count);
716	701
717		- if ((dp->link_train.link_rate != DP_LINK_BW_1_62) &&
718		- (dp->link_train.link_rate != DP_LINK_BW_2_7) &&
719		- (dp->link_train.link_rate != DP_LINK_BW_5_4)) {
720		- dev_err(dp->dev, "Rx Max Link Rate is abnormal :%x !\n",
721		- dp->link_train.link_rate);
722		- dp->link_train.link_rate = DP_LINK_BW_1_62;
723		- }
	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);
724	705
725		- if (dp->link_train.lane_count == 0) {
726		- dev_err(dp->dev, "Rx Max Lane count is abnormal :%x !\n",
727		- dp->link_train.lane_count);
728		- 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;
729	711	}
730	712
731	713	drm_dp_dpcd_readb(&dp->aux, DP_MAX_DOWNSPREAD, &dpcd);
732	714	dp->link_train.ssc = !!(dpcd & DP_MAX_DOWNSPREAD_0_5);
733		-
734		- /* Setup TX lane count & rate */
735		- if (dp->link_train.lane_count > max_lanes)
736		- dp->link_train.lane_count = max_lanes;
737		- if (dp->link_train.link_rate > max_rate)
738		- dp->link_train.link_rate = max_rate;
739	715
740	716	/* All DP analog module power up */
741	717	analogix_dp_set_analog_power_down(dp, POWER_ALL, 0);
..	..	@@ -873,7 +849,7 @@
873	849	analogix_dp_set_video_cr_mn(dp, CALCULATED_M, 0, 0);
874	850
875	851	/* For video bist, Video timing must be generated by register */
876		- analogix_dp_set_video_timing_mode(dp, VIDEO_TIMING_FROM_CAPTURE);
	852	+ analogix_dp_set_video_timing_mode(dp, VIDEO_TIMING_FROM_REGISTER);
877	853
878	854	/* Disable video mute */
879	855	analogix_dp_enable_video_mute(dp, 0);
..	..	@@ -935,6 +911,156 @@
935	911	return ret < 0 ? ret : 0;
936	912	}
937	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	+
938	1064	static irqreturn_t analogix_dp_hpd_irq_handler(int irq, void *arg)
939	1065	{
940	1066	struct analogix_dp_device *dp = arg;
..	..	@@ -945,38 +1071,11 @@
945	1071	return IRQ_HANDLED;
946	1072	}
947	1073
948		-static irqreturn_t analogix_dp_hardirq(int irq, void *arg)
949		-{
950		- struct analogix_dp_device *dp = arg;
951		- irqreturn_t ret = IRQ_NONE;
952		- enum dp_irq_type irq_type;
953		-
954		- irq_type = analogix_dp_get_irq_type(dp);
955		- if (irq_type != DP_IRQ_TYPE_UNKNOWN) {
956		- analogix_dp_mute_hpd_interrupt(dp);
957		- ret = IRQ_WAKE_THREAD;
958		- }
959		-
960		- return ret;
961		-}
962		-
963	1074	static irqreturn_t analogix_dp_irq_thread(int irq, void *arg)
964	1075	{
965	1076	struct analogix_dp_device *dp = arg;
966		- enum dp_irq_type irq_type;
967	1077
968		- irq_type = analogix_dp_get_irq_type(dp);
969		- if (irq_type & DP_IRQ_TYPE_HP_CABLE_IN \|\|
970		- irq_type & DP_IRQ_TYPE_HP_CABLE_OUT) {
971		- dev_dbg(dp->dev, "Detected cable status changed!\n");
972		- if (dp->drm_dev)
973		- drm_helper_hpd_irq_event(dp->drm_dev);
974		- }
975		-
976		- if (irq_type != DP_IRQ_TYPE_UNKNOWN) {
977		- analogix_dp_clear_hotplug_interrupts(dp);
978		- analogix_dp_unmute_hpd_interrupt(dp);
979		- }
	1078	+ analogix_dp_irq_handler(dp);
980	1079
981	1080	return IRQ_HANDLED;
982	1081	}
..	..	@@ -997,10 +1096,68 @@
997	1096	return 0;
998	1097	}
999	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	+
1000	1145	static int analogix_dp_commit(struct analogix_dp_device *dp)
1001	1146	{
1002	1147	struct video_info *video = &dp->video_info;
1003	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	+ }
1004	1161
1005	1162	if (device_property_read_bool(dp->dev, "panel-self-test"))
1006	1163	return drm_dp_dpcd_writeb(&dp->aux, DP_EDP_CONFIGURATION_SET,
..	..	@@ -1010,13 +1167,6 @@
1010	1167	if (ret) {
1011	1168	dev_err(dp->dev, "unable to do link train, ret=%d\n", ret);
1012	1169	return ret;
1013		- }
1014		-
1015		- if (!analogix_dp_bandwidth_ok(dp, &video->mode,
1016		- drm_dp_bw_code_to_link_rate(dp->link_train.link_rate),
1017		- dp->link_train.lane_count)) {
1018		- dev_err(dp->dev, "bandwidth overflow\n");
1019		- return -EINVAL;
1020	1170	}
1021	1171
1022	1172	ret = analogix_dp_enable_scramble(dp, 1);
..	..	@@ -1037,23 +1187,99 @@
1037	1187	return ret;
1038	1188	}
1039	1189
1040		- ret = analogix_dp_detect_sink_psr(dp);
1041		- if (ret)
1042		- return ret;
1043		-
1044	1190	/* Check whether panel supports fast training */
1045	1191	ret = analogix_dp_fast_link_train_detection(dp);
1046	1192	if (ret)
1047		- dp->psr_enable = false;
	1193	+ return ret;
1048	1194
1049		- if (dp->psr_enable) {
	1195	+ if (analogix_dp_detect_sink_psr(dp)) {
1050	1196	ret = analogix_dp_enable_sink_psr(dp);
1051	1197	if (ret)
1052	1198	return ret;
1053	1199	}
1054	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	+ }
1055	1239
1056	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);
1057	1283	}
1058	1284
1059	1285	static int analogix_dp_get_modes(struct drm_connector *connector)
..	..	@@ -1062,31 +1288,49 @@
1062	1288	struct edid *edid;
1063	1289	int ret, num_modes = 0;
1064	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	+
1065	1300	if (dp->plat_data->panel)
1066		- 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);
1067	1305
1068	1306	if (!num_modes) {
1069		- if (dp->plat_data->panel) {
1070		- ret = analogix_dp_prepare_panel(dp, true);
1071		- if (ret) {
1072		- DRM_ERROR("Failed to prepare panel (%d)\n", ret);
1073		- return 0;
1074		- }
1075		- }
	1307	+ ret = analogix_dp_phy_power_on(dp);
	1308	+ if (ret)
	1309	+ return 0;
1076	1310
1077		- pm_runtime_get_sync(dp->dev);
	1311	+ if (dp->plat_data->panel)
	1312	+ analogix_dp_panel_prepare(dp);
	1313	+
1078	1314	edid = drm_get_edid(connector, &dp->aux.ddc);
1079		- pm_runtime_put(dp->dev);
1080	1315	if (edid) {
1081	1316	drm_connector_update_edid_property(&dp->connector,
1082	1317	edid);
1083	1318	num_modes += drm_add_edid_modes(&dp->connector, edid);
1084	1319	kfree(edid);
1085	1320	}
	1321	+
	1322	+ analogix_dp_phy_power_off(dp);
1086	1323	}
1087	1324
1088	1325	if (dp->plat_data->get_modes)
1089	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	+ }
1090	1334
1091	1335	return num_modes;
1092	1336	}
..	..	@@ -1099,91 +1343,148 @@
1099	1343	return dp->encoder;
1100	1344	}
1101	1345
1102		-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)
1103	1349	{
1104	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;
1105	1383	int ret;
1106	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	+
1107	1391	if (dp->plat_data->panel)
1108		- drm_panel_loader_protect(dp->plat_data->panel, on);
	1392	+ analogix_dp_panel_prepare(dp);
1109	1393
1110		- if (on) {
1111		- 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	+ }
1112	1400
1113		- 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	+ }
1114	1406
1115		- analogix_dp_phy_power_on(dp);
	1407	+ status = connector_status_connected;
	1408	+ }
1116	1409
1117		- ret = analogix_dp_detect_sink_psr(dp);
1118		- if (ret)
1119		- return ret;
	1410	+ if (dp->plat_data->bridge) {
	1411	+ struct drm_bridge *next_bridge = dp->plat_data->bridge;
1120	1412
1121		- if (dp->psr_enable) {
1122		- ret = analogix_dp_enable_sink_psr(dp);
1123		- if (ret)
1124		- 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;
1125	1469	}
1126	1470	}
1127	1471
1128	1472	return 0;
1129	1473	}
1130	1474
1131		-static const struct drm_connector_helper_funcs analogix_dp_connector_helper_funcs = {
1132		- .loader_protect = analogix_dp_loader_protect,
1133		- .get_modes = analogix_dp_get_modes,
1134		- .best_encoder = analogix_dp_best_encoder,
1135		-};
1136		-
1137		-static enum drm_connector_status
1138		-analogix_dp_detect(struct drm_connector *connector, bool force)
1139		-{
1140		- struct analogix_dp_device *dp = to_dp(connector);
1141		- enum drm_connector_status status = connector_status_disconnected;
1142		- int ret;
1143		-
1144		- if (dp->plat_data->panel) {
1145		- ret = analogix_dp_prepare_panel(dp, true);
1146		- if (ret) {
1147		- DRM_ERROR("Failed to prepare panel (%d)\n", ret);
1148		- return ret;
1149		- }
1150		- }
1151		-
1152		- pm_runtime_get_sync(dp->dev);
1153		- if (!analogix_dp_detect_hpd(dp))
1154		- status = connector_status_connected;
1155		- pm_runtime_put(dp->dev);
1156		-
1157		- return status;
1158		-}
1159		-
1160		-static int
1161		-analogix_dp_atomic_connector_get_property(struct drm_connector *connector,
1162		- const struct drm_connector_state *state,
1163		- struct drm_property *property,
1164		- uint64_t *val)
1165		-{
1166		- struct analogix_dp_device *dp = to_dp(connector);
1167		- const struct analogix_dp_property_ops *ops = dp->plat_data->property_ops;
1168		-
1169		- if (ops && ops->get_property)
1170		- return ops->get_property(connector, state, property,
1171		- val, dp->plat_data);
1172		- else
1173		- return -EINVAL;
1174		-}
1175		-
1176	1475	static const struct drm_connector_funcs analogix_dp_connector_funcs = {
1177	1476	.fill_modes = drm_helper_probe_single_connector_modes,
1178		- .detect = analogix_dp_detect,
	1477	+ .detect = analogix_dp_connector_detect,
1179	1478	.destroy = drm_connector_cleanup,
1180	1479	.reset = drm_atomic_helper_connector_reset,
1181	1480	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
1182	1481	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
	1482	+ .force = analogix_dp_connector_force,
1183	1483	.atomic_get_property = analogix_dp_atomic_connector_get_property,
1184	1484	};
1185	1485
1186		-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)
1187	1488	{
1188	1489	struct analogix_dp_device *dp = bridge->driver_private;
1189	1490	struct drm_encoder *encoder = dp->encoder;
..	..	@@ -1195,26 +1496,51 @@
1195	1496	return -ENODEV;
1196	1497	}
1197	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	+
1198	1512	if (!dp->plat_data->skip_connector) {
1199		- 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;
1200	1519
1201	1520	connector = &dp->connector;
1202	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;
1203	1525
1204	1526	ret = drm_connector_init(dp->drm_dev, connector,
1205	1527	&analogix_dp_connector_funcs,
1206		- DRM_MODE_CONNECTOR_eDP);
	1528	+ connector_type);
1207	1529	if (ret) {
1208	1530	DRM_ERROR("Failed to initialize connector with drm\n");
1209	1531	return ret;
1210	1532	}
1211	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	+
1212	1541	drm_connector_helper_add(connector,
1213	1542	&analogix_dp_connector_helper_funcs);
1214	1543	drm_connector_attach_encoder(connector, encoder);
1215		-
1216		- if (ops && ops->attach_properties)
1217		- ops->attach_properties(connector);
1218	1544	}
1219	1545
1220	1546	/*
..	..	@@ -1223,18 +1549,10 @@
1223	1549	* plat_data->attch return, that's why we record the connector
1224	1550	* point after plat attached.
1225	1551	*/
1226		- if (dp->plat_data->attach) {
1227		- ret = dp->plat_data->attach(dp->plat_data, bridge, connector);
1228		- if (ret) {
1229		- DRM_ERROR("Failed at platform attch func\n");
1230		- return ret;
1231		- }
1232		- }
1233		-
1234		- if (dp->plat_data->panel) {
1235		- 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);
1236	1554	if (ret) {
1237		- DRM_ERROR("Failed to attach panel\n");
	1555	+ DRM_ERROR("Failed at platform attach func\n");
1238	1556	return ret;
1239	1557	}
1240	1558	}
..	..	@@ -1242,28 +1560,89 @@
1242	1560	return 0;
1243	1561	}
1244	1562
1245		-static void analogix_dp_bridge_pre_enable(struct drm_bridge *bridge)
	1563	+static void analogix_dp_bridge_detach(struct drm_bridge *bridge)
1246	1564	{
1247	1565	struct analogix_dp_device *dp = bridge->driver_private;
1248		- int ret;
1249	1566
1250		- if (dp->plat_data->panel) {
1251		- ret = analogix_dp_prepare_panel(dp, true);
1252		- if (ret)
1253		- DRM_ERROR("failed to setup the panel ret = %d\n", ret);
1254		- }
	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);
1255	1634	}
1256	1635
1257	1636	static int analogix_dp_set_bridge(struct analogix_dp_device *dp)
1258	1637	{
1259	1638	int ret;
1260	1639
1261		- pm_runtime_get_sync(dp->dev);
1262		-
1263	1640	if (dp->plat_data->power_on_start)
1264	1641	dp->plat_data->power_on_start(dp->plat_data);
1265	1642
1266		- analogix_dp_phy_power_on(dp);
	1643	+ ret = analogix_dp_phy_power_on(dp);
	1644	+ if (ret)
	1645	+ return ret;
1267	1646
1268	1647	ret = analogix_dp_init_dp(dp);
1269	1648	if (ret)
..	..	@@ -1292,22 +1671,47 @@
1292	1671	if (dp->plat_data->power_on_end)
1293	1672	dp->plat_data->power_on_end(dp->plat_data);
1294	1673
1295		- enable_irq(dp->irq);
1296	1674	return 0;
1297	1675
1298	1676	out_dp_init:
1299	1677	analogix_dp_phy_power_off(dp);
1300	1678	if (dp->plat_data->power_off)
1301	1679	dp->plat_data->power_off(dp->plat_data);
1302		- pm_runtime_put_sync(dp->dev);
1303		-
1304	1680	return ret;
1305	1681	}
1306	1682
1307		-static void analogix_dp_bridge_enable(struct drm_bridge *bridge)
	1683	+static void analogix_dp_modeset_retry_work_fn(struct work_struct *work)
1308	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;
1309	1697	struct analogix_dp_device *dp = bridge->driver_private;
	1698	+ struct drm_crtc *crtc;
	1699	+ struct drm_crtc_state *old_crtc_state;
1310	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	+ }
1311	1715
1312	1716	if (dp->dpms_mode == DRM_MODE_DPMS_ON)
1313	1717	return;
..	..	@@ -1323,12 +1727,14 @@
1323	1727	usleep_range(10, 11);
1324	1728	}
1325	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);
1326	1733	}
1327	1734
1328	1735	static void analogix_dp_bridge_disable(struct drm_bridge *bridge)
1329	1736	{
1330	1737	struct analogix_dp_device *dp = bridge->driver_private;
1331		- int ret;
1332	1738
1333	1739	if (dp->dpms_mode != DRM_MODE_DPMS_ON)
1334	1740	return;
..	..	@@ -1340,44 +1746,115 @@
1340	1746	}
1341	1747	}
1342	1748
1343		- disable_irq(dp->irq);
	1749	+ if (!analogix_dp_get_plug_in_status(dp))
	1750	+ analogix_dp_link_power_down(dp);
1344	1751
1345	1752	if (dp->plat_data->power_off)
1346	1753	dp->plat_data->power_off(dp->plat_data);
1347	1754
1348		- analogix_dp_reset_aux(dp);
1349	1755	analogix_dp_set_analog_power_down(dp, POWER_ALL, 1);
1350	1756	analogix_dp_phy_power_off(dp);
1351	1757
1352		- pm_runtime_put_sync(dp->dev);
	1758	+ if (dp->plat_data->panel)
	1759	+ analogix_dp_panel_unprepare(dp);
1353	1760
1354		- if (dp->plat_data->panel) {
1355		- ret = analogix_dp_prepare_panel(dp, false);
1356		- if (ret)
1357		- DRM_ERROR("failed to setup the panel ret = %d\n", ret);
1358		- }
1359		-
1360		- dp->psr_enable = false;
1361	1761	dp->fast_train_enable = false;
	1762	+ dp->psr_supported = false;
1362	1763	dp->dpms_mode = DRM_MODE_DPMS_OFF;
1363	1764	}
1364	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	+
1365	1835	static void analogix_dp_bridge_mode_set(struct drm_bridge *bridge,
1366		- struct drm_display_mode *orig_mode,
1367		- struct drm_display_mode *mode)
	1836	+ const struct drm_display_mode *adj_mode)
1368	1837	{
1369	1838	struct analogix_dp_device *dp = bridge->driver_private;
1370	1839	struct drm_display_info *display_info = &dp->connector.display_info;
1371	1840	struct video_info *video = &dp->video_info;
	1841	+ struct drm_display_mode *mode = &video->mode;
1372	1842	struct device_node *dp_node = dp->dev->of_node;
1373	1843	int vic;
1374	1844
1375		- 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);
1376	1848
1377	1849	/* Input video interlaces & hsync pol & vsync pol */
1378	1850	video->interlaced = !!(mode->flags & DRM_MODE_FLAG_INTERLACE);
1379		- video->v_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NVSYNC);
1380		- 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	+ }
1381	1858
1382	1859	/* Input video dynamic_range & colorimetry */
1383	1860	vic = drm_match_cea_mode(mode);
..	..	@@ -1441,74 +1918,152 @@
1441	1918	video->interlaced = true;
1442	1919	}
1443	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	+
1444	1944	static enum drm_mode_status
1445	1945	analogix_dp_bridge_mode_valid(struct drm_bridge *bridge,
	1946	+ const struct drm_display_info *info,
1446	1947	const struct drm_display_mode *mode)
1447	1948	{
1448	1949	struct analogix_dp_device *dp = bridge->driver_private;
	1950	+ struct drm_display_mode m;
	1951	+ u32 max_link_rate, max_lane_count;
1449	1952
1450		- if (!analogix_dp_bandwidth_ok(dp, mode,
1451		- drm_dp_bw_code_to_link_rate(dp->video_info.max_link_rate),
1452		- 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))
1453	1966	return MODE_BAD;
1454	1967
1455	1968	return MODE_OK;
1456	1969	}
1457	1970
1458		-static void analogix_dp_bridge_nop(struct drm_bridge *bridge)
1459		-{
1460		- /* do nothing */
1461		-}
1462		-
1463	1971	static const struct drm_bridge_funcs analogix_dp_bridge_funcs = {
1464		- .pre_enable = analogix_dp_bridge_pre_enable,
1465		- .enable = analogix_dp_bridge_enable,
1466		- .disable = analogix_dp_bridge_disable,
1467		- .post_disable = analogix_dp_bridge_nop,
1468		- .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,
1469	1979	.attach = analogix_dp_bridge_attach,
	1980	+ .detach = analogix_dp_bridge_detach,
1470	1981	.mode_valid = analogix_dp_bridge_mode_valid,
1471	1982	};
1472	1983
1473		-static int analogix_dp_create_bridge(struct drm_device *drm_dev,
1474		- struct analogix_dp_device *dp)
	1984	+static int analogix_dp_bridge_init(struct analogix_dp_device *dp)
1475	1985	{
1476		- struct drm_bridge *bridge;
	1986	+ struct drm_bridge *bridge = &dp->bridge;
1477	1987	int ret;
1478	1988
1479		- bridge = devm_kzalloc(drm_dev->dev, sizeof(*bridge), GFP_KERNEL);
1480		- if (!bridge) {
1481		- DRM_ERROR("failed to allocate for drm bridge\n");
1482		- 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	+ }
1483	1995	}
1484	1996
1485		- 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);
1486	2002
1487		- bridge->driver_private = dp;
1488		- bridge->funcs = &analogix_dp_bridge_funcs;
1489		-
1490		- ret = drm_bridge_attach(dp->encoder, bridge, NULL);
1491		- if (ret) {
1492		- DRM_ERROR("failed to attach drm bridge\n");
1493		- 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;
1494	2007	}
1495	2008
1496	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;
1497	2045	}
1498	2046
1499	2047	static int analogix_dp_dt_parse_pdata(struct analogix_dp_device *dp)
1500	2048	{
1501	2049	struct device_node *dp_node = dp->dev->of_node;
1502	2050	struct video_info *video_info = &dp->video_info;
	2051	+ struct property *prop;
	2052	+ int ret, len, num_lanes;
	2053	+ u32 max_link_rate;
1503	2054
1504	2055	switch (dp->plat_data->dev_type) {
1505	2056	case RK3288_DP:
1506		- case RK3368_EDP:
1507	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	+ */
1508	2062	video_info->max_link_rate = 0x0A;
1509	2063	video_info->max_lane_count = 0x04;
1510	2064	break;
1511	2065	case RK3399_EDP:
	2066	+ case RK3588_EDP:
1512	2067	video_info->max_link_rate = 0x14;
1513	2068	video_info->max_lane_count = 0x04;
1514	2069	break;
..	..	@@ -1524,8 +2079,43 @@
1524	2079	break;
1525	2080	}
1526	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	+
1527	2086	video_info->video_bist_enable =
1528	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;
1529	2119
1530	2120	return 0;
1531	2121	}
..	..	@@ -1534,8 +2124,19 @@
1534	2124	struct drm_dp_aux_msg *msg)
1535	2125	{
1536	2126	struct analogix_dp_device *dp = to_dp(aux);
	2127	+ int ret;
1537	2128
1538		- 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;
1539	2140	}
1540	2141
1541	2142	int analogix_dp_audio_hw_params(struct analogix_dp_device *dp,
..	..	@@ -1580,9 +2181,70 @@
1580	2181	}
1581	2182	EXPORT_SYMBOL_GPL(analogix_dp_audio_get_eld);
1582	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	+
1583	2246	struct analogix_dp_device *
1584		-analogix_dp_bind(struct device dev, struct drm_device drm_dev,
1585		- struct analogix_dp_plat_data *plat_data)
	2247	+analogix_dp_probe(struct device dev, struct analogix_dp_plat_data plat_data)
1586	2248	{
1587	2249	struct platform_device *pdev = to_platform_device(dev);
1588	2250	struct analogix_dp_device *dp;
..	..	@@ -1600,6 +2262,7 @@
1600	2262
1601	2263	dp->dev = &pdev->dev;
1602	2264	dp->dpms_mode = DRM_MODE_DPMS_OFF;
	2265	+ INIT_WORK(&dp->modeset_retry_work, analogix_dp_modeset_retry_work_fn);
1603	2266
1604	2267	mutex_init(&dp->panel_lock);
1605	2268	dp->panel_is_prepared = false;
..	..	@@ -1631,6 +2294,14 @@
1631	2294	}
1632	2295	}
1633	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	+
1634	2305	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1635	2306
1636	2307	dp->reg_base = devm_ioremap_resource(&pdev->dev, res);
..	..	@@ -1651,11 +2322,9 @@
1651	2322	}
1652	2323
1653	2324	if (dp->hpd_gpiod) {
1654		- dp->hpd_irq = gpiod_to_irq(dp->hpd_gpiod);
1655		- if (dp->hpd_irq < 0)
1656		- return ERR_PTR(-EINVAL);
1657		-
1658		- 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,
1659	2328	analogix_dp_hpd_irq_handler,
1660	2329	IRQF_TRIGGER_RISING \|
1661	2330	IRQF_TRIGGER_FALLING \|
..	..	@@ -1674,71 +2343,91 @@
1674	2343	}
1675	2344
1676	2345	irq_set_status_flags(dp->irq, IRQ_NOAUTOEN);
1677		- ret = devm_request_threaded_irq(&pdev->dev, dp->irq,
1678		- analogix_dp_hardirq,
	2346	+ ret = devm_request_threaded_irq(dev, dp->irq, NULL,
1679	2347	analogix_dp_irq_thread,
1680		- 0, "analogix-dp", dp);
	2348	+ IRQF_ONESHOT, dev_name(dev), dp);
1681	2349	if (ret) {
1682	2350	dev_err(&pdev->dev, "failed to request irq\n");
1683		- goto err_disable_pm_runtime;
	2351	+ return ERR_PTR(ret);
1684	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;
1685	2376
1686	2377	dp->drm_dev = drm_dev;
1687	2378	dp->encoder = dp->plat_data->encoder;
1688	2379
1689	2380	dp->aux.name = "DP-AUX";
1690	2381	dp->aux.transfer = analogix_dpaux_transfer;
1691		- dp->aux.dev = &pdev->dev;
	2382	+ dp->aux.dev = dp->dev;
1692	2383
1693	2384	ret = drm_dp_aux_register(&dp->aux);
1694	2385	if (ret)
1695		- return ERR_PTR(ret);
	2386	+ return ret;
1696	2387
1697		- pm_runtime_enable(dev);
	2388	+ pm_runtime_enable(dp->dev);
	2389	+ pm_runtime_get_sync(dp->dev);
	2390	+ analogix_dp_init(dp);
1698	2391
1699		- ret = analogix_dp_create_bridge(drm_dev, dp);
	2392	+ ret = analogix_dp_bridge_init(dp);
1700	2393	if (ret) {
1701		- DRM_ERROR("failed to create bridge (%d)\n", ret);
	2394	+ DRM_ERROR("failed to init bridge (%d)\n", ret);
1702	2395	goto err_disable_pm_runtime;
1703	2396	}
1704	2397
1705		- return dp;
	2398	+ enable_irq(dp->irq);
	2399	+
	2400	+ return 0;
1706	2401
1707	2402	err_disable_pm_runtime:
	2403	+ pm_runtime_put(dp->dev);
	2404	+ pm_runtime_disable(dp->dev);
	2405	+ drm_dp_aux_unregister(&dp->aux);
1708	2406
1709		- pm_runtime_disable(dev);
1710		-
1711		- return ERR_PTR(ret);
	2407	+ return ret;
1712	2408	}
1713	2409	EXPORT_SYMBOL_GPL(analogix_dp_bind);
1714	2410
1715	2411	void analogix_dp_unbind(struct analogix_dp_device *dp)
1716	2412	{
1717		- analogix_dp_bridge_disable(dp->bridge);
1718		- dp->connector.funcs->destroy(&dp->connector);
1719		-
1720		- if (dp->plat_data->panel) {
1721		- if (drm_panel_unprepare(dp->plat_data->panel))
1722		- DRM_ERROR("failed to turnoff the panel\n");
1723		- if (drm_panel_detach(dp->plat_data->panel))
1724		- DRM_ERROR("failed to detach the panel\n");
1725		- }
1726		-
	2413	+ disable_irq(dp->irq);
	2414	+ if (dp->connector.funcs->destroy)
	2415	+ dp->connector.funcs->destroy(&dp->connector);
1727	2416	drm_dp_aux_unregister(&dp->aux);
	2417	+ pm_runtime_put(dp->dev);
1728	2418	pm_runtime_disable(dp->dev);
1729	2419	}
1730	2420	EXPORT_SYMBOL_GPL(analogix_dp_unbind);
1731	2421
1732		-#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	+
1733	2428	int analogix_dp_suspend(struct analogix_dp_device *dp)
1734	2429	{
1735		- if (dp->hpd_gpiod)
1736		- disable_irq(dp->hpd_irq);
1737		-
1738		- if (dp->plat_data->panel) {
1739		- if (drm_panel_unprepare(dp->plat_data->panel))
1740		- DRM_ERROR("failed to turnoff the panel\n");
1741		- }
	2430	+ pm_runtime_force_suspend(dp->dev);
1742	2431
1743	2432	return 0;
1744	2433	}
..	..	@@ -1746,20 +2435,26 @@
1746	2435
1747	2436	int analogix_dp_resume(struct analogix_dp_device *dp)
1748	2437	{
1749		- if (dp->plat_data->panel) {
1750		- if (drm_panel_prepare(dp->plat_data->panel)) {
1751		- DRM_ERROR("failed to setup the panel\n");
1752		- return -EBUSY;
1753		- }
1754		- }
1755		-
1756		- if (dp->hpd_gpiod)
1757		- enable_irq(dp->hpd_irq);
	2438	+ pm_runtime_force_resume(dp->dev);
	2439	+ analogix_dp_init(dp);
1758	2440
1759	2441	return 0;
1760	2442	}
1761	2443	EXPORT_SYMBOL_GPL(analogix_dp_resume);
1762		-#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);
1763	2458
1764	2459	int analogix_dp_start_crc(struct drm_connector *connector)
1765	2460	{