1 /* 2 * Copyright (c) 2017-2022, STMicroelectronics - All Rights Reserved 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <assert.h> 8 #include <errno.h> 9 10 #include <common/debug.h> 11 #include <drivers/delay_timer.h> 12 #include <drivers/st/regulator.h> 13 #include <drivers/st/stm32_i2c.h> 14 #include <drivers/st/stm32mp_pmic.h> 15 #include <drivers/st/stpmic1.h> 16 #include <lib/mmio.h> 17 #include <lib/utils_def.h> 18 #include <libfdt.h> 19 20 #include <platform_def.h> 21 22 #define PMIC_NODE_NOT_FOUND 1 23 24 static struct i2c_handle_s i2c_handle; 25 static uint32_t pmic_i2c_addr; 26 27 static int register_pmic(void); 28 29 static int dt_get_pmic_node(void *fdt) 30 { 31 static int node = -FDT_ERR_BADOFFSET; 32 33 if (node == -FDT_ERR_BADOFFSET) { 34 node = fdt_node_offset_by_compatible(fdt, -1, "st,stpmic1"); 35 } 36 37 return node; 38 } 39 40 int dt_pmic_status(void) 41 { 42 static int status = -FDT_ERR_BADVALUE; 43 int node; 44 void *fdt; 45 46 if (status != -FDT_ERR_BADVALUE) { 47 return status; 48 } 49 50 if (fdt_get_address(&fdt) == 0) { 51 return -ENOENT; 52 } 53 54 node = dt_get_pmic_node(fdt); 55 if (node <= 0) { 56 status = -FDT_ERR_NOTFOUND; 57 58 return status; 59 } 60 61 status = (int)fdt_get_status(node); 62 63 return status; 64 } 65 66 static bool dt_pmic_is_secure(void) 67 { 68 int status = dt_pmic_status(); 69 70 return (status >= 0) && 71 (status == DT_SECURE) && 72 (i2c_handle.dt_status == DT_SECURE); 73 } 74 75 /* 76 * Get PMIC and its I2C bus configuration from the device tree. 77 * Return 0 on success, negative on error, 1 if no PMIC node is defined. 78 */ 79 static int dt_pmic_i2c_config(struct dt_node_info *i2c_info, 80 struct stm32_i2c_init_s *init) 81 { 82 static int i2c_node = -FDT_ERR_NOTFOUND; 83 void *fdt; 84 85 if (fdt_get_address(&fdt) == 0) { 86 return -FDT_ERR_NOTFOUND; 87 } 88 89 if (i2c_node == -FDT_ERR_NOTFOUND) { 90 int pmic_node; 91 const fdt32_t *cuint; 92 93 pmic_node = dt_get_pmic_node(fdt); 94 if (pmic_node < 0) { 95 return PMIC_NODE_NOT_FOUND; 96 } 97 98 cuint = fdt_getprop(fdt, pmic_node, "reg", NULL); 99 if (cuint == NULL) { 100 return -FDT_ERR_NOTFOUND; 101 } 102 103 pmic_i2c_addr = fdt32_to_cpu(*cuint) << 1; 104 if (pmic_i2c_addr > UINT16_MAX) { 105 return -FDT_ERR_BADVALUE; 106 } 107 108 i2c_node = fdt_parent_offset(fdt, pmic_node); 109 if (i2c_node < 0) { 110 return -FDT_ERR_NOTFOUND; 111 } 112 } 113 114 dt_fill_device_info(i2c_info, i2c_node); 115 if (i2c_info->base == 0U) { 116 return -FDT_ERR_NOTFOUND; 117 } 118 119 return stm32_i2c_get_setup_from_fdt(fdt, i2c_node, init); 120 } 121 122 bool initialize_pmic_i2c(void) 123 { 124 int ret; 125 struct dt_node_info i2c_info; 126 struct i2c_handle_s *i2c = &i2c_handle; 127 struct stm32_i2c_init_s i2c_init; 128 129 ret = dt_pmic_i2c_config(&i2c_info, &i2c_init); 130 if (ret < 0) { 131 ERROR("I2C configuration failed %d\n", ret); 132 panic(); 133 } 134 135 if (ret != 0) { 136 return false; 137 } 138 139 /* Initialize PMIC I2C */ 140 i2c->i2c_base_addr = i2c_info.base; 141 i2c->dt_status = i2c_info.status; 142 i2c->clock = i2c_info.clock; 143 i2c->i2c_state = I2C_STATE_RESET; 144 i2c_init.own_address1 = pmic_i2c_addr; 145 i2c_init.addressing_mode = I2C_ADDRESSINGMODE_7BIT; 146 i2c_init.dual_address_mode = I2C_DUALADDRESS_DISABLE; 147 i2c_init.own_address2 = 0; 148 i2c_init.own_address2_masks = I2C_OAR2_OA2NOMASK; 149 i2c_init.general_call_mode = I2C_GENERALCALL_DISABLE; 150 i2c_init.no_stretch_mode = I2C_NOSTRETCH_DISABLE; 151 i2c_init.analog_filter = 1; 152 i2c_init.digital_filter_coef = 0; 153 154 ret = stm32_i2c_init(i2c, &i2c_init); 155 if (ret != 0) { 156 ERROR("Cannot initialize I2C %x (%d)\n", 157 i2c->i2c_base_addr, ret); 158 panic(); 159 } 160 161 if (!stm32_i2c_is_device_ready(i2c, pmic_i2c_addr, 1, 162 I2C_TIMEOUT_BUSY_MS)) { 163 ERROR("I2C device not ready\n"); 164 panic(); 165 } 166 167 stpmic1_bind_i2c(i2c, (uint16_t)pmic_i2c_addr); 168 169 return true; 170 } 171 172 static void register_pmic_shared_peripherals(void) 173 { 174 uintptr_t i2c_base = i2c_handle.i2c_base_addr; 175 176 if (dt_pmic_is_secure()) { 177 stm32mp_register_secure_periph_iomem(i2c_base); 178 } else { 179 if (i2c_base != 0U) { 180 stm32mp_register_non_secure_periph_iomem(i2c_base); 181 } 182 } 183 } 184 185 void initialize_pmic(void) 186 { 187 if (!initialize_pmic_i2c()) { 188 VERBOSE("No PMIC\n"); 189 return; 190 } 191 192 register_pmic_shared_peripherals(); 193 194 if (register_pmic() < 0) { 195 panic(); 196 } 197 198 if (stpmic1_powerctrl_on() < 0) { 199 panic(); 200 } 201 202 } 203 204 #if DEBUG 205 void print_pmic_info_and_debug(void) 206 { 207 unsigned long pmic_version; 208 209 if (stpmic1_get_version(&pmic_version) != 0) { 210 ERROR("Failed to access PMIC\n"); 211 panic(); 212 } 213 214 INFO("PMIC version = 0x%02lx\n", pmic_version); 215 } 216 #endif 217 218 int pmic_ddr_power_init(enum ddr_type ddr_type) 219 { 220 int status; 221 uint16_t buck3_min_mv; 222 struct rdev *buck2, *buck3, *vref; 223 struct rdev *ldo3 __unused; 224 225 buck2 = regulator_get_by_name("buck2"); 226 if (buck2 == NULL) { 227 return -ENOENT; 228 } 229 230 #if STM32MP15 231 ldo3 = regulator_get_by_name("ldo3"); 232 if (ldo3 == NULL) { 233 return -ENOENT; 234 } 235 #endif 236 237 vref = regulator_get_by_name("vref_ddr"); 238 if (vref == NULL) { 239 return -ENOENT; 240 } 241 242 switch (ddr_type) { 243 case STM32MP_DDR3: 244 #if STM32MP15 245 status = regulator_set_flag(ldo3, REGUL_SINK_SOURCE); 246 if (status != 0) { 247 return status; 248 } 249 #endif 250 251 status = regulator_set_min_voltage(buck2); 252 if (status != 0) { 253 return status; 254 } 255 256 status = regulator_enable(buck2); 257 if (status != 0) { 258 return status; 259 } 260 261 status = regulator_enable(vref); 262 if (status != 0) { 263 return status; 264 } 265 266 #if STM32MP15 267 status = regulator_enable(ldo3); 268 if (status != 0) { 269 return status; 270 } 271 #endif 272 break; 273 274 case STM32MP_LPDDR2: 275 case STM32MP_LPDDR3: 276 /* 277 * Set LDO3 to 1.8V 278 * Set LDO3 to bypass mode if BUCK3 = 1.8V 279 * Set LDO3 to normal mode if BUCK3 != 1.8V 280 */ 281 buck3 = regulator_get_by_name("buck3"); 282 if (buck3 == NULL) { 283 return -ENOENT; 284 } 285 286 regulator_get_range(buck3, &buck3_min_mv, NULL); 287 288 #if STM32MP15 289 if (buck3_min_mv != 1800) { 290 status = regulator_set_min_voltage(ldo3); 291 if (status != 0) { 292 return status; 293 } 294 } else { 295 status = regulator_set_flag(ldo3, REGUL_ENABLE_BYPASS); 296 if (status != 0) { 297 return status; 298 } 299 } 300 #endif 301 302 status = regulator_set_min_voltage(buck2); 303 if (status != 0) { 304 return status; 305 } 306 307 #if STM32MP15 308 status = regulator_enable(ldo3); 309 if (status != 0) { 310 return status; 311 } 312 #endif 313 314 status = regulator_enable(buck2); 315 if (status != 0) { 316 return status; 317 } 318 319 status = regulator_enable(vref); 320 if (status != 0) { 321 return status; 322 } 323 break; 324 325 default: 326 break; 327 }; 328 329 return 0; 330 } 331 332 int pmic_voltages_init(void) 333 { 334 #if STM32MP13 335 struct rdev *buck1, *buck4; 336 int status; 337 338 buck1 = regulator_get_by_name("buck1"); 339 if (buck1 == NULL) { 340 return -ENOENT; 341 } 342 343 buck4 = regulator_get_by_name("buck4"); 344 if (buck4 == NULL) { 345 return -ENOENT; 346 } 347 348 status = regulator_set_min_voltage(buck1); 349 if (status != 0) { 350 return status; 351 } 352 353 status = regulator_set_min_voltage(buck4); 354 if (status != 0) { 355 return status; 356 } 357 #endif 358 359 return 0; 360 } 361 362 enum { 363 STPMIC1_BUCK1 = 0, 364 STPMIC1_BUCK2, 365 STPMIC1_BUCK3, 366 STPMIC1_BUCK4, 367 STPMIC1_LDO1, 368 STPMIC1_LDO2, 369 STPMIC1_LDO3, 370 STPMIC1_LDO4, 371 STPMIC1_LDO5, 372 STPMIC1_LDO6, 373 STPMIC1_VREF_DDR, 374 STPMIC1_BOOST, 375 STPMIC1_VBUS_OTG, 376 STPMIC1_SW_OUT, 377 }; 378 379 static int pmic_set_state(const struct regul_description *desc, bool enable) 380 { 381 VERBOSE("%s: set state to %d\n", desc->node_name, enable); 382 383 if (enable == STATE_ENABLE) { 384 return stpmic1_regulator_enable(desc->node_name); 385 } else { 386 return stpmic1_regulator_disable(desc->node_name); 387 } 388 } 389 390 static int pmic_get_state(const struct regul_description *desc) 391 { 392 VERBOSE("%s: get state\n", desc->node_name); 393 394 return stpmic1_is_regulator_enabled(desc->node_name); 395 } 396 397 static int pmic_get_voltage(const struct regul_description *desc) 398 { 399 VERBOSE("%s: get volt\n", desc->node_name); 400 401 return stpmic1_regulator_voltage_get(desc->node_name); 402 } 403 404 static int pmic_set_voltage(const struct regul_description *desc, uint16_t mv) 405 { 406 VERBOSE("%s: get volt\n", desc->node_name); 407 408 return stpmic1_regulator_voltage_set(desc->node_name, mv); 409 } 410 411 static int pmic_list_voltages(const struct regul_description *desc, 412 const uint16_t **levels, size_t *count) 413 { 414 VERBOSE("%s: list volt\n", desc->node_name); 415 416 return stpmic1_regulator_levels_mv(desc->node_name, levels, count); 417 } 418 419 static int pmic_set_flag(const struct regul_description *desc, uint16_t flag) 420 { 421 VERBOSE("%s: set_flag 0x%x\n", desc->node_name, flag); 422 423 switch (flag) { 424 case REGUL_OCP: 425 return stpmic1_regulator_icc_set(desc->node_name); 426 427 case REGUL_ACTIVE_DISCHARGE: 428 return stpmic1_active_discharge_mode_set(desc->node_name); 429 430 case REGUL_PULL_DOWN: 431 return stpmic1_regulator_pull_down_set(desc->node_name); 432 433 case REGUL_MASK_RESET: 434 return stpmic1_regulator_mask_reset_set(desc->node_name); 435 436 case REGUL_SINK_SOURCE: 437 return stpmic1_regulator_sink_mode_set(desc->node_name); 438 439 case REGUL_ENABLE_BYPASS: 440 return stpmic1_regulator_bypass_mode_set(desc->node_name); 441 442 default: 443 return -EINVAL; 444 } 445 } 446 447 static const struct regul_ops pmic_ops = { 448 .set_state = pmic_set_state, 449 .get_state = pmic_get_state, 450 .set_voltage = pmic_set_voltage, 451 .get_voltage = pmic_get_voltage, 452 .list_voltages = pmic_list_voltages, 453 .set_flag = pmic_set_flag, 454 }; 455 456 #define DEFINE_REGU(name) { \ 457 .node_name = name, \ 458 .ops = &pmic_ops, \ 459 .driver_data = NULL, \ 460 .enable_ramp_delay = 1000, \ 461 } 462 463 static const struct regul_description pmic_regs[] = { 464 [STPMIC1_BUCK1] = DEFINE_REGU("buck1"), 465 [STPMIC1_BUCK2] = DEFINE_REGU("buck2"), 466 [STPMIC1_BUCK3] = DEFINE_REGU("buck3"), 467 [STPMIC1_BUCK4] = DEFINE_REGU("buck4"), 468 [STPMIC1_LDO1] = DEFINE_REGU("ldo1"), 469 [STPMIC1_LDO2] = DEFINE_REGU("ldo2"), 470 [STPMIC1_LDO3] = DEFINE_REGU("ldo3"), 471 [STPMIC1_LDO4] = DEFINE_REGU("ldo4"), 472 [STPMIC1_LDO5] = DEFINE_REGU("ldo5"), 473 [STPMIC1_LDO6] = DEFINE_REGU("ldo6"), 474 [STPMIC1_VREF_DDR] = DEFINE_REGU("vref_ddr"), 475 [STPMIC1_BOOST] = DEFINE_REGU("boost"), 476 [STPMIC1_VBUS_OTG] = DEFINE_REGU("pwr_sw1"), 477 [STPMIC1_SW_OUT] = DEFINE_REGU("pwr_sw2"), 478 }; 479 480 #define NB_REG ARRAY_SIZE(pmic_regs) 481 482 static int register_pmic(void) 483 { 484 void *fdt; 485 int pmic_node, regulators_node, subnode; 486 487 VERBOSE("Register pmic\n"); 488 489 if (fdt_get_address(&fdt) == 0) { 490 return -FDT_ERR_NOTFOUND; 491 } 492 493 pmic_node = dt_get_pmic_node(fdt); 494 if (pmic_node < 0) { 495 return pmic_node; 496 } 497 498 regulators_node = fdt_subnode_offset(fdt, pmic_node, "regulators"); 499 if (regulators_node < 0) { 500 return -ENOENT; 501 } 502 503 fdt_for_each_subnode(subnode, fdt, regulators_node) { 504 const char *reg_name = fdt_get_name(fdt, subnode, NULL); 505 const struct regul_description *desc; 506 unsigned int i; 507 int ret; 508 509 for (i = 0; i < NB_REG; i++) { 510 desc = &pmic_regs[i]; 511 if (strcmp(desc->node_name, reg_name) == 0) { 512 break; 513 } 514 } 515 assert(i < NB_REG); 516 517 ret = regulator_register(desc, subnode); 518 if (ret != 0) { 519 WARN("%s:%d failed to register %s\n", __func__, 520 __LINE__, reg_name); 521 return ret; 522 } 523 } 524 525 return 0; 526 } 527