blob: 06c48a64b7456157ade7855f6a991753ef2d6d52 [file] [log] [blame]
Rob Clarkcd5351f2011-11-12 12:09:40 -06001/*
Andrew F. Davisbb5cdf82017-12-05 14:29:31 -06002 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
Rob Clarkcd5351f2011-11-12 12:09:40 -06003 * Author: Rob Clark <rob@ti.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
Laurent Pinchart69a12262015-03-05 21:38:16 +020018#include <drm/drm_atomic_helper.h>
Laurent Pinchart2d278f52015-03-05 21:31:37 +020019#include <drm/drm_crtc.h>
20#include <drm/drm_crtc_helper.h>
Rob Clarkcd5351f2011-11-12 12:09:40 -060021
Laurent Pinchart2d278f52015-03-05 21:31:37 +020022#include "omap_drv.h"
Rob Clarkcd5351f2011-11-12 12:09:40 -060023
24/*
25 * connector funcs
26 */
27
28#define to_omap_connector(x) container_of(x, struct omap_connector, base)
29
30struct omap_connector {
31 struct drm_connector base;
Laurent Pinchart47a3ee22018-05-31 23:14:43 +030032 struct omap_dss_device *output;
33 struct omap_dss_device *display;
Laurent Pinchart18412b62018-05-30 21:46:44 +030034 struct omap_dss_device *hpd;
Tomi Valkeinen4f930c02014-06-18 14:19:48 +030035 bool hdmi_mode;
Rob Clarkcd5351f2011-11-12 12:09:40 -060036};
37
Laurent Pinchartf0063252018-05-30 16:53:43 +030038static void omap_connector_hpd_notify(struct drm_connector *connector,
39 struct omap_dss_device *src,
40 enum drm_connector_status status)
41{
42 if (status == connector_status_disconnected) {
43 /*
44 * If the source is an HDMI encoder, notify it of disconnection.
45 * This is required to let the HDMI encoder reset any internal
46 * state related to connection status, such as the CEC address.
47 */
48 if (src && src->type == OMAP_DISPLAY_TYPE_HDMI &&
49 src->ops->hdmi.lost_hotplug)
50 src->ops->hdmi.lost_hotplug(src);
51 }
52}
53
Peter Ujfalusi3c596802017-06-02 15:26:35 +030054static void omap_connector_hpd_cb(void *cb_data,
55 enum drm_connector_status status)
56{
57 struct omap_connector *omap_connector = cb_data;
58 struct drm_connector *connector = &omap_connector->base;
59 struct drm_device *dev = connector->dev;
60 enum drm_connector_status old_status;
61
62 mutex_lock(&dev->mode_config.mutex);
63 old_status = connector->status;
64 connector->status = status;
65 mutex_unlock(&dev->mode_config.mutex);
66
Laurent Pinchartf0063252018-05-30 16:53:43 +030067 if (old_status == status)
68 return;
69
70 omap_connector_hpd_notify(connector, omap_connector->hpd, status);
71
72 drm_kms_helper_hotplug_event(dev);
Peter Ujfalusi3c596802017-06-02 15:26:35 +030073}
74
Laurent Pinchart18412b62018-05-30 21:46:44 +030075void omap_connector_enable_hpd(struct drm_connector *connector)
76{
77 struct omap_connector *omap_connector = to_omap_connector(connector);
78 struct omap_dss_device *hpd = omap_connector->hpd;
79
80 if (hpd)
81 hpd->ops->register_hpd_cb(hpd, omap_connector_hpd_cb,
82 omap_connector);
83}
84
85void omap_connector_disable_hpd(struct drm_connector *connector)
86{
87 struct omap_connector *omap_connector = to_omap_connector(connector);
88 struct omap_dss_device *hpd = omap_connector->hpd;
89
90 if (hpd)
91 hpd->ops->unregister_hpd_cb(hpd);
92}
93
Tomi Valkeinen4f930c02014-06-18 14:19:48 +030094bool omap_connector_get_hdmi_mode(struct drm_connector *connector)
95{
96 struct omap_connector *omap_connector = to_omap_connector(connector);
97
98 return omap_connector->hdmi_mode;
99}
100
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300101static struct omap_dss_device *
102omap_connector_find_device(struct drm_connector *connector,
103 enum omap_dss_device_ops_flag op)
104{
105 struct omap_connector *omap_connector = to_omap_connector(connector);
106 struct omap_dss_device *dssdev;
107
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300108 for (dssdev = omap_connector->display; dssdev; dssdev = dssdev->src) {
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300109 if (dssdev->ops_flags & op)
110 return dssdev;
111 }
112
113 return NULL;
114}
115
Rob Clarkf5f94542012-12-04 13:59:12 -0600116static enum drm_connector_status omap_connector_detect(
Rob Clarkcd5351f2011-11-12 12:09:40 -0600117 struct drm_connector *connector, bool force)
118{
119 struct omap_connector *omap_connector = to_omap_connector(connector);
Laurent Pinchartf2ea5572018-05-28 16:49:36 +0300120 struct omap_dss_device *dssdev;
121 enum drm_connector_status status;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600122
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300123 dssdev = omap_connector_find_device(connector,
124 OMAP_DSS_DEVICE_OP_DETECT);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600125
Laurent Pinchartf2ea5572018-05-28 16:49:36 +0300126 if (dssdev) {
Laurent Pinchartf0063252018-05-30 16:53:43 +0300127 status = dssdev->ops->detect(dssdev)
128 ? connector_status_connected
129 : connector_status_disconnected;
130
131 omap_connector_hpd_notify(connector, dssdev->src, status);
Laurent Pinchartf2ea5572018-05-28 16:49:36 +0300132 } else {
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300133 switch (omap_connector->display->type) {
Laurent Pinchartf2ea5572018-05-28 16:49:36 +0300134 case OMAP_DISPLAY_TYPE_DPI:
135 case OMAP_DISPLAY_TYPE_DBI:
136 case OMAP_DISPLAY_TYPE_SDI:
137 case OMAP_DISPLAY_TYPE_DSI:
138 status = connector_status_connected;
139 break;
140 default:
141 status = connector_status_unknown;
142 break;
143 }
144 }
Rob Clarkcd5351f2011-11-12 12:09:40 -0600145
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300146 VERB("%s: %d (force=%d)", omap_connector->display->name, status, force);
Laurent Pinchartf2ea5572018-05-28 16:49:36 +0300147
148 return status;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600149}
150
151static void omap_connector_destroy(struct drm_connector *connector)
152{
153 struct omap_connector *omap_connector = to_omap_connector(connector);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600154
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300155 DBG("%s", omap_connector->display->name);
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300156
Laurent Pinchart18412b62018-05-30 21:46:44 +0300157 if (omap_connector->hpd) {
158 struct omap_dss_device *hpd = omap_connector->hpd;
159
160 hpd->ops->unregister_hpd_cb(hpd);
161 omapdss_device_put(hpd);
162 omap_connector->hpd = NULL;
Peter Ujfalusi3c596802017-06-02 15:26:35 +0300163 }
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300164
Thomas Wood34ea3d32014-05-29 16:57:41 +0100165 drm_connector_unregister(connector);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600166 drm_connector_cleanup(connector);
167 kfree(omap_connector);
168
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300169 omapdss_device_put(omap_connector->output);
170 omapdss_device_put(omap_connector->display);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600171}
172
173#define MAX_EDID 512
174
Laurent Pinchart90279e92018-05-31 22:09:14 +0300175static int omap_connector_get_modes_edid(struct drm_connector *connector,
176 struct omap_dss_device *dssdev)
177{
178 struct omap_connector *omap_connector = to_omap_connector(connector);
179 enum drm_connector_status status;
180 void *edid;
181 int n;
182
183 status = omap_connector_detect(connector, false);
184 if (status != connector_status_connected)
185 goto no_edid;
186
187 edid = kzalloc(MAX_EDID, GFP_KERNEL);
188 if (!edid)
189 goto no_edid;
190
191 if (dssdev->ops->read_edid(dssdev, edid, MAX_EDID) <= 0 ||
192 !drm_edid_is_valid(edid)) {
193 kfree(edid);
194 goto no_edid;
195 }
196
197 drm_connector_update_edid_property(connector, edid);
198 n = drm_add_edid_modes(connector, edid);
199
200 omap_connector->hdmi_mode = drm_detect_hdmi_monitor(edid);
201
202 kfree(edid);
203 return n;
204
205no_edid:
206 drm_connector_update_edid_property(connector, NULL);
207 return 0;
208}
209
Rob Clarkcd5351f2011-11-12 12:09:40 -0600210static int omap_connector_get_modes(struct drm_connector *connector)
211{
212 struct omap_connector *omap_connector = to_omap_connector(connector);
Laurent Pinchart90279e92018-05-31 22:09:14 +0300213 struct omap_dss_device *dssdev;
214 struct drm_display_mode *mode;
215 struct videomode vm = {0};
Rob Clarkcd5351f2011-11-12 12:09:40 -0600216
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300217 DBG("%s", omap_connector->display->name);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600218
Laurent Pinchart90279e92018-05-31 22:09:14 +0300219 /*
220 * If display exposes EDID, then we parse that in the normal way to
221 * build table of supported modes. Otherwise (ie. fixed resolution
Rob Clarkcd5351f2011-11-12 12:09:40 -0600222 * LCD panels) we just return a single mode corresponding to the
Laurent Pinchart90279e92018-05-31 22:09:14 +0300223 * currently configured timings.
Rob Clarkcd5351f2011-11-12 12:09:40 -0600224 */
Laurent Pinchart90279e92018-05-31 22:09:14 +0300225 dssdev = omap_connector_find_device(connector,
226 OMAP_DSS_DEVICE_OP_EDID);
227 if (dssdev)
228 return omap_connector_get_modes_edid(connector, dssdev);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600229
Laurent Pinchart90279e92018-05-31 22:09:14 +0300230 mode = drm_mode_create(connector->dev);
231 if (!mode)
232 return 0;
Tomi Valkeinen47aaaec2018-05-02 12:11:59 +0300233
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300234 dssdev = omap_connector->display;
Laurent Pinchart90279e92018-05-31 22:09:14 +0300235 dssdev->ops->get_timings(dssdev, &vm);
Tomi Valkeinen4f930c02014-06-18 14:19:48 +0300236
Laurent Pinchart90279e92018-05-31 22:09:14 +0300237 drm_display_mode_from_videomode(&vm, mode);
Tomi Valkeinen4f930c02014-06-18 14:19:48 +0300238
Laurent Pinchart90279e92018-05-31 22:09:14 +0300239 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
240 drm_mode_set_name(mode);
241 drm_mode_probed_add(connector, mode);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600242
Laurent Pinchart90279e92018-05-31 22:09:14 +0300243 if (dssdev->driver && dssdev->driver->get_size)
244 dssdev->driver->get_size(dssdev,
Sebastian Reichelb070d6e2017-07-24 19:33:04 +0200245 &connector->display_info.width_mm,
246 &connector->display_info.height_mm);
Sebastian Reichelb070d6e2017-07-24 19:33:04 +0200247
Laurent Pinchart90279e92018-05-31 22:09:14 +0300248 return 1;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600249}
250
251static int omap_connector_mode_valid(struct drm_connector *connector,
252 struct drm_display_mode *mode)
253{
254 struct omap_connector *omap_connector = to_omap_connector(connector);
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300255 struct omap_dss_device *dssdev = omap_connector->display;
Peter Ujfalusida11bbbb2016-09-22 14:07:04 +0300256 struct videomode vm = {0};
Rob Clarkcd5351f2011-11-12 12:09:40 -0600257 struct drm_device *dev = connector->dev;
258 struct drm_display_mode *new_mode;
Archit Tanejabddabbe2013-03-26 19:15:20 +0530259 int r, ret = MODE_BAD;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600260
Peter Ujfalusida11bbbb2016-09-22 14:07:04 +0300261 drm_display_mode_to_videomode(mode, &vm);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600262 mode->vrefresh = drm_mode_vrefresh(mode);
263
Archit Tanejabddabbe2013-03-26 19:15:20 +0530264 /*
265 * if the panel driver doesn't have a check_timings, it's most likely
266 * a fixed resolution panel, check if the timings match with the
267 * panel's timings
268 */
Laurent Pinchart83910ad2018-06-01 19:45:01 +0300269 if (dssdev->ops->check_timings) {
270 r = dssdev->ops->check_timings(dssdev, &vm);
Archit Tanejabddabbe2013-03-26 19:15:20 +0530271 } else {
Peter Ujfalusi4520ff22016-09-22 14:07:03 +0300272 struct videomode t = {0};
Archit Tanejabddabbe2013-03-26 19:15:20 +0530273
Laurent Pinchart83910ad2018-06-01 19:45:01 +0300274 dssdev->ops->get_timings(dssdev, &t);
Archit Tanejabddabbe2013-03-26 19:15:20 +0530275
Tomi Valkeinen50fa9f02016-11-23 13:24:00 +0200276 /*
277 * Ignore the flags, as we don't get them from
278 * drm_display_mode_to_videomode.
279 */
280 t.flags = 0;
281
Laurent Pinchartd501b122016-12-12 11:57:24 +0200282 if (memcmp(&vm, &t, sizeof(vm)))
Archit Tanejabddabbe2013-03-26 19:15:20 +0530283 r = -EINVAL;
284 else
285 r = 0;
286 }
287
288 if (!r) {
Rob Clarkcd5351f2011-11-12 12:09:40 -0600289 /* check if vrefresh is still valid */
290 new_mode = drm_mode_duplicate(dev, mode);
Tomi Valkeinen47aaaec2018-05-02 12:11:59 +0300291
292 if (!new_mode)
293 return MODE_BAD;
294
Peter Ujfalusida11bbbb2016-09-22 14:07:04 +0300295 new_mode->clock = vm.pixelclock / 1000;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600296 new_mode->vrefresh = 0;
297 if (mode->vrefresh == drm_mode_vrefresh(new_mode))
298 ret = MODE_OK;
299 drm_mode_destroy(dev, new_mode);
300 }
301
302 DBG("connector: mode %s: "
303 "%d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x",
304 (ret == MODE_OK) ? "valid" : "invalid",
305 mode->base.id, mode->name, mode->vrefresh, mode->clock,
306 mode->hdisplay, mode->hsync_start,
307 mode->hsync_end, mode->htotal,
308 mode->vdisplay, mode->vsync_start,
309 mode->vsync_end, mode->vtotal, mode->type, mode->flags);
310
311 return ret;
312}
313
Rob Clarkcd5351f2011-11-12 12:09:40 -0600314static const struct drm_connector_funcs omap_connector_funcs = {
Laurent Pinchart69a12262015-03-05 21:38:16 +0200315 .reset = drm_atomic_helper_connector_reset,
Rob Clarkcd5351f2011-11-12 12:09:40 -0600316 .detect = omap_connector_detect,
317 .fill_modes = drm_helper_probe_single_connector_modes,
318 .destroy = omap_connector_destroy,
Laurent Pinchart69a12262015-03-05 21:38:16 +0200319 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
320 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
Rob Clarkcd5351f2011-11-12 12:09:40 -0600321};
322
323static const struct drm_connector_helper_funcs omap_connector_helper_funcs = {
324 .get_modes = omap_connector_get_modes,
325 .mode_valid = omap_connector_mode_valid,
Rob Clarkcd5351f2011-11-12 12:09:40 -0600326};
327
Laurent Pinchart52c5dd22018-06-06 00:31:57 +0300328static int omap_connector_get_type(struct omap_dss_device *display)
329{
330 switch (display->type) {
331 case OMAP_DISPLAY_TYPE_HDMI:
332 return DRM_MODE_CONNECTOR_HDMIA;
333 case OMAP_DISPLAY_TYPE_DVI:
334 return DRM_MODE_CONNECTOR_DVID;
335 case OMAP_DISPLAY_TYPE_DSI:
336 return DRM_MODE_CONNECTOR_DSI;
337 case OMAP_DISPLAY_TYPE_DPI:
338 case OMAP_DISPLAY_TYPE_DBI:
339 return DRM_MODE_CONNECTOR_DPI;
340 case OMAP_DISPLAY_TYPE_VENC:
341 /* TODO: This could also be composite */
342 return DRM_MODE_CONNECTOR_SVIDEO;
343 case OMAP_DISPLAY_TYPE_SDI:
344 return DRM_MODE_CONNECTOR_LVDS;
345 default:
346 return DRM_MODE_CONNECTOR_Unknown;
347 }
348}
349
Rob Clarkcd5351f2011-11-12 12:09:40 -0600350/* initialize connector */
351struct drm_connector *omap_connector_init(struct drm_device *dev,
Laurent Pinchart52c5dd22018-06-06 00:31:57 +0300352 struct omap_dss_device *output,
353 struct omap_dss_device *display,
354 struct drm_encoder *encoder)
Rob Clarkcd5351f2011-11-12 12:09:40 -0600355{
356 struct drm_connector *connector = NULL;
357 struct omap_connector *omap_connector;
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300358 struct omap_dss_device *dssdev;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600359
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300360 DBG("%s", display->name);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600361
Laurent Pinchartd501b122016-12-12 11:57:24 +0200362 omap_connector = kzalloc(sizeof(*omap_connector), GFP_KERNEL);
Joe Perches78110bb2013-02-11 09:41:29 -0800363 if (!omap_connector)
Rob Clarkcd5351f2011-11-12 12:09:40 -0600364 goto fail;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600365
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300366 omap_connector->output = omapdss_device_get(output);
367 omap_connector->display = omapdss_device_get(display);
Rob Clarkf5f94542012-12-04 13:59:12 -0600368
Rob Clarkcd5351f2011-11-12 12:09:40 -0600369 connector = &omap_connector->base;
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300370 connector->interlace_allowed = 1;
371 connector->doublescan_allowed = 0;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600372
373 drm_connector_init(dev, connector, &omap_connector_funcs,
Laurent Pinchart52c5dd22018-06-06 00:31:57 +0300374 omap_connector_get_type(display));
Rob Clarkcd5351f2011-11-12 12:09:40 -0600375 drm_connector_helper_add(connector, &omap_connector_helper_funcs);
376
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300377 /*
378 * Initialize connector status handling. First try to find a device that
379 * supports hot-plug reporting. If it fails, fall back to a device that
380 * support polling. If that fails too, we don't support hot-plug
381 * detection at all.
382 */
383 dssdev = omap_connector_find_device(connector, OMAP_DSS_DEVICE_OP_HPD);
384 if (dssdev) {
Laurent Pinchart18412b62018-05-30 21:46:44 +0300385 omap_connector->hpd = omapdss_device_get(dssdev);
Laurent Pincharta21a8f32018-05-30 18:51:59 +0300386 connector->polled = DRM_CONNECTOR_POLL_HPD;
387 } else {
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300388 dssdev = omap_connector_find_device(connector,
389 OMAP_DSS_DEVICE_OP_DETECT);
390 if (dssdev)
391 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
392 DRM_CONNECTOR_POLL_DISCONNECT;
393 }
Rob Clarkcd5351f2011-11-12 12:09:40 -0600394
Rob Clarkcd5351f2011-11-12 12:09:40 -0600395 return connector;
396
397fail:
YAMANE Toshiakifdbf20b2012-11-14 19:28:54 +0900398 if (connector)
Rob Clarkcd5351f2011-11-12 12:09:40 -0600399 omap_connector_destroy(connector);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600400
401 return NULL;
402}