drm: lcdif: Add multiple encoders and first bridges support

The single LCDIF embedded in i.MX93 SoC may drive multiple displays
simultaneously.  Look at LCDIF output port's remote port parents to
find all enabled first bridges.  Add an encoder for each found bridge
and attach the bridge to the encoder.  This is a preparation for
adding i.MX93 LCDIF support.

Tested-by: Alexander Stein <alexander.stein@ew.tq-group.com>
Acked-by: Alexander Stein <alexander.stein@ew.tq-group.com>
Signed-off-by: Liu Ying <victor.liu@nxp.com>
Reviewed-by: Marek Vasut <marex@denx.de>
Signed-off-by: Marek Vasut <marex@denx.de>
Link: https://patchwork.freedesktop.org/patch/msgid/20230510092450.4024730-6-victor.liu@nxp.com

diff --git a/drivers/gpu/drm/mxsfb/lcdif_drv.c b/drivers/gpu/drm/mxsfb/lcdif_drv.c
index e816f87828fbcad34d7246f4b8984f458bb03295..dc85498b81cdb0478de4d65d65886517ca4d0ddd 100644 (file)
--- a/drivers/gpu/drm/mxsfb/lcdif_drv.c
+++ b/drivers/gpu/drm/mxsfb/lcdif_drv.c
@@ -9,13 +9,16 @@
 #include <linux/dma-mapping.h>
 #include <linux/io.h>
 #include <linux/module.h>
+#include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/of_graph.h>
 #include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_bridge.h>
 #include <drm/drm_drv.h>
+#include <drm/drm_encoder.h>
 #include <drm/drm_fbdev_dma.h>
 #include <drm/drm_gem_dma_helper.h>
 #include <drm/drm_gem_framebuffer_helper.h>
@@ -38,19 +41,70 @@ static const struct drm_mode_config_helper_funcs lcdif_mode_config_helpers = {
        .atomic_commit_tail = drm_atomic_helper_commit_tail_rpm,
 };
 
+static const struct drm_encoder_funcs lcdif_encoder_funcs = {
+       .destroy = drm_encoder_cleanup,
+};
+
 static int lcdif_attach_bridge(struct lcdif_drm_private *lcdif)
 {
-       struct drm_device *drm = lcdif->drm;
+       struct device *dev = lcdif->drm->dev;
+       struct device_node *ep;
        struct drm_bridge *bridge;
        int ret;
 
-       bridge = devm_drm_of_get_bridge(drm->dev, drm->dev->of_node, 0, 0);
-       if (IS_ERR(bridge))
-               return PTR_ERR(bridge);
-
-       ret = drm_bridge_attach(&lcdif->encoder, bridge, NULL, 0);
-       if (ret)
-               return dev_err_probe(drm->dev, ret, "Failed to attach bridge\n");
+       for_each_endpoint_of_node(dev->of_node, ep) {
+               struct device_node *remote;
+               struct of_endpoint of_ep;
+               struct drm_encoder *encoder;
+
+               remote = of_graph_get_remote_port_parent(ep);
+               if (!of_device_is_available(remote)) {
+                       of_node_put(remote);
+                       continue;
+               }
+               of_node_put(remote);
+
+               ret = of_graph_parse_endpoint(ep, &of_ep);
+               if (ret < 0) {
+                       dev_err(dev, "Failed to parse endpoint %pOF\n", ep);
+                       of_node_put(ep);
+                       return ret;
+               }
+
+               bridge = devm_drm_of_get_bridge(dev, dev->of_node, 0, of_ep.id);
+               if (IS_ERR(bridge)) {
+                       of_node_put(ep);
+                       return dev_err_probe(dev, PTR_ERR(bridge),
+                                            "Failed to get bridge for endpoint%u\n",
+                                            of_ep.id);
+               }
+
+               encoder = devm_kzalloc(dev, sizeof(*encoder), GFP_KERNEL);
+               if (!encoder) {
+                       dev_err(dev, "Failed to allocate encoder for endpoint%u\n",
+                               of_ep.id);
+                       of_node_put(ep);
+                       return -ENOMEM;
+               }
+
+               encoder->possible_crtcs = drm_crtc_mask(&lcdif->crtc);
+               ret = drm_encoder_init(lcdif->drm, encoder, &lcdif_encoder_funcs,
+                                      DRM_MODE_ENCODER_NONE, NULL);
+               if (ret) {
+                       dev_err(dev, "Failed to initialize encoder for endpoint%u: %d\n",
+                               of_ep.id, ret);
+                       of_node_put(ep);
+                       return ret;
+               }
+
+               ret = drm_bridge_attach(encoder, bridge, NULL, 0);
+               if (ret) {
+                       of_node_put(ep);
+                       return dev_err_probe(dev, ret,
+                                            "Failed to attach bridge for endpoint%u\n",
+                                            of_ep.id);
+               }
+       }
 
        return 0;
 }

