Merge airlied/drm-next into drm-misc-next

[linux-2.6-microblaze.git] / drivers / gpu / drm / rockchip / analogix_dp-rockchip.c

diff --git a/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c b/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c
index 9606121..1262120 100644 (file)
--- a/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c
+++ b/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c
@@ -72,7 +72,7 @@ struct rockchip_dp_device {
        struct reset_control     *rst;
 
        struct work_struct       psr_work;
-       spinlock_t               psr_lock;
+       struct mutex             psr_lock;
        unsigned int             psr_state;
 
        const struct rockchip_dp_chip_data *data;
@@ -83,21 +83,20 @@ struct rockchip_dp_device {
 static void analogix_dp_psr_set(struct drm_encoder *encoder, bool enabled)
 {
        struct rockchip_dp_device *dp = to_dp(encoder);
-       unsigned long flags;
 
        if (!analogix_dp_psr_supported(dp->dev))
                return;
 
-       dev_dbg(dp->dev, "%s PSR...\n", enabled ? "Entry" : "Exit");
+       DRM_DEV_DEBUG(dp->dev, "%s PSR...\n", enabled ? "Entry" : "Exit");
 
-       spin_lock_irqsave(&dp->psr_lock, flags);
+       mutex_lock(&dp->psr_lock);
        if (enabled)
                dp->psr_state = EDP_VSC_PSR_STATE_ACTIVE;
        else
                dp->psr_state = ~EDP_VSC_PSR_STATE_ACTIVE;
 
        schedule_work(&dp->psr_work);
-       spin_unlock_irqrestore(&dp->psr_lock, flags);
+       mutex_unlock(&dp->psr_lock);
 }
 
 static void analogix_dp_psr_work(struct work_struct *work)
@@ -105,21 +104,20 @@ static void analogix_dp_psr_work(struct work_struct *work)
        struct rockchip_dp_device *dp =
                                container_of(work, typeof(*dp), psr_work);
        int ret;
-       unsigned long flags;
 
        ret = rockchip_drm_wait_vact_end(dp->encoder.crtc,
                                         PSR_WAIT_LINE_FLAG_TIMEOUT_MS);
        if (ret) {
-               dev_err(dp->dev, "line flag interrupt did not arrive\n");
+               DRM_DEV_ERROR(dp->dev, "line flag interrupt did not arrive\n");
                return;
        }
 
-       spin_lock_irqsave(&dp->psr_lock, flags);
+       mutex_lock(&dp->psr_lock);
        if (dp->psr_state == EDP_VSC_PSR_STATE_ACTIVE)
                analogix_dp_enable_psr(dp->dev);
        else
                analogix_dp_disable_psr(dp->dev);
-       spin_unlock_irqrestore(&dp->psr_lock, flags);
+       mutex_unlock(&dp->psr_lock);
 }
 
 static int rockchip_dp_pre_init(struct rockchip_dp_device *dp)
@@ -140,13 +138,13 @@ static int rockchip_dp_poweron(struct analogix_dp_plat_data *plat_data)
 
        ret = clk_prepare_enable(dp->pclk);
        if (ret < 0) {
-               dev_err(dp->dev, "failed to enable pclk %d\n", ret);
+               DRM_DEV_ERROR(dp->dev, "failed to enable pclk %d\n", ret);
                return ret;
        }
 
        ret = rockchip_dp_pre_init(dp);
        if (ret < 0) {
-               dev_err(dp->dev, "failed to dp pre init %d\n", ret);
+               DRM_DEV_ERROR(dp->dev, "failed to dp pre init %d\n", ret);
                clk_disable_unprepare(dp->pclk);
                return ret;
        }
@@ -211,17 +209,17 @@ static void rockchip_dp_drm_encoder_enable(struct drm_encoder *encoder)
        else
                val = dp->data->lcdsel_big;
 
-       dev_dbg(dp->dev, "vop %s output to dp\n", (ret) ? "LIT" : "BIG");
+       DRM_DEV_DEBUG(dp->dev, "vop %s output to dp\n", (ret) ? "LIT" : "BIG");
 
        ret = clk_prepare_enable(dp->grfclk);
        if (ret < 0) {
-               dev_err(dp->dev, "failed to enable grfclk %d\n", ret);
+               DRM_DEV_ERROR(dp->dev, "failed to enable grfclk %d\n", ret);
                return;
        }
 
        ret = regmap_write(dp->grf, dp->data->lcdsel_grf_reg, val);
        if (ret != 0)
-               dev_err(dp->dev, "Could not write to GRF: %d\n", ret);
+               DRM_DEV_ERROR(dp->dev, "Could not write to GRF: %d\n", ret);
 
        clk_disable_unprepare(dp->grfclk);
 }
