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