1
2
3
4
5
6
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
20
21
22
23
24
25
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
52
53
54
55
56
57
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
78
79
80
81
82
83
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
121
122
123
124
125
126
127
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
164
165
166
167
168
169
170
171
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
228
229
230
231
232
233
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
253
254
255
256
257
258
259
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
282
283
284
285
286
287
288
289
290
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
300
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
322
323
324
325
326
327
328
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
353
354
355
356
357
358
359
360
361int regulator_map_voltage_linear(struct regulator_dev *rdev,
362 int min_uV, int max_uV)
363{
364 int ret, voltage;
365
366
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
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
399
400
401
402
403
404
405
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
432
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
448
449
450
451
452
453
454
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
495
496
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
513
514
515
516
517
518
519
520
521
522
523int regulator_desc_list_voltage_linear(const struct regulator_desc *desc,
524 unsigned int selector)
525{
526 if (selector >= desc->n_voltages)
527 return -EINVAL;
528
529 if (selector < desc->linear_min_sel)
530 return 0;
531
532 selector -= desc->linear_min_sel;
533
534 return desc->min_uV + (desc->uV_step * selector);
535}
536EXPORT_SYMBOL_GPL(regulator_desc_list_voltage_linear);
537
538
539
540
541
542
543
544
545
546
547
548int regulator_list_voltage_linear(struct regulator_dev *rdev,
549 unsigned int selector)
550{
551 return regulator_desc_list_voltage_linear(rdev->desc, selector);
552}
553EXPORT_SYMBOL_GPL(regulator_list_voltage_linear);
554
555
556
557
558
559
560
561
562
563
564int regulator_list_voltage_pickable_linear_range(struct regulator_dev *rdev,
565 unsigned int selector)
566{
567 const struct linear_range *range;
568 int i;
569 unsigned int all_sels = 0;
570
571 if (!rdev->desc->n_linear_ranges) {
572 BUG_ON(!rdev->desc->n_linear_ranges);
573 return -EINVAL;
574 }
575
576 for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
577 unsigned int sel_indexes;
578
579 range = &rdev->desc->linear_ranges[i];
580
581 sel_indexes = linear_range_values_in_range(range) - 1;
582
583 if (all_sels + sel_indexes >= selector) {
584 selector -= all_sels;
585
586
587
588
589
590
591
592
593
594
595 return range->min + (range->step * selector);
596 }
597
598 all_sels += (sel_indexes + 1);
599 }
600
601 return -EINVAL;
602}
603EXPORT_SYMBOL_GPL(regulator_list_voltage_pickable_linear_range);
604
605
606
607
608
609
610
611
612
613
614
615
616
617int regulator_desc_list_voltage_linear_range(const struct regulator_desc *desc,
618 unsigned int selector)
619{
620 unsigned int val;
621 int ret;
622
623 BUG_ON(!desc->n_linear_ranges);
624
625 ret = linear_range_get_value_array(desc->linear_ranges,
626 desc->n_linear_ranges, selector,
627 &val);
628 if (ret)
629 return ret;
630
631 return val;
632}
633EXPORT_SYMBOL_GPL(regulator_desc_list_voltage_linear_range);
634
635
636
637
638
639
640
641
642
643
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
654
655
656
657
658
659
660
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 if (selector < rdev->desc->linear_min_sel)
673 return 0;
674
675 return rdev->desc->volt_table[selector];
676}
677EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
678
679
680
681
682
683
684
685int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
686{
687 unsigned int val;
688
689 if (enable) {
690 val = rdev->desc->bypass_val_on;
691 if (!val)
692 val = rdev->desc->bypass_mask;
693 } else {
694 val = rdev->desc->bypass_val_off;
695 }
696
697 return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
698 rdev->desc->bypass_mask, val);
699}
700EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap);
701
702
703
704
705
706
707int regulator_set_soft_start_regmap(struct regulator_dev *rdev)
708{
709 unsigned int val;
710
711 val = rdev->desc->soft_start_val_on;
712 if (!val)
713 val = rdev->desc->soft_start_mask;
714
715 return regmap_update_bits(rdev->regmap, rdev->desc->soft_start_reg,
716 rdev->desc->soft_start_mask, val);
717}
718EXPORT_SYMBOL_GPL(regulator_set_soft_start_regmap);
719
720
721
722
723
724
725int regulator_set_pull_down_regmap(struct regulator_dev *rdev)
726{
727 unsigned int val;
728
729 val = rdev->desc->pull_down_val_on;
730 if (!val)
731 val = rdev->desc->pull_down_mask;
732
733 return regmap_update_bits(rdev->regmap, rdev->desc->pull_down_reg,
734 rdev->desc->pull_down_mask, val);
735}
736EXPORT_SYMBOL_GPL(regulator_set_pull_down_regmap);
737
738
739
740
741
742
743
744int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable)
745{
746 unsigned int val;
747 unsigned int val_on = rdev->desc->bypass_val_on;
748 int ret;
749
750 ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val);
751 if (ret != 0)
752 return ret;
753
754 if (!val_on)
755 val_on = rdev->desc->bypass_mask;
756
757 *enable = (val & rdev->desc->bypass_mask) == val_on;
758
759 return 0;
760}
761EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap);
762
763
764
765
766
767
768
769
770int regulator_set_active_discharge_regmap(struct regulator_dev *rdev,
771 bool enable)
772{
773 unsigned int val;
774
775 if (enable)
776 val = rdev->desc->active_discharge_on;
777 else
778 val = rdev->desc->active_discharge_off;
779
780 return regmap_update_bits(rdev->regmap,
781 rdev->desc->active_discharge_reg,
782 rdev->desc->active_discharge_mask, val);
783}
784EXPORT_SYMBOL_GPL(regulator_set_active_discharge_regmap);
785
786
787
788
789
790
791
792
793
794
795
796
797int regulator_set_current_limit_regmap(struct regulator_dev *rdev,
798 int min_uA, int max_uA)
799{
800 unsigned int n_currents = rdev->desc->n_current_limits;
801 int i, sel = -1;
802
803 if (n_currents == 0)
804 return -EINVAL;
805
806 if (rdev->desc->curr_table) {
807 const unsigned int *curr_table = rdev->desc->curr_table;
808 bool ascend = curr_table[n_currents - 1] > curr_table[0];
809
810
811 if (ascend) {
812 for (i = n_currents - 1; i >= 0; i--) {
813 if (min_uA <= curr_table[i] &&
814 curr_table[i] <= max_uA) {
815 sel = i;
816 break;
817 }
818 }
819 } else {
820 for (i = 0; i < n_currents; i++) {
821 if (min_uA <= curr_table[i] &&
822 curr_table[i] <= max_uA) {
823 sel = i;
824 break;
825 }
826 }
827 }
828 }
829
830 if (sel < 0)
831 return -EINVAL;
832
833 sel <<= ffs(rdev->desc->csel_mask) - 1;
834
835 return regmap_update_bits(rdev->regmap, rdev->desc->csel_reg,
836 rdev->desc->csel_mask, sel);
837}
838EXPORT_SYMBOL_GPL(regulator_set_current_limit_regmap);
839
840
841
842
843
844
845
846
847
848
849int regulator_get_current_limit_regmap(struct regulator_dev *rdev)
850{
851 unsigned int val;
852 int ret;
853
854 ret = regmap_read(rdev->regmap, rdev->desc->csel_reg, &val);
855 if (ret != 0)
856 return ret;
857
858 val &= rdev->desc->csel_mask;
859 val >>= ffs(rdev->desc->csel_mask) - 1;
860
861 if (rdev->desc->curr_table) {
862 if (val >= rdev->desc->n_current_limits)
863 return -EINVAL;
864
865 return rdev->desc->curr_table[val];
866 }
867
868 return -EINVAL;
869}
870EXPORT_SYMBOL_GPL(regulator_get_current_limit_regmap);
871
872
873
874
875
876
877
878
879
880
881
882void regulator_bulk_set_supply_names(struct regulator_bulk_data *consumers,
883 const char *const *supply_names,
884 unsigned int num_supplies)
885{
886 unsigned int i;
887
888 for (i = 0; i < num_supplies; i++)
889 consumers[i].supply = supply_names[i];
890}
891EXPORT_SYMBOL_GPL(regulator_bulk_set_supply_names);
892
893
894
895
896
897
898
899bool regulator_is_equal(struct regulator *reg1, struct regulator *reg2)
900{
901 return reg1->rdev == reg2->rdev;
902}
903EXPORT_SYMBOL_GPL(regulator_is_equal);
904
905static int find_closest_bigger(unsigned int target, const unsigned int *table,
906 unsigned int num_sel, unsigned int *sel)
907{
908 unsigned int s, tmp, max, maxsel = 0;
909 bool found = false;
910
911 max = table[0];
912
913 for (s = 0; s < num_sel; s++) {
914 if (table[s] > max) {
915 max = table[s];
916 maxsel = s;
917 }
918 if (table[s] >= target) {
919 if (!found || table[s] - target < tmp - target) {
920 tmp = table[s];
921 *sel = s;
922 found = true;
923 if (tmp == target)
924 break;
925 }
926 }
927 }
928
929 if (!found) {
930 *sel = maxsel;
931 return -EINVAL;
932 }
933
934 return 0;
935}
936
937
938
939
940
941
942
943
944
945
946int regulator_set_ramp_delay_regmap(struct regulator_dev *rdev, int ramp_delay)
947{
948 int ret;
949 unsigned int sel;
950
951 if (WARN_ON(!rdev->desc->n_ramp_values || !rdev->desc->ramp_delay_table))
952 return -EINVAL;
953
954 ret = find_closest_bigger(ramp_delay, rdev->desc->ramp_delay_table,
955 rdev->desc->n_ramp_values, &sel);
956
957 if (ret) {
958 dev_warn(rdev_get_dev(rdev),
959 "Can't set ramp-delay %u, setting %u\n", ramp_delay,
960 rdev->desc->ramp_delay_table[sel]);
961 }
962
963 sel <<= ffs(rdev->desc->ramp_mask) - 1;
964
965 return regmap_update_bits(rdev->regmap, rdev->desc->ramp_reg,
966 rdev->desc->ramp_mask, sel);
967}
968EXPORT_SYMBOL_GPL(regulator_set_ramp_delay_regmap);
969