drivers/gpu/drm/omapdrm/omap_encoder.c

   1 /*
   2  * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
   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
  18 #include <linux/list.h>
  19
  20 #include <drm/drm_crtc.h>
  21 #include <drm/drm_modeset_helper_vtables.h>
  22 #include <drm/drm_edid.h>
  23
  24 #include "omap_drv.h"
  25
  26 /*
  27  * encoder funcs
  28  */
  29
  30 #define to_omap_encoder(x) container_of(x, struct omap_encoder, base)
  31
  32 /* The encoder and connector both map to same dssdev.. the encoder
  33  * handles the 'active' parts, ie. anything the modifies the state
  34  * of the hw, and the connector handles the 'read-only' parts, like
  35  * detecting connection and reading edid.
  36  */
  37 struct omap_encoder {
  38         struct drm_encoder base;
  39         struct omap_dss_device *output;
  40         struct omap_dss_device *display;
  41 };
  42
  43 static void omap_encoder_destroy(struct drm_encoder *encoder)
  44 {
  45         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
  46
  47         drm_encoder_cleanup(encoder);
  48         kfree(omap_encoder);
  49 }
  50
  51 static const struct drm_encoder_funcs omap_encoder_funcs = {
  52         .destroy = omap_encoder_destroy,
  53 };
  54
  55 static void omap_encoder_hdmi_mode_set(struct drm_encoder *encoder,
  56                                        struct drm_display_mode *adjusted_mode)
  57 {
  58         struct drm_device *dev = encoder->dev;
  59         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
  60         struct omap_dss_device *dssdev = omap_encoder->output;
  61         struct drm_connector *connector;
  62         bool hdmi_mode;
  63
  64         hdmi_mode = false;
  65         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  66                 if (connector->encoder == encoder) {
  67                         hdmi_mode = omap_connector_get_hdmi_mode(connector);
  68                         break;
  69                 }
  70         }
  71
  72         if (dssdev->ops->hdmi.set_hdmi_mode)
  73                 dssdev->ops->hdmi.set_hdmi_mode(dssdev, hdmi_mode);
  74
  75         if (hdmi_mode && dssdev->ops->hdmi.set_infoframe) {
  76                 struct hdmi_avi_infoframe avi;
  77                 int r;
  78
  79                 r = drm_hdmi_avi_infoframe_from_display_mode(&avi, connector,
  80                                                              adjusted_mode);
  81                 if (r == 0)
  82                         dssdev->ops->hdmi.set_infoframe(dssdev, &avi);
  83         }
  84 }
  85
  86 static void omap_encoder_mode_set(struct drm_encoder *encoder,
  87                                   struct drm_display_mode *mode,
  88                                   struct drm_display_mode *adjusted_mode)
  89 {
  90         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
  91         struct omap_dss_device *dssdev;
  92         struct videomode vm = { 0 };
  93
  94         drm_display_mode_to_videomode(adjusted_mode, &vm);
  95
  96         /*
  97          * HACK: This fixes the vm flags.
  98          * struct drm_display_mode does not contain the VSYNC/HSYNC/DE flags and
  99          * they get lost when converting back and forth between struct
 100          * drm_display_mode and struct videomode. The hack below goes and
 101          * fetches the missing flags.
 102          *
 103          * A better solution is to use DRM's bus-flags through the whole driver.
 104          */
 105         for (dssdev = omap_encoder->output; dssdev; dssdev = dssdev->next) {
 106                 unsigned long bus_flags = dssdev->bus_flags;
 107
 108                 if (!(vm.flags & (DISPLAY_FLAGS_DE_LOW |
 109                                   DISPLAY_FLAGS_DE_HIGH))) {
 110                         if (bus_flags & DRM_BUS_FLAG_DE_LOW)
 111                                 vm.flags |= DISPLAY_FLAGS_DE_LOW;
 112                         else if (bus_flags & DRM_BUS_FLAG_DE_HIGH)
 113                                 vm.flags |= DISPLAY_FLAGS_DE_HIGH;
 114                 }
 115
 116                 if (!(vm.flags & (DISPLAY_FLAGS_PIXDATA_POSEDGE |
 117                                   DISPLAY_FLAGS_PIXDATA_NEGEDGE))) {
 118                         if (bus_flags & DRM_BUS_FLAG_PIXDATA_POSEDGE)
 119                                 vm.flags |= DISPLAY_FLAGS_PIXDATA_POSEDGE;
 120                         else if (bus_flags & DRM_BUS_FLAG_PIXDATA_NEGEDGE)
 121                                 vm.flags |= DISPLAY_FLAGS_PIXDATA_NEGEDGE;
 122                 }
 123
 124                 if (!(vm.flags & (DISPLAY_FLAGS_SYNC_POSEDGE |
 125                                   DISPLAY_FLAGS_SYNC_NEGEDGE))) {
 126                         if (bus_flags & DRM_BUS_FLAG_SYNC_POSEDGE)
 127                                 vm.flags |= DISPLAY_FLAGS_SYNC_POSEDGE;
 128                         else if (bus_flags & DRM_BUS_FLAG_SYNC_NEGEDGE)
 129                                 vm.flags |= DISPLAY_FLAGS_SYNC_NEGEDGE;
 130                 }
 131         }
 132
 133         /* Set timings for all devices in the display pipeline. */
 134         dss_mgr_set_timings(omap_encoder->output, &vm);
 135
 136         for (dssdev = omap_encoder->output; dssdev; dssdev = dssdev->next) {
 137                 if (dssdev->ops->set_timings)
 138                         dssdev->ops->set_timings(dssdev, &vm);
 139         }
 140
 141         /* Set the HDMI mode and HDMI infoframe if applicable. */
 142         if (omap_encoder->output->output_type == OMAP_DISPLAY_TYPE_HDMI)
 143                 omap_encoder_hdmi_mode_set(encoder, adjusted_mode);
 144 }
 145
 146 static void omap_encoder_disable(struct drm_encoder *encoder)
 147 {
 148         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 149         struct omap_dss_device *dssdev = omap_encoder->display;
 150
 151         dssdev->ops->disable(dssdev);
 152 }
 153
 154 static void omap_encoder_enable(struct drm_encoder *encoder)
 155 {
 156         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 157         struct omap_dss_device *dssdev = omap_encoder->display;
 158         int r;
 159
 160         r = dssdev->ops->enable(dssdev);
 161         if (r)
 162                 dev_err(encoder->dev->dev,
 163                         "Failed to enable display '%s': %d\n",
 164                         dssdev->name, r);
 165 }
 166
 167 static int omap_encoder_atomic_check(struct drm_encoder *encoder,
 168                                      struct drm_crtc_state *crtc_state,
 169                                      struct drm_connector_state *conn_state)
 170 {
 171         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 172         enum omap_channel channel = omap_encoder->output->dispc_channel;
 173         struct drm_device *dev = encoder->dev;
 174         struct omap_drm_private *priv = dev->dev_private;
 175         struct omap_dss_device *dssdev;
 176         struct videomode vm = { 0 };
 177         int ret;
 178
 179         drm_display_mode_to_videomode(&crtc_state->mode, &vm);
 180
 181         ret = priv->dispc_ops->mgr_check_timings(priv->dispc, channel, &vm);
 182         if (ret)
 183                 goto done;
 184
 185         for (dssdev = omap_encoder->output; dssdev; dssdev = dssdev->next) {
 186                 if (!dssdev->ops->check_timings)
 187                         continue;
 188
 189                 ret = dssdev->ops->check_timings(dssdev, &vm);
 190                 if (ret)
 191                         goto done;
 192         }
 193
 194         drm_display_mode_from_videomode(&vm, &crtc_state->adjusted_mode);
 195
 196 done:
 197         if (ret)
 198                 dev_err(dev->dev, "invalid timings: %d\n", ret);
 199
 200         return ret;
 201 }
 202
 203 static const struct drm_encoder_helper_funcs omap_encoder_helper_funcs = {
 204         .mode_set = omap_encoder_mode_set,
 205         .disable = omap_encoder_disable,
 206         .enable = omap_encoder_enable,
 207         .atomic_check = omap_encoder_atomic_check,
 208 };
 209
 210 /* initialize encoder */
 211 struct drm_encoder *omap_encoder_init(struct drm_device *dev,
 212                                       struct omap_dss_device *output,
 213                                       struct omap_dss_device *display)
 214 {
 215         struct drm_encoder *encoder = NULL;
 216         struct omap_encoder *omap_encoder;
 217
 218         omap_encoder = kzalloc(sizeof(*omap_encoder), GFP_KERNEL);
 219         if (!omap_encoder)
 220                 goto fail;
 221
 222         omap_encoder->output = output;
 223         omap_encoder->display = display;
 224
 225         encoder = &omap_encoder->base;
 226
 227         drm_encoder_init(dev, encoder, &omap_encoder_funcs,
 228                          DRM_MODE_ENCODER_TMDS, NULL);
 229         drm_encoder_helper_add(encoder, &omap_encoder_helper_funcs);
 230
 231         return encoder;
 232
 233 fail:
 234         if (encoder)
 235                 omap_encoder_destroy(encoder);
 236
 237         return NULL;
 238 }