1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
4  */
5 
6 #include <linux/string_choices.h>
7 #include <drm/drm_atomic_helper.h>
8 #include <drm/drm_atomic.h>
9 #include <drm/drm_bridge.h>
10 #include <drm/drm_bridge_connector.h>
11 #include <drm/drm_crtc.h>
12 
13 #include "msm_drv.h"
14 #include "msm_kms.h"
15 #include "dp_drm.h"
16 
17 /**
18  * msm_dp_bridge_detect - callback to determine if connector is connected
19  * @bridge: Pointer to drm bridge structure
20  * Returns: Bridge's 'is connected' status
21  */
msm_dp_bridge_detect(struct drm_bridge * bridge)22 static enum drm_connector_status msm_dp_bridge_detect(struct drm_bridge *bridge)
23 {
24 	struct msm_dp *dp;
25 
26 	dp = to_dp_bridge(bridge)->msm_dp_display;
27 
28 	drm_dbg_dp(dp->drm_dev, "link_ready = %s\n",
29 		str_true_false(dp->link_ready));
30 
31 	return (dp->link_ready) ? connector_status_connected :
32 					connector_status_disconnected;
33 }
34 
msm_dp_bridge_atomic_check(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state,struct drm_crtc_state * crtc_state,struct drm_connector_state * conn_state)35 static int msm_dp_bridge_atomic_check(struct drm_bridge *bridge,
36 			    struct drm_bridge_state *bridge_state,
37 			    struct drm_crtc_state *crtc_state,
38 			    struct drm_connector_state *conn_state)
39 {
40 	struct msm_dp *dp;
41 
42 	dp = to_dp_bridge(bridge)->msm_dp_display;
43 
44 	drm_dbg_dp(dp->drm_dev, "link_ready = %s\n",
45 		str_true_false(dp->link_ready));
46 
47 	/*
48 	 * There is no protection in the DRM framework to check if the display
49 	 * pipeline has been already disabled before trying to disable it again.
50 	 * Hence if the sink is unplugged, the pipeline gets disabled, but the
51 	 * crtc->active is still true. Any attempt to set the mode or manually
52 	 * disable this encoder will result in the crash.
53 	 *
54 	 * TODO: add support for telling the DRM subsystem that the pipeline is
55 	 * disabled by the hardware and thus all access to it should be forbidden.
56 	 * After that this piece of code can be removed.
57 	 */
58 	if (bridge->ops & DRM_BRIDGE_OP_HPD)
59 		return (dp->link_ready) ? 0 : -ENOTCONN;
60 
61 	return 0;
62 }
63 
64 
65 /**
66  * msm_dp_bridge_get_modes - callback to add drm modes via drm_mode_probed_add()
67  * @bridge: Poiner to drm bridge
68  * @connector: Pointer to drm connector structure
69  * Returns: Number of modes added
70  */
msm_dp_bridge_get_modes(struct drm_bridge * bridge,struct drm_connector * connector)71 static int msm_dp_bridge_get_modes(struct drm_bridge *bridge, struct drm_connector *connector)
72 {
73 	int rc = 0;
74 	struct msm_dp *dp;
75 
76 	if (!connector)
77 		return 0;
78 
79 	dp = to_dp_bridge(bridge)->msm_dp_display;
80 
81 	/* pluggable case assumes EDID is read when HPD */
82 	if (dp->link_ready) {
83 		rc = msm_dp_display_get_modes(dp);
84 		if (rc <= 0) {
85 			DRM_ERROR("failed to get DP sink modes, rc=%d\n", rc);
86 			return rc;
87 		}
88 	} else {
89 		drm_dbg_dp(connector->dev, "No sink connected\n");
90 	}
91 	return rc;
92 }
93 
msm_dp_bridge_debugfs_init(struct drm_bridge * bridge,struct dentry * root)94 static void msm_dp_bridge_debugfs_init(struct drm_bridge *bridge, struct dentry *root)
95 {
96 	struct msm_dp *dp = to_dp_bridge(bridge)->msm_dp_display;
97 
98 	msm_dp_display_debugfs_init(dp, root, false);
99 }
100 
101 static const struct drm_bridge_funcs msm_dp_bridge_ops = {
102 	.atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
103 	.atomic_destroy_state   = drm_atomic_helper_bridge_destroy_state,
104 	.atomic_reset           = drm_atomic_helper_bridge_reset,
105 	.atomic_enable          = msm_dp_bridge_atomic_enable,
106 	.atomic_disable         = msm_dp_bridge_atomic_disable,
107 	.atomic_post_disable    = msm_dp_bridge_atomic_post_disable,
108 	.mode_set     = msm_dp_bridge_mode_set,
109 	.mode_valid   = msm_dp_bridge_mode_valid,
110 	.get_modes    = msm_dp_bridge_get_modes,
111 	.detect       = msm_dp_bridge_detect,
112 	.atomic_check = msm_dp_bridge_atomic_check,
113 	.hpd_enable   = msm_dp_bridge_hpd_enable,
114 	.hpd_disable  = msm_dp_bridge_hpd_disable,
115 	.hpd_notify   = msm_dp_bridge_hpd_notify,
116 	.debugfs_init = msm_dp_bridge_debugfs_init,
117 };
118 
msm_edp_bridge_atomic_check(struct drm_bridge * drm_bridge,struct drm_bridge_state * bridge_state,struct drm_crtc_state * crtc_state,struct drm_connector_state * conn_state)119 static int msm_edp_bridge_atomic_check(struct drm_bridge *drm_bridge,
120 				   struct drm_bridge_state *bridge_state,
121 				   struct drm_crtc_state *crtc_state,
122 				   struct drm_connector_state *conn_state)
123 {
124 	struct msm_dp *dp = to_dp_bridge(drm_bridge)->msm_dp_display;
125 
126 	if (WARN_ON(!conn_state))
127 		return -ENODEV;
128 
129 	conn_state->self_refresh_aware = dp->psr_supported;
130 
131 	if (!conn_state->crtc || !crtc_state)
132 		return 0;
133 
134 	if (crtc_state->self_refresh_active && !dp->psr_supported)
135 		return -EINVAL;
136 
137 	return 0;
138 }
139 
msm_edp_bridge_atomic_enable(struct drm_bridge * drm_bridge,struct drm_atomic_state * state)140 static void msm_edp_bridge_atomic_enable(struct drm_bridge *drm_bridge,
141 					 struct drm_atomic_state *state)
142 {
143 	struct drm_crtc *crtc;
144 	struct drm_crtc_state *old_crtc_state;
145 	struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge);
146 	struct msm_dp *dp = msm_dp_bridge->msm_dp_display;
147 
148 	/*
149 	 * Check the old state of the crtc to determine if the panel
150 	 * was put into psr state previously by the msm_edp_bridge_atomic_disable.
151 	 * If the panel is in psr, just exit psr state and skip the full
152 	 * bridge enable sequence.
153 	 */
154 	crtc = drm_atomic_get_new_crtc_for_encoder(state,
155 						   drm_bridge->encoder);
156 	if (!crtc)
157 		return;
158 
159 	old_crtc_state = drm_atomic_get_old_crtc_state(state, crtc);
160 
161 	if (old_crtc_state && old_crtc_state->self_refresh_active) {
162 		msm_dp_display_set_psr(dp, false);
163 		return;
164 	}
165 
166 	msm_dp_bridge_atomic_enable(drm_bridge, state);
167 }
168 
msm_edp_bridge_atomic_disable(struct drm_bridge * drm_bridge,struct drm_atomic_state * atomic_state)169 static void msm_edp_bridge_atomic_disable(struct drm_bridge *drm_bridge,
170 					  struct drm_atomic_state *atomic_state)
171 {
172 	struct drm_crtc *crtc;
173 	struct drm_crtc_state *new_crtc_state = NULL, *old_crtc_state = NULL;
174 	struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge);
175 	struct msm_dp *dp = msm_dp_bridge->msm_dp_display;
176 
177 	crtc = drm_atomic_get_old_crtc_for_encoder(atomic_state,
178 						   drm_bridge->encoder);
179 	if (!crtc)
180 		goto out;
181 
182 	new_crtc_state = drm_atomic_get_new_crtc_state(atomic_state, crtc);
183 	if (!new_crtc_state)
184 		goto out;
185 
186 	old_crtc_state = drm_atomic_get_old_crtc_state(atomic_state, crtc);
187 	if (!old_crtc_state)
188 		goto out;
189 
190 	/*
191 	 * Set self refresh mode if current crtc state is active.
192 	 *
193 	 * If old crtc state is active, then this is a display disable
194 	 * call while the sink is in psr state. So, exit psr here.
195 	 * The eDP controller will be disabled in the
196 	 * msm_edp_bridge_atomic_post_disable function.
197 	 *
198 	 * We observed sink is stuck in self refresh if psr exit is skipped
199 	 * when display disable occurs while the sink is in psr state.
200 	 */
201 	if (new_crtc_state->self_refresh_active) {
202 		msm_dp_display_set_psr(dp, true);
203 		return;
204 	} else if (old_crtc_state->self_refresh_active) {
205 		msm_dp_display_set_psr(dp, false);
206 		return;
207 	}
208 
209 out:
210 	msm_dp_bridge_atomic_disable(drm_bridge, atomic_state);
211 }
212 
msm_edp_bridge_atomic_post_disable(struct drm_bridge * drm_bridge,struct drm_atomic_state * atomic_state)213 static void msm_edp_bridge_atomic_post_disable(struct drm_bridge *drm_bridge,
214 					       struct drm_atomic_state *atomic_state)
215 {
216 	struct drm_crtc *crtc;
217 	struct drm_crtc_state *new_crtc_state = NULL;
218 
219 	crtc = drm_atomic_get_old_crtc_for_encoder(atomic_state,
220 						   drm_bridge->encoder);
221 	if (!crtc)
222 		return;
223 
224 	new_crtc_state = drm_atomic_get_new_crtc_state(atomic_state, crtc);
225 	if (!new_crtc_state)
226 		return;
227 
228 	/*
229 	 * Self refresh mode is already set in msm_edp_bridge_atomic_disable.
230 	 */
231 	if (new_crtc_state->self_refresh_active)
232 		return;
233 
234 	msm_dp_bridge_atomic_post_disable(drm_bridge, atomic_state);
235 }
236 
237 /**
238  * msm_edp_bridge_mode_valid - callback to determine if specified mode is valid
239  * @bridge: Pointer to drm bridge structure
240  * @info: display info
241  * @mode: Pointer to drm mode structure
242  * Returns: Validity status for specified mode
243  */
msm_edp_bridge_mode_valid(struct drm_bridge * bridge,const struct drm_display_info * info,const struct drm_display_mode * mode)244 static enum drm_mode_status msm_edp_bridge_mode_valid(struct drm_bridge *bridge,
245 					  const struct drm_display_info *info,
246 					  const struct drm_display_mode *mode)
247 {
248 	struct msm_dp *dp;
249 	int mode_pclk_khz = mode->clock;
250 
251 	dp = to_dp_bridge(bridge)->msm_dp_display;
252 
253 	if (!dp || !mode_pclk_khz || !dp->connector) {
254 		DRM_ERROR("invalid params\n");
255 		return -EINVAL;
256 	}
257 
258 	if (msm_dp_wide_bus_available(dp))
259 		mode_pclk_khz /= 2;
260 
261 	if (mode_pclk_khz > DP_MAX_PIXEL_CLK_KHZ)
262 		return MODE_CLOCK_HIGH;
263 
264 	/*
265 	 * The eDP controller currently does not have a reliable way of
266 	 * enabling panel power to read sink capabilities. So, we rely
267 	 * on the panel driver to populate only supported modes for now.
268 	 */
269 	return MODE_OK;
270 }
271 
msm_edp_bridge_debugfs_init(struct drm_bridge * bridge,struct dentry * root)272 static void msm_edp_bridge_debugfs_init(struct drm_bridge *bridge, struct dentry *root)
273 {
274 	struct msm_dp *dp = to_dp_bridge(bridge)->msm_dp_display;
275 
276 	msm_dp_display_debugfs_init(dp, root, true);
277 }
278 
279 static const struct drm_bridge_funcs msm_edp_bridge_ops = {
280 	.atomic_enable = msm_edp_bridge_atomic_enable,
281 	.atomic_disable = msm_edp_bridge_atomic_disable,
282 	.atomic_post_disable = msm_edp_bridge_atomic_post_disable,
283 	.mode_set = msm_dp_bridge_mode_set,
284 	.mode_valid = msm_edp_bridge_mode_valid,
285 	.atomic_reset = drm_atomic_helper_bridge_reset,
286 	.atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
287 	.atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
288 	.atomic_check = msm_edp_bridge_atomic_check,
289 	.debugfs_init = msm_edp_bridge_debugfs_init,
290 };
291 
msm_dp_bridge_init(struct msm_dp * msm_dp_display,struct drm_device * dev,struct drm_encoder * encoder,bool yuv_supported)292 int msm_dp_bridge_init(struct msm_dp *msm_dp_display, struct drm_device *dev,
293 		   struct drm_encoder *encoder, bool yuv_supported)
294 {
295 	int rc;
296 	struct msm_dp_bridge *msm_dp_bridge;
297 	struct drm_bridge *bridge;
298 
299 	msm_dp_bridge = devm_kzalloc(dev->dev, sizeof(*msm_dp_bridge), GFP_KERNEL);
300 	if (!msm_dp_bridge)
301 		return -ENOMEM;
302 
303 	msm_dp_bridge->msm_dp_display = msm_dp_display;
304 
305 	bridge = &msm_dp_bridge->bridge;
306 	bridge->funcs = msm_dp_display->is_edp ? &msm_edp_bridge_ops : &msm_dp_bridge_ops;
307 	bridge->type = msm_dp_display->connector_type;
308 	bridge->ycbcr_420_allowed = yuv_supported;
309 
310 	/*
311 	 * Many ops only make sense for DP. Why?
312 	 * - Detect/HPD are used by DRM to know if a display is _physically_
313 	 *   there, not whether the display is powered on / finished initting.
314 	 *   On eDP we assume the display is always there because you can't
315 	 *   know until power is applied. If we don't implement the ops DRM will
316 	 *   assume our display is always there.
317 	 * - Currently eDP mode reading is driven by the panel driver. This
318 	 *   allows the panel driver to properly power itself on to read the
319 	 *   modes.
320 	 */
321 	if (!msm_dp_display->is_edp) {
322 		bridge->ops =
323 			DRM_BRIDGE_OP_DETECT |
324 			DRM_BRIDGE_OP_HPD |
325 			DRM_BRIDGE_OP_MODES;
326 	}
327 
328 	rc = devm_drm_bridge_add(dev->dev, bridge);
329 	if (rc) {
330 		DRM_ERROR("failed to add bridge, rc=%d\n", rc);
331 
332 		return rc;
333 	}
334 
335 	rc = drm_bridge_attach(encoder, bridge, NULL, DRM_BRIDGE_ATTACH_NO_CONNECTOR);
336 	if (rc) {
337 		DRM_ERROR("failed to attach bridge, rc=%d\n", rc);
338 
339 		return rc;
340 	}
341 
342 	if (msm_dp_display->next_bridge) {
343 		rc = drm_bridge_attach(encoder,
344 					msm_dp_display->next_bridge, bridge,
345 					DRM_BRIDGE_ATTACH_NO_CONNECTOR);
346 		if (rc < 0) {
347 			DRM_ERROR("failed to attach panel bridge: %d\n", rc);
348 			return rc;
349 		}
350 	}
351 
352 	return 0;
353 }
354 
355 /* connector initialization */
msm_dp_drm_connector_init(struct msm_dp * msm_dp_display,struct drm_encoder * encoder)356 struct drm_connector *msm_dp_drm_connector_init(struct msm_dp *msm_dp_display,
357 					    struct drm_encoder *encoder)
358 {
359 	struct drm_connector *connector = NULL;
360 
361 	connector = drm_bridge_connector_init(msm_dp_display->drm_dev, encoder);
362 	if (IS_ERR(connector))
363 		return connector;
364 
365 	if (!msm_dp_display->is_edp)
366 		drm_connector_attach_dp_subconnector_property(connector);
367 
368 	drm_connector_attach_encoder(connector, encoder);
369 
370 	return connector;
371 }
372