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