drm/exynos: consider deferred probe case

This patch makes sure that exynos drm framework handles deferred
probe case correctly.

Sub drivers could be probed before resources, clock, regulator,
phy or panel, are ready for them so we should make sure that exynos
drm core waits until all resources are ready and sub drivers are
probed correctly.

Chagelog v2:
- Make sure that exynos drm core tries to bind sub drivers only in case that
  they have a pair: crtc and encoder/connector components should be a pair.
- Remove unnecessary patch:
  drm/exynos: mipi-dsi: consider panel driver-deferred probe
- Return error type correctly.

Signed-off-by: Inki Dae <inki.dae@samsung.com>
Acked-by: Kyungmin Park <kyungmin.park@samsung.com>

8 files changed, 303 insertions, 75 deletions

diff --git a/drivers/gpu/drm/exynos/exynos_dp_core.c b/drivers/gpu/drm/exynos/exynos_dp_core.c
index 8b67f4141e78..5e05dbc60082 100644
--- a/drivers/gpu/drm/exynos/exynos_dp_core.c
+++ b/drivers/gpu/drm/exynos/exynos_dp_core.c
@@ -1325,12 +1325,26 @@ static const struct component_ops exynos_dp_ops = {
 
 static int exynos_dp_probe(struct platform_device *pdev)
 {
-        return exynos_drm_component_add(&pdev->dev, &exynos_dp_ops);
+        int ret;
+
+        ret = exynos_drm_component_add(&pdev->dev, EXYNOS_DEVICE_TYPE_CONNECTOR,
+                                        exynos_dp_display.type);
+        if (ret)
+                return ret;
+
+        ret = component_add(&pdev->dev, &exynos_dp_ops);
+        if (ret)
+                exynos_drm_component_del(&pdev->dev,
+                                                EXYNOS_DEVICE_TYPE_CONNECTOR);
+
+        return ret;
 }
 
 static int exynos_dp_remove(struct platform_device *pdev)
 {
-        exynos_drm_component_del(&pdev->dev, &exynos_dp_ops);
+        component_del(&pdev->dev, &exynos_dp_ops);
+        exynos_drm_component_del(&pdev->dev, EXYNOS_DEVICE_TYPE_CONNECTOR);
+
         return 0;
 }
 
diff --git a/drivers/gpu/drm/exynos/exynos_drm_dpi.c b/drivers/gpu/drm/exynos/exynos_drm_dpi.c
index a832364358a7..f1b8587cc63d 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_dpi.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_dpi.c
@@ -295,9 +295,15 @@ struct exynos_drm_display *exynos_dpi_probe(struct device *dev)
         struct exynos_dpi *ctx;
         int ret;
 
+        ret = exynos_drm_component_add(dev,
+                                        EXYNOS_DEVICE_TYPE_CONNECTOR,
+                                        exynos_dpi_display.type);
+        if (ret)
+                return ERR_PTR(ret);
+
         ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
         if (!ctx)
-                return NULL;
+                goto err_del_component;
 
         ctx->dev = dev;
         exynos_dpi_display.ctx = ctx;
@@ -306,16 +312,24 @@ struct exynos_drm_display *exynos_dpi_probe(struct device *dev)
         ret = exynos_dpi_parse_dt(ctx);
         if (ret < 0) {
                 devm_kfree(dev, ctx);
-                return NULL;
+                goto err_del_component;
         }
 
         if (ctx->panel_node) {
                 ctx->panel = of_drm_find_panel(ctx->panel_node);
-                if (!ctx->panel)
+                if (!ctx->panel) {
+                        exynos_drm_component_del(dev,
+                                                EXYNOS_DEVICE_TYPE_CONNECTOR);
                         return ERR_PTR(-EPROBE_DEFER);
+                }
         }
 
         return &exynos_dpi_display;
+
+err_del_component:
+        exynos_drm_component_del(dev, EXYNOS_DEVICE_TYPE_CONNECTOR);
+
+        return NULL;
 }
 
 int exynos_dpi_remove(struct device *dev)
@@ -327,5 +341,7 @@ int exynos_dpi_remove(struct device *dev)
         encoder->funcs->destroy(encoder);
         drm_connector_cleanup(&ctx->connector);
 
+        exynos_drm_component_del(dev, EXYNOS_DEVICE_TYPE_CONNECTOR);
+
         return 0;
 }
diff --git a/drivers/gpu/drm/exynos/exynos_drm_drv.c b/drivers/gpu/drm/exynos/exynos_drm_drv.c
index c5a401ae4de5..5d225dd58a87 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_drv.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_drv.c
@@ -48,7 +48,10 @@ static LIST_HEAD(drm_component_list);
 
 struct component_dev {
         struct list_head list;
-        struct device *dev;
+        struct device *crtc_dev;
+        struct device *conn_dev;
+        enum exynos_drm_output_type out_type;
+        unsigned int dev_type_flag;
 };
 
 static int exynos_drm_load(struct drm_device *dev, unsigned long flags)
@@ -382,22 +385,65 @@ static const struct dev_pm_ops exynos_drm_pm_ops = {
 };
 
 int exynos_drm_component_add(struct device *dev,
-                                const struct component_ops *ops)
+                                enum exynos_drm_device_type dev_type,
+                                enum exynos_drm_output_type out_type)
 {
         struct component_dev *cdev;
-        int ret;
+
+        if (dev_type != EXYNOS_DEVICE_TYPE_CRTC &&
+                        dev_type != EXYNOS_DEVICE_TYPE_CONNECTOR) {
+                DRM_ERROR("invalid device type.\n");
+                return -EINVAL;
+        }
+
+        mutex_lock(&drm_component_lock);
+
+        /*
+         * Make sure to check if there is a component which has two device
+         * objects, for connector and for encoder/connector.
+         * It should make sure that crtc and encoder/connector drivers are
+         * ready before exynos drm core binds them.
+         */
+        list_for_each_entry(cdev, &drm_component_list, list) {
+                if (cdev->out_type == out_type) {
+                        /*
+                         * If crtc and encoder/connector device objects are
+                         * added already just return.
+                         */
+                        if (cdev->dev_type_flag == (EXYNOS_DEVICE_TYPE_CRTC |
+                                                EXYNOS_DEVICE_TYPE_CONNECTOR)) {
+                                mutex_unlock(&drm_component_lock);
+                                return 0;
+                        }
+
+                        if (dev_type == EXYNOS_DEVICE_TYPE_CRTC) {
+                                cdev->crtc_dev = dev;
+                                cdev->dev_type_flag |= dev_type;
+                        }
+
+                        if (dev_type == EXYNOS_DEVICE_TYPE_CONNECTOR) {
+                                cdev->conn_dev = dev;
+                                cdev->dev_type_flag |= dev_type;
+                        }
+
+                        mutex_unlock(&drm_component_lock);
+                        return 0;
+                }
+        }
+
+        mutex_unlock(&drm_component_lock);