Commit dada25bd authored by Rob Clark's avatar Rob Clark
Browse files

drm/msm: add hdmi support for apq8x74/mdp5 



The HDMI block is basically the same between older SoC's with mdp4
display controller, and newer ones with mdp5.

So mostly this consists of better abstracting out the different sets of
regulators, clks, etc.  In particular, for regulators and clks we can
split it up by what is needed for hot plug detect to work, and what is
needed to light up the display.

Also, 8x74 has a new phy.. a very simple one, but split out into a
different mmio space.  And with mdp5, the irq is shared with mdp, so we
don't directly register our own irq handler.

Signed-off-by: default avatarRob Clark <robdclark@gmail.com>
parent 9e0efa63

drivers/gpu/drm/msm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ msm-y := \ 
	hdmi/hdmi_i2c.o \

	hdmi/hdmi_phy_8960.o \

	hdmi/hdmi_phy_8x60.o \

	hdmi/hdmi_phy_8x74.o \

	mdp/mdp_format.o \

	mdp/mdp_kms.o \

	mdp/mdp4/mdp4_crtc.o \

drivers/gpu/drm/msm/hdmi/hdmi.c

+150 −49
Original line number Diff line number Diff line
@@ -41,7 +41,7 @@ void hdmi_set_mode(struct hdmi *hdmi, bool power_on) 
			power_on ? "Enable" : "Disable", ctrl);

}



static irqreturn_t hdmi_irq(int irq, void *dev_id)

irqreturn_t hdmi_irq(int irq, void *dev_id)

{

	struct hdmi *hdmi = dev_id;
@@ -71,13 +71,13 @@ void hdmi_destroy(struct kref *kref) 
}



/* initialize connector */

int hdmi_init(struct drm_device *dev, struct drm_encoder *encoder)

struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder)

