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 } 355