projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6-block.git] / drivers / regulator / helpers.c
CommitLineData
c4a54b8d
MB		 1/*
2 * helpers.c -- Voltage/Current Regulator framework helper functions.
3 *
4 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
5 * Copyright 2008 SlimLogic Ltd.
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
11 *
12 */
13
14#include <linux/kernel.h>
15#include <linux/err.h>
16#include <linux/delay.h>
17#include <linux/regmap.h>
18#include <linux/regulator/consumer.h>
19#include <linux/regulator/driver.h>
20#include <linux/module.h>
21
22/**
23 * regulator_is_enabled_regmap - standard is_enabled() for regmap users
24 *
25 * @rdev: regulator to operate on
26 *
27 * Regulators that use regmap for their register I/O can set the
28 * enable_reg and enable_mask fields in their descriptor and then use
29 * this as their is_enabled operation, saving some code.
30 */
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
ca5d1b35
CC		 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 }
c4a54b8d
MB		 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
ca5d1b35
CC		 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 }
c4a54b8d
MB		 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
ca5d1b35
CC		 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 }
c4a54b8d
MB		 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
18e4b55f
MV		 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
c4a54b8d
MB		 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/**
43343f8d 400 * regulator_map_voltage_linear_range - map_voltage() for multiple linear ranges
c4a54b8d
MB		 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++) {
e277e656
AL		 422 int linear_max_uV;
423
c4a54b8d 424 range = &rdev->desc->linear_ranges[i];
e277e656
AL		 425 linear_max_uV = range->min_uV +
426 (range->max_sel - range->min_sel) * range->uV_step;
c4a54b8d 427
e277e656 428 if (!(min_uV <= linear_max_uV && max_uV >= range->min_uV))
c4a54b8d
MB		 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
e7d80b6b
MV		 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;
c4a54b8d
MB		 453 }
454
455 if (i == rdev->desc->n_linear_ranges)
456 return -EINVAL;
457
c4a54b8d
MB		 458 return ret;
459}
460EXPORT_SYMBOL_GPL(regulator_map_voltage_linear_range);
461
18e4b55f
MV		 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
d295f767
AL		 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
18e4b55f
MV		 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
d295f767
AL		 596/**
597 * regulator_list_voltage_linear_range - List voltages for linear ranges
598 *
599 * @rdev: Regulator device
600 * @selector: Selector to convert into a voltage
601 *
602 * Regulators with a series of simple linear mappings between voltages
603 * and selectors can set linear_ranges in the regulator descriptor and
604 * then use this function as their list_voltage() operation,
605 */
606int regulator_list_voltage_linear_range(struct regulator_dev *rdev,
607 unsigned int selector)
608{
609 const struct regulator_linear_range *range;
610 int i;
611
612 if (!rdev->desc->n_linear_ranges) {
613 BUG_ON(!rdev->desc->n_linear_ranges);
614 return -EINVAL;
615 }
616
617 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
618 range = &rdev->desc->linear_ranges[i];
619
620 if (!(selector >= range->min_sel &&
621 selector <= range->max_sel))
622 continue;
623
624 selector -= range->min_sel;
625
626 return range->min_uV + (range->uV_step * selector);
627 }
628
629 return -EINVAL;
630}
631EXPORT_SYMBOL_GPL(regulator_list_voltage_linear_range);
632
633/**
634 * regulator_list_voltage_table - List voltages with table based mapping
635 *
636 * @rdev: Regulator device
637 * @selector: Selector to convert into a voltage
638 *
639 * Regulators with table based mapping between voltages and
640 * selectors can set volt_table in the regulator descriptor
641 * and then use this function as their list_voltage() operation.
642 */
643int regulator_list_voltage_table(struct regulator_dev *rdev,
644 unsigned int selector)
645{
646 if (!rdev->desc->volt_table) {
647 BUG_ON(!rdev->desc->volt_table);
648 return -EINVAL;
649 }
650
651 if (selector >= rdev->desc->n_voltages)
652 return -EINVAL;
653
654 return rdev->desc->volt_table[selector];
655}
656EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
657
c4a54b8d
MB		 658/**
659 * regulator_set_bypass_regmap - Default set_bypass() using regmap
660 *
661 * @rdev: device to operate on.
662 * @enable: state to set.
663 */
664int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
665{
666 unsigned int val;
667
ca5d1b35
CC		 668 if (enable) {
669 val = rdev->desc->bypass_val_on;
670 if (!val)
671 val = rdev->desc->bypass_mask;
672 } else {
673 val = rdev->desc->bypass_val_off;
674 }
c4a54b8d
MB		 675
676 return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
677 rdev->desc->bypass_mask, val);
678}
679EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap);
680
a7a453f5
CK		 681/**
682 * regulator_set_soft_start_regmap - Default set_soft_start() using regmap
683 *
684 * @rdev: device to operate on.
685 */
686int regulator_set_soft_start_regmap(struct regulator_dev *rdev)
687{
688 unsigned int val;
689
690 val = rdev->desc->soft_start_val_on;
691 if (!val)
692 val = rdev->desc->soft_start_mask;
693
694 return regmap_update_bits(rdev->regmap, rdev->desc->soft_start_reg,
695 rdev->desc->soft_start_mask, val);
696}
697EXPORT_SYMBOL_GPL(regulator_set_soft_start_regmap);
698
f7d37bc3
CK		 699/**
700 * regulator_set_pull_down_regmap - Default set_pull_down() using regmap
701 *
702 * @rdev: device to operate on.
703 */
704int regulator_set_pull_down_regmap(struct regulator_dev *rdev)
705{
706 unsigned int val;
707
708 val = rdev->desc->pull_down_val_on;
709 if (!val)
710 val = rdev->desc->pull_down_mask;
711
712 return regmap_update_bits(rdev->regmap, rdev->desc->pull_down_reg,
713 rdev->desc->pull_down_mask, val);
714}
715EXPORT_SYMBOL_GPL(regulator_set_pull_down_regmap);
716
c4a54b8d
MB		 717/**
718 * regulator_get_bypass_regmap - Default get_bypass() using regmap
719 *
720 * @rdev: device to operate on.
721 * @enable: current state.
722 */
723int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable)
724{
725 unsigned int val;
85b03744 726 unsigned int val_on = rdev->desc->bypass_val_on;
c4a54b8d
MB		 727 int ret;
728
729 ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val);
730 if (ret != 0)
731 return ret;
732
85b03744
CK		 733 if (!val_on)
734 val_on = rdev->desc->bypass_mask;
735
736 *enable = (val & rdev->desc->bypass_mask) == val_on;
c4a54b8d
MB		 737
738 return 0;
739}
740EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap);
354794da
LD		 741
742/**
743 * regulator_set_active_discharge_regmap - Default set_active_discharge()
744 * using regmap
745 *
746 * @rdev: device to operate on.
747 * @enable: state to set, 0 to disable and 1 to enable.
748 */
749int regulator_set_active_discharge_regmap(struct regulator_dev *rdev,
750 bool enable)
751{
752 unsigned int val;
753
754 if (enable)
755 val = rdev->desc->active_discharge_on;
756 else
757 val = rdev->desc->active_discharge_off;
758
759 return regmap_update_bits(rdev->regmap,
760 rdev->desc->active_discharge_reg,
761 rdev->desc->active_discharge_mask, val);
762}
763EXPORT_SYMBOL_GPL(regulator_set_active_discharge_regmap);
Linux 6.x block layer and io_uring tree(s)