LXR linux/drivers/soc/tegra/regulators-tegra20.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Voltage regulators coupler for NVIDIA Tegra20
   4 * Copyright (C) 2019 GRATE-DRIVER project
   5 *
   6 * Voltage constraints borrowed from downstream kernel sources
   7 * Copyright (C) 2010-2011 NVIDIA Corporation
   8 */
   9
  10#define pr_fmt(fmt)     "tegra voltage-coupler: " fmt
  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
  19struct tegra_regulator_coupler {
  20        struct regulator_coupler coupler;
  21        struct regulator_dev *core_rdev;
  22        struct regulator_dev *cpu_rdev;
  23        struct regulator_dev *rtc_rdev;
  24        int core_min_uV;
  25};
  26
  27static inline struct tegra_regulator_coupler *
  28to_tegra_coupler(struct regulator_coupler *coupler)
  29{
  30        return container_of(coupler, struct tegra_regulator_coupler, coupler);
  31}
  32
  33static int tegra20_core_limit(struct tegra_regulator_coupler *tegra,
  34                              struct regulator_dev *core_rdev)
  35{
  36        int core_min_uV = 0;
  37        int core_max_uV;
  38        int core_cur_uV;
  39        int err;
  40
  41        if (tegra->core_min_uV > 0)
  42                return tegra->core_min_uV;
  43
  44        core_cur_uV = regulator_get_voltage_rdev(core_rdev);
  45        if (core_cur_uV < 0)
  46                return core_cur_uV;
  47
  48        core_max_uV = max(core_cur_uV, 1200000);
  49
  50        err = regulator_check_voltage(core_rdev, &core_min_uV, &core_max_uV);
  51        if (err)
  52                return err;
  53
  54        /*
  55         * Limit minimum CORE voltage to a value left from bootloader or,
  56         * if it's unreasonably low value, to the most common 1.2v or to
  57         * whatever maximum value defined via board's device-tree.
  58         */
  59        tegra->core_min_uV = core_max_uV;
  60
  61        pr_info("core minimum voltage limited to %duV\n", tegra->core_min_uV);
  62
  63        return tegra->core_min_uV;
  64}
  65
  66static int tegra20_core_rtc_max_spread(struct regulator_dev *core_rdev,
  67                                       struct regulator_dev *rtc_rdev)
  68{
  69        struct coupling_desc *c_desc = &core_rdev->coupling_desc;
  70        struct regulator_dev *rdev;
  71        int max_spread;
  72        unsigned int i;
  73
  74        for (i = 1; i < c_desc->n_coupled; i++) {
  75                max_spread = core_rdev->constraints->max_spread[i - 1];
  76                rdev = c_desc->coupled_rdevs[i];
  77
  78                if (rdev == rtc_rdev && max_spread)
  79                        return max_spread;
  80        }
  81
  82        pr_err_once("rtc-core max-spread is undefined in device-tree\n");
  83
  84        return 150000;
  85}
  86
  87static int tegra20_core_rtc_update(struct tegra_regulator_coupler *tegra,
  88                                   struct regulator_dev *core_rdev,
  89                                   struct regulator_dev *rtc_rdev,
  90                                   int cpu_uV, int cpu_min_uV)
  91{
  92        int core_min_uV, core_max_uV = INT_MAX;
  93        int rtc_min_uV, rtc_max_uV = INT_MAX;
  94        int core_target_uV;
  95        int rtc_target_uV;
  96        int max_spread;
  97        int core_uV;
  98        int rtc_uV;
  99        int err;
 100
 101        /*
 102         * RTC and CORE voltages should be no more than 170mV from each other,
 103         * CPU should be below RTC and CORE by at least 120mV. This applies
 104         * to all Tegra20 SoC's.
 105         */
 106        max_spread = tegra20_core_rtc_max_spread(core_rdev, rtc_rdev);
 107
 108        /*
 109         * The core voltage scaling is currently not hooked up in drivers,
 110         * hence we will limit the minimum core voltage to a reasonable value.
 111         * This should be good enough for the time being.
 112         */
 113        core_min_uV = tegra20_core_limit(tegra, core_rdev);
 114        if (core_min_uV < 0)
 115                return core_min_uV;
 116
 117        err = regulator_check_voltage(core_rdev, &core_min_uV, &core_max_uV);
 118        if (err)
 119                return err;
 120
 121        err = regulator_check_consumers(core_rdev, &core_min_uV, &core_max_uV,
 122                                        PM_SUSPEND_ON);
 123        if (err)
 124                return err;
 125
 126        core_uV = regulator_get_voltage_rdev(core_rdev);
 127        if (core_uV < 0)
 128                return core_uV;
 129
 130        core_min_uV = max(cpu_min_uV + 125000, core_min_uV);
 131        if (core_min_uV > core_max_uV)
 132                return -EINVAL;
 133
 134        if (cpu_uV + 120000 > core_uV)
 135                pr_err("core-cpu voltage constraint violated: %d %d\n",
 136                       core_uV, cpu_uV + 120000);
 137
 138        rtc_uV = regulator_get_voltage_rdev(rtc_rdev);
 139        if (rtc_uV < 0)
 140                return rtc_uV;
 141
 142        if (cpu_uV + 120000 > rtc_uV)
 143                pr_err("rtc-cpu voltage constraint violated: %d %d\n",
 144                       rtc_uV, cpu_uV + 120000);
 145
 146        if (abs(core_uV - rtc_uV) > 170000)
 147                pr_err("core-rtc voltage constraint violated: %d %d\n",
 148                       core_uV, rtc_uV);
 149
 150        rtc_min_uV = max(cpu_min_uV + 125000, core_min_uV - max_spread);
 151
 152        err = regulator_check_voltage(rtc_rdev, &rtc_min_uV, &rtc_max_uV);
 153        if (err)
 154                return err;
 155
 156        while (core_uV != core_min_uV || rtc_uV != rtc_min_uV) {
 157                if (core_uV < core_min_uV) {
 158                        core_target_uV = min(core_uV + max_spread, core_min_uV);
 159                        core_target_uV = min(rtc_uV + max_spread, core_target_uV);
 160                } else {
 161                        core_target_uV = max(core_uV - max_spread, core_min_uV);
 162                        core_target_uV = max(rtc_uV - max_spread, core_target_uV);
 163                }
 164
 165                if (core_uV == core_target_uV)
 166                        goto update_rtc;
 167
 168                err = regulator_set_voltage_rdev(core_rdev,
 169                                                 core_target_uV,
 170                                                 core_max_uV,
 171                                                 PM_SUSPEND_ON);
 172                if (err)
 173                        return err;
 174
 175                core_uV = core_target_uV;
 176update_rtc:
 177                if (rtc_uV < rtc_min_uV) {
 178                        rtc_target_uV = min(rtc_uV + max_spread, rtc_min_uV);
 179                        rtc_target_uV = min(core_uV + max_spread, rtc_target_uV);
 180                } else {
 181                        rtc_target_uV = max(rtc_uV - max_spread, rtc_min_uV);
 182                        rtc_target_uV = max(core_uV - max_spread, rtc_target_uV);
 183                }
 184
 185                if (rtc_uV == rtc_target_uV)
 186                        continue;
 187
 188                err = regulator_set_voltage_rdev(rtc_rdev,
 189                                                 rtc_target_uV,
 190                                                 rtc_max_uV,
 191                                                 PM_SUSPEND_ON);
 192                if (err)
 193                        return err;
 194
 195                rtc_uV = rtc_target_uV;
 196        }
 197
 198        return 0;
 199}
 200
 201static int tegra20_core_voltage_update(struct tegra_regulator_coupler *tegra,
 202                                       struct regulator_dev *cpu_rdev,
 203                                       struct regulator_dev *core_rdev,
 204                                       struct regulator_dev *rtc_rdev)
 205{
 206        int cpu_uV;
 207
 208        cpu_uV = regulator_get_voltage_rdev(cpu_rdev);
 209        if (cpu_uV < 0)
 210                return cpu_uV;
 211
 212        return tegra20_core_rtc_update(tegra, core_rdev, rtc_rdev,
 213                                       cpu_uV, cpu_uV);
 214}
 215
 216static int tegra20_cpu_voltage_update(struct tegra_regulator_coupler *tegra,
 217                                      struct regulator_dev *cpu_rdev,
 218                                      struct regulator_dev *core_rdev,
 219                                      struct regulator_dev *rtc_rdev)
 220{
 221        int cpu_min_uV_consumers = 0;
 222        int cpu_max_uV = INT_MAX;
 223        int cpu_min_uV = 0;
 224        int cpu_uV;
 225        int err;
 226
 227        err = regulator_check_voltage(cpu_rdev, &cpu_min_uV, &cpu_max_uV);
 228        if (err)
 229                return err;
 230
 231        err = regulator_check_consumers(cpu_rdev, &cpu_min_uV, &cpu_max_uV,
 232                                        PM_SUSPEND_ON);
 233        if (err)
 234                return err;
 235
 236        err = regulator_check_consumers(cpu_rdev, &cpu_min_uV_consumers,
 237                                        &cpu_max_uV, PM_SUSPEND_ON);
 238        if (err)
 239                return err;
 240
 241        cpu_uV = regulator_get_voltage_rdev(cpu_rdev);
 242        if (cpu_uV < 0)
 243                return cpu_uV;
 244
 245        /*
 246         * CPU's regulator may not have any consumers, hence the voltage
 247         * must not be changed in that case because CPU simply won't
 248         * survive the voltage drop if it's running on a higher frequency.
 249         */
 250        if (!cpu_min_uV_consumers)
 251                cpu_min_uV = cpu_uV;
 252
 253        if (cpu_min_uV > cpu_uV) {
 254                err = tegra20_core_rtc_update(tegra, core_rdev, rtc_rdev,
 255                                              cpu_uV, cpu_min_uV);
 256                if (err)
 257                        return err;
 258
 259                err = regulator_set_voltage_rdev(cpu_rdev, cpu_min_uV,
 260                                                 cpu_max_uV, PM_SUSPEND_ON);
 261                if (err)
 262                        return err;
 263        } else if (cpu_min_uV < cpu_uV)  {
 264                err = regulator_set_voltage_rdev(cpu_rdev, cpu_min_uV,
 265                                                 cpu_max_uV, PM_SUSPEND_ON);
 266                if (err)
 267                        return err;
 268
 269                err = tegra20_core_rtc_update(tegra, core_rdev, rtc_rdev,
 270                                              cpu_uV, cpu_min_uV);
 271                if (err)
 272                        return err;
 273        }
 274
 275        return 0;
 276}
 277
 278static int tegra20_regulator_balance_voltage(struct regulator_coupler *coupler,
 279                                             struct regulator_dev *rdev,
 280                                             suspend_state_t state)
 281{
 282        struct tegra_regulator_coupler *tegra = to_tegra_coupler(coupler);
 283        struct regulator_dev *core_rdev = tegra->core_rdev;
 284        struct regulator_dev *cpu_rdev = tegra->cpu_rdev;
 285        struct regulator_dev *rtc_rdev = tegra->rtc_rdev;
 286
 287        if ((core_rdev != rdev && cpu_rdev != rdev && rtc_rdev != rdev) ||
 288            state != PM_SUSPEND_ON) {
 289                pr_err("regulators are not coupled properly\n");
 290                return -EINVAL;
 291        }
 292
 293        if (rdev == cpu_rdev)
 294                return tegra20_cpu_voltage_update(tegra, cpu_rdev,
 295                                                  core_rdev, rtc_rdev);
 296
 297        if (rdev == core_rdev)
 298                return tegra20_core_voltage_update(tegra, cpu_rdev,
 299                                                   core_rdev, rtc_rdev);
 300
 301        pr_err("changing %s voltage not permitted\n", rdev_get_name(rtc_rdev));
 302
 303        return -EPERM;
 304}
 305
 306static int tegra20_regulator_attach(struct regulator_coupler *coupler,
 307                                    struct regulator_dev *rdev)
 308{
 309        struct tegra_regulator_coupler *tegra = to_tegra_coupler(coupler);
 310        struct device_node *np = rdev->dev.of_node;
 311
 312        if (of_property_read_bool(np, "nvidia,tegra-core-regulator") &&
 313            !tegra->core_rdev) {
 314                tegra->core_rdev = rdev;
 315                return 0;
 316        }
 317
 318        if (of_property_read_bool(np, "nvidia,tegra-rtc-regulator") &&
 319            !tegra->rtc_rdev) {
 320                tegra->rtc_rdev = rdev;
 321                return 0;
 322        }
 323
 324        if (of_property_read_bool(np, "nvidia,tegra-cpu-regulator") &&
 325            !tegra->cpu_rdev) {
 326                tegra->cpu_rdev = rdev;
 327                return 0;
 328        }
 329
 330        return -EINVAL;
 331}
 332
 333static int tegra20_regulator_detach(struct regulator_coupler *coupler,
 334                                    struct regulator_dev *rdev)
 335{
 336        struct tegra_regulator_coupler *tegra = to_tegra_coupler(coupler);
 337
 338        if (tegra->core_rdev == rdev) {
 339                tegra->core_rdev = NULL;
 340                return 0;
 341        }
 342
 343        if (tegra->rtc_rdev == rdev) {
 344                tegra->rtc_rdev = NULL;
 345                return 0;
 346        }
 347
 348        if (tegra->cpu_rdev == rdev) {
 349                tegra->cpu_rdev = NULL;
 350                return 0;
 351        }
 352
 353        return -EINVAL;
 354}
 355
 356static struct tegra_regulator_coupler tegra20_coupler = {
 357        .coupler = {
 358                .attach_regulator = tegra20_regulator_attach,
 359                .detach_regulator = tegra20_regulator_detach,
 360                .balance_voltage = tegra20_regulator_balance_voltage,
 361        },
 362};
 363
 364static int __init tegra_regulator_coupler_init(void)
 365{
 366        if (!of_machine_is_compatible("nvidia,tegra20"))
 367                return 0;
 368
 369        return regulator_coupler_register(&tegra20_coupler.coupler);
 370}
 371arch_initcall(tegra_regulator_coupler_init);
 372