drm/logicvc/logicvc_interface.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Copyright (C) 2019-2022 Bootlin
0004  * Author: Paul Kocialkowski <paul.kocialkowski@bootlin.com>
0005  */
0006
0007 #include <linux/types.h>
0008
0009 #include <drm/drm_atomic_helper.h>
0010 #include <drm/drm_bridge.h>
0011 #include <drm/drm_connector.h>
0012 #include <drm/drm_crtc_helper.h>
0013 #include <drm/drm_drv.h>
0014 #include <drm/drm_encoder.h>
0015 #include <drm/drm_gem_cma_helper.h>
0016 #include <drm/drm_modeset_helper_vtables.h>
0017 #include <drm/drm_of.h>
0018 #include <drm/drm_panel.h>
0019 #include <drm/drm_print.h>
0020 #include <drm/drm_probe_helper.h>
0021
0022 #include "logicvc_crtc.h"
0023 #include "logicvc_drm.h"
0024 #include "logicvc_interface.h"
0025 #include "logicvc_regs.h"
0026
0027 #define logicvc_interface_from_drm_encoder(c) \
0028     container_of(c, struct logicvc_interface, drm_encoder)
0029 #define logicvc_interface_from_drm_connector(c) \
0030     container_of(c, struct logicvc_interface, drm_connector)
0031
0032 static void logicvc_encoder_enable(struct drm_encoder *drm_encoder)
0033 {
0034     struct logicvc_drm *logicvc = logicvc_drm(drm_encoder->dev);
0035     struct logicvc_interface *interface =
0036         logicvc_interface_from_drm_encoder(drm_encoder);
0037
0038     regmap_update_bits(logicvc->regmap, LOGICVC_POWER_CTRL_REG,
0039                LOGICVC_POWER_CTRL_VIDEO_ENABLE,
0040                LOGICVC_POWER_CTRL_VIDEO_ENABLE);
0041
0042     if (interface->drm_panel) {
0043         drm_panel_prepare(interface->drm_panel);
0044         drm_panel_enable(interface->drm_panel);
0045     }
0046 }
0047
0048 static void logicvc_encoder_disable(struct drm_encoder *drm_encoder)
0049 {
0050     struct logicvc_interface *interface =
0051         logicvc_interface_from_drm_encoder(drm_encoder);
0052
0053     if (interface->drm_panel) {
0054         drm_panel_disable(interface->drm_panel);
0055         drm_panel_unprepare(interface->drm_panel);
0056     }
0057 }
0058
0059 static const struct drm_encoder_helper_funcs logicvc_encoder_helper_funcs = {
0060     .enable         = logicvc_encoder_enable,
0061     .disable        = logicvc_encoder_disable,
0062 };
0063
0064 static const struct drm_encoder_funcs logicvc_encoder_funcs = {
0065     .destroy        = drm_encoder_cleanup,
0066 };
0067
0068 static int logicvc_connector_get_modes(struct drm_connector *drm_connector)
0069 {
0070     struct logicvc_interface *interface =
0071         logicvc_interface_from_drm_connector(drm_connector);
0072
0073     if (interface->drm_panel)
0074         return drm_panel_get_modes(interface->drm_panel, drm_connector);
0075
0076     WARN_ONCE(1, "Retrieving modes from a native connector is not implemented.");
0077
0078     return 0;
0079 }
0080
0081 static const struct drm_connector_helper_funcs logicvc_connector_helper_funcs = {
0082     .get_modes      = logicvc_connector_get_modes,
0083 };
0084
0085 static const struct drm_connector_funcs logicvc_connector_funcs = {
0086     .reset          = drm_atomic_helper_connector_reset,
0087     .fill_modes     = drm_helper_probe_single_connector_modes,
0088     .destroy        = drm_connector_cleanup,
0089     .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
0090     .atomic_destroy_state   = drm_atomic_helper_connector_destroy_state,
0091 };
0092
0093 static int logicvc_interface_encoder_type(struct logicvc_drm *logicvc)
0094 {
0095     switch (logicvc->config.display_interface) {
0096     case LOGICVC_DISPLAY_INTERFACE_LVDS_4BITS:
0097     case LOGICVC_DISPLAY_INTERFACE_LVDS_4BITS_CAMERA:
0098     case LOGICVC_DISPLAY_INTERFACE_LVDS_3BITS:
0099         return DRM_MODE_ENCODER_LVDS;
0100     case LOGICVC_DISPLAY_INTERFACE_DVI:
0101         return DRM_MODE_ENCODER_TMDS;
0102     case LOGICVC_DISPLAY_INTERFACE_RGB:
0103         return DRM_MODE_ENCODER_DPI;
0104     default:
0105         return DRM_MODE_ENCODER_NONE;
0106     }
0107 }
0108
0109 static int logicvc_interface_connector_type(struct logicvc_drm *logicvc)
0110 {
0111     switch (logicvc->config.display_interface) {
0112     case LOGICVC_DISPLAY_INTERFACE_LVDS_4BITS:
0113     case LOGICVC_DISPLAY_INTERFACE_LVDS_4BITS_CAMERA:
0114     case LOGICVC_DISPLAY_INTERFACE_LVDS_3BITS:
0115         return DRM_MODE_CONNECTOR_LVDS;
0116     case LOGICVC_DISPLAY_INTERFACE_DVI:
0117         return DRM_MODE_CONNECTOR_DVID;
0118     case LOGICVC_DISPLAY_INTERFACE_RGB:
0119         return DRM_MODE_CONNECTOR_DPI;
0120     default:
0121         return DRM_MODE_CONNECTOR_Unknown;
0122     }
0123 }
0124
0125 static bool logicvc_interface_native_connector(struct logicvc_drm *logicvc)
0126 {
0127     switch (logicvc->config.display_interface) {
0128     case LOGICVC_DISPLAY_INTERFACE_DVI:
0129         return true;
0130     default:
0131         return false;
0132     }
0133 }
0134
0135 void logicvc_interface_attach_crtc(struct logicvc_drm *logicvc)
0136 {
0137     uint32_t possible_crtcs = drm_crtc_mask(&logicvc->crtc->drm_crtc);
0138
0139     logicvc->interface->drm_encoder.possible_crtcs = possible_crtcs;
0140 }
0141
0142 int logicvc_interface_init(struct logicvc_drm *logicvc)
0143 {
0144     struct logicvc_interface *interface;
0145     struct drm_device *drm_dev = &logicvc->drm_dev;
0146     struct device *dev = drm_dev->dev;
0147     struct device_node *of_node = dev->of_node;
0148     int encoder_type = logicvc_interface_encoder_type(logicvc);
0149     int connector_type = logicvc_interface_connector_type(logicvc);
0150     bool native_connector = logicvc_interface_native_connector(logicvc);
0151     int ret;
0152
0153     interface = devm_kzalloc(dev, sizeof(*interface), GFP_KERNEL);
0154     if (!interface) {
0155         ret = -ENOMEM;
0156         goto error_early;
0157     }
0158
0159     ret = drm_of_find_panel_or_bridge(of_node, 0, 0, &interface->drm_panel,
0160                       &interface->drm_bridge);
0161     if (ret == -EPROBE_DEFER)
0162         goto error_early;
0163
0164     ret = drm_encoder_init(drm_dev, &interface->drm_encoder,
0165                    &logicvc_encoder_funcs, encoder_type, NULL);
0166     if (ret) {
0167         drm_err(drm_dev, "Failed to initialize encoder\n");
0168         goto error_early;
0169     }
0170
0171     drm_encoder_helper_add(&interface->drm_encoder,
0172                    &logicvc_encoder_helper_funcs);
0173
0174     if (native_connector || interface->drm_panel) {
0175         ret = drm_connector_init(drm_dev, &interface->drm_connector,
0176                      &logicvc_connector_funcs,
0177                      connector_type);
0178         if (ret) {
0179             drm_err(drm_dev, "Failed to initialize connector\n");
0180             goto error_encoder;
0181         }
0182
0183         drm_connector_helper_add(&interface->drm_connector,
0184                      &logicvc_connector_helper_funcs);
0185
0186         ret = drm_connector_attach_encoder(&interface->drm_connector,
0187                            &interface->drm_encoder);
0188         if (ret) {
0189             drm_err(drm_dev,
0190                 "Failed to attach connector to encoder\n");
0191             goto error_encoder;
0192         }
0193     }
0194
0195     if (interface->drm_bridge) {
0196         ret = drm_bridge_attach(&interface->drm_encoder,
0197                     interface->drm_bridge, NULL, 0);
0198         if (ret) {
0199             drm_err(drm_dev,
0200                 "Failed to attach bridge to encoder\n");
0201             goto error_encoder;
0202         }
0203     }
0204
0205     logicvc->interface = interface;
0206
0207     return 0;
0208
0209 error_encoder:
0210     drm_encoder_cleanup(&interface->drm_encoder);
0211
0212 error_early:
0213     return ret;
0214 }