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 <mka@chromium.org>"); 557 MODULE_LICENSE("GPL v2"); 558