diff --git a/drivers/gpu/drm/mxsfb/lcdif_drv.h b/drivers/gpu/drm/mxsfb/lcdif_drv.h
index aa6d099a1897cd391c34058689205bc4f3aa8a63..61483a4e058dd841535425d8cf5bf52c5a475c68 100644 (file)
--- a/drivers/gpu/drm/mxsfb/lcdif_drv.h
+++ b/drivers/gpu/drm/mxsfb/lcdif_drv.h
@@ -11,7 +11,6 @@
 #include <drm/drm_bridge.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_device.h>
-#include <drm/drm_encoder.h>
 #include <drm/drm_plane.h>
 
 struct clk;
@@ -30,7 +29,6 @@ struct lcdif_drm_private {
                /* i.MXRT does support overlay planes, add them here. */
        } planes;
        struct drm_crtc                 crtc;
-       struct drm_encoder              encoder;
 };
 
 static inline struct lcdif_drm_private *

diff --git a/drivers/gpu/drm/mxsfb/lcdif_kms.c b/drivers/gpu/drm/mxsfb/lcdif_kms.c
index e13382beb53e8f5bbe1371e8abcce1ec54496276..2541d2de4e45f8c4d32a25a2e0c62efb473078d6 100644 (file)
--- a/drivers/gpu/drm/mxsfb/lcdif_kms.c
+++ b/drivers/gpu/drm/mxsfb/lcdif_kms.c
@@ -659,14 +659,6 @@ static const struct drm_crtc_funcs lcdif_crtc_funcs = {
        .disable_vblank = lcdif_crtc_disable_vblank,
 };
 
-/* -----------------------------------------------------------------------------
- * Encoder
- */
-
-static const struct drm_encoder_funcs lcdif_encoder_funcs = {
-       .destroy = drm_encoder_cleanup,
-};
-
 /* -----------------------------------------------------------------------------
  * Planes
  */
@@ -759,7 +751,6 @@ int lcdif_kms_init(struct lcdif_drm_private *lcdif)
                                        BIT(DRM_COLOR_YCBCR_BT2020);
        const u32 supported_ranges = BIT(DRM_COLOR_YCBCR_LIMITED_RANGE) |
                                     BIT(DRM_COLOR_YCBCR_FULL_RANGE);
-       struct drm_encoder *encoder = &lcdif->encoder;
        struct drm_crtc *crtc = &lcdif->crtc;
        int ret;
 
@@ -783,13 +774,7 @@ int lcdif_kms_init(struct lcdif_drm_private *lcdif)
                return ret;
 
        drm_crtc_helper_add(crtc, &lcdif_crtc_helper_funcs);
-       ret = drm_crtc_init_with_planes(lcdif->drm, crtc,
-                                       &lcdif->planes.primary, NULL,
-                                       &lcdif_crtc_funcs, NULL);
-       if (ret)
-               return ret;
-
-       encoder->possible_crtcs = drm_crtc_mask(crtc);
-       return drm_encoder_init(lcdif->drm, encoder, &lcdif_encoder_funcs,
-                               DRM_MODE_ENCODER_NONE, NULL);
+       return drm_crtc_init_with_planes(lcdif->drm, crtc,
+                                        &lcdif->planes.primary, NULL,
+                                        &lcdif_crtc_funcs, NULL);
 }