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_audio.h" 16 #include "dp_drm.h" 17 18 /** 19 * msm_dp_bridge_get_modes - callback to add drm modes via drm_mode_probed_add() 20 * @bridge: Poiner to drm bridge 21 * @connector: Pointer to drm connector structure 22 * Returns: Number of modes added 23 */ 24 static int msm_dp_bridge_get_modes(struct drm_bridge *bridge, struct drm_connector *connector) 25 { 26 int rc = 0; 27 struct msm_dp *dp; 28 29 if (!connector) 30 return 0; 31 32 dp = to_dp_bridge(bridge)->msm_dp_display; 33 34 /* pluggable case assumes EDID is read when HPD */ 35 rc = msm_dp_display_get_modes(dp); 36 if (rc <= 0) { 37 DRM_ERROR("failed to get DP sink modes, rc=%d\n", rc); 38 return rc; 39 } else { 40 drm_dbg_dp(connector->dev, "No sink connected\n"); 41 } 42 return rc; 43 } 44 45 static void msm_dp_bridge_debugfs_init(struct drm_bridge *bridge, struct dentry *root) 46 { 47 struct msm_dp *dp = to_dp_bridge(bridge)->msm_dp_display; 48 49 msm_dp_display_debugfs_init(dp, root, false); 50 } 51 52 static void msm_dp_bridge_atomic_pre_enable(struct drm_bridge *drm_bridge, 53 struct drm_atomic_commit *state) 54 { 55 struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge); 56 struct msm_dp *dp = dp_bridge->msm_dp_display; 57 58 msm_dp_display_atomic_pre_enable(dp, state); 59 } 60 61 static void msm_dp_bridge_atomic_enable(struct drm_bridge *drm_bridge, 62 struct drm_atomic_commit *state) 63 { 64 struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge); 65 struct msm_dp *dp = dp_bridge->msm_dp_display; 66 67 msm_dp_display_atomic_enable(dp, state); 68 } 69 70 static void msm_dp_bridge_atomic_disable(struct drm_bridge *drm_bridge, 71 struct drm_atomic_commit *state) 72 { 73 struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge); 74 struct msm_dp *dp = dp_bridge->msm_dp_display; 75 76 msm_dp_display_atomic_disable(dp); 77 } 78 79 static void msm_dp_bridge_atomic_post_disable(struct drm_bridge *drm_bridge, 80 struct drm_atomic_commit *state) 81 { 82 struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge); 83 struct msm_dp *dp = dp_bridge->msm_dp_display; 84 85 msm_dp_display_atomic_post_disable(dp); 86 } 87 88 static enum drm_mode_status msm_dp_bridge_mode_valid(struct drm_bridge *drm_bridge, 89 const struct drm_display_info *info, 90 const struct drm_display_mode *mode) 91 { 92 struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge); 93 struct msm_dp *dp = dp_bridge->msm_dp_display; 94 95 return msm_dp_display_mode_valid(dp, info, mode); 96 } 97 98 static const struct drm_bridge_funcs msm_dp_bridge_ops = { 99 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, 100 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, 101 .atomic_create_state = drm_atomic_helper_bridge_create_state, 102 .atomic_pre_enable = msm_dp_bridge_atomic_pre_enable, 103 .atomic_enable = msm_dp_bridge_atomic_enable, 104 .atomic_disable = msm_dp_bridge_atomic_disable, 105 .atomic_post_disable = msm_dp_bridge_atomic_post_disable, 106 .mode_valid = msm_dp_bridge_mode_valid, 107 .get_modes = msm_dp_bridge_get_modes, 108 .detect = msm_dp_bridge_detect, 109 .hpd_enable = msm_dp_bridge_hpd_enable, 110 .hpd_disable = msm_dp_bridge_hpd_disable, 111 .hpd_notify = msm_dp_bridge_hpd_notify, 112 .debugfs_init = msm_dp_bridge_debugfs_init, 113 114 .dp_audio_prepare = msm_dp_audio_prepare, 115 .dp_audio_shutdown = msm_dp_audio_shutdown, 116 }; 117 118 static int msm_edp_bridge_atomic_check(struct drm_bridge *drm_bridge, 119 struct drm_bridge_state *bridge_state, 120 struct drm_crtc_state *crtc_state, 121 struct drm_connector_state *conn_state) 122 { 123 struct msm_dp *dp = to_dp_bridge(drm_bridge)->msm_dp_display; 124 125 if (WARN_ON(!conn_state)) 126 return -ENODEV; 127 128 conn_state->self_refresh_aware = dp->psr_supported; 129 130 if (!conn_state->crtc || !crtc_state) 131 return 0; 132 133 if (crtc_state->self_refresh_active && !dp->psr_supported) 134 return -EINVAL; 135 136 return 0; 137 } 138 139 static void msm_edp_bridge_atomic_enable(struct drm_bridge *drm_bridge, 140 struct drm_atomic_commit *state) 141 { 142 struct drm_crtc *crtc; 143 struct drm_crtc_state *old_crtc_state; 144 struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge); 145 struct msm_dp *dp = msm_dp_bridge->msm_dp_display; 146 147 /* 148 * Check the old state of the crtc to determine if the panel 149 * was put into psr state previously by the msm_edp_bridge_atomic_disable. 150 * If the panel is in psr, just exit psr state and skip the full 151 * bridge enable sequence. 152 */ 153 crtc = drm_atomic_get_new_crtc_for_encoder(state, 154 drm_bridge->encoder); 155 if (!crtc) 156 return; 157 158 old_crtc_state = drm_atomic_get_old_crtc_state(state, crtc); 159 160 if (old_crtc_state && old_crtc_state->self_refresh_active) { 161 msm_dp_display_set_psr(dp, false); 162 return; 163 } 164 165 msm_dp_display_atomic_enable(dp, state); 166 } 167 168 static void msm_edp_bridge_atomic_disable(struct drm_bridge *drm_bridge, 169 struct drm_atomic_commit *atomic_state) 170 { 171 struct drm_crtc *crtc; 172 struct drm_crtc_state *new_crtc_state = NULL, *old_crtc_state = NULL; 173 struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge); 174 struct msm_dp *dp = msm_dp_bridge->msm_dp_display; 175 176 crtc = drm_atomic_get_old_crtc_for_encoder(atomic_state, 177 drm_bridge->encoder); 178 if (!crtc) 179 goto out; 180 181 new_crtc_state = drm_atomic_get_new_crtc_state(atomic_state, crtc); 182 if (!new_crtc_state) 183 goto out; 184 185 old_crtc_state = drm_atomic_get_old_crtc_state(atomic_state, crtc); 186 if (!old_crtc_state) 187 goto out; 188 189 /* 190 * Set self refresh mode if current crtc state is active. 191 * 192 * If old crtc state is active, then this is a display disable 193 * call while the sink is in psr state. So, exit psr here. 194 * The eDP controller will be disabled in the 195 * msm_edp_bridge_atomic_post_disable function. 196 * 197 * We observed sink is stuck in self refresh if psr exit is skipped 198 * when display disable occurs while the sink is in psr state. 199 */ 200 if (new_crtc_state->self_refresh_active) { 201 msm_dp_display_set_psr(dp, true); 202 return; 203 } else if (old_crtc_state->self_refresh_active) { 204 msm_dp_display_set_psr(dp, false); 205 return; 206 } 207 208 out: 209 msm_dp_bridge_atomic_disable(drm_bridge, atomic_state); 210 } 211 212 static void msm_edp_bridge_atomic_post_disable(struct drm_bridge *drm_bridge, 213 struct drm_atomic_commit *atomic_state) 214 { 215 struct drm_crtc *crtc; 216 struct drm_crtc_state *new_crtc_state = NULL; 217 218 crtc = drm_atomic_get_old_crtc_for_encoder(atomic_state, 219 drm_bridge->encoder); 220 if (!crtc) 221 return; 222 223 new_crtc_state = drm_atomic_get_new_crtc_state(atomic_state, crtc); 224 if (!new_crtc_state) 225 return; 226 227 /* 228 * Self refresh mode is already set in msm_edp_bridge_atomic_disable. 229 */ 230 if (new_crtc_state->self_refresh_active) 231 return; 232 233 msm_dp_bridge_atomic_post_disable(drm_bridge, atomic_state); 234 } 235 236 /** 237 * msm_edp_bridge_mode_valid - callback to determine if specified mode is valid 238 * @bridge: Pointer to drm bridge structure 239 * @info: display info 240 * @mode: Pointer to drm mode structure 241 * Returns: Validity status for specified mode 242 */ 243 static enum drm_mode_status msm_edp_bridge_mode_valid(struct drm_bridge *bridge, 244 const struct drm_display_info *info, 245 const struct drm_display_mode *mode) 246 { 247 struct msm_dp *dp; 248 int mode_pclk_khz = mode->clock; 249 250 dp = to_dp_bridge(bridge)->msm_dp_display; 251 252 if (!dp || !mode_pclk_khz || !dp->connector) { 253 DRM_ERROR("invalid params\n"); 254 return -EINVAL; 255 } 256 257 if (msm_dp_wide_bus_available(dp)) 258 mode_pclk_khz /= 2; 259 260 if (mode_pclk_khz > DP_MAX_PIXEL_CLK_KHZ) 261 return MODE_CLOCK_HIGH; 262 263 /* 264 * The eDP controller currently does not have a reliable way of 265 * enabling panel power to read sink capabilities. So, we rely 266 * on the panel driver to populate only supported modes for now. 267 */ 268 return MODE_OK; 269 } 270 271 static void msm_edp_bridge_debugfs_init(struct drm_bridge *bridge, struct dentry *root) 272 { 273 struct msm_dp *dp = to_dp_bridge(bridge)->msm_dp_display; 274 275 msm_dp_display_debugfs_init(dp, root, true); 276 } 277 278 static const struct drm_bridge_funcs msm_edp_bridge_ops = { 279 .atomic_pre_enable = msm_dp_bridge_atomic_pre_enable, 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_valid = msm_edp_bridge_mode_valid, 284 .atomic_create_state = drm_atomic_helper_bridge_create_state, 285 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, 286 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, 287 .atomic_check = msm_edp_bridge_atomic_check, 288 .debugfs_init = msm_edp_bridge_debugfs_init, 289 }; 290 291 int msm_dp_bridge_init(struct msm_dp *msm_dp_display, struct drm_device *dev, 292 struct drm_encoder *encoder, bool yuv_supported) 293 { 294 int rc; 295 struct msm_dp_bridge *msm_dp_bridge; 296 struct drm_bridge *bridge; 297 298 msm_dp_bridge = devm_drm_bridge_alloc(dev->dev, struct msm_dp_bridge, bridge, 299 msm_dp_display->is_edp ? &msm_edp_bridge_ops : 300 &msm_dp_bridge_ops); 301 if (IS_ERR(msm_dp_bridge)) 302 return PTR_ERR(msm_dp_bridge); 303 304 msm_dp_bridge->msm_dp_display = msm_dp_display; 305 306 bridge = &msm_dp_bridge->bridge; 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_DP_AUDIO | 324 DRM_BRIDGE_OP_DETECT | 325 DRM_BRIDGE_OP_HPD | 326 DRM_BRIDGE_OP_MODES; 327 bridge->hdmi_audio_dev = &msm_dp_display->pdev->dev; 328 bridge->hdmi_audio_max_i2s_playback_channels = 8; 329 bridge->hdmi_audio_dai_port = -1; 330 } 331 332 rc = devm_drm_bridge_add(dev->dev, bridge); 333 if (rc) { 334 DRM_ERROR("failed to add bridge, rc=%d\n", rc); 335 336 return rc; 337 } 338 339 rc = drm_bridge_attach(encoder, bridge, NULL, DRM_BRIDGE_ATTACH_NO_CONNECTOR); 340 if (rc) { 341 DRM_ERROR("failed to attach bridge, rc=%d\n", rc); 342 343 return rc; 344 } 345 346 if (msm_dp_display->next_bridge) { 347 rc = drm_bridge_attach(encoder, 348 msm_dp_display->next_bridge, bridge, 349 DRM_BRIDGE_ATTACH_NO_CONNECTOR); 350 if (rc < 0) { 351 DRM_ERROR("failed to attach panel bridge: %d\n", rc); 352 return rc; 353 } 354 } 355 356 msm_dp_display->bridge = bridge; 357 358 return 0; 359 } 360 361 /* connector initialization */ 362 struct drm_connector *msm_dp_drm_connector_init(struct msm_dp *msm_dp_display, 363 struct drm_encoder *encoder) 364 { 365 struct drm_connector *connector = NULL; 366 367 connector = drm_bridge_connector_init(msm_dp_display->drm_dev, encoder); 368 if (IS_ERR(connector)) 369 return connector; 370 371 if (!msm_dp_display->is_edp) 372 drm_connector_attach_dp_subconnector_property(connector); 373 374 return connector; 375 } 376