drm/panel-simple: Non-eDP panels don't need "HPD" handling

All of the "HPD" handling added to panel-simple recently was for eDP
panels. Remove it from panel-simple now that panel-edp handles eDP
panels. The "prepare_to_enable" delay only makes sense in the context
of HPD, so remove it too. No non-eDP panels used it anyway.

Signed-off-by: Douglas Anderson <dianders@chromium.org>
Acked-by: Sam Ravnborg <sam@ravnborg.org>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Link: https://patchwork.freedesktop.org/patch/msgid/20210914132020.v5.9.I77d7a48df0a6585ef2cc2ff140fbe8f236a9a9f7@changeid

diff --git a/drivers/gpu/drm/panel/panel-simple.c b/drivers/gpu/drm/panel/panel-simple.c
index 133ba035bc33feb8dea51eee828df36b7c86b62e..7f3e1b84b5f5c54ed496947a89b4b1e76b95d6ff 100644 (file)
--- a/drivers/gpu/drm/panel/panel-simple.c
+++ b/drivers/gpu/drm/panel/panel-simple.c
@@ -23,7 +23,6 @@
 
 #include <linux/delay.h>
 #include <linux/gpio/consumer.h>
-#include <linux/iopoll.h>
 #include <linux/module.h>
 #include <linux/of_platform.h>
 #include <linux/platform_device.h>
@@ -92,44 +91,6 @@ struct panel_desc {
                 */
                unsigned int prepare;
 
-               /**
-                * @delay.hpd_absent_delay: Time to wait if HPD isn't hooked up.
-                *
-                * Add this to the prepare delay if we know Hot Plug Detect
-                * isn't used.
-                */
-               unsigned int hpd_absent_delay;
-
-               /**
-                * @delay.prepare_to_enable: Time between prepare and enable.
-                *
-                * The minimum time, in milliseconds, that needs to have passed
-                * between when prepare finished and enable may begin. If at
-                * enable time less time has passed since prepare finished,
-                * the driver waits for the remaining time.
-                *
-                * If a fixed enable delay is also specified, we'll start
-                * counting before delaying for the fixed delay.
-                *
-                * If a fixed prepare delay is also specified, we won't start
-                * counting until after the fixed delay. We can't overlap this
-                * fixed delay with the min time because the fixed delay
-                * doesn't happen at the end of the function if a HPD GPIO was
-                * specified.
-                *
-                * In other words:
-                *   prepare()
-                *     ...
-                *     // do fixed prepare delay
-                *     // wait for HPD GPIO if applicable
-                *     // start counting for prepare_to_enable
-                *
-                *   enable()
-                *     // do fixed enable delay
-                *     // enforce prepare_to_enable min time
-                */
-               unsigned int prepare_to_enable;
-
                /**
                 * @delay.enable: Time for the panel to display a valid frame.
                 *
@@ -174,7 +135,6 @@ struct panel_desc {
 struct panel_simple {
        struct drm_panel base;
        bool enabled;
-       bool no_hpd;
 
        bool prepared;
 
@@ -187,7 +147,6 @@ struct panel_simple {
        struct i2c_adapter *ddc;
 
        struct gpio_desc *enable_gpio;
-       struct gpio_desc *hpd_gpio;
 
        struct edid *edid;
 
@@ -371,30 +330,10 @@ static int panel_simple_unprepare(struct drm_panel *panel)
        return 0;
 }
 
-static int panel_simple_get_hpd_gpio(struct device *dev, struct panel_simple *p)
-{
-       int err;
-
-       p->hpd_gpio = devm_gpiod_get_optional(dev, "hpd", GPIOD_IN);
-       if (IS_ERR(p->hpd_gpio)) {
-               err = PTR_ERR(p->hpd_gpio);
-
-               if (err != -EPROBE_DEFER)
-                       dev_err(dev, "failed to get 'hpd' GPIO: %d\n", err);
-
-               return err;
-       }
-
-       return 0;
-}
-
-static int panel_simple_prepare_once(struct panel_simple *p)
+static int panel_simple_resume(struct device *dev)
 {
-       struct device *dev = p->base.dev;
-       unsigned int delay;
+       struct panel_simple *p = dev_get_drvdata(dev);
        int err;
-       int hpd_asserted;
-       unsigned long hpd_wait_us;
 
        panel_simple_wait(p->unprepared_time, p->desc->delay.unprepare);
 
@@ -406,68 +345,12 @@ static int panel_simple_prepare_once(struct panel_simple *p)
 
        gpiod_set_value_cansleep(p->enable_gpio, 1);
 
-       delay = p->desc->delay.prepare;
-       if (p->no_hpd)
-               delay += p->desc->delay.hpd_absent_delay;
-       if (delay)
-               msleep(delay);
-
-       if (p->hpd_gpio) {
-               if (p->desc->delay.hpd_absent_delay)
-                       hpd_wait_us = p->desc->delay.hpd_absent_delay * 1000UL;
-               else
-                       hpd_wait_us = 2000000;
-
-               err = readx_poll_timeout(gpiod_get_value_cansleep, p->hpd_gpio,
-                                        hpd_asserted, hpd_asserted,
-                                        1000, hpd_wait_us);
-               if (hpd_asserted < 0)
-                       err = hpd_asserted;
-
-               if (err) {
-                       if (err != -ETIMEDOUT)
-                               dev_err(dev,
-                                       "error waiting for hpd GPIO: %d\n", err);
-                       goto error;
-               }
-       }
+       if (p->desc->delay.prepare)
+               msleep(p->desc->delay.prepare);
 
        p->prepared_time = ktime_get();
 
        return 0;
-
-error:
-       gpiod_set_value_cansleep(p->enable_gpio, 0);
-       regulator_disable(p->supply);
-       p->unprepared_time = ktime_get();
-
-       return err;
-}
-
-/*
- * Some panels simply don't always come up and need to be power cycled to
- * work properly.  We'll allow for a handful of retries.
- */
-#define MAX_PANEL_PREPARE_TRIES                5
-
-static int panel_simple_resume(struct device *dev)
-{
-       struct panel_simple *p = dev_get_drvdata(dev);
-       int ret;
-       int try;
-
-       for (try = 0; try < MAX_PANEL_PREPARE_TRIES; try++) {
-               ret = panel_simple_prepare_once(p);
-               if (ret != -ETIMEDOUT)
-                       break;
-       }
-
-       if (ret == -ETIMEDOUT)
-               dev_err(dev, "Prepare timeout after %d tries\n", try);
-       else if (try)
-               dev_warn(dev, "Prepare needed %d retries\n", try);
-
-       return ret;
 }
 
 static int panel_simple_prepare(struct drm_panel *panel)
@@ -500,8 +383,6 @@ static int panel_simple_enable(struct drm_panel *panel)
        if (p->desc->delay.enable)
                msleep(p->desc->delay.enable);
 
-       panel_simple_wait(p->prepared_time, p->desc->delay.prepare_to_enable);
-
        p->enabled = true;
 
        return 0;
@@ -674,13 +555,6 @@ static int panel_simple_probe(struct device *dev, const struct panel_desc *desc)
        panel->prepared_time = 0;
        panel->desc = desc;
 
-       panel->no_hpd = of_property_read_bool(dev->of_node, "no-hpd");
-       if (!panel->no_hpd) {
-               err = panel_simple_get_hpd_gpio(dev, panel);
-               if (err)
-                       return err;
-       }
-
        panel->supply = devm_regulator_get(dev, "power");
        if (IS_ERR(panel->supply))
                return PTR_ERR(panel->supply);