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 */
31int 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 val &= rdev->desc->enable_mask;
41
42 if (rdev->desc->enable_is_inverted) {
43 if (rdev->desc->enable_val)
44 return val != rdev->desc->enable_val;
45 return val == 0;
46 } else {
47 if (rdev->desc->enable_val)
48 return val == rdev->desc->enable_val;
49 return val != 0;
50 }
51}
52EXPORT_SYMBOL_GPL(regulator_is_enabled_regmap);
53
54/**
55 * regulator_enable_regmap - standard enable() for regmap users
56 *
57 * @rdev: regulator to operate on
58 *
59 * Regulators that use regmap for their register I/O can set the
60 * enable_reg and enable_mask fields in their descriptor and then use
61 * this as their enable() operation, saving some code.
62 */
63int regulator_enable_regmap(struct regulator_dev *rdev)
64{
65 unsigned int val;
66
67 if (rdev->desc->enable_is_inverted) {
68 val = rdev->desc->disable_val;
69 } else {
70 val = rdev->desc->enable_val;
71 if (!val)
72 val = rdev->desc->enable_mask;
73 }
74
75 return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
76 rdev->desc->enable_mask, val);
77}
78EXPORT_SYMBOL_GPL(regulator_enable_regmap);
79
80/**
81 * regulator_disable_regmap - standard disable() for regmap users
82 *
83 * @rdev: regulator to operate on
84 *
85 * Regulators that use regmap for their register I/O can set the
86 * enable_reg and enable_mask fields in their descriptor and then use
87 * this as their disable() operation, saving some code.
88 */
89int regulator_disable_regmap(struct regulator_dev *rdev)
90{
91 unsigned int val;
92
93 if (rdev->desc->enable_is_inverted) {
94 val = rdev->desc->enable_val;
95 if (!val)
96 val = rdev->desc->enable_mask;
97 } else {
98 val = rdev->desc->disable_val;
99 }
100
101 return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
102 rdev->desc->enable_mask, val);
103}
104EXPORT_SYMBOL_GPL(regulator_disable_regmap);
105
106static int regulator_range_selector_to_index(struct regulator_dev *rdev,
107 unsigned int rval)
108{
109 int i;
110
111 if (!rdev->desc->linear_range_selectors)
112 return -EINVAL;
113
114 rval &= rdev->desc->vsel_range_mask;
115
116 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
117 if (rdev->desc->linear_range_selectors[i] == rval)
118 return i;
119 }
120 return -EINVAL;
121}
122
123/**
124 * regulator_get_voltage_sel_pickable_regmap - pickable range get_voltage_sel
125 *
126 * @rdev: regulator to operate on
127 *
128 * Regulators that use regmap for their register I/O and use pickable
129 * ranges can set the vsel_reg, vsel_mask, vsel_range_reg and vsel_range_mask
130 * fields in their descriptor and then use this as their get_voltage_vsel
131 * operation, saving some code.
132 */
133int regulator_get_voltage_sel_pickable_regmap(struct regulator_dev *rdev)
134{
135 unsigned int r_val;
136 int range;
137 unsigned int val;
138 int ret, i;
139 unsigned int voltages_in_range = 0;
140
141 if (!rdev->desc->linear_ranges)
142 return -EINVAL;
143
144 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
145 if (ret != 0)
146 return ret;
147
148 ret = regmap_read(rdev->regmap, rdev->desc->vsel_range_reg, &r_val);
149 if (ret != 0)
150 return ret;
151
152 val &= rdev->desc->vsel_mask;
153 val >>= ffs(rdev->desc->vsel_mask) - 1;
154
155 range = regulator_range_selector_to_index(rdev, r_val);
156 if (range < 0)
157 return -EINVAL;
158
159 for (i = 0; i < range; i++)
160 voltages_in_range += (rdev->desc->linear_ranges[i].max_sel -
161 rdev->desc->linear_ranges[i].min_sel) + 1;
162
163 return val + voltages_in_range;
164}
165EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_pickable_regmap);
166
167/**
168 * regulator_set_voltage_sel_pickable_regmap - pickable range set_voltage_sel
169 *
170 * @rdev: regulator to operate on
171 * @sel: Selector to set
172 *
173 * Regulators that use regmap for their register I/O and use pickable
174 * ranges can set the vsel_reg, vsel_mask, vsel_range_reg and vsel_range_mask
175 * fields in their descriptor and then use this as their set_voltage_vsel
176 * operation, saving some code.
177 */
178int regulator_set_voltage_sel_pickable_regmap(struct regulator_dev *rdev,
179 unsigned int sel)
180{
181 unsigned int range;
182 int ret, i;
183 unsigned int voltages_in_range = 0;
184
185 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
186 voltages_in_range = (rdev->desc->linear_ranges[i].max_sel -
187 rdev->desc->linear_ranges[i].min_sel) + 1;
188 if (sel < voltages_in_range)
189 break;
190 sel -= voltages_in_range;
191 }
192
193 if (i == rdev->desc->n_linear_ranges)
194 return -EINVAL;
195
196 sel <<= ffs(rdev->desc->vsel_mask) - 1;
197 sel += rdev->desc->linear_ranges[i].min_sel;
198
199 range = rdev->desc->linear_range_selectors[i];
200
201 if (rdev->desc->vsel_reg == rdev->desc->vsel_range_reg) {
202 ret = regmap_update_bits(rdev->regmap,
203 rdev->desc->vsel_reg,
204 rdev->desc->vsel_range_mask |
205 rdev->desc->vsel_mask, sel | range);
206 } else {
207 ret = regmap_update_bits(rdev->regmap,
208 rdev->desc->vsel_range_reg,
209 rdev->desc->vsel_range_mask, range);
210 if (ret)
211 return ret;
212
213 ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
214 rdev->desc->vsel_mask, sel);
215 }
216
217 if (ret)
218 return ret;
219
220 if (rdev->desc->apply_bit)
221 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
222 rdev->desc->apply_bit,
223 rdev->desc->apply_bit);
224 return ret;
225}
226EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_pickable_regmap);
227
228/**
229 * regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users
230 *
231 * @rdev: regulator to operate on
232 *
233 * Regulators that use regmap for their register I/O can set the
234 * vsel_reg and vsel_mask fields in their descriptor and then use this
235 * as their get_voltage_vsel operation, saving some code.
236 */
237int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev)
238{
239 unsigned int val;
240 int ret;
241
242 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
243 if (ret != 0)
244 return ret;
245
246 val &= rdev->desc->vsel_mask;
247 val >>= ffs(rdev->desc->vsel_mask) - 1;
248
249 return val;
250}
251EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_regmap);
252
253/**
254 * regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users
255 *
256 * @rdev: regulator to operate on
257 * @sel: Selector to set
258 *
259 * Regulators that use regmap for their register I/O can set the
260 * vsel_reg and vsel_mask fields in their descriptor and then use this
261 * as their set_voltage_vsel operation, saving some code.
262 */
263int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel)
264{
265 int ret;
266
267 sel <<= ffs(rdev->desc->vsel_mask) - 1;
268
269 ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
270 rdev->desc->vsel_mask, sel);
271 if (ret)
272 return ret;
273
274 if (rdev->desc->apply_bit)
275 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
276 rdev->desc->apply_bit,
277 rdev->desc->apply_bit);
278 return ret;
279}
280EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_regmap);
281
282/**
283 * regulator_map_voltage_iterate - map_voltage() based on list_voltage()
284 *
285 * @rdev: Regulator to operate on
286 * @min_uV: Lower bound for voltage
287 * @max_uV: Upper bound for voltage
288 *
289 * Drivers implementing set_voltage_sel() and list_voltage() can use
290 * this as their map_voltage() operation. It will find a suitable
291 * voltage by calling list_voltage() until it gets something in bounds
292 * for the requested voltages.
293 */
294int regulator_map_voltage_iterate(struct regulator_dev *rdev,
295 int min_uV, int max_uV)
296{
297 int best_val = INT_MAX;
298 int selector = 0;
299 int i, ret;
300
301 /* Find the smallest voltage that falls within the specified
302 * range.
303 */
304 for (i = 0; i < rdev->desc->n_voltages; i++) {
305 ret = rdev->desc->ops->list_voltage(rdev, i);
306 if (ret < 0)
307 continue;
308
309 if (ret < best_val && ret >= min_uV && ret <= max_uV) {
310 best_val = ret;
311 selector = i;
312 }
313 }
314
315 if (best_val != INT_MAX)
316 return selector;
317 else
318 return -EINVAL;
319}
320EXPORT_SYMBOL_GPL(regulator_map_voltage_iterate);
321
322/**
323 * regulator_map_voltage_ascend - map_voltage() for ascendant voltage list
324 *
325 * @rdev: Regulator to operate on
326 * @min_uV: Lower bound for voltage
327 * @max_uV: Upper bound for voltage
328 *
329 * Drivers that have ascendant voltage list can use this as their
330 * map_voltage() operation.
331 */
332int regulator_map_voltage_ascend(struct regulator_dev *rdev,
333 int min_uV, int max_uV)
334{
335 int i, ret;
336
337 for (i = 0; i < rdev->desc->n_voltages; i++) {
338 ret = rdev->desc->ops->list_voltage(rdev, i);
339 if (ret < 0)
340 continue;
341
342 if (ret > max_uV)
343 break;
344
345 if (ret >= min_uV && ret <= max_uV)
346 return i;
347 }
348
349 return -EINVAL;
350}
351EXPORT_SYMBOL_GPL(regulator_map_voltage_ascend);
352
353/**
354 * regulator_map_voltage_linear - map_voltage() for simple linear mappings
355 *
356 * @rdev: Regulator to operate on
357 * @min_uV: Lower bound for voltage
358 * @max_uV: Upper bound for voltage
359 *
360 * Drivers providing min_uV and uV_step in their regulator_desc can
361 * use this as their map_voltage() operation.
362 */
363int regulator_map_voltage_linear(struct regulator_dev *rdev,
364 int min_uV, int max_uV)
365{
366 int ret, voltage;
367
368 /* Allow uV_step to be 0 for fixed voltage */
369 if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) {
370 if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV)
371 return 0;
372 else
373 return -EINVAL;
374 }
375
376 if (!rdev->desc->uV_step) {
377 BUG_ON(!rdev->desc->uV_step);
378 return -EINVAL;
379 }
380
381 if (min_uV < rdev->desc->min_uV)
382 min_uV = rdev->desc->min_uV;
383
384 ret = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step);
385 if (ret < 0)
386 return ret;
387
388 ret += rdev->desc->linear_min_sel;
389
390 /* Map back into a voltage to verify we're still in bounds */
391 voltage = rdev->desc->ops->list_voltage(rdev, ret);
392 if (voltage < min_uV || voltage > max_uV)
393 return -EINVAL;
394
395 return ret;
396}
397EXPORT_SYMBOL_GPL(regulator_map_voltage_linear);
398
399/**
400 * regulator_map_voltage_linear_range - map_voltage() for multiple linear ranges
401 *
402 * @rdev: Regulator to operate on
403 * @min_uV: Lower bound for voltage
404 * @max_uV: Upper bound for voltage
405 *
406 * Drivers providing linear_ranges in their descriptor can use this as
407 * their map_voltage() callback.
408 */
409int regulator_map_voltage_linear_range(struct regulator_dev *rdev,
410 int min_uV, int max_uV)
411{
412 const struct regulator_linear_range *range;
413 int ret = -EINVAL;
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 int linear_max_uV;
423
424 range = &rdev->desc->linear_ranges[i];
425 linear_max_uV = range->min_uV +
426 (range->max_sel - range->min_sel) * range->uV_step;
427
428 if (!(min_uV <= linear_max_uV && max_uV >= range->min_uV))
429 continue;
430
431 if (min_uV <= range->min_uV)
432 min_uV = range->min_uV;
433
434 /* range->uV_step == 0 means fixed voltage range */
435 if (range->uV_step == 0) {
436 ret = 0;
437 } else {
438 ret = DIV_ROUND_UP(min_uV - range->min_uV,
439 range->uV_step);
440 if (ret < 0)
441 return ret;
442 }
443
444 ret += range->min_sel;
445
446 /*
447 * Map back into a voltage to verify we're still in bounds.
448 * If we are not, then continue checking rest of the ranges.
449 */
450 voltage = rdev->desc->ops->list_voltage(rdev, ret);
451 if (voltage >= min_uV && voltage <= max_uV)
452 break;
453 }
454
455 if (i == rdev->desc->n_linear_ranges)
456 return -EINVAL;
457
458 return ret;
459}
460EXPORT_SYMBOL_GPL(regulator_map_voltage_linear_range);
461
462/**
463 * regulator_map_voltage_pickable_linear_range - map_voltage, pickable ranges
464 *
465 * @rdev: Regulator to operate on
466 * @min_uV: Lower bound for voltage
467 * @max_uV: Upper bound for voltage
468 *
469 * Drivers providing pickable linear_ranges in their descriptor can use
470 * this as their map_voltage() callback.
471 */
472int regulator_map_voltage_pickable_linear_range(struct regulator_dev *rdev,
473 int min_uV, int max_uV)
474{
475 const struct regulator_linear_range *range;
476 int ret = -EINVAL;
477 int voltage, i;
478 unsigned int selector = 0;
479
480 if (!rdev->desc->n_linear_ranges) {
481 BUG_ON(!rdev->desc->n_linear_ranges);
482 return -EINVAL;
483 }
484
485 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
486 int linear_max_uV;
487
488 range = &rdev->desc->linear_ranges[i];
489 linear_max_uV = range->min_uV +
490 (range->max_sel - range->min_sel) * range->uV_step;
491
492 if (!(min_uV <= linear_max_uV && max_uV >= range->min_uV)) {
493 selector += (range->max_sel - range->min_sel + 1);
494 continue;
495 }
496
497 if (min_uV <= range->min_uV)
498 min_uV = range->min_uV;
499
500 /* range->uV_step == 0 means fixed voltage range */
501 if (range->uV_step == 0) {
502 ret = 0;
503 } else {
504 ret = DIV_ROUND_UP(min_uV - range->min_uV,
505 range->uV_step);
506 if (ret < 0)
507 return ret;
508 }
509
510 ret += selector;
511
512 voltage = rdev->desc->ops->list_voltage(rdev, ret);
513
514 /*
515 * Map back into a voltage to verify we're still in bounds.
516 * We may have overlapping voltage ranges. Hence we don't
517 * exit but retry until we have checked all ranges.
518 */
519 if (voltage < min_uV || voltage > max_uV)
520 selector += (range->max_sel - range->min_sel + 1);
521 else
522 break;
523 }
524
525 if (i == rdev->desc->n_linear_ranges)
526 return -EINVAL;
527
528 return ret;
529}
530EXPORT_SYMBOL_GPL(regulator_map_voltage_pickable_linear_range);
531
532/**
533 * regulator_list_voltage_linear - List voltages with simple calculation
534 *
535 * @rdev: Regulator device
536 * @selector: Selector to convert into a voltage
537 *
538 * Regulators with a simple linear mapping between voltages and
539 * selectors can set min_uV and uV_step in the regulator descriptor
540 * and then use this function as their list_voltage() operation,
541 */
542int regulator_list_voltage_linear(struct regulator_dev *rdev,
543 unsigned int selector)
544{
545 if (selector >= rdev->desc->n_voltages)
546 return -EINVAL;
547 if (selector < rdev->desc->linear_min_sel)
548 return 0;
549
550 selector -= rdev->desc->linear_min_sel;
551
552 return rdev->desc->min_uV + (rdev->desc->uV_step * selector);
553}
554EXPORT_SYMBOL_GPL(regulator_list_voltage_linear);
555
556/**
557 * regulator_list_voltage_pickable_linear_range - pickable range list voltages
558 *
559 * @rdev: Regulator device
560 * @selector: Selector to convert into a voltage
561 *
562 * list_voltage() operation, intended to be used by drivers utilizing pickable
563 * ranges helpers.
564 */
565int regulator_list_voltage_pickable_linear_range(struct regulator_dev *rdev,
566 unsigned int selector)
567{
568 const struct regulator_linear_range *range;
569 int i;
570 unsigned int all_sels = 0;
571
572 if (!rdev->desc->n_linear_ranges) {
573 BUG_ON(!rdev->desc->n_linear_ranges);
574 return -EINVAL;
575 }
576
577 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
578 unsigned int sels_in_range;
579
580 range = &rdev->desc->linear_ranges[i];
581
582 sels_in_range = range->max_sel - range->min_sel;
583
584 if (all_sels + sels_in_range >= selector) {
585 selector -= all_sels;
586 return range->min_uV + (range->uV_step * selector);
587 }
588
589 all_sels += (sels_in_range + 1);
590 }
591
592 return -EINVAL;
593}
594EXPORT_SYMBOL_GPL(regulator_list_voltage_pickable_linear_range);
595
596/**
597 * regulator_desc_list_voltage_linear_range - List voltages for linear ranges
598 *
599 * @desc: Regulator desc for regulator which volatges are to be listed
600 * @selector: Selector to convert into a voltage
601 *
602 * Regulators with a series of simple linear mappings between voltages
603 * and selectors who have set linear_ranges in the regulator descriptor
604 * can use this function prior regulator registration to list voltages.
605 * This is useful when voltages need to be listed during device-tree
606 * parsing.
607 */
608int regulator_desc_list_voltage_linear_range(const struct regulator_desc *desc,
609 unsigned int selector)
610{
611 const struct regulator_linear_range *range;
612 int i;
613
614 if (!desc->n_linear_ranges) {
615 BUG_ON(!desc->n_linear_ranges);
616 return -EINVAL;
617 }
618
619 for (i = 0; i < desc->n_linear_ranges; i++) {
620 range = &desc->linear_ranges[i];
621
622 if (!(selector >= range->min_sel &&
623 selector <= range->max_sel))
624 continue;
625
626 selector -= range->min_sel;
627
628 return range->min_uV + (range->uV_step * selector);
629 }
630
631 return -EINVAL;
632}
633EXPORT_SYMBOL_GPL(regulator_desc_list_voltage_linear_range);
634
635/**
636 * regulator_list_voltage_linear_range - List voltages for linear ranges
637 *
638 * @rdev: Regulator device
639 * @selector: Selector to convert into a voltage
640 *
641 * Regulators with a series of simple linear mappings between voltages
642 * and selectors can set linear_ranges in the regulator descriptor and
643 * then use this function as their list_voltage() operation,
644 */
645int regulator_list_voltage_linear_range(struct regulator_dev *rdev,
646 unsigned int selector)
647{
648 return regulator_desc_list_voltage_linear_range(rdev->desc, selector);
649}
650EXPORT_SYMBOL_GPL(regulator_list_voltage_linear_range);
651
652/**
653 * regulator_list_voltage_table - List voltages with table based mapping
654 *
655 * @rdev: Regulator device
656 * @selector: Selector to convert into a voltage
657 *
658 * Regulators with table based mapping between voltages and
659 * selectors can set volt_table in the regulator descriptor
660 * and then use this function as their list_voltage() operation.
661 */
662int regulator_list_voltage_table(struct regulator_dev *rdev,
663 unsigned int selector)
664{
665 if (!rdev->desc->volt_table) {
666 BUG_ON(!rdev->desc->volt_table);
667 return -EINVAL;
668 }
669
670 if (selector >= rdev->desc->n_voltages)
671 return -EINVAL;
672
673 return rdev->desc->volt_table[selector];
674}
675EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
676
677/**
678 * regulator_set_bypass_regmap - Default set_bypass() using regmap
679 *
680 * @rdev: device to operate on.
681 * @enable: state to set.
682 */
683int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
684{
685 unsigned int val;
686
687 if (enable) {
688 val = rdev->desc->bypass_val_on;
689 if (!val)
690 val = rdev->desc->bypass_mask;
691 } else {
692 val = rdev->desc->bypass_val_off;
693 }
694
695 return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
696 rdev->desc->bypass_mask, val);
697}
698EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap);
699
700/**
701 * regulator_set_soft_start_regmap - Default set_soft_start() using regmap
702 *
703 * @rdev: device to operate on.
704 */
705int regulator_set_soft_start_regmap(struct regulator_dev *rdev)
706{
707 unsigned int val;
708
709 val = rdev->desc->soft_start_val_on;
710 if (!val)
711 val = rdev->desc->soft_start_mask;
712
713 return regmap_update_bits(rdev->regmap, rdev->desc->soft_start_reg,
714 rdev->desc->soft_start_mask, val);
715}
716EXPORT_SYMBOL_GPL(regulator_set_soft_start_regmap);
717
718/**
719 * regulator_set_pull_down_regmap - Default set_pull_down() using regmap
720 *
721 * @rdev: device to operate on.
722 */
723int regulator_set_pull_down_regmap(struct regulator_dev *rdev)
724{
725 unsigned int val;
726
727 val = rdev->desc->pull_down_val_on;
728 if (!val)
729 val = rdev->desc->pull_down_mask;
730
731 return regmap_update_bits(rdev->regmap, rdev->desc->pull_down_reg,
732 rdev->desc->pull_down_mask, val);
733}
734EXPORT_SYMBOL_GPL(regulator_set_pull_down_regmap);
735
736/**
737 * regulator_get_bypass_regmap - Default get_bypass() using regmap
738 *
739 * @rdev: device to operate on.
740 * @enable: current state.
741 */
742int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable)
743{
744 unsigned int val;
745 unsigned int val_on = rdev->desc->bypass_val_on;
746 int ret;
747
748 ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val);
749 if (ret != 0)
750 return ret;
751
752 if (!val_on)
753 val_on = rdev->desc->bypass_mask;
754
755 *enable = (val & rdev->desc->bypass_mask) == val_on;
756
757 return 0;
758}
759EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap);
760
761/**
762 * regulator_set_active_discharge_regmap - Default set_active_discharge()
763 * using regmap
764 *
765 * @rdev: device to operate on.
766 * @enable: state to set, 0 to disable and 1 to enable.
767 */
768int regulator_set_active_discharge_regmap(struct regulator_dev *rdev,
769 bool enable)
770{
771 unsigned int val;
772
773 if (enable)
774 val = rdev->desc->active_discharge_on;
775 else
776 val = rdev->desc->active_discharge_off;
777
778 return regmap_update_bits(rdev->regmap,
779 rdev->desc->active_discharge_reg,
780 rdev->desc->active_discharge_mask, val);
781}
782EXPORT_SYMBOL_GPL(regulator_set_active_discharge_regmap);
783
784/**
785 * regulator_set_current_limit_regmap - set_current_limit for regmap users
786 *
787 * @rdev: regulator to operate on
788 * @min_uA: Lower bound for current limit
789 * @max_uA: Upper bound for current limit
790 *
791 * Regulators that use regmap for their register I/O can set curr_table,
792 * csel_reg and csel_mask fields in their descriptor and then use this
793 * as their set_current_limit operation, saving some code.
794 */
795int regulator_set_current_limit_regmap(struct regulator_dev *rdev,
796 int min_uA, int max_uA)
797{
798 unsigned int n_currents = rdev->desc->n_current_limits;
799 int i, sel = -1;
800
801 if (n_currents == 0)
802 return -EINVAL;
803
804 if (rdev->desc->curr_table) {
805 const unsigned int *curr_table = rdev->desc->curr_table;
806 bool ascend = curr_table[n_currents - 1] > curr_table[0];
807
808 /* search for closest to maximum */
809 if (ascend) {
810 for (i = n_currents - 1; i >= 0; i--) {
811 if (min_uA <= curr_table[i] &&
812 curr_table[i] <= max_uA) {
813 sel = i;
814 break;
815 }
816 }
817 } else {
818 for (i = 0; i < n_currents; i++) {
819 if (min_uA <= curr_table[i] &&
820 curr_table[i] <= max_uA) {
821 sel = i;
822 break;
823 }
824 }
825 }
826 }
827
828 if (sel < 0)
829 return -EINVAL;
830
831 sel <<= ffs(rdev->desc->csel_mask) - 1;
832
833 return regmap_update_bits(rdev->regmap, rdev->desc->csel_reg,
834 rdev->desc->csel_mask, sel);
835}
836EXPORT_SYMBOL_GPL(regulator_set_current_limit_regmap);
837
838/**
839 * regulator_get_current_limit_regmap - get_current_limit for regmap users
840 *
841 * @rdev: regulator to operate on
842 *
843 * Regulators that use regmap for their register I/O can set the
844 * csel_reg and csel_mask fields in their descriptor and then use this
845 * as their get_current_limit operation, saving some code.
846 */
847int regulator_get_current_limit_regmap(struct regulator_dev *rdev)
848{
849 unsigned int val;
850 int ret;
851
852 ret = regmap_read(rdev->regmap, rdev->desc->csel_reg, &val);
853 if (ret != 0)
854 return ret;
855
856 val &= rdev->desc->csel_mask;
857 val >>= ffs(rdev->desc->csel_mask) - 1;
858
859 if (rdev->desc->curr_table) {
860 if (val >= rdev->desc->n_current_limits)
861 return -EINVAL;
862
863 return rdev->desc->curr_table[val];
864 }
865
866 return -EINVAL;
867}
868EXPORT_SYMBOL_GPL(regulator_get_current_limit_regmap);
869