drivers/gpu/drm/sun4i/sun4i_lvds.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2017 Free Electrons
   4  * Maxime Ripard <[email protected]>
   5  */
   6
   7 #include <linux/clk.h>
   8
   9 #include <drm/drm_atomic_helper.h>
  10 #include <drm/drm_bridge.h>
  11 #include <drm/drm_of.h>
  12 #include <drm/drm_panel.h>
  13 #include <drm/drm_print.h>
  14 #include <drm/drm_probe_helper.h>
  15 #include <drm/drm_simple_kms_helper.h>
  16
  17 #include "sun4i_crtc.h"
  18 #include "sun4i_tcon.h"
  19 #include "sun4i_lvds.h"
  20
  21 struct sun4i_lvds {
  22         struct drm_connector    connector;
  23         struct drm_encoder      encoder;
  24
  25         struct drm_panel        *panel;
  26 };
  27
  28 static inline struct sun4i_lvds *
  29 drm_connector_to_sun4i_lvds(struct drm_connector *connector)
  30 {
  31         return container_of(connector, struct sun4i_lvds,
  32                             connector);
  33 }
  34
  35 static inline struct sun4i_lvds *
  36 drm_encoder_to_sun4i_lvds(struct drm_encoder *encoder)
  37 {
  38         return container_of(encoder, struct sun4i_lvds,
  39                             encoder);
  40 }
  41
  42 static int sun4i_lvds_get_modes(struct drm_connector *connector)
  43 {
  44         struct sun4i_lvds *lvds =
  45                 drm_connector_to_sun4i_lvds(connector);
  46
  47         return drm_panel_get_modes(lvds->panel, connector);
  48 }
  49
  50 static struct drm_connector_helper_funcs sun4i_lvds_con_helper_funcs = {
  51         .get_modes      = sun4i_lvds_get_modes,
  52 };
  53
  54 static void
  55 sun4i_lvds_connector_destroy(struct drm_connector *connector)
  56 {
  57         struct sun4i_lvds *lvds = drm_connector_to_sun4i_lvds(connector);
  58
  59         drm_panel_detach(lvds->panel);
  60         drm_connector_cleanup(connector);
  61 }
  62
  63 static const struct drm_connector_funcs sun4i_lvds_con_funcs = {
  64         .fill_modes             = drm_helper_probe_single_connector_modes,
  65         .destroy                = sun4i_lvds_connector_destroy,
  66         .reset                  = drm_atomic_helper_connector_reset,
  67         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
  68         .atomic_destroy_state   = drm_atomic_helper_connector_destroy_state,
  69 };
  70
  71 static void sun4i_lvds_encoder_enable(struct drm_encoder *encoder)
  72 {
  73         struct sun4i_lvds *lvds = drm_encoder_to_sun4i_lvds(encoder);
  74
  75         DRM_DEBUG_DRIVER("Enabling LVDS output\n");
  76
  77         if (lvds->panel) {
  78                 drm_panel_prepare(lvds->panel);
  79                 drm_panel_enable(lvds->panel);
  80         }
  81 }
  82
  83 static void sun4i_lvds_encoder_disable(struct drm_encoder *encoder)
  84 {
  85         struct sun4i_lvds *lvds = drm_encoder_to_sun4i_lvds(encoder);
  86
  87         DRM_DEBUG_DRIVER("Disabling LVDS output\n");
  88
  89         if (lvds->panel) {
  90                 drm_panel_disable(lvds->panel);
  91                 drm_panel_unprepare(lvds->panel);
  92         }
  93 }
  94
  95 static const struct drm_encoder_helper_funcs sun4i_lvds_enc_helper_funcs = {
  96         .disable        = sun4i_lvds_encoder_disable,
  97         .enable         = sun4i_lvds_encoder_enable,
  98 };
  99
 100 int sun4i_lvds_init(struct drm_device *drm, struct sun4i_tcon *tcon)
 101 {
 102         struct drm_encoder *encoder;
 103         struct drm_bridge *bridge;
 104         struct sun4i_lvds *lvds;
 105         int ret;
 106
 107         lvds = devm_kzalloc(drm->dev, sizeof(*lvds), GFP_KERNEL);
 108         if (!lvds)
 109                 return -ENOMEM;
 110         encoder = &lvds->encoder;
 111
 112         ret = drm_of_find_panel_or_bridge(tcon->dev->of_node, 1, 0,
 113                                           &lvds->panel, &bridge);
 114         if (ret) {
 115                 dev_info(drm->dev, "No panel or bridge found... LVDS output disabled\n");
 116                 return 0;
 117         }
 118
 119         drm_encoder_helper_add(&lvds->encoder,
 120                                &sun4i_lvds_enc_helper_funcs);
 121         ret = drm_simple_encoder_init(drm, &lvds->encoder,
 122                                       DRM_MODE_ENCODER_LVDS);
 123         if (ret) {
 124                 dev_err(drm->dev, "Couldn't initialise the lvds encoder\n");
 125                 goto err_out;
 126         }
 127
 128         /* The LVDS encoder can only work with the TCON channel 0 */
 129         lvds->encoder.possible_crtcs = drm_crtc_mask(&tcon->crtc->crtc);
 130
 131         if (lvds->panel) {
 132                 drm_connector_helper_add(&lvds->connector,
 133                                          &sun4i_lvds_con_helper_funcs);
 134                 ret = drm_connector_init(drm, &lvds->connector,
 135                                          &sun4i_lvds_con_funcs,
 136                                          DRM_MODE_CONNECTOR_LVDS);
 137                 if (ret) {
 138                         dev_err(drm->dev, "Couldn't initialise the lvds connector\n");
 139                         goto err_cleanup_connector;
 140                 }
 141
 142                 drm_connector_attach_encoder(&lvds->connector,
 143                                                   &lvds->encoder);
 144
 145                 ret = drm_panel_attach(lvds->panel, &lvds->connector);
 146                 if (ret) {
 147                         dev_err(drm->dev, "Couldn't attach our panel\n");
 148                         goto err_cleanup_connector;
 149                 }
 150         }
 151
 152         if (bridge) {
 153                 ret = drm_bridge_attach(encoder, bridge, NULL, 0);
 154                 if (ret) {
 155                         dev_err(drm->dev, "Couldn't attach our bridge\n");
 156                         goto err_cleanup_connector;
 157                 }
 158         }
 159
 160         return 0;
 161
 162 err_cleanup_connector:
 163         drm_encoder_cleanup(&lvds->encoder);
 164 err_out:
 165         return ret;
 166 }
 167 EXPORT_SYMBOL(sun4i_lvds_init);