drivers/gpu/drm/msm/edp/edp_connector.c

   1 /*
   2  * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 and
   6  * only version 2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include "drm/drm_edid.h"
  15 #include "msm_kms.h"
  16 #include "edp.h"
  17
  18 struct edp_connector {
  19         struct drm_connector base;
  20         struct msm_edp *edp;
  21 };
  22 #define to_edp_connector(x) container_of(x, struct edp_connector, base)
  23
  24 static enum drm_connector_status edp_connector_detect(
  25                 struct drm_connector *connector, bool force)
  26 {
  27         struct edp_connector *edp_connector = to_edp_connector(connector);
  28         struct msm_edp *edp = edp_connector->edp;
  29
  30         DBG("");
  31         return msm_edp_ctrl_panel_connected(edp->ctrl) ?
  32                 connector_status_connected : connector_status_disconnected;
  33 }
  34
  35 static void edp_connector_destroy(struct drm_connector *connector)
  36 {
  37         struct edp_connector *edp_connector = to_edp_connector(connector);
  38
  39         DBG("");
  40         drm_connector_unregister(connector);
  41         drm_connector_cleanup(connector);
  42
  43         kfree(edp_connector);
  44 }
  45
  46 static int edp_connector_get_modes(struct drm_connector *connector)
  47 {
  48         struct edp_connector *edp_connector = to_edp_connector(connector);
  49         struct msm_edp *edp = edp_connector->edp;
  50
  51         struct edid *drm_edid = NULL;
  52         int ret = 0;
  53
  54         DBG("");
  55         ret = msm_edp_ctrl_get_panel_info(edp->ctrl, connector, &drm_edid);
  56         if (ret)
  57                 return ret;
  58
  59         drm_mode_connector_update_edid_property(connector, drm_edid);
  60         if (drm_edid)
  61                 ret = drm_add_edid_modes(connector, drm_edid);
  62
  63         return ret;
  64 }
  65
  66 static int edp_connector_mode_valid(struct drm_connector *connector,
  67                                  struct drm_display_mode *mode)
  68 {
  69         struct edp_connector *edp_connector = to_edp_connector(connector);
  70         struct msm_edp *edp = edp_connector->edp;
  71         struct msm_drm_private *priv = connector->dev->dev_private;
  72         struct msm_kms *kms = priv->kms;
  73         long actual, requested;
  74
  75         requested = 1000 * mode->clock;
  76         actual = kms->funcs->round_pixclk(kms,
  77                         requested, edp_connector->edp->encoder);
  78
  79         DBG("requested=%ld, actual=%ld", requested, actual);
  80         if (actual != requested)
  81                 return MODE_CLOCK_RANGE;
  82
  83         if (!msm_edp_ctrl_pixel_clock_valid(
  84                 edp->ctrl, mode->clock, NULL, NULL))
  85                 return MODE_CLOCK_RANGE;
  86
  87         /* Invalidate all modes if color format is not supported */
  88         if (connector->display_info.bpc > 8)
  89                 return MODE_BAD;
  90
  91         return MODE_OK;
  92 }
  93
  94 static struct drm_encoder *
  95 edp_connector_best_encoder(struct drm_connector *connector)
  96 {
  97         struct edp_connector *edp_connector = to_edp_connector(connector);
  98
  99         DBG("");
 100         return edp_connector->edp->encoder;
 101 }
 102
 103 static const struct drm_connector_funcs edp_connector_funcs = {
 104         .dpms = drm_atomic_helper_connector_dpms,
 105         .detect = edp_connector_detect,
 106         .fill_modes = drm_helper_probe_single_connector_modes,
 107         .destroy = edp_connector_destroy,
 108         .reset = drm_atomic_helper_connector_reset,
 109         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 110         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 111 };
 112
 113 static const struct drm_connector_helper_funcs edp_connector_helper_funcs = {
 114         .get_modes = edp_connector_get_modes,
 115         .mode_valid = edp_connector_mode_valid,
 116         .best_encoder = edp_connector_best_encoder,
 117 };
 118
 119 /* initialize connector */
 120 struct drm_connector *msm_edp_connector_init(struct msm_edp *edp)
 121 {
 122         struct drm_connector *connector = NULL;
 123         struct edp_connector *edp_connector;
 124         int ret;
 125
 126         edp_connector = kzalloc(sizeof(*edp_connector), GFP_KERNEL);
 127         if (!edp_connector) {
 128                 ret = -ENOMEM;
 129                 goto fail;
 130         }
 131
 132         edp_connector->edp = edp;
 133
 134         connector = &edp_connector->base;
 135
 136         ret = drm_connector_init(edp->dev, connector, &edp_connector_funcs,
 137                         DRM_MODE_CONNECTOR_eDP);
 138         if (ret)
 139                 goto fail;
 140
 141         drm_connector_helper_add(connector, &edp_connector_helper_funcs);
 142
 143         /* We don't support HPD, so only poll status until connected. */
 144         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
 145
 146         /* Display driver doesn't support interlace now. */
 147         connector->interlace_allowed = false;
 148         connector->doublescan_allowed = false;
 149
 150         ret = drm_connector_register(connector);
 151         if (ret)
 152                 goto fail;
 153
 154         drm_mode_connector_attach_encoder(connector, edp->encoder);
 155
 156         return connector;
 157
 158 fail:
 159         if (connector)
 160                 edp_connector_destroy(connector);
 161
 162         return ERR_PTR(ret);
 163 }