drivers/gpu/drm/omapdrm/omap_connector.c

   1 /*
   2  * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
   3  * Author: Rob Clark <[email protected]>
   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
  18 #include <drm/drm_atomic_helper.h>
  19 #include <drm/drm_crtc.h>
  20 #include <drm/drm_crtc_helper.h>
  21
  22 #include "omap_drv.h"
  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;
  33         bool hdmi_mode;
  34 };
  35
  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
  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
  60 static enum drm_connector_status omap_connector_detect(
  61                 struct drm_connector *connector, bool force)
  62 {
  63         struct omap_connector *omap_connector = to_omap_connector(connector);
  64         struct omap_dss_device *dssdev = omap_connector->dssdev;
  65         struct omap_dss_driver *dssdrv = dssdev->driver;
  66         enum drm_connector_status ret;
  67
  68         if (dssdrv->detect) {
  69                 if (dssdrv->detect(dssdev))
  70                         ret = connector_status_connected;
  71                 else
  72                         ret = connector_status_disconnected;
  73         } else if (dssdev->type == OMAP_DISPLAY_TYPE_DPI ||
  74                         dssdev->type == OMAP_DISPLAY_TYPE_DBI ||
  75                         dssdev->type == OMAP_DISPLAY_TYPE_SDI ||
  76                         dssdev->type == OMAP_DISPLAY_TYPE_DSI) {
  77                 ret = connector_status_connected;
  78         } else {
  79                 ret = connector_status_unknown;
  80         }
  81
  82         VERB("%s: %d (force=%d)", omap_connector->dssdev->name, ret, force);
  83
  84         return ret;
  85 }
  86
  87 static void omap_connector_destroy(struct drm_connector *connector)
  88 {
  89         struct omap_connector *omap_connector = to_omap_connector(connector);
  90         struct omap_dss_device *dssdev = omap_connector->dssdev;
  91
  92         DBG("%s", omap_connector->dssdev->name);
  93         if (connector->polled == DRM_CONNECTOR_POLL_HPD &&
  94             dssdev->driver->unregister_hpd_cb) {
  95                 dssdev->driver->unregister_hpd_cb(dssdev);
  96         }
  97         drm_connector_unregister(connector);
  98         drm_connector_cleanup(connector);
  99         kfree(omap_connector);
 100
 101         omap_dss_put_device(dssdev);
 102 }
 103
 104 #define MAX_EDID  512
 105
 106 static int omap_connector_get_modes(struct drm_connector *connector)
 107 {
 108         struct omap_connector *omap_connector = to_omap_connector(connector);
 109         struct omap_dss_device *dssdev = omap_connector->dssdev;
 110         struct omap_dss_driver *dssdrv = dssdev->driver;
 111         struct drm_device *dev = connector->dev;
 112         int n = 0;
 113
 114         DBG("%s", omap_connector->dssdev->name);
 115
 116         /* if display exposes EDID, then we parse that in the normal way to
 117          * build table of supported modes.. otherwise (ie. fixed resolution
 118          * LCD panels) we just return a single mode corresponding to the
 119          * currently configured timings:
 120          */
 121         if (dssdrv->read_edid) {
 122                 void *edid = kzalloc(MAX_EDID, GFP_KERNEL);
 123
 124                 if (!edid)
 125                         return 0;
 126
 127                 if ((dssdrv->read_edid(dssdev, edid, MAX_EDID) > 0) &&
 128                                 drm_edid_is_valid(edid)) {
 129                         drm_mode_connector_update_edid_property(
 130                                         connector, edid);
 131                         n = drm_add_edid_modes(connector, edid);
 132
 133                         omap_connector->hdmi_mode =
 134                                 drm_detect_hdmi_monitor(edid);
 135                 } else {
 136                         drm_mode_connector_update_edid_property(
 137                                         connector, NULL);
 138                 }
 139
 140                 kfree(edid);
 141         } else {
 142                 struct drm_display_mode *mode = drm_mode_create(dev);
 143                 struct videomode vm = {0};
 144
 145                 if (!mode)
 146                         return 0;
 147
 148                 dssdrv->get_timings(dssdev, &vm);
 149
 150                 drm_display_mode_from_videomode(&vm, mode);
 151
 152                 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 153                 drm_mode_set_name(mode);
 154                 drm_mode_probed_add(connector, mode);
 155
 156                 if (dssdrv->get_size) {
 157                         dssdrv->get_size(dssdev,
 158                                          &connector->display_info.width_mm,
 159                                          &connector->display_info.height_mm);
 160                 }
 161
 162                 n = 1;
 163         }
 164
 165         return n;
 166 }
 167
 168 static int omap_connector_mode_valid(struct drm_connector *connector,
 169                                  struct drm_display_mode *mode)
 170 {
 171         struct omap_connector *omap_connector = to_omap_connector(connector);
 172         struct omap_dss_device *dssdev = omap_connector->dssdev;
 173         struct omap_dss_driver *dssdrv = dssdev->driver;
 174         struct videomode vm = {0};
 175         struct drm_device *dev = connector->dev;
 176         struct drm_display_mode *new_mode;
 177         int r, ret = MODE_BAD;
 178
 179         drm_display_mode_to_videomode(mode, &vm);
 180         mode->vrefresh = drm_mode_vrefresh(mode);
 181
 182         /*
 183          * if the panel driver doesn't have a check_timings, it's most likely
 184          * a fixed resolution panel, check if the timings match with the
 185          * panel's timings
 186          */
 187         if (dssdrv->check_timings) {
 188                 r = dssdrv->check_timings(dssdev, &vm);
 189         } else {
 190                 struct videomode t = {0};
 191
 192                 dssdrv->get_timings(dssdev, &t);
 193
 194                 /*
 195                  * Ignore the flags, as we don't get them from
 196                  * drm_display_mode_to_videomode.
 197                  */
 198                 t.flags = 0;
 199
 200                 if (memcmp(&vm, &t, sizeof(vm)))
 201                         r = -EINVAL;
 202                 else
 203                         r = 0;
 204         }
 205
 206         if (!r) {
 207                 /* check if vrefresh is still valid */
 208                 new_mode = drm_mode_duplicate(dev, mode);
 209
 210                 if (!new_mode)
 211                         return MODE_BAD;
 212
 213                 new_mode->clock = vm.pixelclock / 1000;
 214                 new_mode->vrefresh = 0;
 215                 if (mode->vrefresh == drm_mode_vrefresh(new_mode))
 216                         ret = MODE_OK;
 217                 drm_mode_destroy(dev, new_mode);
 218         }
 219
 220         DBG("connector: mode %s: "
 221                         "%d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x",
 222                         (ret == MODE_OK) ? "valid" : "invalid",
 223                         mode->base.id, mode->name, mode->vrefresh, mode->clock,
 224                         mode->hdisplay, mode->hsync_start,
 225                         mode->hsync_end, mode->htotal,
 226                         mode->vdisplay, mode->vsync_start,
 227                         mode->vsync_end, mode->vtotal, mode->type, mode->flags);
 228
 229         return ret;
 230 }
 231
 232 static const struct drm_connector_funcs omap_connector_funcs = {
 233         .reset = drm_atomic_helper_connector_reset,
 234         .detect = omap_connector_detect,
 235         .fill_modes = drm_helper_probe_single_connector_modes,
 236         .destroy = omap_connector_destroy,
 237         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 238         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 239 };
 240
 241 static const struct drm_connector_helper_funcs omap_connector_helper_funcs = {
 242         .get_modes = omap_connector_get_modes,
 243         .mode_valid = omap_connector_mode_valid,
 244 };
 245
 246 /* initialize connector */
 247 struct drm_connector *omap_connector_init(struct drm_device *dev,
 248                 int connector_type, struct omap_dss_device *dssdev,
 249                 struct drm_encoder *encoder)
 250 {
 251         struct drm_connector *connector = NULL;
 252         struct omap_connector *omap_connector;
 253         bool hpd_supported = false;
 254
 255         DBG("%s", dssdev->name);
 256
 257         omap_dss_get_device(dssdev);
 258
 259         omap_connector = kzalloc(sizeof(*omap_connector), GFP_KERNEL);
 260         if (!omap_connector)
 261                 goto fail;
 262
 263         omap_connector->dssdev = dssdev;
 264
 265         connector = &omap_connector->base;
 266
 267         drm_connector_init(dev, connector, &omap_connector_funcs,
 268                                 connector_type);
 269         drm_connector_helper_add(connector, &omap_connector_helper_funcs);
 270
 271         if (dssdev->driver->register_hpd_cb) {
 272                 int ret = dssdev->driver->register_hpd_cb(dssdev,
 273                                                           omap_connector_hpd_cb,
 274                                                           omap_connector);
 275                 if (!ret)
 276                         hpd_supported = true;
 277                 else if (ret != -ENOTSUPP)
 278                         DBG("%s: Failed to register HPD callback (%d).",
 279                             dssdev->name, ret);
 280         }
 281
 282         if (hpd_supported)
 283                 connector->polled = DRM_CONNECTOR_POLL_HPD;
 284         else if (dssdev->driver->detect)
 285                 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
 286                                     DRM_CONNECTOR_POLL_DISCONNECT;
 287         else
 288                 connector->polled = 0;
 289
 290         connector->interlace_allowed = 1;
 291         connector->doublescan_allowed = 0;
 292
 293         return connector;
 294
 295 fail:
 296         if (connector)
 297                 omap_connector_destroy(connector);
 298
 299         return NULL;
 300 }