drivers/gpu/drm/meson/meson_venc_cvbs.c

   1 /*
   2  * Copyright (C) 2016 BayLibre, SAS
   3  * Author: Neil Armstrong <narmstrong@baylibre.com>
   4  * Copyright (C) 2015 Amlogic, Inc. All rights reserved.
   5  * Copyright (C) 2014 Endless Mobile
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  *
  20  * Written by:
  21  *     Jasper St. Pierre <jstpierre@mecheye.net>
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/of_graph.h>
  27
  28 #include <drm/drmP.h>
  29 #include <drm/drm_edid.h>
  30 #include <drm/drm_crtc_helper.h>
  31 #include <drm/drm_atomic_helper.h>
  32
  33 #include "meson_venc_cvbs.h"
  34 #include "meson_venc.h"
  35 #include "meson_registers.h"
  36
  37 /* HHI VDAC Registers */
  38 #define HHI_VDAC_CNTL0          0x2F4 /* 0xbd offset in data sheet */
  39 #define HHI_VDAC_CNTL1          0x2F8 /* 0xbe offset in data sheet */
  40
  41 struct meson_venc_cvbs {
  42         struct drm_encoder      encoder;
  43         struct drm_connector    connector;
  44         struct meson_drm        *priv;
  45 };
  46 #define encoder_to_meson_venc_cvbs(x) \
  47         container_of(x, struct meson_venc_cvbs, encoder)
  48
  49 #define connector_to_meson_venc_cvbs(x) \
  50         container_of(x, struct meson_venc_cvbs, connector)
  51
  52 /* Supported Modes */
  53
  54 struct meson_cvbs_mode meson_cvbs_modes[MESON_CVBS_MODES_COUNT] = {
  55         { /* PAL */
  56                 .enci = &meson_cvbs_enci_pal,
  57                 .mode = {
  58                         DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 13500,
  59                                  720, 732, 795, 864, 0, 576, 580, 586, 625, 0,
  60                                  DRM_MODE_FLAG_INTERLACE),
  61                         .vrefresh = 50,
  62                         .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3,
  63                 },
  64         },
  65         { /* NTSC */
  66                 .enci = &meson_cvbs_enci_ntsc,
  67                 .mode = {
  68                         DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 13500,
  69                                 720, 739, 801, 858, 0, 480, 488, 494, 525, 0,
  70                                 DRM_MODE_FLAG_INTERLACE),
  71                         .vrefresh = 60,
  72                         .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3,
  73                 },
  74         },
  75 };
  76
  77 /* Connector */
  78
  79 static void meson_cvbs_connector_destroy(struct drm_connector *connector)
  80 {
  81         drm_connector_cleanup(connector);
  82 }
  83
  84 static enum drm_connector_status
  85 meson_cvbs_connector_detect(struct drm_connector *connector, bool force)
  86 {
  87         /* FIXME: Add load-detect or jack-detect if possible */
  88         return connector_status_connected;
  89 }
  90
  91 static int meson_cvbs_connector_get_modes(struct drm_connector *connector)
  92 {
  93         struct drm_device *dev = connector->dev;
  94         struct drm_display_mode *mode;
  95         int i;
  96
  97         for (i = 0; i < MESON_CVBS_MODES_COUNT; ++i) {
  98                 struct meson_cvbs_mode *meson_mode = &meson_cvbs_modes[i];
  99
 100                 mode = drm_mode_duplicate(dev, &meson_mode->mode);
 101                 if (!mode) {
 102                         DRM_ERROR("Failed to create a new display mode\n");
 103                         return 0;
 104                 }
 105
 106                 drm_mode_probed_add(connector, mode);
 107         }
 108
 109         return i;
 110 }
 111
 112 static int meson_cvbs_connector_mode_valid(struct drm_connector *connector,
 113                                            struct drm_display_mode *mode)
 114 {
 115         /* Validate the modes added in get_modes */
 116         return MODE_OK;
 117 }
 118
 119 static const struct drm_connector_funcs meson_cvbs_connector_funcs = {
 120         .dpms                   = drm_atomic_helper_connector_dpms,
 121         .detect                 = meson_cvbs_connector_detect,
 122         .fill_modes             = drm_helper_probe_single_connector_modes,
 123         .destroy                = meson_cvbs_connector_destroy,
 124         .reset                  = drm_atomic_helper_connector_reset,
 125         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 126         .atomic_destroy_state   = drm_atomic_helper_connector_destroy_state,
 127 };
 128
 129 static const
 130 struct drm_connector_helper_funcs meson_cvbs_connector_helper_funcs = {
 131         .get_modes      = meson_cvbs_connector_get_modes,
 132         .mode_valid     = meson_cvbs_connector_mode_valid,
 133 };
 134
 135 /* Encoder */
 136
 137 static void meson_venc_cvbs_encoder_destroy(struct drm_encoder *encoder)
 138 {
 139         drm_encoder_cleanup(encoder);
 140 }
 141
 142 static const struct drm_encoder_funcs meson_venc_cvbs_encoder_funcs = {
 143         .destroy        = meson_venc_cvbs_encoder_destroy,
 144 };
 145
 146 static int meson_venc_cvbs_encoder_atomic_check(struct drm_encoder *encoder,
 147                                         struct drm_crtc_state *crtc_state,
 148                                         struct drm_connector_state *conn_state)
 149 {
 150         int i;
 151
 152         for (i = 0; i < MESON_CVBS_MODES_COUNT; ++i) {
 153                 struct meson_cvbs_mode *meson_mode = &meson_cvbs_modes[i];
 154
 155                 if (drm_mode_equal(&crtc_state->mode, &meson_mode->mode))
 156                         return 0;
 157         }
 158
 159         return -EINVAL;
 160 }
 161
 162 static void meson_venc_cvbs_encoder_disable(struct drm_encoder *encoder)
 163 {
 164         struct meson_venc_cvbs *meson_venc_cvbs =
 165                                         encoder_to_meson_venc_cvbs(encoder);
 166         struct meson_drm *priv = meson_venc_cvbs->priv;
 167
 168         /* Disable CVBS VDAC */
 169         regmap_write(priv->hhi, HHI_VDAC_CNTL0, 0);
 170         regmap_write(priv->hhi, HHI_VDAC_CNTL1, 8);
 171 }
 172
 173 static void meson_venc_cvbs_encoder_enable(struct drm_encoder *encoder)
 174 {
 175         struct meson_venc_cvbs *meson_venc_cvbs =
 176                                         encoder_to_meson_venc_cvbs(encoder);
 177         struct meson_drm *priv = meson_venc_cvbs->priv;
 178
 179         /* VDAC0 source is not from ATV */
 180         writel_bits_relaxed(BIT(5), 0, priv->io_base + _REG(VENC_VDAC_DACSEL0));
 181
 182         if (meson_vpu_is_compatible(priv, "amlogic,meson-gxbb-vpu"))
 183                 regmap_write(priv->hhi, HHI_VDAC_CNTL0, 1);
 184         else if (meson_vpu_is_compatible(priv, "amlogic,meson-gxm-vpu") ||
 185                  meson_vpu_is_compatible(priv, "amlogic,meson-gxl-vpu"))
 186                 regmap_write(priv->hhi, HHI_VDAC_CNTL0, 0xf0001);
 187
 188         regmap_write(priv->hhi, HHI_VDAC_CNTL1, 0);
 189 }
 190
 191 static void meson_venc_cvbs_encoder_mode_set(struct drm_encoder *encoder,
 192                                    struct drm_display_mode *mode,
 193                                    struct drm_display_mode *adjusted_mode)
 194 {
 195         struct meson_venc_cvbs *meson_venc_cvbs =
 196                                         encoder_to_meson_venc_cvbs(encoder);
 197         int i;
 198
 199         for (i = 0; i < MESON_CVBS_MODES_COUNT; ++i) {
 200                 struct meson_cvbs_mode *meson_mode = &meson_cvbs_modes[i];
 201
 202                 if (drm_mode_equal(mode, &meson_mode->mode)) {
 203                         meson_venci_cvbs_mode_set(meson_venc_cvbs->priv,
 204                                                   meson_mode->enci);
 205                         break;
 206                 }
 207         }
 208 }
 209
 210 static const struct drm_encoder_helper_funcs
 211                                 meson_venc_cvbs_encoder_helper_funcs = {
 212         .atomic_check   = meson_venc_cvbs_encoder_atomic_check,
 213         .disable        = meson_venc_cvbs_encoder_disable,
 214         .enable         = meson_venc_cvbs_encoder_enable,
 215         .mode_set       = meson_venc_cvbs_encoder_mode_set,
 216 };
 217
 218 static bool meson_venc_cvbs_connector_is_available(struct meson_drm *priv)
 219 {
 220         struct device_node *ep, *remote;
 221
 222         /* CVBS VDAC output is on the first port, first endpoint */
 223         ep = of_graph_get_endpoint_by_regs(priv->dev->of_node, 0, 0);
 224         if (!ep)
 225                 return false;
 226
 227
 228         /* If the endpoint node exists, consider it enabled */
 229         remote = of_graph_get_remote_port(ep);
 230         if (remote) {
 231                 of_node_put(ep);
 232                 return true;
 233         }
 234
 235         of_node_put(ep);
 236         of_node_put(remote);
 237
 238         return false;
 239 }
 240
 241 int meson_venc_cvbs_create(struct meson_drm *priv)
 242 {
 243         struct drm_device *drm = priv->drm;
 244         struct meson_venc_cvbs *meson_venc_cvbs;
 245         struct drm_connector *connector;
 246         struct drm_encoder *encoder;
 247         int ret;
 248
 249         if (!meson_venc_cvbs_connector_is_available(priv)) {
 250                 dev_info(drm->dev, "CVBS Output connector not available\n");
 251                 return -ENODEV;
 252         }
 253
 254         meson_venc_cvbs = devm_kzalloc(priv->dev, sizeof(*meson_venc_cvbs),
 255                                        GFP_KERNEL);
 256         if (!meson_venc_cvbs)
 257                 return -ENOMEM;
 258
 259         meson_venc_cvbs->priv = priv;
 260         encoder = &meson_venc_cvbs->encoder;
 261         connector = &meson_venc_cvbs->connector;
 262
 263         /* Connector */
 264
 265         drm_connector_helper_add(connector,
 266                                  &meson_cvbs_connector_helper_funcs);
 267
 268         ret = drm_connector_init(drm, connector, &meson_cvbs_connector_funcs,
 269                                  DRM_MODE_CONNECTOR_Composite);
 270         if (ret) {
 271                 dev_err(priv->dev, "Failed to init CVBS connector\n");
 272                 return ret;
 273         }
 274
 275         connector->interlace_allowed = 1;
 276
 277         /* Encoder */
 278
 279         drm_encoder_helper_add(encoder, &meson_venc_cvbs_encoder_helper_funcs);
 280
 281         ret = drm_encoder_init(drm, encoder, &meson_venc_cvbs_encoder_funcs,
 282                                DRM_MODE_ENCODER_TVDAC, "meson_venc_cvbs");
 283         if (ret) {
 284                 dev_err(priv->dev, "Failed to init CVBS encoder\n");
 285                 return ret;
 286         }
 287
 288         encoder->possible_crtcs = BIT(0);
 289
 290         drm_mode_connector_attach_encoder(connector, encoder);
 291
 292         return 0;
 293 }