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