1 /* 2 * Copyright (c) 2016-2021, STMicroelectronics - All Rights Reserved 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <errno.h> 8 #include <string.h> 9 10 #include <common/debug.h> 11 #include <drivers/st/stpmic1.h> 12 13 #define I2C_TIMEOUT_MS 25 14 15 struct regul_struct { 16 const char *dt_node_name; 17 const uint16_t *voltage_table; 18 uint8_t voltage_table_size; 19 uint8_t control_reg; 20 uint8_t low_power_reg; 21 uint8_t pull_down_reg; 22 uint8_t pull_down; 23 uint8_t mask_reset_reg; 24 uint8_t mask_reset; 25 }; 26 27 static struct i2c_handle_s *pmic_i2c_handle; 28 static uint16_t pmic_i2c_addr; 29 30 /* Voltage tables in mV */ 31 static const uint16_t buck1_voltage_table[] = { 32 725, 33 725, 34 725, 35 725, 36 725, 37 725, 38 750, 39 775, 40 800, 41 825, 42 850, 43 875, 44 900, 45 925, 46 950, 47 975, 48 1000, 49 1025, 50 1050, 51 1075, 52 1100, 53 1125, 54 1150, 55 1175, 56 1200, 57 1225, 58 1250, 59 1275, 60 1300, 61 1325, 62 1350, 63 1375, 64 1400, 65 1425, 66 1450, 67 1475, 68 1500, 69 1500, 70 1500, 71 1500, 72 1500, 73 1500, 74 1500, 75 1500, 76 1500, 77 1500, 78 1500, 79 1500, 80 1500, 81 1500, 82 1500, 83 1500, 84 1500, 85 1500, 86 1500, 87 1500, 88 1500, 89 1500, 90 1500, 91 1500, 92 1500, 93 1500, 94 1500, 95 1500, 96 }; 97 98 static const uint16_t buck2_voltage_table[] = { 99 1000, 100 1000, 101 1000, 102 1000, 103 1000, 104 1000, 105 1000, 106 1000, 107 1000, 108 1000, 109 1000, 110 1000, 111 1000, 112 1000, 113 1000, 114 1000, 115 1000, 116 1000, 117 1050, 118 1050, 119 1100, 120 1100, 121 1150, 122 1150, 123 1200, 124 1200, 125 1250, 126 1250, 127 1300, 128 1300, 129 1350, 130 1350, 131 1400, 132 1400, 133 1450, 134 1450, 135 1500, 136 }; 137 138 static const uint16_t buck3_voltage_table[] = { 139 1000, 140 1000, 141 1000, 142 1000, 143 1000, 144 1000, 145 1000, 146 1000, 147 1000, 148 1000, 149 1000, 150 1000, 151 1000, 152 1000, 153 1000, 154 1000, 155 1000, 156 1000, 157 1000, 158 1000, 159 1100, 160 1100, 161 1100, 162 1100, 163 1200, 164 1200, 165 1200, 166 1200, 167 1300, 168 1300, 169 1300, 170 1300, 171 1400, 172 1400, 173 1400, 174 1400, 175 1500, 176 1600, 177 1700, 178 1800, 179 1900, 180 2000, 181 2100, 182 2200, 183 2300, 184 2400, 185 2500, 186 2600, 187 2700, 188 2800, 189 2900, 190 3000, 191 3100, 192 3200, 193 3300, 194 3400, 195 }; 196 197 static const uint16_t buck4_voltage_table[] = { 198 600, 199 625, 200 650, 201 675, 202 700, 203 725, 204 750, 205 775, 206 800, 207 825, 208 850, 209 875, 210 900, 211 925, 212 950, 213 975, 214 1000, 215 1025, 216 1050, 217 1075, 218 1100, 219 1125, 220 1150, 221 1175, 222 1200, 223 1225, 224 1250, 225 1275, 226 1300, 227 1300, 228 1350, 229 1350, 230 1400, 231 1400, 232 1450, 233 1450, 234 1500, 235 1600, 236 1700, 237 1800, 238 1900, 239 2000, 240 2100, 241 2200, 242 2300, 243 2400, 244 2500, 245 2600, 246 2700, 247 2800, 248 2900, 249 3000, 250 3100, 251 3200, 252 3300, 253 3400, 254 3500, 255 3600, 256 3700, 257 3800, 258 3900, 259 }; 260 261 static const uint16_t ldo1_voltage_table[] = { 262 1700, 263 1700, 264 1700, 265 1700, 266 1700, 267 1700, 268 1700, 269 1700, 270 1700, 271 1800, 272 1900, 273 2000, 274 2100, 275 2200, 276 2300, 277 2400, 278 2500, 279 2600, 280 2700, 281 2800, 282 2900, 283 3000, 284 3100, 285 3200, 286 3300, 287 }; 288 289 static const uint16_t ldo2_voltage_table[] = { 290 1700, 291 1700, 292 1700, 293 1700, 294 1700, 295 1700, 296 1700, 297 1700, 298 1700, 299 1800, 300 1900, 301 2000, 302 2100, 303 2200, 304 2300, 305 2400, 306 2500, 307 2600, 308 2700, 309 2800, 310 2900, 311 3000, 312 3100, 313 3200, 314 3300, 315 }; 316 317 static const uint16_t ldo3_voltage_table[] = { 318 1700, 319 1700, 320 1700, 321 1700, 322 1700, 323 1700, 324 1700, 325 1700, 326 1700, 327 1800, 328 1900, 329 2000, 330 2100, 331 2200, 332 2300, 333 2400, 334 2500, 335 2600, 336 2700, 337 2800, 338 2900, 339 3000, 340 3100, 341 3200, 342 3300, 343 3300, 344 3300, 345 3300, 346 3300, 347 3300, 348 3300, 349 500, 350 0xFFFF, /* VREFDDR */ 351 }; 352 353 static const uint16_t ldo5_voltage_table[] = { 354 1700, 355 1700, 356 1700, 357 1700, 358 1700, 359 1700, 360 1700, 361 1700, 362 1700, 363 1800, 364 1900, 365 2000, 366 2100, 367 2200, 368 2300, 369 2400, 370 2500, 371 2600, 372 2700, 373 2800, 374 2900, 375 3000, 376 3100, 377 3200, 378 3300, 379 3400, 380 3500, 381 3600, 382 3700, 383 3800, 384 3900, 385 }; 386 387 static const uint16_t ldo6_voltage_table[] = { 388 900, 389 1000, 390 1100, 391 1200, 392 1300, 393 1400, 394 1500, 395 1600, 396 1700, 397 1800, 398 1900, 399 2000, 400 2100, 401 2200, 402 2300, 403 2400, 404 2500, 405 2600, 406 2700, 407 2800, 408 2900, 409 3000, 410 3100, 411 3200, 412 3300, 413 }; 414 415 static const uint16_t ldo4_voltage_table[] = { 416 3300, 417 }; 418 419 static const uint16_t vref_ddr_voltage_table[] = { 420 3300, 421 }; 422 423 /* Table of Regulators in PMIC SoC */ 424 static const struct regul_struct regulators_table[] = { 425 { 426 .dt_node_name = "buck1", 427 .voltage_table = buck1_voltage_table, 428 .voltage_table_size = ARRAY_SIZE(buck1_voltage_table), 429 .control_reg = BUCK1_CONTROL_REG, 430 .low_power_reg = BUCK1_PWRCTRL_REG, 431 .pull_down_reg = BUCK_PULL_DOWN_REG, 432 .pull_down = BUCK1_PULL_DOWN_SHIFT, 433 .mask_reset_reg = MASK_RESET_BUCK_REG, 434 .mask_reset = BUCK1_MASK_RESET, 435 }, 436 { 437 .dt_node_name = "buck2", 438 .voltage_table = buck2_voltage_table, 439 .voltage_table_size = ARRAY_SIZE(buck2_voltage_table), 440 .control_reg = BUCK2_CONTROL_REG, 441 .low_power_reg = BUCK2_PWRCTRL_REG, 442 .pull_down_reg = BUCK_PULL_DOWN_REG, 443 .pull_down = BUCK2_PULL_DOWN_SHIFT, 444 .mask_reset_reg = MASK_RESET_BUCK_REG, 445 .mask_reset = BUCK2_MASK_RESET, 446 }, 447 { 448 .dt_node_name = "buck3", 449 .voltage_table = buck3_voltage_table, 450 .voltage_table_size = ARRAY_SIZE(buck3_voltage_table), 451 .control_reg = BUCK3_CONTROL_REG, 452 .low_power_reg = BUCK3_PWRCTRL_REG, 453 .pull_down_reg = BUCK_PULL_DOWN_REG, 454 .pull_down = BUCK3_PULL_DOWN_SHIFT, 455 .mask_reset_reg = MASK_RESET_BUCK_REG, 456 .mask_reset = BUCK3_MASK_RESET, 457 }, 458 { 459 .dt_node_name = "buck4", 460 .voltage_table = buck4_voltage_table, 461 .voltage_table_size = ARRAY_SIZE(buck4_voltage_table), 462 .control_reg = BUCK4_CONTROL_REG, 463 .low_power_reg = BUCK4_PWRCTRL_REG, 464 .pull_down_reg = BUCK_PULL_DOWN_REG, 465 .pull_down = BUCK4_PULL_DOWN_SHIFT, 466 .mask_reset_reg = MASK_RESET_BUCK_REG, 467 .mask_reset = BUCK4_MASK_RESET, 468 }, 469 { 470 .dt_node_name = "ldo1", 471 .voltage_table = ldo1_voltage_table, 472 .voltage_table_size = ARRAY_SIZE(ldo1_voltage_table), 473 .control_reg = LDO1_CONTROL_REG, 474 .low_power_reg = LDO1_PWRCTRL_REG, 475 .mask_reset_reg = MASK_RESET_LDO_REG, 476 .mask_reset = LDO1_MASK_RESET, 477 }, 478 { 479 .dt_node_name = "ldo2", 480 .voltage_table = ldo2_voltage_table, 481 .voltage_table_size = ARRAY_SIZE(ldo2_voltage_table), 482 .control_reg = LDO2_CONTROL_REG, 483 .low_power_reg = LDO2_PWRCTRL_REG, 484 .mask_reset_reg = MASK_RESET_LDO_REG, 485 .mask_reset = LDO2_MASK_RESET, 486 }, 487 { 488 .dt_node_name = "ldo3", 489 .voltage_table = ldo3_voltage_table, 490 .voltage_table_size = ARRAY_SIZE(ldo3_voltage_table), 491 .control_reg = LDO3_CONTROL_REG, 492 .low_power_reg = LDO3_PWRCTRL_REG, 493 .mask_reset_reg = MASK_RESET_LDO_REG, 494 .mask_reset = LDO3_MASK_RESET, 495 }, 496 { 497 .dt_node_name = "ldo4", 498 .voltage_table = ldo4_voltage_table, 499 .voltage_table_size = ARRAY_SIZE(ldo4_voltage_table), 500 .control_reg = LDO4_CONTROL_REG, 501 .low_power_reg = LDO4_PWRCTRL_REG, 502 .mask_reset_reg = MASK_RESET_LDO_REG, 503 .mask_reset = LDO4_MASK_RESET, 504 }, 505 { 506 .dt_node_name = "ldo5", 507 .voltage_table = ldo5_voltage_table, 508 .voltage_table_size = ARRAY_SIZE(ldo5_voltage_table), 509 .control_reg = LDO5_CONTROL_REG, 510 .low_power_reg = LDO5_PWRCTRL_REG, 511 .mask_reset_reg = MASK_RESET_LDO_REG, 512 .mask_reset = LDO5_MASK_RESET, 513 }, 514 { 515 .dt_node_name = "ldo6", 516 .voltage_table = ldo6_voltage_table, 517 .voltage_table_size = ARRAY_SIZE(ldo6_voltage_table), 518 .control_reg = LDO6_CONTROL_REG, 519 .low_power_reg = LDO6_PWRCTRL_REG, 520 .mask_reset_reg = MASK_RESET_LDO_REG, 521 .mask_reset = LDO6_MASK_RESET, 522 }, 523 { 524 .dt_node_name = "vref_ddr", 525 .voltage_table = vref_ddr_voltage_table, 526 .voltage_table_size = ARRAY_SIZE(vref_ddr_voltage_table), 527 .control_reg = VREF_DDR_CONTROL_REG, 528 .low_power_reg = VREF_DDR_PWRCTRL_REG, 529 .mask_reset_reg = MASK_RESET_LDO_REG, 530 .mask_reset = VREF_DDR_MASK_RESET, 531 }, 532 }; 533 534 #define MAX_REGUL ARRAY_SIZE(regulators_table) 535 536 static const struct regul_struct *get_regulator_data(const char *name) 537 { 538 uint8_t i; 539 540 for (i = 0 ; i < MAX_REGUL ; i++) { 541 if (strncmp(name, regulators_table[i].dt_node_name, 542 strlen(regulators_table[i].dt_node_name)) == 0) { 543 return ®ulators_table[i]; 544 } 545 } 546 547 /* Regulator not found */ 548 panic(); 549 return NULL; 550 } 551 552 static uint8_t voltage_to_index(const char *name, uint16_t millivolts) 553 { 554 const struct regul_struct *regul = get_regulator_data(name); 555 uint8_t i; 556 557 for (i = 0 ; i < regul->voltage_table_size ; i++) { 558 if (regul->voltage_table[i] == millivolts) { 559 return i; 560 } 561 } 562 563 /* Voltage not found */ 564 panic(); 565 566 return 0; 567 } 568 569 int stpmic1_powerctrl_on(void) 570 { 571 return stpmic1_register_update(MAIN_CONTROL_REG, PWRCTRL_PIN_VALID, 572 PWRCTRL_PIN_VALID); 573 } 574 575 int stpmic1_switch_off(void) 576 { 577 return stpmic1_register_update(MAIN_CONTROL_REG, 1, 578 SOFTWARE_SWITCH_OFF_ENABLED); 579 } 580 581 int stpmic1_regulator_enable(const char *name) 582 { 583 const struct regul_struct *regul = get_regulator_data(name); 584 585 return stpmic1_register_update(regul->control_reg, BIT(0), BIT(0)); 586 } 587 588 int stpmic1_regulator_disable(const char *name) 589 { 590 const struct regul_struct *regul = get_regulator_data(name); 591 592 return stpmic1_register_update(regul->control_reg, 0, BIT(0)); 593 } 594 595 uint8_t stpmic1_is_regulator_enabled(const char *name) 596 { 597 uint8_t val; 598 const struct regul_struct *regul = get_regulator_data(name); 599 600 if (stpmic1_register_read(regul->control_reg, &val) != 0) { 601 panic(); 602 } 603 604 return (val & 0x1U); 605 } 606 607 int stpmic1_regulator_voltage_set(const char *name, uint16_t millivolts) 608 { 609 uint8_t voltage_index = voltage_to_index(name, millivolts); 610 const struct regul_struct *regul = get_regulator_data(name); 611 uint8_t mask; 612 613 /* Voltage can be set for buck<N> or ldo<N> (except ldo4) regulators */ 614 if (strncmp(name, "buck", 4) == 0) { 615 mask = BUCK_VOLTAGE_MASK; 616 } else if ((strncmp(name, "ldo", 3) == 0) && 617 (strncmp(name, "ldo4", 4) != 0)) { 618 mask = LDO_VOLTAGE_MASK; 619 } else { 620 return 0; 621 } 622 623 return stpmic1_register_update(regul->control_reg, 624 voltage_index << LDO_BUCK_VOLTAGE_SHIFT, 625 mask); 626 } 627 628 int stpmic1_regulator_pull_down_set(const char *name) 629 { 630 const struct regul_struct *regul = get_regulator_data(name); 631 632 if (regul->pull_down_reg != 0) { 633 return stpmic1_register_update(regul->pull_down_reg, 634 BIT(regul->pull_down), 635 LDO_BUCK_PULL_DOWN_MASK << 636 regul->pull_down); 637 } 638 639 return 0; 640 } 641 642 int stpmic1_regulator_mask_reset_set(const char *name) 643 { 644 const struct regul_struct *regul = get_regulator_data(name); 645 646 return stpmic1_register_update(regul->mask_reset_reg, 647 BIT(regul->mask_reset), 648 LDO_BUCK_RESET_MASK << 649 regul->mask_reset); 650 } 651 652 int stpmic1_regulator_voltage_get(const char *name) 653 { 654 const struct regul_struct *regul = get_regulator_data(name); 655 uint8_t value; 656 uint8_t mask; 657 int status; 658 659 /* Voltage can be set for buck<N> or ldo<N> (except ldo4) regulators */ 660 if (strncmp(name, "buck", 4) == 0) { 661 mask = BUCK_VOLTAGE_MASK; 662 } else if ((strncmp(name, "ldo", 3) == 0) && 663 (strncmp(name, "ldo4", 4) != 0)) { 664 mask = LDO_VOLTAGE_MASK; 665 } else { 666 return 0; 667 } 668 669 status = stpmic1_register_read(regul->control_reg, &value); 670 if (status < 0) { 671 return status; 672 } 673 674 value = (value & mask) >> LDO_BUCK_VOLTAGE_SHIFT; 675 676 if (value > regul->voltage_table_size) { 677 return -ERANGE; 678 } 679 680 return (int)regul->voltage_table[value]; 681 } 682 683 int stpmic1_register_read(uint8_t register_id, uint8_t *value) 684 { 685 return stm32_i2c_mem_read(pmic_i2c_handle, pmic_i2c_addr, 686 (uint16_t)register_id, 687 I2C_MEMADD_SIZE_8BIT, value, 688 1, I2C_TIMEOUT_MS); 689 } 690 691 int stpmic1_register_write(uint8_t register_id, uint8_t value) 692 { 693 int status; 694 695 status = stm32_i2c_mem_write(pmic_i2c_handle, pmic_i2c_addr, 696 (uint16_t)register_id, 697 I2C_MEMADD_SIZE_8BIT, &value, 698 1, I2C_TIMEOUT_MS); 699 700 #if ENABLE_ASSERTIONS 701 if (status != 0) { 702 return status; 703 } 704 705 if ((register_id != WATCHDOG_CONTROL_REG) && (register_id <= 0x40U)) { 706 uint8_t readval; 707 708 status = stpmic1_register_read(register_id, &readval); 709 if (status != 0) { 710 return status; 711 } 712 713 if (readval != value) { 714 return -EIO; 715 } 716 } 717 #endif 718 719 return status; 720 } 721 722 int stpmic1_register_update(uint8_t register_id, uint8_t value, uint8_t mask) 723 { 724 int status; 725 uint8_t val; 726 727 status = stpmic1_register_read(register_id, &val); 728 if (status != 0) { 729 return status; 730 } 731 732 val = (val & ~mask) | (value & mask); 733 734 return stpmic1_register_write(register_id, val); 735 } 736 737 void stpmic1_bind_i2c(struct i2c_handle_s *i2c_handle, uint16_t i2c_addr) 738 { 739 pmic_i2c_handle = i2c_handle; 740 pmic_i2c_addr = i2c_addr; 741 } 742 743 void stpmic1_dump_regulators(void) 744 { 745 uint32_t i; 746 747 for (i = 0U; i < MAX_REGUL; i++) { 748 const char *name __unused = regulators_table[i].dt_node_name; 749 750 VERBOSE("PMIC regul %s: %sable, %dmV", 751 name, 752 stpmic1_is_regulator_enabled(name) ? "en" : "dis", 753 stpmic1_regulator_voltage_get(name)); 754 } 755 } 756 757 int stpmic1_get_version(unsigned long *version) 758 { 759 uint8_t read_val; 760 int status; 761 762 status = stpmic1_register_read(VERSION_STATUS_REG, &read_val); 763 if (status < 0) { 764 return status; 765 } 766 767 *version = (unsigned long)read_val; 768 769 return 0; 770 } 771