]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - drivers/regulator/helpers.c
projects / mirror_ubuntu-jammy-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'sound-5.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai...
[mirror_ubuntu-jammy-kernel.git] / drivers / regulator / helpers.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
f2c6203f
MB		 2//
3// helpers.c -- Voltage/Current Regulator framework helper functions.
4//
5// Copyright 2007, 2008 Wolfson Microelectronics PLC.
6// Copyright 2008 SlimLogic Ltd.
c4a54b8d
MB		 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
b059b7e0
MV		 16#include "internal.h"
17
c4a54b8d
MB		 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
ca5d1b35
CC		 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 }
c4a54b8d
MB		 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
ca5d1b35
CC		 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 }
c4a54b8d
MB		 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
ca5d1b35
CC		 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 }
c4a54b8d
MB		 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
18e4b55f
MV		 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, i;
135 unsigned int voltages_in_range = 0;
136
137 if (!rdev->desc->linear_ranges)
138 return -EINVAL;
139
140 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
141 if (ret != 0)
142 return ret;
143
144 ret = regmap_read(rdev->regmap, rdev->desc->vsel_range_reg, &r_val);
145 if (ret != 0)
146 return ret;
147
148 val &= rdev->desc->vsel_mask;
149 val >>= ffs(rdev->desc->vsel_mask) - 1;
150
151 range = regulator_range_selector_to_index(rdev, r_val);
152 if (range < 0)
153 return -EINVAL;
154
155 for (i = 0; i < range; i++)
156 voltages_in_range += (rdev->desc->linear_ranges[i].max_sel -
157 rdev->desc->linear_ranges[i].min_sel) + 1;
158
159 return val + voltages_in_range;
160}
161EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_pickable_regmap);
162
163/**
164 * regulator_set_voltage_sel_pickable_regmap - pickable range set_voltage_sel
165 *
166 * @rdev: regulator to operate on
167 * @sel: Selector to set
168 *
169 * Regulators that use regmap for their register I/O and use pickable
170 * ranges can set the vsel_reg, vsel_mask, vsel_range_reg and vsel_range_mask
171 * fields in their descriptor and then use this as their set_voltage_vsel
172 * operation, saving some code.
173 */
174int regulator_set_voltage_sel_pickable_regmap(struct regulator_dev *rdev,
175 unsigned int sel)
176{
177 unsigned int range;
178 int ret, i;
179 unsigned int voltages_in_range = 0;
180
181 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
182 voltages_in_range = (rdev->desc->linear_ranges[i].max_sel -
183 rdev->desc->linear_ranges[i].min_sel) + 1;
184 if (sel < voltages_in_range)
185 break;
186 sel -= voltages_in_range;
187 }
188
189 if (i == rdev->desc->n_linear_ranges)
190 return -EINVAL;
191
192 sel <<= ffs(rdev->desc->vsel_mask) - 1;
193 sel += rdev->desc->linear_ranges[i].min_sel;
194
195 range = rdev->desc->linear_range_selectors[i];
196
197 if (rdev->desc->vsel_reg == rdev->desc->vsel_range_reg) {
198 ret = regmap_update_bits(rdev->regmap,
199 rdev->desc->vsel_reg,
200 rdev->desc->vsel_range_mask |
201 rdev->desc->vsel_mask, sel | range);
202 } else {
203 ret = regmap_update_bits(rdev->regmap,
204 rdev->desc->vsel_range_reg,
205 rdev->desc->vsel_range_mask, range);
206 if (ret)
207 return ret;
208
209 ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
210 rdev->desc->vsel_mask, sel);
211 }
212
213 if (ret)
214 return ret;
215
216 if (rdev->desc->apply_bit)
217 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
218 rdev->desc->apply_bit,
219 rdev->desc->apply_bit);
220 return ret;
221}
222EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_pickable_regmap);
223
c4a54b8d
MB		 224/**
225 * regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users
226 *
227 * @rdev: regulator to operate on
228 *
229 * Regulators that use regmap for their register I/O can set the
230 * vsel_reg and vsel_mask fields in their descriptor and then use this
231 * as their get_voltage_vsel operation, saving some code.
232 */
233int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev)
234{
235 unsigned int val;
236 int ret;
237
238 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
239 if (ret != 0)
240 return ret;
241
242 val &= rdev->desc->vsel_mask;
243 val >>= ffs(rdev->desc->vsel_mask) - 1;
244
245 return val;
246}
247EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_regmap);
248
249/**
250 * regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users
251 *
252 * @rdev: regulator to operate on
253 * @sel: Selector to set
254 *
255 * Regulators that use regmap for their register I/O can set the
256 * vsel_reg and vsel_mask fields in their descriptor and then use this
257 * as their set_voltage_vsel operation, saving some code.
258 */
259int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel)
260{
261 int ret;
262
263 sel <<= ffs(rdev->desc->vsel_mask) - 1;
264
265 ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
266 rdev->desc->vsel_mask, sel);
267 if (ret)
268 return ret;
269
270 if (rdev->desc->apply_bit)
271 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
272 rdev->desc->apply_bit,
273 rdev->desc->apply_bit);
274 return ret;
275}
276EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_regmap);
277
278/**
279 * regulator_map_voltage_iterate - map_voltage() based on list_voltage()
280 *
281 * @rdev: Regulator to operate on
282 * @min_uV: Lower bound for voltage
283 * @max_uV: Upper bound for voltage
284 *
285 * Drivers implementing set_voltage_sel() and list_voltage() can use
286 * this as their map_voltage() operation. It will find a suitable
287 * voltage by calling list_voltage() until it gets something in bounds
288 * for the requested voltages.
289 */
290int regulator_map_voltage_iterate(struct regulator_dev *rdev,
291 int min_uV, int max_uV)
292{
293 int best_val = INT_MAX;
294 int selector = 0;
295 int i, ret;
296
297 /* Find the smallest voltage that falls within the specified
298 * range.
299 */
300 for (i = 0; i < rdev->desc->n_voltages; i++) {
301 ret = rdev->desc->ops->list_voltage(rdev, i);
302 if (ret < 0)
303 continue;
304
305 if (ret < best_val && ret >= min_uV && ret <= max_uV) {
306 best_val = ret;
307 selector = i;
308 }
309 }
310
311 if (best_val != INT_MAX)
312 return selector;
313 else
314 return -EINVAL;
315}
316EXPORT_SYMBOL_GPL(regulator_map_voltage_iterate);
317
318/**
319 * regulator_map_voltage_ascend - map_voltage() for ascendant voltage list
320 *
321 * @rdev: Regulator to operate on
322 * @min_uV: Lower bound for voltage
323 * @max_uV: Upper bound for voltage
324 *
325 * Drivers that have ascendant voltage list can use this as their
326 * map_voltage() operation.
327 */
328int regulator_map_voltage_ascend(struct regulator_dev *rdev,
329 int min_uV, int max_uV)
330{
331 int i, ret;
332
333 for (i = 0; i < rdev->desc->n_voltages; i++) {
334 ret = rdev->desc->ops->list_voltage(rdev, i);
335 if (ret < 0)
336 continue;
337
338 if (ret > max_uV)
339 break;
340
341 if (ret >= min_uV && ret <= max_uV)
342 return i;
343 }
344
345 return -EINVAL;
346}
347EXPORT_SYMBOL_GPL(regulator_map_voltage_ascend);
348
349/**
350 * regulator_map_voltage_linear - map_voltage() for simple linear mappings
351 *
352 * @rdev: Regulator to operate on
353 * @min_uV: Lower bound for voltage
354 * @max_uV: Upper bound for voltage
355 *
356 * Drivers providing min_uV and uV_step in their regulator_desc can
357 * use this as their map_voltage() operation.
358 */
359int regulator_map_voltage_linear(struct regulator_dev *rdev,
360 int min_uV, int max_uV)
361{
362 int ret, voltage;
363
364 /* Allow uV_step to be 0 for fixed voltage */
365 if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) {
366 if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV)
367 return 0;
368 else
369 return -EINVAL;
370 }
371
372 if (!rdev->desc->uV_step) {
373 BUG_ON(!rdev->desc->uV_step);
374 return -EINVAL;
375 }
376
377 if (min_uV < rdev->desc->min_uV)
378 min_uV = rdev->desc->min_uV;
379
380 ret = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step);
381 if (ret < 0)
382 return ret;
383
384 ret += rdev->desc->linear_min_sel;
385
386 /* Map back into a voltage to verify we're still in bounds */
387 voltage = rdev->desc->ops->list_voltage(rdev, ret);
388 if (voltage < min_uV || voltage > max_uV)
389 return -EINVAL;
390
391 return ret;
392}
393EXPORT_SYMBOL_GPL(regulator_map_voltage_linear);
394
395/**
43343f8d 396 * regulator_map_voltage_linear_range - map_voltage() for multiple linear ranges
c4a54b8d
MB		 397 *
398 * @rdev: Regulator to operate on
399 * @min_uV: Lower bound for voltage
400 * @max_uV: Upper bound for voltage
401 *
402 * Drivers providing linear_ranges in their descriptor can use this as
403 * their map_voltage() callback.
404 */
405int regulator_map_voltage_linear_range(struct regulator_dev *rdev,
406 int min_uV, int max_uV)
407{
408 const struct regulator_linear_range *range;
409 int ret = -EINVAL;
410 int voltage, i;
411
412 if (!rdev->desc->n_linear_ranges) {
413 BUG_ON(!rdev->desc->n_linear_ranges);
414 return -EINVAL;
415 }
416
417 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
e277e656
AL		 418 int linear_max_uV;
419
c4a54b8d 420 range = &rdev->desc->linear_ranges[i];
e277e656
AL		 421 linear_max_uV = range->min_uV +
422 (range->max_sel - range->min_sel) * range->uV_step;
c4a54b8d 423
e277e656 424 if (!(min_uV <= linear_max_uV && max_uV >= range->min_uV))
c4a54b8d
MB		 425 continue;
426
427 if (min_uV <= range->min_uV)
428 min_uV = range->min_uV;
429
430 /* range->uV_step == 0 means fixed voltage range */
431 if (range->uV_step == 0) {
432 ret = 0;
433 } else {
434 ret = DIV_ROUND_UP(min_uV - range->min_uV,
435 range->uV_step);
436 if (ret < 0)
437 return ret;
438 }
439
440 ret += range->min_sel;
441
e7d80b6b
MV		 442 /*
443 * Map back into a voltage to verify we're still in bounds.
444 * If we are not, then continue checking rest of the ranges.
445 */
446 voltage = rdev->desc->ops->list_voltage(rdev, ret);
447 if (voltage >= min_uV && voltage <= max_uV)
448 break;
c4a54b8d
MB		 449 }
450
451 if (i == rdev->desc->n_linear_ranges)
452 return -EINVAL;
453
c4a54b8d
MB		 454 return ret;
455}
456EXPORT_SYMBOL_GPL(regulator_map_voltage_linear_range);
457
18e4b55f
MV		 458/**
459 * regulator_map_voltage_pickable_linear_range - map_voltage, pickable ranges
460 *
461 * @rdev: Regulator to operate on
462 * @min_uV: Lower bound for voltage
463 * @max_uV: Upper bound for voltage
464 *
465 * Drivers providing pickable linear_ranges in their descriptor can use
466 * this as their map_voltage() callback.
467 */
468int regulator_map_voltage_pickable_linear_range(struct regulator_dev *rdev,
469 int min_uV, int max_uV)
470{
471 const struct regulator_linear_range *range;
472 int ret = -EINVAL;
473 int voltage, i;
474 unsigned int selector = 0;
475
476 if (!rdev->desc->n_linear_ranges) {
477 BUG_ON(!rdev->desc->n_linear_ranges);
478 return -EINVAL;
479 }
480
481 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
482 int linear_max_uV;
483
484 range = &rdev->desc->linear_ranges[i];
485 linear_max_uV = range->min_uV +
486 (range->max_sel - range->min_sel) * range->uV_step;
487
488 if (!(min_uV <= linear_max_uV && max_uV >= range->min_uV)) {
489 selector += (range->max_sel - range->min_sel + 1);
490 continue;
491 }
492
493 if (min_uV <= range->min_uV)
494 min_uV = range->min_uV;
495
496 /* range->uV_step == 0 means fixed voltage range */
497 if (range->uV_step == 0) {
498 ret = 0;
499 } else {
500 ret = DIV_ROUND_UP(min_uV - range->min_uV,
501 range->uV_step);
502 if (ret < 0)
503 return ret;
504 }
505
506 ret += selector;
507
508 voltage = rdev->desc->ops->list_voltage(rdev, ret);
509
510 /*
511 * Map back into a voltage to verify we're still in bounds.
512 * We may have overlapping voltage ranges. Hence we don't
513 * exit but retry until we have checked all ranges.
514 */
515 if (voltage < min_uV || voltage > max_uV)
516 selector += (range->max_sel - range->min_sel + 1);
517 else
518 break;
519 }
520
521 if (i == rdev->desc->n_linear_ranges)
522 return -EINVAL;
523
524 return ret;
525}
526EXPORT_SYMBOL_GPL(regulator_map_voltage_pickable_linear_range);
527
d295f767
AL		 528/**
529 * regulator_list_voltage_linear - List voltages with simple calculation
530 *
531 * @rdev: Regulator device
532 * @selector: Selector to convert into a voltage
533 *
534 * Regulators with a simple linear mapping between voltages and
535 * selectors can set min_uV and uV_step in the regulator descriptor
536 * and then use this function as their list_voltage() operation,
537 */
538int regulator_list_voltage_linear(struct regulator_dev *rdev,
539 unsigned int selector)
540{
541 if (selector >= rdev->desc->n_voltages)
542 return -EINVAL;
543 if (selector < rdev->desc->linear_min_sel)
544 return 0;
545
546 selector -= rdev->desc->linear_min_sel;
547
548 return rdev->desc->min_uV + (rdev->desc->uV_step * selector);
549}
550EXPORT_SYMBOL_GPL(regulator_list_voltage_linear);
551
18e4b55f
MV		 552/**
553 * regulator_list_voltage_pickable_linear_range - pickable range list voltages
554 *
555 * @rdev: Regulator device
556 * @selector: Selector to convert into a voltage
557 *
558 * list_voltage() operation, intended to be used by drivers utilizing pickable
559 * ranges helpers.
560 */
561int regulator_list_voltage_pickable_linear_range(struct regulator_dev *rdev,
562 unsigned int selector)
563{
564 const struct regulator_linear_range *range;
565 int i;
566 unsigned int all_sels = 0;
567
568 if (!rdev->desc->n_linear_ranges) {
569 BUG_ON(!rdev->desc->n_linear_ranges);
570 return -EINVAL;
571 }
572
573 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
574 unsigned int sels_in_range;
575
576 range = &rdev->desc->linear_ranges[i];
577
578 sels_in_range = range->max_sel - range->min_sel;
579
580 if (all_sels + sels_in_range >= selector) {
581 selector -= all_sels;
582 return range->min_uV + (range->uV_step * selector);
583 }
584
585 all_sels += (sels_in_range + 1);
586 }
587
588 return -EINVAL;
589}
590EXPORT_SYMBOL_GPL(regulator_list_voltage_pickable_linear_range);
591
d295f767 592/**
6a47b4da 593 * regulator_desc_list_voltage_linear_range - List voltages for linear ranges
d295f767 594 *
6a47b4da 595 * @desc: Regulator desc for regulator which volatges are to be listed
d295f767
AL		 596 * @selector: Selector to convert into a voltage
597 *
598 * Regulators with a series of simple linear mappings between voltages
6a47b4da
MV		 599 * and selectors who have set linear_ranges in the regulator descriptor
600 * can use this function prior regulator registration to list voltages.
601 * This is useful when voltages need to be listed during device-tree
602 * parsing.
d295f767 603 */
6a47b4da
MV		 604int regulator_desc_list_voltage_linear_range(const struct regulator_desc *desc,
605 unsigned int selector)
d295f767
AL		 606{
607 const struct regulator_linear_range *range;
608 int i;
609
6a47b4da
MV		 610 if (!desc->n_linear_ranges) {
611 BUG_ON(!desc->n_linear_ranges);
d295f767
AL		 612 return -EINVAL;
613 }
614
6a47b4da
MV		 615 for (i = 0; i < desc->n_linear_ranges; i++) {
616 range = &desc->linear_ranges[i];
d295f767
AL		 617
618 if (!(selector >= range->min_sel &&
619 selector <= range->max_sel))
620 continue;
621
622 selector -= range->min_sel;
623
624 return range->min_uV + (range->uV_step * selector);
625 }
626
627 return -EINVAL;
628}
6a47b4da
MV		 629EXPORT_SYMBOL_GPL(regulator_desc_list_voltage_linear_range);
630
631/**
632 * regulator_list_voltage_linear_range - List voltages for linear ranges
633 *
634 * @rdev: Regulator device
635 * @selector: Selector to convert into a voltage
636 *
637 * Regulators with a series of simple linear mappings between voltages
638 * and selectors can set linear_ranges in the regulator descriptor and
639 * then use this function as their list_voltage() operation,
640 */
641int regulator_list_voltage_linear_range(struct regulator_dev *rdev,
642 unsigned int selector)
643{
644 return regulator_desc_list_voltage_linear_range(rdev->desc, selector);
645}
d295f767
AL		 646EXPORT_SYMBOL_GPL(regulator_list_voltage_linear_range);
647
648/**
649 * regulator_list_voltage_table - List voltages with table based mapping
650 *
651 * @rdev: Regulator device
652 * @selector: Selector to convert into a voltage
653 *
654 * Regulators with table based mapping between voltages and
655 * selectors can set volt_table in the regulator descriptor
656 * and then use this function as their list_voltage() operation.
657 */
658int regulator_list_voltage_table(struct regulator_dev *rdev,
659 unsigned int selector)
660{
661 if (!rdev->desc->volt_table) {
662 BUG_ON(!rdev->desc->volt_table);
663 return -EINVAL;
664 }
665
666 if (selector >= rdev->desc->n_voltages)
667 return -EINVAL;
668
669 return rdev->desc->volt_table[selector];
670}
671EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
672
c4a54b8d
MB		 673/**
674 * regulator_set_bypass_regmap - Default set_bypass() using regmap
675 *
676 * @rdev: device to operate on.
677 * @enable: state to set.
678 */
679int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
680{
681 unsigned int val;
682
ca5d1b35
CC		 683 if (enable) {
684 val = rdev->desc->bypass_val_on;
685 if (!val)
686 val = rdev->desc->bypass_mask;
687 } else {
688 val = rdev->desc->bypass_val_off;
689 }
c4a54b8d
MB		 690
691 return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
692 rdev->desc->bypass_mask, val);
693}
694EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap);
695
a7a453f5
CK		 696/**
697 * regulator_set_soft_start_regmap - Default set_soft_start() using regmap
698 *
699 * @rdev: device to operate on.
700 */
701int regulator_set_soft_start_regmap(struct regulator_dev *rdev)
702{
703 unsigned int val;
704
705 val = rdev->desc->soft_start_val_on;
706 if (!val)
707 val = rdev->desc->soft_start_mask;
708
709 return regmap_update_bits(rdev->regmap, rdev->desc->soft_start_reg,
710 rdev->desc->soft_start_mask, val);
711}
712EXPORT_SYMBOL_GPL(regulator_set_soft_start_regmap);
713
f7d37bc3
CK		 714/**
715 * regulator_set_pull_down_regmap - Default set_pull_down() using regmap
716 *
717 * @rdev: device to operate on.
718 */
719int regulator_set_pull_down_regmap(struct regulator_dev *rdev)
720{
721 unsigned int val;
722
723 val = rdev->desc->pull_down_val_on;
724 if (!val)
725 val = rdev->desc->pull_down_mask;
726
727 return regmap_update_bits(rdev->regmap, rdev->desc->pull_down_reg,
728 rdev->desc->pull_down_mask, val);
729}
730EXPORT_SYMBOL_GPL(regulator_set_pull_down_regmap);
731
c4a54b8d
MB		 732/**
733 * regulator_get_bypass_regmap - Default get_bypass() using regmap
734 *
735 * @rdev: device to operate on.
736 * @enable: current state.
737 */
738int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable)
739{
740 unsigned int val;
85b03744 741 unsigned int val_on = rdev->desc->bypass_val_on;
c4a54b8d
MB		 742 int ret;
743
744 ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val);
745 if (ret != 0)
746 return ret;
747
85b03744
CK		 748 if (!val_on)
749 val_on = rdev->desc->bypass_mask;
750
751 *enable = (val & rdev->desc->bypass_mask) == val_on;
c4a54b8d
MB		 752
753 return 0;
754}
755EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap);
354794da
LD		 756
757/**
758 * regulator_set_active_discharge_regmap - Default set_active_discharge()
759 * using regmap
760 *
761 * @rdev: device to operate on.
762 * @enable: state to set, 0 to disable and 1 to enable.
763 */
764int regulator_set_active_discharge_regmap(struct regulator_dev *rdev,
765 bool enable)
766{
767 unsigned int val;
768
769 if (enable)
770 val = rdev->desc->active_discharge_on;
771 else
772 val = rdev->desc->active_discharge_off;
773
774 return regmap_update_bits(rdev->regmap,
775 rdev->desc->active_discharge_reg,
776 rdev->desc->active_discharge_mask, val);
777}
778EXPORT_SYMBOL_GPL(regulator_set_active_discharge_regmap);
a32e0c77
AL		 779
780/**
781 * regulator_set_current_limit_regmap - set_current_limit for regmap users
782 *
783 * @rdev: regulator to operate on
784 * @min_uA: Lower bound for current limit
785 * @max_uA: Upper bound for current limit
786 *
787 * Regulators that use regmap for their register I/O can set curr_table,
788 * csel_reg and csel_mask fields in their descriptor and then use this
789 * as their set_current_limit operation, saving some code.
790 */
791int regulator_set_current_limit_regmap(struct regulator_dev *rdev,
792 int min_uA, int max_uA)
793{
794 unsigned int n_currents = rdev->desc->n_current_limits;
795 int i, sel = -1;
796
797 if (n_currents == 0)
798 return -EINVAL;
799
800 if (rdev->desc->curr_table) {
801 const unsigned int *curr_table = rdev->desc->curr_table;
802 bool ascend = curr_table[n_currents - 1] > curr_table[0];
803
804 /* search for closest to maximum */
805 if (ascend) {
806 for (i = n_currents - 1; i >= 0; i--) {
807 if (min_uA <= curr_table[i] &&
808 curr_table[i] <= max_uA) {
809 sel = i;
810 break;
811 }
812 }
813 } else {
814 for (i = 0; i < n_currents; i++) {
815 if (min_uA <= curr_table[i] &&
816 curr_table[i] <= max_uA) {
817 sel = i;
818 break;
819 }
820 }
821 }
822 }
823
824 if (sel < 0)
825 return -EINVAL;
826
827 sel <<= ffs(rdev->desc->csel_mask) - 1;
828
829 return regmap_update_bits(rdev->regmap, rdev->desc->csel_reg,
830 rdev->desc->csel_mask, sel);
831}
832EXPORT_SYMBOL_GPL(regulator_set_current_limit_regmap);
833
834/**
835 * regulator_get_current_limit_regmap - get_current_limit for regmap users
836 *
837 * @rdev: regulator to operate on
838 *
839 * Regulators that use regmap for their register I/O can set the
840 * csel_reg and csel_mask fields in their descriptor and then use this
841 * as their get_current_limit operation, saving some code.
842 */
843int regulator_get_current_limit_regmap(struct regulator_dev *rdev)
844{
845 unsigned int val;
846 int ret;
847
848 ret = regmap_read(rdev->regmap, rdev->desc->csel_reg, &val);
849 if (ret != 0)
850 return ret;
851
852 val &= rdev->desc->csel_mask;
853 val >>= ffs(rdev->desc->csel_mask) - 1;
854
855 if (rdev->desc->curr_table) {
856 if (val >= rdev->desc->n_current_limits)
857 return -EINVAL;
858
859 return rdev->desc->curr_table[val];
860 }
861
862 return -EINVAL;
863}
864EXPORT_SYMBOL_GPL(regulator_get_current_limit_regmap);
d0087e72
BG		 865
866/**
867 * regulator_bulk_set_supply_names - initialize the 'supply' fields in an array
868 * of regulator_bulk_data structs
869 *
870 * @consumers: array of regulator_bulk_data entries to initialize
871 * @supply_names: array of supply name strings
872 * @num_supplies: number of supply names to initialize
873 *
874 * Note: the 'consumers' array must be the size of 'num_supplies'.
875 */
876void regulator_bulk_set_supply_names(struct regulator_bulk_data *consumers,
877 const char *const *supply_names,
878 unsigned int num_supplies)
879{
880 unsigned int i;
881
882 for (i = 0; i < num_supplies; i++)
883 consumers[i].supply = supply_names[i];
884}
885EXPORT_SYMBOL_GPL(regulator_bulk_set_supply_names);
b059b7e0
MV		 886
887/**
888 * regulator_is_equal - test whether two regulators are the same
889 *
890 * @reg1: first regulator to operate on
891 * @reg2: second regulator to operate on
892 */
893bool regulator_is_equal(struct regulator *reg1, struct regulator *reg2)
894{
895 return reg1->rdev == reg2->rdev;
896}
897EXPORT_SYMBOL_GPL(regulator_is_equal);
Ubuntu Jammy Linux kernel mirror