Skip to contentSkip to conversation

Internal voltage control for qcom SDHC

PATCH Superseded Veerabhadrarao Badiganti 6 participants 39 messages May 15, 2020 – Jul 6, 2020

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

cover Internal voltage control for qcom SDHC

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

So added support to register voltage regulators from the msm driver and use them.

This patchset was posted long back but not actively pursued
https://lore.kernel.org/linux-arm-msm/[email protected]/
So posting it as fresh patchset.

Veerabhadrarao Badiganti (1):
dt-bindings: mmc: Supply max load for mmc supplies

Vijay Viswanath (2):
mmc: sdhci-msm: Use internal voltage control
mmc: sdhci: Allow platform controlled voltage switching

 .../devicetree/bindings/mmc/mmc-controller.yaml    |  16 ++
 drivers/mmc/host/sdhci-msm.c                       | 215 ++++++++++++++++++++-
 drivers/mmc/host/sdhci.c                           |  32 +--
 drivers/mmc/host/sdhci.h                           |   1 +
 4 files changed, 243 insertions(+), 21 deletions(-)
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#1 lore raw

PATCH 1/3 dt-bindings: mmc: Supply max load for mmc supplies

Supply the max load needed for driving the mmc supplies.

---
 .../devicetree/bindings/mmc/mmc-controller.yaml          | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
Documentation/devicetree/bindings/mmc/mmc-controller.yaml +16 -0
index acc9f10..9058b82 100644
@@ -290,6 +290,22 @@ properties:
     description:
       Supply for the bus IO line power
 
+  vmmc-max-load-microamp:
+    allOf:
+      - $ref: /schemas/types.yaml#/definitions/uint32
+      - minimum: 0
+      - maximum: 1000000
+    description:
+      Maximum load for the card power.
+
+  vqmmc-max-load-microamp:
+    allOf:
+      - $ref: /schemas/types.yaml#/definitions/uint32
+      - minimum: 0
+      - maximum: 1000000
+    description:
+      Maximum load for the bus IO line power.
+
   mmc-pwrseq:
     $ref: /schemas/types.yaml#/definitions/phandle
     description:
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#2 lore raw

PATCH 2/3 mmc: sdhci-msm: Use internal voltage control

In reply to Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

Set the regulator load as well so that regulator can be configured in LPM mode when in is not being used.

---
 drivers/mmc/host/sdhci-msm.c | 215 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 207 insertions(+), 8 deletions(-)
drivers/mmc/host/sdhci-msm.c +207 -8
index 97758fa..a10e955 100644
@@ -36,7 +36,9 @@
 #define CORE_PWRCTL_IO_LOW	BIT(2)
 #define CORE_PWRCTL_IO_HIGH	BIT(3)
 #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
 #define CORE_PWRCTL_IO_SUCCESS	BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
 #define REQ_BUS_OFF		BIT(0)
 #define REQ_BUS_ON		BIT(1)
 #define REQ_IO_LOW		BIT(2)
@@ -263,6 +265,9 @@ struct sdhci_msm_host {
 	bool use_cdr;
 	u32 transfer_mode;
 	bool updated_ddr_cfg;
+	u32 vmmc_load;
+	u32 vqmmc_load;
+	bool vqmmc_enabled;
 };
 
 static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1298,6 +1303,78 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
 		sdhci_msm_hs400(host, &mmc->ios);
 }
 
+static int sdhci_msm_set_vmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, int level)
+{
+	int load, ret;
+
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	if (msm_host->vmmc_load) {
+		load = level ? msm_host->vmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vmmc, load);
+		if (ret)
+			goto out;
+	}
+
+	ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+out:
+	if (ret)
+		pr_err("%s: vmmc set load/ocr failed: %d\n",
+				mmc_hostname(mmc), ret);
+
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, int level)
+{
+	int load, ret;
+	struct mmc_ios ios;
+
+	if (IS_ERR(mmc->supply.vqmmc)			 ||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED) ||
+	    (msm_host->vqmmc_enabled == level))
+		return 0;
+
+	if (msm_host->vqmmc_load) {
+		load = level ? msm_host->vqmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vqmmc, load);
+		if (ret)
+			goto out;
+	}
+
+	/*
+	 * The IO voltage regulator may not always support a voltage close to
+	 * vdd. Set IO voltage based on capability of the regulator.
+	 */
+	if (level) {
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			pr_debug("%s: %s: setting signal voltage: %d\n",
+					mmc_hostname(mmc), __func__,
+					ios.signal_voltage);
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0)
+				goto out;
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}
+out:
+	if (ret)
+		pr_err("%s: vqmmc failed: %d\n", mmc_hostname(mmc), ret);
+	else
+		msm_host->vqmmc_enabled = level;
+
+	return ret;
+}
+
 static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
 {
 	init_waitqueue_head(&msm_host->pwr_irq_wait);
@@ -1401,8 +1478,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 {
 	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 	struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+	struct mmc_host *mmc = host->mmc;
 	u32 irq_status, irq_ack = 0;
-	int retry = 10;
+	int retry = 10, ret = 0;
 	u32 pwr_state = 0, io_level = 0;
 	u32 config;
 	const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1438,14 +1516,35 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 
 	/* Handle BUS ON/OFF*/
 	if (irq_status & CORE_PWRCTL_BUS_ON) {
-		pwr_state = REQ_BUS_ON;
-		io_level = REQ_IO_HIGH;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		ret = sdhci_msm_set_vmmc(msm_host, mmc, 1);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc, 1);
+
+		if (!ret) {
+			pwr_state = REQ_BUS_ON;
+			io_level = REQ_IO_HIGH;
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		} else {
+			pr_err("%s: BUS_ON req failed(%d). irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret, irq_status);
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+			sdhci_msm_set_vmmc(msm_host, mmc, 0);
+		}
 	}
 	if (irq_status & CORE_PWRCTL_BUS_OFF) {
-		pwr_state = REQ_BUS_OFF;
-		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		ret = sdhci_msm_set_vmmc(msm_host, mmc, 0);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc, 0);
+
+		if (!ret) {
+			pwr_state = REQ_BUS_OFF;
+			io_level = REQ_IO_LOW;
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		} else {
+			pr_err("%s: BUS_ON req failed(%d). irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret, irq_status);
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+		}
 	}
 	/* Handle IO LOW/HIGH */
 	if (irq_status & CORE_PWRCTL_IO_LOW) {
@@ -1457,6 +1556,15 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
 	}
 
+	if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+		ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);
+		if (ret < 0)
+			pr_err("%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret,
+					mmc->ios.signal_voltage, mmc->ios.vdd,
+					irq_status);
+	}
+
 	/*
 	 * The driver has to acknowledge the interrupt, switch voltages and
 	 * report back if it succeded or not to this register. The voltage
@@ -1833,6 +1941,91 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
 	sdhci_reset(host, mask);
 }
 
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
+{
+	int ret = 0;
+	struct mmc_host *mmc = msm_host->mmc;
+
+	ret = mmc_regulator_get_supply(msm_host->mmc);
+	if (ret)
+		return ret;
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vmmc-max-load-microamp",
+			&msm_host->vmmc_load);
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vqmmc-max-load-microamp",
+			&msm_host->vqmmc_load);
+
+	sdhci_msm_set_regulator_caps(msm_host);
+	mmc->ios.power_mode = MMC_POWER_UNDEFINED;
+
+	return 0;
+
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
+			return -EINVAL;
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+		/* 3.3V regulator output should be stable within 5 ms */
+		ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+		if (!(ctrl & SDHCI_CTRL_VDD_180))
+			return 0;
+
+		pr_warn("%s: 3.3V regulator output did not became stable\n",
+			mmc_hostname(mmc));
+
+		return -EAGAIN;
+	case MMC_SIGNAL_VOLTAGE_180:
+		if (!(host->flags & SDHCI_SIGNALING_180))
+			return -EINVAL;
+
+		/*
+		 * Enable 1.8V Signal Enable in the Host Control2
+		 * register
+		 */
+		ctrl |= SDHCI_CTRL_VDD_180;
+		sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+		/* 1.8V regulator output should be stable within 5 ms */
+		ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+		if (ctrl & SDHCI_CTRL_VDD_180)
+			return 0;
+
+		pr_warn("%s: 1.8V regulator output did not became stable\n",
+			mmc_hostname(mmc));
+
+		return -EAGAIN;
+	case MMC_SIGNAL_VOLTAGE_120:
+		if (!(host->flags & SDHCI_SIGNALING_120))
+			return -EINVAL;
+		return 0;
+	default:
+		/* No signal voltage switch required */
+		return 0;
+	}
+
+}
+
 static const struct sdhci_msm_variant_ops mci_var_ops = {
 	.msm_readl_relaxed = sdhci_msm_mci_variant_readl_relaxed,
 	.msm_writel_relaxed = sdhci_msm_mci_variant_writel_relaxed,
@@ -1880,6 +2073,7 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
 	.write_w = sdhci_msm_writew,
 	.write_b = sdhci_msm_writeb,
 	.irq	= sdhci_msm_cqe_irq,
+	.set_power = sdhci_set_power_noreg,
 };
 
 static const struct sdhci_pltfm_data sdhci_msm_pdata = {
@@ -2072,6 +2266,10 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 	if (core_major == 1 && core_minor >= 0x49)
 		msm_host->updated_ddr_cfg = true;
 
+	ret = sdhci_msm_register_vreg(msm_host);
+	if (ret)
+		goto clk_disable;
+
 	/*
 	 * Power on reset state may trigger power irq if previous status of
 	 * PWRCTL was either BUS_ON or IO_HIGH_V. So before enabling pwr irq
@@ -2116,6 +2314,8 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 					 MSM_MMC_AUTOSUSPEND_DELAY_MS);
 	pm_runtime_use_autosuspend(&pdev->dev);
 
+	host->mmc_host_ops.start_signal_voltage_switch =
+		sdhci_msm_start_signal_voltage_switch;
 	host->mmc_host_ops.execute_tuning = sdhci_msm_execute_tuning;
 	if (of_property_read_bool(node, "supports-cqe"))
 		ret = sdhci_msm_cqe_add_host(host, pdev);
@@ -2123,7 +2323,6 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 		ret = sdhci_add_host(host);
 	if (ret)
 		goto pm_runtime_disable;
-	sdhci_msm_set_regulator_caps(msm_host);
 
 	pm_runtime_mark_last_busy(&pdev->dev);
 	pm_runtime_put_autosuspend(&pdev->dev);
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#7 lore raw

PATCH 3/3 mmc: sdhci: Allow platform controlled voltage switching

In reply to Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

If vendor platform drivers are controlling whole logic of voltage switching, then sdhci driver no need control vqmmc regulator. So skip enabling/disable vqmmc from SDHC driver.

---
 drivers/mmc/host/sdhci.c | 32 +++++++++++++++++++-------------
 drivers/mmc/host/sdhci.h |  1 +
 2 files changed, 20 insertions(+), 13 deletions(-)
drivers/mmc/host/sdhci.c +19 -13
index 1bb6b67..c010823 100644
@@ -4098,6 +4098,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	unsigned int override_timeout_clk;
 	u32 max_clk;
 	int ret;
+	bool enable_vqmmc = false;
 
 	WARN_ON(host == NULL);
 	if (host == NULL)
@@ -4111,9 +4112,12 @@ int sdhci_setup_host(struct sdhci_host *host)
 	 * the host can take the appropriate action if regulators are not
 	 * available.
 	 */
-	ret = mmc_regulator_get_supply(mmc);
-	if (ret)
-		return ret;
+	if (!mmc->supply.vqmmc) {
+		ret = mmc_regulator_get_supply(mmc);
+		if (ret)
+			return ret;
+		enable_vqmmc  = true;
+	}
 
 	DBG("Version:   0x%08x | Present:  0x%08x\n",
 	    sdhci_readw(host, SDHCI_HOST_VERSION),
@@ -4373,7 +4377,15 @@ int sdhci_setup_host(struct sdhci_host *host)
 		mmc->caps |= MMC_CAP_NEEDS_POLL;
 
 	if (!IS_ERR(mmc->supply.vqmmc)) {
-		ret = regulator_enable(mmc->supply.vqmmc);
+		if (enable_vqmmc) {
+			ret = regulator_enable(mmc->supply.vqmmc);
+			if (ret) {
+				pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
+					mmc_hostname(mmc), ret);
+				mmc->supply.vqmmc = ERR_PTR(-EINVAL);
+			}
+			host->vqmmc_enabled = !ret;
+		}
 
 		/* If vqmmc provides no 1.8V signalling, then there's no UHS */
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000,
@@ -4386,12 +4398,6 @@ int sdhci_setup_host(struct sdhci_host *host)
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000,
 						    3600000))
 			host->flags &= ~SDHCI_SIGNALING_330;
-
-		if (ret) {
-			pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
-				mmc_hostname(mmc), ret);
-			mmc->supply.vqmmc = ERR_PTR(-EINVAL);
-		}
 	}
 
 	if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) {
@@ -4625,7 +4631,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	return 0;
 
 unreg:
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->vqmmc_enabled)
 		regulator_disable(mmc->supply.vqmmc);
 undma:
 	if (host->align_buffer)
@@ -4643,7 +4649,7 @@ void sdhci_cleanup_host(struct sdhci_host *host)
 {
 	struct mmc_host *mmc = host->mmc;
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->vqmmc_enabled)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
@@ -4780,7 +4786,7 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 
 	destroy_workqueue(host->complete_wq);
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->vqmmc_enabled)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
drivers/mmc/host/sdhci.h +1 -0
index 8d2a096..24d27e1 100644
@@ -570,6 +570,7 @@ struct sdhci_host {
 	u32 caps1;		/* CAPABILITY_1 */
 	bool read_caps;		/* Capability flags have been read */
 
+	bool vqmmc_enabled;	/* Vqmmc is enabled */
 	unsigned int            ocr_avail_sdio;	/* OCR bit masks */
 	unsigned int            ocr_avail_sd;
 	unsigned int            ocr_avail_mmc;
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#3 lore raw

Re: [PATCH V1 2/3] mmc: sdhci-msm: Use internal voltage control

In reply to Veerabhadrarao Badiganti
Quoted 9 lines · Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

Quoted 6 lines

Set the regulator load as well so that regulator can be configured in LPM mode when in is not being used.

Please note that per Documentation/process/submitting-patches.rst section 11) this states:

1) You wrote the patch (From:) without stating that its Certificate of origin.

2) Then Asutosh took your patch (in full or part) and guarantees that he's allowed to contribute it to the project.

3) Then you took his patch (in full or part) and guarantee that you're allowed to contribute it to the project.

4) Then Veerabhadrarao took your patch (in full or part) and guarantees that he's allowed to contribute it to the project

5) Then somehow it came out of your inbox - even if Veerabhadrarao was the one who handled it last.

As author you should be the first one to certify, and as poster to LKML you should be the last one.

If you worked together on this, then list Asutosh and Veerabhadrarao as Co-developed-by.

Quoted 33 lines
---
 drivers/mmc/host/sdhci-msm.c | 215 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 207 insertions(+), 8 deletions(-)
drivers/mmc/host/sdhci-msm.c +6 -0
index 97758fa..a10e955 100644
@@ -36,7 +36,9 @@
 #define CORE_PWRCTL_IO_LOW	BIT(2)
 #define CORE_PWRCTL_IO_HIGH	BIT(3)
 #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
 #define CORE_PWRCTL_IO_SUCCESS	BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
 #define REQ_BUS_OFF		BIT(0)
 #define REQ_BUS_ON		BIT(1)
 #define REQ_IO_LOW		BIT(2)
@@ -263,6 +265,9 @@ struct sdhci_msm_host {
 	bool use_cdr;
 	u32 transfer_mode;
 	bool updated_ddr_cfg;
+	u32 vmmc_load;
+	u32 vqmmc_load;
+	bool vqmmc_enabled;
 };
 
 static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1298,6 +1303,78 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
 		sdhci_msm_hs400(host, &mmc->ios);
 }
 
+static int sdhci_msm_set_vmmc(struct sdhci_msm_host *msm_host,

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1316

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+			      struct mmc_host *mmc, int level)
+{
+	int load, ret;
+
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	if (msm_host->vmmc_load) {
+		load = level ? msm_host->vmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vmmc, load);

I started on the comment about regulator_set_load() that you can find below...

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1321

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +5 -0
+		if (ret)
+			goto out;
+	}
+
+	ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);

...but I don't see that mmc->ios.vdd necessarily is in sync with "level". Or do you here simply set the load based on what the hardware tell you and then orthogonally to that let the core enable/disable the regulator?

Perhaps I'm just missing something obvious, but if not I believe this warrants a comment describing that you're lowering the power level regardless of the actual power being disabled.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1325

Quoted 4 lines
drivers/mmc/host/sdhci-msm.c +4 -0
+out:
+	if (ret)
+		pr_err("%s: vmmc set load/ocr failed: %d\n",
+				mmc_hostname(mmc), ret);

Please use:

	dev_err(mmc_dev(mmc), ...);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1331

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, int level)

vqmmc_enabled is a bool and "level" sounds like an int with several possible values. So please make level bool here as well, to make it easer to read..

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1343

Quoted 12 lines
drivers/mmc/host/sdhci-msm.c +12 -0
+{
+	int load, ret;
+	struct mmc_ios ios;
+
+	if (IS_ERR(mmc->supply.vqmmc)			 ||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED) ||
+	    (msm_host->vqmmc_enabled == level))
+		return 0;
+
+	if (msm_host->vqmmc_load) {
+		load = level ? msm_host->vqmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vqmmc, load);

Since v5.0 the "load" of a regulator consumer is only taken into consideration if the consumer is enabled. So given that you're toggling the regulator below there's no need to change this here.

Just specify the "active load" at probe time.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1351

Quoted 8 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+		if (ret)
+			goto out;
+	}
+
+	/*
+	 * The IO voltage regulator may not always support a voltage close to
+	 * vdd. Set IO voltage based on capability of the regulator.
+	 */

Is this comment related to the if/else-if inside the conditional? If so please move it one line down.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1356

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +5 -0
+	if (level) {
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;

Please add a space here, to indicate that the if statement on the next line is unrelated to the if/elseif above.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1360

Quoted 4 lines
drivers/mmc/host/sdhci-msm.c +4 -0
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			pr_debug("%s: %s: setting signal voltage: %d\n",
+					mmc_hostname(mmc), __func__,
+					ios.signal_voltage);

I strongly believe you should replace these debug prints with tracepoints, throughout the driver.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1368

Quoted 9 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0)
+				goto out;
 
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}

Given that you don't need to regulator_set_load() this function is now just one large if/else condition on a constant passed as an argument. Please split it into sdhci_msm_enable_vqmmc() and sdhci_msm_disable_vqmmc().

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1371

Quoted 3 lines
drivers/mmc/host/sdhci-msm.c +3 -0
+out:
+	if (ret)
+		pr_err("%s: vqmmc failed: %d\n", mmc_hostname(mmc), ret);

I think it would be useful to know if this error came from mmc_regulator_set_vqmmc() or regulator_enable() - or regulator_disable().

So please move this up and add some context in the error message, and please use dev_err().

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+	else
+		msm_host->vqmmc_enabled = level;
+
+	return ret;
+}
+
 static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
 {
drivers/mmc/host/sdhci-msm.c +0 -0
 	init_waitqueue_head(&msm_host->pwr_irq_wait);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1483

Quoted 7 lines
drivers/mmc/host/sdhci-msm.c +2 -1
@@ -1401,8 +1478,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 {
 	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 	struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+	struct mmc_host *mmc = host->mmc;
 	u32 irq_status, irq_ack = 0;
-	int retry = 10;
+	int retry = 10, ret = 0;

There's no need to initialize ret, in all occasions it's assigned before being read.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1521

Quoted 13 lines
drivers/mmc/host/sdhci-msm.c +3 -3
 	u32 pwr_state = 0, io_level = 0;
 	u32 config;
 	const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1438,14 +1516,35 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 
 	/* Handle BUS ON/OFF*/
 	if (irq_status & CORE_PWRCTL_BUS_ON) {
-		pwr_state = REQ_BUS_ON;
-		io_level = REQ_IO_HIGH;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		ret = sdhci_msm_set_vmmc(msm_host, mmc, 1);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc, 1);

I find this quite complex to follow. Wouldn't it be cleaner to retain the 4 checks on irq_status as they are and then before the writel of irq_ack check pwr_state and io_level and call sdhci_msm_set_{vmmc,vqmmc} accordingly?

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1529

Quoted 8 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+
+		if (!ret) {
+			pwr_state = REQ_BUS_ON;
+			io_level = REQ_IO_HIGH;
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		} else {
+			pr_err("%s: BUS_ON req failed(%d). irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret, irq_status);

You already printed that this failed in sdhci_msm_set_{vmmc,vqmmc}, no need to print again.

Quoted 25 lines
drivers/mmc/host/sdhci-msm.c +16 -3
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+			sdhci_msm_set_vmmc(msm_host, mmc, 0);
+		}
 	}
 	if (irq_status & CORE_PWRCTL_BUS_OFF) {
-		pwr_state = REQ_BUS_OFF;
-		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		ret = sdhci_msm_set_vmmc(msm_host, mmc, 0);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc, 0);
+
+		if (!ret) {
+			pwr_state = REQ_BUS_OFF;
+			io_level = REQ_IO_LOW;
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		} else {
+			pr_err("%s: BUS_ON req failed(%d). irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret, irq_status);
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+		}
 	}
 	/* Handle IO LOW/HIGH */
 	if (irq_status & CORE_PWRCTL_IO_LOW) {

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1560

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +2 -0
@@ -1457,6 +1556,15 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
 	}
 
+	if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+		ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);

Didn't you already call this through sdhci_msm_set_vqmmc()?

Quoted 11 lines
drivers/mmc/host/sdhci-msm.c +7 -0
+		if (ret < 0)
+			pr_err("%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret,
+					mmc->ios.signal_voltage, mmc->ios.vdd,
+					irq_status);
+	}
+
 	/*
 	 * The driver has to acknowledge the interrupt, switch voltages and
 	 * report back if it succeded or not to this register. The voltage

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1946

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +3 -0
@@ -1833,6 +1941,91 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
 	sdhci_reset(host, mask);
 }
 
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
+{
+	int ret = 0;

No need to initialize ret, first use is an assignment.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1957

Quoted 11 lines
drivers/mmc/host/sdhci-msm.c +11 -0
+	struct mmc_host *mmc = msm_host->mmc;
+
+	ret = mmc_regulator_get_supply(msm_host->mmc);
+	if (ret)
+		return ret;
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vmmc-max-load-microamp",
+			&msm_host->vmmc_load);
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vqmmc-max-load-microamp",
+			&msm_host->vqmmc_load);

These properties are not documented. Do they vary enough to mandate being read from DT or could they simply be approximated by a define instead?

Quoted 22 lines
drivers/mmc/host/sdhci-msm.c +22 -0
+
+	sdhci_msm_set_regulator_caps(msm_host);
+	mmc->ios.power_mode = MMC_POWER_UNDEFINED;
+
+	return 0;
+
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1989

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
+			return -EINVAL;
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+		/* 3.3V regulator output should be stable within 5 ms */

What mechanism ensures that the readw won't return withing 5ms from the writew above?

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1997

Quoted 8 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+		ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+		if (!(ctrl & SDHCI_CTRL_VDD_180))
+			return 0;
+
+		pr_warn("%s: 3.3V regulator output did not became stable\n",
+			mmc_hostname(mmc));
+
+		return -EAGAIN;

The body of the 330 and 180 cases are quite similar, can you perhaps deal with those after the switch, once?

