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