drivers/gpu/drm/omapdrm/omap_connector.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
   4  * Author: Rob Clark <rob@ti.com>
   5  */
   6
   7 #include <drm/drm_atomic_helper.h>
   8 #include <drm/drm_crtc.h>
   9 #include <drm/drm_panel.h>
  10 #include <drm/drm_probe_helper.h>
  11
  12 #include "omap_drv.h"
  13
  14 /*
  15  * connector funcs
  16  */
  17
  18 #define to_omap_connector(x) container_of(x, struct omap_connector, base)
  19
  20 struct omap_connector {
  21         struct drm_connector base;
  22         struct omap_dss_device *output;
  23         struct omap_dss_device *hpd;
  24         bool hdmi_mode;
  25 };
  26
  27 static void omap_connector_hpd_notify(struct drm_connector *connector,
  28                                       enum drm_connector_status status)
  29 {
  30         struct omap_connector *omap_connector = to_omap_connector(connector);
  31         struct omap_dss_device *dssdev;
  32
  33         if (status != connector_status_disconnected)
  34                 return;
  35
  36         /*
  37          * Notify all devics in the pipeline of disconnection. This is required
  38          * to let the HDMI encoders reset their internal state related to
  39          * connection status, such as the CEC address.
  40          */
  41         for (dssdev = omap_connector->output; dssdev; dssdev = dssdev->next) {
  42                 if (dssdev->ops && dssdev->ops->hdmi.lost_hotplug)
  43                         dssdev->ops->hdmi.lost_hotplug(dssdev);
  44         }
  45 }
  46
  47 static void omap_connector_hpd_cb(void *cb_data,
  48                                   enum drm_connector_status status)
  49 {
  50         struct omap_connector *omap_connector = cb_data;
  51         struct drm_connector *connector = &omap_connector->base;
  52         struct drm_device *dev = connector->dev;
  53         enum drm_connector_status old_status;
  54
  55         mutex_lock(&dev->mode_config.mutex);
  56         old_status = connector->status;
  57         connector->status = status;
  58         mutex_unlock(&dev->mode_config.mutex);
  59
  60         if (old_status == status)
  61                 return;
  62
  63         omap_connector_hpd_notify(connector, status);
  64
  65         drm_kms_helper_hotplug_event(dev);
  66 }
  67
  68 void omap_connector_enable_hpd(struct drm_connector *connector)
  69 {
  70         struct omap_connector *omap_connector = to_omap_connector(connector);
  71         struct omap_dss_device *hpd = omap_connector->hpd;
  72
  73         if (hpd)
  74                 hpd->ops->register_hpd_cb(hpd, omap_connector_hpd_cb,
  75                                           omap_connector);
  76 }
  77
  78 void omap_connector_disable_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->unregister_hpd_cb(hpd);
  85 }
  86
  87 bool omap_connector_get_hdmi_mode(struct drm_connector *connector)
  88 {
  89         struct omap_connector *omap_connector = to_omap_connector(connector);
  90
  91         return omap_connector->hdmi_mode;
  92 }
  93
  94 static struct omap_dss_device *
  95 omap_connector_find_device(struct drm_connector *connector,
  96                            enum omap_dss_device_ops_flag op)
  97 {
  98         struct omap_connector *omap_connector = to_omap_connector(connector);
  99         struct omap_dss_device *dssdev = NULL;
 100         struct omap_dss_device *d;
 101
 102         for (d = omap_connector->output; d; d = d->next) {
 103                 if (d->ops_flags & op)
 104                         dssdev = d;
 105         }
 106
 107         return dssdev;
 108 }
 109
 110 static enum drm_connector_status omap_connector_detect(
 111                 struct drm_connector *connector, bool force)
 112 {
 113         struct omap_dss_device *dssdev;
 114         enum drm_connector_status status;
 115
 116         dssdev = omap_connector_find_device(connector,
 117                                             OMAP_DSS_DEVICE_OP_DETECT);
 118
 119         if (dssdev) {
 120                 status = dssdev->ops->detect(dssdev)
 121                        ? connector_status_connected
 122                        : connector_status_disconnected;
 123
 124                 omap_connector_hpd_notify(connector, status);
 125         } else {
 126                 switch (connector->connector_type) {
 127                 case DRM_MODE_CONNECTOR_DPI:
 128                 case DRM_MODE_CONNECTOR_LVDS:
 129                 case DRM_MODE_CONNECTOR_DSI:
 130                         status = connector_status_connected;
 131                         break;
 132                 default:
 133                         status = connector_status_unknown;
 134                         break;
 135                 }
 136         }
 137
 138         VERB("%s: %d (force=%d)", connector->name, status, force);
 139
 140         return status;
 141 }
 142
 143 static void omap_connector_destroy(struct drm_connector *connector)
 144 {
 145         struct omap_connector *omap_connector = to_omap_connector(connector);
 146
 147         DBG("%s", connector->name);
 148
 149         if (omap_connector->hpd) {
 150                 struct omap_dss_device *hpd = omap_connector->hpd;
 151
 152                 hpd->ops->unregister_hpd_cb(hpd);
 153                 omapdss_device_put(hpd);
 154                 omap_connector->hpd = NULL;
 155         }
 156
 157         drm_connector_unregister(connector);
 158         drm_connector_cleanup(connector);
 159
 160         omapdss_device_put(omap_connector->output);
 161
 162         kfree(omap_connector);
 163 }
 164
 165 #define MAX_EDID  512
 166
 167 static int omap_connector_get_modes_edid(struct drm_connector *connector,
 168                                          struct omap_dss_device *dssdev)
 169 {
 170         struct omap_connector *omap_connector = to_omap_connector(connector);
 171         enum drm_connector_status status;
 172         void *edid;
 173         int n;
 174
 175         status = omap_connector_detect(connector, false);
 176         if (status != connector_status_connected)
 177                 goto no_edid;
 178
 179         edid = kzalloc(MAX_EDID, GFP_KERNEL);
 180         if (!edid)
 181                 goto no_edid;
 182
 183         if (dssdev->ops->read_edid(dssdev, edid, MAX_EDID) <= 0 ||
 184             !drm_edid_is_valid(edid)) {
 185                 kfree(edid);
 186                 goto no_edid;
 187         }
 188
 189         drm_connector_update_edid_property(connector, edid);
 190         n = drm_add_edid_modes(connector, edid);
 191
 192         omap_connector->hdmi_mode = drm_detect_hdmi_monitor(edid);
 193
 194         kfree(edid);
 195         return n;
 196
 197 no_edid:
 198         drm_connector_update_edid_property(connector, NULL);
 199         return 0;
 200 }
 201
 202 static int omap_connector_get_modes(struct drm_connector *connector)
 203 {
 204         struct omap_connector *omap_connector = to_omap_connector(connector);
 205         struct omap_dss_device *dssdev;
 206
 207         DBG("%s", connector->name);
 208
 209         /*
 210          * If display exposes EDID, then we parse that in the normal way to
 211          * build table of supported modes.
 212          */
 213         dssdev = omap_connector_find_device(connector,
 214                                             OMAP_DSS_DEVICE_OP_EDID);
 215         if (dssdev)
 216                 return omap_connector_get_modes_edid(connector, dssdev);
 217
 218         /*
 219          * Otherwise if the display pipeline reports modes (e.g. with a fixed
 220          * resolution panel or an analog TV output), query it.
 221          */
 222         dssdev = omap_connector_find_device(connector,
 223                                             OMAP_DSS_DEVICE_OP_MODES);
 224         if (dssdev)
 225                 return dssdev->ops->get_modes(dssdev, connector);
 226
 227         /*
 228          * Otherwise if the display pipeline uses a drm_panel, we delegate the
 229          * operation to the panel API.
 230          */
 231         if (omap_connector->output->panel)
 232                 return drm_panel_get_modes(omap_connector->output->panel,
 233                                            connector);
 234
 235         /*
 236          * We can't retrieve modes, which can happen for instance for a DVI or
 237          * VGA output with the DDC bus unconnected. The KMS core will add the
 238          * default modes.
 239          */
 240         return 0;
 241 }
 242
 243 enum drm_mode_status omap_connector_mode_fixup(struct omap_dss_device *dssdev,
 244                                         const struct drm_display_mode *mode,
 245                                         struct drm_display_mode *adjusted_mode)
 246 {
 247         int ret;
 248
 249         drm_mode_copy(adjusted_mode, mode);
 250
 251         for (; dssdev; dssdev = dssdev->next) {
 252                 if (!dssdev->ops->check_timings)
 253                         continue;
 254
 255                 ret = dssdev->ops->check_timings(dssdev, adjusted_mode);
 256                 if (ret)
 257                         return MODE_BAD;
 258         }
 259
 260         return MODE_OK;
 261 }
 262
 263 static enum drm_mode_status omap_connector_mode_valid(struct drm_connector *connector,
 264                                  struct drm_display_mode *mode)
 265 {
 266         struct omap_connector *omap_connector = to_omap_connector(connector);
 267         struct drm_display_mode new_mode = { { 0 } };
 268         enum drm_mode_status status;
 269
 270         status = omap_connector_mode_fixup(omap_connector->output, mode,
 271                                            &new_mode);
 272         if (status != MODE_OK)
 273                 goto done;
 274
 275         /* Check if vrefresh is still valid. */
 276         if (drm_mode_vrefresh(mode) != drm_mode_vrefresh(&new_mode))
 277                 status = MODE_NOCLOCK;
 278
 279 done:
 280         DBG("connector: mode %s: " DRM_MODE_FMT,
 281                         (status == MODE_OK) ? "valid" : "invalid",
 282                         DRM_MODE_ARG(mode));
 283
 284         return status;
 285 }
 286
 287 static const struct drm_connector_funcs omap_connector_funcs = {
 288         .reset = drm_atomic_helper_connector_reset,
 289         .detect = omap_connector_detect,
 290         .fill_modes = drm_helper_probe_single_connector_modes,
 291         .destroy = omap_connector_destroy,
 292         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 293         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 294 };
 295
 296 static const struct drm_connector_helper_funcs omap_connector_helper_funcs = {
 297         .get_modes = omap_connector_get_modes,
 298         .mode_valid = omap_connector_mode_valid,
 299 };
 300
 301 static int omap_connector_get_type(struct omap_dss_device *output)
 302 {
 303         struct omap_dss_device *display;
 304         enum omap_display_type type;
 305
 306         display = omapdss_display_get(output);
 307         type = display->type;
 308         omapdss_device_put(display);
 309
 310         switch (type) {
 311         case OMAP_DISPLAY_TYPE_HDMI:
 312                 return DRM_MODE_CONNECTOR_HDMIA;
 313         case OMAP_DISPLAY_TYPE_DVI:
 314                 return DRM_MODE_CONNECTOR_DVID;
 315         case OMAP_DISPLAY_TYPE_DSI:
 316                 return DRM_MODE_CONNECTOR_DSI;
 317         case OMAP_DISPLAY_TYPE_DPI:
 318         case OMAP_DISPLAY_TYPE_DBI:
 319                 return DRM_MODE_CONNECTOR_DPI;
 320         case OMAP_DISPLAY_TYPE_VENC:
 321                 /* TODO: This could also be composite */
 322                 return DRM_MODE_CONNECTOR_SVIDEO;
 323         case OMAP_DISPLAY_TYPE_SDI:
 324                 return DRM_MODE_CONNECTOR_LVDS;
 325         default:
 326                 return DRM_MODE_CONNECTOR_Unknown;
 327         }
 328 }
 329
 330 /* initialize connector */
 331 struct drm_connector *omap_connector_init(struct drm_device *dev,
 332                                           struct omap_dss_device *output,
 333                                           struct drm_encoder *encoder)
 334 {
 335         struct drm_connector *connector = NULL;
 336         struct omap_connector *omap_connector;
 337         struct omap_dss_device *dssdev;
 338
 339         DBG("%s", output->name);
 340
 341         omap_connector = kzalloc(sizeof(*omap_connector), GFP_KERNEL);
 342         if (!omap_connector)
 343                 goto fail;
 344
 345         omap_connector->output = omapdss_device_get(output);
 346
 347         connector = &omap_connector->base;
 348         connector->interlace_allowed = 1;
 349         connector->doublescan_allowed = 0;
 350
 351         drm_connector_init(dev, connector, &omap_connector_funcs,
 352                            omap_connector_get_type(output));
 353         drm_connector_helper_add(connector, &omap_connector_helper_funcs);
 354
 355         /*
 356          * Initialize connector status handling. First try to find a device that
 357          * supports hot-plug reporting. If it fails, fall back to a device that
 358          * support polling. If that fails too, we don't support hot-plug
 359          * detection at all.
 360          */
 361         dssdev = omap_connector_find_device(connector, OMAP_DSS_DEVICE_OP_HPD);
 362         if (dssdev) {
 363                 omap_connector->hpd = omapdss_device_get(dssdev);
 364                 connector->polled = DRM_CONNECTOR_POLL_HPD;
 365         } else {
 366                 dssdev = omap_connector_find_device(connector,
 367                                                     OMAP_DSS_DEVICE_OP_DETECT);
 368                 if (dssdev)
 369                         connector->polled = DRM_CONNECTOR_POLL_CONNECT |
 370                                             DRM_CONNECTOR_POLL_DISCONNECT;
 371         }
 372
 373         return connector;
 374
 375 fail:
 376         if (connector)
 377                 omap_connector_destroy(connector);
 378
 379         return NULL;
 380 }