Quoted 19 lines
drivers/mmc/host/sdhci-msm.c +19 -0
+	case MMC_SIGNAL_VOLTAGE_180:
+		if (!(host->flags & SDHCI_SIGNALING_180))
+			return -EINVAL;
+
+		/*
+		 * Enable 1.8V Signal Enable in the Host Control2
+		 * register
+		 */
+		ctrl |= SDHCI_CTRL_VDD_180;
+		sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+		/* 1.8V regulator output should be stable within 5 ms */
+		ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+		if (ctrl & SDHCI_CTRL_VDD_180)
+			return 0;
+
+		pr_warn("%s: 1.8V regulator output did not became stable\n",
+			mmc_hostname(mmc));
+

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 2026

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+		return -EAGAIN;
+	case MMC_SIGNAL_VOLTAGE_120:
+		if (!(host->flags & SDHCI_SIGNALING_120))
+			return -EINVAL;
+		return 0;
+	default:
+		/* No signal voltage switch required */
+		return 0;
+	}
+

Empty line.

Regards,
Bjorn

Quoted 44 lines
drivers/mmc/host/sdhci-msm.c +9 -1
+}
+
 static const struct sdhci_msm_variant_ops mci_var_ops = {
 	.msm_readl_relaxed = sdhci_msm_mci_variant_readl_relaxed,
 	.msm_writel_relaxed = sdhci_msm_mci_variant_writel_relaxed,
@@ -1880,6 +2073,7 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
 	.write_w = sdhci_msm_writew,
 	.write_b = sdhci_msm_writeb,
 	.irq	= sdhci_msm_cqe_irq,
+	.set_power = sdhci_set_power_noreg,
 };
 
 static const struct sdhci_pltfm_data sdhci_msm_pdata = {
@@ -2072,6 +2266,10 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 	if (core_major == 1 && core_minor >= 0x49)
 		msm_host->updated_ddr_cfg = true;
 
+	ret = sdhci_msm_register_vreg(msm_host);
+	if (ret)
+		goto clk_disable;
+
 	/*
 	 * Power on reset state may trigger power irq if previous status of
 	 * PWRCTL was either BUS_ON or IO_HIGH_V. So before enabling pwr irq
@@ -2116,6 +2314,8 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 					 MSM_MMC_AUTOSUSPEND_DELAY_MS);
 	pm_runtime_use_autosuspend(&pdev->dev);
 
+	host->mmc_host_ops.start_signal_voltage_switch =
+		sdhci_msm_start_signal_voltage_switch;
 	host->mmc_host_ops.execute_tuning = sdhci_msm_execute_tuning;
 	if (of_property_read_bool(node, "supports-cqe"))
 		ret = sdhci_msm_cqe_add_host(host, pdev);
@@ -2123,7 +2323,6 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 		ret = sdhci_add_host(host);
 	if (ret)
 		goto pm_runtime_disable;
-	sdhci_msm_set_regulator_caps(msm_host);
 
 	pm_runtime_mark_last_busy(&pdev->dev);
 	pm_runtime_put_autosuspend(&pdev->dev);
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#4 lore raw

Re: [PATCH V1 2/3] mmc: sdhci-msm: Use internal voltage control

Quoted 2 lines · Bjorn Andersson
Quoted 1 line · Veerabhadrarao Badiganti
drivers/mmc/host/sdhci-msm.c +0 -0

[..]

Quoted 6 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1946

Quoted 3 lines
drivers/mmc/host/sdhci-msm.c +3 -0
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
+{
+	int ret = 0;

No need to initialize ret, first use is an assignment.

Quoted 16 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1957

Quoted 11 lines
drivers/mmc/host/sdhci-msm.c +11 -0
+	struct mmc_host *mmc = msm_host->mmc;
+
+	ret = mmc_regulator_get_supply(msm_host->mmc);
+	if (ret)
+		return ret;
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vmmc-max-load-microamp",
+			&msm_host->vmmc_load);
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vqmmc-max-load-microamp",
+			&msm_host->vqmmc_load);

These properties are not documented. Do they vary enough to mandate being read from DT or could they simply be approximated by a define instead?

Disregard my comment about them not being documented, I wasn't Cc'ed on the binding patch and missed it.

My question about just defining them statically still stands.

Thanks,
Bjorn

maintainer
#8 lore raw

Re: [PATCH V1 3/3] mmc: sdhci: Allow platform controlled voltage switching

In reply to Veerabhadrarao Badiganti
Quoted 103 lines · Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

If vendor platform drivers are controlling whole logic of voltage switching, then sdhci driver no need control vqmmc regulator. So skip enabling/disable vqmmc from SDHC driver.

---
 drivers/mmc/host/sdhci.c | 32 +++++++++++++++++++-------------
 drivers/mmc/host/sdhci.h |  1 +
 2 files changed, 20 insertions(+), 13 deletions(-)
drivers/mmc/host/sdhci.c +19 -13
index 1bb6b67..c010823 100644
@@ -4098,6 +4098,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	unsigned int override_timeout_clk;
 	u32 max_clk;
 	int ret;
+	bool enable_vqmmc = false;
 
 	WARN_ON(host == NULL);
 	if (host == NULL)
@@ -4111,9 +4112,12 @@ int sdhci_setup_host(struct sdhci_host *host)
 	 * the host can take the appropriate action if regulators are not
 	 * available.
 	 */
-	ret = mmc_regulator_get_supply(mmc);
-	if (ret)
-		return ret;
+	if (!mmc->supply.vqmmc) {
+		ret = mmc_regulator_get_supply(mmc);
+		if (ret)
+			return ret;
+		enable_vqmmc  = true;
+	}
 
 	DBG("Version:   0x%08x | Present:  0x%08x\n",
 	    sdhci_readw(host, SDHCI_HOST_VERSION),
@@ -4373,7 +4377,15 @@ int sdhci_setup_host(struct sdhci_host *host)
 		mmc->caps |= MMC_CAP_NEEDS_POLL;
 
 	if (!IS_ERR(mmc->supply.vqmmc)) {
-		ret = regulator_enable(mmc->supply.vqmmc);
+		if (enable_vqmmc) {
+			ret = regulator_enable(mmc->supply.vqmmc);
+			if (ret) {
+				pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
+					mmc_hostname(mmc), ret);
+				mmc->supply.vqmmc = ERR_PTR(-EINVAL);
+			}
+			host->vqmmc_enabled = !ret;
+		}
 
 		/* If vqmmc provides no 1.8V signalling, then there's no UHS */
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000,
@@ -4386,12 +4398,6 @@ int sdhci_setup_host(struct sdhci_host *host)
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000,
 						    3600000))
 			host->flags &= ~SDHCI_SIGNALING_330;
-
-		if (ret) {
-			pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
-				mmc_hostname(mmc), ret);
-			mmc->supply.vqmmc = ERR_PTR(-EINVAL);
-		}
 	}
 
 	if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) {
@@ -4625,7 +4631,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	return 0;
 
 unreg:
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->vqmmc_enabled)
 		regulator_disable(mmc->supply.vqmmc);
 undma:
 	if (host->align_buffer)
@@ -4643,7 +4649,7 @@ void sdhci_cleanup_host(struct sdhci_host *host)
 {
 	struct mmc_host *mmc = host->mmc;
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->vqmmc_enabled)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
@@ -4780,7 +4786,7 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 
 	destroy_workqueue(host->complete_wq);
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->vqmmc_enabled)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
drivers/mmc/host/sdhci.h +0 -0
index 8d2a096..24d27e1 100644

drivers/mmc/host/sdhci.h struct sdhci_host { · line 573

Quoted 4 lines
drivers/mmc/host/sdhci.h +1 -0
@@ -570,6 +570,7 @@ struct sdhci_host {
 	u32 caps1;		/* CAPABILITY_1 */
 	bool read_caps;		/* Capability flags have been read */
 
+	bool vqmmc_enabled;	/* Vqmmc is enabled */

Last time around there was dissatisfaction with this variable name. Perhaps change it to sdhci_core_to_disable_vqmmc

Quoted 4 lines
drivers/mmc/host/sdhci.h +0 -0
 	unsigned int            ocr_avail_sdio;	/* OCR bit masks */
 	unsigned int            ocr_avail_sd;
 	unsigned int            ocr_avail_mmc;
#5 lore raw

Re: [PATCH V1 2/3] mmc: sdhci-msm: Use internal voltage control

In reply to Bjorn Andersson

Thanks Bjorn for the review. For major comments I'm responding. Other comments, i will take care of them in my next patch-set.

Quoted 98 lines · Bjorn Andersson
Quoted 9 lines · Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

Quoted 6 lines

Set the regulator load as well so that regulator can be configured in LPM mode when in is not being used.

Please note that per Documentation/process/submitting-patches.rst section 11) this states:

1) You wrote the patch (From:) without stating that its Certificate of origin.

2) Then Asutosh took your patch (in full or part) and guarantees that he's allowed to contribute it to the project.

3) Then you took his patch (in full or part) and guarantee that you're allowed to contribute it to the project.

4) Then Veerabhadrarao took your patch (in full or part) and guarantees that he's allowed to contribute it to the project

5) Then somehow it came out of your inbox - even if Veerabhadrarao was the one who handled it last.

As author you should be the first one to certify, and as poster to LKML you should be the last one.

If you worked together on this, then list Asutosh and Veerabhadrarao as Co-developed-by.

Quoted 33 lines
---
  drivers/mmc/host/sdhci-msm.c | 215 +++++++++++++++++++++++++++++++++++++++++--
  1 file changed, 207 insertions(+), 8 deletions(-)
drivers/mmc/host/sdhci-msm.c +6 -0
index 97758fa..a10e955 100644
@@ -36,7 +36,9 @@
  #define CORE_PWRCTL_IO_LOW	BIT(2)
  #define CORE_PWRCTL_IO_HIGH	BIT(3)
  #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
  #define CORE_PWRCTL_IO_SUCCESS	BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
  #define REQ_BUS_OFF		BIT(0)
  #define REQ_BUS_ON		BIT(1)
  #define REQ_IO_LOW		BIT(2)
@@ -263,6 +265,9 @@ struct sdhci_msm_host {
  	bool use_cdr;
  	u32 transfer_mode;
  	bool updated_ddr_cfg;
+	u32 vmmc_load;
+	u32 vqmmc_load;
+	bool vqmmc_enabled;
  };
 
  static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1298,6 +1303,78 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
  		sdhci_msm_hs400(host, &mmc->ios);
  }
 
+static int sdhci_msm_set_vmmc(struct sdhci_msm_host *msm_host,

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1316

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+			      struct mmc_host *mmc, int level)
+{
+	int load, ret;
+
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	if (msm_host->vmmc_load) {
+		load = level ? msm_host->vmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vmmc, load);

I started on the comment about regulator_set_load() that you can find below...

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1321

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +5 -0
+		if (ret)
+			goto out;
+	}
+
+	ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);

...but I don't see that mmc->ios.vdd necessarily is in sync with "level". Or do you here simply set the load based on what the hardware tell you and then orthogonally to that let the core enable/disable the regulator?

Quoted 3 lines

Perhaps I'm just missing something obvious, but if not I believe this warrants a comment describing that you're lowering the power level regardless of the actual power being disabled.

ios.vdd will be in sync with level. Vdd will be either 0 or a valid voltage (3v).

This indirectly gets triggered/invoked through power-irq when driver writes 0 or valid voltage to SDHCI_POWER_CONTROL register from sdhci_set_power_noreg().

Quoted 33 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1325

Quoted 4 lines
drivers/mmc/host/sdhci-msm.c +4 -0
+out:
+	if (ret)
+		pr_err("%s: vmmc set load/ocr failed: %d\n",
+				mmc_hostname(mmc), ret);

Please use:

	dev_err(mmc_dev(mmc), ...);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1331

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, int level)

vqmmc_enabled is a bool and "level" sounds like an int with several possible values. So please make level bool here as well, to make it easer to read..

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1343

Quoted 12 lines
drivers/mmc/host/sdhci-msm.c +12 -0
+{
+	int load, ret;
+	struct mmc_ios ios;
+
+	if (IS_ERR(mmc->supply.vqmmc)			 ||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED) ||
+	    (msm_host->vqmmc_enabled == level))
+		return 0;
+
+	if (msm_host->vqmmc_load) {
+		load = level ? msm_host->vqmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vqmmc, load);

Since v5.0 the "load" of a regulator consumer is only taken into consideration if the consumer is enabled. So given that you're toggling the regulator below there's no need to change this here.

Quoted 1 line

Just specify the "active load" at probe time.

For eMMC case, we don't disable this Vccq2 regulator by having always-on flag in the regulator node. Only for SDcard Vccq2 will be disabled. Sice driver is common for both eMMC and SDcard, I have to set 0 load to make it generic and to ensure eMMC Vccq2 regulator will be in LPM mode.

Quoted 27 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1351

Quoted 9 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+		if (ret)
+			goto out;
+	}
+
+	/*
+	 * The IO voltage regulator may not always support a voltage close to
+	 * vdd. Set IO voltage based on capability of the regulator.
+	 */

Is this comment related to the if/else-if inside the conditional? If so please move it one line down.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1356

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +5 -0
+	if (level) {
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;

Please add a space here, to indicate that the if statement on the next line is unrelated to the if/elseif above.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1360

Quoted 4 lines
drivers/mmc/host/sdhci-msm.c +4 -0
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			pr_debug("%s: %s: setting signal voltage: %d\n",
+					mmc_hostname(mmc), __func__,
+					ios.signal_voltage);

I strongly believe you should replace these debug prints with tracepoints, throughout the driver.

Quoted 12 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1368

Quoted 8 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0)
+				goto out;
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}

Given that you don't need to regulator_set_load() this function is now just one large if/else condition on a constant passed as an argument. Please split it into sdhci_msm_enable_vqmmc() and sdhci_msm_disable_vqmmc().

Same response as above
For eMMC case, we don't disable this Vccq2 regulator by having always-on flag in the regulator node. Only for SDcard Vccq2 will be disabled. Sice driver is common for both eMMC and SDcard, I have to set 0 load to make it generic and to ensure eMMC Vccq2 regulator will be in LPM mode.

Quoted 35 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1371

Quoted 3 lines
drivers/mmc/host/sdhci-msm.c +3 -0
+out:
+	if (ret)
+		pr_err("%s: vqmmc failed: %d\n", mmc_hostname(mmc), ret);

I think it would be useful to know if this error came from mmc_regulator_set_vqmmc() or regulator_enable() - or regulator_disable().

So please move this up and add some context in the error message, and please use dev_err().

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+	else
+		msm_host->vqmmc_enabled = level;
+
+	return ret;
+}
+
  static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
  {
  	init_waitqueue_head(&msm_host->pwr_irq_wait);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1483

Quoted 7 lines
drivers/mmc/host/sdhci-msm.c +2 -1
@@ -1401,8 +1478,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
  {
  	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
  	struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+	struct mmc_host *mmc = host->mmc;
  	u32 irq_status, irq_ack = 0;
-	int retry = 10;
+	int retry = 10, ret = 0;

There's no need to initialize ret, in all occasions it's assigned before being read.

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +0 -0
  	u32 pwr_state = 0, io_level = 0;
  	u32 config;
  	const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1438,14 +1516,35 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 
Quoted 12 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1521

Quoted 8 lines
drivers/mmc/host/sdhci-msm.c +3 -3
  	/* Handle BUS ON/OFF*/
  	if (irq_status & CORE_PWRCTL_BUS_ON) {
-		pwr_state = REQ_BUS_ON;
-		io_level = REQ_IO_HIGH;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		ret = sdhci_msm_set_vmmc(msm_host, mmc, 1);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc, 1);

I find this quite complex to follow. Wouldn't it be cleaner to retain the 4 checks on irq_status as they are and then before the writel of irq_ack check pwr_state and io_level and call sdhci_msm_set_{vmmc,vqmmc} accordingly?

I will see if i can update as you suggested.

Quoted 39 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1529

Quoted 8 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+
+		if (!ret) {
+			pwr_state = REQ_BUS_ON;
+			io_level = REQ_IO_HIGH;
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		} else {
+			pr_err("%s: BUS_ON req failed(%d). irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret, irq_status);

You already printed that this failed in sdhci_msm_set_{vmmc,vqmmc}, no need to print again.

Quoted 28 lines
drivers/mmc/host/sdhci-msm.c +16 -3
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+			sdhci_msm_set_vmmc(msm_host, mmc, 0);
+		}
  	}
  	if (irq_status & CORE_PWRCTL_BUS_OFF) {
-		pwr_state = REQ_BUS_OFF;
-		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		ret = sdhci_msm_set_vmmc(msm_host, mmc, 0);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc, 0);
+
+		if (!ret) {
+			pwr_state = REQ_BUS_OFF;
+			io_level = REQ_IO_LOW;
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		} else {
+			pr_err("%s: BUS_ON req failed(%d). irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret, irq_status);
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+		}
  	}
  	/* Handle IO LOW/HIGH */
  	if (irq_status & CORE_PWRCTL_IO_LOW) {
@@ -1457,6 +1556,15 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
  		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
  	}
 
Quoted 3 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1560

Quoted 2 lines
drivers/mmc/host/sdhci-msm.c +2 -0
+	if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+		ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);

Didn't you already call this through sdhci_msm_set_vqmmc()?

No.sdhci_msm_set_vqmmc handles only vqmmc ON/OFF. While turning it ON it sets Vqmmc to possbile default IO level (1.8v or 3.0v).
Where this is only to make IO lines high (3.0v) or Low (1.8v).

Quoted 19 lines
Quoted 11 lines
drivers/mmc/host/sdhci-msm.c +7 -0
+		if (ret < 0)
+			pr_err("%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret,
+					mmc->ios.signal_voltage, mmc->ios.vdd,
+					irq_status);
+	}
+
  	/*
  	 * The driver has to acknowledge the interrupt, switch voltages and
  	 * report back if it succeded or not to this register. The voltage

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1946

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +3 -0
@@ -1833,6 +1941,91 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
  	sdhci_reset(host, mask);
  }
 
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
+{
+	int ret = 0;

No need to initialize ret, first use is an assignment.

Quoted 14 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1957

Quoted 11 lines
drivers/mmc/host/sdhci-msm.c +11 -0
+	struct mmc_host *mmc = msm_host->mmc;
+
+	ret = mmc_regulator_get_supply(msm_host->mmc);
+	if (ret)
+		return ret;
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vmmc-max-load-microamp",
+			&msm_host->vmmc_load);
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vqmmc-max-load-microamp",
+			&msm_host->vqmmc_load);

These properties are not documented. Do they vary enough to mandate being read from DT or could they simply be approximated by a define instead?

I can use defines. But since these values are different for eMMC and SDcard I will have to maintain two sets and need to have logic during probe to identify SDcard or eMMC and use the assign the set accordingly. So we tought, getting from dt is simpler and clean.
In case Rob didn't agree with dt entries, I will go with this approach.

Quoted 26 lines
Quoted 26 lines
drivers/mmc/host/sdhci-msm.c +26 -0
+
+	sdhci_msm_set_regulator_caps(msm_host);
+	mmc->ios.power_mode = MMC_POWER_UNDEFINED;
+
+	return 0;
+
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
Quoted 8 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1989

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+			return -EINVAL;
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+		/* 3.3V regulator output should be stable within 5 ms */

What mechanism ensures that the readw won't return withing 5ms from the writew above?

Thanks for pointing this. This delay got missed. I will add it in next patchset.

Quoted 10 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1997

Quoted 8 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+		ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+		if (!(ctrl & SDHCI_CTRL_VDD_180))
+			return 0;
+
+		pr_warn("%s: 3.3V regulator output did not became stable\n",
+			mmc_hostname(mmc));
+
+		return -EAGAIN;

The body of the 330 and 180 cases are quite similar, can you perhaps deal with those after the switch, once?

Sure. Will check this.

Quoted 78 lines
Quoted 19 lines
drivers/mmc/host/sdhci-msm.c +19 -0
+	case MMC_SIGNAL_VOLTAGE_180:
+		if (!(host->flags & SDHCI_SIGNALING_180))
+			return -EINVAL;
+
+		/*
+		 * Enable 1.8V Signal Enable in the Host Control2
+		 * register
+		 */
+		ctrl |= SDHCI_CTRL_VDD_180;
+		sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+		/* 1.8V regulator output should be stable within 5 ms */
+		ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+		if (ctrl & SDHCI_CTRL_VDD_180)
+			return 0;
+
+		pr_warn("%s: 1.8V regulator output did not became stable\n",
+			mmc_hostname(mmc));
+

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 2026

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+		return -EAGAIN;
+	case MMC_SIGNAL_VOLTAGE_120:
+		if (!(host->flags & SDHCI_SIGNALING_120))
+			return -EINVAL;
+		return 0;
+	default:
+		/* No signal voltage switch required */
+		return 0;
+	}
+

Empty line.

Regards,
Bjorn

Quoted 44 lines
drivers/mmc/host/sdhci-msm.c +9 -1
+}
+
  static const struct sdhci_msm_variant_ops mci_var_ops = {
  	.msm_readl_relaxed = sdhci_msm_mci_variant_readl_relaxed,
  	.msm_writel_relaxed = sdhci_msm_mci_variant_writel_relaxed,
@@ -1880,6 +2073,7 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
  	.write_w = sdhci_msm_writew,
  	.write_b = sdhci_msm_writeb,
  	.irq	= sdhci_msm_cqe_irq,
+	.set_power = sdhci_set_power_noreg,
  };
 
  static const struct sdhci_pltfm_data sdhci_msm_pdata = {
@@ -2072,6 +2266,10 @@ static int sdhci_msm_probe(struct platform_device *pdev)
  	if (core_major == 1 && core_minor >= 0x49)
  		msm_host->updated_ddr_cfg = true;
 
+	ret = sdhci_msm_register_vreg(msm_host);
+	if (ret)
+		goto clk_disable;
+
  	/*
  	 * Power on reset state may trigger power irq if previous status of
  	 * PWRCTL was either BUS_ON or IO_HIGH_V. So before enabling pwr irq
@@ -2116,6 +2314,8 @@ static int sdhci_msm_probe(struct platform_device *pdev)
  					 MSM_MMC_AUTOSUSPEND_DELAY_MS);
  	pm_runtime_use_autosuspend(&pdev->dev);
 
+	host->mmc_host_ops.start_signal_voltage_switch =
+		sdhci_msm_start_signal_voltage_switch;
  	host->mmc_host_ops.execute_tuning = sdhci_msm_execute_tuning;
  	if (of_property_read_bool(node, "supports-cqe"))
  		ret = sdhci_msm_cqe_add_host(host, pdev);
@@ -2123,7 +2323,6 @@ static int sdhci_msm_probe(struct platform_device *pdev)
  		ret = sdhci_add_host(host);
  	if (ret)
  		goto pm_runtime_disable;
-	sdhci_msm_set_regulator_caps(msm_host);
 
  	pm_runtime_mark_last_busy(&pdev->dev);
  	pm_runtime_put_autosuspend(&pdev->dev);
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#9 lore raw

Re: [PATCH V1 3/3] mmc: sdhci: Allow platform controlled voltage switching

In reply to Adrian Hunter
Quoted 107 lines · Adrian Hunter
Quoted 106 lines · Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

If vendor platform drivers are controlling whole logic of voltage switching, then sdhci driver no need control vqmmc regulator. So skip enabling/disable vqmmc from SDHC driver.

---
  drivers/mmc/host/sdhci.c | 32 +++++++++++++++++++-------------
  drivers/mmc/host/sdhci.h |  1 +
  2 files changed, 20 insertions(+), 13 deletions(-)
drivers/mmc/host/sdhci.c +19 -13
index 1bb6b67..c010823 100644
@@ -4098,6 +4098,7 @@ int sdhci_setup_host(struct sdhci_host *host)
  	unsigned int override_timeout_clk;
  	u32 max_clk;
  	int ret;
+	bool enable_vqmmc = false;
 
  	WARN_ON(host == NULL);
  	if (host == NULL)
@@ -4111,9 +4112,12 @@ int sdhci_setup_host(struct sdhci_host *host)
  	 * the host can take the appropriate action if regulators are not
  	 * available.
  	 */
-	ret = mmc_regulator_get_supply(mmc);
-	if (ret)
-		return ret;
+	if (!mmc->supply.vqmmc) {
+		ret = mmc_regulator_get_supply(mmc);
+		if (ret)
+			return ret;
+		enable_vqmmc  = true;
+	}
 
  	DBG("Version:   0x%08x | Present:  0x%08x\n",
  	    sdhci_readw(host, SDHCI_HOST_VERSION),
@@ -4373,7 +4377,15 @@ int sdhci_setup_host(struct sdhci_host *host)
  		mmc->caps |= MMC_CAP_NEEDS_POLL;
 
  	if (!IS_ERR(mmc->supply.vqmmc)) {
-		ret = regulator_enable(mmc->supply.vqmmc);
+		if (enable_vqmmc) {
+			ret = regulator_enable(mmc->supply.vqmmc);
+			if (ret) {
+				pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
+					mmc_hostname(mmc), ret);
+				mmc->supply.vqmmc = ERR_PTR(-EINVAL);
+			}
+			host->vqmmc_enabled = !ret;
+		}
 
  		/* If vqmmc provides no 1.8V signalling, then there's no UHS */
  		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000,
@@ -4386,12 +4398,6 @@ int sdhci_setup_host(struct sdhci_host *host)
  		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000,
  						    3600000))
  			host->flags &= ~SDHCI_SIGNALING_330;