{

	struct hdmi *hdmi = NULL;

	struct msm_drm_private *priv = dev->dev_private;

	struct platform_device *pdev = hdmi_pdev;

	struct hdmi_platform_config *config;

	int ret;

	int i, ret;



	if (!pdev) {

		dev_err(dev->dev, "no hdmi device\n");
@@ -99,6 +99,7 @@ int hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) 


	hdmi->dev = dev;

	hdmi->pdev = pdev;

	hdmi->config = config;

	hdmi->encoder = encoder;



	/* not sure about which phy maps to which msm.. probably I miss some */
@@ -114,46 +115,72 @@ int hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) 
		goto fail;

	}



	hdmi->mmio = msm_ioremap(pdev, "hdmi_msm_hdmi_addr", "HDMI");

	hdmi->mmio = msm_ioremap(pdev, config->mmio_name, "HDMI");

	if (IS_ERR(hdmi->mmio)) {

		ret = PTR_ERR(hdmi->mmio);

		goto fail;

	}



	hdmi->mvs = devm_regulator_get(&pdev->dev, "8901_hdmi_mvs");

	if (IS_ERR(hdmi->mvs))

		hdmi->mvs = devm_regulator_get(&pdev->dev, "8921_hdmi_mvs");

	if (IS_ERR(hdmi->mvs)) {

		ret = PTR_ERR(hdmi->mvs);

		dev_err(dev->dev, "failed to get mvs regulator: %d\n", ret);

	BUG_ON(config->hpd_reg_cnt > ARRAY_SIZE(hdmi->hpd_regs));

	for (i = 0; i < config->hpd_reg_cnt; i++) {

		struct regulator *reg;



		reg = devm_regulator_get(&pdev->dev, config->hpd_reg_names[i]);

		if (IS_ERR(reg)) {

			ret = PTR_ERR(reg);

			dev_err(dev->dev, "failed to get hpd regulator: %s (%d)\n",

					config->hpd_reg_names[i], ret);

			goto fail;

		}



	hdmi->mpp0 = devm_regulator_get(&pdev->dev, "8901_mpp0");

	if (IS_ERR(hdmi->mpp0))

		hdmi->mpp0 = NULL;

		hdmi->hpd_regs[i] = reg;

	}



	BUG_ON(config->pwr_reg_cnt > ARRAY_SIZE(hdmi->pwr_regs));

	for (i = 0; i < config->pwr_reg_cnt; i++) {

		struct regulator *reg;



	hdmi->clk = devm_clk_get(&pdev->dev, "core_clk");

	if (IS_ERR(hdmi->clk)) {

		ret = PTR_ERR(hdmi->clk);

		dev_err(dev->dev, "failed to get 'clk': %d\n", ret);

		reg = devm_regulator_get(&pdev->dev, config->pwr_reg_names[i]);

		if (IS_ERR(reg)) {

			ret = PTR_ERR(reg);

			dev_err(dev->dev, "failed to get pwr regulator: %s (%d)\n",

					config->pwr_reg_names[i], ret);

			goto fail;

		}



	hdmi->m_pclk = devm_clk_get(&pdev->dev, "master_iface_clk");

	if (IS_ERR(hdmi->m_pclk)) {

		ret = PTR_ERR(hdmi->m_pclk);

		dev_err(dev->dev, "failed to get 'm_pclk': %d\n", ret);

		hdmi->pwr_regs[i] = reg;

	}



	BUG_ON(config->hpd_clk_cnt > ARRAY_SIZE(hdmi->hpd_clks));

	for (i = 0; i < config->hpd_clk_cnt; i++) {

		struct clk *clk;



		clk = devm_clk_get(&pdev->dev, config->hpd_clk_names[i]);

		if (IS_ERR(clk)) {

			ret = PTR_ERR(clk);

			dev_err(dev->dev, "failed to get hpd clk: %s (%d)\n",

					config->hpd_clk_names[i], ret);

			goto fail;

		}



	hdmi->s_pclk = devm_clk_get(&pdev->dev, "slave_iface_clk");

	if (IS_ERR(hdmi->s_pclk)) {

		ret = PTR_ERR(hdmi->s_pclk);

		dev_err(dev->dev, "failed to get 's_pclk': %d\n", ret);

		hdmi->hpd_clks[i] = clk;

	}



	BUG_ON(config->pwr_clk_cnt > ARRAY_SIZE(hdmi->pwr_clks));

	for (i = 0; i < config->pwr_clk_cnt; i++) {

		struct clk *clk;



		clk = devm_clk_get(&pdev->dev, config->pwr_clk_names[i]);

		if (IS_ERR(clk)) {

			ret = PTR_ERR(clk);

			dev_err(dev->dev, "failed to get pwr clk: %s (%d)\n",

					config->pwr_clk_names[i], ret);

			goto fail;

		}



		hdmi->pwr_clks[i] = clk;

	}



	hdmi->i2c = hdmi_i2c_init(hdmi);

	if (IS_ERR(hdmi->i2c)) {

		ret = PTR_ERR(hdmi->i2c);
@@ -178,6 +205,7 @@ int hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) 
		goto fail;

	}



	if (!config->shared_irq) {

		hdmi->irq = platform_get_irq(pdev, 0);

		if (hdmi->irq < 0) {

			ret = hdmi->irq;
@@ -193,13 +221,14 @@ int hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) 
					hdmi->irq, ret);

			goto fail;

		}

	}



	encoder->bridge = hdmi->bridge;



	priv->bridges[priv->num_bridges++]       = hdmi->bridge;

	priv->connectors[priv->num_connectors++] = hdmi->connector;



	return 0;

	return hdmi;



fail:

	if (hdmi) {
@@ -211,37 +240,100 @@ fail: 
		hdmi_destroy(&hdmi->refcount);

	}



	return ret;

	return ERR_PTR(ret);

}



/*

 * The hdmi device:

 */



#include <linux/of_gpio.h>



static int hdmi_dev_probe(struct platform_device *pdev)

