The dispc hardware needs to be put in a known-good state when the
driver starts. This was previously done unconditionally during
dispc_init(), but it should only be performed on the reset path when
implementing state readout.

Rename dispc_init_hw() to dispc_reset_hw(), export it, and remove
the call from dispc_init(). Implement &drm_mode_config_funcs.hw_reset
through tidss_hw_reset() which performs the dispc soft reset and then
calls drm_mode_config_helper_hw_reset() to reset the rest of the
objects.

Reviewed-by: Maarten Lankhorst <[email protected]>
Signed-off-by: Maxime Ripard <[email protected]>
---
 drivers/gpu/drm/tidss/tidss_dispc.c | 48 +++++++++----------------------------
 drivers/gpu/drm/tidss/tidss_dispc.h |  1 +
 drivers/gpu/drm/tidss/tidss_drv.c   | 22 ++++++++++-------
 drivers/gpu/drm/tidss/tidss_kms.c   | 14 +++++++++++
 4 files changed, 40 insertions(+), 45 deletions(-)

diff --git a/drivers/gpu/drm/tidss/tidss_dispc.c 
b/drivers/gpu/drm/tidss/tidss_dispc.c
index b5fb296fddcc..8720403af9ed 100644
--- a/drivers/gpu/drm/tidss/tidss_dispc.c
+++ b/drivers/gpu/drm/tidss/tidss_dispc.c
@@ -2932,43 +2932,21 @@ static int dispc_softreset(struct dispc_device *dispc)
 }
 
-static int dispc_init_hw(struct dispc_device *dispc)
+int dispc_reset_hw(struct dispc_device *dispc)
 {
-       struct device *dev = dispc->dev;
+       struct tidss_device *tidss = dispc->tidss;
        int ret;
 
-       ret = pm_runtime_set_active(dev);
-       if (ret) {
-               dev_err(dev, "Failed to set DSS PM to active\n");
-               return ret;
-       }
-
-       ret = clk_prepare_enable(dispc->fclk);
-       if (ret) {
-               dev_err(dev, "Failed to enable DSS fclk\n");
-               goto err_runtime_suspend;
-       }
+       /*
+        * The reset runs from drm_mode_config_create_initial_state(), so
+        * after the driver has enabled runtime PM. As
+        * pm_runtime_set_active() is only allowed while runtime PM is
+        * disabled, rely on the regular runtime PM references to power
+        * the device up for the reset instead.
+        */
+       tidss_runtime_get(tidss);
 
        ret = dispc_softreset(dispc);
-       if (ret)
-               goto err_clk_disable;
 
-       clk_disable_unprepare(dispc->fclk);
-       ret = pm_runtime_set_suspended(dev);
-       if (ret) {
-               dev_err(dev, "Failed to set DSS PM to suspended\n");
-               return ret;
-       }
-
-       return 0;
-
-err_clk_disable:
-       clk_disable_unprepare(dispc->fclk);
-
-err_runtime_suspend:
-       ret = pm_runtime_set_suspended(dev);
-       if (ret) {
-               dev_err(dev, "Failed to set DSS PM to suspended\n");
-               return ret;
-       }
+       tidss_runtime_put(tidss);
 
        return ret;
@@ -3082,8 +3060,4 @@ int dispc_init(struct tidss_device *tidss)
                             &dispc->memory_bandwidth_limit);
 
-       r = dispc_init_hw(dispc);
-       if (r)
-               return r;
-
        tidss->dispc = dispc;
 
diff --git a/drivers/gpu/drm/tidss/tidss_dispc.h 
b/drivers/gpu/drm/tidss/tidss_dispc.h
index df3daccf3f31..caf0f8c58739 100644
--- a/drivers/gpu/drm/tidss/tidss_dispc.h
+++ b/drivers/gpu/drm/tidss/tidss_dispc.h
@@ -149,4 +149,5 @@ void dispc_plane_enable(struct dispc_device *dispc, u32 
hw_plane, bool enable);
 const u32 *dispc_plane_formats(struct dispc_device *dispc, unsigned int *len);
 
+int dispc_reset_hw(struct dispc_device *dispc);
 int dispc_init(struct tidss_device *tidss);
 void dispc_remove(struct tidss_device *tidss);
diff --git a/drivers/gpu/drm/tidss/tidss_drv.c 
b/drivers/gpu/drm/tidss/tidss_drv.c
index e258f656cf03..409d599bb2ff 100644
--- a/drivers/gpu/drm/tidss/tidss_drv.c
+++ b/drivers/gpu/drm/tidss/tidss_drv.c
@@ -152,4 +152,18 @@ static int tidss_probe(struct platform_device *pdev)
        }
 
+       drm_kms_helper_poll_init(ddev);
+
+       /*
+        * drm_mode_config_create_initial_state() resets the DISPC when
+        * the state readout isn't possible, which also clears the
+        * interrupt enable registers. Install the interrupts only once
+        * that's been done, so that the reset can't wipe them.
+        */
+       ret = drm_mode_config_create_initial_state(ddev);
+       if (ret) {
+               dev_err(dev, "failed to create initial state: %d\n", ret);
+               goto err_runtime_suspend;
+       }
+
        irq = platform_get_irq(pdev, 0);
        if (irq < 0) {
@@ -165,12 +179,4 @@ static int tidss_probe(struct platform_device *pdev)
        }
 
-       drm_kms_helper_poll_init(ddev);
-
-       ret = drm_mode_config_create_initial_state(ddev);
-       if (ret) {
-               dev_err(dev, "failed to create initial state: %d\n", ret);
-               goto err_irq_uninstall;
-       }
-
        ret = drm_dev_register(ddev, 0);
        if (ret) {
diff --git a/drivers/gpu/drm/tidss/tidss_kms.c 
b/drivers/gpu/drm/tidss/tidss_kms.c
index eefe2221bdde..a3bf94e56fcb 100644
--- a/drivers/gpu/drm/tidss/tidss_kms.c
+++ b/drivers/gpu/drm/tidss/tidss_kms.c
@@ -11,4 +11,5 @@
 #include <drm/drm_of.h>
 #include <drm/drm_panel.h>
+#include <drm/drm_print.h>
 #include <drm/drm_vblank.h>
 
@@ -117,8 +118,21 @@ static int tidss_atomic_check(struct drm_device *ddev,
 }
 
+static void tidss_hw_reset(struct drm_device *dev)
+{
+       struct tidss_device *tidss = to_tidss(dev);
+       int ret;
+
+       ret = dispc_reset_hw(tidss->dispc);
+       if (ret)
+               drm_warn(dev, "Couldn't reset dispc");
+
+       drm_mode_config_helper_hw_reset(dev);
+}
+
 static const struct drm_mode_config_funcs mode_config_funcs = {
        .fb_create = drm_gem_fb_create,
        .atomic_check = tidss_atomic_check,
        .atomic_commit = drm_atomic_helper_commit,
+       .hw_reset = tidss_hw_reset,
 };
 

-- 
2.55.0

Reply via email to