exynos-regulator-coupler.c

  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
 19static 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
119static 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
199out:
200	return ret;
201}
202
203static int exynos_coupler_attach(struct regulator_coupler *coupler,
204				 struct regulator_dev *rdev)
205{
206	return 0;
207}
208
209static struct regulator_coupler exynos_coupler = {
210	.attach_regulator = exynos_coupler_attach,
211	.balance_voltage  = exynos_coupler_balance_voltage,
212};
213
214static 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}
221arch_initcall(exynos_coupler_init);