Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 1 | /* |
Andrew F. Davis | bb5cdf8 | 2017-12-05 14:29:31 -0600 | [diff] [blame] | 2 | * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/ |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 3 | * 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 Pinchart | 69a1226 | 2015-03-05 21:38:16 +0200 | [diff] [blame] | 18 | #include <drm/drm_atomic_helper.h> |
Laurent Pinchart | 2d278f5 | 2015-03-05 21:31:37 +0200 | [diff] [blame] | 19 | #include <drm/drm_crtc.h> |
| 20 | #include <drm/drm_crtc_helper.h> |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 21 | |
Laurent Pinchart | 2d278f5 | 2015-03-05 21:31:37 +0200 | [diff] [blame] | 22 | #include "omap_drv.h" |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 23 | |
| 24 | /* |
| 25 | * connector funcs |
| 26 | */ |
| 27 | |
| 28 | #define to_omap_connector(x) container_of(x, struct omap_connector, base) |
| 29 | |
| 30 | struct omap_connector { |
| 31 | struct drm_connector base; |
| 32 | struct omap_dss_device *dssdev; |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 33 | bool hdmi_mode; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 34 | }; |
| 35 | |
Peter Ujfalusi | 3c59680 | 2017-06-02 15:26:35 +0300 | [diff] [blame] | 36 | static void omap_connector_hpd_cb(void *cb_data, |
| 37 | enum drm_connector_status status) |
| 38 | { |
| 39 | struct omap_connector *omap_connector = cb_data; |
| 40 | struct drm_connector *connector = &omap_connector->base; |
| 41 | struct drm_device *dev = connector->dev; |
| 42 | enum drm_connector_status old_status; |
| 43 | |
| 44 | mutex_lock(&dev->mode_config.mutex); |
| 45 | old_status = connector->status; |
| 46 | connector->status = status; |
| 47 | mutex_unlock(&dev->mode_config.mutex); |
| 48 | |
| 49 | if (old_status != status) |
| 50 | drm_kms_helper_hotplug_event(dev); |
| 51 | } |
| 52 | |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 53 | bool omap_connector_get_hdmi_mode(struct drm_connector *connector) |
| 54 | { |
| 55 | struct omap_connector *omap_connector = to_omap_connector(connector); |
| 56 | |
| 57 | return omap_connector->hdmi_mode; |
| 58 | } |
| 59 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 60 | static enum drm_connector_status omap_connector_detect( |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 61 | struct drm_connector *connector, bool force) |
| 62 | { |
| 63 | struct omap_connector *omap_connector = to_omap_connector(connector); |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame^] | 64 | struct omap_dss_device *dssdev; |
| 65 | enum drm_connector_status status; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 66 | |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame^] | 67 | for (dssdev = omap_connector->dssdev; dssdev; dssdev = dssdev->src) { |
| 68 | if (dssdev->ops_flags & OMAP_DSS_DEVICE_OP_DETECT) |
| 69 | break; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 70 | } |
| 71 | |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame^] | 72 | if (dssdev) { |
| 73 | if (dssdev->ops->detect(dssdev)) |
| 74 | status = connector_status_connected; |
| 75 | else |
| 76 | status = connector_status_disconnected; |
| 77 | } else { |
| 78 | switch (omap_connector->dssdev->type) { |
| 79 | case OMAP_DISPLAY_TYPE_DPI: |
| 80 | case OMAP_DISPLAY_TYPE_DBI: |
| 81 | case OMAP_DISPLAY_TYPE_SDI: |
| 82 | case OMAP_DISPLAY_TYPE_DSI: |
| 83 | status = connector_status_connected; |
| 84 | break; |
| 85 | default: |
| 86 | status = connector_status_unknown; |
| 87 | break; |
| 88 | } |
| 89 | } |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 90 | |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame^] | 91 | VERB("%s: %d (force=%d)", omap_connector->dssdev->name, status, force); |
| 92 | |
| 93 | return status; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 94 | } |
| 95 | |
| 96 | static void omap_connector_destroy(struct drm_connector *connector) |
| 97 | { |
| 98 | struct omap_connector *omap_connector = to_omap_connector(connector); |
| 99 | struct omap_dss_device *dssdev = omap_connector->dssdev; |
| 100 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 101 | DBG("%s", omap_connector->dssdev->name); |
Peter Ujfalusi | 3c59680 | 2017-06-02 15:26:35 +0300 | [diff] [blame] | 102 | if (connector->polled == DRM_CONNECTOR_POLL_HPD && |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 103 | dssdev->ops->unregister_hpd_cb) { |
| 104 | dssdev->ops->unregister_hpd_cb(dssdev); |
Peter Ujfalusi | 3c59680 | 2017-06-02 15:26:35 +0300 | [diff] [blame] | 105 | } |
Thomas Wood | 34ea3d3 | 2014-05-29 16:57:41 +0100 | [diff] [blame] | 106 | drm_connector_unregister(connector); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 107 | drm_connector_cleanup(connector); |
| 108 | kfree(omap_connector); |
| 109 | |
Laurent Pinchart | c1dfe72 | 2018-03-02 02:43:45 +0200 | [diff] [blame] | 110 | omapdss_device_put(dssdev); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 111 | } |
| 112 | |
| 113 | #define MAX_EDID 512 |
| 114 | |
| 115 | static int omap_connector_get_modes(struct drm_connector *connector) |
| 116 | { |
| 117 | struct omap_connector *omap_connector = to_omap_connector(connector); |
| 118 | struct omap_dss_device *dssdev = omap_connector->dssdev; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 119 | struct drm_device *dev = connector->dev; |
| 120 | int n = 0; |
| 121 | |
| 122 | DBG("%s", omap_connector->dssdev->name); |
| 123 | |
| 124 | /* if display exposes EDID, then we parse that in the normal way to |
| 125 | * build table of supported modes.. otherwise (ie. fixed resolution |
| 126 | * LCD panels) we just return a single mode corresponding to the |
| 127 | * currently configured timings: |
| 128 | */ |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 129 | if (dssdev->ops->read_edid) { |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 130 | void *edid = kzalloc(MAX_EDID, GFP_KERNEL); |
| 131 | |
Tomi Valkeinen | 47aaaec | 2018-05-02 12:11:59 +0300 | [diff] [blame] | 132 | if (!edid) |
| 133 | return 0; |
| 134 | |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 135 | if ((dssdev->ops->read_edid(dssdev, edid, MAX_EDID) > 0) && |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 136 | drm_edid_is_valid(edid)) { |
Daniel Vetter | c555f02 | 2018-07-09 10:40:06 +0200 | [diff] [blame] | 137 | drm_connector_update_edid_property( |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 138 | connector, edid); |
| 139 | n = drm_add_edid_modes(connector, edid); |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 140 | |
| 141 | omap_connector->hdmi_mode = |
| 142 | drm_detect_hdmi_monitor(edid); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 143 | } else { |
Daniel Vetter | c555f02 | 2018-07-09 10:40:06 +0200 | [diff] [blame] | 144 | drm_connector_update_edid_property( |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 145 | connector, NULL); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 146 | } |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 147 | |
Jani Nikula | 451023d | 2012-08-15 09:32:39 +0000 | [diff] [blame] | 148 | kfree(edid); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 149 | } else { |
| 150 | struct drm_display_mode *mode = drm_mode_create(dev); |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 151 | struct videomode vm = {0}; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 152 | |
Tomi Valkeinen | 47aaaec | 2018-05-02 12:11:59 +0300 | [diff] [blame] | 153 | if (!mode) |
| 154 | return 0; |
| 155 | |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 156 | dssdev->ops->get_timings(dssdev, &vm); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 157 | |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 158 | drm_display_mode_from_videomode(&vm, mode); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 159 | |
| 160 | mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; |
| 161 | drm_mode_set_name(mode); |
| 162 | drm_mode_probed_add(connector, mode); |
| 163 | |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 164 | if (dssdev->driver && dssdev->driver->get_size) { |
| 165 | dssdev->driver->get_size(dssdev, |
Sebastian Reichel | b070d6e | 2017-07-24 19:33:04 +0200 | [diff] [blame] | 166 | &connector->display_info.width_mm, |
| 167 | &connector->display_info.height_mm); |
| 168 | } |
| 169 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 170 | n = 1; |
| 171 | } |
| 172 | |
| 173 | return n; |
| 174 | } |
| 175 | |
| 176 | static int omap_connector_mode_valid(struct drm_connector *connector, |
| 177 | struct drm_display_mode *mode) |
| 178 | { |
| 179 | struct omap_connector *omap_connector = to_omap_connector(connector); |
| 180 | struct omap_dss_device *dssdev = omap_connector->dssdev; |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 181 | struct videomode vm = {0}; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 182 | struct drm_device *dev = connector->dev; |
| 183 | struct drm_display_mode *new_mode; |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 184 | int r, ret = MODE_BAD; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 185 | |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 186 | drm_display_mode_to_videomode(mode, &vm); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 187 | mode->vrefresh = drm_mode_vrefresh(mode); |
| 188 | |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 189 | /* |
| 190 | * if the panel driver doesn't have a check_timings, it's most likely |
| 191 | * a fixed resolution panel, check if the timings match with the |
| 192 | * panel's timings |
| 193 | */ |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 194 | if (dssdev->ops->check_timings) { |
| 195 | r = dssdev->ops->check_timings(dssdev, &vm); |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 196 | } else { |
Peter Ujfalusi | 4520ff2 | 2016-09-22 14:07:03 +0300 | [diff] [blame] | 197 | struct videomode t = {0}; |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 198 | |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 199 | dssdev->ops->get_timings(dssdev, &t); |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 200 | |
Tomi Valkeinen | 50fa9f0 | 2016-11-23 13:24:00 +0200 | [diff] [blame] | 201 | /* |
| 202 | * Ignore the flags, as we don't get them from |
| 203 | * drm_display_mode_to_videomode. |
| 204 | */ |
| 205 | t.flags = 0; |
| 206 | |
Laurent Pinchart | d501b12 | 2016-12-12 11:57:24 +0200 | [diff] [blame] | 207 | if (memcmp(&vm, &t, sizeof(vm))) |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 208 | r = -EINVAL; |
| 209 | else |
| 210 | r = 0; |
| 211 | } |
| 212 | |
| 213 | if (!r) { |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 214 | /* check if vrefresh is still valid */ |
| 215 | new_mode = drm_mode_duplicate(dev, mode); |
Tomi Valkeinen | 47aaaec | 2018-05-02 12:11:59 +0300 | [diff] [blame] | 216 | |
| 217 | if (!new_mode) |
| 218 | return MODE_BAD; |
| 219 | |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 220 | new_mode->clock = vm.pixelclock / 1000; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 221 | new_mode->vrefresh = 0; |
| 222 | if (mode->vrefresh == drm_mode_vrefresh(new_mode)) |
| 223 | ret = MODE_OK; |
| 224 | drm_mode_destroy(dev, new_mode); |
| 225 | } |
| 226 | |
| 227 | DBG("connector: mode %s: " |
| 228 | "%d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x", |
| 229 | (ret == MODE_OK) ? "valid" : "invalid", |
| 230 | mode->base.id, mode->name, mode->vrefresh, mode->clock, |
| 231 | mode->hdisplay, mode->hsync_start, |
| 232 | mode->hsync_end, mode->htotal, |
| 233 | mode->vdisplay, mode->vsync_start, |
| 234 | mode->vsync_end, mode->vtotal, mode->type, mode->flags); |
| 235 | |
| 236 | return ret; |
| 237 | } |
| 238 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 239 | static const struct drm_connector_funcs omap_connector_funcs = { |
Laurent Pinchart | 69a1226 | 2015-03-05 21:38:16 +0200 | [diff] [blame] | 240 | .reset = drm_atomic_helper_connector_reset, |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 241 | .detect = omap_connector_detect, |
| 242 | .fill_modes = drm_helper_probe_single_connector_modes, |
| 243 | .destroy = omap_connector_destroy, |
Laurent Pinchart | 69a1226 | 2015-03-05 21:38:16 +0200 | [diff] [blame] | 244 | .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, |
| 245 | .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 246 | }; |
| 247 | |
| 248 | static const struct drm_connector_helper_funcs omap_connector_helper_funcs = { |
| 249 | .get_modes = omap_connector_get_modes, |
| 250 | .mode_valid = omap_connector_mode_valid, |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 251 | }; |
| 252 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 253 | /* initialize connector */ |
| 254 | struct drm_connector *omap_connector_init(struct drm_device *dev, |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 255 | int connector_type, struct omap_dss_device *dssdev, |
| 256 | struct drm_encoder *encoder) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 257 | { |
| 258 | struct drm_connector *connector = NULL; |
| 259 | struct omap_connector *omap_connector; |
Peter Ujfalusi | 3c59680 | 2017-06-02 15:26:35 +0300 | [diff] [blame] | 260 | bool hpd_supported = false; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 261 | |
| 262 | DBG("%s", dssdev->name); |
| 263 | |
Laurent Pinchart | c1dfe72 | 2018-03-02 02:43:45 +0200 | [diff] [blame] | 264 | omapdss_device_get(dssdev); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 265 | |
Laurent Pinchart | d501b12 | 2016-12-12 11:57:24 +0200 | [diff] [blame] | 266 | omap_connector = kzalloc(sizeof(*omap_connector), GFP_KERNEL); |
Joe Perches | 78110bb | 2013-02-11 09:41:29 -0800 | [diff] [blame] | 267 | if (!omap_connector) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 268 | goto fail; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 269 | |
| 270 | omap_connector->dssdev = dssdev; |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 271 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 272 | connector = &omap_connector->base; |
| 273 | |
| 274 | drm_connector_init(dev, connector, &omap_connector_funcs, |
| 275 | connector_type); |
| 276 | drm_connector_helper_add(connector, &omap_connector_helper_funcs); |
| 277 | |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 278 | if (dssdev->ops->register_hpd_cb) { |
| 279 | int ret = dssdev->ops->register_hpd_cb(dssdev, |
| 280 | omap_connector_hpd_cb, |
| 281 | omap_connector); |
Peter Ujfalusi | 3c59680 | 2017-06-02 15:26:35 +0300 | [diff] [blame] | 282 | if (!ret) |
| 283 | hpd_supported = true; |
| 284 | else if (ret != -ENOTSUPP) |
| 285 | DBG("%s: Failed to register HPD callback (%d).", |
| 286 | dssdev->name, ret); |
| 287 | } |
| 288 | |
| 289 | if (hpd_supported) |
| 290 | connector->polled = DRM_CONNECTOR_POLL_HPD; |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 291 | else if (dssdev->ops->detect) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 292 | connector->polled = DRM_CONNECTOR_POLL_CONNECT | |
Peter Ujfalusi | 4573ebe | 2016-08-22 15:54:30 +0300 | [diff] [blame] | 293 | DRM_CONNECTOR_POLL_DISCONNECT; |
| 294 | else |
| 295 | connector->polled = 0; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 296 | |
| 297 | connector->interlace_allowed = 1; |
| 298 | connector->doublescan_allowed = 0; |
| 299 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 300 | return connector; |
| 301 | |
| 302 | fail: |
YAMANE Toshiaki | fdbf20b | 2012-11-14 19:28:54 +0900 | [diff] [blame] | 303 | if (connector) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 304 | omap_connector_destroy(connector); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 305 | |
| 306 | return NULL; |
| 307 | } |