-
-		if (ret) {
-			pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
-				mmc_hostname(mmc), ret);
-			mmc->supply.vqmmc = ERR_PTR(-EINVAL);
-		}
  	}
 
  	if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) {
@@ -4625,7 +4631,7 @@ int sdhci_setup_host(struct sdhci_host *host)
  	return 0;
 
  unreg:
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->vqmmc_enabled)
  		regulator_disable(mmc->supply.vqmmc);
  undma:
  	if (host->align_buffer)
@@ -4643,7 +4649,7 @@ void sdhci_cleanup_host(struct sdhci_host *host)
  {
  	struct mmc_host *mmc = host->mmc;
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->vqmmc_enabled)
  		regulator_disable(mmc->supply.vqmmc);
 
  	if (host->align_buffer)
@@ -4780,7 +4786,7 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 
  	destroy_workqueue(host->complete_wq);
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->vqmmc_enabled)
  		regulator_disable(mmc->supply.vqmmc);
 
  	if (host->align_buffer)
drivers/mmc/host/sdhci.h +0 -0
index 8d2a096..24d27e1 100644
@@ -570,6 +570,7 @@ struct sdhci_host {
  	u32 caps1;		/* CAPABILITY_1 */
  	bool read_caps;		/* Capability flags have been read */
 
Quoted 3 lines

drivers/mmc/host/sdhci.h struct sdhci_host { · line 573

Quoted 1 line
drivers/mmc/host/sdhci.h +1 -0
+	bool vqmmc_enabled;	/* Vqmmc is enabled */

Last time around there was dissatisfaction with this variable name. Perhaps change it to sdhci_core_to_disable_vqmmc

Sure Adrian. Will update this variable name.

Quoted 5 lines
Quoted 5 lines
drivers/mmc/host/sdhci.h +0 -0
  	unsigned int            ocr_avail_sdio;	/* OCR bit masks */
  	unsigned int            ocr_avail_sd;
  	unsigned int            ocr_avail_mmc;
#11 lore raw

PATCH v2 1/3 dt-bindings: mmc: Supply max load for mmc supplies

In reply to Veerabhadrarao Badiganti

Supply the max load needed for driving the mmc supplies.

---
 .../devicetree/bindings/mmc/mmc-controller.yaml          | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
Documentation/devicetree/bindings/mmc/mmc-controller.yaml +16 -0
index acc9f10..9058b82 100644
@@ -290,6 +290,22 @@ properties:
     description:
       Supply for the bus IO line power
 
+  vmmc-max-load-microamp:
+    allOf:
+      - $ref: /schemas/types.yaml#/definitions/uint32
+      - minimum: 0
+      - maximum: 1000000
+    description:
+      Maximum load for the card power.
+
+  vqmmc-max-load-microamp:
+    allOf:
+      - $ref: /schemas/types.yaml#/definitions/uint32
+      - minimum: 0
+      - maximum: 1000000
+    description:
+      Maximum load for the bus IO line power.
+
   mmc-pwrseq:
     $ref: /schemas/types.yaml#/definitions/phandle
     description:
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#10 lore raw

v2 cover Internal voltage control for qcom SDHC

In reply to Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

So added support to register voltage regulators from the msm driver and use them.

This patchset was posted long back but not actively pursued
https://lore.kernel.org/linux-arm-msm/[email protected]/
So posting it as fresh patchset.

Changes since V1:
- Removed setting load for Vmmc regulator while turning it on/off. Instead setting the active load once during probe.
- Simplified handlng of supplies for BUS_ON/OFF cases in shci_msm_handle_pwr_irq().
- Moved common code out of switch case in sdhci_msm_start_signal_voltage_switch().
- Updated variable name to sdhci_core_to_disable_vqmmc.
- Updated pr_err logs to dev_err logs.

Veerabhadrarao Badiganti (1):
dt-bindings: mmc: Supply max load for mmc supplies
mmc: sdhci-msm: Use internal voltage control

Vijay Viswanath (1):
mmc: sdhci: Allow platform controlled voltage switching

 .../devicetree/bindings/mmc/mmc-controller.yaml    |  16 ++
 drivers/mmc/host/sdhci-msm.c                       | 207 ++++++++++++++++++++-
 drivers/mmc/host/sdhci.c                           |  32 ++--
 drivers/mmc/host/sdhci.h                           |   1 +
 4 files changed, 234 insertions(+), 22 deletions(-)
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#13 lore raw

PATCH v2 2/3 mmc: sdhci-msm: Use internal voltage control

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

Set the regulator load as well so that regulator can be configured in LPM mode when in is not being used.

---
 drivers/mmc/host/sdhci-msm.c | 207 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 198 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +198 -9
index 97758fa..6211ab4 100644
@@ -36,7 +36,9 @@
 #define CORE_PWRCTL_IO_LOW	BIT(2)
 #define CORE_PWRCTL_IO_HIGH	BIT(3)
 #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
 #define CORE_PWRCTL_IO_SUCCESS	BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
 #define REQ_BUS_OFF		BIT(0)
 #define REQ_BUS_ON		BIT(1)
 #define REQ_IO_LOW		BIT(2)
@@ -263,6 +265,8 @@ struct sdhci_msm_host {
 	bool use_cdr;
 	u32 transfer_mode;
 	bool updated_ddr_cfg;
+	u32 vqmmc_load;
+	bool vqmmc_enabled;
 };
 
 static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1298,6 +1302,71 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
 		sdhci_msm_hs400(host, &mmc->ios);
 }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)
+{
+	int ret;
+
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vmmc set ocr with vdd=%d failed: %d\n",
+			mmc_hostname(mmc), mmc->ios.vdd, ret);
+
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int load, ret;
+	struct mmc_ios ios;
+
+	if (IS_ERR(mmc->supply.vqmmc)			 ||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED) ||
+	    (msm_host->vqmmc_enabled == level))
+		return 0;
+
+	if (msm_host->vqmmc_load) {
+		load = level ? msm_host->vqmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vqmmc, load);
+		if (ret) {
+			dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+				mmc_hostname(mmc), ret);
+			goto out;
+		}
+	}
+
+	if (level) {
+		/* Set the IO voltage regulator to default voltage level */
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0) {
+				dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+					mmc_hostname(mmc), ret);
+				goto out;
+			}
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}
+
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+			mmc_hostname(mmc), level ? "en":"dis", ret);
+	else
+		msm_host->vqmmc_enabled = level;
+out:
+	return ret;
+}
+
 static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
 {
 	init_waitqueue_head(&msm_host->pwr_irq_wait);
@@ -1401,8 +1470,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 {
 	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 	struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+	struct mmc_host *mmc = host->mmc;
 	u32 irq_status, irq_ack = 0;
-	int retry = 10;
+	int retry = 10, ret;
 	u32 pwr_state = 0, io_level = 0;
 	u32 config;
 	const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1440,21 +1510,42 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 	if (irq_status & CORE_PWRCTL_BUS_ON) {
 		pwr_state = REQ_BUS_ON;
 		io_level = REQ_IO_HIGH;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
 	}
 	if (irq_status & CORE_PWRCTL_BUS_OFF) {
 		pwr_state = REQ_BUS_OFF;
 		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
 	}
+
+	if (pwr_state) {
+		ret = sdhci_msm_set_vmmc(mmc);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc,
+					pwr_state & REQ_BUS_ON);
+		if (!ret)
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		else
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+	}
+
 	/* Handle IO LOW/HIGH */
-	if (irq_status & CORE_PWRCTL_IO_LOW) {
+	if (irq_status & CORE_PWRCTL_IO_LOW)
 		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
-	}
-	if (irq_status & CORE_PWRCTL_IO_HIGH) {
+
+	if (irq_status & CORE_PWRCTL_IO_HIGH)
 		io_level = REQ_IO_HIGH;
+
+	if (io_level)
 		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
+
+	if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+		ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);
+		if (ret < 0) {
+			dev_err(mmc_dev(mmc), "%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret,
+					mmc->ios.signal_voltage, mmc->ios.vdd,
+					irq_status);
+			irq_ack |= CORE_PWRCTL_IO_FAIL;
+		}
 	}
 
 	/*
@@ -1503,7 +1594,7 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 	if (io_level)
 		msm_host->curr_io_level = io_level;
 
-	pr_debug("%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
+	dev_dbg(mmc_dev(mmc), "%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
 		mmc_hostname(msm_host->mmc), __func__, irq, irq_status,
 		irq_ack);
 }
@@ -1833,6 +1924,98 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
 	sdhci_reset(host, mask);
 }
 
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
+{
+	int ret;
+	u32 vmmc_load;
+	struct mmc_host *mmc = msm_host->mmc;
+
+	ret = mmc_regulator_get_supply(msm_host->mmc);
+	if (ret)
+		return ret;
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vmmc-max-load-microamp",
+			&vmmc_load);
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vqmmc-max-load-microamp",
+			&msm_host->vqmmc_load);
+
+	/* Vmmc regulator can be turned off. So just set active load once */
+	if (!IS_ERR(mmc->supply.vmmc) && vmmc_load) {
+		ret = regulator_set_load(mmc->supply.vmmc, vmmc_load);
+		if (ret) {
+			dev_err(mmc_dev(mmc), "%s: vmmc set active load failed: %d\n",
+				mmc_hostname(mmc), ret);
+			return ret;
+		}
+	}
+
+	sdhci_msm_set_regulator_caps(msm_host);
+	mmc->ios.power_mode = MMC_POWER_UNDEFINED;
+
+	return 0;
+
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl, status;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
+			return -EINVAL;
+
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_180:
+		if (!(host->flags & SDHCI_SIGNALING_180))
+			return -EINVAL;
+
+		/*
+		 * Enable 1.8V Signal Enable in the Host Control2
+		 * register
+		 */
+		ctrl |= SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_120:
+		if (!(host->flags & SDHCI_SIGNALING_120))
+			return -EINVAL;
+		return 0;
+	default:
+		/* No signal voltage switch required */
+		return 0;
+	}
+
+	sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+	/* Wait for 5ms */
+	usleep_range(5000, 5500);
+
+	/* regulator output should be stable within 5 ms */
+	status = !!(ctrl & SDHCI_CTRL_VDD_180);
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+	if (!!(ctrl &  SDHCI_CTRL_VDD_180) == status)
+		return 0;
+
+	dev_warn(mmc_dev(mmc), "%s: Regulator output did not became stable\n",
+		mmc_hostname(mmc));
+
+	return -EAGAIN;
+}
+
 static const struct sdhci_msm_variant_ops mci_var_ops = {
 	.msm_readl_relaxed = sdhci_msm_mci_variant_readl_relaxed,
 	.msm_writel_relaxed = sdhci_msm_mci_variant_writel_relaxed,
@@ -1880,6 +2063,7 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
 	.write_w = sdhci_msm_writew,
 	.write_b = sdhci_msm_writeb,
 	.irq	= sdhci_msm_cqe_irq,
+	.set_power = sdhci_set_power_noreg,
 };
 
 static const struct sdhci_pltfm_data sdhci_msm_pdata = {
@@ -2072,6 +2256,10 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 	if (core_major == 1 && core_minor >= 0x49)
 		msm_host->updated_ddr_cfg = true;
 
+	ret = sdhci_msm_register_vreg(msm_host);
+	if (ret)
+		goto clk_disable;
+
 	/*
 	 * Power on reset state may trigger power irq if previous status of
 	 * PWRCTL was either BUS_ON or IO_HIGH_V. So before enabling pwr irq
@@ -2116,6 +2304,8 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 					 MSM_MMC_AUTOSUSPEND_DELAY_MS);
 	pm_runtime_use_autosuspend(&pdev->dev);
 
+	host->mmc_host_ops.start_signal_voltage_switch =
+		sdhci_msm_start_signal_voltage_switch;
 	host->mmc_host_ops.execute_tuning = sdhci_msm_execute_tuning;
 	if (of_property_read_bool(node, "supports-cqe"))
 		ret = sdhci_msm_cqe_add_host(host, pdev);
@@ -2123,7 +2313,6 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 		ret = sdhci_add_host(host);
 	if (ret)
 		goto pm_runtime_disable;
-	sdhci_msm_set_regulator_caps(msm_host);
 
 	pm_runtime_mark_last_busy(&pdev->dev);
 	pm_runtime_put_autosuspend(&pdev->dev);
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#18 lore raw

PATCH v2 3/3 mmc: sdhci: Allow platform controlled voltage switching

In reply to Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

If vendor platform drivers are controlling whole logic of voltage switching, then sdhci driver no need control vqmmc regulator. So skip enabling/disable vqmmc from SDHC driver.

---
 drivers/mmc/host/sdhci.c | 32 +++++++++++++++++++-------------
 drivers/mmc/host/sdhci.h |  1 +
 2 files changed, 20 insertions(+), 13 deletions(-)
drivers/mmc/host/sdhci.c +19 -13
index 1bb6b67..88e5312 100644
@@ -4098,6 +4098,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	unsigned int override_timeout_clk;
 	u32 max_clk;
 	int ret;
+	bool enable_vqmmc = false;
 
 	WARN_ON(host == NULL);
 	if (host == NULL)
@@ -4111,9 +4112,12 @@ int sdhci_setup_host(struct sdhci_host *host)
 	 * the host can take the appropriate action if regulators are not
 	 * available.
 	 */
-	ret = mmc_regulator_get_supply(mmc);
-	if (ret)
-		return ret;
+	if (!mmc->supply.vqmmc) {
+		ret = mmc_regulator_get_supply(mmc);
+		if (ret)
+			return ret;
+		enable_vqmmc  = true;
+	}
 
 	DBG("Version:   0x%08x | Present:  0x%08x\n",
 	    sdhci_readw(host, SDHCI_HOST_VERSION),
@@ -4373,7 +4377,15 @@ int sdhci_setup_host(struct sdhci_host *host)
 		mmc->caps |= MMC_CAP_NEEDS_POLL;
 
 	if (!IS_ERR(mmc->supply.vqmmc)) {
-		ret = regulator_enable(mmc->supply.vqmmc);
+		if (enable_vqmmc) {
+			ret = regulator_enable(mmc->supply.vqmmc);
+			if (ret) {
+				pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
+					mmc_hostname(mmc), ret);
+				mmc->supply.vqmmc = ERR_PTR(-EINVAL);
+			}
+			host->sdhci_core_to_disable_vqmmc = !ret;
+		}
 
 		/* If vqmmc provides no 1.8V signalling, then there's no UHS */
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000,
@@ -4386,12 +4398,6 @@ int sdhci_setup_host(struct sdhci_host *host)
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000,
 						    3600000))
 			host->flags &= ~SDHCI_SIGNALING_330;
-
-		if (ret) {
-			pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
-				mmc_hostname(mmc), ret);
-			mmc->supply.vqmmc = ERR_PTR(-EINVAL);
-		}
 	}
 
 	if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) {
@@ -4625,7 +4631,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	return 0;
 
 unreg:
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 undma:
 	if (host->align_buffer)
@@ -4643,7 +4649,7 @@ void sdhci_cleanup_host(struct sdhci_host *host)
 {
 	struct mmc_host *mmc = host->mmc;
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
@@ -4780,7 +4786,7 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 
 	destroy_workqueue(host->complete_wq);
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
drivers/mmc/host/sdhci.h +1 -0
index 8d2a096..c7dbc68 100644
@@ -570,6 +570,7 @@ struct sdhci_host {
 	u32 caps1;		/* CAPABILITY_1 */
 	bool read_caps;		/* Capability flags have been read */
 
+	bool sdhci_core_to_disable_vqmmc;  /* sdhci core can disable vqmmc */
 	unsigned int            ocr_avail_sdio;	/* OCR bit masks */
 	unsigned int            ocr_avail_sd;
 	unsigned int            ocr_avail_mmc;
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#6 lore raw

Re: [PATCH V1 2/3] mmc: sdhci-msm: Use internal voltage control

In reply to Veerabhadrarao Badiganti
Quoted 6 lines · Veerabhadrarao Badiganti

Thanks Bjorn for the review. For major comments I'm responding. Other comments, i will take care of them in my next patch-set.

Quoted 1 line · Bjorn Andersson

On Fri 15 May 04:18 PDT 2020, Veerabhadrarao Badiganti wrote:

[..]

Quoted 1 line
Quoted 1 line
Quoted 1 line
drivers/mmc/host/sdhci-msm.c +0 -0

[..]

Quoted 28 lines
Quoted 24 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1316

Quoted 11 lines
drivers/mmc/host/sdhci-msm.c +11 -0
+static int sdhci_msm_set_vmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, int level)
+{
+	int load, ret;
+
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	if (msm_host->vmmc_load) {
+		load = level ? msm_host->vmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vmmc, load);

I started on the comment about regulator_set_load() that you can find below...

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1321

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +5 -0
+		if (ret)
+			goto out;
+	}
+
+	ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);

...but I don't see that mmc->ios.vdd necessarily is in sync with "level". Or do you here simply set the load based on what the hardware tell you and then orthogonally to that let the core enable/disable the regulator?

Quoted 3 lines

Perhaps I'm just missing something obvious, but if not I believe this warrants a comment describing that you're lowering the power level regardless of the actual power being disabled.

Quoted 7 lines

ios.vdd will be in sync with level. Vdd will be either 0 or a valid voltage (3v).

This indirectly gets triggered/invoked through power-irq when driver writes 0
or valid voltage to SDHCI_POWER_CONTROL register from sdhci_set_power_noreg().

Ok, thanks for explaining.

Quoted 33 lines
Quoted 33 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1325

Quoted 4 lines
drivers/mmc/host/sdhci-msm.c +4 -0
+out:
+	if (ret)
+		pr_err("%s: vmmc set load/ocr failed: %d\n",
+				mmc_hostname(mmc), ret);

Please use:

	dev_err(mmc_dev(mmc), ...);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1331

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, int level)

vqmmc_enabled is a bool and "level" sounds like an int with several possible values. So please make level bool here as well, to make it easer to read..

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1343

Quoted 12 lines
drivers/mmc/host/sdhci-msm.c +12 -0
+{
+	int load, ret;
+	struct mmc_ios ios;
+
+	if (IS_ERR(mmc->supply.vqmmc)			 ||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED) ||
+	    (msm_host->vqmmc_enabled == level))
+		return 0;
+
+	if (msm_host->vqmmc_load) {
+		load = level ? msm_host->vqmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vqmmc, load);

Since v5.0 the "load" of a regulator consumer is only taken into consideration if the consumer is enabled. So given that you're toggling the regulator below there's no need to change this here.

Quoted 8 lines
Quoted 1 line

Just specify the "active load" at probe time.

For eMMC case, we don't disable this Vccq2 regulator by having always-on flag
in the regulator node. Only for SDcard Vccq2 will be disabled. Sice driver is common for both eMMC and SDcard, I have to set 0 load to make it generic and to ensure eMMC Vccq2 regulator will be in LPM mode.

You should still call regulator_enable()/regulator_disable() on your consumer regulator in this driver. When you do this the regulator core will conclude that the regulator_dev (i.e. the part that represents the hardware) is marked always_on and will not enable/disable the regulator.

But it will still invoke _regulator_handle_consumer_enable() and _regulator_handle_consumer_disable(), which will aggregate the "load" of all client regulators and update the regulator's load.

So this will apply the load as you expect regardless of it being supplied by a regulator marked as always_on.

Quoted 139 lines
Quoted 27 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1351

Quoted 9 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+		if (ret)
+			goto out;
+	}
+
+	/*
+	 * The IO voltage regulator may not always support a voltage close to
+	 * vdd. Set IO voltage based on capability of the regulator.
+	 */

Is this comment related to the if/else-if inside the conditional? If so please move it one line down.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1356

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +5 -0
+	if (level) {
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;

Please add a space here, to indicate that the if statement on the next line is unrelated to the if/elseif above.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1360

Quoted 4 lines
drivers/mmc/host/sdhci-msm.c +4 -0
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			pr_debug("%s: %s: setting signal voltage: %d\n",
+					mmc_hostname(mmc), __func__,
+					ios.signal_voltage);

I strongly believe you should replace these debug prints with tracepoints, throughout the driver.

Quoted 12 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1368

Quoted 8 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0)
+				goto out;
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}

Given that you don't need to regulator_set_load() this function is now just one large if/else condition on a constant passed as an argument. Please split it into sdhci_msm_enable_vqmmc() and sdhci_msm_disable_vqmmc().

Same response as above
For eMMC case, we don't disable this Vccq2 regulator by having always-on flag
in the regulator node. Only for SDcard Vccq2 will be disabled. Sice driver is common for both eMMC and SDcard, I have to set 0 load to make it generic and to ensure eMMC Vccq2 regulator will be in LPM mode.

Quoted 30 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1371

Quoted 3 lines
drivers/mmc/host/sdhci-msm.c +3 -0
+out:
+	if (ret)
+		pr_err("%s: vqmmc failed: %d\n", mmc_hostname(mmc), ret);

I think it would be useful to know if this error came from mmc_regulator_set_vqmmc() or regulator_enable() - or regulator_disable().

So please move this up and add some context in the error message, and please use dev_err().

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+	else
+		msm_host->vqmmc_enabled = level;
+
+	return ret;
+}
+
  static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
  {
  	init_waitqueue_head(&msm_host->pwr_irq_wait);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1483

Quoted 7 lines
drivers/mmc/host/sdhci-msm.c +2 -1
@@ -1401,8 +1478,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
  {
  	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
  	struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+	struct mmc_host *mmc = host->mmc;
  	u32 irq_status, irq_ack = 0;
-	int retry = 10;
+	int retry = 10, ret = 0;

There's no need to initialize ret, in all occasions it's assigned before being read.

Quoted 16 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1520

Quoted 12 lines
drivers/mmc/host/sdhci-msm.c +3 -3
  	u32 pwr_state = 0, io_level = 0;
  	u32 config;
  	const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1438,14 +1516,35 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
  	/* Handle BUS ON/OFF*/
  	if (irq_status & CORE_PWRCTL_BUS_ON) {
-		pwr_state = REQ_BUS_ON;
-		io_level = REQ_IO_HIGH;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		ret = sdhci_msm_set_vmmc(msm_host, mmc, 1);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc, 1);

I find this quite complex to follow. Wouldn't it be cleaner to retain the 4 checks on irq_status as they are and then before the writel of irq_ack check pwr_state and io_level and call sdhci_msm_set_{vmmc,vqmmc} accordingly?

I will see if i can update as you suggested.

Quoted 33 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1529

Quoted 8 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+
+		if (!ret) {
+			pwr_state = REQ_BUS_ON;
+			io_level = REQ_IO_HIGH;
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		} else {
+			pr_err("%s: BUS_ON req failed(%d). irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret, irq_status);

You already printed that this failed in sdhci_msm_set_{vmmc,vqmmc}, no need to print again.

Quoted 22 lines
drivers/mmc/host/sdhci-msm.c +16 -3
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+			sdhci_msm_set_vmmc(msm_host, mmc, 0);
+		}
  	}
  	if (irq_status & CORE_PWRCTL_BUS_OFF) {
-		pwr_state = REQ_BUS_OFF;
-		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		ret = sdhci_msm_set_vmmc(msm_host, mmc, 0);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc, 0);
+
+		if (!ret) {
+			pwr_state = REQ_BUS_OFF;
+			io_level = REQ_IO_LOW;
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		} else {
+			pr_err("%s: BUS_ON req failed(%d). irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret, irq_status);
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+		}
  	}
Quoted 8 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) · line 1559

Quoted 7 lines
drivers/mmc/host/sdhci-msm.c +2 -0
  	/* Handle IO LOW/HIGH */
  	if (irq_status & CORE_PWRCTL_IO_LOW) {
@@ -1457,6 +1556,15 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
  		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
  	}
+	if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+		ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);

