soc: samsung: exynos-regulator-coupler: Add simple voltage coupler for Exynos5800
authorMarek Szyprowski <m.szyprowski@samsung.com>
Tue, 21 Jul 2020 18:09:00 +0000 (20:09 +0200)
committerArnd Bergmann <arnd@arndb.de>
Wed, 22 Jul 2020 20:33:57 +0000 (22:33 +0200)
Add a simple custom voltage regulator coupler for Exynos5800 SoCs, which
require coupling between "vdd_arm" and "vdd_int" regulators. This coupler
ensures that the voltage values don't go below the bootloader-selected
operation point during the boot process until the clients set their
constraints. It is achieved by assuming minimal voltage value equal to
the current value if no constraints are set. This also ensures proper
voltage balancing if any of the client driver is missing.

The balancing code comes from the regulator/core.c with the additional
logic for handling regulators without client constraints applied added.

Link: https://lore.kernel.org/r/20200721180900.13844-5-krzk@kernel.org
Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
Reviewed-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Krzysztof Kozlowski <krzk@kernel.org>
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
arch/arm/mach-exynos/Kconfig
drivers/soc/samsung/Kconfig
drivers/soc/samsung/Makefile
drivers/soc/samsung/exynos-regulator-coupler.c [new file with mode: 0644]

index 7683825..f185cd3 100644 (file)
@@ -118,6 +118,7 @@ config SOC_EXYNOS5800
        bool "Samsung EXYNOS5800"
        default y
        depends on SOC_EXYNOS5420
+       select EXYNOS_REGULATOR_COUPLER
 
 config EXYNOS_MCPM
        bool
index c7a2003..2641856 100644 (file)
@@ -37,4 +37,7 @@ config EXYNOS_PM_DOMAINS
        bool "Exynos PM domains" if COMPILE_TEST
        depends on PM_GENERIC_DOMAINS || COMPILE_TEST
 
+config EXYNOS_REGULATOR_COUPLER
+       bool "Exynos SoC Regulator Coupler" if COMPILE_TEST
+       depends on ARCH_EXYNOS || COMPILE_TEST
 endif
index edd1d6e..ecc3a32 100644 (file)
@@ -9,3 +9,4 @@ obj-$(CONFIG_EXYNOS_PMU)        += exynos-pmu.o
 obj-$(CONFIG_EXYNOS_PMU_ARM_DRIVERS)   += exynos3250-pmu.o exynos4-pmu.o \
                                        exynos5250-pmu.o exynos5420-pmu.o
 obj-$(CONFIG_EXYNOS_PM_DOMAINS) += pm_domains.o
