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 */
dp_connector_detect(struct drm_connector * conn,bool force)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 */
dp_connector_get_modes(struct drm_connector * connector)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 */
dp_connector_mode_valid(struct drm_connector * connector,struct drm_display_mode * mode)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 */
dp_drm_connector_init(struct msm_dp * dp_display)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 }
176