Commit b6d5ffce authored by Douglas Anderson's avatar Douglas Anderson
Browse files

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: default avatarDouglas Anderson <dianders@chromium.org>
Acked-by: default avatarSam Ravnborg <sam@ravnborg.org>
Acked-by: default avatarLinus Walleij <linus.walleij@linaro.org>
Link: https://patchwork.freedesktop.org/patch/msgid/20210914132020.v5.9.I77d7a48df0a6585ef2cc2ff140fbe8f236a9a9f7@changeid
parent 3fd68b7b

drivers/gpu/drm/panel/panel-simple.c

+4 −130
Original line number Diff line number Diff line
@@ -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);