drivers/gpu/drm/omapdrm/omap_encoder.c

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