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_crtc.h>
  10
  11 #include "msm_drv.h"
  12 #include "msm_kms.h"
  13 #include "dp_drm.h"
  14
  15 struct dp_connector {
  16         struct drm_connector base;
  17         struct msm_dp *dp_display;
  18 };
  19 #define to_dp_connector(x) container_of(x, struct dp_connector, base)
  20
  21 /**
  22  * dp_connector_detect - callback to determine if connector is connected
  23  * @conn: Pointer to drm connector structure
  24  * @force: Force detect setting from drm framework
  25  * Returns: Connector 'is connected' status
  26  */
  27 static enum drm_connector_status dp_connector_detect(struct drm_connector *conn,
  28                 bool force)
  29 {
  30         struct msm_dp *dp;
  31
  32         dp = to_dp_connector(conn)->dp_display;
  33
  34         DRM_DEBUG_DP("is_connected = %s\n",
  35                 (dp->is_connected) ? "true" : "false");
  36
  37         return (dp->is_connected) ? connector_status_connected :
  38                                         connector_status_disconnected;
  39 }
  40
  41 /**
  42  * dp_connector_get_modes - callback to add drm modes via drm_mode_probed_add()
  43  * @connector: Pointer to drm connector structure
  44  * Returns: Number of modes added
  45  */
  46 static int dp_connector_get_modes(struct drm_connector *connector)
  47 {
  48         int rc = 0;
  49         struct msm_dp *dp;
  50         struct dp_display_mode *dp_mode = NULL;
  51         struct drm_display_mode *m, drm_mode;
  52
  53         if (!connector)
  54                 return 0;
  55
  56         dp = to_dp_connector(connector)->dp_display;
  57
  58         dp_mode = kzalloc(sizeof(*dp_mode),  GFP_KERNEL);
  59         if (!dp_mode)
  60                 return 0;
  61
  62         /* pluggable case assumes EDID is read when HPD */
  63         if (dp->is_connected) {
  64                 /*
  65                  *The get_modes() function might return one mode that is stored
  66                  * in dp_mode when compliance test is in progress. If not, the
  67                  * return value is equal to the total number of modes supported
  68                  * by the sink
  69                  */
  70                 rc = dp_display_get_modes(dp, dp_mode);
  71                 if (rc <= 0) {
  72                         DRM_ERROR("failed to get DP sink modes, rc=%d\n", rc);
  73                         kfree(dp_mode);
  74                         return rc;
  75                 }
  76                 if (dp_mode->drm_mode.clock) { /* valid DP mode */
  77                         memset(&drm_mode, 0x0, sizeof(drm_mode));
  78                         drm_mode_copy(&drm_mode, &dp_mode->drm_mode);
  79                         m = drm_mode_duplicate(connector->dev, &drm_mode);
  80                         if (!m) {
  81                                 DRM_ERROR("failed to add mode %ux%u\n",
  82                                        drm_mode.hdisplay,
  83                                        drm_mode.vdisplay);
  84                                 kfree(dp_mode);
  85                                 return 0;
  86                         }
  87                         drm_mode_probed_add(connector, m);
  88                 }
  89         } else {
  90                 DRM_DEBUG_DP("No sink connected\n");
  91         }
  92         kfree(dp_mode);
  93         return rc;
  94 }
  95
  96 /**
  97  * dp_connector_mode_valid - callback to determine if specified mode is valid
  98  * @connector: Pointer to drm connector structure
  99  * @mode: Pointer to drm mode structure
 100  * Returns: Validity status for specified mode
 101  */
 102 static enum drm_mode_status dp_connector_mode_valid(
 103                 struct drm_connector *connector,
 104                 struct drm_display_mode *mode)
 105 {
 106         struct msm_dp *dp_disp;
 107
 108         dp_disp = to_dp_connector(connector)->dp_display;
 109
 110         if ((dp_disp->max_pclk_khz <= 0) ||
 111                         (dp_disp->max_pclk_khz > DP_MAX_PIXEL_CLK_KHZ) ||
 112                         (mode->clock > dp_disp->max_pclk_khz))
 113                 return MODE_BAD;
 114
 115         return dp_display_validate_mode(dp_disp, mode->clock);
 116 }
 117
 118 static const struct drm_connector_funcs dp_connector_funcs = {
 119         .detect = dp_connector_detect,
 120         .fill_modes = drm_helper_probe_single_connector_modes,
 121         .destroy = drm_connector_cleanup,
 122         .reset = drm_atomic_helper_connector_reset,
 123         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 124         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 125 };
 126
 127 static const struct drm_connector_helper_funcs dp_connector_helper_funcs = {
 128         .get_modes = dp_connector_get_modes,
 129         .mode_valid = dp_connector_mode_valid,
 130 };
 131
 132 /* connector initialization */
 133 struct drm_connector *dp_drm_connector_init(struct msm_dp *dp_display)
 134 {
 135         struct drm_connector *connector = NULL;
 136         struct dp_connector *dp_connector;
 137         int ret;
 138
 139         dp_connector = devm_kzalloc(dp_display->drm_dev->dev,
 140                                         sizeof(*dp_connector),
 141                                         GFP_KERNEL);
 142         if (!dp_connector)
 143                 return ERR_PTR(-ENOMEM);
 144
 145         dp_connector->dp_display = dp_display;
 146
 147         connector = &dp_connector->base;
 148
 149         ret = drm_connector_init(dp_display->drm_dev, connector,
 150                         &dp_connector_funcs,
 151                         dp_display->connector_type);
 152         if (ret)
 153                 return ERR_PTR(ret);
 154
 155         drm_connector_helper_add(connector, &dp_connector_helper_funcs);
 156
 157         /*
 158          * Enable HPD to let hpd event is handled when cable is connected.
 159          */
 160         connector->polled = DRM_CONNECTOR_POLL_HPD;
 161
 162         drm_connector_attach_encoder(connector, dp_display->encoder);
 163
 164         if (dp_display->panel_bridge) {
 165                 ret = drm_bridge_attach(dp_display->encoder,
 166                                         dp_display->panel_bridge, NULL,
 167                                         DRM_BRIDGE_ATTACH_NO_CONNECTOR);
 168                 if (ret < 0) {
 169                         DRM_ERROR("failed to attach panel bridge: %d\n", ret);
 170                         return ERR_PTR(ret);
 171                 }
 172         }
 173
 174         return connector;
 175 }