Didn't you already call this through sdhci_msm_set_vqmmc()?

Quoted 4 lines

No.sdhci_msm_set_vqmmc handles only vqmmc ON/OFF. While turning it ON it sets
Vqmmc to possbile default IO level (1.8v or 3.0v).
Where this is only to make IO lines high (3.0v) or Low (1.8v).

If you move both the regulator operations here (below the point where you figure out pwr_state and io_level), wouldn't it be possible to avoid the additional, nested, vqmmc voltage request?

Quoted 33 lines
Quoted 18 lines
Quoted 11 lines
drivers/mmc/host/sdhci-msm.c +7 -0
+		if (ret < 0)
+			pr_err("%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret,
+					mmc->ios.signal_voltage, mmc->ios.vdd,
+					irq_status);
+	}
+
  	/*
  	 * The driver has to acknowledge the interrupt, switch voltages and
  	 * report back if it succeded or not to this register. The voltage

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1945

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +3 -0
@@ -1833,6 +1941,91 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
  	sdhci_reset(host, mask);
  }
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
+{
+	int ret = 0;

No need to initialize ret, first use is an assignment.

Quoted 14 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1957

Quoted 11 lines
drivers/mmc/host/sdhci-msm.c +11 -0
+	struct mmc_host *mmc = msm_host->mmc;
+
+	ret = mmc_regulator_get_supply(msm_host->mmc);
+	if (ret)
+		return ret;
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vmmc-max-load-microamp",
+			&msm_host->vmmc_load);
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vqmmc-max-load-microamp",
+			&msm_host->vqmmc_load);

These properties are not documented. Do they vary enough to mandate being read from DT or could they simply be approximated by a define instead?

Quoted 6 lines

I can use defines. But since these values are different for eMMC and SDcard I will have to maintain two sets and need to have logic during probe to identify SDcard or eMMC and use the assign the set accordingly. So we tought, getting from dt is simpler and clean.
In case Rob didn't agree with dt entries, I will go with this approach.

Sounds reasonable, let's see what Rob says.

Quoted 35 lines
Quoted 26 lines
Quoted 26 lines
drivers/mmc/host/sdhci-msm.c +26 -0
+
+	sdhci_msm_set_regulator_caps(msm_host);
+	mmc->ios.power_mode = MMC_POWER_UNDEFINED;
+
+	return 0;
+
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
Quoted 8 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 1989

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+			return -EINVAL;
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+		/* 3.3V regulator output should be stable within 5 ms */

What mechanism ensures that the readw won't return withing 5ms from the writew above?

Quoted 2 lines

Thanks for pointing this. This delay got missed. I will add it in next patchset.

Nice, thanks.

Regards,
Bjorn

#14 lore raw

Re: [PATCH V2 2/3] mmc: sdhci-msm: Use internal voltage control

In reply to Veerabhadrarao Badiganti
Quoted 10 lines · Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

Set the regulator load as well so that regulator can be configured in LPM mode when in is not being used.

Quoted 6 lines

Looks better, thanks.

Quoted 5 lines
---
 drivers/mmc/host/sdhci-msm.c | 207 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 198 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +0 -0

[..]

Quoted 6 lines

static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)

drivers/mmc/host/sdhci-msm.c +1 -0
@@ -1298,6 +1302,71 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
 		sdhci_msm_hs400(host, &mmc->ios);
 }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1315

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+{
+	int ret;
+
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vmmc set ocr with vdd=%d failed: %d\n",
+			mmc_hostname(mmc), mmc->ios.vdd, ret);

Missed this one on v1, in the event that mmc_regulator_set_ocr() return a non-zero value it has already printed an error message. So please replace the tail with just:

	return mmc_regulator_set_ocr(...);
Quoted 8 lines
drivers/mmc/host/sdhci-msm.c +8 -0
+
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int load, ret;

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1333

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+	struct mmc_ios ios;
+
+	if (IS_ERR(mmc->supply.vqmmc)			 ||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED) ||
+	    (msm_host->vqmmc_enabled == level))
+		return 0;
+
+	if (msm_host->vqmmc_load) {
+		load = level ? msm_host->vqmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vqmmc, load);

Sorry for the late reply on v1, but please see my explanation regarding load and always-on regulators there.

Quoted 35 lines
drivers/mmc/host/sdhci-msm.c +35 -0
+		if (ret) {
+			dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+				mmc_hostname(mmc), ret);
+			goto out;
+		}
+	}
+
+	if (level) {
+		/* Set the IO voltage regulator to default voltage level */
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0) {
+				dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+					mmc_hostname(mmc), ret);
+				goto out;
+			}
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}
+
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+			mmc_hostname(mmc), level ? "en":"dis", ret);
+	else
+		msm_host->vqmmc_enabled = level;
+out:
+	return ret;
+}

[..]

Quoted 41 lines
drivers/mmc/host/sdhci-msm.c +41 -0
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl, status;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
+			return -EINVAL;
+
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_180:
+		if (!(host->flags & SDHCI_SIGNALING_180))
+			return -EINVAL;
+
+		/*
+		 * Enable 1.8V Signal Enable in the Host Control2
+		 * register
+		 */
+		ctrl |= SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_120:
+		if (!(host->flags & SDHCI_SIGNALING_120))
+			return -EINVAL;
+		return 0;
+	default:
+		/* No signal voltage switch required */
+		return 0;
+	}

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 2010

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+
+	sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+	/* Wait for 5ms */
+	usleep_range(5000, 5500);
+
+	/* regulator output should be stable within 5 ms */
+	status = !!(ctrl & SDHCI_CTRL_VDD_180);
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+	if (!!(ctrl &  SDHCI_CTRL_VDD_180) == status)

You should be able to drop the !! both here and when assigning status.

Overall this looks neater, thanks for reworking it.

Regards,
Bjorn

#15 lore raw

Re: [PATCH V2 2/3] mmc: sdhci-msm: Use internal voltage control

Hi Bjorn,

Quoted 60 lines · Bjorn Andersson
Quoted 10 lines · Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

Set the regulator load as well so that regulator can be configured in LPM mode when in is not being used.

Quoted 6 lines

Looks better, thanks.

Quoted 5 lines
---
  drivers/mmc/host/sdhci-msm.c | 207 +++++++++++++++++++++++++++++++++++++++++--
  1 file changed, 198 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +0 -0

[..]

Quoted 6 lines

static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)

drivers/mmc/host/sdhci-msm.c +1 -0
@@ -1298,6 +1302,71 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
  		sdhci_msm_hs400(host, &mmc->ios);
  }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1315

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+{
+	int ret;
+
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vmmc set ocr with vdd=%d failed: %d\n",
+			mmc_hostname(mmc), mmc->ios.vdd, ret);

Missed this one on v1, in the event that mmc_regulator_set_ocr() return a non-zero value it has already printed an error message. So please replace the tail with just:

	return mmc_regulator_set_ocr(...);
Quoted 12 lines
drivers/mmc/host/sdhci-msm.c +12 -0
+
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int load, ret;
+	struct mmc_ios ios;
+
+	if (IS_ERR(mmc->supply.vqmmc)			 ||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED) ||
Quoted 8 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1333

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+	    (msm_host->vqmmc_enabled == level))
+		return 0;
+
+	if (msm_host->vqmmc_load) {
+		load = level ? msm_host->vqmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vqmmc, load);

Sorry for the late reply on v1, but please see my explanation regarding load and always-on regulators there.

<Merging your comment from V1 here>

Quoted 11 lines
Quoted 11 lines

You should still call regulator_enable()/regulator_disable() on your consumer regulator in this driver. When you do this the regulator core will conclude that the regulator_dev (i.e. the part that represents the hardware) is marked always_on and will not enable/disable the regulator.

But it will still invoke _regulator_handle_consumer_enable() and _regulator_handle_consumer_disable(), which will aggregate the "load" of all client regulators and update the regulator's load.

So this will apply the load as you expect regardless of it being supplied by a regulator marked as always_on.

Since I'm not turning off this regulator for eMMC, I wanted to keep it in LPM mode to save some power.
When the regulator configured in auto mode (RPMH_REGULATOR_MODE_AUTO) it switches to LPM/HPM mode based on the active load.
So i have to minimize my driver load requirement so that I can let this regulator in LPM mode.
So i need to set load every-time I disable/enable the regulator.

Quoted 89 lines
Quoted 35 lines
drivers/mmc/host/sdhci-msm.c +35 -0
+		if (ret) {
+			dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+				mmc_hostname(mmc), ret);
+			goto out;
+		}
+	}
+
+	if (level) {
+		/* Set the IO voltage regulator to default voltage level */
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0) {
+				dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+					mmc_hostname(mmc), ret);
+				goto out;
+			}
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}
+
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+			mmc_hostname(mmc), level ? "en":"dis", ret);
+	else
+		msm_host->vqmmc_enabled = level;
+out:
+	return ret;
+}

[..]

Quoted 41 lines
drivers/mmc/host/sdhci-msm.c +41 -0
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl, status;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
+			return -EINVAL;
+
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_180:
+		if (!(host->flags & SDHCI_SIGNALING_180))
+			return -EINVAL;
+
+		/*
+		 * Enable 1.8V Signal Enable in the Host Control2
+		 * register
+		 */
+		ctrl |= SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_120:
+		if (!(host->flags & SDHCI_SIGNALING_120))
+			return -EINVAL;
+		return 0;
+	default:
+		/* No signal voltage switch required */
+		return 0;
+	}

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 2010

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+
+	sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+	/* Wait for 5ms */
+	usleep_range(5000, 5500);
+
+	/* regulator output should be stable within 5 ms */
+	status = !!(ctrl & SDHCI_CTRL_VDD_180);
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+	if (!!(ctrl &  SDHCI_CTRL_VDD_180) == status)

You should be able to drop the !! both here and when assigning status.

Quoted 4 lines

Overall this looks neater, thanks for reworking it.

Regards,
Bjorn

Thanks

Veera

#16 lore raw

Re: [PATCH V2 2/3] mmc: sdhci-msm: Use internal voltage control

Quoted 85 lines · Veerabhadrarao Badiganti

Hi Bjorn,

Quoted 59 lines · Bjorn Andersson
Quoted 10 lines · Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

Set the regulator load as well so that regulator can be configured in LPM mode when in is not being used.

Quoted 6 lines

Looks better, thanks.

Quoted 5 lines
---
  drivers/mmc/host/sdhci-msm.c | 207 +++++++++++++++++++++++++++++++++++++++++--
  1 file changed, 198 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +0 -0

[..]

Quoted 5 lines

static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)

drivers/mmc/host/sdhci-msm.c +1 -0
@@ -1298,6 +1302,71 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
  		sdhci_msm_hs400(host, &mmc->ios);
  }
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1314

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+{
+	int ret;
+
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vmmc set ocr with vdd=%d failed: %d\n",
+			mmc_hostname(mmc), mmc->ios.vdd, ret);

Missed this one on v1, in the event that mmc_regulator_set_ocr() return a non-zero value it has already printed an error message. So please replace the tail with just:

	return mmc_regulator_set_ocr(...);
Quoted 12 lines
drivers/mmc/host/sdhci-msm.c +12 -0
+
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int load, ret;
+	struct mmc_ios ios;
+
+	if (IS_ERR(mmc->supply.vqmmc)			 ||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED) ||
Quoted 8 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1333

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+	    (msm_host->vqmmc_enabled == level))
+		return 0;
+
+	if (msm_host->vqmmc_load) {
+		load = level ? msm_host->vqmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vqmmc, load);

Sorry for the late reply on v1, but please see my explanation regarding load and always-on regulators there.

<Merging your comment from V1 here>

Quoted 11 lines
Quoted 11 lines

You should still call regulator_enable()/regulator_disable() on your consumer regulator in this driver. When you do this the regulator core will conclude that the regulator_dev (i.e. the part that represents the hardware) is marked always_on and will not enable/disable the regulator.

But it will still invoke _regulator_handle_consumer_enable() and _regulator_handle_consumer_disable(), which will aggregate the "load" of all client regulators and update the regulator's load.

So this will apply the load as you expect regardless of it being supplied by a regulator marked as always_on.

Quoted 10 lines

Since I'm not turning off this regulator for eMMC, I wanted to keep it in LPM mode
to save some power.
When the regulator configured in auto mode (RPMH_REGULATOR_MODE_AUTO) it switches to LPM/HPM mode based on the active load.
So i have to minimize my driver load requirement so that I can let this regulator
in LPM mode.
So i need to set load every-time I disable/enable the regulator.

You call regulator_enable(vqmmc) and regulator_disable() below, so you are telling the regulator framework that your struct regulator should be "on" or "off".

This will cause the sum of all struct regulator's for the underlying struct regulator_dev to be recalculated. So after calling regulator_disable() below your effective addition to the load calculation is 0, regardless of which load you have specified.

Independent of this the property regulator-always-on (always_on in struct regulator_dev) will determine if the enable/disable request will actually be sent to the RPMh.

So, if you where to not call regulator_disable() for eMMC your argument is correct, but as far as I can see you are and you're relying on the regulator core to keep it always-on - and then the load logic is in effect still.

Regards,
Bjorn

Quoted 35 lines
Quoted 35 lines
Quoted 35 lines
drivers/mmc/host/sdhci-msm.c +35 -0
+		if (ret) {
+			dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+				mmc_hostname(mmc), ret);
+			goto out;
+		}
+	}
+
+	if (level) {
+		/* Set the IO voltage regulator to default voltage level */
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0) {
+				dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+					mmc_hostname(mmc), ret);
+				goto out;
+			}
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}
+
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+			mmc_hostname(mmc), level ? "en":"dis", ret);
+	else
+		msm_host->vqmmc_enabled = level;
+out:
+	return ret;
+}
maintainer Acked-by on v2 3/3
#19 lore raw

Re: [PATCH V2 3/3] mmc: sdhci: Allow platform controlled voltage switching

In reply to Veerabhadrarao Badiganti
Quoted 8 lines · Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

If vendor platform drivers are controlling whole logic of voltage switching, then sdhci driver no need control vqmmc regulator. So skip enabling/disable vqmmc from SDHC driver.

Quoted 103 lines
---
 drivers/mmc/host/sdhci.c | 32 +++++++++++++++++++-------------
 drivers/mmc/host/sdhci.h |  1 +
 2 files changed, 20 insertions(+), 13 deletions(-)
drivers/mmc/host/sdhci.c +19 -13
index 1bb6b67..88e5312 100644
@@ -4098,6 +4098,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	unsigned int override_timeout_clk;
 	u32 max_clk;
 	int ret;
+	bool enable_vqmmc = false;
 
 	WARN_ON(host == NULL);
 	if (host == NULL)
@@ -4111,9 +4112,12 @@ int sdhci_setup_host(struct sdhci_host *host)
 	 * the host can take the appropriate action if regulators are not
 	 * available.
 	 */
-	ret = mmc_regulator_get_supply(mmc);
-	if (ret)
-		return ret;
+	if (!mmc->supply.vqmmc) {
+		ret = mmc_regulator_get_supply(mmc);
+		if (ret)
+			return ret;
+		enable_vqmmc  = true;
+	}
 
 	DBG("Version:   0x%08x | Present:  0x%08x\n",
 	    sdhci_readw(host, SDHCI_HOST_VERSION),
@@ -4373,7 +4377,15 @@ int sdhci_setup_host(struct sdhci_host *host)
 		mmc->caps |= MMC_CAP_NEEDS_POLL;
 
 	if (!IS_ERR(mmc->supply.vqmmc)) {
-		ret = regulator_enable(mmc->supply.vqmmc);
+		if (enable_vqmmc) {
+			ret = regulator_enable(mmc->supply.vqmmc);
+			if (ret) {
+				pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
+					mmc_hostname(mmc), ret);
+				mmc->supply.vqmmc = ERR_PTR(-EINVAL);
+			}
+			host->sdhci_core_to_disable_vqmmc = !ret;
+		}
 
 		/* If vqmmc provides no 1.8V signalling, then there's no UHS */
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000,
@@ -4386,12 +4398,6 @@ int sdhci_setup_host(struct sdhci_host *host)
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000,
 						    3600000))
 			host->flags &= ~SDHCI_SIGNALING_330;
-
-		if (ret) {
-			pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
-				mmc_hostname(mmc), ret);
-			mmc->supply.vqmmc = ERR_PTR(-EINVAL);
-		}
 	}
 
 	if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) {
@@ -4625,7 +4631,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	return 0;
 
 unreg:
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 undma:
 	if (host->align_buffer)
@@ -4643,7 +4649,7 @@ void sdhci_cleanup_host(struct sdhci_host *host)
 {
 	struct mmc_host *mmc = host->mmc;
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
@@ -4780,7 +4786,7 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 
 	destroy_workqueue(host->complete_wq);
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
drivers/mmc/host/sdhci.h +1 -0
index 8d2a096..c7dbc68 100644
@@ -570,6 +570,7 @@ struct sdhci_host {
 	u32 caps1;		/* CAPABILITY_1 */
 	bool read_caps;		/* Capability flags have been read */
 
+	bool sdhci_core_to_disable_vqmmc;  /* sdhci core can disable vqmmc */
 	unsigned int            ocr_avail_sdio;	/* OCR bit masks */
 	unsigned int            ocr_avail_sd;
 	unsigned int            ocr_avail_mmc;
#17 lore raw

Re: [PATCH V2 2/3] mmc: sdhci-msm: Use internal voltage control

In reply to Bjorn Andersson
Quoted 107 lines · Bjorn Andersson
Quoted 81 lines · Veerabhadrarao Badiganti

Hi Bjorn,

Quoted 59 lines · Bjorn Andersson
Quoted 10 lines · Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

Set the regulator load as well so that regulator can be configured in LPM mode when in is not being used.

Quoted 6 lines

Looks better, thanks.

Quoted 5 lines
---
   drivers/mmc/host/sdhci-msm.c | 207 +++++++++++++++++++++++++++++++++++++++++--
   1 file changed, 198 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +0 -0

[..]

Quoted 5 lines

static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)

drivers/mmc/host/sdhci-msm.c +1 -0
@@ -1298,6 +1302,71 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
   		sdhci_msm_hs400(host, &mmc->ios);
   }
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1314

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+{
+	int ret;
+
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vmmc set ocr with vdd=%d failed: %d\n",
+			mmc_hostname(mmc), mmc->ios.vdd, ret);

Missed this one on v1, in the event that mmc_regulator_set_ocr() return a non-zero value it has already printed an error message. So please replace the tail with just:

	return mmc_regulator_set_ocr(...);
Quoted 12 lines
drivers/mmc/host/sdhci-msm.c +12 -0
+
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int load, ret;
+	struct mmc_ios ios;
+
+	if (IS_ERR(mmc->supply.vqmmc)			 ||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED) ||
Quoted 8 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1333

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +6 -0
+	    (msm_host->vqmmc_enabled == level))
+		return 0;
+
+	if (msm_host->vqmmc_load) {
+		load = level ? msm_host->vqmmc_load : 0;
+		ret = regulator_set_load(mmc->supply.vqmmc, load);

Sorry for the late reply on v1, but please see my explanation regarding load and always-on regulators there.

<Merging your comment from V1 here>

Quoted 9 lines
Quoted 9 lines

You should still call regulator_enable()/regulator_disable() on your consumer regulator in this driver. When you do this the regulator core will conclude that the regulator_dev (i.e. the part that represents the hardware) is marked always_on and will not enable/disable the regulator. But it will still invoke _regulator_handle_consumer_enable() and _regulator_handle_consumer_disable(), which will aggregate the "load" of all client regulators and update the regulator's load.
So this will apply the load as you expect regardless of it being supplied by a regulator marked as always_on.

Quoted 10 lines

Since I'm not turning off this regulator for eMMC, I wanted to keep it in LPM mode
to save some power.
When the regulator configured in auto mode (RPMH_REGULATOR_MODE_AUTO) it switches to LPM/HPM mode based on the active load.
So i have to minimize my driver load requirement so that I can let this regulator
in LPM mode.
So i need to set load every-time I disable/enable the regulator.

You call regulator_enable(vqmmc) and regulator_disable() below, so you are telling the regulator framework that your struct regulator should be "on" or "off".

This will cause the sum of all struct regulator's for the underlying struct regulator_dev to be recalculated. So after calling regulator_disable() below your effective addition to the load calculation is 0, regardless of which load you have specified.

Independent of this the property regulator-always-on (always_on in struct regulator_dev) will determine if the enable/disable request will actually be sent to the RPMh.

Quoted 4 lines

So, if you where to not call regulator_disable() for eMMC your argument is correct, but as far as I can see you are and you're relying on the regulator core to keep it always-on - and then the load logic is in effect still.

Thanks for the details Bjorn.
My requirement is, for eMMC i shouldn't be turning this regulator off. But has to configure in LPM mode. For SD-card, i have to turn-off this regulator.
So I'm planning to update the logic as below, let me know if you have any other suggestions.

+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host, +                             struct mmc_host *mmc, bool level) +{
+       int ret;
+       bool always_on;
+
+       if (IS_ERR(mmc->supply.vqmmc)           ||
+           (mmc->ios.power_mode == MMC_POWER_UNDEFINED))
+               return 0;
+       /*
+        * For eMMC don't turn off Vqmmc, Instead just configure it in LPM +        * and HPM modes by setting the right amount of load. +        */
+       always_on = mmc->card && mmc_card_mmc(mmc->card);
+
+       if (always_on)
+               ret = msm_config_vqmmc_mode(msm_host, mmc, level); +       else
+               ret = msm_toggle_vqmmc(msm_host, mmc, level); +
+       return ret;
+}

Quoted 38 lines

Regards,
Bjorn

Quoted 35 lines
Quoted 35 lines
Quoted 35 lines
drivers/mmc/host/sdhci-msm.c +35 -0
+		if (ret) {
+			dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+				mmc_hostname(mmc), ret);
+			goto out;
+		}
+	}
+
+	if (level) {
+		/* Set the IO voltage regulator to default voltage level */
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0) {
+				dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+					mmc_hostname(mmc), ret);
+				goto out;
+			}
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}
+
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+			mmc_hostname(mmc), level ? "en":"dis", ret);
+	else
+		msm_host->vqmmc_enabled = level;
+out:
+	return ret;
+}
maintainer
#12 lore raw

Re: [PATCH V2 1/3] dt-bindings: mmc: Supply max load for mmc supplies

In reply to Veerabhadrarao Badiganti
Quoted 12 lines · Veerabhadrarao Badiganti

Supply the max load needed for driving the mmc supplies.

---
 .../devicetree/bindings/mmc/mmc-controller.yaml          | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
Documentation/devicetree/bindings/mmc/mmc-controller.yaml +0 -0
index acc9f10..9058b82 100644

Documentation/devicetree/bindings/mmc/mmc-controller.yaml properties: · line 293

Quoted 4 lines
Documentation/devicetree/bindings/mmc/mmc-controller.yaml +1 -0
@@ -290,6 +290,22 @@ properties:
     description:
       Supply for the bus IO line power
 
