From 77f170a2507f4d40f73c2b41c863fccb988da247 Mon Sep 17 00:00:00 2001
From: Venkat Reddy Talla <vreddytalla@nvidia.com>
Date: Thu, 14 Jun 2018 15:21:44 +0530
Subject: tegra: dc: use pinctrl fw to configure io pad dpd

Using pincontrol framework to configure io pad dpd mode
for display io pads.In k4.14 programming io pad dpd
mode(enable/disable) using padcontrol framework deprecated,
so moving display io pad dpd mode programming to pin control
framework.

Bug 200414242
Bug 200416228

Change-Id: Iffe84f3c19f3b8bbdfe546c3a891a163035dee92
Signed-off-by: Venkat Reddy Talla <vreddytalla@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/1749804
Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>
---
 drivers/video/tegra/dc/dsi.c | 51 +++++++++++------------
 drivers/video/tegra/dc/dsi.h |  3 +-
 drivers/video/tegra/dc/sor.c | 96 ++++++++++++++++++++++++++++++--------------
 drivers/video/tegra/dc/sor.h |  4 +-
 4 files changed, 96 insertions(+), 58 deletions(-)

diff --git a/drivers/video/tegra/dc/dsi.c b/drivers/video/tegra/dc/dsi.c
index 7019d0cf7..7d2a68279 100644
--- a/drivers/video/tegra/dc/dsi.c
+++ b/drivers/video/tegra/dc/dsi.c
@@ -39,7 +39,6 @@
 #include <linux/nvhost.h>
 #include <linux/of_address.h>
 #include <linux/io.h>
-#include <linux/padctrl/padctrl.h>
 #include <linux/tegra_prod.h>
 
 #include "dc.h"
@@ -4472,14 +4471,13 @@ static int _tegra_dc_dsi_init(struct tegra_dc *dc)
 	struct clk *dsi_fixed_clk = NULL;
 	struct clk *dsi_lp_clk = NULL;
 	struct reset_control *dsi_reset = NULL;
-	struct padctrl *dsi_io_padctrl = NULL;
-
 	struct tegra_dsi_out *dsi_pdata = NULL;
 	int err = 0, i;
 	int dsi_instance;
 	int index = 0;
 
-	char *dsi_io_padctrl_name[4] = {"dsia", "dsib", "dsic", "dsid"};
+	char *dsi_pad_dpd_on[4] = {"dsi-dpd-enable", "dsib-dpd-enable",
+			"dsic-dpd-enable", "dsid-dpd-enable"};
 	char *dsi_clk_name[4] = {"dsi", "dsib", "dsic", "dsid"};
 	char *dsi_lp_clk_name[4] = {"dsia_lp", "dsib_lp", "dsic_lp", "dsid_lp"};
 	char *dsi_reset_name[4] = {"dsia", "dsib", "dsic", "dsid"};
@@ -4538,14 +4536,6 @@ static int _tegra_dc_dsi_init(struct tegra_dc *dc)
 		goto err_free_dsi_lp_clk;
 	}
 
-	dsi->dsi_io_padctrl = kzalloc(tegra_dc_get_max_dsi_instance() *
-				      sizeof(struct tegra_dsi_padctrl *),
-				      GFP_KERNEL);
-	if (!dsi->dsi_io_padctrl) {
-		err = -ENOMEM;
-		goto err_free_dsi_reset;
-	}
-
 	/* Detect when user provides wrong dsi_instance or
 	 * max dsi instances.
 	 */
@@ -4556,6 +4546,13 @@ static int _tegra_dc_dsi_init(struct tegra_dc *dc)
 		goto err_free_dsi_reset;
 	}
 
