1 // SPDX-License-Identifier: BSD-3-Clause 2 /* 3 * Copyright (c) 2016-2018, STMicroelectronics - All Rights Reserved 4 */ 5 6 #include <assert.h> 7 #include <drivers/stpmic1.h> 8 #include <kernel/panic.h> 9 #include <platform_config.h> 10 #include <stdint.h> 11 #include <string.h> 12 #include <trace.h> 13 14 #define STPMIC1_I2C_TIMEOUT_US (10 * 1000) 15 16 struct regul_struct { 17 const char *dt_node_name; 18 const uint16_t *voltage_table; 19 uint8_t voltage_table_size; 20 uint8_t control_reg; 21 uint8_t low_power_reg; 22 uint8_t pull_down_reg; 23 uint8_t pull_down_pos; 24 uint8_t mask_reset_reg; 25 uint8_t mask_reset_pos; 26 }; 27 28 static struct i2c_handle_s *pmic_i2c_handle; 29 static uint16_t pmic_i2c_addr; 30 31 /* Voltage tables in mV */ 32 static const uint16_t buck1_voltage_table[] = { 33 725, 34 725, 35 725, 36 725, 37 725, 38 725, 39 750, 40 775, 41 800, 42 825, 43 850, 44 875, 45 900, 46 925, 47 950, 48 975, 49 1000, 50 1025, 51 1050, 52 1075, 53 1100, 54 1125, 55 1150, 56 1175, 57 1200, 58 1225, 59 1250, 60 1275, 61 1300, 62 1325, 63 1350, 64 1375, 65 1400, 66 1425, 67 1450, 68 1475, 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 1500, 97 }; 98 99 static const uint16_t buck2_voltage_table[] = { 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 1000, 118 1050, 119 1050, 120 1100, 121 1100, 122 1150, 123 1150, 124 1200, 125 1200, 126 1250, 127 1250, 128 1300, 129 1300, 130 1350, 131 1350, 132 1400, 133 1400, 134 1450, 135 1450, 136 1500, 137 }; 138 139 static const uint16_t buck3_voltage_table[] = { 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 1000, 160 1100, 161 1100, 162 1100, 163 1100, 164 1200, 165 1200, 166 1200, 167 1200, 168 1300, 169 1300, 170 1300, 171 1300, 172 1400, 173 1400, 174 1400, 175 1400, 176 1500, 177 1600, 178 1700, 179 1800, 180 1900, 181 2000, 182 2100, 183 2200, 184 2300, 185 2400, 186 2500, 187 2600, 188 2700, 189 2800, 190 2900, 191 3000, 192 3100, 193 3200, 194 3300, 195 3400, 196 }; 197 198 static const uint16_t buck4_voltage_table[] = { 199 600, 200 625, 201 650, 202 675, 203 700, 204 725, 205 750, 206 775, 207 800, 208 825, 209 850, 210 875, 211 900, 212 925, 213 950, 214 975, 215 1000, 216 1025, 217 1050, 218 1075, 219 1100, 220 1125, 221 1150, 222 1175, 223 1200, 224 1225, 225 1250, 226 1275, 227 1300, 228 1300, 229 1350, 230 1350, 231 1400, 232 1400, 233 1450, 234 1450, 235 1500, 236 1600, 237 1700, 238 1800, 239 1900, 240 2000, 241 2100, 242 2200, 243 2300, 244 2400, 245 2500, 246 2600, 247 2700, 248 2800, 249 2900, 250 3000, 251 3100, 252 3200, 253 3300, 254 3400, 255 3500, 256 3600, 257 3700, 258 3800, 259 3900, 260 }; 261 262 static const uint16_t ldo1_voltage_table[] = { 263 1700, 264 1700, 265 1700, 266 1700, 267 1700, 268 1700, 269 1700, 270 1700, 271 1700, 272 1800, 273 1900, 274 2000, 275 2100, 276 2200, 277 2300, 278 2400, 279 2500, 280 2600, 281 2700, 282 2800, 283 2900, 284 3000, 285 3100, 286 3200, 287 3300, 288 }; 289 290 static const uint16_t ldo2_voltage_table[] = { 291 1700, 292 1700, 293 1700, 294 1700, 295 1700, 296 1700, 297 1700, 298 1700, 299 1700, 300 1800, 301 1900, 302 2000, 303 2100, 304 2200, 305 2300, 306 2400, 307 2500, 308 2600, 309 2700, 310 2800, 311 2900, 312 3000, 313 3100, 314 3200, 315 3300, 316 }; 317 318 static const uint16_t ldo3_voltage_table[] = { 319 1700, 320 1700, 321 1700, 322 1700, 323 1700, 324 1700, 325 1700, 326 1700, 327 1700, 328 1800, 329 1900, 330 2000, 331 2100, 332 2200, 333 2300, 334 2400, 335 2500, 336 2600, 337 2700, 338 2800, 339 2900, 340 3000, 341 3100, 342 3200, 343 3300, 344 3300, 345 3300, 346 3300, 347 3300, 348 3300, 349 3300, 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_pos = BUCK1_PULL_DOWN_SHIFT, 433 .mask_reset_reg = MASK_RESET_BUCK_REG, 434 .mask_reset_pos = BUCK1_MASK_RESET_SHIFT, 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_pos = BUCK2_PULL_DOWN_SHIFT, 444 .mask_reset_reg = MASK_RESET_BUCK_REG, 445 .mask_reset_pos = BUCK2_MASK_RESET_SHIFT, 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_pos = BUCK3_PULL_DOWN_SHIFT, 455 .mask_reset_reg = MASK_RESET_BUCK_REG, 456 .mask_reset_pos = BUCK3_MASK_RESET_SHIFT, 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_pos = BUCK4_PULL_DOWN_SHIFT, 466 .mask_reset_reg = MASK_RESET_BUCK_REG, 467 .mask_reset_pos = BUCK4_MASK_RESET_SHIFT, 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_pos = LDO1_MASK_RESET_SHIFT, 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_pos = LDO2_MASK_RESET_SHIFT, 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_pos = LDO3_MASK_RESET_SHIFT, 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_pos = LDO4_MASK_RESET_SHIFT, 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_pos = LDO5_MASK_RESET_SHIFT, 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_pos = LDO6_MASK_RESET_SHIFT, 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_pos = VREF_DDR_MASK_RESET_SHIFT, 531 }, 532 { 533 .dt_node_name = "boost", 534 }, 535 { 536 .dt_node_name = "pwr_sw1", 537 }, 538 { 539 .dt_node_name = "pwr_sw2", 540 }, 541 }; 542 543 static const struct regul_struct *get_regulator_data(const char *name) 544 { 545 unsigned int i = 0; 546 547 for (i = 0; i < ARRAY_SIZE(regulators_table); i++) 548 if (strcmp(name, regulators_table[i].dt_node_name) == 0) 549 return ®ulators_table[i]; 550 551 /* Regulator not found */ 552 panic(name); 553 } 554 555 static uint8_t voltage_to_index(const char *name, uint16_t millivolts) 556 { 557 const struct regul_struct *regul = get_regulator_data(name); 558 unsigned int i = 0; 559 560 assert(regul->voltage_table); 561 for (i = 0; i < regul->voltage_table_size; i++) 562 if (regul->voltage_table[i] == millivolts) 563 return i; 564 565 /* Voltage not found */ 566 panic(name); 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 const struct regul_struct *regul = get_regulator_data(name); 598 uint8_t val = 0; 599 600 if (stpmic1_register_read(regul->control_reg, &val)) 601 panic(); 602 603 return val & 0x1; 604 } 605 606 int stpmic1_regulator_voltage_set(const char *name, uint16_t millivolts) 607 { 608 uint8_t voltage_index = voltage_to_index(name, millivolts); 609 const struct regul_struct *regul = get_regulator_data(name); 610 uint8_t mask = 0; 611 612 /* Voltage can be set for buck<N> or ldo<N> (except ldo4) regulators */ 613 if (!strcmp(name, "buck")) 614 mask = BUCK_VOLTAGE_MASK; 615 else if (!strcmp(name, "ldo") && strcmp(name, "ldo4")) 616 mask = LDO_VOLTAGE_MASK; 617 else 618 return 0; 619 620 return stpmic1_register_update(regul->control_reg, 621 voltage_index << LDO_BUCK_VOLTAGE_SHIFT, 622 mask); 623 } 624 625 int stpmic1_regulator_mask_reset_set(const char *name) 626 { 627 const struct regul_struct *regul = get_regulator_data(name); 628 629 return stpmic1_register_update(regul->mask_reset_reg, 630 BIT(regul->mask_reset_pos), 631 LDO_BUCK_RESET_MASK << 632 regul->mask_reset_pos); 633 } 634 635 int stpmic1_regulator_voltage_get(const char *name) 636 { 637 const struct regul_struct *regul = get_regulator_data(name); 638 uint8_t value = 0; 639 uint8_t mask = 0; 640 641 /* Voltage can be set for buck<N> or ldo<N> (except ldo4) regulators */ 642 if (!strcmp(name, "buck")) 643 mask = BUCK_VOLTAGE_MASK; 644 else if (!strcmp(name, "ldo") && strcmp(name, "ldo4")) 645 mask = LDO_VOLTAGE_MASK; 646 else 647 return 0; 648 649 if (stpmic1_register_read(regul->control_reg, &value)) 650 return -1; 651 652 value = (value & mask) >> LDO_BUCK_VOLTAGE_SHIFT; 653 654 if (value > regul->voltage_table_size) 655 return -1; 656 657 return regul->voltage_table[value]; 658 } 659 660 int stpmic1_lp_copy_reg(const char *name) 661 { 662 const struct regul_struct *regul = get_regulator_data(name); 663 uint8_t val = 0; 664 int status = 0; 665 666 status = stpmic1_register_read(regul->control_reg, &val); 667 if (status) 668 return status; 669 670 return stpmic1_register_write(regul->low_power_reg, val); 671 } 672 673 int stpmic1_lp_reg_on_off(const char *name, uint8_t enable) 674 { 675 const struct regul_struct *regul = get_regulator_data(name); 676 677 return stpmic1_register_update(regul->low_power_reg, enable, 678 LDO_BUCK_ENABLE_MASK); 679 } 680 681 int stpmic1_lp_set_mode(const char *name, uint8_t hplp) 682 { 683 const struct regul_struct *regul = get_regulator_data(name); 684 685 return stpmic1_register_update(regul->low_power_reg, 686 hplp << LDO_BUCK_HPLP_SHIFT, 687 LDO_BUCK_HPLP_ENABLE_MASK); 688 } 689 690 int stpmic1_lp_set_voltage(const char *name, uint16_t millivolts) 691 { 692 uint8_t voltage_index = voltage_to_index(name, millivolts); 693 const struct regul_struct *regul = get_regulator_data(name); 694 uint8_t mask = 0; 695 696 /* Voltage can be set for buck<N> or ldo<N> (except ldo4) regulators */ 697 if (!strcmp(name, "buck")) 698 mask = BUCK_VOLTAGE_MASK; 699 else if (!strcmp(name, "ldo") && strcmp(name, "ldo4")) 700 mask = LDO_VOLTAGE_MASK; 701 else 702 return 0; 703 704 return stpmic1_register_update(regul->low_power_reg, voltage_index << 2, 705 mask); 706 } 707 708 int stpmic1_register_read(uint8_t register_id, uint8_t *value) 709 { 710 struct i2c_handle_s *i2c = pmic_i2c_handle; 711 712 return stm32_i2c_mem_read(i2c, pmic_i2c_addr, register_id, 1, 713 value, 1, STPMIC1_I2C_TIMEOUT_US); 714 } 715 716 int stpmic1_register_write(uint8_t register_id, uint8_t value) 717 { 718 struct i2c_handle_s *i2c = pmic_i2c_handle; 719 uint8_t val = value; 720 721 return stm32_i2c_mem_write(i2c, pmic_i2c_addr, register_id, 1, 722 &val, 1, STPMIC1_I2C_TIMEOUT_US); 723 } 724 725 int stpmic1_register_update(uint8_t register_id, uint8_t value, uint8_t mask) 726 { 727 int status = 0; 728 uint8_t val = 0; 729 730 status = stpmic1_register_read(register_id, &val); 731 if (status) 732 return status; 733 734 val = (val & ~mask) | (value & mask); 735 736 return stpmic1_register_write(register_id, val); 737 } 738 739 void stpmic1_bind_i2c(struct i2c_handle_s *i2c_handle, uint16_t i2c_addr) 740 { 741 pmic_i2c_handle = i2c_handle; 742 pmic_i2c_addr = i2c_addr; 743 } 744 745 void stpmic1_dump_regulators(void) 746 { 747 size_t i = 0; 748 char __maybe_unused const *name = NULL; 749 750 for (i = 0; i < ARRAY_SIZE(regulators_table); i++) { 751 if (!regulators_table[i].control_reg) 752 continue; 753 754 name = regulators_table[i].dt_node_name; 755 DMSG("PMIC regul %s: %sable, %dmV", 756 name, stpmic1_is_regulator_enabled(name) ? "en" : "dis", 757 stpmic1_regulator_voltage_get(name)); 758 } 759 } 760 761 int stpmic1_get_version(unsigned long *version) 762 { 763 uint8_t read_val = 0; 764 765 if (stpmic1_register_read(VERSION_STATUS_REG, &read_val)) 766 return -1; 767 768 *version = read_val; 769 return 0; 770 } 771