+  vmmc-max-load-microamp:

Seems like this should be a common regulator property (it would have to be a suffix to match up with *-supply).

Documentation/devicetree/bindings/mmc/mmc-controller.yaml properties: · line 295

Quoted 2 lines
Documentation/devicetree/bindings/mmc/mmc-controller.yaml +2 -0
+    allOf:
+      - $ref: /schemas/types.yaml#/definitions/uint32

Properties with unit suffix already have a type.

Quoted 19 lines
Documentation/devicetree/bindings/mmc/mmc-controller.yaml +13 -0
+      - minimum: 0
+      - maximum: 1000000
+    description:
+      Maximum load for the card power.
+
+  vqmmc-max-load-microamp:
+    allOf:
+      - $ref: /schemas/types.yaml#/definitions/uint32
+      - minimum: 0
+      - maximum: 1000000
+    description:
+      Maximum load for the bus IO line power.
+
   mmc-pwrseq:
     $ref: /schemas/types.yaml#/definitions/phandle
     description:
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#21 lore raw

PATCH v3 1/3 dt-bindings: mmc: Supply max load for mmc supplies

In reply to Veerabhadrarao Badiganti

Supply the max load needed for driving the mmc supplies.

---
 Documentation/devicetree/bindings/mmc/mmc-controller.yaml | 6 ++++++
 1 file changed, 6 insertions(+)
Documentation/devicetree/bindings/mmc/mmc-controller.yaml +6 -0
index acc9f10871d4..d95219721fa1 100644
@@ -290,6 +290,12 @@ properties:
     description:
       Supply for the bus IO line power
 
+  vmmc-supply-max-microamp:
+    description: Maximum load for the card power.
+
+  vqmmc-supply-max-microamp:
+    description: Maximum load for the bus IO line power.
+
   mmc-pwrseq:
     $ref: /schemas/types.yaml#/definitions/phandle
     description:
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#24 lore raw

PATCH v3 2/3 mmc: sdhci: Allow platform controlled voltage switching

In reply to Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

If vendor platform drivers are controlling whole logic of voltage switching, then sdhci driver no need control vqmmc regulator. So skip enabling/disable vqmmc from SDHC driver.

---
 drivers/mmc/host/sdhci.c | 32 +++++++++++++++++++-------------
 drivers/mmc/host/sdhci.h |  1 +
 2 files changed, 20 insertions(+), 13 deletions(-)
drivers/mmc/host/sdhci.c +19 -13
index 37b1158c1c0c..e6275c2202b0 100644
@@ -4105,6 +4105,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	unsigned int override_timeout_clk;
 	u32 max_clk;
 	int ret;
+	bool enable_vqmmc = false;
 
 	WARN_ON(host == NULL);
 	if (host == NULL)
@@ -4118,9 +4119,12 @@ int sdhci_setup_host(struct sdhci_host *host)
 	 * the host can take the appropriate action if regulators are not
 	 * available.
 	 */
-	ret = mmc_regulator_get_supply(mmc);
-	if (ret)
-		return ret;
+	if (!mmc->supply.vqmmc) {
+		ret = mmc_regulator_get_supply(mmc);
+		if (ret)
+			return ret;
+		enable_vqmmc  = true;
+	}
 
 	DBG("Version:   0x%08x | Present:  0x%08x\n",
 	    sdhci_readw(host, SDHCI_HOST_VERSION),
@@ -4377,7 +4381,15 @@ int sdhci_setup_host(struct sdhci_host *host)
 		mmc->caps |= MMC_CAP_NEEDS_POLL;
 
 	if (!IS_ERR(mmc->supply.vqmmc)) {
-		ret = regulator_enable(mmc->supply.vqmmc);
+		if (enable_vqmmc) {
+			ret = regulator_enable(mmc->supply.vqmmc);
+			if (ret) {
+				pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
+					mmc_hostname(mmc), ret);
+				mmc->supply.vqmmc = ERR_PTR(-EINVAL);
+			}
+			host->sdhci_core_to_disable_vqmmc = !ret;
+		}
 
 		/* If vqmmc provides no 1.8V signalling, then there's no UHS */
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000,
@@ -4390,12 +4402,6 @@ int sdhci_setup_host(struct sdhci_host *host)
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000,
 						    3600000))
 			host->flags &= ~SDHCI_SIGNALING_330;
-
-		if (ret) {
-			pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
-				mmc_hostname(mmc), ret);
-			mmc->supply.vqmmc = ERR_PTR(-EINVAL);
-		}
 	}
 
 	if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) {
@@ -4626,7 +4632,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	return 0;
 
 unreg:
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 undma:
 	if (host->align_buffer)
@@ -4644,7 +4650,7 @@ void sdhci_cleanup_host(struct sdhci_host *host)
 {
 	struct mmc_host *mmc = host->mmc;
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
@@ -4787,7 +4793,7 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 
 	destroy_workqueue(host->complete_wq);
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
drivers/mmc/host/sdhci.h +1 -0
index 0008bbd27127..0770c036e2ff 100644
@@ -567,6 +567,7 @@ struct sdhci_host {
 	u32 caps1;		/* CAPABILITY_1 */
 	bool read_caps;		/* Capability flags have been read */
 
+	bool sdhci_core_to_disable_vqmmc;  /* sdhci core can disable vqmmc */
 	unsigned int            ocr_avail_sdio;	/* OCR bit masks */
 	unsigned int            ocr_avail_sd;
 	unsigned int            ocr_avail_mmc;
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#20 lore raw

v3 cover Internal voltage control for qcom SDHC

In reply to Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

So added support to register voltage regulators from the msm driver and use them.

This patchset was posted long back but not actively pursued
https://lore.kernel.org/linux-arm-msm/[email protected]/
So posting it as fresh patchset.

Changes since V2:
- Removed redundant log from sdhci_msm_set_vmmc.
- Added the condition for skiping disabling of vqmmc for eMMC.
- Updated logic such that, setting load for vqmmc only if it is kept ON.
- Retained ack by Adrian for second patch.
- Updated dt properties names as per Robs comments.

Changes since V1:
- Removed setting load for Vmmc regulator while turning it on/off. Instead setting the active load once during probe.
- Simplified handlng of supplies for BUS_ON/OFF cases in shci_msm_handle_pwr_irq().
- Moved common code out of switch case in sdhci_msm_start_signal_voltage_switch().
- Updated variable name to sdhci_core_to_disable_vqmmc.
- Updated pr_err logs to dev_err logs.

Veerabhadrarao Badiganti (2):
dt-bindings: mmc: Supply max load for mmc supplies
mmc: sdhci-msm: Use internal voltage control

Vijay Viswanath (1):
mmc: sdhci: Allow platform controlled voltage switching

 .../devicetree/bindings/mmc/mmc-controller.yaml    |   6 +
 drivers/mmc/host/sdhci-msm.c                       | 235 ++++++++++++++++++++-
 drivers/mmc/host/sdhci.c                           |  32 +--
 drivers/mmc/host/sdhci.h                           |   1 +
 4 files changed, 252 insertions(+), 22 deletions(-)
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#25 lore raw

PATCH v3 3/3 mmc: sdhci-msm: Use internal voltage control

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

Set the regulator load as well so that regulator can be configured in LPM mode when in is not being used.

---
 drivers/mmc/host/sdhci-msm.c | 235 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 226 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +226 -9
index 95cd9735e9a3..20ef90fc7dd7 100644
@@ -36,7 +36,9 @@
 #define CORE_PWRCTL_IO_LOW	BIT(2)
 #define CORE_PWRCTL_IO_HIGH	BIT(3)
 #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
 #define CORE_PWRCTL_IO_SUCCESS	BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
 #define REQ_BUS_OFF		BIT(0)
 #define REQ_BUS_ON		BIT(1)
 #define REQ_IO_LOW		BIT(2)
@@ -277,6 +279,8 @@ struct sdhci_msm_host {
 	bool uses_tassadar_dll;
 	u32 dll_config;
 	u32 ddr_config;
+	u32 vqmmc_load;
+	bool vqmmc_enabled;
 };
 
 static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1339,6 +1343,91 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
 		sdhci_msm_hs400(host, &mmc->ios);
 }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)
+{
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	return mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+}
+
+static int msm_toggle_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int ret;
+	struct mmc_ios ios;
+
+	if (msm_host->vqmmc_enabled == level)
+		return 0;
+
+	if (level) {
+		/* Set the IO voltage regulator to default voltage level */
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0) {
+				dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+					mmc_hostname(mmc), ret);
+				goto out;
+			}
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}
+
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+			mmc_hostname(mmc), level ? "en":"dis", ret);
+	else
+		msm_host->vqmmc_enabled = level;
+out:
+	return ret;
+}
+
+static int msm_config_vqmmc_mode(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool hpm)
+{
+	int load, ret;
+
+	if (!msm_host->vqmmc_load)
+		return 0;
+
+	load = hpm ? msm_host->vqmmc_load : 0;
+	ret = regulator_set_load(mmc->supply.vqmmc, load);
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+			mmc_hostname(mmc), ret);
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int ret;
+	bool always_on;
+
+	if (IS_ERR(mmc->supply.vqmmc)		||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED))
+		return 0;
+	/*
+	 * For eMMC don't turn off Vqmmc, Instead just configure it in LPM
+	 * and HPM modes by setting the right amonut of load.
+	 */
+	always_on = mmc->card && mmc_card_mmc(mmc->card);
+
+	if (always_on)
+		ret = msm_config_vqmmc_mode(msm_host, mmc, level);
+	else
+		ret = msm_toggle_vqmmc(msm_host, mmc, level);
+
+	return ret;
+}
+
 static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
 {
 	init_waitqueue_head(&msm_host->pwr_irq_wait);
@@ -1442,8 +1531,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 {
 	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 	struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+	struct mmc_host *mmc = host->mmc;
 	u32 irq_status, irq_ack = 0;
-	int retry = 10;
+	int retry = 10, ret;
 	u32 pwr_state = 0, io_level = 0;
 	u32 config;
 	const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1481,21 +1571,42 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 	if (irq_status & CORE_PWRCTL_BUS_ON) {
 		pwr_state = REQ_BUS_ON;
 		io_level = REQ_IO_HIGH;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
 	}
 	if (irq_status & CORE_PWRCTL_BUS_OFF) {
 		pwr_state = REQ_BUS_OFF;
 		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
 	}
+
+	if (pwr_state) {
+		ret = sdhci_msm_set_vmmc(mmc);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc,
+					pwr_state & REQ_BUS_ON);
+		if (!ret)
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		else
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+	}
+
 	/* Handle IO LOW/HIGH */
-	if (irq_status & CORE_PWRCTL_IO_LOW) {
+	if (irq_status & CORE_PWRCTL_IO_LOW)
 		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
-	}
-	if (irq_status & CORE_PWRCTL_IO_HIGH) {
+
+	if (irq_status & CORE_PWRCTL_IO_HIGH)
 		io_level = REQ_IO_HIGH;
+
+	if (io_level)
 		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
+
+	if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+		ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);
+		if (ret < 0) {
+			dev_err(mmc_dev(mmc), "%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret,
+					mmc->ios.signal_voltage, mmc->ios.vdd,
+					irq_status);
+			irq_ack |= CORE_PWRCTL_IO_FAIL;
+		}
 	}
 
 	/*
@@ -1544,7 +1655,7 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 	if (io_level)
 		msm_host->curr_io_level = io_level;
 
-	pr_debug("%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
+	dev_dbg(mmc_dev(mmc), "%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
 		mmc_hostname(msm_host->mmc), __func__, irq, irq_status,
 		irq_ack);
 }
@@ -1874,6 +1985,106 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
 	sdhci_reset(host, mask);
 }
 
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
+{
+	int ret;
+	u32 vmmc_load;
+	struct mmc_host *mmc = msm_host->mmc;
+
+	ret = mmc_regulator_get_supply(msm_host->mmc);
+	if (ret)
+		return ret;
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vmmc-supply-max-microamp",
+			&vmmc_load);
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vqmmc-supply-max-microamp",
+			&msm_host->vqmmc_load);
+
+	/* Set active load */
+	if (!IS_ERR(mmc->supply.vmmc) && vmmc_load) {
+		ret = regulator_set_load(mmc->supply.vmmc, vmmc_load);
+		if (ret) {
+			dev_err(mmc_dev(mmc), "%s: vmmc set active load failed: %d\n",
+				mmc_hostname(mmc), ret);
+			return ret;
+		}
+	}
+	if (!IS_ERR(mmc->supply.vqmmc) && msm_host->vqmmc_load) {
+		ret = regulator_set_load(mmc->supply.vmmc,
+					msm_host->vqmmc_load);
+		if (ret) {
+			dev_err(mmc_dev(mmc), "%s: vqmmc set active load failed: %d\n",
+				mmc_hostname(mmc), ret);
+			return ret;
+		}
+	}
+
+	sdhci_msm_set_regulator_caps(msm_host);
+	mmc->ios.power_mode = MMC_POWER_UNDEFINED;
+
+	return 0;
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl, status;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
+			return -EINVAL;
+
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_180:
+		if (!(host->flags & SDHCI_SIGNALING_180))
+			return -EINVAL;
+
+		/*
+		 * Enable 1.8V Signal Enable in the Host Control2
+		 * register
+		 */
+		ctrl |= SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_120:
+		if (!(host->flags & SDHCI_SIGNALING_120))
+			return -EINVAL;
+		return 0;
+	default:
+		/* No signal voltage switch required */
+		return 0;
+	}
+
+	sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+	/* Wait for 5ms */
+	usleep_range(5000, 5500);
+
+	/* regulator output should be stable within 5 ms */
+	status = ctrl & SDHCI_CTRL_VDD_180;
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+	if ((ctrl & SDHCI_CTRL_VDD_180) == status)
+		return 0;
+
+	dev_warn(mmc_dev(mmc), "%s: Regulator output did not became stable\n",
+		mmc_hostname(mmc));
+
+	return -EAGAIN;
+}
+
 #define DRIVER_NAME "sdhci_msm"
 #define SDHCI_MSM_DUMP(f, x...) \
 	pr_err("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)
@@ -1960,6 +2171,7 @@ void sdhci_msm_dump_vendor_regs(struct sdhci_host *host)
 	.write_b = sdhci_msm_writeb,
 	.irq	= sdhci_msm_cqe_irq,
 	.dump_vendor_regs = sdhci_msm_dump_vendor_regs,
+	.set_power = sdhci_set_power_noreg,
 };
 
 static const struct sdhci_pltfm_data sdhci_msm_pdata = {
@@ -2169,6 +2381,10 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 	if (core_major == 1 && core_minor >= 0x49)
 		msm_host->updated_ddr_cfg = true;
 
+	ret = sdhci_msm_register_vreg(msm_host);
+	if (ret)
+		goto clk_disable;
+
 	/*
 	 * Power on reset state may trigger power irq if previous status of
 	 * PWRCTL was either BUS_ON or IO_HIGH_V. So before enabling pwr irq
@@ -2213,6 +2429,8 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 					 MSM_MMC_AUTOSUSPEND_DELAY_MS);
 	pm_runtime_use_autosuspend(&pdev->dev);
 
+	host->mmc_host_ops.start_signal_voltage_switch =
+		sdhci_msm_start_signal_voltage_switch;
 	host->mmc_host_ops.execute_tuning = sdhci_msm_execute_tuning;
 	if (of_property_read_bool(node, "supports-cqe"))
 		ret = sdhci_msm_cqe_add_host(host, pdev);
@@ -2220,7 +2438,6 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 		ret = sdhci_add_host(host);
 	if (ret)
 		goto pm_runtime_disable;
-	sdhci_msm_set_regulator_caps(msm_host);
 
 	pm_runtime_mark_last_busy(&pdev->dev);
 	pm_runtime_put_autosuspend(&pdev->dev);
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#26 lore raw

Re: [PATCH V3 3/3] mmc: sdhci-msm: Use internal voltage control

Hi Bjorn,

Do you have any comments on V3 patchset?

Thanks
Veera

Quoted 347 lines · Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

Set the regulator load as well so that regulator can be configured in LPM mode when in is not being used.

---
  drivers/mmc/host/sdhci-msm.c | 235 +++++++++++++++++++++++++++++++++++++++++--
  1 file changed, 226 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +226 -9
index 95cd9735e9a3..20ef90fc7dd7 100644
@@ -36,7 +36,9 @@
  #define CORE_PWRCTL_IO_LOW	BIT(2)
  #define CORE_PWRCTL_IO_HIGH	BIT(3)
  #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
  #define CORE_PWRCTL_IO_SUCCESS	BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
  #define REQ_BUS_OFF		BIT(0)
  #define REQ_BUS_ON		BIT(1)
  #define REQ_IO_LOW		BIT(2)
@@ -277,6 +279,8 @@ struct sdhci_msm_host {
  	bool uses_tassadar_dll;
  	u32 dll_config;
  	u32 ddr_config;
+	u32 vqmmc_load;
+	bool vqmmc_enabled;
  };
 
  static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1339,6 +1343,91 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
  		sdhci_msm_hs400(host, &mmc->ios);
  }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)
+{
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	return mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+}
+
+static int msm_toggle_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int ret;
+	struct mmc_ios ios;
+
+	if (msm_host->vqmmc_enabled == level)
+		return 0;
+
+	if (level) {
+		/* Set the IO voltage regulator to default voltage level */
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0) {
+				dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+					mmc_hostname(mmc), ret);
+				goto out;
+			}
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}
+
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+			mmc_hostname(mmc), level ? "en":"dis", ret);
+	else
+		msm_host->vqmmc_enabled = level;
+out:
+	return ret;
+}
+
+static int msm_config_vqmmc_mode(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool hpm)
+{
+	int load, ret;
+
+	if (!msm_host->vqmmc_load)
+		return 0;
+
+	load = hpm ? msm_host->vqmmc_load : 0;
+	ret = regulator_set_load(mmc->supply.vqmmc, load);
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+			mmc_hostname(mmc), ret);
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int ret;
+	bool always_on;
+
+	if (IS_ERR(mmc->supply.vqmmc)		||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED))
+		return 0;
+	/*
+	 * For eMMC don't turn off Vqmmc, Instead just configure it in LPM
+	 * and HPM modes by setting the right amonut of load.
+	 */
+	always_on = mmc->card && mmc_card_mmc(mmc->card);
+
+	if (always_on)
+		ret = msm_config_vqmmc_mode(msm_host, mmc, level);
+	else
+		ret = msm_toggle_vqmmc(msm_host, mmc, level);
+
+	return ret;
+}
+
  static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
  {
  	init_waitqueue_head(&msm_host->pwr_irq_wait);
@@ -1442,8 +1531,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
  {
  	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
  	struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+	struct mmc_host *mmc = host->mmc;
  	u32 irq_status, irq_ack = 0;
-	int retry = 10;
+	int retry = 10, ret;
  	u32 pwr_state = 0, io_level = 0;
  	u32 config;
  	const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1481,21 +1571,42 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
  	if (irq_status & CORE_PWRCTL_BUS_ON) {
  		pwr_state = REQ_BUS_ON;
  		io_level = REQ_IO_HIGH;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
  	}
  	if (irq_status & CORE_PWRCTL_BUS_OFF) {
  		pwr_state = REQ_BUS_OFF;
  		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
  	}
+
+	if (pwr_state) {
+		ret = sdhci_msm_set_vmmc(mmc);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc,
+					pwr_state & REQ_BUS_ON);
+		if (!ret)
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		else
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+	}
+
  	/* Handle IO LOW/HIGH */
-	if (irq_status & CORE_PWRCTL_IO_LOW) {
+	if (irq_status & CORE_PWRCTL_IO_LOW)
  		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
-	}
-	if (irq_status & CORE_PWRCTL_IO_HIGH) {
+
+	if (irq_status & CORE_PWRCTL_IO_HIGH)
  		io_level = REQ_IO_HIGH;
+
+	if (io_level)
  		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
+
+	if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+		ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);
+		if (ret < 0) {
+			dev_err(mmc_dev(mmc), "%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret,
+					mmc->ios.signal_voltage, mmc->ios.vdd,
+					irq_status);
+			irq_ack |= CORE_PWRCTL_IO_FAIL;
+		}
  	}
 
  	/*
@@ -1544,7 +1655,7 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
  	if (io_level)
  		msm_host->curr_io_level = io_level;
 
-	pr_debug("%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
+	dev_dbg(mmc_dev(mmc), "%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
  		mmc_hostname(msm_host->mmc), __func__, irq, irq_status,
  		irq_ack);
  }
@@ -1874,6 +1985,106 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
  	sdhci_reset(host, mask);
  }
 
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
+{
+	int ret;
+	u32 vmmc_load;
+	struct mmc_host *mmc = msm_host->mmc;
+
+	ret = mmc_regulator_get_supply(msm_host->mmc);
+	if (ret)
+		return ret;
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vmmc-supply-max-microamp",
+			&vmmc_load);
+	device_property_read_u32(&msm_host->pdev->dev,
+			"vqmmc-supply-max-microamp",
+			&msm_host->vqmmc_load);
+
+	/* Set active load */
+	if (!IS_ERR(mmc->supply.vmmc) && vmmc_load) {
+		ret = regulator_set_load(mmc->supply.vmmc, vmmc_load);
+		if (ret) {
+			dev_err(mmc_dev(mmc), "%s: vmmc set active load failed: %d\n",
+				mmc_hostname(mmc), ret);
+			return ret;
+		}
+	}
+	if (!IS_ERR(mmc->supply.vqmmc) && msm_host->vqmmc_load) {
+		ret = regulator_set_load(mmc->supply.vmmc,
+					msm_host->vqmmc_load);
+		if (ret) {
+			dev_err(mmc_dev(mmc), "%s: vqmmc set active load failed: %d\n",
+				mmc_hostname(mmc), ret);
+			return ret;
+		}
+	}
+
+	sdhci_msm_set_regulator_caps(msm_host);
+	mmc->ios.power_mode = MMC_POWER_UNDEFINED;
+
+	return 0;
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl, status;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
+			return -EINVAL;
+
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_180:
+		if (!(host->flags & SDHCI_SIGNALING_180))
+			return -EINVAL;
+
+		/*
+		 * Enable 1.8V Signal Enable in the Host Control2
+		 * register
+		 */
+		ctrl |= SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_120:
+		if (!(host->flags & SDHCI_SIGNALING_120))
+			return -EINVAL;
+		return 0;
+	default:
+		/* No signal voltage switch required */
+		return 0;
+	}
+
+	sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+	/* Wait for 5ms */
+	usleep_range(5000, 5500);
+
+	/* regulator output should be stable within 5 ms */
+	status = ctrl & SDHCI_CTRL_VDD_180;
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+	if ((ctrl & SDHCI_CTRL_VDD_180) == status)
+		return 0;
+
+	dev_warn(mmc_dev(mmc), "%s: Regulator output did not became stable\n",
+		mmc_hostname(mmc));
+
+	return -EAGAIN;
+}
+
  #define DRIVER_NAME "sdhci_msm"
  #define SDHCI_MSM_DUMP(f, x...) \
  	pr_err("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)
@@ -1960,6 +2171,7 @@ void sdhci_msm_dump_vendor_regs(struct sdhci_host *host)
  	.write_b = sdhci_msm_writeb,
  	.irq	= sdhci_msm_cqe_irq,
  	.dump_vendor_regs = sdhci_msm_dump_vendor_regs,
+	.set_power = sdhci_set_power_noreg,
  };
 
  static const struct sdhci_pltfm_data sdhci_msm_pdata = {
@@ -2169,6 +2381,10 @@ static int sdhci_msm_probe(struct platform_device *pdev)
  	if (core_major == 1 && core_minor >= 0x49)
  		msm_host->updated_ddr_cfg = true;
 
+	ret = sdhci_msm_register_vreg(msm_host);
+	if (ret)
+		goto clk_disable;
+
  	/*
  	 * Power on reset state may trigger power irq if previous status of
  	 * PWRCTL was either BUS_ON or IO_HIGH_V. So before enabling pwr irq
@@ -2213,6 +2429,8 @@ static int sdhci_msm_probe(struct platform_device *pdev)
  					 MSM_MMC_AUTOSUSPEND_DELAY_MS);
  	pm_runtime_use_autosuspend(&pdev->dev);
 
+	host->mmc_host_ops.start_signal_voltage_switch =
+		sdhci_msm_start_signal_voltage_switch;
  	host->mmc_host_ops.execute_tuning = sdhci_msm_execute_tuning;
  	if (of_property_read_bool(node, "supports-cqe"))
  		ret = sdhci_msm_cqe_add_host(host, pdev);
@@ -2220,7 +2438,6 @@ static int sdhci_msm_probe(struct platform_device *pdev)
  		ret = sdhci_add_host(host);
  	if (ret)
  		goto pm_runtime_disable;
-	sdhci_msm_set_regulator_caps(msm_host);
 
  	pm_runtime_mark_last_busy(&pdev->dev);
  	pm_runtime_put_autosuspend(&pdev->dev);
maintainer
#22 lore raw

Re: [PATCH V3 1/3] dt-bindings: mmc: Supply max load for mmc supplies

In reply to Veerabhadrarao Badiganti

+Mark B

Quoted 12 lines · Veerabhadrarao Badiganti

Supply the max load needed for driving the mmc supplies.

---
 Documentation/devicetree/bindings/mmc/mmc-controller.yaml | 6 ++++++
 1 file changed, 6 insertions(+)
Documentation/devicetree/bindings/mmc/mmc-controller.yaml +0 -0
index acc9f10871d4..d95219721fa1 100644

Documentation/devicetree/bindings/mmc/mmc-controller.yaml properties: · line 297

Quoted 8 lines
Documentation/devicetree/bindings/mmc/mmc-controller.yaml +5 -0
@@ -290,6 +290,12 @@ properties:
     description:
       Supply for the bus IO line power
 
+  vmmc-supply-max-microamp:
+    description: Maximum load for the card power.
+
+  vqmmc-supply-max-microamp:
+    description: Maximum load for the bus IO line power.

By a 'common regulator property' I meant documented with regulator binding like *-supply, not common to MMC. How is MMC special?

Thinking about this some more, what's wrong with the max current in the regulator nodes? I suppose you could have more than one load and need to define the loads separately?

Rob

#23 lore raw

Re: [PATCH V3 1/3] dt-bindings: mmc: Supply max load for mmc supplies

Quoted 10 lines · Rob Herring

Documentation/devicetree/bindings/mmc/mmc-controller.yaml properties: · line 297

Quoted 5 lines · Veerabhadrarao Badiganti
Documentation/devicetree/bindings/mmc/mmc-controller.yaml +4 -0
+  vmmc-supply-max-microamp:
+    description: Maximum load for the card power.
 
+  vqmmc-supply-max-microamp:
+    description: Maximum load for the bus IO line power.

By a 'common regulator property' I meant documented with regulator binding like *-supply, not common to MMC. How is MMC special?

TBH I'm surprised that these aren't defined by the MMC spec or by the ID information from the part we find connected - I'd not expect the board to be defining these at all.

Quoted 3 lines

Thinking about this some more, what's wrong with the max current in the regulator nodes? I suppose you could have more than one load and need to define the loads separately?

One of the bigger reasons to think about the loads would be to dynamically configure the mode the regulator is in to go into a more efficient mode when some of the devices attached to it are turned off.

#27 lore raw

v4 cover Internal voltage control for qcom SDHC

In reply to Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

So added support to register voltage regulators from the msm driver and use them.

This patchset was posted long back but not actively pursued
https://lore.kernel.org/linux-arm-msm/[email protected]/
So posting it as fresh patchset.

Changes since V3:
- Dropped reading of regulator load values from device tree.
- Dropped documentaiton chagne.
- Since only Vqmmc supply of eMMC would be kept On during suspend, setting load only for this regulator so that it can go to LPM. And since this Load reamins same, load value is hard-coded in the driver.

Changes since V2:
- Removed redundant log from sdhci_msm_set_vmmc.
- Added the condition for skiping disabling of vqmmc for eMMC.
- Updated logic such that, setting load for vqmmc only if it is kept ON.
- Retained ack by Adrian for second patch.
- Updated dt properties names as per Robs comments.

Changes since V1:
- Removed setting load for Vmmc regulator while turning it on/off. Instead setting the active load once during probe.
- Simplified handlng of supplies for BUS_ON/OFF cases in shci_msm_handle_pwr_irq().
- Moved common code out of switch case in sdhci_msm_start_signal_voltage_switch().
- Updated variable name to sdhci_core_to_disable_vqmmc.
- Updated pr_err logs to dev_err logs.

Veerabhadrarao Badiganti (2):
dt-bindings: mmc: Supply max load for mmc supplies
mmc: sdhci-msm: Use internal voltage control

Vijay Viswanath (1):
mmc: sdhci: Allow platform controlled voltage switching

 drivers/mmc/host/sdhci-msm.c | 208 +++++++++++++++++++++++++++++++++++++++++--
 drivers/mmc/host/sdhci.c     |  32 ++++---
 drivers/mmc/host/sdhci.h     |   1 +
 3 files changed, 219 insertions(+), 22 deletions(-)
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#29 lore raw

PATCH v4 2/2 mmc: sdhci-msm: Use internal voltage control

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

IO-bus supply of eMMC would be kept always-on. So set the load for this supply to configure it in LPM when eMMC is suspend state
and in HPM when eMMC is active.

---
 drivers/mmc/host/sdhci-msm.c | 208 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 199 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +199 -9
index 15c42b059240..8297b2142748 100644
@@ -37,7 +37,9 @@
 #define CORE_PWRCTL_IO_LOW	BIT(2)
 #define CORE_PWRCTL_IO_HIGH	BIT(3)
 #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
 #define CORE_PWRCTL_IO_SUCCESS	BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
 #define REQ_BUS_OFF		BIT(0)
 #define REQ_BUS_ON		BIT(1)
 #define REQ_IO_LOW		BIT(2)
@@ -127,6 +129,9 @@
 /* Timeout value to avoid infinite waiting for pwr_irq */
 #define MSM_PWR_IRQ_TIMEOUT_MS 5000
 
+/* Max load for eMMC Vdd-io supply */
+#define MMC_VQMMC_MAX_LOAD_UA	325000
+
 #define msm_host_readl(msm_host, host, offset) \
 	msm_host->var_ops->msm_readl_relaxed(host, offset)
 
@@ -278,6 +283,7 @@ struct sdhci_msm_host {
 	bool uses_tassadar_dll;
 	u32 dll_config;
 	u32 ddr_config;
+	bool vqmmc_enabled;
 };
 
 static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1346,6 +1352,88 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
 		sdhci_msm_hs400(host, &mmc->ios);
 }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)
