drivers/gpu/drm/meson/meson_venc_cvbs.c

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