blob: e01e4cf61ae1a378004e9d1455393d958f1231e1 [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>
Daniel Vetterfcd70cd2019-01-17 22:03:34 +010020#include <drm/drm_probe_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;
Laurent Pinchart18412b62018-05-30 21:46:44 +030033 struct omap_dss_device *hpd;
Tomi Valkeinen4f930c02014-06-18 14:19:48 +030034 bool hdmi_mode;
Rob Clarkcd5351f2011-11-12 12:09:40 -060035};
36
Laurent Pinchartf0063252018-05-30 16:53:43 +030037static void omap_connector_hpd_notify(struct drm_connector *connector,
Laurent Pinchartf0063252018-05-30 16:53:43 +030038 enum drm_connector_status status)
39{
Laurent Pinchart27a7e3e2018-09-13 03:45:06 +030040 struct omap_connector *omap_connector = to_omap_connector(connector);
41 struct omap_dss_device *dssdev;
42
43 if (status != connector_status_disconnected)
44 return;
45
46 /*
47 * Notify all devics in the pipeline of disconnection. This is required
48 * to let the HDMI encoders reset their internal state related to
49 * connection status, such as the CEC address.
50 */
51 for (dssdev = omap_connector->output; dssdev; dssdev = dssdev->next) {
52 if (dssdev->ops && dssdev->ops->hdmi.lost_hotplug)
53 dssdev->ops->hdmi.lost_hotplug(dssdev);
Laurent Pinchartf0063252018-05-30 16:53:43 +030054 }
55}
56
Peter Ujfalusi3c596802017-06-02 15:26:35 +030057static void omap_connector_hpd_cb(void *cb_data,
58 enum drm_connector_status status)
59{
60 struct omap_connector *omap_connector = cb_data;
61 struct drm_connector *connector = &omap_connector->base;
62 struct drm_device *dev = connector->dev;
63 enum drm_connector_status old_status;
64
65 mutex_lock(&dev->mode_config.mutex);
66 old_status = connector->status;
67 connector->status = status;
68 mutex_unlock(&dev->mode_config.mutex);
69
Laurent Pinchartf0063252018-05-30 16:53:43 +030070 if (old_status == status)
71 return;
72
Laurent Pinchart27a7e3e2018-09-13 03:45:06 +030073 omap_connector_hpd_notify(connector, status);
Laurent Pinchartf0063252018-05-30 16:53:43 +030074
75 drm_kms_helper_hotplug_event(dev);
Peter Ujfalusi3c596802017-06-02 15:26:35 +030076}
77
Laurent Pinchart18412b62018-05-30 21:46:44 +030078void omap_connector_enable_hpd(struct drm_connector *connector)
79{
80 struct omap_connector *omap_connector = to_omap_connector(connector);
81 struct omap_dss_device *hpd = omap_connector->hpd;
82
83 if (hpd)
84 hpd->ops->register_hpd_cb(hpd, omap_connector_hpd_cb,
85 omap_connector);
86}
87
88void omap_connector_disable_hpd(struct drm_connector *connector)
89{
90 struct omap_connector *omap_connector = to_omap_connector(connector);
91 struct omap_dss_device *hpd = omap_connector->hpd;
92
93 if (hpd)
94 hpd->ops->unregister_hpd_cb(hpd);
95}
96
Tomi Valkeinen4f930c02014-06-18 14:19:48 +030097bool omap_connector_get_hdmi_mode(struct drm_connector *connector)
98{
99 struct omap_connector *omap_connector = to_omap_connector(connector);
100
101 return omap_connector->hdmi_mode;
102}
103
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300104static struct omap_dss_device *
105omap_connector_find_device(struct drm_connector *connector,
106 enum omap_dss_device_ops_flag op)
107{
108 struct omap_connector *omap_connector = to_omap_connector(connector);
Laurent Pinchart6b97cc92018-09-13 03:10:25 +0300109 struct omap_dss_device *dssdev = NULL;
110 struct omap_dss_device *d;
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300111
Laurent Pinchart6b97cc92018-09-13 03:10:25 +0300112 for (d = omap_connector->output; d; d = d->next) {
113 if (d->ops_flags & op)
114 dssdev = d;
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300115 }
116
Laurent Pinchart6b97cc92018-09-13 03:10:25 +0300117 return dssdev;
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300118}
119
Rob Clarkf5f94542012-12-04 13:59:12 -0600120static enum drm_connector_status omap_connector_detect(
Rob Clarkcd5351f2011-11-12 12:09:40 -0600121 struct drm_connector *connector, bool force)
122{
Laurent Pinchartf2ea5572018-05-28 16:49:36 +0300123 struct omap_dss_device *dssdev;
124 enum drm_connector_status status;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600125
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300126 dssdev = omap_connector_find_device(connector,
127 OMAP_DSS_DEVICE_OP_DETECT);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600128
Laurent Pinchartf2ea5572018-05-28 16:49:36 +0300129 if (dssdev) {
Laurent Pinchartf0063252018-05-30 16:53:43 +0300130 status = dssdev->ops->detect(dssdev)
131 ? connector_status_connected
132 : connector_status_disconnected;
133
Laurent Pinchart27a7e3e2018-09-13 03:45:06 +0300134 omap_connector_hpd_notify(connector, status);
Laurent Pinchartf2ea5572018-05-28 16:49:36 +0300135 } else {
Laurent Pinchart6b97cc92018-09-13 03:10:25 +0300136 switch (connector->connector_type) {
137 case DRM_MODE_CONNECTOR_DPI:
138 case DRM_MODE_CONNECTOR_LVDS:
139 case DRM_MODE_CONNECTOR_DSI:
Laurent Pinchartf2ea5572018-05-28 16:49:36 +0300140 status = connector_status_connected;
141 break;
142 default:
143 status = connector_status_unknown;
144 break;
145 }
146 }
Rob Clarkcd5351f2011-11-12 12:09:40 -0600147
Laurent Pinchart6b97cc92018-09-13 03:10:25 +0300148 VERB("%s: %d (force=%d)", connector->name, status, force);
Laurent Pinchartf2ea5572018-05-28 16:49:36 +0300149
150 return status;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600151}
152
153static void omap_connector_destroy(struct drm_connector *connector)
154{
155 struct omap_connector *omap_connector = to_omap_connector(connector);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600156
Laurent Pinchart6b97cc92018-09-13 03:10:25 +0300157 DBG("%s", connector->name);
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300158
Laurent Pinchart18412b62018-05-30 21:46:44 +0300159 if (omap_connector->hpd) {
160 struct omap_dss_device *hpd = omap_connector->hpd;
161
162 hpd->ops->unregister_hpd_cb(hpd);
163 omapdss_device_put(hpd);
164 omap_connector->hpd = NULL;
Peter Ujfalusi3c596802017-06-02 15:26:35 +0300165 }
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300166
Thomas Wood34ea3d32014-05-29 16:57:41 +0100167 drm_connector_unregister(connector);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600168 drm_connector_cleanup(connector);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600169
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300170 omapdss_device_put(omap_connector->output);
Tomi Valkeinen2e65c7a2018-09-26 13:02:56 +0300171
172 kfree(omap_connector);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600173}
174
175#define MAX_EDID 512
176
Laurent Pinchart90279e92018-05-31 22:09:14 +0300177static int omap_connector_get_modes_edid(struct drm_connector *connector,
178 struct omap_dss_device *dssdev)
179{
180 struct omap_connector *omap_connector = to_omap_connector(connector);
181 enum drm_connector_status status;
182 void *edid;
183 int n;
184
185 status = omap_connector_detect(connector, false);
186 if (status != connector_status_connected)
187 goto no_edid;
188
189 edid = kzalloc(MAX_EDID, GFP_KERNEL);
190 if (!edid)
191 goto no_edid;
192
193 if (dssdev->ops->read_edid(dssdev, edid, MAX_EDID) <= 0 ||
194 !drm_edid_is_valid(edid)) {
195 kfree(edid);
196 goto no_edid;
197 }
198
199 drm_connector_update_edid_property(connector, edid);
200 n = drm_add_edid_modes(connector, edid);
201
202 omap_connector->hdmi_mode = drm_detect_hdmi_monitor(edid);
203
204 kfree(edid);
205 return n;
206
207no_edid:
208 drm_connector_update_edid_property(connector, NULL);
209 return 0;
210}
211
Rob Clarkcd5351f2011-11-12 12:09:40 -0600212static int omap_connector_get_modes(struct drm_connector *connector)
213{
Laurent Pinchart90279e92018-05-31 22:09:14 +0300214 struct omap_dss_device *dssdev;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600215
Laurent Pinchart6b97cc92018-09-13 03:10:25 +0300216 DBG("%s", connector->name);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600217
Laurent Pinchart90279e92018-05-31 22:09:14 +0300218 /*
219 * If display exposes EDID, then we parse that in the normal way to
Laurent Pinchart35d944c2018-06-06 17:49:37 +0300220 * build table of supported modes.
Rob Clarkcd5351f2011-11-12 12:09:40 -0600221 */
Laurent Pinchart90279e92018-05-31 22:09:14 +0300222 dssdev = omap_connector_find_device(connector,
223 OMAP_DSS_DEVICE_OP_EDID);
224 if (dssdev)
225 return omap_connector_get_modes_edid(connector, dssdev);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600226
Laurent Pinchart35d944c2018-06-06 17:49:37 +0300227 /*
Laurent Pincharta872d5e2018-09-13 00:35:54 +0300228 * Otherwise if the display pipeline reports modes (e.g. with a fixed
229 * resolution panel or an analog TV output), query it.
Laurent Pinchart35d944c2018-06-06 17:49:37 +0300230 */
Laurent Pinchart46b38472018-09-13 00:37:35 +0300231 dssdev = omap_connector_find_device(connector,
232 OMAP_DSS_DEVICE_OP_MODES);
233 if (dssdev)
234 return dssdev->ops->get_modes(dssdev, connector);
Laurent Pinchart35d944c2018-06-06 17:49:37 +0300235
Laurent Pinchart870e19d2018-09-13 00:17:01 +0300236 /*
237 * We can't retrieve modes, which can happen for instance for a DVI or
238 * VGA output with the DDC bus unconnected. The KMS core will add the
239 * default modes.
240 */
241 return 0;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600242}
243
244static int omap_connector_mode_valid(struct drm_connector *connector,
245 struct drm_display_mode *mode)
246{
247 struct omap_connector *omap_connector = to_omap_connector(connector);
Laurent Pinchart7c27fa52018-06-05 01:57:09 +0300248 enum omap_channel channel = omap_connector->output->dispc_channel;
249 struct omap_drm_private *priv = connector->dev->dev_private;
Laurent Pinchart28120302018-06-06 00:55:48 +0300250 struct omap_dss_device *dssdev;
Peter Ujfalusida11bbbb2016-09-22 14:07:04 +0300251 struct videomode vm = {0};
Rob Clarkcd5351f2011-11-12 12:09:40 -0600252 struct drm_device *dev = connector->dev;
253 struct drm_display_mode *new_mode;
Archit Tanejabddabbe2013-03-26 19:15:20 +0530254 int r, ret = MODE_BAD;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600255
Peter Ujfalusida11bbbb2016-09-22 14:07:04 +0300256 drm_display_mode_to_videomode(mode, &vm);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600257 mode->vrefresh = drm_mode_vrefresh(mode);
258
Laurent Pinchart7c27fa52018-06-05 01:57:09 +0300259 r = priv->dispc_ops->mgr_check_timings(priv->dispc, channel, &vm);
260 if (r)
261 goto done;
262
Laurent Pinchart28120302018-06-06 00:55:48 +0300263 for (dssdev = omap_connector->output; dssdev; dssdev = dssdev->next) {
264 if (!dssdev->ops->check_timings)
265 continue;
Tomi Valkeinen47aaaec2018-05-02 12:11:59 +0300266
Laurent Pinchart28120302018-06-06 00:55:48 +0300267 r = dssdev->ops->check_timings(dssdev, &vm);
268 if (r)
269 goto done;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600270 }
271
Laurent Pinchart28120302018-06-06 00:55:48 +0300272 /* check if vrefresh is still valid */
273 new_mode = drm_mode_duplicate(dev, mode);
274 if (!new_mode)
275 return MODE_BAD;
276
277 new_mode->clock = vm.pixelclock / 1000;
278 new_mode->vrefresh = 0;
279 if (mode->vrefresh == drm_mode_vrefresh(new_mode))
280 ret = MODE_OK;
281 drm_mode_destroy(dev, new_mode);
282
283done:
Shayenne Mourac39ff7e2018-12-20 10:26:10 -0200284 DBG("connector: mode %s: " DRM_MODE_FMT,
Rob Clarkcd5351f2011-11-12 12:09:40 -0600285 (ret == MODE_OK) ? "valid" : "invalid",
Shayenne Mourac39ff7e2018-12-20 10:26:10 -0200286 DRM_MODE_ARG(mode));
Rob Clarkcd5351f2011-11-12 12:09:40 -0600287
288 return ret;
289}
290
Rob Clarkcd5351f2011-11-12 12:09:40 -0600291static const struct drm_connector_funcs omap_connector_funcs = {
Laurent Pinchart69a12262015-03-05 21:38:16 +0200292 .reset = drm_atomic_helper_connector_reset,
Rob Clarkcd5351f2011-11-12 12:09:40 -0600293 .detect = omap_connector_detect,
294 .fill_modes = drm_helper_probe_single_connector_modes,
295 .destroy = omap_connector_destroy,
Laurent Pinchart69a12262015-03-05 21:38:16 +0200296 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
297 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
Rob Clarkcd5351f2011-11-12 12:09:40 -0600298};
299
300static const struct drm_connector_helper_funcs omap_connector_helper_funcs = {
301 .get_modes = omap_connector_get_modes,
302 .mode_valid = omap_connector_mode_valid,
Rob Clarkcd5351f2011-11-12 12:09:40 -0600303};
304
Laurent Pinchart52c5dd22018-06-06 00:31:57 +0300305static int omap_connector_get_type(struct omap_dss_device *display)
306{
307 switch (display->type) {
308 case OMAP_DISPLAY_TYPE_HDMI:
309 return DRM_MODE_CONNECTOR_HDMIA;
310 case OMAP_DISPLAY_TYPE_DVI:
311 return DRM_MODE_CONNECTOR_DVID;
312 case OMAP_DISPLAY_TYPE_DSI:
313 return DRM_MODE_CONNECTOR_DSI;
314 case OMAP_DISPLAY_TYPE_DPI:
315 case OMAP_DISPLAY_TYPE_DBI:
316 return DRM_MODE_CONNECTOR_DPI;
317 case OMAP_DISPLAY_TYPE_VENC:
318 /* TODO: This could also be composite */
319 return DRM_MODE_CONNECTOR_SVIDEO;
320 case OMAP_DISPLAY_TYPE_SDI:
321 return DRM_MODE_CONNECTOR_LVDS;
322 default:
323 return DRM_MODE_CONNECTOR_Unknown;
324 }
325}
326
Rob Clarkcd5351f2011-11-12 12:09:40 -0600327/* initialize connector */
328struct drm_connector *omap_connector_init(struct drm_device *dev,
Laurent Pinchart52c5dd22018-06-06 00:31:57 +0300329 struct omap_dss_device *output,
330 struct omap_dss_device *display,
331 struct drm_encoder *encoder)
Rob Clarkcd5351f2011-11-12 12:09:40 -0600332{
333 struct drm_connector *connector = NULL;
334 struct omap_connector *omap_connector;
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300335 struct omap_dss_device *dssdev;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600336
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300337 DBG("%s", display->name);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600338
Laurent Pinchartd501b122016-12-12 11:57:24 +0200339 omap_connector = kzalloc(sizeof(*omap_connector), GFP_KERNEL);
Joe Perches78110bb2013-02-11 09:41:29 -0800340 if (!omap_connector)
Rob Clarkcd5351f2011-11-12 12:09:40 -0600341 goto fail;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600342
Laurent Pinchart47a3ee22018-05-31 23:14:43 +0300343 omap_connector->output = omapdss_device_get(output);
Rob Clarkf5f94542012-12-04 13:59:12 -0600344
Rob Clarkcd5351f2011-11-12 12:09:40 -0600345 connector = &omap_connector->base;
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300346 connector->interlace_allowed = 1;
347 connector->doublescan_allowed = 0;
Rob Clarkcd5351f2011-11-12 12:09:40 -0600348
349 drm_connector_init(dev, connector, &omap_connector_funcs,
Laurent Pinchart52c5dd22018-06-06 00:31:57 +0300350 omap_connector_get_type(display));
Rob Clarkcd5351f2011-11-12 12:09:40 -0600351 drm_connector_helper_add(connector, &omap_connector_helper_funcs);
352
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300353 /*
354 * Initialize connector status handling. First try to find a device that
355 * supports hot-plug reporting. If it fails, fall back to a device that
356 * support polling. If that fails too, we don't support hot-plug
357 * detection at all.
358 */
359 dssdev = omap_connector_find_device(connector, OMAP_DSS_DEVICE_OP_HPD);
360 if (dssdev) {
Laurent Pinchart18412b62018-05-30 21:46:44 +0300361 omap_connector->hpd = omapdss_device_get(dssdev);
Laurent Pincharta21a8f32018-05-30 18:51:59 +0300362 connector->polled = DRM_CONNECTOR_POLL_HPD;
363 } else {
Laurent Pinchart949ea2e2018-05-30 18:49:48 +0300364 dssdev = omap_connector_find_device(connector,
365 OMAP_DSS_DEVICE_OP_DETECT);
366 if (dssdev)
367 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
368 DRM_CONNECTOR_POLL_DISCONNECT;
369 }
Rob Clarkcd5351f2011-11-12 12:09:40 -0600370
Rob Clarkcd5351f2011-11-12 12:09:40 -0600371 return connector;
372
373fail:
YAMANE Toshiakifdbf20b2012-11-14 19:28:54 +0900374 if (connector)
Rob Clarkcd5351f2011-11-12 12:09:40 -0600375 omap_connector_destroy(connector);
Rob Clarkcd5351f2011-11-12 12:09:40 -0600376
377 return NULL;
378}