1 /* 2 * Copyright (C) 2014-2015 Samsung Electronics 3 * Przemyslaw Marczak <p.marczak@samsung.com> 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <errno.h> 10 #include <dm.h> 11 #include <dm/device-internal.h> 12 #include <dm/uclass-internal.h> 13 #include <power/pmic.h> 14 #include <power/regulator.h> 15 16 DECLARE_GLOBAL_DATA_PTR; 17 18 int regulator_mode(struct udevice *dev, struct dm_regulator_mode **modep) 19 { 20 struct dm_regulator_uclass_platdata *uc_pdata; 21 22 *modep = NULL; 23 24 uc_pdata = dev_get_uclass_platdata(dev); 25 if (!uc_pdata) 26 return -ENXIO; 27 28 *modep = uc_pdata->mode; 29 return uc_pdata->mode_count; 30 } 31 32 int regulator_get_value(struct udevice *dev) 33 { 34 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 35 36 if (!ops || !ops->get_value) 37 return -ENOSYS; 38 39 return ops->get_value(dev); 40 } 41 42 int regulator_set_value(struct udevice *dev, int uV) 43 { 44 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 45 struct dm_regulator_uclass_platdata *uc_pdata; 46 u32 old_uV = -ENODATA, us; 47 int ret; 48 49 uc_pdata = dev_get_uclass_platdata(dev); 50 if (uc_pdata->min_uV != -ENODATA && uV < uc_pdata->min_uV) 51 return -EINVAL; 52 if (uc_pdata->max_uV != -ENODATA && uV > uc_pdata->max_uV) 53 return -EINVAL; 54 55 if (!ops || !ops->set_value) 56 return -ENOSYS; 57 58 if (uc_pdata->ramp_delay != -ENODATA) { 59 if (!ops->get_value) 60 return -ENOSYS; 61 old_uV = ops->get_value(dev); 62 if (old_uV < 0) 63 return -EINVAL; 64 } 65 66 ret = ops->set_value(dev, uV); 67 68 if (!ret && (old_uV != -ENODATA) && (old_uV != uV)) { 69 us = DIV_ROUND_UP(abs(uV - old_uV), uc_pdata->ramp_delay); 70 udelay(us); 71 debug("%s: ramp=%d, old_uV=%d, uV=%d, us=%d\n", 72 uc_pdata->name, uc_pdata->ramp_delay, old_uV, uV, us); 73 } 74 75 return ret; 76 } 77 78 int regulator_set_suspend_value(struct udevice *dev, int uV) 79 { 80 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 81 82 if (!ops || !ops->set_suspend_value) 83 return -ENOSYS; 84 85 return ops->set_suspend_value(dev, uV); 86 } 87 88 int regulator_get_suspend_value(struct udevice *dev) 89 { 90 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 91 92 if (!ops || !ops->get_suspend_value) 93 return -ENOSYS; 94 95 return ops->get_suspend_value(dev); 96 } 97 98 /* 99 * To be called with at most caution as there is no check 100 * before setting the actual voltage value. 101 */ 102 int regulator_set_value_force(struct udevice *dev, int uV) 103 { 104 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 105 106 if (!ops || !ops->set_value) 107 return -ENOSYS; 108 109 return ops->set_value(dev, uV); 110 } 111 112 int regulator_get_current(struct udevice *dev) 113 { 114 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 115 116 if (!ops || !ops->get_current) 117 return -ENOSYS; 118 119 return ops->get_current(dev); 120 } 121 122 int regulator_set_current(struct udevice *dev, int uA) 123 { 124 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 125 struct dm_regulator_uclass_platdata *uc_pdata; 126 127 uc_pdata = dev_get_uclass_platdata(dev); 128 if (uc_pdata->min_uA != -ENODATA && uA < uc_pdata->min_uA) 129 return -EINVAL; 130 if (uc_pdata->max_uA != -ENODATA && uA > uc_pdata->max_uA) 131 return -EINVAL; 132 133 if (!ops || !ops->set_current) 134 return -ENOSYS; 135 136 return ops->set_current(dev, uA); 137 } 138 139 int regulator_get_enable(struct udevice *dev) 140 { 141 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 142 143 if (!ops || !ops->get_enable) 144 return -ENOSYS; 145 146 return ops->get_enable(dev); 147 } 148 149 int regulator_set_enable(struct udevice *dev, bool enable) 150 { 151 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 152 153 if (!ops || !ops->set_enable) 154 return -ENOSYS; 155 156 return ops->set_enable(dev, enable); 157 } 158 159 int regulator_set_suspend_enable(struct udevice *dev, bool enable) 160 { 161 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 162 163 if (!ops || !ops->set_suspend_enable) 164 return -ENOSYS; 165 166 return ops->set_suspend_enable(dev, enable); 167 } 168 169 int regulator_get_suspend_enable(struct udevice *dev) 170 { 171 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 172 173 if (!ops || !ops->get_suspend_enable) 174 return -ENOSYS; 175 176 return ops->get_suspend_enable(dev); 177 } 178 179 int regulator_set_ramp_delay(struct udevice *dev, u32 ramp_delay) 180 { 181 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 182 183 if (!ops || !ops->set_ramp_delay) 184 return -ENOSYS; 185 186 return ops->set_ramp_delay(dev, ramp_delay); 187 } 188 189 int regulator_get_mode(struct udevice *dev) 190 { 191 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 192 193 if (!ops || !ops->get_mode) 194 return -ENOSYS; 195 196 return ops->get_mode(dev); 197 } 198 199 int regulator_set_mode(struct udevice *dev, int mode) 200 { 201 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 202 203 if (!ops || !ops->set_mode) 204 return -ENOSYS; 205 206 return ops->set_mode(dev, mode); 207 } 208 209 int regulator_get_by_platname(const char *plat_name, struct udevice **devp) 210 { 211 struct dm_regulator_uclass_platdata *uc_pdata; 212 struct udevice *dev; 213 int ret; 214 215 *devp = NULL; 216 217 for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev; 218 ret = uclass_find_next_device(&dev)) { 219 if (ret) { 220 debug("regulator %s, ret=%d\n", dev->name, ret); 221 continue; 222 } 223 224 uc_pdata = dev_get_uclass_platdata(dev); 225 if (!uc_pdata || strcmp(plat_name, uc_pdata->name)) 226 continue; 227 228 return uclass_get_device_tail(dev, 0, devp); 229 } 230 231 debug("%s: can't find: %s, ret=%d\n", __func__, plat_name, ret); 232 233 return -ENODEV; 234 } 235 236 int regulator_get_by_devname(const char *devname, struct udevice **devp) 237 { 238 return uclass_get_device_by_name(UCLASS_REGULATOR, devname, devp); 239 } 240 241 int device_get_supply_regulator(struct udevice *dev, const char *supply_name, 242 struct udevice **devp) 243 { 244 return uclass_get_device_by_phandle(UCLASS_REGULATOR, dev, 245 supply_name, devp); 246 } 247 248 static int regulator_init_suspend(struct udevice *dev) 249 { 250 struct dm_regulator_uclass_platdata *uc_pdata; 251 int ret; 252 253 uc_pdata = dev_get_uclass_platdata(dev); 254 255 ret = regulator_set_suspend_enable(dev, uc_pdata->suspend_on); 256 if (!ret && uc_pdata->suspend_on) 257 return regulator_set_suspend_value(dev, uc_pdata->suspend_uV); 258 259 return 0; 260 } 261 262 int regulator_autoset(struct udevice *dev) 263 { 264 struct dm_regulator_uclass_platdata *uc_pdata; 265 int ret = 0; 266 267 uc_pdata = dev_get_uclass_platdata(dev); 268 269 if (uc_pdata->ignore) 270 return ret; 271 272 if (uc_pdata->ramp_delay != -ENODATA) 273 regulator_set_ramp_delay(dev, uc_pdata->ramp_delay); 274 275 if (!uc_pdata->always_on && !uc_pdata->boot_on) 276 return -EMEDIUMTYPE; 277 278 if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV) { 279 ret = regulator_set_value(dev, uc_pdata->min_uV); 280 } else { 281 if ((uc_pdata->type == REGULATOR_TYPE_BUCK) && 282 (uc_pdata->min_uV != -ENODATA) && 283 (uc_pdata->max_uV != -ENODATA) && 284 (uc_pdata->init_uV <= 0)) 285 printf("%s %d uV\n", 286 uc_pdata->name, regulator_get_value(dev)); 287 } 288 289 if (uc_pdata->init_uV > 0) { 290 ret = regulator_set_value(dev, uc_pdata->init_uV); 291 if (!ret) 292 printf("%s init %d uV\n", 293 uc_pdata->name, uc_pdata->init_uV); 294 } 295 296 if (!ret && (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA)) 297 ret = regulator_set_current(dev, uc_pdata->min_uA); 298 299 if (!ret) 300 ret = regulator_set_enable(dev, true); 301 302 return ret; 303 } 304 305 static void regulator_show(struct udevice *dev, int ret) 306 { 307 struct dm_regulator_uclass_platdata *uc_pdata; 308 int uV = 0; 309 310 uc_pdata = dev_get_uclass_platdata(dev); 311 uV = regulator_get_value(dev); 312 313 printf("%25s@%15s: ", dev->name, uc_pdata->name); 314 printf("%7duV <-> %7duV, set %7duV, %s", 315 uc_pdata->min_uV, uc_pdata->max_uV, uV, 316 (uc_pdata->always_on || uc_pdata->boot_on) ? 317 "enabling" : "disabled"); 318 319 printf(" | supsend %7duV, %s", 320 uc_pdata->suspend_uV, 321 uc_pdata->suspend_on ? "enabling" : "disabled"); 322 if (uc_pdata->init_uV != -ENODATA) 323 printf(" ; init %7duV", uc_pdata->init_uV); 324 325 if (ret) 326 printf(" (ret: %d)", ret); 327 328 printf("\n"); 329 } 330 331 int regulator_autoset_by_name(const char *platname, struct udevice **devp) 332 { 333 struct udevice *dev; 334 int ret; 335 336 ret = regulator_get_by_platname(platname, &dev); 337 if (devp) 338 *devp = dev; 339 if (ret) { 340 debug("Can get the regulator: %s (err=%d)\n", platname, ret); 341 return ret; 342 } 343 344 return regulator_autoset(dev); 345 } 346 347 int regulator_list_autoset(const char *list_platname[], 348 struct udevice *list_devp[], 349 bool verbose) 350 { 351 struct udevice *dev; 352 int error = 0, i = 0, ret; 353 354 while (list_platname[i]) { 355 ret = regulator_autoset_by_name(list_platname[i], &dev); 356 if (ret != -EMEDIUMTYPE && verbose) 357 regulator_show(dev, ret); 358 if (ret & !error) 359 error = ret; 360 361 if (list_devp) 362 list_devp[i] = dev; 363 364 i++; 365 } 366 367 return error; 368 } 369 370 static bool regulator_name_is_unique(struct udevice *check_dev, 371 const char *check_name) 372 { 373 struct dm_regulator_uclass_platdata *uc_pdata; 374 struct udevice *dev; 375 int check_len = strlen(check_name); 376 int ret; 377 int len; 378 379 for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev; 380 ret = uclass_find_next_device(&dev)) { 381 if (ret || dev == check_dev) 382 continue; 383 384 uc_pdata = dev_get_uclass_platdata(dev); 385 len = strlen(uc_pdata->name); 386 if (len != check_len) 387 continue; 388 389 if (!strcmp(uc_pdata->name, check_name)) 390 return false; 391 } 392 393 return true; 394 } 395 396 static int regulator_post_bind(struct udevice *dev) 397 { 398 struct dm_regulator_uclass_platdata *uc_pdata; 399 const char *property = "regulator-name"; 400 401 uc_pdata = dev_get_uclass_platdata(dev); 402 403 /* Regulator's mandatory constraint */ 404 uc_pdata->name = dev_read_string(dev, property); 405 if (!uc_pdata->name) { 406 debug("%s: dev '%s' has no property '%s'\n", 407 __func__, dev->name, property); 408 uc_pdata->name = dev_read_name(dev); 409 if (!uc_pdata->name) 410 return -EINVAL; 411 } 412 413 if (regulator_name_is_unique(dev, uc_pdata->name)) 414 return 0; 415 416 #ifdef CONFIG_USING_KERNEL_DTB 417 printf("Pre-reloc: %s\n", uc_pdata->name); 418 419 return 0; 420 #else 421 debug("'%s' of dev: '%s', has nonunique value: '%s\n", 422 property, dev->name, uc_pdata->name); 423 424 return -EINVAL; 425 #endif 426 } 427 428 static int regulator_pre_probe(struct udevice *dev) 429 { 430 struct dm_regulator_uclass_platdata *uc_pdata; 431 ofnode node; 432 433 uc_pdata = dev_get_uclass_platdata(dev); 434 if (!uc_pdata) 435 return -ENXIO; 436 437 /* Regulator's optional constraints */ 438 uc_pdata->min_uV = dev_read_u32_default(dev, "regulator-min-microvolt", 439 -ENODATA); 440 uc_pdata->max_uV = dev_read_u32_default(dev, "regulator-max-microvolt", 441 -ENODATA); 442 uc_pdata->init_uV = dev_read_u32_default(dev, "regulator-init-microvolt", 443 -ENODATA); 444 uc_pdata->min_uA = dev_read_u32_default(dev, "regulator-min-microamp", 445 -ENODATA); 446 uc_pdata->max_uA = dev_read_u32_default(dev, "regulator-max-microamp", 447 -ENODATA); 448 uc_pdata->always_on = dev_read_bool(dev, "regulator-always-on"); 449 uc_pdata->boot_on = dev_read_bool(dev, "regulator-boot-on"); 450 uc_pdata->ignore = dev_read_bool(dev, "regulator-loader-ignore"); 451 uc_pdata->ramp_delay = dev_read_u32_default(dev, "regulator-ramp-delay", 452 -ENODATA); 453 node = dev_read_subnode(dev, "regulator-state-mem"); 454 if (ofnode_valid(node)) { 455 uc_pdata->suspend_on = !ofnode_read_bool(node, "regulator-off-in-suspend"); 456 if (ofnode_read_u32(node, "regulator-suspend-microvolt", &uc_pdata->suspend_uV)) 457 uc_pdata->suspend_uV = uc_pdata->max_uA; 458 } else { 459 uc_pdata->suspend_on = true; 460 uc_pdata->suspend_uV = uc_pdata->max_uA; 461 } 462 463 /* Those values are optional (-ENODATA if unset) */ 464 if ((uc_pdata->min_uV != -ENODATA) && 465 (uc_pdata->max_uV != -ENODATA) && 466 (uc_pdata->min_uV == uc_pdata->max_uV)) 467 uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UV; 468 469 /* Those values are optional (-ENODATA if unset) */ 470 if ((uc_pdata->min_uA != -ENODATA) && 471 (uc_pdata->max_uA != -ENODATA) && 472 (uc_pdata->min_uA == uc_pdata->max_uA)) 473 uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UA; 474 475 debug("dev.name=%s: min_uV=%d, max_uV=%d, boot-on=%d, always-on=%d, " 476 "off-in-suspend=%d, suspend_volt=%d\n", 477 dev->name, uc_pdata->min_uV, uc_pdata->max_uV, uc_pdata->boot_on, 478 uc_pdata->always_on, !uc_pdata->suspend_on, uc_pdata->suspend_uV); 479 480 return 0; 481 } 482 483 int regulators_enable_state_mem(bool verbose) 484 { 485 struct udevice *dev; 486 struct uclass *uc; 487 int ret; 488 489 ret = uclass_get(UCLASS_REGULATOR, &uc); 490 if (ret) 491 return ret; 492 for (uclass_first_device(UCLASS_REGULATOR, &dev); 493 dev; 494 uclass_next_device(&dev)) { 495 ret = regulator_init_suspend(dev); 496 497 if (ret == -EMEDIUMTYPE) 498 ret = 0; 499 if (verbose) 500 regulator_show(dev, ret); 501 if (ret == -ENOSYS) 502 ret = 0; 503 } 504 505 return ret; 506 } 507 508 #ifdef CONFIG_USING_KERNEL_DTB 509 /* 510 * Skip probed pre-reloc regulators. 511 * 512 * Some regulator like fixed/gpio regultor applies a default output state 513 * when probed. It maybe reverse the state which was set by the pre-reloc 514 * regulator. Example: vcc3v3_pcie. 515 */ 516 int regulators_enable_boot_on(bool verbose) 517 { 518 struct dm_regulator_uclass_platdata *uc_pdata; 519 struct udevice *dev; 520 struct uclass *uc; 521 char **pre_probed = NULL; 522 int i = 0, num = 0; 523 int ret; 524 bool skip; 525 526 ret = uclass_get(UCLASS_REGULATOR, &uc); 527 if (ret) 528 return ret; 529 530 /* find probed pre-reloc regulators */ 531 for (uclass_find_first_device(UCLASS_REGULATOR, &dev); 532 dev; 533 uclass_find_next_device(&dev)) { 534 if (!(dev->flags & DM_FLAG_KNRL_DTB) && 535 (dev->flags & DM_FLAG_ACTIVATED)) 536 num++; 537 } 538 if (num) { 539 pre_probed = calloc(num, sizeof(char *)); 540 if (!pre_probed) 541 return -ENOMEM; 542 543 for (uclass_find_first_device(UCLASS_REGULATOR, &dev); 544 dev; 545 uclass_find_next_device(&dev)) { 546 if (!(dev->flags & DM_FLAG_KNRL_DTB) && 547 (dev->flags & DM_FLAG_ACTIVATED)) { 548 uc_pdata = dev_get_uclass_platdata(dev); 549 pre_probed[i++] = (char *)uc_pdata->name; 550 } 551 } 552 } 553 554 /* Skip kernel regulators whose name matches probed pre-reloc regulators */ 555 for (uclass_find_first_device(UCLASS_REGULATOR, &dev); 556 dev; 557 uclass_find_next_device(&dev)) { 558 uc_pdata = dev_get_uclass_platdata(dev); 559 debug("%s: %s%s\n", __func__, uc_pdata->name, 560 dev->flags & DM_FLAG_KNRL_DTB ? "" : "*"); 561 if (dev->flags & DM_FLAG_KNRL_DTB) { 562 for (i = 0, skip = false; i < num; i++) { 563 if (!strcmp(pre_probed[i], uc_pdata->name)) { 564 skip = true; 565 break; 566 } 567 } 568 if (skip) 569 continue; 570 } 571 572 /* Probe and init */ 573 ret = device_probe(dev); 574 if (ret) 575 continue; 576 ret = regulator_autoset(dev); 577 if (ret == -EMEDIUMTYPE) 578 ret = 0; 579 if (verbose) 580 regulator_show(dev, ret); 581 if (ret == -ENOSYS) 582 ret = 0; 583 } 584 585 if (pre_probed) 586 free(pre_probed); 587 588 return ret; 589 } 590 591 #else 592 int regulators_enable_boot_on(bool verbose) 593 { 594 struct udevice *dev; 595 struct uclass *uc; 596 int ret; 597 598 ret = uclass_get(UCLASS_REGULATOR, &uc); 599 if (ret) 600 return ret; 601 for (uclass_first_device(UCLASS_REGULATOR, &dev); 602 dev; 603 uclass_next_device(&dev)) { 604 ret = regulator_autoset(dev); 605 606 if (ret == -EMEDIUMTYPE) 607 ret = 0; 608 if (verbose) 609 regulator_show(dev, ret); 610 if (ret == -ENOSYS) 611 ret = 0; 612 } 613 614 return ret; 615 } 616 #endif 617 618 UCLASS_DRIVER(regulator) = { 619 .id = UCLASS_REGULATOR, 620 .name = "regulator", 621 .post_bind = regulator_post_bind, 622 .pre_probe = regulator_pre_probe, 623 .per_device_platdata_auto_alloc_size = 624 sizeof(struct dm_regulator_uclass_platdata), 625 }; 626