1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
4  *	      http://www.samsung.com/
5  * Author: Marek Szyprowski <m.szyprowski@samsung.com>
6  *
7  * Simplified generic voltage coupler from regulator core.c
8  * The main difference is that it keeps current regulator voltage
9  * if consumers didn't apply their constraints yet.
10  */
11 
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/of.h>
15 #include <linux/regulator/coupler.h>
16 #include <linux/regulator/driver.h>
17 #include <linux/regulator/machine.h>
18 
19 static int regulator_get_optimal_voltage(struct regulator_dev *rdev,
20 					 int *current_uV,
21 					 int *min_uV, int *max_uV,
22 					 suspend_state_t state)
23 {
24 	struct coupling_desc *c_desc = &rdev->coupling_desc;
25 	struct regulator_dev **c_rdevs = c_desc->coupled_rdevs;
26 	struct regulation_constraints *constraints = rdev->constraints;
27 	int desired_min_uV = 0, desired_max_uV = INT_MAX;
28 	int max_current_uV = 0, min_current_uV = INT_MAX;
29 	int highest_min_uV = 0, target_uV, possible_uV;
30 	int i, ret, max_spread, n_coupled = c_desc->n_coupled;
31 	bool done;
32 
33 	*current_uV = -1;
34 
35 	/* Find highest min desired voltage */
36 	for (i = 0; i < n_coupled; i++) {
37 		int tmp_min = 0;
38 		int tmp_max = INT_MAX;
39 
40 		lockdep_assert_held_once(&c_rdevs[i]->mutex.base);
41 
42 		ret = regulator_check_consumers(c_rdevs[i],
43 						&tmp_min,
44 						&tmp_max, state);
45 		if (ret < 0)
46 			return ret;
47 
48 		if (tmp_min == 0) {
49 			ret = regulator_get_voltage_rdev(c_rdevs[i]);
50 			if (ret < 0)
51 				return ret;
52 			tmp_min = ret;
53 		}
54 
55 		/* apply constraints */
56 		ret = regulator_check_voltage(c_rdevs[i], &tmp_min, &tmp_max);
57 		if (ret < 0)
58 			return ret;
59 
60 		highest_min_uV = max(highest_min_uV, tmp_min);
61 
62 		if (i == 0) {
63 			desired_min_uV = tmp_min;
64 			desired_max_uV = tmp_max;
65 		}
66 	}
67 
68 	max_spread = constraints->max_spread[0];
69 
70 	/*
71 	 * Let target_uV be equal to the desired one if possible.
72 	 * If not, set it to minimum voltage, allowed by other coupled
73 	 * regulators.
74 	 */
75 	target_uV = max(desired_min_uV, highest_min_uV - max_spread);
76 
77 	/*
78 	 * Find min and max voltages, which currently aren't violating
79 	 * max_spread.
80 	 */
81 	for (i = 1; i < n_coupled; i++) {
82 		int tmp_act;
83 
84 		tmp_act = regulator_get_voltage_rdev(c_rdevs[i]);
85 		if (tmp_act < 0)
86 			return tmp_act;
87 
88 		min_current_uV = min(tmp_act, min_current_uV);
89 		max_current_uV = max(tmp_act, max_current_uV);
90 	}
91 
92 	/*
93 	 * Correct target voltage, so as it currently isn't
94 	 * violating max_spread
95 	 */
96 	possible_uV = max(target_uV, max_current_uV - max_spread);
97 	possible_uV = min(possible_uV, min_current_uV + max_spread);
98 
99 	if (possible_uV > desired_max_uV)
100 		return -EINVAL;
101 
102 	done = (possible_uV == target_uV);
103 	desired_min_uV = possible_uV;
104 
105 	/* Set current_uV if wasn't done earlier in the code and if necessary */
106 	if (*current_uV == -1) {
107 		ret = regulator_get_voltage_rdev(rdev);
108 		if (ret < 0)
109 			return ret;
110 		*current_uV = ret;
111 	}
112 
113 	*min_uV = desired_min_uV;
114 	*max_uV = desired_max_uV;
115 
116 	return done;
117 }
118 
119 static int exynos_coupler_balance_voltage(struct regulator_coupler *coupler,
120 					  struct regulator_dev *rdev,
121 					  suspend_state_t state)
122 {
123 	struct regulator_dev **c_rdevs;
124 	struct regulator_dev *best_rdev;
125 	struct coupling_desc *c_desc = &rdev->coupling_desc;
126 	int i, ret, n_coupled, best_min_uV, best_max_uV, best_c_rdev;
127 	unsigned int delta, best_delta;
128 	unsigned long c_rdev_done = 0;
129 	bool best_c_rdev_done;
130 
131 	c_rdevs = c_desc->coupled_rdevs;
132 	n_coupled = c_desc->n_coupled;
133 
134 	/*
135 	 * Find the best possible voltage change on each loop. Leave the loop
136 	 * if there isn't any possible change.
137 	 */
138 	do {
139 		best_c_rdev_done = false;
140 		best_delta = 0;
141 		best_min_uV = 0;
142 		best_max_uV = 0;
143 		best_c_rdev = 0;
144 		best_rdev = NULL;
145 
146 		/*
147 		 * Find highest difference between optimal voltage
148 		 * and current voltage.
149 		 */
150 		for (i = 0; i < n_coupled; i++) {
151 			/*
152 			 * optimal_uV is the best voltage that can be set for
153 			 * i-th regulator at the moment without violating
154 			 * max_spread constraint in order to balance
155 			 * the coupled voltages.
156 			 */
157 			int optimal_uV = 0, optimal_max_uV = 0, current_uV = 0;
158 
159 			if (test_bit(i, &c_rdev_done))
160 				continue;
161 
162 			ret = regulator_get_optimal_voltage(c_rdevs[i],
163 							    &current_uV,
164 							    &optimal_uV,
165 							    &optimal_max_uV,
166 							    state);
167 			if (ret < 0)
168 				goto out;
169 
170 			delta = abs(optimal_uV - current_uV);
171 
172 			if (delta && best_delta <= delta) {
173 				best_c_rdev_done = ret;
174 				best_delta = delta;
175 				best_rdev = c_rdevs[i];
176 				best_min_uV = optimal_uV;
177 				best_max_uV = optimal_max_uV;
178 				best_c_rdev = i;
179 			}
180 		}
181 
182 		/* Nothing to change, return successfully */
183 		if (!best_rdev) {
184 			ret = 0;
185 			goto out;
186 		}
187 
188 		ret = regulator_set_voltage_rdev(best_rdev, best_min_uV,
189 						 best_max_uV, state);
190 
191 		if (ret < 0)
192 			goto out;
193 
194 		if (best_c_rdev_done)
195 			set_bit(best_c_rdev, &c_rdev_done);
196 
197 	} while (n_coupled > 1);
198 
199 out:
200 	return ret;
201 }
202 
203 static int exynos_coupler_attach(struct regulator_coupler *coupler,
204 				 struct regulator_dev *rdev)
205 {
206 	return 0;
207 }
208 
209 static struct regulator_coupler exynos_coupler = {
210 	.attach_regulator = exynos_coupler_attach,
211 	.balance_voltage  = exynos_coupler_balance_voltage,
212 };
213 
214 static int __init exynos_coupler_init(void)
215 {
216 	if (!of_machine_is_compatible("samsung,exynos5800"))
217 		return 0;
218 
219 	return regulator_coupler_register(&exynos_coupler);
220 }
221 arch_initcall(exynos_coupler_init);
222