Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2//
3// helpers.c -- Voltage/Current Regulator framework helper functions.
4//
5// Copyright 2007, 2008 Wolfson Microelectronics PLC.
6// Copyright 2008 SlimLogic Ltd.
7
8#include <linux/kernel.h>
9#include <linux/err.h>
10#include <linux/delay.h>
11#include <linux/regmap.h>
12#include <linux/regulator/consumer.h>
13#include <linux/regulator/driver.h>
14#include <linux/module.h>
15
16#include "internal.h"
17
18/**
19 * regulator_is_enabled_regmap - standard is_enabled() for regmap users
20 *
21 * @rdev: regulator to operate on
22 *
23 * Regulators that use regmap for their register I/O can set the
24 * enable_reg and enable_mask fields in their descriptor and then use
25 * this as their is_enabled operation, saving some code.
26 */
27int regulator_is_enabled_regmap(struct regulator_dev *rdev)
28{
29 unsigned int val;
30 int ret;
31
32 ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
33 if (ret != 0)
34 return ret;
35
36 val &= rdev->desc->enable_mask;
37
38 if (rdev->desc->enable_is_inverted) {
39 if (rdev->desc->enable_val)
40 return val != rdev->desc->enable_val;
41 return val == 0;
42 } else {
43 if (rdev->desc->enable_val)
44 return val == rdev->desc->enable_val;
45 return val != 0;
46 }
47}
48EXPORT_SYMBOL_GPL(regulator_is_enabled_regmap);
49
50/**
51 * regulator_enable_regmap - standard enable() for regmap users
52 *
53 * @rdev: regulator to operate on
54 *
55 * Regulators that use regmap for their register I/O can set the
56 * enable_reg and enable_mask fields in their descriptor and then use
57 * this as their enable() operation, saving some code.
58 */
59int regulator_enable_regmap(struct regulator_dev *rdev)
60{
61 unsigned int val;
62
63 if (rdev->desc->enable_is_inverted) {
64 val = rdev->desc->disable_val;
65 } else {
66 val = rdev->desc->enable_val;
67 if (!val)
68 val = rdev->desc->enable_mask;
69 }
70
71 return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
72 rdev->desc->enable_mask, val);
73}
74EXPORT_SYMBOL_GPL(regulator_enable_regmap);
75
76/**
77 * regulator_disable_regmap - standard disable() for regmap users
78 *
79 * @rdev: regulator to operate on
80 *
81 * Regulators that use regmap for their register I/O can set the
82 * enable_reg and enable_mask fields in their descriptor and then use
83 * this as their disable() operation, saving some code.
84 */
85int regulator_disable_regmap(struct regulator_dev *rdev)
86{
87 unsigned int val;
88
89 if (rdev->desc->enable_is_inverted) {
90 val = rdev->desc->enable_val;
91 if (!val)
92 val = rdev->desc->enable_mask;
93 } else {
94 val = rdev->desc->disable_val;
95 }
96
97 return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
98 rdev->desc->enable_mask, val);
99}
100EXPORT_SYMBOL_GPL(regulator_disable_regmap);
101
102static int regulator_range_selector_to_index(struct regulator_dev *rdev,
103 unsigned int rval)
104{
105 int i;
106
107 if (!rdev->desc->linear_range_selectors)
108 return -EINVAL;
109
110 rval &= rdev->desc->vsel_range_mask;
111
112 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
113 if (rdev->desc->linear_range_selectors[i] == rval)
114 return i;
115 }
116 return -EINVAL;
117}
118
119/**
120 * regulator_get_voltage_sel_pickable_regmap - pickable range get_voltage_sel
121 *
122 * @rdev: regulator to operate on
123 *
124 * Regulators that use regmap for their register I/O and use pickable
125 * ranges can set the vsel_reg, vsel_mask, vsel_range_reg and vsel_range_mask
126 * fields in their descriptor and then use this as their get_voltage_vsel
127 * operation, saving some code.
128 */
129int regulator_get_voltage_sel_pickable_regmap(struct regulator_dev *rdev)
130{
131 unsigned int r_val;
132 int range;
133 unsigned int val;
134 int ret;
135 unsigned int voltages = 0;
136 const struct linear_range *r = rdev->desc->linear_ranges;
137
138 if (!r)
139 return -EINVAL;
140
141 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
142 if (ret != 0)
143 return ret;
144
145 ret = regmap_read(rdev->regmap, rdev->desc->vsel_range_reg, &r_val);
146 if (ret != 0)
147 return ret;
148
149 val &= rdev->desc->vsel_mask;
150 val >>= ffs(rdev->desc->vsel_mask) - 1;
151
152 range = regulator_range_selector_to_index(rdev, r_val);
153 if (range < 0)
154 return -EINVAL;
155
156 voltages = linear_range_values_in_range_array(r, range);
157
158 return val + voltages;
159}
160EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_pickable_regmap);
161
162/**
163 * regulator_set_voltage_sel_pickable_regmap - pickable range set_voltage_sel
164 *
165 * @rdev: regulator to operate on
166 * @sel: Selector to set
167 *
168 * Regulators that use regmap for their register I/O and use pickable
169 * ranges can set the vsel_reg, vsel_mask, vsel_range_reg and vsel_range_mask
170 * fields in their descriptor and then use this as their set_voltage_vsel
171 * operation, saving some code.
172 */
173int regulator_set_voltage_sel_pickable_regmap(struct regulator_dev *rdev,
174 unsigned int sel)
175{
176 unsigned int range;
177 int ret, i;
178 unsigned int voltages_in_range = 0;
179
180 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
181 const struct linear_range *r;
182
183 r = &rdev->desc->linear_ranges[i];
184 voltages_in_range = linear_range_values_in_range(r);
185
186 if (sel < voltages_in_range)
187 break;
188 sel -= voltages_in_range;
189 }
190
191 if (i == rdev->desc->n_linear_ranges)
192 return -EINVAL;
193
194 sel <<= ffs(rdev->desc->vsel_mask) - 1;
195 sel += rdev->desc->linear_ranges[i].min_sel;
196
197 range = rdev->desc->linear_range_selectors[i];
198
199 if (rdev->desc->vsel_reg == rdev->desc->vsel_range_reg) {
200 ret = regmap_update_bits(rdev->regmap,
201 rdev->desc->vsel_reg,
202 rdev->desc->vsel_range_mask |
203 rdev->desc->vsel_mask, sel | range);
204 } else {
205 ret = regmap_update_bits(rdev->regmap,
206 rdev->desc->vsel_range_reg,
207 rdev->desc->vsel_range_mask, range);
208 if (ret)
209 return ret;
210
211 ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
212 rdev->desc->vsel_mask, sel);
213 }
214
215 if (ret)
216 return ret;
217
218 if (rdev->desc->apply_bit)
219 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
220 rdev->desc->apply_bit,
221 rdev->desc->apply_bit);
222 return ret;
223}
224EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_pickable_regmap);
225
226/**
227 * regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users
228 *
229 * @rdev: regulator to operate on
230 *
231 * Regulators that use regmap for their register I/O can set the
232 * vsel_reg and vsel_mask fields in their descriptor and then use this
233 * as their get_voltage_vsel operation, saving some code.
234 */
235int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev)
236{
237 unsigned int val;
238 int ret;
239
240 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
241 if (ret != 0)
242 return ret;
243
244 val &= rdev->desc->vsel_mask;
245 val >>= ffs(rdev->desc->vsel_mask) - 1;
246
247 return val;
248}
249EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_regmap);
250
251/**
252 * regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users
253 *
254 * @rdev: regulator to operate on
255 * @sel: Selector to set
256 *
257 * Regulators that use regmap for their register I/O can set the
258 * vsel_reg and vsel_mask fields in their descriptor and then use this
259 * as their set_voltage_vsel operation, saving some code.
260 */
261int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel)
262{
263 int ret;
264
265 sel <<= ffs(rdev->desc->vsel_mask) - 1;
266
267 ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
268 rdev->desc->vsel_mask, sel);
269 if (ret)
270 return ret;
271
272 if (rdev->desc->apply_bit)
273 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
274 rdev->desc->apply_bit,
275 rdev->desc->apply_bit);
276 return ret;
277}
278EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_regmap);
279
280/**
281 * regulator_map_voltage_iterate - map_voltage() based on list_voltage()
282 *
283 * @rdev: Regulator to operate on
284 * @min_uV: Lower bound for voltage
285 * @max_uV: Upper bound for voltage
286 *
287 * Drivers implementing set_voltage_sel() and list_voltage() can use
288 * this as their map_voltage() operation. It will find a suitable
289 * voltage by calling list_voltage() until it gets something in bounds
290 * for the requested voltages.
291 */
292int regulator_map_voltage_iterate(struct regulator_dev *rdev,
293 int min_uV, int max_uV)
294{
295 int best_val = INT_MAX;
296 int selector = 0;
297 int i, ret;
298
299 /* Find the smallest voltage that falls within the specified
300 * range.
301 */
302 for (i = 0; i < rdev->desc->n_voltages; i++) {
303 ret = rdev->desc->ops->list_voltage(rdev, i);
304 if (ret < 0)
305 continue;
306
307 if (ret < best_val && ret >= min_uV && ret <= max_uV) {
308 best_val = ret;
309 selector = i;
310 }
311 }
312
313 if (best_val != INT_MAX)
314 return selector;
315 else
316 return -EINVAL;
317}
318EXPORT_SYMBOL_GPL(regulator_map_voltage_iterate);
319
320/**
321 * regulator_map_voltage_ascend - map_voltage() for ascendant voltage list
322 *
323 * @rdev: Regulator to operate on
324 * @min_uV: Lower bound for voltage
325 * @max_uV: Upper bound for voltage
326 *
327 * Drivers that have ascendant voltage list can use this as their
328 * map_voltage() operation.
329 */
330int regulator_map_voltage_ascend(struct regulator_dev *rdev,
331 int min_uV, int max_uV)
332{
333 int i, ret;
334
335 for (i = 0; i < rdev->desc->n_voltages; i++) {
336 ret = rdev->desc->ops->list_voltage(rdev, i);
337 if (ret < 0)
338 continue;
339
340 if (ret > max_uV)
341 break;
342
343 if (ret >= min_uV && ret <= max_uV)
344 return i;
345 }
346
347 return -EINVAL;
348}
349EXPORT_SYMBOL_GPL(regulator_map_voltage_ascend);
350
351/**
352 * regulator_map_voltage_linear - map_voltage() for simple linear mappings
353 *
354 * @rdev: Regulator to operate on
355 * @min_uV: Lower bound for voltage
356 * @max_uV: Upper bound for voltage
357 *
358 * Drivers providing min_uV and uV_step in their regulator_desc can
359 * use this as their map_voltage() operation.
360 */
361int regulator_map_voltage_linear(struct regulator_dev *rdev,
362 int min_uV, int max_uV)
363{
364 int ret, voltage;
365
366 /* Allow uV_step to be 0 for fixed voltage */
367 if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) {
368 if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV)
369 return 0;
370 else
371 return -EINVAL;
372 }
373
374 if (!rdev->desc->uV_step) {
375 BUG_ON(!rdev->desc->uV_step);
376 return -EINVAL;
377 }
378
379 if (min_uV < rdev->desc->min_uV)
380 min_uV = rdev->desc->min_uV;
381
382 ret = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step);
383 if (ret < 0)
384 return ret;
385
386 ret += rdev->desc->linear_min_sel;
387
388 /* Map back into a voltage to verify we're still in bounds */
389 voltage = rdev->desc->ops->list_voltage(rdev, ret);
390 if (voltage < min_uV || voltage > max_uV)
391 return -EINVAL;
392
393 return ret;
394}
395EXPORT_SYMBOL_GPL(regulator_map_voltage_linear);
396
397/**
398 * regulator_map_voltage_linear_range - map_voltage() for multiple linear ranges
399 *
400 * @rdev: Regulator to operate on
401 * @min_uV: Lower bound for voltage
402 * @max_uV: Upper bound for voltage
403 *
404 * Drivers providing linear_ranges in their descriptor can use this as
405 * their map_voltage() callback.
406 */
407int regulator_map_voltage_linear_range(struct regulator_dev *rdev,
408 int min_uV, int max_uV)
409{
410 const struct linear_range *range;
411 int ret = -EINVAL;
412 unsigned int sel;
413 bool found;
414 int voltage, i;
415
416 if (!rdev->desc->n_linear_ranges) {
417 BUG_ON(!rdev->desc->n_linear_ranges);
418 return -EINVAL;
419 }
420
421 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
422 range = &rdev->desc->linear_ranges[i];
423
424 ret = linear_range_get_selector_high(range, min_uV, &sel,
425 &found);
426 if (ret)
427 continue;
428 ret = sel;
429
430 /*
431 * Map back into a voltage to verify we're still in bounds.
432 * If we are not, then continue checking rest of the ranges.
433 */
434 voltage = rdev->desc->ops->list_voltage(rdev, sel);
435 if (voltage >= min_uV && voltage <= max_uV)
436 break;
437 }
438
439 if (i == rdev->desc->n_linear_ranges)
440 return -EINVAL;
441
442 return ret;
443}
444EXPORT_SYMBOL_GPL(regulator_map_voltage_linear_range);
445
446/**
447 * regulator_map_voltage_pickable_linear_range - map_voltage, pickable ranges
448 *
449 * @rdev: Regulator to operate on
450 * @min_uV: Lower bound for voltage
451 * @max_uV: Upper bound for voltage
452 *
453 * Drivers providing pickable linear_ranges in their descriptor can use
454 * this as their map_voltage() callback.
455 */
456int regulator_map_voltage_pickable_linear_range(struct regulator_dev *rdev,
457 int min_uV, int max_uV)
458{
459 const struct linear_range *range;
460 int ret = -EINVAL;
461 int voltage, i;
462 unsigned int selector = 0;
463
464 if (!rdev->desc->n_linear_ranges) {
465 BUG_ON(!rdev->desc->n_linear_ranges);
466 return -EINVAL;
467 }
468
469 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
470 int linear_max_uV;
471 bool found;
472 unsigned int sel;
473
474 range = &rdev->desc->linear_ranges[i];
475 linear_max_uV = linear_range_get_max_value(range);
476
477 if (!(min_uV <= linear_max_uV && max_uV >= range->min)) {
478 selector += linear_range_values_in_range(range);
479 continue;
480 }
481
482 ret = linear_range_get_selector_high(range, min_uV, &sel,
483 &found);
484 if (ret) {
485 selector += linear_range_values_in_range(range);
486 continue;
487 }
488
489 ret = selector + sel - range->min_sel;
490
491 voltage = rdev->desc->ops->list_voltage(rdev, ret);
492
493 /*
494 * Map back into a voltage to verify we're still in bounds.
495 * We may have overlapping voltage ranges. Hence we don't
496 * exit but retry until we have checked all ranges.
497 */
498 if (voltage < min_uV || voltage > max_uV)
499 selector += linear_range_values_in_range(range);
500 else
501 break;
502 }
503
504 if (i == rdev->desc->n_linear_ranges)
505 return -EINVAL;
506
507 return ret;
508}
509EXPORT_SYMBOL_GPL(regulator_map_voltage_pickable_linear_range);
510
511/**
512 * regulator_list_voltage_linear - List voltages with simple calculation
513 *
514 * @rdev: Regulator device
515 * @selector: Selector to convert into a voltage
516 *
517 * Regulators with a simple linear mapping between voltages and
518 * selectors can set min_uV and uV_step in the regulator descriptor
519 * and then use this function as their list_voltage() operation,
520 */
521int regulator_list_voltage_linear(struct regulator_dev *rdev,
522 unsigned int selector)
523{
524 if (selector >= rdev->desc->n_voltages)
525 return -EINVAL;
526 if (selector < rdev->desc->linear_min_sel)
527 return 0;
528
529 selector -= rdev->desc->linear_min_sel;
530
531 return rdev->desc->min_uV + (rdev->desc->uV_step * selector);
532}
533EXPORT_SYMBOL_GPL(regulator_list_voltage_linear);
534
535/**
536 * regulator_list_voltage_pickable_linear_range - pickable range list voltages
537 *
538 * @rdev: Regulator device
539 * @selector: Selector to convert into a voltage
540 *
541 * list_voltage() operation, intended to be used by drivers utilizing pickable
542 * ranges helpers.
543 */
544int regulator_list_voltage_pickable_linear_range(struct regulator_dev *rdev,
545 unsigned int selector)
546{
547 const struct linear_range *range;
548 int i;
549 unsigned int all_sels = 0;
550
551 if (!rdev->desc->n_linear_ranges) {
552 BUG_ON(!rdev->desc->n_linear_ranges);
553 return -EINVAL;
554 }
555
556 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
557 unsigned int sel_indexes;
558
559 range = &rdev->desc->linear_ranges[i];
560
561 sel_indexes = linear_range_values_in_range(range) - 1;
562
563 if (all_sels + sel_indexes >= selector) {
564 selector -= all_sels;
565 /*
566 * As we see here, pickable ranges work only as
567 * long as the first selector for each pickable
568 * range is 0, and the each subsequent range for
569 * this 'pick' follow immediately at next unused
570 * selector (Eg. there is no gaps between ranges).
571 * I think this is fine but it probably should be
572 * documented. OTOH, whole pickable range stuff
573 * might benefit from some documentation
574 */
575 return range->min + (range->step * selector);
576 }
577
578 all_sels += (sel_indexes + 1);
579 }
580
581 return -EINVAL;
582}
583EXPORT_SYMBOL_GPL(regulator_list_voltage_pickable_linear_range);
584
585/**
586 * regulator_desc_list_voltage_linear_range - List voltages for linear ranges
587 *
588 * @desc: Regulator desc for regulator which volatges are to be listed
589 * @selector: Selector to convert into a voltage
590 *
591 * Regulators with a series of simple linear mappings between voltages
592 * and selectors who have set linear_ranges in the regulator descriptor
593 * can use this function prior regulator registration to list voltages.
594 * This is useful when voltages need to be listed during device-tree
595 * parsing.
596 */
597int regulator_desc_list_voltage_linear_range(const struct regulator_desc *desc,
598 unsigned int selector)
599{
600 unsigned int val;
601 int ret;
602
603 BUG_ON(!desc->n_linear_ranges);
604
605 ret = linear_range_get_value_array(desc->linear_ranges,
606 desc->n_linear_ranges, selector,
607 &val);
608 if (ret)
609 return ret;
610
611 return val;
612}
613EXPORT_SYMBOL_GPL(regulator_desc_list_voltage_linear_range);
614
615/**
616 * regulator_list_voltage_linear_range - List voltages for linear ranges
617 *
618 * @rdev: Regulator device
619 * @selector: Selector to convert into a voltage
620 *
621 * Regulators with a series of simple linear mappings between voltages
622 * and selectors can set linear_ranges in the regulator descriptor and
623 * then use this function as their list_voltage() operation,
624 */
625int regulator_list_voltage_linear_range(struct regulator_dev *rdev,
626 unsigned int selector)
627{
628 return regulator_desc_list_voltage_linear_range(rdev->desc, selector);
629}
630EXPORT_SYMBOL_GPL(regulator_list_voltage_linear_range);
631
632/**
633 * regulator_list_voltage_table - List voltages with table based mapping
634 *
635 * @rdev: Regulator device
636 * @selector: Selector to convert into a voltage
637 *
638 * Regulators with table based mapping between voltages and
639 * selectors can set volt_table in the regulator descriptor
640 * and then use this function as their list_voltage() operation.
641 */
642int regulator_list_voltage_table(struct regulator_dev *rdev,
643 unsigned int selector)
644{
645 if (!rdev->desc->volt_table) {
646 BUG_ON(!rdev->desc->volt_table);
647 return -EINVAL;
648 }
649
650 if (selector >= rdev->desc->n_voltages)
651 return -EINVAL;
652
653 return rdev->desc->volt_table[selector];
654}
655EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
656
657/**
658 * regulator_set_bypass_regmap - Default set_bypass() using regmap
659 *
660 * @rdev: device to operate on.
661 * @enable: state to set.
662 */
663int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
664{
665 unsigned int val;
666
667 if (enable) {
668 val = rdev->desc->bypass_val_on;
669 if (!val)
670 val = rdev->desc->bypass_mask;
671 } else {
672 val = rdev->desc->bypass_val_off;
673 }
674
675 return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
676 rdev->desc->bypass_mask, val);
677}
678EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap);
679
680/**
681 * regulator_set_soft_start_regmap - Default set_soft_start() using regmap
682 *
683 * @rdev: device to operate on.
684 */
685int regulator_set_soft_start_regmap(struct regulator_dev *rdev)
686{
687 unsigned int val;
688
689 val = rdev->desc->soft_start_val_on;
690 if (!val)
691 val = rdev->desc->soft_start_mask;
692
693 return regmap_update_bits(rdev->regmap, rdev->desc->soft_start_reg,
694 rdev->desc->soft_start_mask, val);
695}
696EXPORT_SYMBOL_GPL(regulator_set_soft_start_regmap);
697
698/**
699 * regulator_set_pull_down_regmap - Default set_pull_down() using regmap
700 *
701 * @rdev: device to operate on.
702 */
703int regulator_set_pull_down_regmap(struct regulator_dev *rdev)
704{
705 unsigned int val;
706
707 val = rdev->desc->pull_down_val_on;
708 if (!val)
709 val = rdev->desc->pull_down_mask;
710
711 return regmap_update_bits(rdev->regmap, rdev->desc->pull_down_reg,
712 rdev->desc->pull_down_mask, val);
713}
714EXPORT_SYMBOL_GPL(regulator_set_pull_down_regmap);
715
716/**
717 * regulator_get_bypass_regmap - Default get_bypass() using regmap
718 *
719 * @rdev: device to operate on.
720 * @enable: current state.
721 */
722int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable)
723{
724 unsigned int val;
725 unsigned int val_on = rdev->desc->bypass_val_on;
726 int ret;
727
728 ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val);
729 if (ret != 0)
730 return ret;
731
732 if (!val_on)
733 val_on = rdev->desc->bypass_mask;
734
735 *enable = (val & rdev->desc->bypass_mask) == val_on;
736
737 return 0;
738}
739EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap);
740
741/**
742 * regulator_set_active_discharge_regmap - Default set_active_discharge()
743 * using regmap
744 *
745 * @rdev: device to operate on.
746 * @enable: state to set, 0 to disable and 1 to enable.
747 */
748int regulator_set_active_discharge_regmap(struct regulator_dev *rdev,
749 bool enable)
750{
751 unsigned int val;
752
753 if (enable)
754 val = rdev->desc->active_discharge_on;
755 else
756 val = rdev->desc->active_discharge_off;
757
758 return regmap_update_bits(rdev->regmap,
759 rdev->desc->active_discharge_reg,
760 rdev->desc->active_discharge_mask, val);
761}
762EXPORT_SYMBOL_GPL(regulator_set_active_discharge_regmap);
763
764/**
765 * regulator_set_current_limit_regmap - set_current_limit for regmap users
766 *
767 * @rdev: regulator to operate on
768 * @min_uA: Lower bound for current limit
769 * @max_uA: Upper bound for current limit
770 *
771 * Regulators that use regmap for their register I/O can set curr_table,
772 * csel_reg and csel_mask fields in their descriptor and then use this
773 * as their set_current_limit operation, saving some code.
774 */
775int regulator_set_current_limit_regmap(struct regulator_dev *rdev,
776 int min_uA, int max_uA)
777{
778 unsigned int n_currents = rdev->desc->n_current_limits;
779 int i, sel = -1;
780
781 if (n_currents == 0)
782 return -EINVAL;
783
784 if (rdev->desc->curr_table) {
785 const unsigned int *curr_table = rdev->desc->curr_table;
786 bool ascend = curr_table[n_currents - 1] > curr_table[0];
787
788 /* search for closest to maximum */
789 if (ascend) {
790 for (i = n_currents - 1; i >= 0; i--) {
791 if (min_uA <= curr_table[i] &&
792 curr_table[i] <= max_uA) {
793 sel = i;
794 break;
795 }
796 }
797 } else {
798 for (i = 0; i < n_currents; i++) {
799 if (min_uA <= curr_table[i] &&
800 curr_table[i] <= max_uA) {
801 sel = i;
802 break;
803 }
804 }
805 }
806 }
807
808 if (sel < 0)
809 return -EINVAL;
810
811 sel <<= ffs(rdev->desc->csel_mask) - 1;
812
813 return regmap_update_bits(rdev->regmap, rdev->desc->csel_reg,
814 rdev->desc->csel_mask, sel);
815}
816EXPORT_SYMBOL_GPL(regulator_set_current_limit_regmap);
817
818/**
819 * regulator_get_current_limit_regmap - get_current_limit for regmap users
820 *
821 * @rdev: regulator to operate on
822 *
823 * Regulators that use regmap for their register I/O can set the
824 * csel_reg and csel_mask fields in their descriptor and then use this
825 * as their get_current_limit operation, saving some code.
826 */
827int regulator_get_current_limit_regmap(struct regulator_dev *rdev)
828{
829 unsigned int val;
830 int ret;
831
832 ret = regmap_read(rdev->regmap, rdev->desc->csel_reg, &val);
833 if (ret != 0)
834 return ret;
835
836 val &= rdev->desc->csel_mask;
837 val >>= ffs(rdev->desc->csel_mask) - 1;
838
839 if (rdev->desc->curr_table) {
840 if (val >= rdev->desc->n_current_limits)
841 return -EINVAL;
842
843 return rdev->desc->curr_table[val];
844 }
845
846 return -EINVAL;
847}
848EXPORT_SYMBOL_GPL(regulator_get_current_limit_regmap);
849
850/**
851 * regulator_bulk_set_supply_names - initialize the 'supply' fields in an array
852 * of regulator_bulk_data structs
853 *
854 * @consumers: array of regulator_bulk_data entries to initialize
855 * @supply_names: array of supply name strings
856 * @num_supplies: number of supply names to initialize
857 *
858 * Note: the 'consumers' array must be the size of 'num_supplies'.
859 */
860void regulator_bulk_set_supply_names(struct regulator_bulk_data *consumers,
861 const char *const *supply_names,
862 unsigned int num_supplies)
863{
864 unsigned int i;
865
866 for (i = 0; i < num_supplies; i++)
867 consumers[i].supply = supply_names[i];
868}
869EXPORT_SYMBOL_GPL(regulator_bulk_set_supply_names);
870
871/**
872 * regulator_is_equal - test whether two regulators are the same
873 *
874 * @reg1: first regulator to operate on
875 * @reg2: second regulator to operate on
876 */
877bool regulator_is_equal(struct regulator *reg1, struct regulator *reg2)
878{
879 return reg1->rdev == reg2->rdev;
880}
881EXPORT_SYMBOL_GPL(regulator_is_equal);
1// SPDX-License-Identifier: GPL-2.0-or-later
2//
3// helpers.c -- Voltage/Current Regulator framework helper functions.
4//
5// Copyright 2007, 2008 Wolfson Microelectronics PLC.
6// Copyright 2008 SlimLogic Ltd.
7
8#include <linux/bitops.h>
9#include <linux/delay.h>
10#include <linux/err.h>
11#include <linux/export.h>
12#include <linux/kernel.h>
13#include <linux/regmap.h>
14#include <linux/regulator/consumer.h>
15#include <linux/regulator/driver.h>
16
17#include "internal.h"
18
19/**
20 * regulator_is_enabled_regmap - standard is_enabled() for regmap users
21 *
22 * @rdev: regulator to operate on
23 *
24 * Regulators that use regmap for their register I/O can set the
25 * enable_reg and enable_mask fields in their descriptor and then use
26 * this as their is_enabled operation, saving some code.
27 */
28int regulator_is_enabled_regmap(struct regulator_dev *rdev)
29{
30 unsigned int val;
31 int ret;
32
33 ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
34 if (ret != 0)
35 return ret;
36
37 val &= rdev->desc->enable_mask;
38
39 if (rdev->desc->enable_is_inverted) {
40 if (rdev->desc->enable_val)
41 return val != rdev->desc->enable_val;
42 return val == 0;
43 } else {
44 if (rdev->desc->enable_val)
45 return val == rdev->desc->enable_val;
46 return val != 0;
47 }
48}
49EXPORT_SYMBOL_GPL(regulator_is_enabled_regmap);
50
51/**
52 * regulator_enable_regmap - standard enable() for regmap users
53 *
54 * @rdev: regulator to operate on
55 *
56 * Regulators that use regmap for their register I/O can set the
57 * enable_reg and enable_mask fields in their descriptor and then use
58 * this as their enable() operation, saving some code.
59 */
60int regulator_enable_regmap(struct regulator_dev *rdev)
61{
62 unsigned int val;
63
64 if (rdev->desc->enable_is_inverted) {
65 val = rdev->desc->disable_val;
66 } else {
67 val = rdev->desc->enable_val;
68 if (!val)
69 val = rdev->desc->enable_mask;
70 }
71
72 return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
73 rdev->desc->enable_mask, val);
74}
75EXPORT_SYMBOL_GPL(regulator_enable_regmap);
76
77/**
78 * regulator_disable_regmap - standard disable() for regmap users
79 *
80 * @rdev: regulator to operate on
81 *
82 * Regulators that use regmap for their register I/O can set the
83 * enable_reg and enable_mask fields in their descriptor and then use
84 * this as their disable() operation, saving some code.
85 */
86int regulator_disable_regmap(struct regulator_dev *rdev)
87{
88 unsigned int val;
89
90 if (rdev->desc->enable_is_inverted) {
91 val = rdev->desc->enable_val;
92 if (!val)
93 val = rdev->desc->enable_mask;
94 } else {
95 val = rdev->desc->disable_val;
96 }
97
98 return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
99 rdev->desc->enable_mask, val);
100}
101EXPORT_SYMBOL_GPL(regulator_disable_regmap);
102
103static int regulator_range_selector_to_index(struct regulator_dev *rdev,
104 unsigned int rval)
105{
106 int i;
107
108 if (!rdev->desc->linear_range_selectors_bitfield)
109 return -EINVAL;
110
111 rval &= rdev->desc->vsel_range_mask;
112 rval >>= ffs(rdev->desc->vsel_range_mask) - 1;
113
114 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
115 if (rdev->desc->linear_range_selectors_bitfield[i] == rval)
116 return i;
117 }
118 return -EINVAL;
119}
120
121/**
122 * regulator_get_voltage_sel_pickable_regmap - pickable range get_voltage_sel
123 *
124 * @rdev: regulator to operate on
125 *
126 * Regulators that use regmap for their register I/O and use pickable
127 * ranges can set the vsel_reg, vsel_mask, vsel_range_reg and vsel_range_mask
128 * fields in their descriptor and then use this as their get_voltage_vsel
129 * operation, saving some code.
130 */
131int regulator_get_voltage_sel_pickable_regmap(struct regulator_dev *rdev)
132{
133 unsigned int r_val;
134 int range;
135 unsigned int val;
136 int ret;
137 unsigned int voltages = 0;
138 const struct linear_range *r = rdev->desc->linear_ranges;
139
140 if (!r)
141 return -EINVAL;
142
143 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
144 if (ret != 0)
145 return ret;
146
147 ret = regmap_read(rdev->regmap, rdev->desc->vsel_range_reg, &r_val);
148 if (ret != 0)
149 return ret;
150
151 val &= rdev->desc->vsel_mask;
152 val >>= ffs(rdev->desc->vsel_mask) - 1;
153
154 range = regulator_range_selector_to_index(rdev, r_val);
155 if (range < 0)
156 return -EINVAL;
157
158 voltages = linear_range_values_in_range_array(r, range);
159
160 return val + voltages;
161}
162EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_pickable_regmap);
163
164static int write_separate_vsel_and_range(struct regulator_dev *rdev,
165 unsigned int sel, unsigned int range)
166{
167 bool range_updated;
168 int ret;
169
170 ret = regmap_update_bits_base(rdev->regmap, rdev->desc->vsel_range_reg,
171 rdev->desc->vsel_range_mask,
172 range, &range_updated, false, false);
173 if (ret)
174 return ret;
175
176 /*
177 * Some PMICs treat the vsel_reg same as apply-bit. Force it to be
178 * written if the range changed, even if the old selector was same as
179 * the new one
180 */
181 if (rdev->desc->range_applied_by_vsel && range_updated)
182 return regmap_write_bits(rdev->regmap,
183 rdev->desc->vsel_reg,
184 rdev->desc->vsel_mask, sel);
185
186 return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
187 rdev->desc->vsel_mask, sel);
188}
189
190/**
191 * regulator_set_voltage_sel_pickable_regmap - pickable range set_voltage_sel
192 *
193 * @rdev: regulator to operate on
194 * @sel: Selector to set
195 *
196 * Regulators that use regmap for their register I/O and use pickable
197 * ranges can set the vsel_reg, vsel_mask, vsel_range_reg and vsel_range_mask
198 * fields in their descriptor and then use this as their set_voltage_vsel
199 * operation, saving some code.
200 */
201int regulator_set_voltage_sel_pickable_regmap(struct regulator_dev *rdev,
202 unsigned int sel)
203{
204 unsigned int range;
205 int ret, i;
206 unsigned int voltages_in_range = 0;
207
208 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
209 const struct linear_range *r;
210
211 r = &rdev->desc->linear_ranges[i];
212 voltages_in_range = linear_range_values_in_range(r);
213
214 if (sel < voltages_in_range)
215 break;
216 sel -= voltages_in_range;
217 }
218
219 if (i == rdev->desc->n_linear_ranges)
220 return -EINVAL;
221
222 sel <<= ffs(rdev->desc->vsel_mask) - 1;
223 sel += rdev->desc->linear_ranges[i].min_sel;
224
225 range = rdev->desc->linear_range_selectors_bitfield[i];
226 range <<= ffs(rdev->desc->vsel_range_mask) - 1;
227
228 if (rdev->desc->vsel_reg == rdev->desc->vsel_range_reg)
229 ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
230 rdev->desc->vsel_range_mask |
231 rdev->desc->vsel_mask, sel | range);
232 else
233 ret = write_separate_vsel_and_range(rdev, sel, range);
234
235 if (ret)
236 return ret;
237
238 if (rdev->desc->apply_bit)
239 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
240 rdev->desc->apply_bit,
241 rdev->desc->apply_bit);
242 return ret;
243}
244EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_pickable_regmap);
245
246/**
247 * regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users
248 *
249 * @rdev: regulator to operate on
250 *
251 * Regulators that use regmap for their register I/O can set the
252 * vsel_reg and vsel_mask fields in their descriptor and then use this
253 * as their get_voltage_vsel operation, saving some code.
254 */
255int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev)
256{
257 unsigned int val;
258 int ret;
259
260 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
261 if (ret != 0)
262 return ret;
263
264 val &= rdev->desc->vsel_mask;
265 val >>= ffs(rdev->desc->vsel_mask) - 1;
266
267 return val;
268}
269EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_regmap);
270
271/**
272 * regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users
273 *
274 * @rdev: regulator to operate on
275 * @sel: Selector to set
276 *
277 * Regulators that use regmap for their register I/O can set the
278 * vsel_reg and vsel_mask fields in their descriptor and then use this
279 * as their set_voltage_vsel operation, saving some code.
280 */
281int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel)
282{
283 int ret;
284
285 sel <<= ffs(rdev->desc->vsel_mask) - 1;
286
287 ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
288 rdev->desc->vsel_mask, sel);
289 if (ret)
290 return ret;
291
292 if (rdev->desc->apply_bit)
293 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
294 rdev->desc->apply_bit,
295 rdev->desc->apply_bit);
296 return ret;
297}
298EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_regmap);
299
300/**
301 * regulator_map_voltage_iterate - map_voltage() based on list_voltage()
302 *
303 * @rdev: Regulator to operate on
304 * @min_uV: Lower bound for voltage
305 * @max_uV: Upper bound for voltage
306 *
307 * Drivers implementing set_voltage_sel() and list_voltage() can use
308 * this as their map_voltage() operation. It will find a suitable
309 * voltage by calling list_voltage() until it gets something in bounds
310 * for the requested voltages.
311 */
312int regulator_map_voltage_iterate(struct regulator_dev *rdev,
313 int min_uV, int max_uV)
314{
315 int best_val = INT_MAX;
316 int selector = 0;
317 int i, ret;
318
319 /* Find the smallest voltage that falls within the specified
320 * range.
321 */
322 for (i = 0; i < rdev->desc->n_voltages; i++) {
323 ret = rdev->desc->ops->list_voltage(rdev, i);
324 if (ret < 0)
325 continue;
326
327 if (ret < best_val && ret >= min_uV && ret <= max_uV) {
328 best_val = ret;
329 selector = i;
330 }
331 }
332
333 if (best_val != INT_MAX)
334 return selector;
335 else
336 return -EINVAL;
337}
338EXPORT_SYMBOL_GPL(regulator_map_voltage_iterate);
339
340/**
341 * regulator_map_voltage_ascend - map_voltage() for ascendant voltage list
342 *
343 * @rdev: Regulator to operate on
344 * @min_uV: Lower bound for voltage
345 * @max_uV: Upper bound for voltage
346 *
347 * Drivers that have ascendant voltage list can use this as their
348 * map_voltage() operation.
349 */
350int regulator_map_voltage_ascend(struct regulator_dev *rdev,
351 int min_uV, int max_uV)
352{
353 int i, ret;
354
355 for (i = 0; i < rdev->desc->n_voltages; i++) {
356 ret = rdev->desc->ops->list_voltage(rdev, i);
357 if (ret < 0)
358 continue;
359
360 if (ret > max_uV)
361 break;
362
363 if (ret >= min_uV && ret <= max_uV)
364 return i;
365 }
366
367 return -EINVAL;
368}
369EXPORT_SYMBOL_GPL(regulator_map_voltage_ascend);
370
371/**
372 * regulator_map_voltage_linear - map_voltage() for simple linear mappings
373 *
374 * @rdev: Regulator to operate on
375 * @min_uV: Lower bound for voltage
376 * @max_uV: Upper bound for voltage
377 *
378 * Drivers providing min_uV and uV_step in their regulator_desc can
379 * use this as their map_voltage() operation.
380 */
381int regulator_map_voltage_linear(struct regulator_dev *rdev,
382 int min_uV, int max_uV)
383{
384 int ret, voltage;
385
386 /* Allow uV_step to be 0 for fixed voltage */
387 if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) {
388 if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV)
389 return 0;
390 else
391 return -EINVAL;
392 }
393
394 if (!rdev->desc->uV_step) {
395 BUG_ON(!rdev->desc->uV_step);
396 return -EINVAL;
397 }
398
399 if (min_uV < rdev->desc->min_uV)
400 min_uV = rdev->desc->min_uV;
401
402 ret = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step);
403 if (ret < 0)
404 return ret;
405
406 ret += rdev->desc->linear_min_sel;
407
408 /* Map back into a voltage to verify we're still in bounds */
409 voltage = rdev->desc->ops->list_voltage(rdev, ret);
410 if (voltage < min_uV || voltage > max_uV)
411 return -EINVAL;
412
413 return ret;
414}
415EXPORT_SYMBOL_GPL(regulator_map_voltage_linear);
416
417/**
418 * regulator_map_voltage_linear_range - map_voltage() for multiple linear ranges
419 *
420 * @rdev: Regulator to operate on
421 * @min_uV: Lower bound for voltage
422 * @max_uV: Upper bound for voltage
423 *
424 * Drivers providing linear_ranges in their descriptor can use this as
425 * their map_voltage() callback.
426 */
427int regulator_map_voltage_linear_range(struct regulator_dev *rdev,
428 int min_uV, int max_uV)
429{
430 const struct linear_range *range;
431 int ret = -EINVAL;
432 unsigned int sel;
433 bool found;
434 int voltage, i;
435
436 if (!rdev->desc->n_linear_ranges) {
437 BUG_ON(!rdev->desc->n_linear_ranges);
438 return -EINVAL;
439 }
440
441 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
442 range = &rdev->desc->linear_ranges[i];
443
444 ret = linear_range_get_selector_high(range, min_uV, &sel,
445 &found);
446 if (ret)
447 continue;
448 ret = sel;
449
450 /*
451 * Map back into a voltage to verify we're still in bounds.
452 * If we are not, then continue checking rest of the ranges.
453 */
454 voltage = rdev->desc->ops->list_voltage(rdev, sel);
455 if (voltage >= min_uV && voltage <= max_uV)
456 break;
457 }
458
459 if (i == rdev->desc->n_linear_ranges)
460 return -EINVAL;
461
462 return ret;
463}
464EXPORT_SYMBOL_GPL(regulator_map_voltage_linear_range);
465
466/**
467 * regulator_map_voltage_pickable_linear_range - map_voltage, pickable ranges
468 *
469 * @rdev: Regulator to operate on
470 * @min_uV: Lower bound for voltage
471 * @max_uV: Upper bound for voltage
472 *
473 * Drivers providing pickable linear_ranges in their descriptor can use
474 * this as their map_voltage() callback.
475 */
476int regulator_map_voltage_pickable_linear_range(struct regulator_dev *rdev,
477 int min_uV, int max_uV)
478{
479 const struct linear_range *range;
480 int ret = -EINVAL;
481 int voltage, i;
482 unsigned int selector = 0;
483
484 if (!rdev->desc->n_linear_ranges) {
485 BUG_ON(!rdev->desc->n_linear_ranges);
486 return -EINVAL;
487 }
488
489 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
490 int linear_max_uV;
491 bool found;
492 unsigned int sel;
493
494 range = &rdev->desc->linear_ranges[i];
495 linear_max_uV = linear_range_get_max_value(range);
496
497 if (!(min_uV <= linear_max_uV && max_uV >= range->min)) {
498 selector += linear_range_values_in_range(range);
499 continue;
500 }
501
502 ret = linear_range_get_selector_high(range, min_uV, &sel,
503 &found);
504 if (ret) {
505 selector += linear_range_values_in_range(range);
506 continue;
507 }
508
509 ret = selector + sel - range->min_sel;
510
511 voltage = rdev->desc->ops->list_voltage(rdev, ret);
512
513 /*
514 * Map back into a voltage to verify we're still in bounds.
515 * We may have overlapping voltage ranges. Hence we don't
516 * exit but retry until we have checked all ranges.
517 */
518 if (voltage < min_uV || voltage > max_uV)
519 selector += linear_range_values_in_range(range);
520 else
521 break;
522 }
523
524 if (i == rdev->desc->n_linear_ranges)
525 return -EINVAL;
526
527 return ret;
528}
529EXPORT_SYMBOL_GPL(regulator_map_voltage_pickable_linear_range);
530
531/**
532 * regulator_desc_list_voltage_linear - List voltages with simple calculation
533 *
534 * @desc: Regulator desc for regulator which volatges are to be listed
535 * @selector: Selector to convert into a voltage
536 *
537 * Regulators with a simple linear mapping between voltages and
538 * selectors can set min_uV and uV_step in the regulator descriptor
539 * and then use this function prior regulator registration to list
540 * the voltages. This is useful when voltages need to be listed during
541 * device-tree parsing.
542 */
543int regulator_desc_list_voltage_linear(const struct regulator_desc *desc,
544 unsigned int selector)
545{
546 if (selector >= desc->n_voltages)
547 return -EINVAL;
548
549 if (selector < desc->linear_min_sel)
550 return 0;
551
552 selector -= desc->linear_min_sel;
553
554 return desc->min_uV + (desc->uV_step * selector);
555}
556EXPORT_SYMBOL_GPL(regulator_desc_list_voltage_linear);
557
558/**
559 * regulator_list_voltage_linear - List voltages with simple calculation
560 *
561 * @rdev: Regulator device
562 * @selector: Selector to convert into a voltage
563 *
564 * Regulators with a simple linear mapping between voltages and
565 * selectors can set min_uV and uV_step in the regulator descriptor
566 * and then use this function as their list_voltage() operation,
567 */
568int regulator_list_voltage_linear(struct regulator_dev *rdev,
569 unsigned int selector)
570{
571 return regulator_desc_list_voltage_linear(rdev->desc, selector);
572}
573EXPORT_SYMBOL_GPL(regulator_list_voltage_linear);
574
575/**
576 * regulator_list_voltage_pickable_linear_range - pickable range list voltages
577 *
578 * @rdev: Regulator device
579 * @selector: Selector to convert into a voltage
580 *
581 * list_voltage() operation, intended to be used by drivers utilizing pickable
582 * ranges helpers.
583 */
584int regulator_list_voltage_pickable_linear_range(struct regulator_dev *rdev,
585 unsigned int selector)
586{
587 const struct linear_range *range;
588 int i;
589 unsigned int all_sels = 0;
590
591 if (!rdev->desc->n_linear_ranges) {
592 BUG_ON(!rdev->desc->n_linear_ranges);
593 return -EINVAL;
594 }
595
596 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
597 unsigned int sel_indexes;
598
599 range = &rdev->desc->linear_ranges[i];
600
601 sel_indexes = linear_range_values_in_range(range) - 1;
602
603 if (all_sels + sel_indexes >= selector) {
604 selector -= all_sels;
605 /*
606 * As we see here, pickable ranges work only as
607 * long as the first selector for each pickable
608 * range is 0, and the each subsequent range for
609 * this 'pick' follow immediately at next unused
610 * selector (Eg. there is no gaps between ranges).
611 * I think this is fine but it probably should be
612 * documented. OTOH, whole pickable range stuff
613 * might benefit from some documentation
614 */
615 return range->min + (range->step * selector);
616 }
617
618 all_sels += (sel_indexes + 1);
619 }
620
621 return -EINVAL;
622}
623EXPORT_SYMBOL_GPL(regulator_list_voltage_pickable_linear_range);
624
625/**
626 * regulator_desc_list_voltage_linear_range - List voltages for linear ranges
627 *
628 * @desc: Regulator desc for regulator which volatges are to be listed
629 * @selector: Selector to convert into a voltage
630 *
631 * Regulators with a series of simple linear mappings between voltages
632 * and selectors who have set linear_ranges in the regulator descriptor
633 * can use this function prior regulator registration to list voltages.
634 * This is useful when voltages need to be listed during device-tree
635 * parsing.
636 */
637int regulator_desc_list_voltage_linear_range(const struct regulator_desc *desc,
638 unsigned int selector)
639{
640 unsigned int val;
641 int ret;
642
643 BUG_ON(!desc->n_linear_ranges);
644
645 ret = linear_range_get_value_array(desc->linear_ranges,
646 desc->n_linear_ranges, selector,
647 &val);
648 if (ret)
649 return ret;
650
651 return val;
652}
653EXPORT_SYMBOL_GPL(regulator_desc_list_voltage_linear_range);
654
655/**
656 * regulator_list_voltage_linear_range - List voltages for linear ranges
657 *
658 * @rdev: Regulator device
659 * @selector: Selector to convert into a voltage
660 *
661 * Regulators with a series of simple linear mappings between voltages
662 * and selectors can set linear_ranges in the regulator descriptor and
663 * then use this function as their list_voltage() operation,
664 */
665int regulator_list_voltage_linear_range(struct regulator_dev *rdev,
666 unsigned int selector)
667{
668 return regulator_desc_list_voltage_linear_range(rdev->desc, selector);
669}
670EXPORT_SYMBOL_GPL(regulator_list_voltage_linear_range);
671
672/**
673 * regulator_list_voltage_table - List voltages with table based mapping
674 *
675 * @rdev: Regulator device
676 * @selector: Selector to convert into a voltage
677 *
678 * Regulators with table based mapping between voltages and
679 * selectors can set volt_table in the regulator descriptor
680 * and then use this function as their list_voltage() operation.
681 */
682int regulator_list_voltage_table(struct regulator_dev *rdev,
683 unsigned int selector)
684{
685 if (!rdev->desc->volt_table) {
686 BUG_ON(!rdev->desc->volt_table);
687 return -EINVAL;
688 }
689
690 if (selector >= rdev->desc->n_voltages)
691 return -EINVAL;
692 if (selector < rdev->desc->linear_min_sel)
693 return 0;
694
695 return rdev->desc->volt_table[selector];
696}
697EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
698
699/**
700 * regulator_set_bypass_regmap - Default set_bypass() using regmap
701 *
702 * @rdev: device to operate on.
703 * @enable: state to set.
704 */
705int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
706{
707 unsigned int val;
708
709 if (enable) {
710 val = rdev->desc->bypass_val_on;
711 if (!val)
712 val = rdev->desc->bypass_mask;
713 } else {
714 val = rdev->desc->bypass_val_off;
715 }
716
717 return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
718 rdev->desc->bypass_mask, val);
719}
720EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap);
721
722/**
723 * regulator_set_soft_start_regmap - Default set_soft_start() using regmap
724 *
725 * @rdev: device to operate on.
726 */
727int regulator_set_soft_start_regmap(struct regulator_dev *rdev)
728{
729 unsigned int val;
730
731 val = rdev->desc->soft_start_val_on;
732 if (!val)
733 val = rdev->desc->soft_start_mask;
734
735 return regmap_update_bits(rdev->regmap, rdev->desc->soft_start_reg,
736 rdev->desc->soft_start_mask, val);
737}
738EXPORT_SYMBOL_GPL(regulator_set_soft_start_regmap);
739
740/**
741 * regulator_set_pull_down_regmap - Default set_pull_down() using regmap
742 *
743 * @rdev: device to operate on.
744 */
745int regulator_set_pull_down_regmap(struct regulator_dev *rdev)
746{
747 unsigned int val;
748
749 val = rdev->desc->pull_down_val_on;
750 if (!val)
751 val = rdev->desc->pull_down_mask;
752
753 return regmap_update_bits(rdev->regmap, rdev->desc->pull_down_reg,
754 rdev->desc->pull_down_mask, val);
755}
756EXPORT_SYMBOL_GPL(regulator_set_pull_down_regmap);
757
758/**
759 * regulator_get_bypass_regmap - Default get_bypass() using regmap
760 *
761 * @rdev: device to operate on.
762 * @enable: current state.
763 */
764int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable)
765{
766 unsigned int val;
767 unsigned int val_on = rdev->desc->bypass_val_on;
768 int ret;
769
770 ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val);
771 if (ret != 0)
772 return ret;
773
774 if (!val_on)
775 val_on = rdev->desc->bypass_mask;
776
777 *enable = (val & rdev->desc->bypass_mask) == val_on;
778
779 return 0;
780}
781EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap);
782
783/**
784 * regulator_set_active_discharge_regmap - Default set_active_discharge()
785 * using regmap
786 *
787 * @rdev: device to operate on.
788 * @enable: state to set, 0 to disable and 1 to enable.
789 */
790int regulator_set_active_discharge_regmap(struct regulator_dev *rdev,
791 bool enable)
792{
793 unsigned int val;
794
795 if (enable)
796 val = rdev->desc->active_discharge_on;
797 else
798 val = rdev->desc->active_discharge_off;
799
800 return regmap_update_bits(rdev->regmap,
801 rdev->desc->active_discharge_reg,
802 rdev->desc->active_discharge_mask, val);
803}
804EXPORT_SYMBOL_GPL(regulator_set_active_discharge_regmap);
805
806/**
807 * regulator_set_current_limit_regmap - set_current_limit for regmap users
808 *
809 * @rdev: regulator to operate on
810 * @min_uA: Lower bound for current limit
811 * @max_uA: Upper bound for current limit
812 *
813 * Regulators that use regmap for their register I/O can set curr_table,
814 * csel_reg and csel_mask fields in their descriptor and then use this
815 * as their set_current_limit operation, saving some code.
816 */
817int regulator_set_current_limit_regmap(struct regulator_dev *rdev,
818 int min_uA, int max_uA)
819{
820 unsigned int n_currents = rdev->desc->n_current_limits;
821 int i, sel = -1;
822
823 if (n_currents == 0)
824 return -EINVAL;
825
826 if (rdev->desc->curr_table) {
827 const unsigned int *curr_table = rdev->desc->curr_table;
828 bool ascend = curr_table[n_currents - 1] > curr_table[0];
829
830 /* search for closest to maximum */
831 if (ascend) {
832 for (i = n_currents - 1; i >= 0; i--) {
833 if (min_uA <= curr_table[i] &&
834 curr_table[i] <= max_uA) {
835 sel = i;
836 break;
837 }
838 }
839 } else {
840 for (i = 0; i < n_currents; i++) {
841 if (min_uA <= curr_table[i] &&
842 curr_table[i] <= max_uA) {
843 sel = i;
844 break;
845 }
846 }
847 }
848 }
849
850 if (sel < 0)
851 return -EINVAL;
852
853 sel <<= ffs(rdev->desc->csel_mask) - 1;
854
855 return regmap_update_bits(rdev->regmap, rdev->desc->csel_reg,
856 rdev->desc->csel_mask, sel);
857}
858EXPORT_SYMBOL_GPL(regulator_set_current_limit_regmap);
859
860/**
861 * regulator_get_current_limit_regmap - get_current_limit for regmap users
862 *
863 * @rdev: regulator to operate on
864 *
865 * Regulators that use regmap for their register I/O can set the
866 * csel_reg and csel_mask fields in their descriptor and then use this
867 * as their get_current_limit operation, saving some code.
868 */
869int regulator_get_current_limit_regmap(struct regulator_dev *rdev)
870{
871 unsigned int val;
872 int ret;
873
874 ret = regmap_read(rdev->regmap, rdev->desc->csel_reg, &val);
875 if (ret != 0)
876 return ret;
877
878 val &= rdev->desc->csel_mask;
879 val >>= ffs(rdev->desc->csel_mask) - 1;
880
881 if (rdev->desc->curr_table) {
882 if (val >= rdev->desc->n_current_limits)
883 return -EINVAL;
884
885 return rdev->desc->curr_table[val];
886 }
887
888 return -EINVAL;
889}
890EXPORT_SYMBOL_GPL(regulator_get_current_limit_regmap);
891
892/**
893 * regulator_bulk_set_supply_names - initialize the 'supply' fields in an array
894 * of regulator_bulk_data structs
895 *
896 * @consumers: array of regulator_bulk_data entries to initialize
897 * @supply_names: array of supply name strings
898 * @num_supplies: number of supply names to initialize
899 *
900 * Note: the 'consumers' array must be the size of 'num_supplies'.
901 */
902void regulator_bulk_set_supply_names(struct regulator_bulk_data *consumers,
903 const char *const *supply_names,
904 unsigned int num_supplies)
905{
906 unsigned int i;
907
908 for (i = 0; i < num_supplies; i++)
909 consumers[i].supply = supply_names[i];
910}
911EXPORT_SYMBOL_GPL(regulator_bulk_set_supply_names);
912
913/**
914 * regulator_is_equal - test whether two regulators are the same
915 *
916 * @reg1: first regulator to operate on
917 * @reg2: second regulator to operate on
918 */
919bool regulator_is_equal(struct regulator *reg1, struct regulator *reg2)
920{
921 return reg1->rdev == reg2->rdev;
922}
923EXPORT_SYMBOL_GPL(regulator_is_equal);
924
925/**
926 * regulator_find_closest_bigger - helper to find offset in ramp delay table
927 *
928 * @target: targeted ramp_delay
929 * @table: table with supported ramp delays
930 * @num_sel: number of entries in the table
931 * @sel: Pointer to store table offset
932 *
933 * This is the internal helper used by regulator_set_ramp_delay_regmap to
934 * map ramp delay to register value. It should only be used directly if
935 * regulator_set_ramp_delay_regmap cannot handle a specific device setup
936 * (e.g. because the value is split over multiple registers).
937 */
938int regulator_find_closest_bigger(unsigned int target, const unsigned int *table,
939 unsigned int num_sel, unsigned int *sel)
940{
941 unsigned int s, tmp, max, maxsel = 0;
942 bool found = false;
943
944 max = table[0];
945
946 for (s = 0; s < num_sel; s++) {
947 if (table[s] > max) {
948 max = table[s];
949 maxsel = s;
950 }
951 if (table[s] >= target) {
952 if (!found || table[s] - target < tmp - target) {
953 tmp = table[s];
954 *sel = s;
955 found = true;
956 if (tmp == target)
957 break;
958 }
959 }
960 }
961
962 if (!found) {
963 *sel = maxsel;
964 return -EINVAL;
965 }
966
967 return 0;
968}
969EXPORT_SYMBOL_GPL(regulator_find_closest_bigger);
970
971/**
972 * regulator_set_ramp_delay_regmap - set_ramp_delay() helper
973 *
974 * @rdev: regulator to operate on
975 * @ramp_delay: ramp-rate value given in units V/S (uV/uS)
976 *
977 * Regulators that use regmap for their register I/O can set the ramp_reg
978 * and ramp_mask fields in their descriptor and then use this as their
979 * set_ramp_delay operation, saving some code.
980 */
981int regulator_set_ramp_delay_regmap(struct regulator_dev *rdev, int ramp_delay)
982{
983 int ret;
984 unsigned int sel;
985
986 if (WARN_ON(!rdev->desc->n_ramp_values || !rdev->desc->ramp_delay_table))
987 return -EINVAL;
988
989 ret = regulator_find_closest_bigger(ramp_delay, rdev->desc->ramp_delay_table,
990 rdev->desc->n_ramp_values, &sel);
991
992 if (ret) {
993 dev_warn(rdev_get_dev(rdev),
994 "Can't set ramp-delay %u, setting %u\n", ramp_delay,
995 rdev->desc->ramp_delay_table[sel]);
996 }
997
998 sel <<= ffs(rdev->desc->ramp_mask) - 1;
999
1000 return regmap_update_bits(rdev->regmap, rdev->desc->ramp_reg,
1001 rdev->desc->ramp_mask, sel);
1002}
1003EXPORT_SYMBOL_GPL(regulator_set_ramp_delay_regmap);