drm/msm/mdp4: Clean up modeset_init

modeset_init() for mdp4 isn't very flexible. That makes it hard to add
more interfaces.

Split out the encoder/connector creation code in modeset_init into a
separate function. This is similar to what's done in modeset_init for
mdp5.

Signed-off-by: Archit Taneja <architt@codeaurora.org>
Signed-off-by: Rob Clark <robdclark@gmail.com>

1 files changed, 109 insertions, 83 deletions

diff --git a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.c b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.c
index 76984a8d038c..379b43521853 100644
--- a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.c
+++ b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.c
@@ -270,117 +270,143 @@ static struct drm_panel *detect_panel(struct drm_device *dev)
         return panel;
 }
 
-static int modeset_init(struct mdp4_kms *mdp4_kms)
+static int mdp4_modeset_init_intf(struct mdp4_kms *mdp4_kms,
+                                  int intf_type)
 {
         struct drm_device *dev = mdp4_kms->dev;
         struct msm_drm_private *priv = dev->dev_private;
-        struct drm_plane *plane;
-        struct drm_crtc *crtc;
         struct drm_encoder *encoder;
         struct drm_connector *connector;
         struct drm_panel *panel;
         int ret;
 
-        /* construct non-private planes: */
-        plane = mdp4_plane_init(dev, VG1, false);
-        if (IS_ERR(plane)) {
-                dev_err(dev->dev, "failed to construct plane for VG1\n");
-                ret = PTR_ERR(plane);
-                goto fail;
-        }
-        priv->planes[priv->num_planes++] = plane;
+        switch (intf_type) {
+        case DRM_MODE_ENCODER_LVDS:
+                panel = detect_panel(dev);
+                if (IS_ERR(panel)) {
+                        dev_err(dev->dev, "failed to detect LVDS panel\n");
+                        return PTR_ERR(panel);
+                }
 
-        plane = mdp4_plane_init(dev, VG2, false);
-        if (IS_ERR(plane)) {
-                dev_err(dev->dev, "failed to construct plane for VG2\n");
-                ret = PTR_ERR(plane);
-                goto fail;
-        }
-        priv->planes[priv->num_planes++] = plane;
+                encoder = mdp4_lcdc_encoder_init(dev, panel);
+                if (IS_ERR(encoder)) {
+                        dev_err(dev->dev, "failed to construct LCDC encoder\n");
+                        return PTR_ERR(encoder);
+                }
 
-        /*
-         * Setup the LCDC/LVDS path: RGB2 -> DMA_P -> LCDC -> LVDS:
-         */
+                /* LCDC can be hooked to DMA_P (TODO: Add DMA_S later?) */
+                encoder->possible_crtcs = 1 << DMA_P;
 
-        panel = detect_panel(dev);
-        if (IS_ERR(panel)) {
-                ret = PTR_ERR(panel);
-                dev_err(dev->dev, "failed to detect LVDS panel: %d\n", ret);
-                goto fail;
-        }
+                connector = mdp4_lvds_connector_init(dev, panel, encoder);
+                if (IS_ERR(connector)) {
+                        dev_err(dev->dev, "failed to initialize LVDS connector\n");
+                        return PTR_ERR(connector);
+                }
 
-        plane = mdp4_plane_init(dev, RGB2, true);
-        if (IS_ERR(plane)) {
-                dev_err(dev->dev, "failed to construct plane for RGB2\n");
-                ret = PTR_ERR(plane);
-                goto fail;
-        }
+                priv->encoders[priv->num_encoders++] = encoder;
+                priv->connectors[priv->num_connectors++] = connector;
 
-        crtc  = mdp4_crtc_init(dev, plane, priv->num_crtcs, 0, DMA_P);
-        if (IS_ERR(crtc)) {
-                dev_err(dev->dev, "failed to construct crtc for DMA_P\n");
-                ret = PTR_ERR(crtc);
-                goto fail;
-        }
+                break;
+        case DRM_MODE_ENCODER_TMDS:
+                encoder = mdp4_dtv_encoder_init(dev);
+                if (IS_ERR(encoder)) {
+                        dev_err(dev->dev, "failed to construct DTV encoder\n");
+                        return PTR_ERR(encoder);
+                }
 
-        encoder = mdp4_lcdc_encoder_init(dev, panel);
-        if (IS_ERR(encoder)) {
-                dev_err(dev->dev, "failed to construct LCDC encoder\n");
-                ret = PTR_ERR(encoder);
-                goto fail;
-        }
+                /* DTV can be hooked to DMA_E: */
+                encoder->possible_crtcs = 1 << 1;
 
-        /* LCDC can be hooked to DMA_P: */
-        encoder->possible_crtcs = 1 << priv->num_crtcs;
+                if (priv->hdmi) {
+                        /* Construct bridge/connector for HDMI: */
+                        ret = hdmi_modeset_init(priv->hdmi, dev, encoder);
+                        if (ret) {
+                                dev_err(dev->dev, "failed to initialize HDMI: %d\n", ret);
+                                return ret;
+                        }
+                }
 
-        priv->crtcs[priv->num_crtcs++] = crtc;
-        priv->encoders[priv->num_encoders++] = encoder;
+                priv->encoders[priv->num_encoders++] = encoder;
 
-        connector = mdp4_lvds_connector_init(dev, panel, encoder);
-        if (IS_ERR(connector)) {
-                ret = PTR_ERR(connector);
-                dev_err(dev->dev, "failed to initialize LVDS connector: %d\n", ret);
-                goto fail;
+                break;
+        default:
+                dev_err(dev->dev, "Invalid or unsupported interface\n");
+                return -EINVAL;
         }
 
-        priv->connectors[priv->num_connectors++] = connector;
 
-        /*
-         * Setup DTV/HDMI path: RGB1 -> DMA_E -> DTV -> HDMI:
-         */
+        return 0;
+}
 
-        plane = mdp4_plane_init(dev, RGB1, true);
-        if (IS_ERR(plane)) {
-                dev_err(dev->dev, "failed to construct plane for RGB1\n");
-                ret = PTR_ERR(plane);
-                goto fail;
-        }
+static int modeset_init(struct mdp4_kms *mdp4_kms)
+{
+        struct drm_device *dev = mdp4_kms->dev;
+        struct msm_drm_private *priv = dev->dev_private;
+        struct drm_plane *plane;
+        struct drm_crtc *crtc;
+        int i, ret;
+        static const enum mdp4_pipe rgb_planes[] = {
+                RGB1, RGB2,
+        };
+        static const enum mdp4_pipe vg_planes[] = {
+                VG1, VG2,
+        };
+        static const enum mdp4_dma mdp4_crtcs[] = {
+                DMA_P, DMA_E,
+        };
+        static const char * const mdp4_crtc_names[] = {
+                "DMA_P", "DMA_E",
+        };
+        static const int mdp4_intfs[] = {
+                DRM_MODE_ENCODER_LVDS,
+                DRM_MODE_ENCODER_TMDS,
+        };
 
-        crtc  = mdp4_crtc_init(dev, plane, priv->num_crtcs, 1, DMA_E);
-        if (IS_ERR(crtc)) {
-                dev_err(dev->dev, "failed to construct crtc for DMA_E\n");
-                ret = PTR_ERR(crtc);
-                goto fail;
+        /* construct non-private planes: */
+        for (i = 0; i < ARRAY_SIZE(vg_planes); i++) {
+                plane = mdp4_plane_init(dev, vg_planes[i], false);
+                if (IS_ERR(plane)) {
+                        dev_err(dev->dev,
+                                "failed to construct plane for VG%d\n", i + 1);
+                        ret = PTR_ERR(plane);
+                        goto fail;
+                }
+                priv->planes[priv->num_planes++] = plane;
         }
 
-        encoder = mdp4_dtv_encoder_init(dev);
-        if (IS_ERR(encoder)) {
-                dev_err(dev->dev, "failed to construct DTV encoder\n");
-                ret = PTR_ERR(encoder);
-                goto fail;
-        }
+        for (i = 0; i < ARRAY_SIZE(mdp4_crtcs); i++) {
+                plane = mdp4_plane_init(dev, rgb_planes[i], true);
+                if (IS_ERR(plane)) {
+                        dev_err(dev->dev,
+                                "failed to construct plane for RGB%d\n", i + 1);
+                        ret = PTR_ERR(plane);
+                        goto fail;
+                }
 
-        /* DTV can be hooked to DMA_E: */
-        encoder->possible_crtcs = 1 << priv->num_crtcs;
+                crtc  = mdp4_crtc_init(dev, plane, priv->num_crtcs, i,
+                                mdp4_crtcs[i]);
+                if (IS_ERR(crtc)) {
+                        dev_err(dev->dev, "failed to construct crtc for %s\n",
+                                mdp4_crtc_names[i]);
+                        ret = PTR_ERR(crtc);
+                        goto fail;
+                }
+
+                priv->crtcs[priv->num_crtcs++] = crtc;
+        }
 
-        priv->crtcs[priv->num_crtcs++] = crtc;
-        priv->encoders[priv->num_encoders++] = encoder;
+        /*
+         * we currently set up two relatively fixed paths:
+         *
+         * LCDC/LVDS path: RGB1 -> DMA_P -> LCDC -> LVDS
+         * DTV/HDMI path: RGB2 -> DMA_E -> DTV -> HDMI
+         */
 
-        if (priv->hdmi) {
-                /* Construct bridge/connector for HDMI: */
-                ret = hdmi_modeset_init(priv->hdmi, dev, encoder);
+        for (i = 0; i < ARRAY_SIZE(mdp4_intfs); i++) {
+                ret = mdp4_modeset_init_intf(mdp4_kms, mdp4_intfs[i]);
                 if (ret) {
-                        dev_err(dev->dev, "failed to initialize HDMI: %d\n", ret);
+                        dev_err(dev->dev, "failed to initialize intf: %d, %d\n",
+                                i, ret);
                         goto fail;
                 }
         }