1 // SPDX-License-Identifier: GPL-2.0
3 * Helper functions for MMC regulators.
6 #include <linux/device.h>
8 #include <linux/log2.h>
9 #include <linux/regulator/consumer.h>
11 #include <linux/mmc/host.h>
16 #ifdef CONFIG_REGULATOR
19 * mmc_ocrbitnum_to_vdd - Convert a OCR bit number to its voltage
20 * @vdd_bit: OCR bit number
21 * @min_uV: minimum voltage value (mV)
22 * @max_uV: maximum voltage value (mV)
24 * This function returns the voltage range according to the provided OCR
25 * bit number. If conversion is not possible a negative errno value returned.
27 static int mmc_ocrbitnum_to_vdd(int vdd_bit, int *min_uV, int *max_uV)
35 * REVISIT mmc_vddrange_to_ocrmask() may have set some
36 * bits this regulator doesn't quite support ... don't
37 * be too picky, most cards and regulators are OK with
38 * a 0.1V range goof (it's a small error percentage).
40 tmp = vdd_bit - ilog2(MMC_VDD_165_195);
42 *min_uV = 1650 * 1000;
43 *max_uV = 1950 * 1000;
45 *min_uV = 1900 * 1000 + tmp * 100 * 1000;
46 *max_uV = *min_uV + 100 * 1000;
53 * mmc_regulator_get_ocrmask - return mask of supported voltages
54 * @supply: regulator to use
56 * This returns either a negative errno, or a mask of voltages that
57 * can be provided to MMC/SD/SDIO devices using the specified voltage
58 * regulator. This would normally be called before registering the
61 static int mmc_regulator_get_ocrmask(struct regulator *supply)
69 count = regulator_count_voltages(supply);
73 for (i = 0; i < count; i++) {
74 vdd_uV = regulator_list_voltage(supply, i);
78 vdd_mV = vdd_uV / 1000;
79 result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
83 vdd_uV = regulator_get_voltage(supply);
87 vdd_mV = vdd_uV / 1000;
88 result = mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
95 * mmc_regulator_set_ocr - set regulator to match host->ios voltage
96 * @mmc: the host to regulate
97 * @supply: regulator to use
98 * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
100 * Returns zero on success, else negative errno.
102 * MMC host drivers may use this to enable or disable a regulator using
103 * a particular supply voltage. This would normally be called from the
106 int mmc_regulator_set_ocr(struct mmc_host *mmc,
107 struct regulator *supply,
108 unsigned short vdd_bit)
117 mmc_ocrbitnum_to_vdd(vdd_bit, &min_uV, &max_uV);
119 result = regulator_set_voltage(supply, min_uV, max_uV);
120 if (result == 0 && !mmc->regulator_enabled) {
121 result = regulator_enable(supply);
123 mmc->regulator_enabled = true;
125 } else if (mmc->regulator_enabled) {
126 result = regulator_disable(supply);
128 mmc->regulator_enabled = false;
132 dev_err(mmc_dev(mmc),
133 "could not set regulator OCR (%d)\n", result);
136 EXPORT_SYMBOL_GPL(mmc_regulator_set_ocr);
138 static int mmc_regulator_set_voltage_if_supported(struct regulator *regulator,
139 int min_uV, int target_uV,
145 * Check if supported first to avoid errors since we may try several
146 * signal levels during power up and don't want to show errors.
148 if (!regulator_is_supported_voltage(regulator, min_uV, max_uV))
152 * The voltage is already set, no need to switch.
153 * Return 1 to indicate that no switch happened.
155 current_uV = regulator_get_voltage(regulator);
156 if (current_uV == target_uV)
159 return regulator_set_voltage_triplet(regulator, min_uV, target_uV,
164 * mmc_regulator_set_vqmmc - Set VQMMC as per the ios
165 * @mmc: the host to regulate
166 * @ios: io bus settings
168 * For 3.3V signaling, we try to match VQMMC to VMMC as closely as possible.
169 * That will match the behavior of old boards where VQMMC and VMMC were supplied
170 * by the same supply. The Bus Operating conditions for 3.3V signaling in the
171 * SD card spec also define VQMMC in terms of VMMC.
172 * If this is not possible we'll try the full 2.7-3.6V of the spec.
174 * For 1.2V and 1.8V signaling we'll try to get as close as possible to the
175 * requested voltage. This is definitely a good idea for UHS where there's a
176 * separate regulator on the card that's trying to make 1.8V and it's best if
179 * This function is expected to be used by a controller's
180 * start_signal_voltage_switch() function.
182 int mmc_regulator_set_vqmmc(struct mmc_host *mmc, struct mmc_ios *ios)
184 struct device *dev = mmc_dev(mmc);
185 int ret, volt, min_uV, max_uV;
187 /* If no vqmmc supply then we can't change the voltage */
188 if (IS_ERR(mmc->supply.vqmmc))
191 switch (ios->signal_voltage) {
192 case MMC_SIGNAL_VOLTAGE_120:
193 return mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
194 1100000, 1200000, 1300000);
195 case MMC_SIGNAL_VOLTAGE_180:
196 return mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
197 1700000, 1800000, 1950000);
198 case MMC_SIGNAL_VOLTAGE_330:
199 ret = mmc_ocrbitnum_to_vdd(mmc->ios.vdd, &volt, &max_uV);
203 dev_dbg(dev, "%s: found vmmc voltage range of %d-%duV\n",
204 __func__, volt, max_uV);
206 min_uV = max(volt - 300000, 2700000);
207 max_uV = min(max_uV + 200000, 3600000);
210 * Due to a limitation in the current implementation of
211 * regulator_set_voltage_triplet() which is taking the lowest
212 * voltage possible if below the target, search for a suitable
213 * voltage in two steps and try to stay close to vmmc
214 * with a 0.3V tolerance at first.
216 ret = mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
217 min_uV, volt, max_uV);
221 return mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
222 2700000, volt, 3600000);
227 EXPORT_SYMBOL_GPL(mmc_regulator_set_vqmmc);
231 static inline int mmc_regulator_get_ocrmask(struct regulator *supply)
236 #endif /* CONFIG_REGULATOR */
239 * mmc_regulator_get_supply - try to get VMMC and VQMMC regulators for a host
240 * @mmc: the host to regulate
242 * Returns 0 or errno. errno should be handled, it is either a critical error
243 * or -EPROBE_DEFER. 0 means no critical error but it does not mean all
244 * regulators have been found because they all are optional. If you require
245 * certain regulators, you need to check separately in your driver if they got
246 * populated after calling this function.
248 int mmc_regulator_get_supply(struct mmc_host *mmc)
250 struct device *dev = mmc_dev(mmc);
253 mmc->supply.vmmc = devm_regulator_get_optional(dev, "vmmc");
254 mmc->supply.vqmmc = devm_regulator_get_optional(dev, "vqmmc");
256 if (IS_ERR(mmc->supply.vmmc)) {
257 if (PTR_ERR(mmc->supply.vmmc) == -EPROBE_DEFER)
258 return -EPROBE_DEFER;
259 dev_dbg(dev, "No vmmc regulator found\n");
261 ret = mmc_regulator_get_ocrmask(mmc->supply.vmmc);
263 mmc->ocr_avail = ret;
265 dev_warn(dev, "Failed getting OCR mask: %d\n", ret);
268 if (IS_ERR(mmc->supply.vqmmc)) {
269 if (PTR_ERR(mmc->supply.vqmmc) == -EPROBE_DEFER)
270 return -EPROBE_DEFER;
271 dev_dbg(dev, "No vqmmc regulator found\n");
276 EXPORT_SYMBOL_GPL(mmc_regulator_get_supply);
279 * mmc_regulator_enable_vqmmc - enable VQMMC regulator for a host
280 * @mmc: the host to regulate
282 * Returns 0 or errno. Enables the regulator for vqmmc.
283 * Keeps track of the enable status for ensuring that calls to
284 * regulator_enable/disable are balanced.
286 int mmc_regulator_enable_vqmmc(struct mmc_host *mmc)
290 if (!IS_ERR(mmc->supply.vqmmc) && !mmc->vqmmc_enabled) {
291 ret = regulator_enable(mmc->supply.vqmmc);
293 dev_err(mmc_dev(mmc), "enabling vqmmc regulator failed\n");
295 mmc->vqmmc_enabled = true;
300 EXPORT_SYMBOL_GPL(mmc_regulator_enable_vqmmc);
303 * mmc_regulator_disable_vqmmc - disable VQMMC regulator for a host
304 * @mmc: the host to regulate
306 * Returns 0 or errno. Disables the regulator for vqmmc.
307 * Keeps track of the enable status for ensuring that calls to
308 * regulator_enable/disable are balanced.
310 void mmc_regulator_disable_vqmmc(struct mmc_host *mmc)
312 if (!IS_ERR(mmc->supply.vqmmc) && mmc->vqmmc_enabled) {
313 regulator_disable(mmc->supply.vqmmc);
314 mmc->vqmmc_enabled = false;
317 EXPORT_SYMBOL_GPL(mmc_regulator_disable_vqmmc);