drivers/regulator/vctrl-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for voltage controller regulators
   4  *
   5  * Copyright (C) 2017 Google, Inc.
   6  */
   7
   8 #include <linux/delay.h>
   9 #include <linux/err.h>
  10 #include <linux/init.h>
  11 #include <linux/module.h>
  12 #include <linux/of.h>
  13 #include <linux/of_device.h>
  14 #include <linux/regulator/coupler.h>
  15 #include <linux/regulator/driver.h>
  16 #include <linux/regulator/of_regulator.h>
  17 #include <linux/sort.h>
  18
  19 #include "internal.h"
  20
  21 struct vctrl_voltage_range {
  22         int min_uV;
  23         int max_uV;
  24 };
  25
  26 struct vctrl_voltage_ranges {
  27         struct vctrl_voltage_range ctrl;
  28         struct vctrl_voltage_range out;
  29 };
  30
  31 struct vctrl_voltage_table {
  32         int ctrl;
  33         int out;
  34         int ovp_min_sel;
  35 };
  36
  37 struct vctrl_data {
  38         struct regulator_dev *rdev;
  39         struct regulator_desc desc;
  40         bool enabled;
  41         unsigned int min_slew_down_rate;
  42         unsigned int ovp_threshold;
  43         struct vctrl_voltage_ranges vrange;
  44         struct vctrl_voltage_table *vtable;
  45         unsigned int sel;
  46 };
  47
  48 static int vctrl_calc_ctrl_voltage(struct vctrl_data *vctrl, int out_uV)
  49 {
  50         struct vctrl_voltage_range *ctrl = &vctrl->vrange.ctrl;
  51         struct vctrl_voltage_range *out = &vctrl->vrange.out;
  52
  53         return ctrl->min_uV +
  54                 DIV_ROUND_CLOSEST_ULL((s64)(out_uV - out->min_uV) *
  55                                       (ctrl->max_uV - ctrl->min_uV),
  56                                       out->max_uV - out->min_uV);
  57 }
  58
  59 static int vctrl_calc_output_voltage(struct vctrl_data *vctrl, int ctrl_uV)
  60 {
  61         struct vctrl_voltage_range *ctrl = &vctrl->vrange.ctrl;
  62         struct vctrl_voltage_range *out = &vctrl->vrange.out;
  63
  64         if (ctrl_uV < 0) {
  65                 pr_err("vctrl: failed to get control voltage\n");
  66                 return ctrl_uV;
  67         }
  68
  69         if (ctrl_uV < ctrl->min_uV)
  70                 return out->min_uV;
  71
  72         if (ctrl_uV > ctrl->max_uV)
  73                 return out->max_uV;
  74
  75         return out->min_uV +
  76                 DIV_ROUND_CLOSEST_ULL((s64)(ctrl_uV - ctrl->min_uV) *
  77                                       (out->max_uV - out->min_uV),
  78                                       ctrl->max_uV - ctrl->min_uV);
  79 }
  80
  81 static int vctrl_get_voltage(struct regulator_dev *rdev)
  82 {
  83         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
  84         int ctrl_uV;
  85
  86         if (!rdev->supply)
  87                 return -EPROBE_DEFER;
  88
  89         ctrl_uV = regulator_get_voltage_rdev(rdev->supply->rdev);
  90
  91         return vctrl_calc_output_voltage(vctrl, ctrl_uV);
  92 }
  93
  94 static int vctrl_set_voltage(struct regulator_dev *rdev,
  95                              int req_min_uV, int req_max_uV,
  96                              unsigned int *selector)
  97 {
  98         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
  99         int orig_ctrl_uV;
 100         int uV;
 101         int ret;
 102
 103         if (!rdev->supply)
 104                 return -EPROBE_DEFER;
 105
 106         orig_ctrl_uV = regulator_get_voltage_rdev(rdev->supply->rdev);
 107         uV = vctrl_calc_output_voltage(vctrl, orig_ctrl_uV);
 108
 109         if (req_min_uV >= uV || !vctrl->ovp_threshold)
 110                 /* voltage rising or no OVP */
 111                 return regulator_set_voltage_rdev(rdev->supply->rdev,
 112                         vctrl_calc_ctrl_voltage(vctrl, req_min_uV),
 113                         vctrl_calc_ctrl_voltage(vctrl, req_max_uV),
 114                         PM_SUSPEND_ON);
 115
 116         while (uV > req_min_uV) {
 117                 int max_drop_uV = (uV * vctrl->ovp_threshold) / 100;
 118                 int next_uV;
 119                 int next_ctrl_uV;
 120                 int delay;
 121
 122                 /* Make sure no infinite loop even in crazy cases */
 123                 if (max_drop_uV == 0)
 124                         max_drop_uV = 1;
 125
 126                 next_uV = max_t(int, req_min_uV, uV - max_drop_uV);
 127                 next_ctrl_uV = vctrl_calc_ctrl_voltage(vctrl, next_uV);
 128
 129                 ret = regulator_set_voltage_rdev(rdev->supply->rdev,
 130                                             next_ctrl_uV,
 131                                             next_ctrl_uV,
 132                                             PM_SUSPEND_ON);
 133                 if (ret)
 134                         goto err;
 135
 136                 delay = DIV_ROUND_UP(uV - next_uV, vctrl->min_slew_down_rate);
 137                 usleep_range(delay, delay + DIV_ROUND_UP(delay, 10));
 138
 139                 uV = next_uV;
 140         }
 141
 142         return 0;
 143
 144 err:
 145         /* Try to go back to original voltage */
 146         regulator_set_voltage_rdev(rdev->supply->rdev, orig_ctrl_uV, orig_ctrl_uV,
 147                                    PM_SUSPEND_ON);
 148
 149         return ret;
 150 }
 151
 152 static int vctrl_get_voltage_sel(struct regulator_dev *rdev)
 153 {
 154         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
 155
 156         return vctrl->sel;
 157 }
 158
 159 static int vctrl_set_voltage_sel(struct regulator_dev *rdev,
 160                                  unsigned int selector)
 161 {
 162         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
 163         unsigned int orig_sel = vctrl->sel;
 164         int ret;
 165
 166         if (!rdev->supply)
 167                 return -EPROBE_DEFER;
 168
 169         if (selector >= rdev->desc->n_voltages)
 170                 return -EINVAL;
 171
 172         if (selector >= vctrl->sel || !vctrl->ovp_threshold) {
 173                 /* voltage rising or no OVP */
 174                 ret = regulator_set_voltage_rdev(rdev->supply->rdev,
 175                                             vctrl->vtable[selector].ctrl,
 176                                             vctrl->vtable[selector].ctrl,
 177                                             PM_SUSPEND_ON);
 178                 if (!ret)
 179                         vctrl->sel = selector;
 180
 181                 return ret;
 182         }
 183
 184         while (vctrl->sel != selector) {
 185                 unsigned int next_sel;
 186                 int delay;
 187
 188                 if (selector >= vctrl->vtable[vctrl->sel].ovp_min_sel)
 189                         next_sel = selector;
 190                 else
 191                         next_sel = vctrl->vtable[vctrl->sel].ovp_min_sel;
 192
 193                 ret = regulator_set_voltage_rdev(rdev->supply->rdev,
 194                                             vctrl->vtable[next_sel].ctrl,
 195                                             vctrl->vtable[next_sel].ctrl,
 196                                             PM_SUSPEND_ON);
 197                 if (ret) {
 198                         dev_err(&rdev->dev,
 199                                 "failed to set control voltage to %duV\n",
 200                                 vctrl->vtable[next_sel].ctrl);
 201                         goto err;
 202                 }
 203                 vctrl->sel = next_sel;
 204
 205                 delay = DIV_ROUND_UP(vctrl->vtable[vctrl->sel].out -
 206                                      vctrl->vtable[next_sel].out,
 207                                      vctrl->min_slew_down_rate);
 208                 usleep_range(delay, delay + DIV_ROUND_UP(delay, 10));
 209         }
 210
 211         return 0;
 212
 213 err:
 214         if (vctrl->sel != orig_sel) {
 215                 /* Try to go back to original voltage */
 216                 if (!regulator_set_voltage_rdev(rdev->supply->rdev,
 217                                            vctrl->vtable[orig_sel].ctrl,
 218                                            vctrl->vtable[orig_sel].ctrl,
 219                                            PM_SUSPEND_ON))
 220                         vctrl->sel = orig_sel;
 221                 else
 222                         dev_warn(&rdev->dev,
 223                                  "failed to restore original voltage\n");
 224         }
 225
 226         return ret;
 227 }
 228
 229 static int vctrl_list_voltage(struct regulator_dev *rdev,
 230                               unsigned int selector)
 231 {
 232         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
 233
 234         if (selector >= rdev->desc->n_voltages)
 235                 return -EINVAL;
 236
 237         return vctrl->vtable[selector].out;
 238 }
 239
 240 static int vctrl_parse_dt(struct platform_device *pdev,
 241                           struct vctrl_data *vctrl)
 242 {
 243         int ret;
 244         struct device_node *np = pdev->dev.of_node;
 245         u32 pval;
 246         u32 vrange_ctrl[2];
 247
 248         ret = of_property_read_u32(np, "ovp-threshold-percent", &pval);
 249         if (!ret) {
 250                 vctrl->ovp_threshold = pval;
 251                 if (vctrl->ovp_threshold > 100) {
 252                         dev_err(&pdev->dev,
 253                                 "ovp-threshold-percent (%u) > 100\n",
 254                                 vctrl->ovp_threshold);
 255                         return -EINVAL;
 256                 }
 257         }
 258
 259         ret = of_property_read_u32(np, "min-slew-down-rate", &pval);
 260         if (!ret) {
 261                 vctrl->min_slew_down_rate = pval;
 262
 263                 /* We use the value as int and as divider; sanity check */
 264                 if (vctrl->min_slew_down_rate == 0) {
 265                         dev_err(&pdev->dev,
 266                                 "min-slew-down-rate must not be 0\n");
 267                         return -EINVAL;
 268                 } else if (vctrl->min_slew_down_rate > INT_MAX) {
 269                         dev_err(&pdev->dev, "min-slew-down-rate (%u) too big\n",
 270                                 vctrl->min_slew_down_rate);
 271                         return -EINVAL;
 272                 }
 273         }
 274
 275         if (vctrl->ovp_threshold && !vctrl->min_slew_down_rate) {
 276                 dev_err(&pdev->dev,
 277                         "ovp-threshold-percent requires min-slew-down-rate\n");
 278                 return -EINVAL;
 279         }
 280
 281         ret = of_property_read_u32(np, "regulator-min-microvolt", &pval);
 282         if (ret) {
 283                 dev_err(&pdev->dev,
 284                         "failed to read regulator-min-microvolt: %d\n", ret);
 285                 return ret;
 286         }
 287         vctrl->vrange.out.min_uV = pval;
 288
 289         ret = of_property_read_u32(np, "regulator-max-microvolt", &pval);
 290         if (ret) {
 291                 dev_err(&pdev->dev,
 292                         "failed to read regulator-max-microvolt: %d\n", ret);
 293                 return ret;
 294         }
 295         vctrl->vrange.out.max_uV = pval;
 296
 297         ret = of_property_read_u32_array(np, "ctrl-voltage-range", vrange_ctrl,
 298                                          2);
 299         if (ret) {
 300                 dev_err(&pdev->dev, "failed to read ctrl-voltage-range: %d\n",
 301                         ret);
 302                 return ret;
 303         }
 304
 305         if (vrange_ctrl[0] >= vrange_ctrl[1]) {
 306                 dev_err(&pdev->dev, "ctrl-voltage-range is invalid: %d-%d\n",
 307                         vrange_ctrl[0], vrange_ctrl[1]);
 308                 return -EINVAL;
 309         }
 310
 311         vctrl->vrange.ctrl.min_uV = vrange_ctrl[0];
 312         vctrl->vrange.ctrl.max_uV = vrange_ctrl[1];
 313
 314         return 0;
 315 }
 316
 317 static int vctrl_cmp_ctrl_uV(const void *a, const void *b)
 318 {
 319         const struct vctrl_voltage_table *at = a;
 320         const struct vctrl_voltage_table *bt = b;
 321
 322         return at->ctrl - bt->ctrl;
 323 }
 324
 325 static int vctrl_init_vtable(struct platform_device *pdev,
 326                              struct regulator *ctrl_reg)
 327 {
 328         struct vctrl_data *vctrl = platform_get_drvdata(pdev);
 329         struct regulator_desc *rdesc = &vctrl->desc;
 330         struct vctrl_voltage_range *vrange_ctrl = &vctrl->vrange.ctrl;
 331         int n_voltages;
 332         int ctrl_uV;
 333         int i, idx_vt;
 334
 335         n_voltages = regulator_count_voltages(ctrl_reg);
 336
 337         rdesc->n_voltages = n_voltages;
 338
 339         /* determine number of steps within the range of the vctrl regulator */
 340         for (i = 0; i < n_voltages; i++) {
 341                 ctrl_uV = regulator_list_voltage(ctrl_reg, i);
 342
 343                 if (ctrl_uV < vrange_ctrl->min_uV ||
 344                     ctrl_uV > vrange_ctrl->max_uV)
 345                         rdesc->n_voltages--;
 346         }
 347
 348         if (rdesc->n_voltages == 0) {
 349                 dev_err(&pdev->dev, "invalid configuration\n");
 350                 return -EINVAL;
 351         }
 352
 353         vctrl->vtable = devm_kcalloc(&pdev->dev, rdesc->n_voltages,
 354                                      sizeof(struct vctrl_voltage_table),
 355                                      GFP_KERNEL);
 356         if (!vctrl->vtable)
 357                 return -ENOMEM;
 358
 359         /* create mapping control <=> output voltage */
 360         for (i = 0, idx_vt = 0; i < n_voltages; i++) {
 361                 ctrl_uV = regulator_list_voltage(ctrl_reg, i);
 362
 363                 if (ctrl_uV < vrange_ctrl->min_uV ||
 364                     ctrl_uV > vrange_ctrl->max_uV)
 365                         continue;
 366
 367                 vctrl->vtable[idx_vt].ctrl = ctrl_uV;
 368                 vctrl->vtable[idx_vt].out =
 369                         vctrl_calc_output_voltage(vctrl, ctrl_uV);
 370                 idx_vt++;
 371         }
 372
 373         /* we rely on the table to be ordered by ascending voltage */
 374         sort(vctrl->vtable, rdesc->n_voltages,
 375              sizeof(struct vctrl_voltage_table), vctrl_cmp_ctrl_uV,
 376              NULL);
 377
 378         /* pre-calculate OVP-safe downward transitions */
 379         for (i = rdesc->n_voltages - 1; i > 0; i--) {
 380                 int j;
 381                 int ovp_min_uV = (vctrl->vtable[i].out *
 382                                   (100 - vctrl->ovp_threshold)) / 100;
 383
 384                 for (j = 0; j < i; j++) {
 385                         if (vctrl->vtable[j].out >= ovp_min_uV) {
 386                                 vctrl->vtable[i].ovp_min_sel = j;
 387                                 break;
 388                         }
 389                 }
 390
 391                 if (j == i) {
 392                         dev_warn(&pdev->dev, "switching down from %duV may cause OVP shutdown\n",
 393                                 vctrl->vtable[i].out);
 394                         /* use next lowest voltage */
 395                         vctrl->vtable[i].ovp_min_sel = i - 1;
 396                 }
 397         }
 398
 399         return 0;
 400 }
 401
 402 static int vctrl_enable(struct regulator_dev *rdev)
 403 {
 404         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
 405
 406         vctrl->enabled = true;
 407
 408         return 0;
 409 }
 410
 411 static int vctrl_disable(struct regulator_dev *rdev)
 412 {
 413         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
 414
 415         vctrl->enabled = false;
 416
 417         return 0;
 418 }
 419
 420 static int vctrl_is_enabled(struct regulator_dev *rdev)
 421 {
 422         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
 423
 424         return vctrl->enabled;
 425 }
 426
 427 static const struct regulator_ops vctrl_ops_cont = {
 428         .enable           = vctrl_enable,
 429         .disable          = vctrl_disable,
 430         .is_enabled       = vctrl_is_enabled,
 431         .get_voltage      = vctrl_get_voltage,
 432         .set_voltage      = vctrl_set_voltage,
 433 };
 434
 435 static const struct regulator_ops vctrl_ops_non_cont = {
 436         .enable           = vctrl_enable,
 437         .disable          = vctrl_disable,
 438         .is_enabled       = vctrl_is_enabled,
 439         .set_voltage_sel = vctrl_set_voltage_sel,
 440         .get_voltage_sel = vctrl_get_voltage_sel,
 441         .list_voltage    = vctrl_list_voltage,
 442         .map_voltage     = regulator_map_voltage_iterate,
 443 };
 444
 445 static int vctrl_probe(struct platform_device *pdev)
 446 {
 447         struct device_node *np = pdev->dev.of_node;
 448         struct vctrl_data *vctrl;
 449         const struct regulator_init_data *init_data;
 450         struct regulator_desc *rdesc;
 451         struct regulator_config cfg = { };
 452         struct vctrl_voltage_range *vrange_ctrl;
 453         struct regulator *ctrl_reg;
 454         int ctrl_uV;
 455         int ret;
 456
 457         vctrl = devm_kzalloc(&pdev->dev, sizeof(struct vctrl_data),
 458                              GFP_KERNEL);
 459         if (!vctrl)
 460                 return -ENOMEM;
 461
 462         platform_set_drvdata(pdev, vctrl);
 463
 464         ret = vctrl_parse_dt(pdev, vctrl);
 465         if (ret)
 466                 return ret;
 467
 468         ctrl_reg = devm_regulator_get(&pdev->dev, "ctrl");
 469         if (IS_ERR(ctrl_reg))
 470                 return PTR_ERR(ctrl_reg);
 471
 472         vrange_ctrl = &vctrl->vrange.ctrl;
 473
 474         rdesc = &vctrl->desc;
 475         rdesc->name = "vctrl";
 476         rdesc->type = REGULATOR_VOLTAGE;
 477         rdesc->owner = THIS_MODULE;
 478         rdesc->supply_name = "ctrl";
 479
 480         if ((regulator_get_linear_step(ctrl_reg) == 1) ||
 481             (regulator_count_voltages(ctrl_reg) == -EINVAL)) {
 482                 rdesc->continuous_voltage_range = true;
 483                 rdesc->ops = &vctrl_ops_cont;
 484         } else {
 485                 rdesc->ops = &vctrl_ops_non_cont;
 486         }
 487
 488         init_data = of_get_regulator_init_data(&pdev->dev, np, rdesc);
 489         if (!init_data)
 490                 return -ENOMEM;
 491
 492         cfg.of_node = np;
 493         cfg.dev = &pdev->dev;
 494         cfg.driver_data = vctrl;
 495         cfg.init_data = init_data;
 496
 497         if (!rdesc->continuous_voltage_range) {
 498                 ret = vctrl_init_vtable(pdev, ctrl_reg);
 499                 if (ret)
 500                         return ret;
 501
 502                 /* Use locked consumer API when not in regulator framework */
 503                 ctrl_uV = regulator_get_voltage(ctrl_reg);
 504                 if (ctrl_uV < 0) {
 505                         dev_err(&pdev->dev, "failed to get control voltage\n");
 506                         return ctrl_uV;
 507                 }
 508
 509                 /* determine current voltage selector from control voltage */
 510                 if (ctrl_uV < vrange_ctrl->min_uV) {
 511                         vctrl->sel = 0;
 512                 } else if (ctrl_uV > vrange_ctrl->max_uV) {
 513                         vctrl->sel = rdesc->n_voltages - 1;
 514                 } else {
 515                         int i;
 516
 517                         for (i = 0; i < rdesc->n_voltages; i++) {
 518                                 if (ctrl_uV == vctrl->vtable[i].ctrl) {
 519                                         vctrl->sel = i;
 520                                         break;
 521                                 }
 522                         }
 523                 }
 524         }
 525
 526         /* Drop ctrl-supply here in favor of regulator core managed supply */
 527         devm_regulator_put(ctrl_reg);
 528
 529         vctrl->rdev = devm_regulator_register(&pdev->dev, rdesc, &cfg);
 530         if (IS_ERR(vctrl->rdev)) {
 531                 ret = PTR_ERR(vctrl->rdev);
 532                 dev_err(&pdev->dev, "failed to register regulator: %d\n", ret);
 533                 return ret;
 534         }
 535
 536         return 0;
 537 }
 538
 539 static const struct of_device_id vctrl_of_match[] = {
 540         { .compatible = "vctrl-regulator", },
 541         {},
 542 };
 543 MODULE_DEVICE_TABLE(of, vctrl_of_match);
 544
 545 static struct platform_driver vctrl_driver = {
 546         .probe          = vctrl_probe,
 547         .driver         = {
 548                 .name           = "vctrl-regulator",
 549                 .of_match_table = of_match_ptr(vctrl_of_match),
 550         },
 551 };
 552
 553 module_platform_driver(vctrl_driver);
 554
 555 MODULE_DESCRIPTION("Voltage Controlled Regulator Driver");
 556 MODULE_AUTHOR("Matthias Kaehlcke <[email protected]>");
 557 MODULE_LICENSE("GPL v2");