322 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Helper functions for MMC regulators.4 */5 6#include <linux/device.h>7#include <linux/err.h>8#include <linux/log2.h>9#include <linux/regulator/consumer.h>10 11#include <linux/mmc/host.h>12 13#include "core.h"14#include "host.h"15 16#ifdef CONFIG_REGULATOR17 18/**19 * mmc_ocrbitnum_to_vdd - Convert a OCR bit number to its voltage20 * @vdd_bit: OCR bit number21 * @min_uV: minimum voltage value (mV)22 * @max_uV: maximum voltage value (mV)23 *24 * This function returns the voltage range according to the provided OCR25 * bit number. If conversion is not possible a negative errno value returned.26 */27static int mmc_ocrbitnum_to_vdd(int vdd_bit, int *min_uV, int *max_uV)28{29 int tmp;30 31 if (!vdd_bit)32 return -EINVAL;33 34 /*35 * REVISIT mmc_vddrange_to_ocrmask() may have set some36 * bits this regulator doesn't quite support ... don't37 * be too picky, most cards and regulators are OK with38 * a 0.1V range goof (it's a small error percentage).39 */40 tmp = vdd_bit - ilog2(MMC_VDD_165_195);41 if (tmp == 0) {42 *min_uV = 1650 * 1000;43 *max_uV = 1950 * 1000;44 } else {45 *min_uV = 1900 * 1000 + tmp * 100 * 1000;46 *max_uV = *min_uV + 100 * 1000;47 }48 49 return 0;50}51 52/**53 * mmc_regulator_get_ocrmask - return mask of supported voltages54 * @supply: regulator to use55 *56 * This returns either a negative errno, or a mask of voltages that57 * can be provided to MMC/SD/SDIO devices using the specified voltage58 * regulator. This would normally be called before registering the59 * MMC host adapter.60 */61static int mmc_regulator_get_ocrmask(struct regulator *supply)62{63 int result = 0;64 int count;65 int i;66 int vdd_uV;67 int vdd_mV;68 69 count = regulator_count_voltages(supply);70 if (count < 0)71 return count;72 73 for (i = 0; i < count; i++) {74 vdd_uV = regulator_list_voltage(supply, i);75 if (vdd_uV <= 0)76 continue;77 78 vdd_mV = vdd_uV / 1000;79 result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);80 }81 82 if (!result) {83 vdd_uV = regulator_get_voltage(supply);84 if (vdd_uV <= 0)85 return vdd_uV;86 87 vdd_mV = vdd_uV / 1000;88 result = mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);89 }90 91 return result;92}93 94/**95 * mmc_regulator_set_ocr - set regulator to match host->ios voltage96 * @mmc: the host to regulate97 * @supply: regulator to use98 * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)99 *100 * Returns zero on success, else negative errno.101 *102 * MMC host drivers may use this to enable or disable a regulator using103 * a particular supply voltage. This would normally be called from the104 * set_ios() method.105 */106int mmc_regulator_set_ocr(struct mmc_host *mmc,107 struct regulator *supply,108 unsigned short vdd_bit)109{110 int result = 0;111 int min_uV, max_uV;112 113 if (IS_ERR(supply))114 return 0;115 116 if (vdd_bit) {117 mmc_ocrbitnum_to_vdd(vdd_bit, &min_uV, &max_uV);118 119 result = regulator_set_voltage(supply, min_uV, max_uV);120 if (result == 0 && !mmc->regulator_enabled) {121 result = regulator_enable(supply);122 if (!result)123 mmc->regulator_enabled = true;124 }125 } else if (mmc->regulator_enabled) {126 result = regulator_disable(supply);127 if (result == 0)128 mmc->regulator_enabled = false;129 }130 131 if (result)132 dev_err(mmc_dev(mmc),133 "could not set regulator OCR (%d)\n", result);134 return result;135}136EXPORT_SYMBOL_GPL(mmc_regulator_set_ocr);137 138static int mmc_regulator_set_voltage_if_supported(struct regulator *regulator,139 int min_uV, int target_uV,140 int max_uV)141{142 int current_uV;143 144 /*145 * Check if supported first to avoid errors since we may try several146 * signal levels during power up and don't want to show errors.147 */148 if (!regulator_is_supported_voltage(regulator, min_uV, max_uV))149 return -EINVAL;150 151 /*152 * The voltage is already set, no need to switch.153 * Return 1 to indicate that no switch happened.154 */155 current_uV = regulator_get_voltage(regulator);156 if (current_uV == target_uV)157 return 1;158 159 return regulator_set_voltage_triplet(regulator, min_uV, target_uV,160 max_uV);161}162 163/**164 * mmc_regulator_set_vqmmc - Set VQMMC as per the ios165 * @mmc: the host to regulate166 * @ios: io bus settings167 *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 supplied170 * by the same supply. The Bus Operating conditions for 3.3V signaling in the171 * 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.173 *174 * For 1.2V and 1.8V signaling we'll try to get as close as possible to the175 * requested voltage. This is definitely a good idea for UHS where there's a176 * separate regulator on the card that's trying to make 1.8V and it's best if177 * we match.178 *179 * This function is expected to be used by a controller's180 * start_signal_voltage_switch() function.181 */182int mmc_regulator_set_vqmmc(struct mmc_host *mmc, struct mmc_ios *ios)183{184 struct device *dev = mmc_dev(mmc);185 int ret, volt, min_uV, max_uV;186 187 /* If no vqmmc supply then we can't change the voltage */188 if (IS_ERR(mmc->supply.vqmmc))189 return -EINVAL;190 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);200 if (ret < 0)201 return ret;202 203 dev_dbg(dev, "%s: found vmmc voltage range of %d-%duV\n",204 __func__, volt, max_uV);205 206 min_uV = max(volt - 300000, 2700000);207 max_uV = min(max_uV + 200000, 3600000);208 209 /*210 * Due to a limitation in the current implementation of211 * regulator_set_voltage_triplet() which is taking the lowest212 * voltage possible if below the target, search for a suitable213 * voltage in two steps and try to stay close to vmmc214 * with a 0.3V tolerance at first.215 */216 ret = mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,217 min_uV, volt, max_uV);218 if (ret >= 0)219 return ret;220 221 return mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,222 2700000, volt, 3600000);223 default:224 return -EINVAL;225 }226}227EXPORT_SYMBOL_GPL(mmc_regulator_set_vqmmc);228 229#else230 231static inline int mmc_regulator_get_ocrmask(struct regulator *supply)232{233 return 0;234}235 236#endif /* CONFIG_REGULATOR */237 238/**239 * mmc_regulator_get_supply - try to get VMMC and VQMMC regulators for a host240 * @mmc: the host to regulate241 *242 * Returns 0 or errno. errno should be handled, it is either a critical error243 * or -EPROBE_DEFER. 0 means no critical error but it does not mean all244 * regulators have been found because they all are optional. If you require245 * certain regulators, you need to check separately in your driver if they got246 * populated after calling this function.247 */248int mmc_regulator_get_supply(struct mmc_host *mmc)249{250 struct device *dev = mmc_dev(mmc);251 int ret;252 253 mmc->supply.vmmc = devm_regulator_get_optional(dev, "vmmc");254 mmc->supply.vqmmc = devm_regulator_get_optional(dev, "vqmmc");255 256 if (IS_ERR(mmc->supply.vmmc)) {257 if (PTR_ERR(mmc->supply.vmmc) == -EPROBE_DEFER)258 return dev_err_probe(dev, -EPROBE_DEFER,259 "vmmc regulator not available\n");260 261 dev_dbg(dev, "No vmmc regulator found\n");262 } else {263 ret = mmc_regulator_get_ocrmask(mmc->supply.vmmc);264 if (ret > 0)265 mmc->ocr_avail = ret;266 else267 dev_warn(dev, "Failed getting OCR mask: %d\n", ret);268 }269 270 if (IS_ERR(mmc->supply.vqmmc)) {271 if (PTR_ERR(mmc->supply.vqmmc) == -EPROBE_DEFER)272 return dev_err_probe(dev, -EPROBE_DEFER,273 "vqmmc regulator not available\n");274 275 dev_dbg(dev, "No vqmmc regulator found\n");276 }277 278 return 0;279}280EXPORT_SYMBOL_GPL(mmc_regulator_get_supply);281 282/**283 * mmc_regulator_enable_vqmmc - enable VQMMC regulator for a host284 * @mmc: the host to regulate285 *286 * Returns 0 or errno. Enables the regulator for vqmmc.287 * Keeps track of the enable status for ensuring that calls to288 * regulator_enable/disable are balanced.289 */290int mmc_regulator_enable_vqmmc(struct mmc_host *mmc)291{292 int ret = 0;293 294 if (!IS_ERR(mmc->supply.vqmmc) && !mmc->vqmmc_enabled) {295 ret = regulator_enable(mmc->supply.vqmmc);296 if (ret < 0)297 dev_err(mmc_dev(mmc), "enabling vqmmc regulator failed\n");298 else299 mmc->vqmmc_enabled = true;300 }301 302 return ret;303}304EXPORT_SYMBOL_GPL(mmc_regulator_enable_vqmmc);305 306/**307 * mmc_regulator_disable_vqmmc - disable VQMMC regulator for a host308 * @mmc: the host to regulate309 *310 * Returns 0 or errno. Disables the regulator for vqmmc.311 * Keeps track of the enable status for ensuring that calls to312 * regulator_enable/disable are balanced.313 */314void mmc_regulator_disable_vqmmc(struct mmc_host *mmc)315{316 if (!IS_ERR(mmc->supply.vqmmc) && mmc->vqmmc_enabled) {317 regulator_disable(mmc->supply.vqmmc);318 mmc->vqmmc_enabled = false;319 }320}321EXPORT_SYMBOL_GPL(mmc_regulator_disable_vqmmc);322