373 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*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 connected18 * @bridge: Pointer to drm bridge structure19 * Returns: Bridge's 'is connected' status20 */21static 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, "link_ready = %s\n",28 (dp->link_ready) ? "true" : "false");29 30 return (dp->link_ready) ? connector_status_connected :31 connector_status_disconnected;32}33 34static 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, "link_ready = %s\n",44 (dp->link_ready) ? "true" : "false");45 46 /*47 * There is no protection in the DRM framework to check if the display48 * pipeline has been already disabled before trying to disable it again.49 * Hence if the sink is unplugged, the pipeline gets disabled, but the50 * crtc->active is still true. Any attempt to set the mode or manually51 * disable this encoder will result in the crash.52 *53 * TODO: add support for telling the DRM subsystem that the pipeline is54 * 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->link_ready) ? 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 bridge67 * @connector: Pointer to drm connector structure68 * Returns: Number of modes added69 */70static 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->link_ready) {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 93static void dp_bridge_debugfs_init(struct drm_bridge *bridge, struct dentry *root)94{95 struct msm_dp *dp = to_dp_bridge(bridge)->dp_display;96 97 dp_display_debugfs_init(dp, root, false);98}99 100static const struct drm_bridge_funcs dp_bridge_ops = {101 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,102 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,103 .atomic_reset = drm_atomic_helper_bridge_reset,104 .atomic_enable = dp_bridge_atomic_enable,105 .atomic_disable = dp_bridge_atomic_disable,106 .atomic_post_disable = dp_bridge_atomic_post_disable,107 .mode_set = dp_bridge_mode_set,108 .mode_valid = dp_bridge_mode_valid,109 .get_modes = dp_bridge_get_modes,110 .detect = dp_bridge_detect,111 .atomic_check = dp_bridge_atomic_check,112 .hpd_enable = dp_bridge_hpd_enable,113 .hpd_disable = dp_bridge_hpd_disable,114 .hpd_notify = dp_bridge_hpd_notify,115 .debugfs_init = dp_bridge_debugfs_init,116};117 118static int 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)->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 139static void edp_bridge_atomic_enable(struct drm_bridge *drm_bridge,140 struct drm_bridge_state *old_bridge_state)141{142 struct drm_atomic_state *atomic_state = old_bridge_state->base.state;143 struct drm_crtc *crtc;144 struct drm_crtc_state *old_crtc_state;145 struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge);146 struct msm_dp *dp = dp_bridge->dp_display;147 148 /*149 * Check the old state of the crtc to determine if the panel150 * was put into psr state previously by the edp_bridge_atomic_disable.151 * If the panel is in psr, just exit psr state and skip the full152 * bridge enable sequence.153 */154 crtc = drm_atomic_get_new_crtc_for_encoder(atomic_state,155 drm_bridge->encoder);156 if (!crtc)157 return;158 159 old_crtc_state = drm_atomic_get_old_crtc_state(atomic_state, crtc);160 161 if (old_crtc_state && old_crtc_state->self_refresh_active) {162 dp_display_set_psr(dp, false);163 return;164 }165 166 dp_bridge_atomic_enable(drm_bridge, old_bridge_state);167}168 169static void edp_bridge_atomic_disable(struct drm_bridge *drm_bridge,170 struct drm_bridge_state *old_bridge_state)171{172 struct drm_atomic_state *atomic_state = old_bridge_state->base.state;173 struct drm_crtc *crtc;174 struct drm_crtc_state *new_crtc_state = NULL, *old_crtc_state = NULL;175 struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge);176 struct msm_dp *dp = dp_bridge->dp_display;177 178 crtc = drm_atomic_get_old_crtc_for_encoder(atomic_state,179 drm_bridge->encoder);180 if (!crtc)181 goto out;182 183 new_crtc_state = drm_atomic_get_new_crtc_state(atomic_state, crtc);184 if (!new_crtc_state)185 goto out;186 187 old_crtc_state = drm_atomic_get_old_crtc_state(atomic_state, crtc);188 if (!old_crtc_state)189 goto out;190 191 /*192 * Set self refresh mode if current crtc state is active.193 *194 * If old crtc state is active, then this is a display disable195 * call while the sink is in psr state. So, exit psr here.196 * The eDP controller will be disabled in the197 * edp_bridge_atomic_post_disable function.198 *199 * We observed sink is stuck in self refresh if psr exit is skipped200 * when display disable occurs while the sink is in psr state.201 */202 if (new_crtc_state->self_refresh_active) {203 dp_display_set_psr(dp, true);204 return;205 } else if (old_crtc_state->self_refresh_active) {206 dp_display_set_psr(dp, false);207 return;208 }209 210out:211 dp_bridge_atomic_disable(drm_bridge, old_bridge_state);212}213 214static void edp_bridge_atomic_post_disable(struct drm_bridge *drm_bridge,215 struct drm_bridge_state *old_bridge_state)216{217 struct drm_atomic_state *atomic_state = old_bridge_state->base.state;218 struct drm_crtc *crtc;219 struct drm_crtc_state *new_crtc_state = NULL;220 221 crtc = drm_atomic_get_old_crtc_for_encoder(atomic_state,222 drm_bridge->encoder);223 if (!crtc)224 return;225 226 new_crtc_state = drm_atomic_get_new_crtc_state(atomic_state, crtc);227 if (!new_crtc_state)228 return;229 230 /*231 * Self refresh mode is already set in edp_bridge_atomic_disable.232 */233 if (new_crtc_state->self_refresh_active)234 return;235 236 dp_bridge_atomic_post_disable(drm_bridge, old_bridge_state);237}238 239/**240 * edp_bridge_mode_valid - callback to determine if specified mode is valid241 * @bridge: Pointer to drm bridge structure242 * @info: display info243 * @mode: Pointer to drm mode structure244 * Returns: Validity status for specified mode245 */246static enum drm_mode_status edp_bridge_mode_valid(struct drm_bridge *bridge,247 const struct drm_display_info *info,248 const struct drm_display_mode *mode)249{250 struct msm_dp *dp;251 int mode_pclk_khz = mode->clock;252 253 dp = to_dp_bridge(bridge)->dp_display;254 255 if (!dp || !mode_pclk_khz || !dp->connector) {256 DRM_ERROR("invalid params\n");257 return -EINVAL;258 }259 260 if (mode->clock > DP_MAX_PIXEL_CLK_KHZ)261 return MODE_CLOCK_HIGH;262 263 /*264 * The eDP controller currently does not have a reliable way of265 * enabling panel power to read sink capabilities. So, we rely266 * on the panel driver to populate only supported modes for now.267 */268 return MODE_OK;269}270 271static void edp_bridge_debugfs_init(struct drm_bridge *bridge, struct dentry *root)272{273 struct msm_dp *dp = to_dp_bridge(bridge)->dp_display;274 275 dp_display_debugfs_init(dp, root, true);276}277 278static const struct drm_bridge_funcs edp_bridge_ops = {279 .atomic_enable = edp_bridge_atomic_enable,280 .atomic_disable = edp_bridge_atomic_disable,281 .atomic_post_disable = edp_bridge_atomic_post_disable,282 .mode_set = dp_bridge_mode_set,283 .mode_valid = edp_bridge_mode_valid,284 .atomic_reset = drm_atomic_helper_bridge_reset,285 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,286 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,287 .atomic_check = edp_bridge_atomic_check,288 .debugfs_init = edp_bridge_debugfs_init,289};290 291int dp_bridge_init(struct msm_dp *dp_display, struct drm_device *dev,292 struct drm_encoder *encoder)293{294 int rc;295 struct msm_dp_bridge *dp_bridge;296 struct drm_bridge *bridge;297 298 dp_bridge = devm_kzalloc(dev->dev, sizeof(*dp_bridge), GFP_KERNEL);299 if (!dp_bridge)300 return -ENOMEM;301 302 dp_bridge->dp_display = dp_display;303 304 bridge = &dp_bridge->bridge;305 bridge->funcs = dp_display->is_edp ? &edp_bridge_ops : &dp_bridge_ops;306 bridge->type = dp_display->connector_type;307 308 /*309 * Many ops only make sense for DP. Why?310 * - Detect/HPD are used by DRM to know if a display is _physically_311 * there, not whether the display is powered on / finished initting.312 * On eDP we assume the display is always there because you can't313 * know until power is applied. If we don't implement the ops DRM will314 * assume our display is always there.315 * - Currently eDP mode reading is driven by the panel driver. This316 * allows the panel driver to properly power itself on to read the317 * modes.318 */319 if (!dp_display->is_edp) {320 bridge->ops =321 DRM_BRIDGE_OP_DETECT |322 DRM_BRIDGE_OP_HPD |323 DRM_BRIDGE_OP_MODES;324 }325 326 rc = devm_drm_bridge_add(dev->dev, bridge);327 if (rc) {328 DRM_ERROR("failed to add bridge, rc=%d\n", rc);329 330 return rc;331 }332 333 rc = drm_bridge_attach(encoder, bridge, NULL, DRM_BRIDGE_ATTACH_NO_CONNECTOR);334 if (rc) {335 DRM_ERROR("failed to attach bridge, rc=%d\n", rc);336 337 return rc;338 }339 340 if (dp_display->next_bridge) {341 rc = drm_bridge_attach(encoder,342 dp_display->next_bridge, bridge,343 DRM_BRIDGE_ATTACH_NO_CONNECTOR);344 if (rc < 0) {345 DRM_ERROR("failed to attach panel bridge: %d\n", rc);346 return rc;347 }348 }349 350 return 0;351}352 353/* connector initialization */354struct drm_connector *dp_drm_connector_init(struct msm_dp *dp_display, struct drm_encoder *encoder,355 bool yuv_supported)356{357 struct drm_connector *connector = NULL;358 359 connector = drm_bridge_connector_init(dp_display->drm_dev, encoder);360 if (IS_ERR(connector))361 return connector;362 363 if (!dp_display->is_edp)364 drm_connector_attach_dp_subconnector_property(connector);365 366 if (yuv_supported)367 connector->ycbcr_420_allowed = true;368 369 drm_connector_attach_encoder(connector, encoder);370 371 return connector;372}373