Commit | Line | Data |
---|---|---|
c4a54b8d MB |
1 | /* |
2 | * helpers.c -- Voltage/Current Regulator framework helper functions. | |
3 | * | |
4 | * Copyright 2007, 2008 Wolfson Microelectronics PLC. | |
5 | * Copyright 2008 SlimLogic Ltd. | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify it | |
8 | * under the terms of the GNU General Public License as published by the | |
9 | * Free Software Foundation; either version 2 of the License, or (at your | |
10 | * option) any later version. | |
11 | * | |
12 | */ | |
13 | ||
14 | #include <linux/kernel.h> | |
15 | #include <linux/err.h> | |
16 | #include <linux/delay.h> | |
17 | #include <linux/regmap.h> | |
18 | #include <linux/regulator/consumer.h> | |
19 | #include <linux/regulator/driver.h> | |
20 | #include <linux/module.h> | |
21 | ||
22 | /** | |
23 | * regulator_is_enabled_regmap - standard is_enabled() for regmap users | |
24 | * | |
25 | * @rdev: regulator to operate on | |
26 | * | |
27 | * Regulators that use regmap for their register I/O can set the | |
28 | * enable_reg and enable_mask fields in their descriptor and then use | |
29 | * this as their is_enabled operation, saving some code. | |
30 | */ | |
31 | int regulator_is_enabled_regmap(struct regulator_dev *rdev) | |
32 | { | |
33 | unsigned int val; | |
34 | int ret; | |
35 | ||
36 | ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val); | |
37 | if (ret != 0) | |
38 | return ret; | |
39 | ||
40 | if (rdev->desc->enable_is_inverted) | |
41 | return (val & rdev->desc->enable_mask) == 0; | |
42 | else | |
43 | return (val & rdev->desc->enable_mask) != 0; | |
44 | } | |
45 | EXPORT_SYMBOL_GPL(regulator_is_enabled_regmap); | |
46 | ||
47 | /** | |
48 | * regulator_enable_regmap - standard enable() for regmap users | |
49 | * | |
50 | * @rdev: regulator to operate on | |
51 | * | |
52 | * Regulators that use regmap for their register I/O can set the | |
53 | * enable_reg and enable_mask fields in their descriptor and then use | |
54 | * this as their enable() operation, saving some code. | |
55 | */ | |
56 | int regulator_enable_regmap(struct regulator_dev *rdev) | |
57 | { | |
58 | unsigned int val; | |
59 | ||
60 | if (rdev->desc->enable_is_inverted) | |
61 | val = 0; | |
62 | else | |
63 | val = rdev->desc->enable_mask; | |
64 | ||
65 | return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, | |
66 | rdev->desc->enable_mask, val); | |
67 | } | |
68 | EXPORT_SYMBOL_GPL(regulator_enable_regmap); | |
69 | ||
70 | /** | |
71 | * regulator_disable_regmap - standard disable() for regmap users | |
72 | * | |
73 | * @rdev: regulator to operate on | |
74 | * | |
75 | * Regulators that use regmap for their register I/O can set the | |
76 | * enable_reg and enable_mask fields in their descriptor and then use | |
77 | * this as their disable() operation, saving some code. | |
78 | */ | |
79 | int regulator_disable_regmap(struct regulator_dev *rdev) | |
80 | { | |
81 | unsigned int val; | |
82 | ||
83 | if (rdev->desc->enable_is_inverted) | |
84 | val = rdev->desc->enable_mask; | |
85 | else | |
86 | val = 0; | |
87 | ||
88 | return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, | |
89 | rdev->desc->enable_mask, val); | |
90 | } | |
91 | EXPORT_SYMBOL_GPL(regulator_disable_regmap); | |
92 | ||
93 | /** | |
94 | * regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users | |
95 | * | |
96 | * @rdev: regulator to operate on | |
97 | * | |
98 | * Regulators that use regmap for their register I/O can set the | |
99 | * vsel_reg and vsel_mask fields in their descriptor and then use this | |
100 | * as their get_voltage_vsel operation, saving some code. | |
101 | */ | |
102 | int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev) | |
103 | { | |
104 | unsigned int val; | |
105 | int ret; | |
106 | ||
107 | ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val); | |
108 | if (ret != 0) | |
109 | return ret; | |
110 | ||
111 | val &= rdev->desc->vsel_mask; | |
112 | val >>= ffs(rdev->desc->vsel_mask) - 1; | |
113 | ||
114 | return val; | |
115 | } | |
116 | EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_regmap); | |
117 | ||
118 | /** | |
119 | * regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users | |
120 | * | |
121 | * @rdev: regulator to operate on | |
122 | * @sel: Selector to set | |
123 | * | |
124 | * Regulators that use regmap for their register I/O can set the | |
125 | * vsel_reg and vsel_mask fields in their descriptor and then use this | |
126 | * as their set_voltage_vsel operation, saving some code. | |
127 | */ | |
128 | int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel) | |
129 | { | |
130 | int ret; | |
131 | ||
132 | sel <<= ffs(rdev->desc->vsel_mask) - 1; | |
133 | ||
134 | ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg, | |
135 | rdev->desc->vsel_mask, sel); | |
136 | if (ret) | |
137 | return ret; | |
138 | ||
139 | if (rdev->desc->apply_bit) | |
140 | ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg, | |
141 | rdev->desc->apply_bit, | |
142 | rdev->desc->apply_bit); | |
143 | return ret; | |
144 | } | |
145 | EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_regmap); | |
146 | ||
147 | /** | |
148 | * regulator_map_voltage_iterate - map_voltage() based on list_voltage() | |
149 | * | |
150 | * @rdev: Regulator to operate on | |
151 | * @min_uV: Lower bound for voltage | |
152 | * @max_uV: Upper bound for voltage | |
153 | * | |
154 | * Drivers implementing set_voltage_sel() and list_voltage() can use | |
155 | * this as their map_voltage() operation. It will find a suitable | |
156 | * voltage by calling list_voltage() until it gets something in bounds | |
157 | * for the requested voltages. | |
158 | */ | |
159 | int regulator_map_voltage_iterate(struct regulator_dev *rdev, | |
160 | int min_uV, int max_uV) | |
161 | { | |
162 | int best_val = INT_MAX; | |
163 | int selector = 0; | |
164 | int i, ret; | |
165 | ||
166 | /* Find the smallest voltage that falls within the specified | |
167 | * range. | |
168 | */ | |
169 | for (i = 0; i < rdev->desc->n_voltages; i++) { | |
170 | ret = rdev->desc->ops->list_voltage(rdev, i); | |
171 | if (ret < 0) | |
172 | continue; | |
173 | ||
174 | if (ret < best_val && ret >= min_uV && ret <= max_uV) { | |
175 | best_val = ret; | |
176 | selector = i; | |
177 | } | |
178 | } | |
179 | ||
180 | if (best_val != INT_MAX) | |
181 | return selector; | |
182 | else | |
183 | return -EINVAL; | |
184 | } | |
185 | EXPORT_SYMBOL_GPL(regulator_map_voltage_iterate); | |
186 | ||
187 | /** | |
188 | * regulator_map_voltage_ascend - map_voltage() for ascendant voltage list | |
189 | * | |
190 | * @rdev: Regulator to operate on | |
191 | * @min_uV: Lower bound for voltage | |
192 | * @max_uV: Upper bound for voltage | |
193 | * | |
194 | * Drivers that have ascendant voltage list can use this as their | |
195 | * map_voltage() operation. | |
196 | */ | |
197 | int regulator_map_voltage_ascend(struct regulator_dev *rdev, | |
198 | int min_uV, int max_uV) | |
199 | { | |
200 | int i, ret; | |
201 | ||
202 | for (i = 0; i < rdev->desc->n_voltages; i++) { | |
203 | ret = rdev->desc->ops->list_voltage(rdev, i); | |
204 | if (ret < 0) | |
205 | continue; | |
206 | ||
207 | if (ret > max_uV) | |
208 | break; | |
209 | ||
210 | if (ret >= min_uV && ret <= max_uV) | |
211 | return i; | |
212 | } | |
213 | ||
214 | return -EINVAL; | |
215 | } | |
216 | EXPORT_SYMBOL_GPL(regulator_map_voltage_ascend); | |
217 | ||
218 | /** | |
219 | * regulator_map_voltage_linear - map_voltage() for simple linear mappings | |
220 | * | |
221 | * @rdev: Regulator to operate on | |
222 | * @min_uV: Lower bound for voltage | |
223 | * @max_uV: Upper bound for voltage | |
224 | * | |
225 | * Drivers providing min_uV and uV_step in their regulator_desc can | |
226 | * use this as their map_voltage() operation. | |
227 | */ | |
228 | int regulator_map_voltage_linear(struct regulator_dev *rdev, | |
229 | int min_uV, int max_uV) | |
230 | { | |
231 | int ret, voltage; | |
232 | ||
233 | /* Allow uV_step to be 0 for fixed voltage */ | |
234 | if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) { | |
235 | if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV) | |
236 | return 0; | |
237 | else | |
238 | return -EINVAL; | |
239 | } | |
240 | ||
241 | if (!rdev->desc->uV_step) { | |
242 | BUG_ON(!rdev->desc->uV_step); | |
243 | return -EINVAL; | |
244 | } | |
245 | ||
246 | if (min_uV < rdev->desc->min_uV) | |
247 | min_uV = rdev->desc->min_uV; | |
248 | ||
249 | ret = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step); | |
250 | if (ret < 0) | |
251 | return ret; | |
252 | ||
253 | ret += rdev->desc->linear_min_sel; | |
254 | ||
255 | /* Map back into a voltage to verify we're still in bounds */ | |
256 | voltage = rdev->desc->ops->list_voltage(rdev, ret); | |
257 | if (voltage < min_uV || voltage > max_uV) | |
258 | return -EINVAL; | |
259 | ||
260 | return ret; | |
261 | } | |
262 | EXPORT_SYMBOL_GPL(regulator_map_voltage_linear); | |
263 | ||
264 | /** | |
265 | * regulator_map_voltage_linear - map_voltage() for multiple linear ranges | |
266 | * | |
267 | * @rdev: Regulator to operate on | |
268 | * @min_uV: Lower bound for voltage | |
269 | * @max_uV: Upper bound for voltage | |
270 | * | |
271 | * Drivers providing linear_ranges in their descriptor can use this as | |
272 | * their map_voltage() callback. | |
273 | */ | |
274 | int regulator_map_voltage_linear_range(struct regulator_dev *rdev, | |
275 | int min_uV, int max_uV) | |
276 | { | |
277 | const struct regulator_linear_range *range; | |
278 | int ret = -EINVAL; | |
279 | int voltage, i; | |
280 | ||
281 | if (!rdev->desc->n_linear_ranges) { | |
282 | BUG_ON(!rdev->desc->n_linear_ranges); | |
283 | return -EINVAL; | |
284 | } | |
285 | ||
286 | for (i = 0; i < rdev->desc->n_linear_ranges; i++) { | |
287 | range = &rdev->desc->linear_ranges[i]; | |
288 | ||
289 | if (!(min_uV <= range->max_uV && max_uV >= range->min_uV)) | |
290 | continue; | |
291 | ||
292 | if (min_uV <= range->min_uV) | |
293 | min_uV = range->min_uV; | |
294 | ||
295 | /* range->uV_step == 0 means fixed voltage range */ | |
296 | if (range->uV_step == 0) { | |
297 | ret = 0; | |
298 | } else { | |
299 | ret = DIV_ROUND_UP(min_uV - range->min_uV, | |
300 | range->uV_step); | |
301 | if (ret < 0) | |
302 | return ret; | |
303 | } | |
304 | ||
305 | ret += range->min_sel; | |
306 | ||
307 | break; | |
308 | } | |
309 | ||
310 | if (i == rdev->desc->n_linear_ranges) | |
311 | return -EINVAL; | |
312 | ||
313 | /* Map back into a voltage to verify we're still in bounds */ | |
314 | voltage = rdev->desc->ops->list_voltage(rdev, ret); | |
315 | if (voltage < min_uV || voltage > max_uV) | |
316 | return -EINVAL; | |
317 | ||
318 | return ret; | |
319 | } | |
320 | EXPORT_SYMBOL_GPL(regulator_map_voltage_linear_range); | |
321 | ||
322 | /** | |
323 | * regulator_set_bypass_regmap - Default set_bypass() using regmap | |
324 | * | |
325 | * @rdev: device to operate on. | |
326 | * @enable: state to set. | |
327 | */ | |
328 | int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable) | |
329 | { | |
330 | unsigned int val; | |
331 | ||
332 | if (enable) | |
333 | val = rdev->desc->bypass_mask; | |
334 | else | |
335 | val = 0; | |
336 | ||
337 | return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg, | |
338 | rdev->desc->bypass_mask, val); | |
339 | } | |
340 | EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap); | |
341 | ||
342 | /** | |
343 | * regulator_get_bypass_regmap - Default get_bypass() using regmap | |
344 | * | |
345 | * @rdev: device to operate on. | |
346 | * @enable: current state. | |
347 | */ | |
348 | int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable) | |
349 | { | |
350 | unsigned int val; | |
351 | int ret; | |
352 | ||
353 | ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val); | |
354 | if (ret != 0) | |
355 | return ret; | |
356 | ||
357 | *enable = val & rdev->desc->bypass_mask; | |
358 | ||
359 | return 0; | |
360 | } | |
361 | EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap); |