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> |
Daniel Vetter | fcd70cd | 2019-01-17 22:03:34 +0100 | [diff] [blame] | 20 | #include <drm/drm_probe_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; |
Laurent Pinchart | 47a3ee2 | 2018-05-31 23:14:43 +0300 | [diff] [blame] | 32 | struct omap_dss_device *output; |
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 | |
Laurent Pinchart | f006325 | 2018-05-30 16:53:43 +0300 | [diff] [blame] | 37 | static void omap_connector_hpd_notify(struct drm_connector *connector, |
Laurent Pinchart | f006325 | 2018-05-30 16:53:43 +0300 | [diff] [blame] | 38 | enum drm_connector_status status) |
| 39 | { |
Laurent Pinchart | 27a7e3e | 2018-09-13 03:45:06 +0300 | [diff] [blame^] | 40 | 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 Pinchart | f006325 | 2018-05-30 16:53:43 +0300 | [diff] [blame] | 54 | } |
| 55 | } |
| 56 | |
Peter Ujfalusi | 3c59680 | 2017-06-02 15:26:35 +0300 | [diff] [blame] | 57 | static 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 Pinchart | f006325 | 2018-05-30 16:53:43 +0300 | [diff] [blame] | 70 | if (old_status == status) |
| 71 | return; |
| 72 | |
Laurent Pinchart | 27a7e3e | 2018-09-13 03:45:06 +0300 | [diff] [blame^] | 73 | omap_connector_hpd_notify(connector, status); |
Laurent Pinchart | f006325 | 2018-05-30 16:53:43 +0300 | [diff] [blame] | 74 | |
| 75 | drm_kms_helper_hotplug_event(dev); |
Peter Ujfalusi | 3c59680 | 2017-06-02 15:26:35 +0300 | [diff] [blame] | 76 | } |
| 77 | |
Laurent Pinchart | 18412b6 | 2018-05-30 21:46:44 +0300 | [diff] [blame] | 78 | void 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 | |
| 88 | void 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 Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 97 | bool 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 Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 104 | static struct omap_dss_device * |
| 105 | omap_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 Pinchart | 6b97cc9 | 2018-09-13 03:10:25 +0300 | [diff] [blame] | 109 | struct omap_dss_device *dssdev = NULL; |
| 110 | struct omap_dss_device *d; |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 111 | |
Laurent Pinchart | 6b97cc9 | 2018-09-13 03:10:25 +0300 | [diff] [blame] | 112 | for (d = omap_connector->output; d; d = d->next) { |
| 113 | if (d->ops_flags & op) |
| 114 | dssdev = d; |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 115 | } |
| 116 | |
Laurent Pinchart | 6b97cc9 | 2018-09-13 03:10:25 +0300 | [diff] [blame] | 117 | return dssdev; |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 118 | } |
| 119 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 120 | static enum drm_connector_status omap_connector_detect( |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 121 | struct drm_connector *connector, bool force) |
| 122 | { |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame] | 123 | struct omap_dss_device *dssdev; |
| 124 | enum drm_connector_status status; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 125 | |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 126 | dssdev = omap_connector_find_device(connector, |
| 127 | OMAP_DSS_DEVICE_OP_DETECT); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 128 | |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame] | 129 | if (dssdev) { |
Laurent Pinchart | f006325 | 2018-05-30 16:53:43 +0300 | [diff] [blame] | 130 | status = dssdev->ops->detect(dssdev) |
| 131 | ? connector_status_connected |
| 132 | : connector_status_disconnected; |
| 133 | |
Laurent Pinchart | 27a7e3e | 2018-09-13 03:45:06 +0300 | [diff] [blame^] | 134 | omap_connector_hpd_notify(connector, status); |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame] | 135 | } else { |
Laurent Pinchart | 6b97cc9 | 2018-09-13 03:10:25 +0300 | [diff] [blame] | 136 | switch (connector->connector_type) { |
| 137 | case DRM_MODE_CONNECTOR_DPI: |
| 138 | case DRM_MODE_CONNECTOR_LVDS: |
| 139 | case DRM_MODE_CONNECTOR_DSI: |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame] | 140 | status = connector_status_connected; |
| 141 | break; |
| 142 | default: |
| 143 | status = connector_status_unknown; |
| 144 | break; |
| 145 | } |
| 146 | } |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 147 | |
Laurent Pinchart | 6b97cc9 | 2018-09-13 03:10:25 +0300 | [diff] [blame] | 148 | VERB("%s: %d (force=%d)", connector->name, status, force); |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame] | 149 | |
| 150 | return status; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 151 | } |
| 152 | |
| 153 | static void omap_connector_destroy(struct drm_connector *connector) |
| 154 | { |
| 155 | struct omap_connector *omap_connector = to_omap_connector(connector); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 156 | |
Laurent Pinchart | 6b97cc9 | 2018-09-13 03:10:25 +0300 | [diff] [blame] | 157 | DBG("%s", connector->name); |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 158 | |
Laurent Pinchart | 18412b6 | 2018-05-30 21:46:44 +0300 | [diff] [blame] | 159 | 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 Ujfalusi | 3c59680 | 2017-06-02 15:26:35 +0300 | [diff] [blame] | 165 | } |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 166 | |
Thomas Wood | 34ea3d3 | 2014-05-29 16:57:41 +0100 | [diff] [blame] | 167 | drm_connector_unregister(connector); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 168 | drm_connector_cleanup(connector); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 169 | |
Laurent Pinchart | 47a3ee2 | 2018-05-31 23:14:43 +0300 | [diff] [blame] | 170 | omapdss_device_put(omap_connector->output); |
Tomi Valkeinen | 2e65c7a | 2018-09-26 13:02:56 +0300 | [diff] [blame] | 171 | |
| 172 | kfree(omap_connector); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 173 | } |
| 174 | |
| 175 | #define MAX_EDID 512 |
| 176 | |
Laurent Pinchart | 90279e9 | 2018-05-31 22:09:14 +0300 | [diff] [blame] | 177 | static 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 | |
| 207 | no_edid: |
| 208 | drm_connector_update_edid_property(connector, NULL); |
| 209 | return 0; |
| 210 | } |
| 211 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 212 | static int omap_connector_get_modes(struct drm_connector *connector) |
| 213 | { |
Laurent Pinchart | 90279e9 | 2018-05-31 22:09:14 +0300 | [diff] [blame] | 214 | struct omap_dss_device *dssdev; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 215 | |
Laurent Pinchart | 6b97cc9 | 2018-09-13 03:10:25 +0300 | [diff] [blame] | 216 | DBG("%s", connector->name); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 217 | |
Laurent Pinchart | 90279e9 | 2018-05-31 22:09:14 +0300 | [diff] [blame] | 218 | /* |
| 219 | * If display exposes EDID, then we parse that in the normal way to |
Laurent Pinchart | 35d944c | 2018-06-06 17:49:37 +0300 | [diff] [blame] | 220 | * build table of supported modes. |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 221 | */ |
Laurent Pinchart | 90279e9 | 2018-05-31 22:09:14 +0300 | [diff] [blame] | 222 | 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 Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 226 | |
Laurent Pinchart | 35d944c | 2018-06-06 17:49:37 +0300 | [diff] [blame] | 227 | /* |
Laurent Pinchart | a872d5e | 2018-09-13 00:35:54 +0300 | [diff] [blame] | 228 | * Otherwise if the display pipeline reports modes (e.g. with a fixed |
| 229 | * resolution panel or an analog TV output), query it. |
Laurent Pinchart | 35d944c | 2018-06-06 17:49:37 +0300 | [diff] [blame] | 230 | */ |
Laurent Pinchart | 46b3847 | 2018-09-13 00:37:35 +0300 | [diff] [blame] | 231 | dssdev = omap_connector_find_device(connector, |
| 232 | OMAP_DSS_DEVICE_OP_MODES); |
| 233 | if (dssdev) |
| 234 | return dssdev->ops->get_modes(dssdev, connector); |
Laurent Pinchart | 35d944c | 2018-06-06 17:49:37 +0300 | [diff] [blame] | 235 | |
Laurent Pinchart | 870e19d | 2018-09-13 00:17:01 +0300 | [diff] [blame] | 236 | /* |
| 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 Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | static 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 Pinchart | 7c27fa5 | 2018-06-05 01:57:09 +0300 | [diff] [blame] | 248 | enum omap_channel channel = omap_connector->output->dispc_channel; |
| 249 | struct omap_drm_private *priv = connector->dev->dev_private; |
Laurent Pinchart | 2812030 | 2018-06-06 00:55:48 +0300 | [diff] [blame] | 250 | struct omap_dss_device *dssdev; |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 251 | struct videomode vm = {0}; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 252 | struct drm_device *dev = connector->dev; |
| 253 | struct drm_display_mode *new_mode; |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 254 | int r, ret = MODE_BAD; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 255 | |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 256 | drm_display_mode_to_videomode(mode, &vm); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 257 | mode->vrefresh = drm_mode_vrefresh(mode); |
| 258 | |
Laurent Pinchart | 7c27fa5 | 2018-06-05 01:57:09 +0300 | [diff] [blame] | 259 | r = priv->dispc_ops->mgr_check_timings(priv->dispc, channel, &vm); |
| 260 | if (r) |
| 261 | goto done; |
| 262 | |
Laurent Pinchart | 2812030 | 2018-06-06 00:55:48 +0300 | [diff] [blame] | 263 | for (dssdev = omap_connector->output; dssdev; dssdev = dssdev->next) { |
| 264 | if (!dssdev->ops->check_timings) |
| 265 | continue; |
Tomi Valkeinen | 47aaaec | 2018-05-02 12:11:59 +0300 | [diff] [blame] | 266 | |
Laurent Pinchart | 2812030 | 2018-06-06 00:55:48 +0300 | [diff] [blame] | 267 | r = dssdev->ops->check_timings(dssdev, &vm); |
| 268 | if (r) |
| 269 | goto done; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 270 | } |
| 271 | |
Laurent Pinchart | 2812030 | 2018-06-06 00:55:48 +0300 | [diff] [blame] | 272 | /* 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 | |
| 283 | done: |
Shayenne Moura | c39ff7e | 2018-12-20 10:26:10 -0200 | [diff] [blame] | 284 | DBG("connector: mode %s: " DRM_MODE_FMT, |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 285 | (ret == MODE_OK) ? "valid" : "invalid", |
Shayenne Moura | c39ff7e | 2018-12-20 10:26:10 -0200 | [diff] [blame] | 286 | DRM_MODE_ARG(mode)); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 287 | |
| 288 | return ret; |
| 289 | } |
| 290 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 291 | static const struct drm_connector_funcs omap_connector_funcs = { |
Laurent Pinchart | 69a1226 | 2015-03-05 21:38:16 +0200 | [diff] [blame] | 292 | .reset = drm_atomic_helper_connector_reset, |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 293 | .detect = omap_connector_detect, |
| 294 | .fill_modes = drm_helper_probe_single_connector_modes, |
| 295 | .destroy = omap_connector_destroy, |
Laurent Pinchart | 69a1226 | 2015-03-05 21:38:16 +0200 | [diff] [blame] | 296 | .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, |
| 297 | .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 298 | }; |
| 299 | |
| 300 | static 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 Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 303 | }; |
| 304 | |
Laurent Pinchart | 52c5dd2 | 2018-06-06 00:31:57 +0300 | [diff] [blame] | 305 | static 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 Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 327 | /* initialize connector */ |
| 328 | struct drm_connector *omap_connector_init(struct drm_device *dev, |
Laurent Pinchart | 52c5dd2 | 2018-06-06 00:31:57 +0300 | [diff] [blame] | 329 | struct omap_dss_device *output, |
| 330 | struct omap_dss_device *display, |
| 331 | struct drm_encoder *encoder) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 332 | { |
| 333 | struct drm_connector *connector = NULL; |
| 334 | struct omap_connector *omap_connector; |
Laurent Pinchart | 47a3ee2 | 2018-05-31 23:14:43 +0300 | [diff] [blame] | 335 | struct omap_dss_device *dssdev; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 336 | |
Laurent Pinchart | 47a3ee2 | 2018-05-31 23:14:43 +0300 | [diff] [blame] | 337 | DBG("%s", display->name); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 338 | |
Laurent Pinchart | d501b12 | 2016-12-12 11:57:24 +0200 | [diff] [blame] | 339 | omap_connector = kzalloc(sizeof(*omap_connector), GFP_KERNEL); |
Joe Perches | 78110bb | 2013-02-11 09:41:29 -0800 | [diff] [blame] | 340 | if (!omap_connector) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 341 | goto fail; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 342 | |
Laurent Pinchart | 47a3ee2 | 2018-05-31 23:14:43 +0300 | [diff] [blame] | 343 | omap_connector->output = omapdss_device_get(output); |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 344 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 345 | connector = &omap_connector->base; |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 346 | connector->interlace_allowed = 1; |
| 347 | connector->doublescan_allowed = 0; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 348 | |
| 349 | drm_connector_init(dev, connector, &omap_connector_funcs, |
Laurent Pinchart | 52c5dd2 | 2018-06-06 00:31:57 +0300 | [diff] [blame] | 350 | omap_connector_get_type(display)); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 351 | drm_connector_helper_add(connector, &omap_connector_helper_funcs); |
| 352 | |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 353 | /* |
| 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 Pinchart | 18412b6 | 2018-05-30 21:46:44 +0300 | [diff] [blame] | 361 | omap_connector->hpd = omapdss_device_get(dssdev); |
Laurent Pinchart | a21a8f3 | 2018-05-30 18:51:59 +0300 | [diff] [blame] | 362 | connector->polled = DRM_CONNECTOR_POLL_HPD; |
| 363 | } else { |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 364 | 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 Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 370 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 371 | return connector; |
| 372 | |
| 373 | fail: |
YAMANE Toshiaki | fdbf20b | 2012-11-14 19:28:54 +0900 | [diff] [blame] | 374 | if (connector) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 375 | omap_connector_destroy(connector); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 376 | |
| 377 | return NULL; |
| 378 | } |