{

	static struct hdmi_platform_config config = {};

#ifdef CONFIG_OF

	/* TODO */

	struct device_node *of_node = pdev->dev.of_node;



	int get_gpio(const char *name)

	{

		int gpio = of_get_named_gpio(of_node, name, 0);

		if (gpio < 0) {

			dev_err(&pdev->dev, "failed to get gpio: %s (%d)\n",

					name, gpio);

			gpio = -1;

		}

		return gpio;

	}



	/* TODO actually use DT.. */

	static const char *hpd_reg_names[] = {"hpd-gdsc", "hpd-5v"};

	static const char *pwr_reg_names[] = {"core-vdda", "core-vcc"};

	static const char *hpd_clk_names[] = {"iface_clk", "core_clk", "mdp_core_clk"};

	static const char *pwr_clk_names[] = {"extp_clk", "alt_iface_clk"};



	config.phy_init      = hdmi_phy_8x74_init;

	config.mmio_name     = "core_physical";

	config.hpd_reg_names = hpd_reg_names;

	config.hpd_reg_cnt   = ARRAY_SIZE(hpd_reg_names);

	config.pwr_reg_names = pwr_reg_names;

	config.pwr_reg_cnt   = ARRAY_SIZE(pwr_reg_names);

	config.hpd_clk_names = hpd_clk_names;

	config.hpd_clk_cnt   = ARRAY_SIZE(hpd_clk_names);

	config.pwr_clk_names = pwr_clk_names;

	config.pwr_clk_cnt   = ARRAY_SIZE(pwr_clk_names);

	config.ddc_clk_gpio  = get_gpio("qcom,hdmi-tx-ddc-clk");

	config.ddc_data_gpio = get_gpio("qcom,hdmi-tx-ddc-data");

	config.hpd_gpio      = get_gpio("qcom,hdmi-tx-hpd");

	config.mux_en_gpio   = get_gpio("qcom,hdmi-tx-mux-en");

	config.mux_sel_gpio  = get_gpio("qcom,hdmi-tx-mux-sel");

	config.shared_irq    = true;



#else

	static const char *hpd_clk_names[] = {

			"core_clk", "master_iface_clk", "slave_iface_clk",

	};

	if (cpu_is_apq8064()) {

		static const char *hpd_reg_names[] = {"8921_hdmi_mvs"};

		config.phy_init      = hdmi_phy_8960_init;

		config.mmio_name     = "hdmi_msm_hdmi_addr";

		config.hpd_reg_names = hpd_reg_names;

		config.hpd_reg_cnt   = ARRAY_SIZE(hpd_reg_names);

		config.hpd_clk_names = hpd_clk_names;

		config.hpd_clk_cnt   = ARRAY_SIZE(hpd_clk_names);

		config.ddc_clk_gpio  = 70;

		config.ddc_data_gpio = 71;

		config.hpd_gpio      = 72;

		config.pmic_gpio     = 13 + NR_GPIO_IRQS;

		config.mux_en_gpio   = -1;

		config.mux_sel_gpio  = 13 + NR_GPIO_IRQS;

	} else if (cpu_is_msm8960() || cpu_is_msm8960ab()) {

		static const char *hpd_reg_names[] = {"8921_hdmi_mvs"};

		config.phy_init      = hdmi_phy_8960_init;

		config.mmio_name     = "hdmi_msm_hdmi_addr";

		config.hpd_reg_names = hpd_reg_names;

		config.hpd_reg_cnt   = ARRAY_SIZE(hpd_reg_names);

		config.hpd_clk_names = hpd_clk_names;

		config.hpd_clk_cnt   = ARRAY_SIZE(hpd_clk_names);

		config.ddc_clk_gpio  = 100;

		config.ddc_data_gpio = 101;

		config.hpd_gpio      = 102;

		config.pmic_gpio     = -1;

		config.mux_en_gpio   = -1;

		config.mux_sel_gpio  = -1;

	} else if (cpu_is_msm8x60()) {

		static const char *hpd_reg_names[] = {

				"8901_hdmi_mvs", "8901_mpp0"

		};

		config.phy_init      = hdmi_phy_8x60_init;

		config.mmio_name     = "hdmi_msm_hdmi_addr";

		config.hpd_reg_names = hpd_reg_names;

		config.hpd_reg_cnt   = ARRAY_SIZE(hpd_reg_names);

		config.hpd_clk_names = hpd_clk_names;

		config.hpd_clk_cnt   = ARRAY_SIZE(hpd_clk_names);

		config.ddc_clk_gpio  = 170;

		config.ddc_data_gpio = 171;

		config.hpd_gpio      = 172;

		config.pmic_gpio     = -1;

		config.mux_en_gpio   = -1;

		config.mux_sel_gpio  = -1;

	}

#endif

	pdev->dev.platform_data = &config;
@@ -255,10 +347,19 @@ static int hdmi_dev_remove(struct platform_device *pdev) 
	return 0;

}



static const struct of_device_id dt_match[] = {

	{ .compatible = "qcom,hdmi-tx" },

	{}

};

MODULE_DEVICE_TABLE(of, dt_match);



static struct platform_driver hdmi_driver = {

	.probe = hdmi_dev_probe,

	.remove = hdmi_dev_remove,