+{
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	return mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+}
+
+static int msm_toggle_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int ret;
+	struct mmc_ios ios;
+
+	if (msm_host->vqmmc_enabled == level)
+		return 0;
+
+	if (level) {
+		/* Set the IO voltage regulator to default voltage level */
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0) {
+				dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+					mmc_hostname(mmc), ret);
+				goto out;
+			}
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}
+
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+			mmc_hostname(mmc), level ? "en":"dis", ret);
+	else
+		msm_host->vqmmc_enabled = level;
+out:
+	return ret;
+}
+
+static int msm_config_vqmmc_mode(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool hpm)
+{
+	int load, ret;
+
+	load = hpm ? MMC_VQMMC_MAX_LOAD_UA : 0;
+	ret = regulator_set_load(mmc->supply.vqmmc, load);
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+			mmc_hostname(mmc), ret);
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int ret;
+	bool always_on;
+
+	if (IS_ERR(mmc->supply.vqmmc)		||
+	    (mmc->ios.power_mode == MMC_POWER_UNDEFINED))
+		return 0;
+	/*
+	 * For eMMC don't turn off Vqmmc, Instead just configure it in LPM
+	 * and HPM modes by setting the right amonut of load.
+	 */
+	always_on = mmc->card && mmc_card_mmc(mmc->card);
+
+	if (always_on)
+		ret = msm_config_vqmmc_mode(msm_host, mmc, level);
+	else
+		ret = msm_toggle_vqmmc(msm_host, mmc, level);
+
+	return ret;
+}
+
 static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
 {
 	init_waitqueue_head(&msm_host->pwr_irq_wait);
@@ -1449,8 +1537,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 {
 	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 	struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+	struct mmc_host *mmc = host->mmc;
 	u32 irq_status, irq_ack = 0;
-	int retry = 10;
+	int retry = 10, ret;
 	u32 pwr_state = 0, io_level = 0;
 	u32 config;
 	const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1488,21 +1577,42 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 	if (irq_status & CORE_PWRCTL_BUS_ON) {
 		pwr_state = REQ_BUS_ON;
 		io_level = REQ_IO_HIGH;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
 	}
 	if (irq_status & CORE_PWRCTL_BUS_OFF) {
 		pwr_state = REQ_BUS_OFF;
 		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
 	}
+
+	if (pwr_state) {
+		ret = sdhci_msm_set_vmmc(mmc);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc,
+					pwr_state & REQ_BUS_ON);
+		if (!ret)
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		else
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+	}
+
 	/* Handle IO LOW/HIGH */
-	if (irq_status & CORE_PWRCTL_IO_LOW) {
+	if (irq_status & CORE_PWRCTL_IO_LOW)
 		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
-	}
-	if (irq_status & CORE_PWRCTL_IO_HIGH) {
+
+	if (irq_status & CORE_PWRCTL_IO_HIGH)
 		io_level = REQ_IO_HIGH;
+
+	if (io_level)
 		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
+
+	if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+		ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);
+		if (ret < 0) {
+			dev_err(mmc_dev(mmc), "%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret,
+					mmc->ios.signal_voltage, mmc->ios.vdd,
+					irq_status);
+			irq_ack |= CORE_PWRCTL_IO_FAIL;
+		}
 	}
 
 	/*
@@ -1551,7 +1661,7 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 	if (io_level)
 		msm_host->curr_io_level = io_level;
 
-	pr_debug("%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
+	dev_dbg(mmc_dev(mmc), "%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
 		mmc_hostname(msm_host->mmc), __func__, irq, irq_status,
 		irq_ack);
 }
@@ -1881,6 +1991,80 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
 	sdhci_reset(host, mask);
 }
 
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
+{
+	int ret;
+	struct mmc_host *mmc = msm_host->mmc;
+
+	ret = mmc_regulator_get_supply(msm_host->mmc);
+	if (ret)
+		return ret;
+
+	sdhci_msm_set_regulator_caps(msm_host);
+	mmc->ios.power_mode = MMC_POWER_UNDEFINED;
+
+	return 0;
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl, status;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
+			return -EINVAL;
+
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_180:
+		if (!(host->flags & SDHCI_SIGNALING_180))
+			return -EINVAL;
+
+		/*
+		 * Enable 1.8V Signal Enable in the Host Control2
+		 * register
+		 */
+		ctrl |= SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_120:
+		if (!(host->flags & SDHCI_SIGNALING_120))
+			return -EINVAL;
+		return 0;
+	default:
+		/* No signal voltage switch required */
+		return 0;
+	}
+
+	sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+	/* Wait for 5ms */
+	usleep_range(5000, 5500);
+
+	/* regulator output should be stable within 5 ms */
+	status = ctrl & SDHCI_CTRL_VDD_180;
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+	if ((ctrl & SDHCI_CTRL_VDD_180) == status)
+		return 0;
+
+	dev_warn(mmc_dev(mmc), "%s: Regulator output did not became stable\n",
+		mmc_hostname(mmc));
+
+	return -EAGAIN;
+}
+
 #define DRIVER_NAME "sdhci_msm"
 #define SDHCI_MSM_DUMP(f, x...) \
 	pr_err("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)
@@ -1967,6 +2151,7 @@ void sdhci_msm_dump_vendor_regs(struct sdhci_host *host)
 	.write_b = sdhci_msm_writeb,
 	.irq	= sdhci_msm_cqe_irq,
 	.dump_vendor_regs = sdhci_msm_dump_vendor_regs,
+	.set_power = sdhci_set_power_noreg,
 };
 
 static const struct sdhci_pltfm_data sdhci_msm_pdata = {
@@ -2181,6 +2366,10 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 	if (core_major == 1 && core_minor >= 0x49)
 		msm_host->updated_ddr_cfg = true;
 
+	ret = sdhci_msm_register_vreg(msm_host);
+	if (ret)
+		goto clk_disable;
+
 	/*
 	 * Power on reset state may trigger power irq if previous status of
 	 * PWRCTL was either BUS_ON or IO_HIGH_V. So before enabling pwr irq
@@ -2225,6 +2414,8 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 					 MSM_MMC_AUTOSUSPEND_DELAY_MS);
 	pm_runtime_use_autosuspend(&pdev->dev);
 
+	host->mmc_host_ops.start_signal_voltage_switch =
+		sdhci_msm_start_signal_voltage_switch;
 	host->mmc_host_ops.execute_tuning = sdhci_msm_execute_tuning;
 	if (of_property_read_bool(node, "supports-cqe"))
 		ret = sdhci_msm_cqe_add_host(host, pdev);
@@ -2232,7 +2423,6 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 		ret = sdhci_add_host(host);
 	if (ret)
 		goto pm_runtime_disable;
-	sdhci_msm_set_regulator_caps(msm_host);
 
 	pm_runtime_mark_last_busy(&pdev->dev);
 	pm_runtime_put_autosuspend(&pdev->dev);
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#28 lore raw

PATCH v4 1/2 mmc: sdhci: Allow platform controlled voltage switching

In reply to Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

If vendor platform drivers are controlling whole logic of voltage switching, then sdhci driver no need control vqmmc regulator. So skip enabling/disable vqmmc from SDHC driver.

---
 drivers/mmc/host/sdhci.c | 32 +++++++++++++++++++-------------
 drivers/mmc/host/sdhci.h |  1 +
 2 files changed, 20 insertions(+), 13 deletions(-)
drivers/mmc/host/sdhci.c +19 -13
index 37b1158c1c0c..e6275c2202b0 100644
@@ -4105,6 +4105,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	unsigned int override_timeout_clk;
 	u32 max_clk;
 	int ret;
+	bool enable_vqmmc = false;
 
 	WARN_ON(host == NULL);
 	if (host == NULL)
@@ -4118,9 +4119,12 @@ int sdhci_setup_host(struct sdhci_host *host)
 	 * the host can take the appropriate action if regulators are not
 	 * available.
 	 */
-	ret = mmc_regulator_get_supply(mmc);
-	if (ret)
-		return ret;
+	if (!mmc->supply.vqmmc) {
+		ret = mmc_regulator_get_supply(mmc);
+		if (ret)
+			return ret;
+		enable_vqmmc  = true;
+	}
 
 	DBG("Version:   0x%08x | Present:  0x%08x\n",
 	    sdhci_readw(host, SDHCI_HOST_VERSION),
@@ -4377,7 +4381,15 @@ int sdhci_setup_host(struct sdhci_host *host)
 		mmc->caps |= MMC_CAP_NEEDS_POLL;
 
 	if (!IS_ERR(mmc->supply.vqmmc)) {
-		ret = regulator_enable(mmc->supply.vqmmc);
+		if (enable_vqmmc) {
+			ret = regulator_enable(mmc->supply.vqmmc);
+			if (ret) {
+				pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
+					mmc_hostname(mmc), ret);
+				mmc->supply.vqmmc = ERR_PTR(-EINVAL);
+			}
+			host->sdhci_core_to_disable_vqmmc = !ret;
+		}
 
 		/* If vqmmc provides no 1.8V signalling, then there's no UHS */
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000,
@@ -4390,12 +4402,6 @@ int sdhci_setup_host(struct sdhci_host *host)
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000,
 						    3600000))
 			host->flags &= ~SDHCI_SIGNALING_330;
-
-		if (ret) {
-			pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
-				mmc_hostname(mmc), ret);
-			mmc->supply.vqmmc = ERR_PTR(-EINVAL);
-		}
 	}
 
 	if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) {
@@ -4626,7 +4632,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	return 0;
 
 unreg:
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 undma:
 	if (host->align_buffer)
@@ -4644,7 +4650,7 @@ void sdhci_cleanup_host(struct sdhci_host *host)
 {
 	struct mmc_host *mmc = host->mmc;
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
@@ -4787,7 +4793,7 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 
 	destroy_workqueue(host->complete_wq);
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
drivers/mmc/host/sdhci.h +1 -0
index 0008bbd27127..0770c036e2ff 100644
@@ -567,6 +567,7 @@ struct sdhci_host {
 	u32 caps1;		/* CAPABILITY_1 */
 	bool read_caps;		/* Capability flags have been read */
 
+	bool sdhci_core_to_disable_vqmmc;  /* sdhci core can disable vqmmc */
 	unsigned int            ocr_avail_sdio;	/* OCR bit masks */
 	unsigned int            ocr_avail_sd;
 	unsigned int            ocr_avail_mmc;
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#30 lore raw

Re: [PATCH V4 2/2] mmc: sdhci-msm: Use internal voltage control

In reply to Veerabhadrarao Badiganti
Quoted 114 lines · Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

IO-bus supply of eMMC would be kept always-on. So set the load for this supply to configure it in LPM when eMMC is suspend state
and in HPM when eMMC is active.

---
 drivers/mmc/host/sdhci-msm.c | 208 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 199 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +62 -0
index 15c42b059240..8297b2142748 100644
@@ -37,7 +37,9 @@
 #define CORE_PWRCTL_IO_LOW     BIT(2)
 #define CORE_PWRCTL_IO_HIGH    BIT(3)
 #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
 #define CORE_PWRCTL_IO_SUCCESS BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
 #define REQ_BUS_OFF            BIT(0)
 #define REQ_BUS_ON             BIT(1)
 #define REQ_IO_LOW             BIT(2)
@@ -127,6 +129,9 @@
 /* Timeout value to avoid infinite waiting for pwr_irq */
 #define MSM_PWR_IRQ_TIMEOUT_MS 5000
 
+/* Max load for eMMC Vdd-io supply */
+#define MMC_VQMMC_MAX_LOAD_UA  325000
+
 #define msm_host_readl(msm_host, host, offset) \
        msm_host->var_ops->msm_readl_relaxed(host, offset)
 
@@ -278,6 +283,7 @@ struct sdhci_msm_host {
        bool uses_tassadar_dll;
        u32 dll_config;
        u32 ddr_config;
+       bool vqmmc_enabled;
 };
 
 static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1346,6 +1352,88 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
                sdhci_msm_hs400(host, &mmc->ios);
 }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)
+{
+       if (IS_ERR(mmc->supply.vmmc))
+               return 0;
+
+       return mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+}
+
+static int msm_toggle_vqmmc(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool level)
+{
+       int ret;
+       struct mmc_ios ios;
+
+       if (msm_host->vqmmc_enabled == level)
+               return 0;
+
+       if (level) {
+               /* Set the IO voltage regulator to default voltage level */
+               if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+                       ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+               else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+                       ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+               if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+                       ret = mmc_regulator_set_vqmmc(mmc, &ios);
+                       if (ret < 0) {
+                               dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+                                       mmc_hostname(mmc), ret);
+                               goto out;
+                       }
+               }
+               ret = regulator_enable(mmc->supply.vqmmc);
+       } else {
+               ret = regulator_disable(mmc->supply.vqmmc);
+       }
+
+       if (ret)
+               dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+                       mmc_hostname(mmc), level ? "en":"dis", ret);
+       else
+               msm_host->vqmmc_enabled = level;
+out:
+       return ret;
+}
+
+static int msm_config_vqmmc_mode(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool hpm)
+{
+       int load, ret;
+
+       load = hpm ? MMC_VQMMC_MAX_LOAD_UA : 0;
+       ret = regulator_set_load(mmc->supply.vqmmc, load);
+       if (ret)
+               dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+                       mmc_hostname(mmc), ret);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1420

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+       return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool level)
+{
+       int ret;
+       bool always_on;
+
+       if (IS_ERR(mmc->supply.vqmmc)           ||

White space.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1425

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +5 -0
+           (mmc->ios.power_mode == MMC_POWER_UNDEFINED))
+               return 0;
+       /*
+        * For eMMC don't turn off Vqmmc, Instead just configure it in LPM
+        * and HPM modes by setting the right amonut of load.

/s/right amonut of load/corresponding load

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1432

Quoted 7 lines
drivers/mmc/host/sdhci-msm.c +7 -0
+        */
+       always_on = mmc->card && mmc_card_mmc(mmc->card);
+
+       if (always_on)
+               ret = msm_config_vqmmc_mode(msm_host, mmc, level);
+       else
+               ret = msm_toggle_vqmmc(msm_host, mmc, level);

I am worried that this isn't really doing what you think it does. always_on may not always be set for an eMMC.

This is because the mmc->card doesn't get assigned until the initialization of the eMMC has been completed. In other words, way after VCC and VCCQ have been turned on and changed voltage levels.

Moreover, mmc_card_mmc() is also about legacy MMC cards, not solely for eMMCs.

If you want special treatment of an eMMC, I think it's better to use the DT bindings Documentation/devicetree/bindings/mmc/mmc-card.txt. If you have such a subnode, that indicates that there is an eMMC card attached.

Quoted 81 lines
drivers/mmc/host/sdhci-msm.c +35 -8
+
+       return ret;
+}
+
 static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
 {
        init_waitqueue_head(&msm_host->pwr_irq_wait);
@@ -1449,8 +1537,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 {
        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
        struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+       struct mmc_host *mmc = host->mmc;
        u32 irq_status, irq_ack = 0;
-       int retry = 10;
+       int retry = 10, ret;
        u32 pwr_state = 0, io_level = 0;
        u32 config;
        const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1488,21 +1577,42 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
        if (irq_status & CORE_PWRCTL_BUS_ON) {
                pwr_state = REQ_BUS_ON;
                io_level = REQ_IO_HIGH;
-               irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
        }
        if (irq_status & CORE_PWRCTL_BUS_OFF) {
                pwr_state = REQ_BUS_OFF;
                io_level = REQ_IO_LOW;
-               irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
        }
+
+       if (pwr_state) {
+               ret = sdhci_msm_set_vmmc(mmc);
+               if (!ret)
+                       ret = sdhci_msm_set_vqmmc(msm_host, mmc,
+                                       pwr_state & REQ_BUS_ON);
+               if (!ret)
+                       irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+               else
+                       irq_ack |= CORE_PWRCTL_BUS_FAIL;
+       }
+
        /* Handle IO LOW/HIGH */
-       if (irq_status & CORE_PWRCTL_IO_LOW) {
+       if (irq_status & CORE_PWRCTL_IO_LOW)
                io_level = REQ_IO_LOW;
-               irq_ack |= CORE_PWRCTL_IO_SUCCESS;
-       }
-       if (irq_status & CORE_PWRCTL_IO_HIGH) {
+
+       if (irq_status & CORE_PWRCTL_IO_HIGH)
                io_level = REQ_IO_HIGH;
+
+       if (io_level)
                irq_ack |= CORE_PWRCTL_IO_SUCCESS;
+
+       if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+               ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);
+               if (ret < 0) {
+                       dev_err(mmc_dev(mmc), "%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+                                       mmc_hostname(mmc), ret,
+                                       mmc->ios.signal_voltage, mmc->ios.vdd,
+                                       irq_status);
+                       irq_ack |= CORE_PWRCTL_IO_FAIL;
+               }
        }
 
        /*
@@ -1551,7 +1661,7 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
        if (io_level)
                msm_host->curr_io_level = io_level;
 
-       pr_debug("%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
+       dev_dbg(mmc_dev(mmc), "%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
                mmc_hostname(msm_host->mmc), __func__, irq, irq_status,
                irq_ack);
 }
@@ -1881,6 +1991,80 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
        sdhci_reset(host, mask);
 }
 
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 2004

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+{
+       int ret;
+       struct mmc_host *mmc = msm_host->mmc;
+
+       ret = mmc_regulator_get_supply(msm_host->mmc);
+       if (ret)
+               return ret;
+
+       sdhci_msm_set_regulator_caps(msm_host);
+       mmc->ios.power_mode = MMC_POWER_UNDEFINED;

The mmc core already sets the initial "power_mode" to MMC_POWER_UNDEFINED in mmc_start_host().

If I understand correctly, that may be too late for you. Then, let's move that to mmc_alloc_host() instead, rather than having this done here.

Quoted 31 lines
drivers/mmc/host/sdhci-msm.c +31 -0
+
+       return 0;
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+                                     struct mmc_ios *ios)
+{
+       struct sdhci_host *host = mmc_priv(mmc);
+       u16 ctrl, status;
+
+       /*
+        * Signal Voltage Switching is only applicable for Host Controllers
+        * v3.00 and above.
+        */
+       if (host->version < SDHCI_SPEC_300)
+               return 0;
+
+       ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+       switch (ios->signal_voltage) {
+       case MMC_SIGNAL_VOLTAGE_330:
+               if (!(host->flags & SDHCI_SIGNALING_330))
+                       return -EINVAL;
+
+               /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+               ctrl &= ~SDHCI_CTRL_VDD_180;
+               break;
+       case MMC_SIGNAL_VOLTAGE_180:
+               if (!(host->flags & SDHCI_SIGNALING_180))
+                       return -EINVAL;
+

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 2045

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+               /*
+                * Enable 1.8V Signal Enable in the Host Control2
+                * register
+                */
+               ctrl |= SDHCI_CTRL_VDD_180;
+               break;
+       case MMC_SIGNAL_VOLTAGE_120:
+               if (!(host->flags & SDHCI_SIGNALING_120))
+                       return -EINVAL;
+               return 0;

This looks weird. You probably want to return -EINVAL instead!?

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 2048

Quoted 3 lines
drivers/mmc/host/sdhci-msm.c +3 -0
+       default:
+               /* No signal voltage switch required */
+               return 0;

This is an error and should not be treated as a valid case. I suggest you return -EINVAL here instead, then you may also skip the case for MMC_SIGNAL_VOLTAGE_120 above, as it gets covered in this part.

Quoted 23 lines
drivers/mmc/host/sdhci-msm.c +19 -0
+       }
+
+       sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+       /* Wait for 5ms */
+       usleep_range(5000, 5500);
+
+       /* regulator output should be stable within 5 ms */
+       status = ctrl & SDHCI_CTRL_VDD_180;
+       ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+       if ((ctrl & SDHCI_CTRL_VDD_180) == status)
+               return 0;
+
+       dev_warn(mmc_dev(mmc), "%s: Regulator output did not became stable\n",
+               mmc_hostname(mmc));
+
+       return -EAGAIN;
+}
+
 #define DRIVER_NAME "sdhci_msm"
 #define SDHCI_MSM_DUMP(f, x...) \
        pr_err("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)

drivers/mmc/host/sdhci-msm.c void sdhci_msm_dump_vendor_regs(struct sdhci_host *host) · line 2156

Quoted 6 lines
drivers/mmc/host/sdhci-msm.c +1 -0
@@ -1967,6 +2151,7 @@ void sdhci_msm_dump_vendor_regs(struct sdhci_host *host)
        .write_b = sdhci_msm_writeb,
        .irq    = sdhci_msm_cqe_irq,
        .dump_vendor_regs = sdhci_msm_dump_vendor_regs,
+       .set_power = sdhci_set_power_noreg,
 };
 

