1 // SPDX-License-Identifier: GPL-2.0 2 /* 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_REGULATOR 17 18 /** 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) 23 * 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. 26 */ 27 static 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 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). 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 voltages 54 * @supply: regulator to use 55 * 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 59 * MMC host adapter. 60 */ 61 static 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 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) 99 * 100 * Returns zero on success, else negative errno. 101 * 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 104 * set_ios() method. 105 */ 106 int 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 } 136 EXPORT_SYMBOL_GPL(mmc_regulator_set_ocr); 137 138 static 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 several 146 * 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 ios 165 * @mmc: the host to regulate 166 * @ios: io bus settings 167 * 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. 173 * 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 177 * we match. 178 * 179 * This function is expected to be used by a controller's 180 * start_signal_voltage_switch() function. 181 */ 182 int 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 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. 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 } 227 EXPORT_SYMBOL_GPL(mmc_regulator_set_vqmmc); 228 229 #else 230 231 static 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 host 240 * @mmc: the host to regulate 241 * 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. 247 */ 248 int 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 -EPROBE_DEFER; 259 dev_dbg(dev, "No vmmc regulator found\n"); 260 } else { 261 ret = mmc_regulator_get_ocrmask(mmc->supply.vmmc); 262 if (ret > 0) 263 mmc->ocr_avail = ret; 264 else 265 dev_warn(dev, "Failed getting OCR mask: %d\n", ret); 266 } 267 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"); 272 } 273 274 return 0; 275 } 276 EXPORT_SYMBOL_GPL(mmc_regulator_get_supply); 277 278 /** 279 * mmc_regulator_enable_vqmmc - enable VQMMC regulator for a host 280 * @mmc: the host to regulate 281 * 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. 285 */ 286 int mmc_regulator_enable_vqmmc(struct mmc_host *mmc) 287 { 288 int ret = 0; 289 290 if (!IS_ERR(mmc->supply.vqmmc) && !mmc->vqmmc_enabled) { 291 ret = regulator_enable(mmc->supply.vqmmc); 292 if (ret < 0) 293 dev_err(mmc_dev(mmc), "enabling vqmmc regulator failed\n"); 294 else 295 mmc->vqmmc_enabled = true; 296 } 297 298 return ret; 299 } 300 EXPORT_SYMBOL_GPL(mmc_regulator_enable_vqmmc); 301 302 /** 303 * mmc_regulator_disable_vqmmc - disable VQMMC regulator for a host 304 * @mmc: the host to regulate 305 * 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. 309 */ 310 void mmc_regulator_disable_vqmmc(struct mmc_host *mmc) 311 { 312 if (!IS_ERR(mmc->supply.vqmmc) && mmc->vqmmc_enabled) { 313 regulator_disable(mmc->supply.vqmmc); 314 mmc->vqmmc_enabled = false; 315 } 316 } 317 EXPORT_SYMBOL_GPL(mmc_regulator_disable_vqmmc); 318