drivers/gpu/drm/omapdrm/omap_encoder.c

   1 /*
   2  * drivers/gpu/drm/omapdrm/omap_encoder.c
   3  *
   4  * Copyright (C) 2011 Texas Instruments
   5  * Author: Rob Clark <rob@ti.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 as published by
   9  * the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <linux/list.h>
  21
  22 #include <drm/drm_crtc.h>
  23 #include <drm/drm_crtc_helper.h>
  24 #include <drm/drm_edid.h>
  25
  26 #include "omap_drv.h"
  27
  28 /*
  29  * encoder funcs
  30  */
  31
  32 #define to_omap_encoder(x) container_of(x, struct omap_encoder, base)
  33
  34 /* The encoder and connector both map to same dssdev.. the encoder
  35  * handles the 'active' parts, ie. anything the modifies the state
  36  * of the hw, and the connector handles the 'read-only' parts, like
  37  * detecting connection and reading edid.
  38  */
  39 struct omap_encoder {
  40         struct drm_encoder base;
  41         struct omap_dss_device *dssdev;
  42 };
  43
  44 struct omap_dss_device *omap_encoder_get_dssdev(struct drm_encoder *encoder)
  45 {
  46         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
  47
  48         return omap_encoder->dssdev;
  49 }
  50
  51 static void omap_encoder_destroy(struct drm_encoder *encoder)
  52 {
  53         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
  54
  55         omap_encoder_set_enabled(encoder, false);
  56
  57         drm_encoder_cleanup(encoder);
  58         kfree(omap_encoder);
  59 }
  60
  61 static const struct drm_encoder_funcs omap_encoder_funcs = {
  62         .destroy = omap_encoder_destroy,
  63 };
  64
  65 /*
  66  * The CRTC drm_crtc_helper_set_mode() doesn't really give us the right
  67  * order.. the easiest way to work around this for now is to make all
  68  * the encoder-helper's no-op's and have the omap_crtc code take care
  69  * of the sequencing and call us in the right points.
  70  *
  71  * Eventually to handle connecting CRTCs to different encoders properly,
  72  * either the CRTC helpers need to change or we need to replace
  73  * drm_crtc_helper_set_mode(), but lets wait until atomic-modeset for
  74  * that.
  75  */
  76
  77 static void omap_encoder_dpms(struct drm_encoder *encoder, int mode)
  78 {
  79 }
  80
  81 static bool omap_encoder_mode_fixup(struct drm_encoder *encoder,
  82                                   const struct drm_display_mode *mode,
  83                                   struct drm_display_mode *adjusted_mode)
  84 {
  85         return true;
  86 }
  87
  88 static void omap_encoder_mode_set(struct drm_encoder *encoder,
  89                                 struct drm_display_mode *mode,
  90                                 struct drm_display_mode *adjusted_mode)
  91 {
  92         struct drm_device *dev = encoder->dev;
  93         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
  94         struct omap_dss_device *dssdev = omap_encoder->dssdev;
  95         struct drm_connector *connector;
  96         bool hdmi_mode;
  97         int r;
  98
  99         hdmi_mode = false;
 100         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 101                 if (connector->encoder == encoder) {
 102                         hdmi_mode = omap_connector_get_hdmi_mode(connector);
 103                         break;
 104                 }
 105         }
 106
 107         if (dssdev->driver->set_hdmi_mode)
 108                 dssdev->driver->set_hdmi_mode(dssdev, hdmi_mode);
 109
 110         if (hdmi_mode && dssdev->driver->set_hdmi_infoframe) {
 111                 struct hdmi_avi_infoframe avi;
 112
 113                 r = drm_hdmi_avi_infoframe_from_display_mode(&avi, adjusted_mode);
 114                 if (r == 0)
 115                         dssdev->driver->set_hdmi_infoframe(dssdev, &avi);
 116         }
 117 }
 118
 119 static void omap_encoder_prepare(struct drm_encoder *encoder)
 120 {
 121 }
 122
 123 static void omap_encoder_commit(struct drm_encoder *encoder)
 124 {
 125 }
 126
 127 static void omap_encoder_disable(struct drm_encoder *encoder)
 128 {
 129 }
 130
 131 static void omap_encoder_enable(struct drm_encoder *encoder)
 132 {
 133 }
 134
 135 static const struct drm_encoder_helper_funcs omap_encoder_helper_funcs = {
 136         .dpms = omap_encoder_dpms,
 137         .mode_fixup = omap_encoder_mode_fixup,
 138         .mode_set = omap_encoder_mode_set,
 139         .prepare = omap_encoder_prepare,
 140         .commit = omap_encoder_commit,
 141         .disable = omap_encoder_disable,
 142         .enable = omap_encoder_enable,
 143 };
 144
 145 /*
 146  * Instead of relying on the helpers for modeset, the omap_crtc code
 147  * calls these functions in the proper sequence.
 148  */
 149
 150 int omap_encoder_set_enabled(struct drm_encoder *encoder, bool enabled)
 151 {
 152         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 153         struct omap_dss_device *dssdev = omap_encoder->dssdev;
 154         struct omap_dss_driver *dssdrv = dssdev->driver;
 155
 156         if (enabled) {
 157                 return dssdrv->enable(dssdev);
 158         } else {
 159                 dssdrv->disable(dssdev);
 160                 return 0;
 161         }
 162 }
 163
 164 int omap_encoder_update(struct drm_encoder *encoder,
 165                 struct omap_overlay_manager *mgr,
 166                 struct omap_video_timings *timings)
 167 {
 168         struct drm_device *dev = encoder->dev;
 169         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 170         struct omap_dss_device *dssdev = omap_encoder->dssdev;
 171         struct omap_dss_driver *dssdrv = dssdev->driver;
 172         int ret;
 173
 174         dssdev->src->manager = mgr;
 175
 176         if (dssdrv->check_timings) {
 177                 ret = dssdrv->check_timings(dssdev, timings);
 178         } else {
 179                 struct omap_video_timings t = {0};
 180
 181                 dssdrv->get_timings(dssdev, &t);
 182
 183                 if (memcmp(timings, &t, sizeof(struct omap_video_timings)))
 184                         ret = -EINVAL;
 185                 else
 186                         ret = 0;
 187         }
 188
 189         if (ret) {
 190                 dev_err(dev->dev, "could not set timings: %d\n", ret);
 191                 return ret;
 192         }
 193
 194         if (dssdrv->set_timings)
 195                 dssdrv->set_timings(dssdev, timings);
 196
 197         return 0;
 198 }
 199
 200 /* initialize encoder */
 201 struct drm_encoder *omap_encoder_init(struct drm_device *dev,
 202                 struct omap_dss_device *dssdev)
 203 {
 204         struct drm_encoder *encoder = NULL;
 205         struct omap_encoder *omap_encoder;
 206
 207         omap_encoder = kzalloc(sizeof(*omap_encoder), GFP_KERNEL);
 208         if (!omap_encoder)
 209                 goto fail;
 210
 211         omap_encoder->dssdev = dssdev;
 212
 213         encoder = &omap_encoder->base;
 214
 215         drm_encoder_init(dev, encoder, &omap_encoder_funcs,
 216                          DRM_MODE_ENCODER_TMDS);
 217         drm_encoder_helper_add(encoder, &omap_encoder_helper_funcs);
 218
 219         return encoder;
 220
 221 fail:
 222         if (encoder)
 223                 omap_encoder_destroy(encoder);
 224
 225         return NULL;
 226 }