[...]

Kind regards
Uffe

#31 lore raw

Re: [PATCH V4 2/2] mmc: sdhci-msm: Use internal voltage control

Thanks for comments Uffe.

Quoted 141 lines · Ulf Hansson
Quoted 113 lines · Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

IO-bus supply of eMMC would be kept always-on. So set the load for this supply to configure it in LPM when eMMC is suspend state
and in HPM when eMMC is active.

---
  drivers/mmc/host/sdhci-msm.c | 208 +++++++++++++++++++++++++++++++++++++++++--
  1 file changed, 199 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +62 -0
index 15c42b059240..8297b2142748 100644
@@ -37,7 +37,9 @@
  #define CORE_PWRCTL_IO_LOW     BIT(2)
  #define CORE_PWRCTL_IO_HIGH    BIT(3)
  #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
  #define CORE_PWRCTL_IO_SUCCESS BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
  #define REQ_BUS_OFF            BIT(0)
  #define REQ_BUS_ON             BIT(1)
  #define REQ_IO_LOW             BIT(2)
@@ -127,6 +129,9 @@
  /* Timeout value to avoid infinite waiting for pwr_irq */
  #define MSM_PWR_IRQ_TIMEOUT_MS 5000
 
+/* Max load for eMMC Vdd-io supply */
+#define MMC_VQMMC_MAX_LOAD_UA  325000
+
  #define msm_host_readl(msm_host, host, offset) \
         msm_host->var_ops->msm_readl_relaxed(host, offset)
 
@@ -278,6 +283,7 @@ struct sdhci_msm_host {
         bool uses_tassadar_dll;
         u32 dll_config;
         u32 ddr_config;
+       bool vqmmc_enabled;
  };
 
  static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1346,6 +1352,88 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
                 sdhci_msm_hs400(host, &mmc->ios);
  }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)
+{
+       if (IS_ERR(mmc->supply.vmmc))
+               return 0;
+
+       return mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+}
+
+static int msm_toggle_vqmmc(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool level)
+{
+       int ret;
+       struct mmc_ios ios;
+
+       if (msm_host->vqmmc_enabled == level)
+               return 0;
+
+       if (level) {
+               /* Set the IO voltage regulator to default voltage level */
+               if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+                       ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+               else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+                       ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+               if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+                       ret = mmc_regulator_set_vqmmc(mmc, &ios);
+                       if (ret < 0) {
+                               dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+                                       mmc_hostname(mmc), ret);
+                               goto out;
+                       }
+               }
+               ret = regulator_enable(mmc->supply.vqmmc);
+       } else {
+               ret = regulator_disable(mmc->supply.vqmmc);
+       }
+
+       if (ret)
+               dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+                       mmc_hostname(mmc), level ? "en":"dis", ret);
+       else
+               msm_host->vqmmc_enabled = level;
+out:
+       return ret;
+}
+
+static int msm_config_vqmmc_mode(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool hpm)
+{
+       int load, ret;
+
+       load = hpm ? MMC_VQMMC_MAX_LOAD_UA : 0;
+       ret = regulator_set_load(mmc->supply.vqmmc, load);
+       if (ret)
+               dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+                       mmc_hostname(mmc), ret);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1420

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+       return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool level)
+{
+       int ret;
+       bool always_on;
+
+       if (IS_ERR(mmc->supply.vqmmc)           ||

White space.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1425

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +5 -0
+           (mmc->ios.power_mode == MMC_POWER_UNDEFINED))
+               return 0;
+       /*
+        * For eMMC don't turn off Vqmmc, Instead just configure it in LPM
+        * and HPM modes by setting the right amonut of load.

/s/right amonut of load/corresponding load

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1432

Quoted 7 lines
drivers/mmc/host/sdhci-msm.c +7 -0
+        */
+       always_on = mmc->card && mmc_card_mmc(mmc->card);
+
+       if (always_on)
+               ret = msm_config_vqmmc_mode(msm_host, mmc, level);
+       else
+               ret = msm_toggle_vqmmc(msm_host, mmc, level);
Quoted 6 lines

I am worried that this isn't really doing what you think it does. always_on may not always be set for an eMMC.

This is because the mmc->card doesn't get assigned until the initialization of the eMMC has been completed. In other words, way after VCC and VCCQ have been turned on and changed voltage levels.

For the very first time, i have to enable the vqmmc.
And second time on-wards I have to set load instead of turning vqmmc off / on.

This condition helps me in doing exactly the same.

This gets invoked first time when  mmc_power_up() is called. Yes, by that time card won't be initialized. So this check fails and allows to turn on the regulator instead of setting load.

After that, this gets invoked only next time mmc_power_up/off() is called which is during mmc_suspend/resume.

By this time card is initialized, it allows to set load.

Quoted 1 line

Moreover, mmc_card_mmc() is also about legacy MMC cards, not solely for eMMCs.

Okay. But on qcom platform, we have support for only eMMC/SD/SDIO. So this mmc_card_mmc() meets my requirements!!! Allows only eMMC not SD & SDIO.

Quoted 98 lines

If you want special treatment of an eMMC, I think it's better to use the DT bindings Documentation/devicetree/bindings/mmc/mmc-card.txt. If you have such a subnode, that indicates that there is an eMMC card attached.

Quoted 81 lines
drivers/mmc/host/sdhci-msm.c +35 -8
+
+       return ret;
+}
+
  static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
  {
         init_waitqueue_head(&msm_host->pwr_irq_wait);
@@ -1449,8 +1537,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
  {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+       struct mmc_host *mmc = host->mmc;
         u32 irq_status, irq_ack = 0;
-       int retry = 10;
+       int retry = 10, ret;
         u32 pwr_state = 0, io_level = 0;
         u32 config;
         const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1488,21 +1577,42 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
         if (irq_status & CORE_PWRCTL_BUS_ON) {
                 pwr_state = REQ_BUS_ON;
                 io_level = REQ_IO_HIGH;
-               irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
         }
         if (irq_status & CORE_PWRCTL_BUS_OFF) {
                 pwr_state = REQ_BUS_OFF;
                 io_level = REQ_IO_LOW;
-               irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
         }
+
+       if (pwr_state) {
+               ret = sdhci_msm_set_vmmc(mmc);
+               if (!ret)
+                       ret = sdhci_msm_set_vqmmc(msm_host, mmc,
+                                       pwr_state & REQ_BUS_ON);
+               if (!ret)
+                       irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+               else
+                       irq_ack |= CORE_PWRCTL_BUS_FAIL;
+       }
+
         /* Handle IO LOW/HIGH */
-       if (irq_status & CORE_PWRCTL_IO_LOW) {
+       if (irq_status & CORE_PWRCTL_IO_LOW)
                 io_level = REQ_IO_LOW;
-               irq_ack |= CORE_PWRCTL_IO_SUCCESS;
-       }
-       if (irq_status & CORE_PWRCTL_IO_HIGH) {
+
+       if (irq_status & CORE_PWRCTL_IO_HIGH)
                 io_level = REQ_IO_HIGH;
+
+       if (io_level)
                 irq_ack |= CORE_PWRCTL_IO_SUCCESS;
+
+       if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+               ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);
+               if (ret < 0) {
+                       dev_err(mmc_dev(mmc), "%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+                                       mmc_hostname(mmc), ret,
+                                       mmc->ios.signal_voltage, mmc->ios.vdd,
+                                       irq_status);
+                       irq_ack |= CORE_PWRCTL_IO_FAIL;
+               }
         }
 
         /*
@@ -1551,7 +1661,7 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
         if (io_level)
                 msm_host->curr_io_level = io_level;
 
-       pr_debug("%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
+       dev_dbg(mmc_dev(mmc), "%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
                 mmc_hostname(msm_host->mmc), __func__, irq, irq_status,
                 irq_ack);
  }
@@ -1881,6 +1991,80 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
         sdhci_reset(host, mask);
  }
 
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 2004

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+{
+       int ret;
+       struct mmc_host *mmc = msm_host->mmc;
+
+       ret = mmc_regulator_get_supply(msm_host->mmc);
+       if (ret)
+               return ret;
+
+       sdhci_msm_set_regulator_caps(msm_host);
+       mmc->ios.power_mode = MMC_POWER_UNDEFINED;

The mmc core already sets the initial "power_mode" to MMC_POWER_UNDEFINED in mmc_start_host().

Quoted 3 lines

If I understand correctly, that may be too late for you. Then, let's move that to mmc_alloc_host() instead, rather than having this done here.

sure. i will move it to mmc_alloc_host()

Quoted 43 lines
Quoted 31 lines
drivers/mmc/host/sdhci-msm.c +31 -0
+
+       return 0;
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+                                     struct mmc_ios *ios)
+{
+       struct sdhci_host *host = mmc_priv(mmc);
+       u16 ctrl, status;
+
+       /*
+        * Signal Voltage Switching is only applicable for Host Controllers
+        * v3.00 and above.
+        */
+       if (host->version < SDHCI_SPEC_300)
+               return 0;
+
+       ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+       switch (ios->signal_voltage) {
+       case MMC_SIGNAL_VOLTAGE_330:
+               if (!(host->flags & SDHCI_SIGNALING_330))
+                       return -EINVAL;
+
+               /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+               ctrl &= ~SDHCI_CTRL_VDD_180;
+               break;
+       case MMC_SIGNAL_VOLTAGE_180:
+               if (!(host->flags & SDHCI_SIGNALING_180))
+                       return -EINVAL;
+

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 2045

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+               /*
+                * Enable 1.8V Signal Enable in the Host Control2
+                * register
+                */
+               ctrl |= SDHCI_CTRL_VDD_180;
+               break;
+       case MMC_SIGNAL_VOLTAGE_120:
+               if (!(host->flags & SDHCI_SIGNALING_120))
+                       return -EINVAL;
+               return 0;

This looks weird. You probably want to return -EINVAL instead!?

Quoted 7 lines

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_reset(struct sdhci_host *host, u8 mask) · line 2048

Quoted 3 lines
drivers/mmc/host/sdhci-msm.c +3 -0
+       default:
+               /* No signal voltage switch required */
+               return 0;

This is an error and should not be treated as a valid case. I suggest you return -EINVAL here instead, then you may also skip the case for MMC_SIGNAL_VOLTAGE_120 above, as it gets covered in this part.

Sure. I will update this.

Quoted 31 lines
Quoted 29 lines
drivers/mmc/host/sdhci-msm.c +20 -0
+       }
+
+       sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+       /* Wait for 5ms */
+       usleep_range(5000, 5500);
+
+       /* regulator output should be stable within 5 ms */
+       status = ctrl & SDHCI_CTRL_VDD_180;
+       ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+       if ((ctrl & SDHCI_CTRL_VDD_180) == status)
+               return 0;
+
+       dev_warn(mmc_dev(mmc), "%s: Regulator output did not became stable\n",
+               mmc_hostname(mmc));
+
+       return -EAGAIN;
+}
+
  #define DRIVER_NAME "sdhci_msm"
  #define SDHCI_MSM_DUMP(f, x...) \
         pr_err("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)
@@ -1967,6 +2151,7 @@ void sdhci_msm_dump_vendor_regs(struct sdhci_host *host)
         .write_b = sdhci_msm_writeb,
         .irq    = sdhci_msm_cqe_irq,
         .dump_vendor_regs = sdhci_msm_dump_vendor_regs,
+       .set_power = sdhci_set_power_noreg,
  };
 

[...]

Quoted 2 lines

Kind regards
Uffe

Thanks
Veera

#32 lore raw

Re: [PATCH V4 2/2] mmc: sdhci-msm: Use internal voltage control

Quoted 155 lines · Veerabhadrarao Badiganti

Thanks for comments Uffe.

Quoted 141 lines · Ulf Hansson
Quoted 113 lines · Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

IO-bus supply of eMMC would be kept always-on. So set the load for this supply to configure it in LPM when eMMC is suspend state
and in HPM when eMMC is active.

---
  drivers/mmc/host/sdhci-msm.c | 208 +++++++++++++++++++++++++++++++++++++++++--
  1 file changed, 199 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +62 -0
index 15c42b059240..8297b2142748 100644
@@ -37,7 +37,9 @@
  #define CORE_PWRCTL_IO_LOW     BIT(2)
  #define CORE_PWRCTL_IO_HIGH    BIT(3)
  #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
  #define CORE_PWRCTL_IO_SUCCESS BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
  #define REQ_BUS_OFF            BIT(0)
  #define REQ_BUS_ON             BIT(1)
  #define REQ_IO_LOW             BIT(2)
@@ -127,6 +129,9 @@
  /* Timeout value to avoid infinite waiting for pwr_irq */
  #define MSM_PWR_IRQ_TIMEOUT_MS 5000
 
+/* Max load for eMMC Vdd-io supply */
+#define MMC_VQMMC_MAX_LOAD_UA  325000
+
  #define msm_host_readl(msm_host, host, offset) \
         msm_host->var_ops->msm_readl_relaxed(host, offset)
 
@@ -278,6 +283,7 @@ struct sdhci_msm_host {
         bool uses_tassadar_dll;
         u32 dll_config;
         u32 ddr_config;
+       bool vqmmc_enabled;
  };
 
  static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1346,6 +1352,88 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
                 sdhci_msm_hs400(host, &mmc->ios);
  }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)
+{
+       if (IS_ERR(mmc->supply.vmmc))
+               return 0;
+
+       return mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+}
+
+static int msm_toggle_vqmmc(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool level)
+{
+       int ret;
+       struct mmc_ios ios;
+
+       if (msm_host->vqmmc_enabled == level)
+               return 0;
+
+       if (level) {
+               /* Set the IO voltage regulator to default voltage level */
+               if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+                       ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+               else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+                       ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+               if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+                       ret = mmc_regulator_set_vqmmc(mmc, &ios);
+                       if (ret < 0) {
+                               dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+                                       mmc_hostname(mmc), ret);
+                               goto out;
+                       }
+               }
+               ret = regulator_enable(mmc->supply.vqmmc);
+       } else {
+               ret = regulator_disable(mmc->supply.vqmmc);
+       }
+
+       if (ret)
+               dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+                       mmc_hostname(mmc), level ? "en":"dis", ret);
+       else
+               msm_host->vqmmc_enabled = level;
+out:
+       return ret;
+}
+
+static int msm_config_vqmmc_mode(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool hpm)
+{
+       int load, ret;
+
+       load = hpm ? MMC_VQMMC_MAX_LOAD_UA : 0;
+       ret = regulator_set_load(mmc->supply.vqmmc, load);
+       if (ret)
+               dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+                       mmc_hostname(mmc), ret);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1420

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+       return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool level)
+{
+       int ret;
+       bool always_on;
+
+       if (IS_ERR(mmc->supply.vqmmc)           ||

White space.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1425

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +5 -0
+           (mmc->ios.power_mode == MMC_POWER_UNDEFINED))
+               return 0;
+       /*
+        * For eMMC don't turn off Vqmmc, Instead just configure it in LPM
+        * and HPM modes by setting the right amonut of load.

/s/right amonut of load/corresponding load

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1432

Quoted 7 lines
drivers/mmc/host/sdhci-msm.c +7 -0
+        */
+       always_on = mmc->card && mmc_card_mmc(mmc->card);
+
+       if (always_on)
+               ret = msm_config_vqmmc_mode(msm_host, mmc, level);
+       else
+               ret = msm_toggle_vqmmc(msm_host, mmc, level);
Quoted 6 lines

I am worried that this isn't really doing what you think it does. always_on may not always be set for an eMMC.

This is because the mmc->card doesn't get assigned until the initialization of the eMMC has been completed. In other words, way after VCC and VCCQ have been turned on and changed voltage levels.

For the very first time, i have to enable the vqmmc.
And second time on-wards I have to set load instead of turning vqmmc off / on.

Quoted 8 lines

This condition helps me in doing exactly the same.

This gets invoked first time when mmc_power_up() is called. Yes, by that time card won't be initialized. So this check fails and allows to turn on the regulator instead of setting load.

After that, this gets invoked only next time mmc_power_up/off() is called which is during mmc_suspend/resume.

I see.

That assumes the initialization always works at the first attempt, so no re-try or power cycle gets done in some error/reset path.

Quoted 2 lines

By this time card is initialized, it allows to set load.

Okay, I get it. Thanks for clarifying.

Perhaps you can add a small comment about this in the code, so we don't forget the reasons why the code looks like this.

Quoted 7 lines
Quoted 3 lines

Moreover, mmc_card_mmc() is also about legacy MMC cards, not solely for eMMCs.

Okay. But on qcom platform, we have support for only eMMC/SD/SDIO. So this mmc_card_mmc() meets my requirements!!! Allows only eMMC not SD & SDIO.

Well, eMMC is fairly similar to MMC, from a basic functionality point of view. So, I am quite sure you can get it to work with your controller, even if it's not officially supported.

Quoted 5 lines
Quoted 5 lines

If you want special treatment of an eMMC, I think it's better to use the DT bindings Documentation/devicetree/bindings/mmc/mmc-card.txt. If you have such a subnode, that indicates that there is an eMMC card attached.

That said, if you don't like the pure DT based solution, as I suggested above - at least extend mmc_card_mmc() with checking the MMC_CAP_NONREMOVABLE flag.

[...]

Kind regards
Uffe

#33 lore raw

Re: [PATCH V4 2/2] mmc: sdhci-msm: Use internal voltage control

Quoted 166 lines · Ulf Hansson
Quoted 154 lines · Veerabhadrarao Badiganti

Thanks for comments Uffe.

Quoted 141 lines · Ulf Hansson
Quoted 113 lines · Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

IO-bus supply of eMMC would be kept always-on. So set the load for this supply to configure it in LPM when eMMC is suspend state
and in HPM when eMMC is active.

---
   drivers/mmc/host/sdhci-msm.c | 208 +++++++++++++++++++++++++++++++++++++++++--
   1 file changed, 199 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +62 -0
index 15c42b059240..8297b2142748 100644
@@ -37,7 +37,9 @@
   #define CORE_PWRCTL_IO_LOW     BIT(2)
   #define CORE_PWRCTL_IO_HIGH    BIT(3)
   #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
   #define CORE_PWRCTL_IO_SUCCESS BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
   #define REQ_BUS_OFF            BIT(0)
   #define REQ_BUS_ON             BIT(1)
   #define REQ_IO_LOW             BIT(2)
@@ -127,6 +129,9 @@
   /* Timeout value to avoid infinite waiting for pwr_irq */
   #define MSM_PWR_IRQ_TIMEOUT_MS 5000
 
+/* Max load for eMMC Vdd-io supply */
+#define MMC_VQMMC_MAX_LOAD_UA  325000
+
   #define msm_host_readl(msm_host, host, offset) \
          msm_host->var_ops->msm_readl_relaxed(host, offset)
 
@@ -278,6 +283,7 @@ struct sdhci_msm_host {
          bool uses_tassadar_dll;
          u32 dll_config;
          u32 ddr_config;
+       bool vqmmc_enabled;
   };
 
   static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1346,6 +1352,88 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
                  sdhci_msm_hs400(host, &mmc->ios);
   }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)
+{
+       if (IS_ERR(mmc->supply.vmmc))
+               return 0;
+
+       return mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+}
+
+static int msm_toggle_vqmmc(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool level)
+{
+       int ret;
+       struct mmc_ios ios;
+
+       if (msm_host->vqmmc_enabled == level)
+               return 0;
+
+       if (level) {
+               /* Set the IO voltage regulator to default voltage level */
+               if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+                       ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+               else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+                       ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+               if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+                       ret = mmc_regulator_set_vqmmc(mmc, &ios);
+                       if (ret < 0) {
+                               dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+                                       mmc_hostname(mmc), ret);
+                               goto out;
+                       }
+               }
+               ret = regulator_enable(mmc->supply.vqmmc);
+       } else {
+               ret = regulator_disable(mmc->supply.vqmmc);
+       }
+
+       if (ret)
+               dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+                       mmc_hostname(mmc), level ? "en":"dis", ret);
+       else
+               msm_host->vqmmc_enabled = level;
+out:
+       return ret;
+}
+
+static int msm_config_vqmmc_mode(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool hpm)
+{
+       int load, ret;
+
+       load = hpm ? MMC_VQMMC_MAX_LOAD_UA : 0;
+       ret = regulator_set_load(mmc->supply.vqmmc, load);
+       if (ret)
+               dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+                       mmc_hostname(mmc), ret);

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1420

