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         drm_connector_attach_encoder(connector, encoder);
 349
 350         return connector;
 351 }