drm/panel-simple: Support hpd-gpios for delaying prepare()

People use panel-simple when they have panels that are builtin to
their device.  In these cases the HPD (Hot Plug Detect) signal isn't
really used for hotplugging devices but instead is used for power
sequencing.  Panel timing diagrams (especially for eDP panels) usually
have the HPD signal in them and it acts as an indicator that the panel
is ready for us to talk to it.

Sometimes the HPD signal is hooked up to a normal GPIO on a system.
In this case we need to poll it in the correct place to know that the
panel is ready for us.  In some system designs the right place for
this is panel-simple.

When adding this support, we'll account for the case that there might
be a circular dependency between panel-simple and the provider of the
GPIO.  The case this was designed for was for the "ti-sn65dsi86"
bridge chip.  If HPD is hooked up to one of the GPIOs provided by the
bridge chip then in our probe function we'll always get back
-EPROBE_DEFER.  Let's handle this by allowing this GPIO to show up
late if we saw -EPROBE_DEFER during probe.  NOTE: since the
gpio_get_optional() is used, if the "hpd-gpios" isn't there our
variable will just be NULL and we won't do anything in prepare().

Signed-off-by: Douglas Anderson <dianders@chromium.org>
Reviewed-by: Stephen Boyd <swboyd@chromium.org>
Reviewed-by: Linus Walleij <linus.walleij@linaro.org>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
Link: https://patchwork.freedesktop.org/patch/msgid/20200507143354.v5.3.I53fed5b501a31e7a7fa13268ebcdd6b77bd0cadd@changeid

diff --git a/drivers/gpu/drm/panel/panel-simple.c b/drivers/gpu/drm/panel/panel-simple.c
index 7fb7b25..b6ecd15 100644 (file)
--- a/drivers/gpu/drm/panel/panel-simple.c
+++ b/drivers/gpu/drm/panel/panel-simple.c
@@ -23,6 +23,7 @@
 
 #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>
@@ -108,6 +109,7 @@ struct panel_simple {
        struct i2c_adapter *ddc;
 
        struct gpio_desc *enable_gpio;
+       struct gpio_desc *hpd_gpio;
 
        struct drm_display_mode override_mode;
 };
@@ -259,11 +261,37 @@ 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, bool from_probe)
+{
+       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 we're called from probe we won't consider '-EPROBE_DEFER'
+                * to be an error--we'll leave the error code in "hpd_gpio".
+                * When we try to use it we'll try again.  This allows for
+                * circular dependencies where the component providing the
+                * hpd gpio needs the panel to init before probing.
+                */
+               if (err != -EPROBE_DEFER || !from_probe) {
+                       dev_err(dev, "failed to get 'hpd' GPIO: %d\n", err);
+                       return err;
+               }
+       }
+
+       return 0;
+}
+
 static int panel_simple_prepare(struct drm_panel *panel)
 {
        struct panel_simple *p = to_panel_simple(panel);
        unsigned int delay;
        int err;
+       int hpd_asserted;
 
        if (p->prepared)
                return 0;
@@ -282,6 +310,26 @@ static int panel_simple_prepare(struct drm_panel *panel)
        if (delay)
                msleep(delay);
 
+       if (p->hpd_gpio) {
+               if (IS_ERR(p->hpd_gpio)) {
+                       err = panel_simple_get_hpd_gpio(panel->dev, p, false);
+                       if (err)
+                               return err;
+               }
+
+               err = readx_poll_timeout(gpiod_get_value_cansleep, p->hpd_gpio,
+                                        hpd_asserted, hpd_asserted,
+                                        1000, 2000000);
+               if (hpd_asserted < 0)
+                       err = hpd_asserted;
+
+               if (err) {
+                       dev_err(panel->dev,
+                               "error waiting for hpd GPIO: %d\n", err);
+                       return err;
+               }
+       }
+
        p->prepared = true;
 
        return 0;
@@ -462,6 +510,11 @@ static int panel_simple_probe(struct device *dev, const struct panel_desc *desc)
        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, true);
+               if (err)
+                       return err;
+       }
 
        panel->supply = devm_regulator_get(dev, "power");
        if (IS_ERR(panel->supply))