	.driver.name = "hdmi_msm",

	.driver = {

		.name = "hdmi_msm",

		.of_match_table = dt_match,

	},

};



void __init hdmi_register(void)

drivers/gpu/drm/msm/hdmi/hdmi.h

+31 −7
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 




struct hdmi_phy;

struct hdmi_platform_config;



struct hdmi {

	struct kref refcount;
@@ -35,14 +36,14 @@ struct hdmi { 
	struct drm_device *dev;

	struct platform_device *pdev;



	void __iomem *mmio;

	const struct hdmi_platform_config *config;



	struct regulator *mvs;        /* HDMI_5V */

	struct regulator *mpp0;       /* External 5V */

	void __iomem *mmio;



	struct clk *clk;

	struct clk *m_pclk;

	struct clk *s_pclk;

	struct regulator *hpd_regs[2];

	struct regulator *pwr_regs[2];

	struct clk *hpd_clks[3];

	struct clk *pwr_clks[2];



	struct hdmi_phy *phy;

	struct i2c_adapter *i2c;
@@ -60,7 +61,29 @@ struct hdmi { 
/* platform config data (ie. from DT, or pdata) */

struct hdmi_platform_config {

	struct hdmi_phy *(*phy_init)(struct hdmi *hdmi);

	int ddc_clk_gpio, ddc_data_gpio, hpd_gpio, pmic_gpio;

	const char *mmio_name;



	/* regulators that need to be on for hpd: */

	const char **hpd_reg_names;

	int hpd_reg_cnt;



	/* regulators that need to be on for screen pwr: */

	const char **pwr_reg_names;

	int pwr_reg_cnt;



	/* clks that need to be on for hpd: */

	const char **hpd_clk_names;

	int hpd_clk_cnt;



	/* clks that need to be on for screen pwr (ie pixel clk): */

	const char **pwr_clk_names;

	int pwr_clk_cnt;



	/* gpio's: */

	int ddc_clk_gpio, ddc_data_gpio, hpd_gpio, mux_en_gpio, mux_sel_gpio;



	/* older devices had their own irq, mdp5+ it is shared w/ mdp: */

	bool shared_irq;

};



void hdmi_set_mode(struct hdmi *hdmi, bool power_on);
@@ -106,6 +129,7 @@ struct hdmi_phy { 


struct hdmi_phy *hdmi_phy_8960_init(struct hdmi *hdmi);

struct hdmi_phy *hdmi_phy_8x60_init(struct hdmi *hdmi);

struct hdmi_phy *hdmi_phy_8x74_init(struct hdmi *hdmi);



/*

 * hdmi bridge:

drivers/gpu/drm/msm/hdmi/hdmi_bridge.c

+71 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ struct hdmi_bridge { 
	struct drm_bridge base;



	struct hdmi *hdmi;

	bool power_on;



	unsigned long int pixclock;

};
@@ -34,6 +35,65 @@ static void hdmi_bridge_destroy(struct drm_bridge *bridge) 
	kfree(hdmi_bridge);

}



static void power_on(struct drm_bridge *bridge)

{

	struct drm_device *dev = bridge->dev;

	struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);

	struct hdmi *hdmi = hdmi_bridge->hdmi;

	const struct hdmi_platform_config *config = hdmi->config;

	int i, ret;



	for (i = 0; i < config->pwr_reg_cnt; i++) {

		ret = regulator_enable(hdmi->pwr_regs[i]);

		if (ret) {

			dev_err(dev->dev, "failed to enable pwr regulator: %s (%d)\n",

					config->pwr_reg_names[i], ret);

		}

	}



	if (config->pwr_clk_cnt > 0) {

		DBG("pixclock: %lu", hdmi_bridge->pixclock);

		ret = clk_set_rate(hdmi->pwr_clks[0], hdmi_bridge->pixclock);

		if (ret) {

			dev_err(dev->dev, "failed to set pixel clk: %s (%d)\n",

					config->pwr_clk_names[0], ret);

		}

	}



	for (i = 0; i < config->pwr_clk_cnt; i++) {

		ret = clk_prepare_enable(hdmi->pwr_clks[i]);

		if (ret) {

			dev_err(dev->dev, "failed to enable pwr clk: %s (%d)\n",

					config->pwr_clk_names[i], ret);

		}

	}

}



static void power_off(struct drm_bridge *bridge)

{

	struct drm_device *dev = bridge->dev;

	struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);

	struct hdmi *hdmi = hdmi_bridge->hdmi;

	const struct hdmi_platform_config *config = hdmi->config;

	int i, ret;



	/* TODO do we need to wait for final vblank somewhere before

	 * cutting the clocks?

	 */

	mdelay(16 + 4);



	for (i = 0; i < config->pwr_clk_cnt; i++)

		clk_disable_unprepare(hdmi->pwr_clks[i]);



	for (i = 0; i < config->pwr_reg_cnt; i++) {

		ret = regulator_disable(hdmi->pwr_regs[i]);

		if (ret) {

			dev_err(dev->dev, "failed to disable pwr regulator: %s (%d)\n",

					config->pwr_reg_names[i], ret);

		}

	}

}



static void hdmi_bridge_pre_enable(struct drm_bridge *bridge)

{

	struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
@@ -41,6 +101,12 @@ static void hdmi_bridge_pre_enable(struct drm_bridge *bridge) 
	struct hdmi_phy *phy = hdmi->phy;



	DBG("power up");



	if (!hdmi_bridge->power_on) {

		power_on(bridge);

		hdmi_bridge->power_on = true;

	}



	phy->funcs->powerup(phy, hdmi_bridge->pixclock);

	hdmi_set_mode(hdmi, true);

}
@@ -62,6 +128,11 @@ static void hdmi_bridge_post_disable(struct drm_bridge *bridge) 
	DBG("power down");

	hdmi_set_mode(hdmi, false);

	phy->funcs->powerdown(phy);



	if (hdmi_bridge->power_on) {

		power_off(bridge);

		hdmi_bridge->power_on = false;

	}

}



static void hdmi_bridge_mode_set(struct drm_bridge *bridge,

drivers/gpu/drm/msm/hdmi/hdmi_connector.c

+92 −46
Original line number Diff line number Diff line
@@ -23,14 +23,14 @@ 
struct hdmi_connector {

	struct drm_connector base;

	struct hdmi *hdmi;

	struct work_struct hpd_work;

};

#define to_hdmi_connector(x) container_of(x, struct hdmi_connector, base)



static int gpio_config(struct hdmi *hdmi, bool on)

{

	struct drm_device *dev = hdmi->dev;

	struct hdmi_platform_config *config =

			hdmi->pdev->dev.platform_data;

	const struct hdmi_platform_config *config = hdmi->config;

	int ret;



	if (on) {
@@ -40,26 +40,43 @@ static int gpio_config(struct hdmi *hdmi, bool on) 
				"HDMI_DDC_CLK", config->ddc_clk_gpio, ret);

			goto error1;

		}

		gpio_set_value_cansleep(config->ddc_clk_gpio, 1);



		ret = gpio_request(config->ddc_data_gpio, "HDMI_DDC_DATA");

		if (ret) {

			dev_err(dev->dev, "'%s'(%d) gpio_request failed: %d\n",

				"HDMI_DDC_DATA", config->ddc_data_gpio, ret);

			goto error2;

		}

		gpio_set_value_cansleep(config->ddc_data_gpio, 1);



		ret = gpio_request(config->hpd_gpio, "HDMI_HPD");

		if (ret) {

			dev_err(dev->dev, "'%s'(%d) gpio_request failed: %d\n",

				"HDMI_HPD", config->hpd_gpio, ret);

			goto error3;

		}

		if (config->pmic_gpio != -1) {

			ret = gpio_request(config->pmic_gpio, "PMIC_HDMI_MUX_SEL");

		gpio_direction_input(config->hpd_gpio);

		gpio_set_value_cansleep(config->hpd_gpio, 1);



		if (config->mux_en_gpio != -1) {

			ret = gpio_request(config->mux_en_gpio, "HDMI_MUX_EN");

			if (ret) {

				dev_err(dev->dev, "'%s'(%d) gpio_request failed: %d\n",

					"PMIC_HDMI_MUX_SEL", config->pmic_gpio, ret);

					"HDMI_MUX_SEL", config->mux_en_gpio, ret);

				goto error4;

			}

			gpio_set_value_cansleep(config->pmic_gpio, 0);

			gpio_set_value_cansleep(config->mux_en_gpio, 1);

		}



		if (config->mux_sel_gpio != -1) {

			ret = gpio_request(config->mux_sel_gpio, "HDMI_MUX_SEL");

			if (ret) {

				dev_err(dev->dev, "'%s'(%d) gpio_request failed: %d\n",

					"HDMI_MUX_SEL", config->mux_sel_gpio, ret);

				goto error5;

			}

			gpio_set_value_cansleep(config->mux_sel_gpio, 0);

		}

		DBG("gpio on");

	} else {
@@ -67,15 +84,23 @@ static int gpio_config(struct hdmi *hdmi, bool on) 
		gpio_free(config->ddc_data_gpio);

		gpio_free(config->hpd_gpio);



		if (config->pmic_gpio != -1) {

			gpio_set_value_cansleep(config->pmic_gpio, 1);

			gpio_free(config->pmic_gpio);

		if (config->mux_en_gpio != -1) {

			gpio_set_value_cansleep(config->mux_en_gpio, 0);

			gpio_free(config->mux_en_gpio);

		}



		if (config->mux_sel_gpio != -1) {

			gpio_set_value_cansleep(config->mux_sel_gpio, 1);

			gpio_free(config->mux_sel_gpio);

		}

		DBG("gpio off");

	}



	return 0;



error5:

	if (config->mux_en_gpio != -1)

		gpio_free(config->mux_en_gpio);

error4:

	gpio_free(config->hpd_gpio);

error3:
@@ -89,10 +114,11 @@ error1: 
static int hpd_enable(struct hdmi_connector *hdmi_connector)

{

	struct hdmi *hdmi = hdmi_connector->hdmi;

	const struct hdmi_platform_config *config = hdmi->config;

	struct drm_device *dev = hdmi_connector->base.dev;

	struct hdmi_phy *phy = hdmi->phy;

	uint32_t hpd_ctrl;

	int ret;

	int i, ret;



	ret = gpio_config(hdmi, true);

	if (ret) {
@@ -100,31 +126,22 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector) 
		goto fail;

	}



	ret = clk_prepare_enable(hdmi->clk);

	for (i = 0; i < config->hpd_clk_cnt; i++) {

		ret = clk_prepare_enable(hdmi->hpd_clks[i]);

		if (ret) {

		dev_err(dev->dev, "failed to enable 'clk': %d\n", ret);

			dev_err(dev->dev, "failed to enable hpd clk: %s (%d)\n",

					config->hpd_clk_names[i], ret);

			goto fail;

		}



	ret = clk_prepare_enable(hdmi->m_pclk);

	if (ret) {

		dev_err(dev->dev, "failed to enable 'm_pclk': %d\n", ret);

		goto fail;

	}



	ret = clk_prepare_enable(hdmi->s_pclk);

	for (i = 0; i < config->hpd_reg_cnt; i++) {

		ret = regulator_enable(hdmi->hpd_regs[i]);

		if (ret) {

		dev_err(dev->dev, "failed to enable 's_pclk': %d\n", ret);

			dev_err(dev->dev, "failed to enable hpd regulator: %s (%d)\n",

					config->hpd_reg_names[i], ret);

			goto fail;

		}



	if (hdmi->mpp0)

		ret = regulator_enable(hdmi->mpp0);

	if (!ret)

		ret = regulator_enable(hdmi->mvs);

	if (ret) {

		dev_err(dev->dev, "failed to enable regulators: %d\n", ret);

		goto fail;

	}



	hdmi_set_mode(hdmi, false);
@@ -157,26 +174,26 @@ fail: 
static int hdp_disable(struct hdmi_connector *hdmi_connector)

{

	struct hdmi *hdmi = hdmi_connector->hdmi;

	const struct hdmi_platform_config *config = hdmi->config;

	struct drm_device *dev = hdmi_connector->base.dev;

	int ret = 0;

	int i, ret = 0;



	/* Disable HPD interrupt */

	hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL, 0);



	hdmi_set_mode(hdmi, false);



	if (hdmi->mpp0)

		ret = regulator_disable(hdmi->mpp0);

	if (!ret)

		ret = regulator_disable(hdmi->mvs);

	for (i = 0; i < config->hpd_reg_cnt; i++) {

		ret = regulator_disable(hdmi->hpd_regs[i]);

		if (ret) {

		dev_err(dev->dev, "failed to enable regulators: %d\n", ret);

			dev_err(dev->dev, "failed to disable hpd regulator: %s (%d)\n",

					config->hpd_reg_names[i], ret);

			goto fail;

		}

	}



	clk_disable_unprepare(hdmi->clk);

	clk_disable_unprepare(hdmi->m_pclk);

	clk_disable_unprepare(hdmi->s_pclk);

	for (i = 0; i < config->hpd_clk_cnt; i++)

		clk_disable_unprepare(hdmi->hpd_clks[i]);



	ret = gpio_config(hdmi, false);

	if (ret) {
@@ -190,9 +207,19 @@ fail: 
	return ret;

}



static void

hotplug_work(struct work_struct *work)

{

	struct hdmi_connector *hdmi_connector =

		container_of(work, struct hdmi_connector, hpd_work);

	struct drm_connector *connector = &hdmi_connector->base;

	drm_helper_hpd_irq_event(connector->dev);

}



void hdmi_connector_irq(struct drm_connector *connector)

{

	struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);

	struct msm_drm_private *priv = connector->dev->dev_private;

	struct hdmi *hdmi = hdmi_connector->hdmi;

	uint32_t hpd_int_status, hpd_int_ctrl;
@@ -210,13 +237,13 @@ void hdmi_connector_irq(struct drm_connector *connector) 
		hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL,

				hpd_int_ctrl | HDMI_HPD_INT_CTRL_INT_ACK);



		drm_helper_hpd_irq_event(connector->dev);



		/* detect disconnect if we are connected or visa versa: */

		hpd_int_ctrl = HDMI_HPD_INT_CTRL_INT_EN;

		if (!detected)

			hpd_int_ctrl |= HDMI_HPD_INT_CTRL_INT_CONNECT;

		hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL, hpd_int_ctrl);



		queue_work(priv->wq, &hdmi_connector->hpd_work);

	}

}
@@ -225,6 +252,7 @@ static enum drm_connector_status hdmi_connector_detect( 
{

	struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);

	struct hdmi *hdmi = hdmi_connector->hdmi;

	const struct hdmi_platform_config *config = hdmi->config;

	uint32_t hpd_int_status;

	int retry = 20;
@@ -234,6 +262,14 @@ static enum drm_connector_status hdmi_connector_detect( 
	 * let that trick us into thinking the monitor is gone:

	 */

	while (retry-- && !(hpd_int_status & HDMI_HPD_INT_STATUS_CABLE_DETECTED)) {

		/* hdmi debounce logic seems to get stuck sometimes,

		 * read directly the gpio to get a second opinion:

		 */

		if (gpio_get_value(config->hpd_gpio)) {

			DBG("gpio tells us we are connected!");

			hpd_int_status |= HDMI_HPD_INT_STATUS_CABLE_DETECTED;

			break;

		}

		mdelay(10);

		hpd_int_status = hdmi_read(hdmi, REG_HDMI_HPD_INT_STATUS);

		DBG("status=%08x", hpd_int_status);
@@ -286,6 +322,8 @@ static int hdmi_connector_mode_valid(struct drm_connector *connector, 
				 struct drm_display_mode *mode)

{

	struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);

	struct hdmi *hdmi = hdmi_connector->hdmi;

	const struct hdmi_platform_config *config = hdmi->config;

	struct msm_drm_private *priv = connector->dev->dev_private;

	struct msm_kms *kms = priv->kms;

	long actual, requested;
@@ -294,6 +332,13 @@ static int hdmi_connector_mode_valid(struct drm_connector *connector, 
	actual = kms->funcs->round_pixclk(kms,

			requested, hdmi_connector->hdmi->encoder);



	/* for mdp5/apq8074, we manage our own pixel clk (as opposed to

	 * mdp4/dtv stuff where pixel clk is assigned to mdp/encoder

	 * instead):

	 */

	if (config->pwr_clk_cnt > 0)

		actual = clk_round_rate(hdmi->pwr_clks[0], actual);



	DBG("requested=%ld, actual=%ld", requested, actual);



	if (actual != requested)
@@ -336,6 +381,7 @@ struct drm_connector *hdmi_connector_init(struct hdmi *hdmi) 
	}



	hdmi_connector->hdmi = hdmi_reference(hdmi);

	INIT_WORK(&hdmi_connector->hpd_work, hotplug_work);



	connector = &hdmi_connector->base;

CRA Git | Maintained and supported by SUSTech CRA and CCSE