+	dsi->dsi_io_pad_pinctrl = devm_pinctrl_get(&dc->ndev->dev);
+	if (IS_ERR_OR_NULL(dsi->dsi_io_pad_pinctrl)) {
+		dev_err(&dc->ndev->dev, "dsi: missing io pinctrl info:%ld\n",
+			PTR_ERR(dsi->dsi_io_pad_pinctrl));
+		dsi->dsi_io_pad_pinctrl = NULL;
+	}
+
 	for (i = 0; i < dsi->max_instances; i++) {
 
 		index = i + dsi_instance; /*index for dsi instance*/
@@ -4564,13 +4561,13 @@ static int _tegra_dc_dsi_init(struct tegra_dc *dc)
 		if (!base) {
 			dev_err(&dc->ndev->dev, "dsi: ioremap failed\n");
 			err = -ENOENT;
-			goto err_free_dsi_io_padctrl;
+			goto err_free_dsi_reset;
 		}
 
 		dsi_pdata = dc->pdata->default_out->dsi;
 		if (!dsi_pdata) {
 			dev_err(&dc->ndev->dev, "dsi: dsi data not available\n");
-			goto err_free_dsi_io_padctrl;
+			goto err_free_dsi_reset;
 		}
 
 		dsi_clk = tegra_disp_of_clk_get_by_name(np_dsi,
@@ -4596,19 +4593,20 @@ static int _tegra_dc_dsi_init(struct tegra_dc *dc)
 			reset_control_reset(dsi_reset);
 		}
 
-		dsi_io_padctrl = devm_padctrl_get_from_node(&dc->ndev->dev,
-			np_dsi, dsi_io_padctrl_name[index]);
-		if (IS_ERR_OR_NULL(dsi_io_padctrl)) {
-			dev_err(&dc->ndev->dev, "dsi: %s IO padctrl unavailable\n",
-				dsi_io_padctrl_name[index]);
-			dsi_io_padctrl = NULL;
+		if (dsi->dsi_io_pad_pinctrl) {
+			dsi->dpd_enable[i] = pinctrl_lookup_state(dsi->dsi_io_pad_pinctrl,
+								  dsi_pad_dpd_on[i]);
+			if (IS_ERR_OR_NULL(dsi->dpd_enable[i])) {
+				dev_err(&dc->ndev->dev, "dsi: dpd lookup fail:%ld\n",
+					PTR_ERR(dsi->dpd_enable[i]));
+				dsi->dpd_enable[i] = NULL;
+			}
 		}
 
 		dsi->base[i] = base;
 		dsi->dsi_clk[i] = dsi_clk;
 		dsi->dsi_lp_clk[i] = dsi_lp_clk;
 		dsi->dsi_reset[i] = dsi_reset;
-		dsi->dsi_io_padctrl[i] = dsi_io_padctrl;
 	}
 
 	if (tegra_dc_is_t21x()) {
@@ -4687,8 +4685,13 @@ static int _tegra_dc_dsi_init(struct tegra_dc *dc)
 		int i;
 		for (i = 0; i < tegra_dc_get_max_dsi_instance(); i++) {
 			if ((dsi->info.dpd_dsi_pads & DSI_DPD_EN(i)) &&
-				dsi->dsi_io_padctrl[i])
-				padctrl_power_disable(dsi->dsi_io_padctrl[i]);
+				dsi->dpd_enable[i]) {
+				err = pinctrl_select_state(dsi->dsi_io_pad_pinctrl,
+							   dsi->dpd_enable[i]);
+				if (err < 0)
+					dev_err(&dc->ndev->dev,
+						"io pad power-down fail:%d\n", err);
+			}
 		}
 	}
 
@@ -4718,8 +4721,6 @@ err_dsi_clk_put:
 		if (dsi->dsi_reset[i])
 			reset_control_put(dsi->dsi_reset[i]);
 	}
-err_free_dsi_io_padctrl:
-	kfree(dsi->dsi_io_padctrl);
 err_free_dsi_reset:
 	kfree(dsi->dsi_reset);
 err_free_dsi_lp_clk:
