drivers/gpu/drm/omapdrm/omap_encoder.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 <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 #include <drm/drm_panel.h>
  24
  25 #include "omap_drv.h"
  26
  27 /*
  28  * encoder funcs
  29  */
  30
  31 #define to_omap_encoder(x) container_of(x, struct omap_encoder, base)
  32
  33 /* The encoder and connector both map to same dssdev.. the encoder
  34  * handles the 'active' parts, ie. anything the modifies the state
  35  * of the hw, and the connector handles the 'read-only' parts, like
  36  * detecting connection and reading edid.
  37  */
  38 struct omap_encoder {
  39         struct drm_encoder base;
  40         struct omap_dss_device *output;
  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_update_videomode_flags(struct videomode *vm,
  56                                                 u32 bus_flags)
  57 {
  58         if (!(vm->flags & (DISPLAY_FLAGS_DE_LOW |
  59                            DISPLAY_FLAGS_DE_HIGH))) {
  60                 if (bus_flags & DRM_BUS_FLAG_DE_LOW)
  61                         vm->flags |= DISPLAY_FLAGS_DE_LOW;
  62                 else if (bus_flags & DRM_BUS_FLAG_DE_HIGH)
  63                         vm->flags |= DISPLAY_FLAGS_DE_HIGH;
  64         }
  65
  66         if (!(vm->flags & (DISPLAY_FLAGS_PIXDATA_POSEDGE |
  67                            DISPLAY_FLAGS_PIXDATA_NEGEDGE))) {
  68                 if (bus_flags & DRM_BUS_FLAG_PIXDATA_DRIVE_POSEDGE)
  69                         vm->flags |= DISPLAY_FLAGS_PIXDATA_POSEDGE;
  70                 else if (bus_flags & DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE)
  71                         vm->flags |= DISPLAY_FLAGS_PIXDATA_NEGEDGE;
  72         }
  73
  74         if (!(vm->flags & (DISPLAY_FLAGS_SYNC_POSEDGE |
  75                            DISPLAY_FLAGS_SYNC_NEGEDGE))) {
  76                 if (bus_flags & DRM_BUS_FLAG_SYNC_DRIVE_POSEDGE)
  77                         vm->flags |= DISPLAY_FLAGS_SYNC_POSEDGE;
  78                 else if (bus_flags & DRM_BUS_FLAG_SYNC_DRIVE_NEGEDGE)
  79                         vm->flags |= DISPLAY_FLAGS_SYNC_NEGEDGE;
  80         }
  81 }
  82
  83 static void omap_encoder_hdmi_mode_set(struct drm_connector *connector,
  84                                        struct drm_encoder *encoder,
  85                                        struct drm_display_mode *adjusted_mode)
  86 {
  87         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
  88         struct omap_dss_device *dssdev = omap_encoder->output;
  89         bool hdmi_mode;
  90
  91         hdmi_mode = omap_connector_get_hdmi_mode(connector);
  92
  93         if (dssdev->ops->hdmi.set_hdmi_mode)
  94                 dssdev->ops->hdmi.set_hdmi_mode(dssdev, hdmi_mode);
  95
  96         if (hdmi_mode && dssdev->ops->hdmi.set_infoframe) {
  97                 struct hdmi_avi_infoframe avi;
  98                 int r;
  99
 100                 r = drm_hdmi_avi_infoframe_from_display_mode(&avi, connector,
 101                                                              adjusted_mode);
 102                 if (r == 0)
 103                         dssdev->ops->hdmi.set_infoframe(dssdev, &avi);
 104         }
 105 }
 106
 107 static void omap_encoder_mode_set(struct drm_encoder *encoder,
 108                                   struct drm_display_mode *mode,
 109                                   struct drm_display_mode *adjusted_mode)
 110 {
 111         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 112         struct omap_dss_device *output = omap_encoder->output;
 113         struct omap_dss_device *dssdev;
 114         struct drm_device *dev = encoder->dev;
 115         struct drm_connector *connector;
 116         struct drm_bridge *bridge;
 117         struct videomode vm = { 0 };
 118         u32 bus_flags;
 119
 120         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 121                 if (connector->encoder == encoder)
 122                         break;
 123         }
 124
 125         drm_display_mode_to_videomode(adjusted_mode, &vm);
 126
 127         /*
 128          * HACK: This fixes the vm flags.
 129          * struct drm_display_mode does not contain the VSYNC/HSYNC/DE flags and
 130          * they get lost when converting back and forth between struct
 131          * drm_display_mode and struct videomode. The hack below goes and
 132          * fetches the missing flags.
 133          *
 134          * A better solution is to use DRM's bus-flags through the whole driver.
 135          */
 136         for (dssdev = output; dssdev; dssdev = dssdev->next)
 137                 omap_encoder_update_videomode_flags(&vm, dssdev->bus_flags);
 138
 139         for (bridge = output->bridge; bridge; bridge = bridge->next) {
 140                 if (!bridge->timings)
 141                         continue;
 142
 143                 bus_flags = bridge->timings->input_bus_flags;
 144                 omap_encoder_update_videomode_flags(&vm, bus_flags);
 145         }
 146
 147         bus_flags = connector->display_info.bus_flags;
 148         omap_encoder_update_videomode_flags(&vm, bus_flags);
 149
 150         /* Set timings for all devices in the display pipeline. */
 151         dss_mgr_set_timings(output, &vm);
 152
 153         for (dssdev = output; dssdev; dssdev = dssdev->next) {
 154                 if (dssdev->ops->set_timings)
 155                         dssdev->ops->set_timings(dssdev, adjusted_mode);
 156         }
 157
 158         /* Set the HDMI mode and HDMI infoframe if applicable. */
 159         if (output->type == OMAP_DISPLAY_TYPE_HDMI)
 160                 omap_encoder_hdmi_mode_set(connector, encoder, adjusted_mode);
 161 }
 162
 163 static void omap_encoder_disable(struct drm_encoder *encoder)
 164 {
 165         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 166         struct omap_dss_device *dssdev = omap_encoder->output;
 167         struct drm_device *dev = encoder->dev;
 168
 169         dev_dbg(dev->dev, "disable(%s)\n", dssdev->name);
 170
 171         /* Disable the panel if present. */
 172         if (dssdev->panel) {
 173                 drm_panel_disable(dssdev->panel);
 174                 drm_panel_unprepare(dssdev->panel);
 175         }
 176
 177         /*
 178          * Disable the chain of external devices, starting at the one at the
 179          * internal encoder's output.
 180          */
 181         omapdss_device_disable(dssdev->next);
 182
 183         /*
 184          * Disable the internal encoder. This will disable the DSS output. The
 185          * DSI is treated as an exception as DSI pipelines still use the legacy
 186          * flow where the pipeline output controls the encoder.
 187          */
 188         if (dssdev->type != OMAP_DISPLAY_TYPE_DSI) {
 189                 dssdev->ops->disable(dssdev);
 190                 dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 191         }
 192
 193         /*
 194          * Perform the post-disable operations on the chain of external devices
 195          * to complete the display pipeline disable.
 196          */
 197         omapdss_device_post_disable(dssdev->next);
 198 }
 199
 200 static void omap_encoder_enable(struct drm_encoder *encoder)
 201 {
 202         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 203         struct omap_dss_device *dssdev = omap_encoder->output;
 204         struct drm_device *dev = encoder->dev;
 205
 206         dev_dbg(dev->dev, "enable(%s)\n", dssdev->name);
 207
 208         /* Prepare the chain of external devices for pipeline enable. */
 209         omapdss_device_pre_enable(dssdev->next);
 210
 211         /*
 212          * Enable the internal encoder. This will enable the DSS output. The
 213          * DSI is treated as an exception as DSI pipelines still use the legacy
 214          * flow where the pipeline output controls the encoder.
 215          */
 216         if (dssdev->type != OMAP_DISPLAY_TYPE_DSI) {
 217                 dssdev->ops->enable(dssdev);
 218                 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
 219         }
 220
 221         /*
 222          * Enable the chain of external devices, starting at the one at the
 223          * internal encoder's output.
 224          */
 225         omapdss_device_enable(dssdev->next);
 226
 227         /* Enable the panel if present. */
 228         if (dssdev->panel) {
 229                 drm_panel_prepare(dssdev->panel);
 230                 drm_panel_enable(dssdev->panel);
 231         }
 232 }
 233
 234 static int omap_encoder_atomic_check(struct drm_encoder *encoder,
 235                                      struct drm_crtc_state *crtc_state,
 236                                      struct drm_connector_state *conn_state)
 237 {
 238         struct omap_encoder *omap_encoder = to_omap_encoder(encoder);
 239         enum drm_mode_status status;
 240
 241         status = omap_connector_mode_fixup(omap_encoder->output,
 242                                            &crtc_state->mode,
 243                                            &crtc_state->adjusted_mode);
 244         if (status != MODE_OK) {
 245                 dev_err(encoder->dev->dev, "invalid timings: %d\n", status);
 246                 return -EINVAL;
 247         }
 248
 249         return 0;
 250 }
 251
 252 static const struct drm_encoder_helper_funcs omap_encoder_helper_funcs = {
 253         .mode_set = omap_encoder_mode_set,
 254         .disable = omap_encoder_disable,
 255         .enable = omap_encoder_enable,
 256         .atomic_check = omap_encoder_atomic_check,
 257 };
 258
 259 /* initialize encoder */
 260 struct drm_encoder *omap_encoder_init(struct drm_device *dev,
 261                                       struct omap_dss_device *output)
 262 {
 263         struct drm_encoder *encoder = NULL;
 264         struct omap_encoder *omap_encoder;
 265
 266         omap_encoder = kzalloc(sizeof(*omap_encoder), GFP_KERNEL);
 267         if (!omap_encoder)
 268                 goto fail;
 269
 270         omap_encoder->output = output;
 271
 272         encoder = &omap_encoder->base;
 273
 274         drm_encoder_init(dev, encoder, &omap_encoder_funcs,
 275                          DRM_MODE_ENCODER_TMDS, NULL);
 276         drm_encoder_helper_add(encoder, &omap_encoder_helper_funcs);
 277
 278         return encoder;
 279
 280 fail:
 281         if (encoder)
 282                 omap_encoder_destroy(encoder);
 283
 284         return NULL;
 285 }