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         drm_encoder_cleanup(encoder);
  56         kfree(omap_encoder);
  57 }
  58
  59 static const struct drm_encoder_funcs omap_encoder_funcs = {
  60         .destroy = omap_encoder_destroy,
  61 };
  62
  63 static void omap_encoder_mode_set(struct drm_encoder *encoder,
  64                                 struct drm_display_mode *mode,
  65                                 struct drm_display_mode *adjusted_mode)
  66 {
  67         struct drm_device *dev = encoder->dev;
  68         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
  69         struct omap_dss_device *dssdev = omap_encoder->dssdev;
  70         struct drm_connector *connector;
  71         bool hdmi_mode;
  72         int r;
  73
  74         hdmi_mode = false;
  75         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  76                 if (connector->encoder == encoder) {
  77                         hdmi_mode = omap_connector_get_hdmi_mode(connector);
  78                         break;
  79                 }
  80         }
  81
  82         if (dssdev->driver->set_hdmi_mode)
  83                 dssdev->driver->set_hdmi_mode(dssdev, hdmi_mode);
  84
  85         if (hdmi_mode && dssdev->driver->set_hdmi_infoframe) {
  86                 struct hdmi_avi_infoframe avi;
  87
  88                 r = drm_hdmi_avi_infoframe_from_display_mode(&avi, adjusted_mode,
  89                                                              false);
  90                 if (r == 0)
  91                         dssdev->driver->set_hdmi_infoframe(dssdev, &avi);
  92         }
  93 }
  94
  95 static void omap_encoder_disable(struct drm_encoder *encoder)
  96 {
  97         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
  98         struct omap_dss_device *dssdev = omap_encoder->dssdev;
  99         struct omap_dss_driver *dssdrv = dssdev->driver;
 100
 101         dssdrv->disable(dssdev);
 102 }
 103
 104 static int omap_encoder_update(struct drm_encoder *encoder,
 105                                enum omap_channel channel,
 106                                struct videomode *vm)
 107 {
 108         struct drm_device *dev = encoder->dev;
 109         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 110         struct omap_dss_device *dssdev = omap_encoder->dssdev;
 111         struct omap_dss_driver *dssdrv = dssdev->driver;
 112         int ret;
 113
 114         if (dssdrv->check_timings) {
 115                 ret = dssdrv->check_timings(dssdev, vm);
 116         } else {
 117                 struct videomode t = {0};
 118
 119                 dssdrv->get_timings(dssdev, &t);
 120
 121                 if (memcmp(vm, &t, sizeof(*vm)))
 122                         ret = -EINVAL;
 123                 else
 124                         ret = 0;
 125         }
 126
 127         if (ret) {
 128                 dev_err(dev->dev, "could not set timings: %d\n", ret);
 129                 return ret;
 130         }
 131
 132         if (dssdrv->set_timings)
 133                 dssdrv->set_timings(dssdev, vm);
 134
 135         return 0;
 136 }
 137
 138 static void omap_encoder_enable(struct drm_encoder *encoder)
 139 {
 140         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 141         struct omap_dss_device *dssdev = omap_encoder->dssdev;
 142         struct omap_dss_driver *dssdrv = dssdev->driver;
 143         int r;
 144
 145         omap_encoder_update(encoder, omap_crtc_channel(encoder->crtc),
 146                             omap_crtc_timings(encoder->crtc));
 147
 148         r = dssdrv->enable(dssdev);
 149         if (r)
 150                 dev_err(encoder->dev->dev,
 151                         "Failed to enable display '%s': %d\n",
 152                         dssdev->name, r);
 153 }
 154
 155 static int omap_encoder_atomic_check(struct drm_encoder *encoder,
 156                                      struct drm_crtc_state *crtc_state,
 157                                      struct drm_connector_state *conn_state)
 158 {
 159         return 0;
 160 }
 161
 162 static const struct drm_encoder_helper_funcs omap_encoder_helper_funcs = {
 163         .mode_set = omap_encoder_mode_set,
 164         .disable = omap_encoder_disable,
 165         .enable = omap_encoder_enable,
 166         .atomic_check = omap_encoder_atomic_check,
 167 };
 168
 169 /* initialize encoder */
 170 struct drm_encoder *omap_encoder_init(struct drm_device *dev,
 171                 struct omap_dss_device *dssdev)
 172 {
 173         struct drm_encoder *encoder = NULL;
 174         struct omap_encoder *omap_encoder;
 175
 176         omap_encoder = kzalloc(sizeof(*omap_encoder), GFP_KERNEL);
 177         if (!omap_encoder)
 178                 goto fail;
 179
 180         omap_encoder->dssdev = dssdev;
 181
 182         encoder = &omap_encoder->base;
 183
 184         drm_encoder_init(dev, encoder, &omap_encoder_funcs,
 185                          DRM_MODE_ENCODER_TMDS, NULL);
 186         drm_encoder_helper_add(encoder, &omap_encoder_helper_funcs);
 187
 188         return encoder;
 189
 190 fail:
 191         if (encoder)
 192                 omap_encoder_destroy(encoder);
 193
 194         return NULL;
 195 }