diff --git a/drivers/video/tegra/dc/dsi.h b/drivers/video/tegra/dc/dsi.h
index 330926444..cde06b9b8 100644
--- a/drivers/video/tegra/dc/dsi.h
+++ b/drivers/video/tegra/dc/dsi.h
@@ -146,7 +146,8 @@ struct tegra_dc_dsi_data {
 	u32 device_shutdown;
 
 	struct sysedp_consumer *sysedpc;
-	struct padctrl **dsi_io_padctrl;
+	struct pinctrl *dsi_io_pad_pinctrl;
+	struct pinctrl_state *dpd_enable[4];
 
 	struct tegra_dsi_padctrl *pad_ctrl;
 	struct tegra_prod *prod_list;
diff --git a/drivers/video/tegra/dc/sor.c b/drivers/video/tegra/dc/sor.c
index 4506ac7de..8c61f0722 100644
--- a/drivers/video/tegra/dc/sor.c
+++ b/drivers/video/tegra/dc/sor.c
@@ -27,7 +27,6 @@
 #include <linux/tegra_prod.h>
 #include <linux/uaccess.h>
 #include <linux/version.h>
-#include <linux/padctrl/padctrl.h>
 #include <linux/tegra_pm_domains.h>
 #include <video/tegra_dc_ext.h>
 
@@ -740,7 +739,8 @@ struct tegra_dc_sor_data *tegra_dc_sor_init(struct tegra_dc *dc,
 	u32 temp;
 	int err, i;
 	char res_name[CHAR_BUF_SIZE_MAX] = {0};
-	char io_padctrl_name[CHAR_BUF_SIZE_MAX] = {0};
+	char io_pinctrl_en_name[CHAR_BUF_SIZE_MAX] = {0};
+	char io_pinctrl_dis_name[CHAR_BUF_SIZE_MAX] = {0};
 	struct clk *sor_clk = NULL;
 	struct clk *safe_clk = NULL;
 	struct clk *pad_clk = NULL;
@@ -844,20 +844,45 @@ struct tegra_dc_sor_data *tegra_dc_sor_init(struct tegra_dc *dc,
 		sor->xbar_ctrl[i] = i;
 
 	if (tegra_dc_is_t21x() && (sor->ctrl_num == 1)) { /* todo: fix this */
-		snprintf(io_padctrl_name, CHAR_BUF_SIZE_MAX, "hdmi");
+		snprintf(io_pinctrl_en_name, CHAR_BUF_SIZE_MAX,
+			 "hdmi-dpd-enable");
+		snprintf(io_pinctrl_dis_name, CHAR_BUF_SIZE_MAX,
+			 "hdmi-dpd-disable");
 	} else {
-		snprintf(io_padctrl_name, CHAR_BUF_SIZE_MAX, "hdmi-dp%d",
-			sor->ctrl_num);
+		snprintf(io_pinctrl_en_name, CHAR_BUF_SIZE_MAX,
+			 "hdmi-dp%d-dpd-enable", sor->ctrl_num);
+		snprintf(io_pinctrl_dis_name, CHAR_BUF_SIZE_MAX,
+			 "hdmi-dp%d-dpd-disable", sor->ctrl_num);
+	}
+
+	sor->pinctrl_sor = devm_pinctrl_get(&dc->ndev->dev);
+	if (IS_ERR_OR_NULL(sor->pinctrl_sor)) {
+		dev_err(&dc->ndev->dev, "pinctrl get fail: %ld\n",
+			PTR_ERR(sor->pinctrl_sor));
+		sor->pinctrl_sor = NULL;
+		goto bypass_pads;
 	}
 
-	sor->io_padctrl = devm_padctrl_get_from_node(&dc->ndev->dev,
-					sor_np, io_padctrl_name);
-	if (IS_ERR(sor->io_padctrl)) {
-		dev_err(&dc->ndev->dev, "sor: %s IO padctrl unavailable\n",
-			io_padctrl_name);
-		sor->io_padctrl = NULL;
+	if (sor->pinctrl_sor) {
+		sor->dpd_enable = pinctrl_lookup_state(sor->pinctrl_sor,
+						       io_pinctrl_en_name);
+		if (IS_ERR_OR_NULL(sor->dpd_enable)) {
+			dev_err(&dc->ndev->dev, "dpd enable lookup fail:%ld\n",
+				PTR_ERR(sor->dpd_enable));
+			sor->dpd_enable = NULL;
+			goto bypass_pads;
+		}
+
+		sor->dpd_disable = pinctrl_lookup_state(sor->pinctrl_sor,
+							io_pinctrl_dis_name);
+		if (IS_ERR_OR_NULL(sor->dpd_disable)) {
+			dev_err(&dc->ndev->dev, "dpd disable lookup fail:%ld\n",
+				PTR_ERR(sor->dpd_disable));
+			sor->dpd_disable = NULL;
+		}
 	}
 
+bypass_pads:
 	if (of_property_read_u32_array(sor_np, "nvidia,xbar-ctrl",
 		sor->xbar_ctrl, sizeof(sor->xbar_ctrl)/sizeof(u32)))
 		dev_err(&dc->ndev->dev, "%s: error reading nvidia,xbar-ctrl\n",
@@ -961,6 +986,10 @@ void tegra_dc_sor_destroy(struct tegra_dc_sor_data *sor)
 
 	iounmap(sor->base);
 
+	devm_pinctrl_put(sor->pinctrl_sor);
+	sor->dpd_enable = NULL;
+	sor->dpd_disable = NULL;
+
 	if (tegra_dc_is_nvdisplay())
 		devm_kfree(dev, sor->win_state_arr);
 	devm_kfree(dev, sor);
@@ -1153,21 +1182,26 @@ static inline void tegra_dc_sor_update(struct tegra_dc_sor_data *sor)
 
 static void tegra_dc_sor_io_set_dpd(struct tegra_dc_sor_data *sor, bool up)
 {
+	int ret = 0;
+
 	if (tegra_platform_is_vdk())
 		return;
 
-	if (sor->io_padctrl) {
-		int ret;
+	if (!sor->pinctrl_sor)
+		return;
 
-		if (up)
-			ret = padctrl_power_enable(sor->io_padctrl);
-		else
-			ret = padctrl_power_disable(sor->io_padctrl);
-		if (ret < 0)
-			dev_err(&sor->dc->ndev->dev,
-				 "padctrl power %s fail %d\n",
-				 up ? "up" : "down", ret);
+	if (up) {
+		if (sor->dpd_disable)
+			ret = pinctrl_select_state(sor->pinctrl_sor,
+						   sor->dpd_disable);
+	} else {
+		if (sor->dpd_enable)
+			ret = pinctrl_select_state(sor->pinctrl_sor,
+						   sor->dpd_enable);
 	}
+	if (ret < 0)
+		dev_err(&sor->dc->ndev->dev, "io pad power %s fail:%d\n",
+			up ? "disable" : "enable", ret);
 }
 
 /* hdmi uses sor sequencer for pad power up */
@@ -1176,6 +1210,7 @@ void tegra_sor_hdmi_pad_power_up(struct tegra_dc_sor_data *sor)
 	u32 nv_sor_pll0_reg = nv_sor_pll0();
 	u32 nv_sor_pll1_reg = nv_sor_pll1();
 	u32 nv_sor_pll2_reg = nv_sor_pll2();
+	int ret = 0;
 
 	/* seamless */
 	if (sor->dc->initialized)
@@ -1212,12 +1247,11 @@ void tegra_sor_hdmi_pad_power_up(struct tegra_dc_sor_data *sor)
 	tegra_sor_pad_cal_power(sor, false);
 	usleep_range(20, 70);
 
-	if (sor->io_padctrl) {
-		int ret = padctrl_power_enable(sor->io_padctrl);
-
+	if (sor->dpd_disable) {
+		ret = pinctrl_select_state(sor->pinctrl_sor, sor->dpd_disable);
 		if (ret < 0)
-			dev_err(&sor->dc->ndev->dev, "padctrl power up fail %d\n",
-				 ret);
+			dev_err(&sor->dc->ndev->dev,
+				"io pad power-up fail:%d\n", ret);
 	}
 	usleep_range(20, 70);
 
@@ -1253,6 +1287,7 @@ void tegra_sor_hdmi_pad_power_down(struct tegra_dc_sor_data *sor)
 {
 	u32 nv_sor_pll0_reg = nv_sor_pll0();
 	u32 nv_sor_pll2_reg = nv_sor_pll2();
+	int ret = 0;
 
 	tegra_sor_write_field(sor, nv_sor_pll2_reg,
 				NV_SOR_PLL2_AUX7_PORT_POWERDOWN_MASK,
@@ -1273,12 +1308,11 @@ void tegra_sor_hdmi_pad_power_down(struct tegra_dc_sor_data *sor)
 				NV_SOR_PLL2_AUX6_BANDGAP_POWERDOWN_ENABLE);
 	tegra_sor_pad_cal_power(sor, false);
 
-	if (sor->io_padctrl) {
-		int ret = padctrl_power_disable(sor->io_padctrl);
-
+	if (sor->dpd_enable) {
+		ret = pinctrl_select_state(sor->pinctrl_sor, sor->dpd_enable);
 		if (ret < 0)
-			dev_err(&sor->dc->ndev->dev, "padctrl power down fail %d\n",
-				ret);
+			dev_err(&sor->dc->ndev->dev,
+				"io pad power-down fail:%d\n", ret);
 	}
 	usleep_range(20, 70);
 }
diff --git a/drivers/video/tegra/dc/sor.h b/drivers/video/tegra/dc/sor.h
index 9a9363ebd..3b84307b9 100644
--- a/drivers/video/tegra/dc/sor.h
+++ b/drivers/video/tegra/dc/sor.h
@@ -202,7 +202,9 @@ struct tegra_dc_sor_data {
 	u8	clk_type;
 	u32  xbar_ctrl[5];
 	bool audio_support;
-	struct padctrl *io_padctrl;
+	struct pinctrl *pinctrl_sor;
+	struct pinctrl_state *dpd_enable;
+	struct pinctrl_state *dpd_disable;
 	int powergate_id;
 	struct rw_semaphore reset_lock;
 	struct dentry	*debugdir;
-- 
cgit v1.2.2