@@ -269,15 +267,14 @@ static struct drm_encoder_funcs rockchip_dp_encoder_funcs = {
        .destroy = rockchip_dp_drm_encoder_destroy,
 };
 
-static int rockchip_dp_init(struct rockchip_dp_device *dp)
+static int rockchip_dp_of_probe(struct rockchip_dp_device *dp)
 {
        struct device *dev = dp->dev;
        struct device_node *np = dev->of_node;
-       int ret;
 
        dp->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
        if (IS_ERR(dp->grf)) {
-               dev_err(dev, "failed to get rockchip,grf property\n");
+               DRM_DEV_ERROR(dev, "failed to get rockchip,grf property\n");
                return PTR_ERR(dp->grf);
        }
 
@@ -287,35 +284,22 @@ static int rockchip_dp_init(struct rockchip_dp_device *dp)
        } else if (PTR_ERR(dp->grfclk) == -EPROBE_DEFER) {
                return -EPROBE_DEFER;
        } else if (IS_ERR(dp->grfclk)) {
-               dev_err(dev, "failed to get grf clock\n");
+               DRM_DEV_ERROR(dev, "failed to get grf clock\n");
                return PTR_ERR(dp->grfclk);
        }
 
        dp->pclk = devm_clk_get(dev, "pclk");
        if (IS_ERR(dp->pclk)) {
-               dev_err(dev, "failed to get pclk property\n");
+               DRM_DEV_ERROR(dev, "failed to get pclk property\n");
                return PTR_ERR(dp->pclk);
        }
 
        dp->rst = devm_reset_control_get(dev, "dp");
        if (IS_ERR(dp->rst)) {
-               dev_err(dev, "failed to get dp reset control\n");
+               DRM_DEV_ERROR(dev, "failed to get dp reset control\n");
                return PTR_ERR(dp->rst);
        }
 
-       ret = clk_prepare_enable(dp->pclk);
-       if (ret < 0) {
-               dev_err(dp->dev, "failed to enable pclk %d\n", ret);
-               return ret;
-       }
-
-       ret = rockchip_dp_pre_init(dp);
-       if (ret < 0) {
-               dev_err(dp->dev, "failed to pre init %d\n", ret);
-               clk_disable_unprepare(dp->pclk);
-               return ret;
-       }
-
        return 0;
 }
 
@@ -361,10 +345,6 @@ static int rockchip_dp_bind(struct device *dev, struct device *master,
        if (!dp_data)
                return -ENODEV;
 
-       ret = rockchip_dp_init(dp);
-       if (ret < 0)
-               return ret;
-
        dp->data = dp_data;
        dp->drm_dev = drm_dev;
 
@@ -381,7 +361,7 @@ static int rockchip_dp_bind(struct device *dev, struct device *master,
        dp->plat_data.power_off = rockchip_dp_powerdown;
        dp->plat_data.get_modes = rockchip_dp_get_modes;
 
-       spin_lock_init(&dp->psr_lock);
+       mutex_init(&dp->psr_lock);
        dp->psr_state = ~EDP_VSC_PSR_STATE_ACTIVE;
        INIT_WORK(&dp->psr_work, analogix_dp_psr_work);
 
@@ -398,7 +378,6 @@ static void rockchip_dp_unbind(struct device *dev, struct device *master,
        rockchip_drm_psr_unregister(&dp->encoder);
 
        analogix_dp_unbind(dev, master, data);
-       clk_disable_unprepare(dp->pclk);
 }
 
 static const struct component_ops rockchip_dp_component_ops = {
@@ -414,7 +393,7 @@ static int rockchip_dp_probe(struct platform_device *pdev)
        int ret;
 
        ret = drm_of_find_panel_or_bridge(dev->of_node, 1, 0, &panel, NULL);
-       if (ret)
+       if (ret < 0)
                return ret;
 
        dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL);
@@ -422,9 +401,12 @@ static int rockchip_dp_probe(struct platform_device *pdev)
                return -ENOMEM;
 
        dp->dev = dev;
-
        dp->plat_data.panel = panel;
 
+       ret = rockchip_dp_of_probe(dp);
+       if (ret < 0)
+               return ret;
+
        /*
         * We just use the drvdata until driver run into component
         * add function, and then we would set drvdata to null, so