Quoted 10 lines
drivers/mmc/host/sdhci-msm.c +10 -0
+       return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+                             struct mmc_host *mmc, bool level)
+{
+       int ret;
+       bool always_on;
+
+       if (IS_ERR(mmc->supply.vqmmc)           ||

White space.

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1425

Quoted 5 lines
drivers/mmc/host/sdhci-msm.c +5 -0
+           (mmc->ios.power_mode == MMC_POWER_UNDEFINED))
+               return 0;
+       /*
+        * For eMMC don't turn off Vqmmc, Instead just configure it in LPM
+        * and HPM modes by setting the right amonut of load.

/s/right amonut of load/corresponding load

drivers/mmc/host/sdhci-msm.c static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, · line 1432

Quoted 7 lines
drivers/mmc/host/sdhci-msm.c +7 -0
+        */
+       always_on = mmc->card && mmc_card_mmc(mmc->card);
+
+       if (always_on)
+               ret = msm_config_vqmmc_mode(msm_host, mmc, level);
+       else
+               ret = msm_toggle_vqmmc(msm_host, mmc, level);
Quoted 6 lines

I am worried that this isn't really doing what you think it does. always_on may not always be set for an eMMC.

This is because the mmc->card doesn't get assigned until the initialization of the eMMC has been completed. In other words, way after VCC and VCCQ have been turned on and changed voltage levels.

For the very first time, i have to enable the vqmmc.
And second time on-wards I have to set load instead of turning vqmmc off / on.

Quoted 8 lines

This condition helps me in doing exactly the same.

This gets invoked first time when mmc_power_up() is called. Yes, by that time card won't be initialized. So this check fails and allows to turn on the regulator instead of setting load.

After that, this gets invoked only next time mmc_power_up/off() is called which is during mmc_suspend/resume.

I see.

Quoted 8 lines

That assumes the initialization always works at the first attempt, so no re-try or power cycle gets done in some error/reset path.

Quoted 1 line

By this time card is initialized, it allows to set load.

Okay, I get it. Thanks for clarifying.

Perhaps you can add a small comment about this in the code, so we don't forget the reasons why the code looks like this.

Sure. Will update comment with this info.

Quoted 8 lines
Quoted 5 lines
Quoted 2 lines

Moreover, mmc_card_mmc() is also about legacy MMC cards, not solely for eMMCs.

Okay. But on qcom platform, we have support for only eMMC/SD/SDIO. So this mmc_card_mmc() meets my requirements!!! Allows only eMMC not SD & SDIO.

Well, eMMC is fairly similar to MMC, from a basic functionality point of view. So, I am quite sure you can get it to work with your controller, even if it's not officially supported.

Quoted 7 lines
Quoted 4 lines
Quoted 4 lines

If you want special treatment of an eMMC, I think it's better to use the DT bindings Documentation/devicetree/bindings/mmc/mmc-card.txt. If you have such a subnode, that indicates that there is an eMMC card attached.

That said, if you don't like the pure DT based solution, as I suggested above - at least extend mmc_card_mmc() with checking the MMC_CAP_NONREMOVABLE flag.

sure. Will update it. Thank you.

Quoted 5 lines

[...]

Kind regards
Uffe

#35 lore raw

PATCH v5 1/3 mmc: sdhci: Allow platform controlled voltage switching

In reply to Veerabhadrarao Badiganti

From: Vijay Viswanath <[email protected]>

If vendor platform drivers are controlling whole logic of voltage switching, then sdhci driver no need control vqmmc regulator. So skip enabling/disable vqmmc from SDHC driver.

---
 drivers/mmc/host/sdhci.c | 32 +++++++++++++++++++-------------
 drivers/mmc/host/sdhci.h |  1 +
 2 files changed, 20 insertions(+), 13 deletions(-)
drivers/mmc/host/sdhci.c +19 -13
index 37b1158c1c0c..e6275c2202b0 100644
@@ -4105,6 +4105,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	unsigned int override_timeout_clk;
 	u32 max_clk;
 	int ret;
+	bool enable_vqmmc = false;
 
 	WARN_ON(host == NULL);
 	if (host == NULL)
@@ -4118,9 +4119,12 @@ int sdhci_setup_host(struct sdhci_host *host)
 	 * the host can take the appropriate action if regulators are not
 	 * available.
 	 */
-	ret = mmc_regulator_get_supply(mmc);
-	if (ret)
-		return ret;
+	if (!mmc->supply.vqmmc) {
+		ret = mmc_regulator_get_supply(mmc);
+		if (ret)
+			return ret;
+		enable_vqmmc  = true;
+	}
 
 	DBG("Version:   0x%08x | Present:  0x%08x\n",
 	    sdhci_readw(host, SDHCI_HOST_VERSION),
@@ -4377,7 +4381,15 @@ int sdhci_setup_host(struct sdhci_host *host)
 		mmc->caps |= MMC_CAP_NEEDS_POLL;
 
 	if (!IS_ERR(mmc->supply.vqmmc)) {
-		ret = regulator_enable(mmc->supply.vqmmc);
+		if (enable_vqmmc) {
+			ret = regulator_enable(mmc->supply.vqmmc);
+			if (ret) {
+				pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
+					mmc_hostname(mmc), ret);
+				mmc->supply.vqmmc = ERR_PTR(-EINVAL);
+			}
+			host->sdhci_core_to_disable_vqmmc = !ret;
+		}
 
 		/* If vqmmc provides no 1.8V signalling, then there's no UHS */
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000,
@@ -4390,12 +4402,6 @@ int sdhci_setup_host(struct sdhci_host *host)
 		if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000,
 						    3600000))
 			host->flags &= ~SDHCI_SIGNALING_330;
-
-		if (ret) {
-			pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
-				mmc_hostname(mmc), ret);
-			mmc->supply.vqmmc = ERR_PTR(-EINVAL);
-		}
 	}
 
 	if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) {
@@ -4626,7 +4632,7 @@ int sdhci_setup_host(struct sdhci_host *host)
 	return 0;
 
 unreg:
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 undma:
 	if (host->align_buffer)
@@ -4644,7 +4650,7 @@ void sdhci_cleanup_host(struct sdhci_host *host)
 {
 	struct mmc_host *mmc = host->mmc;
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
@@ -4787,7 +4793,7 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 
 	destroy_workqueue(host->complete_wq);
 
-	if (!IS_ERR(mmc->supply.vqmmc))
+	if (host->sdhci_core_to_disable_vqmmc)
 		regulator_disable(mmc->supply.vqmmc);
 
 	if (host->align_buffer)
drivers/mmc/host/sdhci.h +1 -0
index 0008bbd27127..0770c036e2ff 100644
@@ -567,6 +567,7 @@ struct sdhci_host {
 	u32 caps1;		/* CAPABILITY_1 */
 	bool read_caps;		/* Capability flags have been read */
 
+	bool sdhci_core_to_disable_vqmmc;  /* sdhci core can disable vqmmc */
 	unsigned int            ocr_avail_sdio;	/* OCR bit masks */
 	unsigned int            ocr_avail_sd;
 	unsigned int            ocr_avail_mmc;
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#34 lore raw

v5 cover Internal voltage control for qcom SDHC

In reply to Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

So added support to register voltage regulators from the msm driver and use them.

This patchset was posted long back but not actively pursued
https://lore.kernel.org/linux-arm-msm/[email protected]/
So posting it as fresh patchset.

Changes since V4:
- Added clear comments on condtion which allows either to tunf off/on Vqmmc or to set load.
- Added mmc_card_removable() to the condtion whcih checks if the card is eMMC or other card.
- Rerturning error for unsupported voltagtes in sdhci_msm_start_signal_voltage_switch()
- Moved setting ios.power_mode to mmc_alloc_host().

Changes since V3:
- Dropped reading of regulator load values from device tree.
- Dropped documentaiton chagne.
- Since only Vqmmc supply of eMMC would be kept On during suspend, setting load only for this regulator so that it can go to LPM. And since this Load reamins same, load value is hard-coded in the driver.

Changes since V2:
- Removed redundant log from sdhci_msm_set_vmmc.
- Added the condition for skiping disabling of vqmmc for eMMC.
- Updated logic such that, setting load for vqmmc only if it is kept ON.
- Retained ack by Adrian for second patch.
- Updated dt properties names as per Robs comments.

Changes since V1:
- Removed setting load for Vmmc regulator while turning it on/off. Instead setting the active load once during probe.
- Simplified handlng of supplies for BUS_ON/OFF cases in shci_msm_handle_pwr_irq().
- Moved common code out of switch case in sdhci_msm_start_signal_voltage_switch().
- Updated variable name to sdhci_core_to_disable_vqmmc.
- Updated pr_err logs to dev_err logs.
Veerabhadrarao Badiganti (2):
mmc: core: Set default power mode in mmc_alloc_host
mmc: sdhci-msm: Use internal voltage control

Vijay Viswanath (1):
mmc: sdhci: Allow platform controlled voltage switching

 drivers/mmc/core/host.c      |   1 +
 drivers/mmc/host/sdhci-msm.c | 206 +++++++++++++++++++++++++++++++++++++++++--
 drivers/mmc/host/sdhci.c     |  32 ++++---
 drivers/mmc/host/sdhci.h     |   1 +
 4 files changed, 218 insertions(+), 22 deletions(-)
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#37 lore raw

PATCH v5 3/3 mmc: sdhci-msm: Use internal voltage control

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

Use the internal voltage switching and then control the voltage switching using power irq.

IO-bus supply of eMMC would be kept always-on. So set the load for this supply to configure it in LPM when eMMC is suspend state and in HPM when eMMC is active.

---
 drivers/mmc/host/sdhci-msm.c | 206 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 197 insertions(+), 9 deletions(-)
drivers/mmc/host/sdhci-msm.c +197 -9
index 15c42b059240..cbe15519e7b9 100644
@@ -37,7 +37,9 @@
 #define CORE_PWRCTL_IO_LOW	BIT(2)
 #define CORE_PWRCTL_IO_HIGH	BIT(3)
 #define CORE_PWRCTL_BUS_SUCCESS BIT(0)
+#define CORE_PWRCTL_BUS_FAIL    BIT(1)
 #define CORE_PWRCTL_IO_SUCCESS	BIT(2)
+#define CORE_PWRCTL_IO_FAIL     BIT(3)
 #define REQ_BUS_OFF		BIT(0)
 #define REQ_BUS_ON		BIT(1)
 #define REQ_IO_LOW		BIT(2)
@@ -127,6 +129,9 @@
 /* Timeout value to avoid infinite waiting for pwr_irq */
 #define MSM_PWR_IRQ_TIMEOUT_MS 5000
 
+/* Max load for eMMC Vdd-io supply */
+#define MMC_VQMMC_MAX_LOAD_UA	325000
+
 #define msm_host_readl(msm_host, host, offset) \
 	msm_host->var_ops->msm_readl_relaxed(host, offset)
 
@@ -278,6 +283,7 @@ struct sdhci_msm_host {
 	bool uses_tassadar_dll;
 	u32 dll_config;
 	u32 ddr_config;
+	bool vqmmc_enabled;
 };
 
 static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host)
@@ -1346,6 +1352,95 @@ static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host,
 		sdhci_msm_hs400(host, &mmc->ios);
 }
 
+static int sdhci_msm_set_vmmc(struct mmc_host *mmc)
+{
+	if (IS_ERR(mmc->supply.vmmc))
+		return 0;
+
+	return mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, mmc->ios.vdd);
+}
+
+static int msm_toggle_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int ret;
+	struct mmc_ios ios;
+
+	if (msm_host->vqmmc_enabled == level)
+		return 0;
+
+	if (level) {
+		/* Set the IO voltage regulator to default voltage level */
+		if (msm_host->caps_0 & CORE_3_0V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_330;
+		else if (msm_host->caps_0 & CORE_1_8V_SUPPORT)
+			ios.signal_voltage = MMC_SIGNAL_VOLTAGE_180;
+
+		if (msm_host->caps_0 & CORE_VOLT_SUPPORT) {
+			ret = mmc_regulator_set_vqmmc(mmc, &ios);
+			if (ret < 0) {
+				dev_err(mmc_dev(mmc), "%s: vqmmc set volgate failed: %d\n",
+					mmc_hostname(mmc), ret);
+				goto out;
+			}
+		}
+		ret = regulator_enable(mmc->supply.vqmmc);
+	} else {
+		ret = regulator_disable(mmc->supply.vqmmc);
+	}
+
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmm %sable failed: %d\n",
+			mmc_hostname(mmc), level ? "en":"dis", ret);
+	else
+		msm_host->vqmmc_enabled = level;
+out:
+	return ret;
+}
+
+static int msm_config_vqmmc_mode(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool hpm)
+{
+	int load, ret;
+
+	load = hpm ? MMC_VQMMC_MAX_LOAD_UA : 0;
+	ret = regulator_set_load(mmc->supply.vqmmc, load);
+	if (ret)
+		dev_err(mmc_dev(mmc), "%s: vqmmc set load failed: %d\n",
+			mmc_hostname(mmc), ret);
+	return ret;
+}
+
+static int sdhci_msm_set_vqmmc(struct sdhci_msm_host *msm_host,
+			      struct mmc_host *mmc, bool level)
+{
+	int ret;
+	bool always_on;
+
+	if (IS_ERR(mmc->supply.vqmmc) ||
+			(mmc->ios.power_mode == MMC_POWER_UNDEFINED))
+		return 0;
+	/*
+	 * For eMMC don't turn off Vqmmc, Instead just configure it in LPM
+	 * and HPM modes by setting the corresponding load.
+	 *
+	 * Till eMMC is initialized (i.e. always_on == 0), just turn on/off
+	 * Vqmmc. Vqmmc gets turned off only if init fails and mmc_power_off
+	 * gets invoked. Once eMMC is initialized (i.e. always_on == 1),
+	 * Vqmmc should remain ON, So just set the load instead of turning it
+	 * off/on.
+	 */
+	always_on = !mmc_card_is_removable(mmc) &&
+			mmc->card && mmc_card_mmc(mmc->card);
+
+	if (always_on)
+		ret = msm_config_vqmmc_mode(msm_host, mmc, level);
+	else
+		ret = msm_toggle_vqmmc(msm_host, mmc, level);
+
+	return ret;
+}
+
 static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host)
 {
 	init_waitqueue_head(&msm_host->pwr_irq_wait);
@@ -1449,8 +1544,9 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 {
 	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 	struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);
+	struct mmc_host *mmc = host->mmc;
 	u32 irq_status, irq_ack = 0;
-	int retry = 10;
+	int retry = 10, ret;
 	u32 pwr_state = 0, io_level = 0;
 	u32 config;
 	const struct sdhci_msm_offset *msm_offset = msm_host->offset;
@@ -1488,21 +1584,42 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 	if (irq_status & CORE_PWRCTL_BUS_ON) {
 		pwr_state = REQ_BUS_ON;
 		io_level = REQ_IO_HIGH;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
 	}
 	if (irq_status & CORE_PWRCTL_BUS_OFF) {
 		pwr_state = REQ_BUS_OFF;
 		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
 	}
+
+	if (pwr_state) {
+		ret = sdhci_msm_set_vmmc(mmc);
+		if (!ret)
+			ret = sdhci_msm_set_vqmmc(msm_host, mmc,
+					pwr_state & REQ_BUS_ON);
+		if (!ret)
+			irq_ack |= CORE_PWRCTL_BUS_SUCCESS;
+		else
+			irq_ack |= CORE_PWRCTL_BUS_FAIL;
+	}
+
 	/* Handle IO LOW/HIGH */
-	if (irq_status & CORE_PWRCTL_IO_LOW) {
+	if (irq_status & CORE_PWRCTL_IO_LOW)
 		io_level = REQ_IO_LOW;
-		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
-	}
-	if (irq_status & CORE_PWRCTL_IO_HIGH) {
+
+	if (irq_status & CORE_PWRCTL_IO_HIGH)
 		io_level = REQ_IO_HIGH;
+
+	if (io_level)
 		irq_ack |= CORE_PWRCTL_IO_SUCCESS;
+
+	if (io_level && !IS_ERR(mmc->supply.vqmmc) && !pwr_state) {
+		ret = mmc_regulator_set_vqmmc(mmc, &mmc->ios);
+		if (ret < 0) {
+			dev_err(mmc_dev(mmc), "%s: IO_level setting failed(%d). signal_voltage: %d, vdd: %d irq_status: 0x%08x\n",
+					mmc_hostname(mmc), ret,
+					mmc->ios.signal_voltage, mmc->ios.vdd,
+					irq_status);
+			irq_ack |= CORE_PWRCTL_IO_FAIL;
+		}
 	}
 
 	/*
@@ -1551,7 +1668,7 @@ static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq)
 	if (io_level)
 		msm_host->curr_io_level = io_level;
 
-	pr_debug("%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
+	dev_dbg(mmc_dev(mmc), "%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n",
 		mmc_hostname(msm_host->mmc), __func__, irq, irq_status,
 		irq_ack);
 }
@@ -1881,6 +1998,71 @@ static void sdhci_msm_reset(struct sdhci_host *host, u8 mask)
 	sdhci_reset(host, mask);
 }
 
+static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
+{
+	int ret;
+
+	ret = mmc_regulator_get_supply(msm_host->mmc);
+	if (ret)
+		return ret;
+
+	sdhci_msm_set_regulator_caps(msm_host);
+
+	return 0;
+}
+
+static int sdhci_msm_start_signal_voltage_switch(struct mmc_host *mmc,
+				      struct mmc_ios *ios)
+{
+	struct sdhci_host *host = mmc_priv(mmc);
+	u16 ctrl, status;
+
+	/*
+	 * Signal Voltage Switching is only applicable for Host Controllers
+	 * v3.00 and above.
+	 */
+	if (host->version < SDHCI_SPEC_300)
+		return 0;
+
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+	switch (ios->signal_voltage) {
+	case MMC_SIGNAL_VOLTAGE_330:
+		if (!(host->flags & SDHCI_SIGNALING_330))
+			return -EINVAL;
+
+		/* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+		ctrl &= ~SDHCI_CTRL_VDD_180;
+		break;
+	case MMC_SIGNAL_VOLTAGE_180:
+		if (!(host->flags & SDHCI_SIGNALING_180))
+			return -EINVAL;
+
+		/* Enable 1.8V Signal Enable in the Host Control2 register */
+		ctrl |= SDHCI_CTRL_VDD_180;
+		break;
+
+	default:
+		return -EINVAL;
+	}
+
+	sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+	/* Wait for 5ms */
+	usleep_range(5000, 5500);
+
+	/* regulator output should be stable within 5 ms */
+	status = ctrl & SDHCI_CTRL_VDD_180;
+	ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+	if ((ctrl & SDHCI_CTRL_VDD_180) == status)
+		return 0;
+
+	dev_warn(mmc_dev(mmc), "%s: Regulator output did not became stable\n",
+		mmc_hostname(mmc));
+
+	return -EAGAIN;
+}
+
 #define DRIVER_NAME "sdhci_msm"
 #define SDHCI_MSM_DUMP(f, x...) \
 	pr_err("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)
@@ -1967,6 +2149,7 @@ void sdhci_msm_dump_vendor_regs(struct sdhci_host *host)
 	.write_b = sdhci_msm_writeb,
 	.irq	= sdhci_msm_cqe_irq,
 	.dump_vendor_regs = sdhci_msm_dump_vendor_regs,
+	.set_power = sdhci_set_power_noreg,
 };
 
 static const struct sdhci_pltfm_data sdhci_msm_pdata = {
@@ -2181,6 +2364,10 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 	if (core_major == 1 && core_minor >= 0x49)
 		msm_host->updated_ddr_cfg = true;
 
+	ret = sdhci_msm_register_vreg(msm_host);
+	if (ret)
+		goto clk_disable;
+
 	/*
 	 * Power on reset state may trigger power irq if previous status of
 	 * PWRCTL was either BUS_ON or IO_HIGH_V. So before enabling pwr irq
@@ -2225,6 +2412,8 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 					 MSM_MMC_AUTOSUSPEND_DELAY_MS);
 	pm_runtime_use_autosuspend(&pdev->dev);
 
+	host->mmc_host_ops.start_signal_voltage_switch =
+		sdhci_msm_start_signal_voltage_switch;
 	host->mmc_host_ops.execute_tuning = sdhci_msm_execute_tuning;
 	if (of_property_read_bool(node, "supports-cqe"))
 		ret = sdhci_msm_cqe_add_host(host, pdev);
@@ -2232,7 +2421,6 @@ static int sdhci_msm_probe(struct platform_device *pdev)
 		ret = sdhci_add_host(host);
 	if (ret)
 		goto pm_runtime_disable;
-	sdhci_msm_set_regulator_caps(msm_host);
 
 	pm_runtime_mark_last_busy(&pdev->dev);
 	pm_runtime_put_autosuspend(&pdev->dev);
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#36 lore raw

PATCH v5 2/3 mmc: core: Set default power mode in mmc_alloc_host

In reply to Veerabhadrarao Badiganti

Set the default power mode (which is MMC_POWER_UNDEFINE) in mmc_alloc_host, so that the vendor drivers can make use of this state to perform needed actions during the platform driver probe.

---
 drivers/mmc/core/host.c | 1 +
 1 file changed, 1 insertion(+)
drivers/mmc/core/host.c +1 -0
index 6141a85749ca..793597556cd7 100644
@@ -434,6 +434,7 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
 
 	host->fixed_drv_type = -EINVAL;
 	host->ios.power_delay_ms = 10;
+	host->ios.power_mode = MMC_POWER_UNDEFINED;
 
 	return host;
 }
Signature · 1 line
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
#38 lore raw
In reply to Veerabhadrarao Badiganti
Quoted 47 lines · Veerabhadrarao Badiganti

On qcom SD host controllers voltage switching be done after the HW is ready for it. The HW informs its readiness through power irq. The voltage switching should happen only then.

So added support to register voltage regulators from the msm driver and use them.

This patchset was posted long back but not actively pursued
https://lore.kernel.org/linux-arm-msm/[email protected]/
So posting it as fresh patchset.

Changes since V4:
- Added clear comments on condtion which allows either to tunf off/on Vqmmc or to set load.
- Added mmc_card_removable() to the condtion whcih checks if the card is eMMC or other card.
- Rerturning error for unsupported voltagtes in sdhci_msm_start_signal_voltage_switch()
- Moved setting ios.power_mode to mmc_alloc_host().

Changes since V3:
- Dropped reading of regulator load values from device tree.
- Dropped documentaiton chagne.
- Since only Vqmmc supply of eMMC would be kept On during suspend, setting load only for this regulator so that it can go to LPM. And since this Load reamins same, load value is hard-coded in the driver.

Changes since V2:
- Removed redundant log from sdhci_msm_set_vmmc.
- Added the condition for skiping disabling of vqmmc for eMMC.
- Updated logic such that, setting load for vqmmc only if it is kept ON.
- Retained ack by Adrian for second patch.
- Updated dt properties names as per Robs comments.

Changes since V1:
- Removed setting load for Vmmc regulator while turning it on/off. Instead setting the active load once during probe.
- Simplified handlng of supplies for BUS_ON/OFF cases in shci_msm_handle_pwr_irq().
- Moved common code out of switch case in sdhci_msm_start_signal_voltage_switch().
- Updated variable name to sdhci_core_to_disable_vqmmc.
- Updated pr_err logs to dev_err logs.
Veerabhadrarao Badiganti (2):
mmc: core: Set default power mode in mmc_alloc_host
mmc: sdhci-msm: Use internal voltage control

Quoted 9 lines

Vijay Viswanath (1):
mmc: sdhci: Allow platform controlled voltage switching

 drivers/mmc/core/host.c      |   1 +
 drivers/mmc/host/sdhci-msm.c | 206 +++++++++++++++++++++++++++++++++++++++++--
 drivers/mmc/host/sdhci.c     |  32 ++++---
 drivers/mmc/host/sdhci.h     |   1 +
 4 files changed, 218 insertions(+), 22 deletions(-)

V5 applied for next (did some minor amendment to patch 2), thanks!

Kind regards
Uffe