xref: /openbmc/linux/drivers/mmc/core/regulator.c (revision f4356947)
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