Branch data Line data Source code
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 [ # # # # ]: 0 : 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 : 0 : tmp = vdd_bit - ilog2(MMC_VDD_165_195);
41 [ # # # # ]: 0 : if (tmp == 0) {
42 : : *min_uV = 1650 * 1000;
43 : : *max_uV = 1950 * 1000;
44 : : } else {
45 : 0 : *min_uV = 1900 * 1000 + tmp * 100 * 1000;
46 : 0 : *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 : 0 : 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 : 0 : count = regulator_count_voltages(supply);
70 [ # # ]: 0 : if (count < 0)
71 : : return count;
72 : :
73 [ # # ]: 0 : for (i = 0; i < count; i++) {
74 : 0 : vdd_uV = regulator_list_voltage(supply, i);
75 [ # # ]: 0 : if (vdd_uV <= 0)
76 : 0 : continue;
77 : :
78 : 0 : vdd_mV = vdd_uV / 1000;
79 : 0 : result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
80 : : }
81 : :
82 [ # # ]: 0 : if (!result) {
83 : 0 : vdd_uV = regulator_get_voltage(supply);
84 [ # # ]: 0 : if (vdd_uV <= 0)
85 : : return vdd_uV;
86 : :
87 : 0 : vdd_mV = vdd_uV / 1000;
88 : 0 : result = mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
89 : : }
90 : :
91 : 0 : 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 : 0 : 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 [ # # ]: 0 : if (vdd_bit) {
114 : 0 : mmc_ocrbitnum_to_vdd(vdd_bit, &min_uV, &max_uV);
115 : :
116 : 0 : result = regulator_set_voltage(supply, min_uV, max_uV);
117 [ # # # # ]: 0 : if (result == 0 && !mmc->regulator_enabled) {
118 : 0 : result = regulator_enable(supply);
119 [ # # ]: 0 : if (!result)
120 : 0 : mmc->regulator_enabled = true;
121 : : }
122 [ # # ]: 0 : } else if (mmc->regulator_enabled) {
123 : 0 : result = regulator_disable(supply);
124 [ # # ]: 0 : if (result == 0)
125 : 0 : mmc->regulator_enabled = false;
126 : : }
127 : :
128 [ # # ]: 0 : if (result)
129 : 0 : dev_err(mmc_dev(mmc),
130 : : "could not set regulator OCR (%d)\n", result);
131 : 0 : return result;
132 : : }
133 : : EXPORT_SYMBOL_GPL(mmc_regulator_set_ocr);
134 : :
135 : 0 : static int mmc_regulator_set_voltage_if_supported(struct regulator *regulator,
136 : : int min_uV, int target_uV,
137 : : int max_uV)
138 : : {
139 : : /*
140 : : * Check if supported first to avoid errors since we may try several
141 : : * signal levels during power up and don't want to show errors.
142 : : */
143 [ # # ]: 0 : if (!regulator_is_supported_voltage(regulator, min_uV, max_uV))
144 : : return -EINVAL;
145 : :
146 : 0 : return regulator_set_voltage_triplet(regulator, min_uV, target_uV,
147 : : max_uV);
148 : : }
149 : :
150 : : /**
151 : : * mmc_regulator_set_vqmmc - Set VQMMC as per the ios
152 : : *
153 : : * For 3.3V signaling, we try to match VQMMC to VMMC as closely as possible.
154 : : * That will match the behavior of old boards where VQMMC and VMMC were supplied
155 : : * by the same supply. The Bus Operating conditions for 3.3V signaling in the
156 : : * SD card spec also define VQMMC in terms of VMMC.
157 : : * If this is not possible we'll try the full 2.7-3.6V of the spec.
158 : : *
159 : : * For 1.2V and 1.8V signaling we'll try to get as close as possible to the
160 : : * requested voltage. This is definitely a good idea for UHS where there's a
161 : : * separate regulator on the card that's trying to make 1.8V and it's best if
162 : : * we match.
163 : : *
164 : : * This function is expected to be used by a controller's
165 : : * start_signal_voltage_switch() function.
166 : : */
167 : 0 : int mmc_regulator_set_vqmmc(struct mmc_host *mmc, struct mmc_ios *ios)
168 : : {
169 : : struct device *dev = mmc_dev(mmc);
170 : : int ret, volt, min_uV, max_uV;
171 : :
172 : : /* If no vqmmc supply then we can't change the voltage */
173 [ # # ]: 0 : if (IS_ERR(mmc->supply.vqmmc))
174 : : return -EINVAL;
175 : :
176 [ # # # # ]: 0 : switch (ios->signal_voltage) {
177 : : case MMC_SIGNAL_VOLTAGE_120:
178 : 0 : return mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
179 : : 1100000, 1200000, 1300000);
180 : : case MMC_SIGNAL_VOLTAGE_180:
181 : 0 : return mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
182 : : 1700000, 1800000, 1950000);
183 : : case MMC_SIGNAL_VOLTAGE_330:
184 : 0 : ret = mmc_ocrbitnum_to_vdd(mmc->ios.vdd, &volt, &max_uV);
185 [ # # ]: 0 : if (ret < 0)
186 : : return ret;
187 : :
188 : : dev_dbg(dev, "%s: found vmmc voltage range of %d-%duV\n",
189 : : __func__, volt, max_uV);
190 : :
191 : 0 : min_uV = max(volt - 300000, 2700000);
192 : 0 : max_uV = min(max_uV + 200000, 3600000);
193 : :
194 : : /*
195 : : * Due to a limitation in the current implementation of
196 : : * regulator_set_voltage_triplet() which is taking the lowest
197 : : * voltage possible if below the target, search for a suitable
198 : : * voltage in two steps and try to stay close to vmmc
199 : : * with a 0.3V tolerance at first.
200 : : */
201 [ # # ]: 0 : if (!mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
202 : : min_uV, volt, max_uV))
203 : : return 0;
204 : :
205 : 0 : return mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
206 : : 2700000, volt, 3600000);
207 : : default:
208 : : return -EINVAL;
209 : : }
210 : : }
211 : : EXPORT_SYMBOL_GPL(mmc_regulator_set_vqmmc);
212 : :
213 : : #else
214 : :
215 : : static inline int mmc_regulator_get_ocrmask(struct regulator *supply)
216 : : {
217 : : return 0;
218 : : }
219 : :
220 : : #endif /* CONFIG_REGULATOR */
221 : :
222 : : /**
223 : : * mmc_regulator_get_supply - try to get VMMC and VQMMC regulators for a host
224 : : * @mmc: the host to regulate
225 : : *
226 : : * Returns 0 or errno. errno should be handled, it is either a critical error
227 : : * or -EPROBE_DEFER. 0 means no critical error but it does not mean all
228 : : * regulators have been found because they all are optional. If you require
229 : : * certain regulators, you need to check separately in your driver if they got
230 : : * populated after calling this function.
231 : : */
232 : 0 : int mmc_regulator_get_supply(struct mmc_host *mmc)
233 : : {
234 : 0 : struct device *dev = mmc_dev(mmc);
235 : : int ret;
236 : :
237 : 0 : mmc->supply.vmmc = devm_regulator_get_optional(dev, "vmmc");
238 : 0 : mmc->supply.vqmmc = devm_regulator_get_optional(dev, "vqmmc");
239 : :
240 [ # # ]: 0 : if (IS_ERR(mmc->supply.vmmc)) {
241 [ # # ]: 0 : if (PTR_ERR(mmc->supply.vmmc) == -EPROBE_DEFER)
242 : : return -EPROBE_DEFER;
243 : : dev_dbg(dev, "No vmmc regulator found\n");
244 : : } else {
245 : 0 : ret = mmc_regulator_get_ocrmask(mmc->supply.vmmc);
246 [ # # ]: 0 : if (ret > 0)
247 : 0 : mmc->ocr_avail = ret;
248 : : else
249 : 0 : dev_warn(dev, "Failed getting OCR mask: %d\n", ret);
250 : : }
251 : :
252 [ # # ]: 0 : if (IS_ERR(mmc->supply.vqmmc)) {
253 [ # # ]: 0 : if (PTR_ERR(mmc->supply.vqmmc) == -EPROBE_DEFER)
254 : : return -EPROBE_DEFER;
255 : : dev_dbg(dev, "No vqmmc regulator found\n");
256 : : }
257 : :
258 : 0 : return 0;
259 : : }
260 : : EXPORT_SYMBOL_GPL(mmc_regulator_get_supply);
|
