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         .enable       = dp_bridge_enable,
  98         .disable      = dp_bridge_disable,
  99         .post_disable = dp_bridge_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 };
 106
 107 struct drm_bridge *dp_bridge_init(struct msm_dp *dp_display, struct drm_device *dev,
 108                         struct drm_encoder *encoder)
 109 {
 110         int rc;
 111         struct msm_dp_bridge *dp_bridge;
 112         struct drm_bridge *bridge;
 113
 114         dp_bridge = devm_kzalloc(dev->dev, sizeof(*dp_bridge), GFP_KERNEL);
 115         if (!dp_bridge)
 116                 return ERR_PTR(-ENOMEM);
 117
 118         dp_bridge->dp_display = dp_display;
 119
 120         bridge = &dp_bridge->bridge;
 121         bridge->funcs = &dp_bridge_ops;
 122         bridge->type = dp_display->connector_type;
 123
 124         /*
 125          * Many ops only make sense for DP. Why?
 126          * - Detect/HPD are used by DRM to know if a display is _physically_
 127          *   there, not whether the display is powered on / finished initting.
 128          *   On eDP we assume the display is always there because you can't
 129          *   know until power is applied. If we don't implement the ops DRM will
 130          *   assume our display is always there.
 131          * - Currently eDP mode reading is driven by the panel driver. This
 132          *   allows the panel driver to properly power itself on to read the
 133          *   modes.
 134          */
 135         if (!dp_display->is_edp) {
 136                 bridge->ops =
 137                         DRM_BRIDGE_OP_DETECT |
 138                         DRM_BRIDGE_OP_HPD |
 139                         DRM_BRIDGE_OP_MODES;
 140         }
 141
 142         drm_bridge_add(bridge);
 143
 144         rc = drm_bridge_attach(encoder, bridge, NULL, DRM_BRIDGE_ATTACH_NO_CONNECTOR);
 145         if (rc) {
 146                 DRM_ERROR("failed to attach bridge, rc=%d\n", rc);
 147                 drm_bridge_remove(bridge);
 148
 149                 return ERR_PTR(rc);
 150         }
 151
 152         if (dp_display->next_bridge) {
 153                 rc = drm_bridge_attach(encoder,
 154                                         dp_display->next_bridge, bridge,
 155                                         DRM_BRIDGE_ATTACH_NO_CONNECTOR);
 156                 if (rc < 0) {
 157                         DRM_ERROR("failed to attach panel bridge: %d\n", rc);
 158                         drm_bridge_remove(bridge);
 159                         return ERR_PTR(rc);
 160                 }
 161         }
 162
 163         return bridge;
 164 }
 165
 166 /* connector initialization */
 167 struct drm_connector *dp_drm_connector_init(struct msm_dp *dp_display, struct drm_encoder *encoder)
 168 {
 169         struct drm_connector *connector = NULL;
 170
 171         connector = drm_bridge_connector_init(dp_display->drm_dev, encoder);
 172         if (IS_ERR(connector))
 173                 return connector;
 174
 175         drm_connector_attach_encoder(connector, encoder);
 176
 177         return connector;
 178 }