+obj-$(CONFIG_EXYNOS_REGULATOR_COUPLER) += exynos-regulator-coupler.o
diff --git a/drivers/soc/samsung/exynos-regulator-coupler.c b/drivers/soc/samsung/exynos-regulator-coupler.c
new file mode 100644 (file)
index 0000000..61a156b
--- /dev/null
@@ -0,0 +1,221 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *           http://www.samsung.com/
+ * Author: Marek Szyprowski <m.szyprowski@samsung.com>
+ *
+ * Simplified generic voltage coupler from regulator core.c
+ * The main difference is that it keeps current regulator voltage
+ * if consumers didn't apply their constraints yet.
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/of.h>
+#include <linux/regulator/coupler.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+
+static int regulator_get_optimal_voltage(struct regulator_dev *rdev,
+                                        int *current_uV,
+                                        int *min_uV, int *max_uV,
+                                        suspend_state_t state)
+{
+       struct coupling_desc *c_desc = &rdev->coupling_desc;
+       struct regulator_dev **c_rdevs = c_desc->coupled_rdevs;
+       struct regulation_constraints *constraints = rdev->constraints;
+       int desired_min_uV = 0, desired_max_uV = INT_MAX;
+       int max_current_uV = 0, min_current_uV = INT_MAX;
+       int highest_min_uV = 0, target_uV, possible_uV;
+       int i, ret, max_spread, n_coupled = c_desc->n_coupled;
+       bool done;
+
+       *current_uV = -1;
+
+       /* Find highest min desired voltage */
+       for (i = 0; i < n_coupled; i++) {
+               int tmp_min = 0;
+               int tmp_max = INT_MAX;
+
+               lockdep_assert_held_once(&c_rdevs[i]->mutex.base);
+
+               ret = regulator_check_consumers(c_rdevs[i],
+                                               &tmp_min,
+                                               &tmp_max, state);
+               if (ret < 0)
+                       return ret;
+
+               if (tmp_min == 0) {
+                       ret = regulator_get_voltage_rdev(c_rdevs[i]);
+                       if (ret < 0)
+                               return ret;
+                       tmp_min = ret;
+               }
+
+               /* apply constraints */
+               ret = regulator_check_voltage(c_rdevs[i], &tmp_min, &tmp_max);
+               if (ret < 0)
+                       return ret;
+
+               highest_min_uV = max(highest_min_uV, tmp_min);
+
+               if (i == 0) {
+                       desired_min_uV = tmp_min;
+                       desired_max_uV = tmp_max;
+               }
+       }
+
+       max_spread = constraints->max_spread[0];
+
+       /*
+        * Let target_uV be equal to the desired one if possible.
+        * If not, set it to minimum voltage, allowed by other coupled
+        * regulators.
+        */
+       target_uV = max(desired_min_uV, highest_min_uV - max_spread);
+
+       /*
+        * Find min and max voltages, which currently aren't violating
+        * max_spread.
+        */
+       for (i = 1; i < n_coupled; i++) {
+               int tmp_act;
+
+               tmp_act = regulator_get_voltage_rdev(c_rdevs[i]);
+               if (tmp_act < 0)
+                       return tmp_act;
+
+               min_current_uV = min(tmp_act, min_current_uV);
+               max_current_uV = max(tmp_act, max_current_uV);
+       }
+
+       /*
+        * Correct target voltage, so as it currently isn't
+        * violating max_spread
+        */
+       possible_uV = max(target_uV, max_current_uV - max_spread);
+       possible_uV = min(possible_uV, min_current_uV + max_spread);
+
+       if (possible_uV > desired_max_uV)
+               return -EINVAL;
+
+       done = (possible_uV == target_uV);
+       desired_min_uV = possible_uV;
+
+       /* Set current_uV if wasn't done earlier in the code and if necessary */
+       if (*current_uV == -1) {
+               ret = regulator_get_voltage_rdev(rdev);
+               if (ret < 0)
+                       return ret;
+               *current_uV = ret;
+       }
+
+       *min_uV = desired_min_uV;
+       *max_uV = desired_max_uV;
+
+       return done;
+}
+
+static int exynos_coupler_balance_voltage(struct regulator_coupler *coupler,
+                                         struct regulator_dev *rdev,
+                                         suspend_state_t state)
+{
+       struct regulator_dev **c_rdevs;
+       struct regulator_dev *best_rdev;
+       struct coupling_desc *c_desc = &rdev->coupling_desc;
+       int i, ret, n_coupled, best_min_uV, best_max_uV, best_c_rdev;
+       unsigned int delta, best_delta;
+       unsigned long c_rdev_done = 0;
+       bool best_c_rdev_done;
+
+       c_rdevs = c_desc->coupled_rdevs;
+       n_coupled = c_desc->n_coupled;
+
+       /*
+        * Find the best possible voltage change on each loop. Leave the loop
+        * if there isn't any possible change.
+        */
+       do {
+               best_c_rdev_done = false;
+               best_delta = 0;
+               best_min_uV = 0;
+               best_max_uV = 0;
+               best_c_rdev = 0;
+               best_rdev = NULL;
+
+               /*
+                * Find highest difference between optimal voltage
+                * and current voltage.
+                */
+               for (i = 0; i < n_coupled; i++) {
+                       /*
+                        * optimal_uV is the best voltage that can be set for
+                        * i-th regulator at the moment without violating
+                        * max_spread constraint in order to balance
+                        * the coupled voltages.
+                        */
+                       int optimal_uV = 0, optimal_max_uV = 0, current_uV = 0;
+
+                       if (test_bit(i, &c_rdev_done))
+                               continue;
+
+                       ret = regulator_get_optimal_voltage(c_rdevs[i],
+                                                           &current_uV,
+                                                           &optimal_uV,
+                                                           &optimal_max_uV,
+                                                           state);
+                       if (ret < 0)
+                               goto out;
+
+                       delta = abs(optimal_uV - current_uV);
+
+                       if (delta && best_delta <= delta) {
+                               best_c_rdev_done = ret;
+                               best_delta = delta;
+                               best_rdev = c_rdevs[i];
+                               best_min_uV = optimal_uV;
+                               best_max_uV = optimal_max_uV;
+                               best_c_rdev = i;
+                       }
+               }
+
+               /* Nothing to change, return successfully */
+               if (!best_rdev) {
+                       ret = 0;
+                       goto out;
+               }
+
+               ret = regulator_set_voltage_rdev(best_rdev, best_min_uV,
+                                                best_max_uV, state);
+
+               if (ret < 0)
+                       goto out;
+
+               if (best_c_rdev_done)
+                       set_bit(best_c_rdev, &c_rdev_done);
+
+       } while (n_coupled > 1);
+
+out:
+       return ret;
+}
+
+static int exynos_coupler_attach(struct regulator_coupler *coupler,
+                                struct regulator_dev *rdev)
+{
+       return 0;
+}
+
+static struct regulator_coupler exynos_coupler = {
+       .attach_regulator = exynos_coupler_attach,
+       .balance_voltage  = exynos_coupler_balance_voltage,
+};
+
+static int __init exynos_coupler_init(void)
+{
+       if (!of_machine_is_compatible("samsung,exynos5800"))
+               return 0;
+
+       return regulator_coupler_register(&exynos_coupler);
+}
+arch_initcall(exynos_coupler_init);