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