drivers/gpu/drm/rcar-du/rcar_du_lvds.c

   1 /*
   2  * rcar_du_lvds.c  --  R-Car Display Unit LVDS Encoder and Connector
   3  *
   4  * Copyright (C) 2013 Renesas Corporation
   5  *
   6  * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  */
  13
  14 #include <drm/drmP.h>
  15 #include <drm/drm_crtc.h>
  16 #include <drm/drm_crtc_helper.h>
  17
  18 #include "rcar_du_drv.h"
  19 #include "rcar_du_kms.h"
  20 #include "rcar_du_lvds.h"
  21
  22 struct rcar_du_lvds_connector {
  23         struct rcar_du_connector connector;
  24
  25         const struct rcar_du_panel_data *panel;
  26 };
  27
  28 #define to_rcar_lvds_connector(c) \
  29         container_of(c, struct rcar_du_lvds_connector, connector.connector)
  30
  31 /* -----------------------------------------------------------------------------
  32  * Connector
  33  */
  34
  35 static int rcar_du_lvds_connector_get_modes(struct drm_connector *connector)
  36 {
  37         struct rcar_du_lvds_connector *lvdscon = to_rcar_lvds_connector(connector);
  38         struct drm_display_mode *mode;
  39
  40         mode = drm_mode_create(connector->dev);
  41         if (mode == NULL)
  42                 return 0;
  43
  44         mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
  45         mode->clock = lvdscon->panel->mode.clock;
  46         mode->hdisplay = lvdscon->panel->mode.hdisplay;
  47         mode->hsync_start = lvdscon->panel->mode.hsync_start;
  48         mode->hsync_end = lvdscon->panel->mode.hsync_end;
  49         mode->htotal = lvdscon->panel->mode.htotal;
  50         mode->vdisplay = lvdscon->panel->mode.vdisplay;
  51         mode->vsync_start = lvdscon->panel->mode.vsync_start;
  52         mode->vsync_end = lvdscon->panel->mode.vsync_end;
  53         mode->vtotal = lvdscon->panel->mode.vtotal;
  54         mode->flags = lvdscon->panel->mode.flags;
  55
  56         drm_mode_set_name(mode);
  57         drm_mode_probed_add(connector, mode);
  58
  59         return 1;
  60 }
  61
  62 static int rcar_du_lvds_connector_mode_valid(struct drm_connector *connector,
  63                                             struct drm_display_mode *mode)
  64 {
  65         return MODE_OK;
  66 }
  67
  68 static const struct drm_connector_helper_funcs connector_helper_funcs = {
  69         .get_modes = rcar_du_lvds_connector_get_modes,
  70         .mode_valid = rcar_du_lvds_connector_mode_valid,
  71         .best_encoder = rcar_du_connector_best_encoder,
  72 };
  73
  74 static void rcar_du_lvds_connector_destroy(struct drm_connector *connector)
  75 {
  76         drm_sysfs_connector_remove(connector);
  77         drm_connector_cleanup(connector);
  78 }
  79
  80 static enum drm_connector_status
  81 rcar_du_lvds_connector_detect(struct drm_connector *connector, bool force)
  82 {
  83         return connector_status_connected;
  84 }
  85
  86 static const struct drm_connector_funcs connector_funcs = {
  87         .dpms = drm_helper_connector_dpms,
  88         .detect = rcar_du_lvds_connector_detect,
  89         .fill_modes = drm_helper_probe_single_connector_modes,
  90         .destroy = rcar_du_lvds_connector_destroy,
  91 };
  92
  93 static int rcar_du_lvds_connector_init(struct rcar_du_device *rcdu,
  94                                        struct rcar_du_encoder *renc,
  95                                        const struct rcar_du_panel_data *panel)
  96 {
  97         struct rcar_du_lvds_connector *lvdscon;
  98         struct drm_connector *connector;
  99         int ret;
 100
 101         lvdscon = devm_kzalloc(rcdu->dev, sizeof(*lvdscon), GFP_KERNEL);
 102         if (lvdscon == NULL)
 103                 return -ENOMEM;
 104
 105         lvdscon->panel = panel;
 106
 107         connector = &lvdscon->connector.connector;
 108         connector->display_info.width_mm = panel->width_mm;
 109         connector->display_info.height_mm = panel->height_mm;
 110
 111         ret = drm_connector_init(rcdu->ddev, connector, &connector_funcs,
 112                                  DRM_MODE_CONNECTOR_LVDS);
 113         if (ret < 0)
 114                 return ret;
 115
 116         drm_connector_helper_add(connector, &connector_helper_funcs);
 117         ret = drm_sysfs_connector_add(connector);
 118         if (ret < 0)
 119                 return ret;
 120
 121         drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
 122         drm_object_property_set_value(&connector->base,
 123                 rcdu->ddev->mode_config.dpms_property, DRM_MODE_DPMS_OFF);
 124
 125         ret = drm_mode_connector_attach_encoder(connector, &renc->encoder);
 126         if (ret < 0)
 127                 return ret;
 128
 129         connector->encoder = &renc->encoder;
 130         lvdscon->connector.encoder = renc;
 131
 132         return 0;
 133 }
 134
 135 /* -----------------------------------------------------------------------------
 136  * Encoder
 137  */
 138
 139 static void rcar_du_lvds_encoder_dpms(struct drm_encoder *encoder, int mode)
 140 {
 141 }
 142
 143 static bool rcar_du_lvds_encoder_mode_fixup(struct drm_encoder *encoder,
 144                                            const struct drm_display_mode *mode,
 145                                            struct drm_display_mode *adjusted_mode)
 146 {
 147         const struct drm_display_mode *panel_mode;
 148         struct drm_device *dev = encoder->dev;
 149         struct drm_connector *connector;
 150         bool found = false;
 151
 152         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 153                 if (connector->encoder == encoder) {
 154                         found = true;
 155                         break;
 156                 }
 157         }
 158
 159         if (!found) {
 160                 dev_dbg(dev->dev, "mode_fixup: no connector found\n");
 161                 return false;
 162         }
 163
 164         if (list_empty(&connector->modes)) {
 165                 dev_dbg(dev->dev, "mode_fixup: empty modes list\n");
 166                 return false;
 167         }
 168
 169         panel_mode = list_first_entry(&connector->modes,
 170                                       struct drm_display_mode, head);
 171
 172         /* We're not allowed to modify the resolution. */
 173         if (mode->hdisplay != panel_mode->hdisplay ||
 174             mode->vdisplay != panel_mode->vdisplay)
 175                 return false;
 176
 177         /* The flat panel mode is fixed, just copy it to the adjusted mode. */
 178         drm_mode_copy(adjusted_mode, panel_mode);
 179
 180         return true;
 181 }
 182
 183 static const struct drm_encoder_helper_funcs encoder_helper_funcs = {
 184         .dpms = rcar_du_lvds_encoder_dpms,
 185         .mode_fixup = rcar_du_lvds_encoder_mode_fixup,
 186         .prepare = rcar_du_encoder_mode_prepare,
 187         .commit = rcar_du_encoder_mode_commit,
 188         .mode_set = rcar_du_encoder_mode_set,
 189 };
 190
 191 static const struct drm_encoder_funcs encoder_funcs = {
 192         .destroy = drm_encoder_cleanup,
 193 };
 194
 195 int rcar_du_lvds_init(struct rcar_du_device *rcdu,
 196                       const struct rcar_du_encoder_lvds_data *data,
 197                       unsigned int output)
 198 {
 199         struct rcar_du_encoder *renc;
 200         int ret;
 201
 202         renc = devm_kzalloc(rcdu->dev, sizeof(*renc), GFP_KERNEL);
 203         if (renc == NULL)
 204                 return -ENOMEM;
 205
 206         renc->output = output;
 207
 208         ret = drm_encoder_init(rcdu->ddev, &renc->encoder, &encoder_funcs,
 209                                DRM_MODE_ENCODER_LVDS);
 210         if (ret < 0)
 211                 return ret;
 212
 213         drm_encoder_helper_add(&renc->encoder, &encoder_helper_funcs);
 214
 215         return rcar_du_lvds_connector_init(rcdu, renc, &data->panel);
 216 }