1 /*
2 * drivers/gpu/drm/omapdrm/omap_connector.c
3 *
4 * Copyright (C) 2011 Texas Instruments
5 * Author: Rob Clark <rob@ti.com>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 as published by
9 * the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <drm/drm_atomic_helper.h>
21 #include <drm/drm_crtc.h>
22 #include <drm/drm_crtc_helper.h>
23
24 #include "omap_drv.h"
25
26 /*
27 * connector funcs
28 */
29
30 #define to_omap_connector(x) container_of(x, struct omap_connector, base)
31
32 struct omap_connector {
33 struct drm_connector base;
34 struct omap_dss_device *dssdev;
35 bool hdmi_mode;
36 };
37
omap_connector_hpd_cb(void * cb_data,enum drm_connector_status status)38 static void omap_connector_hpd_cb(void *cb_data,
39 enum drm_connector_status status)
40 {
41 struct omap_connector *omap_connector = cb_data;
42 struct drm_connector *connector = &omap_connector->base;
43 struct drm_device *dev = connector->dev;
44 enum drm_connector_status old_status;
45
46 mutex_lock(&dev->mode_config.mutex);
47 old_status = connector->status;
48 connector->status = status;
49 mutex_unlock(&dev->mode_config.mutex);
50
51 if (old_status != status)
52 drm_kms_helper_hotplug_event(dev);
53 }
54
omap_connector_get_hdmi_mode(struct drm_connector * connector)55 bool omap_connector_get_hdmi_mode(struct drm_connector *connector)
56 {
57 struct omap_connector *omap_connector = to_omap_connector(connector);
58
59 return omap_connector->hdmi_mode;
60 }
61
omap_connector_detect(struct drm_connector * connector,bool force)62 static enum drm_connector_status omap_connector_detect(
63 struct drm_connector *connector, bool force)
64 {
65 struct omap_connector *omap_connector = to_omap_connector(connector);
66 struct omap_dss_device *dssdev = omap_connector->dssdev;
67 struct omap_dss_driver *dssdrv = dssdev->driver;
68 enum drm_connector_status ret;
69
70 if (dssdrv->detect) {
71 if (dssdrv->detect(dssdev))
72 ret = connector_status_connected;
73 else
74 ret = connector_status_disconnected;
75 } else if (dssdev->type == OMAP_DISPLAY_TYPE_DPI ||
76 dssdev->type == OMAP_DISPLAY_TYPE_DBI ||
77 dssdev->type == OMAP_DISPLAY_TYPE_SDI ||
78 dssdev->type == OMAP_DISPLAY_TYPE_DSI) {
79 ret = connector_status_connected;
80 } else {
81 ret = connector_status_unknown;
82 }
83
84 VERB("%s: %d (force=%d)", omap_connector->dssdev->name, ret, force);
85
86 return ret;
87 }
88
omap_connector_destroy(struct drm_connector * connector)89 static void omap_connector_destroy(struct drm_connector *connector)
90 {
91 struct omap_connector *omap_connector = to_omap_connector(connector);
92 struct omap_dss_device *dssdev = omap_connector->dssdev;
93
94 DBG("%s", omap_connector->dssdev->name);
95 if (connector->polled == DRM_CONNECTOR_POLL_HPD &&
96 dssdev->driver->unregister_hpd_cb) {
97 dssdev->driver->unregister_hpd_cb(dssdev);
98 }
99 drm_connector_unregister(connector);
100 drm_connector_cleanup(connector);
101 kfree(omap_connector);
102
103 omap_dss_put_device(dssdev);
104 }
105
106 #define MAX_EDID 512
107
omap_connector_get_modes(struct drm_connector * connector)108 static int omap_connector_get_modes(struct drm_connector *connector)
109 {
110 struct omap_connector *omap_connector = to_omap_connector(connector);
111 struct omap_dss_device *dssdev = omap_connector->dssdev;
112 struct omap_dss_driver *dssdrv = dssdev->driver;
113 struct drm_device *dev = connector->dev;
114 int n = 0;
115
116 DBG("%s", omap_connector->dssdev->name);
117
118 /* if display exposes EDID, then we parse that in the normal way to
119 * build table of supported modes.. otherwise (ie. fixed resolution
120 * LCD panels) we just return a single mode corresponding to the
121 * currently configured timings:
122 */
123 if (dssdrv->read_edid) {
124 void *edid = kzalloc(MAX_EDID, GFP_KERNEL);
125
126 if (!edid)
127 return 0;
128
129 if ((dssdrv->read_edid(dssdev, edid, MAX_EDID) > 0) &&
130 drm_edid_is_valid(edid)) {
131 drm_mode_connector_update_edid_property(
132 connector, edid);
133 n = drm_add_edid_modes(connector, edid);
134
135 omap_connector->hdmi_mode =
136 drm_detect_hdmi_monitor(edid);
137 } else {
138 drm_mode_connector_update_edid_property(
139 connector, NULL);
140 }
141
142 kfree(edid);
143 } else {
144 struct drm_display_mode *mode = drm_mode_create(dev);
145 struct videomode vm = {0};
146
147 if (!mode)
148 return 0;
149
150 dssdrv->get_timings(dssdev, &vm);
151
152 drm_display_mode_from_videomode(&vm, mode);
153
154 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
155 drm_mode_set_name(mode);
156 drm_mode_probed_add(connector, mode);
157
158 n = 1;
159 }
160
161 return n;
162 }
163
omap_connector_mode_valid(struct drm_connector * connector,struct drm_display_mode * mode)164 static int omap_connector_mode_valid(struct drm_connector *connector,
165 struct drm_display_mode *mode)
166 {
167 struct omap_connector *omap_connector = to_omap_connector(connector);
168 struct omap_dss_device *dssdev = omap_connector->dssdev;
169 struct omap_dss_driver *dssdrv = dssdev->driver;
170 struct videomode vm = {0};
171 struct drm_device *dev = connector->dev;
172 struct drm_display_mode *new_mode;
173 int r, ret = MODE_BAD;
174
175 drm_display_mode_to_videomode(mode, &vm);
176 mode->vrefresh = drm_mode_vrefresh(mode);
177
178 /*
179 * if the panel driver doesn't have a check_timings, it's most likely
180 * a fixed resolution panel, check if the timings match with the
181 * panel's timings
182 */
183 if (dssdrv->check_timings) {
184 r = dssdrv->check_timings(dssdev, &vm);
185 } else {
186 struct videomode t = {0};
187
188 dssdrv->get_timings(dssdev, &t);
189
190 /*
191 * Ignore the flags, as we don't get them from
192 * drm_display_mode_to_videomode.
193 */
194 t.flags = 0;
195
196 if (memcmp(&vm, &t, sizeof(vm)))
197 r = -EINVAL;
198 else
199 r = 0;
200 }
201
202 if (!r) {
203 /* check if vrefresh is still valid */
204 new_mode = drm_mode_duplicate(dev, mode);
205
206 if (!new_mode)
207 return MODE_BAD;
208
209 new_mode->clock = vm.pixelclock / 1000;
210 new_mode->vrefresh = 0;
211 if (mode->vrefresh == drm_mode_vrefresh(new_mode))
212 ret = MODE_OK;
213 drm_mode_destroy(dev, new_mode);
214 }
215
216 DBG("connector: mode %s: "
217 "%d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x",
218 (ret == MODE_OK) ? "valid" : "invalid",
219 mode->base.id, mode->name, mode->vrefresh, mode->clock,
220 mode->hdisplay, mode->hsync_start,
221 mode->hsync_end, mode->htotal,
222 mode->vdisplay, mode->vsync_start,
223 mode->vsync_end, mode->vtotal, mode->type, mode->flags);
224
225 return ret;
226 }
227
228 static const struct drm_connector_funcs omap_connector_funcs = {
229 .reset = drm_atomic_helper_connector_reset,
230 .detect = omap_connector_detect,
231 .fill_modes = drm_helper_probe_single_connector_modes,
232 .destroy = omap_connector_destroy,
233 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
234 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
235 };
236
237 static const struct drm_connector_helper_funcs omap_connector_helper_funcs = {
238 .get_modes = omap_connector_get_modes,
239 .mode_valid = omap_connector_mode_valid,
240 };
241
242 /* initialize connector */
omap_connector_init(struct drm_device * dev,int connector_type,struct omap_dss_device * dssdev,struct drm_encoder * encoder)243 struct drm_connector *omap_connector_init(struct drm_device *dev,
244 int connector_type, struct omap_dss_device *dssdev,
245 struct drm_encoder *encoder)
246 {
247 struct drm_connector *connector = NULL;
248 struct omap_connector *omap_connector;
249 bool hpd_supported = false;
250
251 DBG("%s", dssdev->name);
252
253 omap_dss_get_device(dssdev);
254
255 omap_connector = kzalloc(sizeof(*omap_connector), GFP_KERNEL);
256 if (!omap_connector)
257 goto fail;
258
259 omap_connector->dssdev = dssdev;
260
261 connector = &omap_connector->base;
262
263 drm_connector_init(dev, connector, &omap_connector_funcs,
264 connector_type);
265 drm_connector_helper_add(connector, &omap_connector_helper_funcs);
266
267 if (dssdev->driver->register_hpd_cb) {
268 int ret = dssdev->driver->register_hpd_cb(dssdev,
269 omap_connector_hpd_cb,
270 omap_connector);
271 if (!ret)
272 hpd_supported = true;
273 else if (ret != -ENOTSUPP)
274 DBG("%s: Failed to register HPD callback (%d).",
275 dssdev->name, ret);
276 }
277
278 if (hpd_supported)
279 connector->polled = DRM_CONNECTOR_POLL_HPD;
280 else if (dssdev->driver->detect)
281 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
282 DRM_CONNECTOR_POLL_DISCONNECT;
283 else
284 connector->polled = 0;
285
286 connector->interlace_allowed = 1;
287 connector->doublescan_allowed = 0;
288
289 return connector;
290
291 fail:
292 if (connector)
293 omap_connector_destroy(connector);
294
295 return NULL;
296 }
297