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 enum { 333 STPMIC1_BUCK1 = 0, 334 STPMIC1_BUCK2, 335 STPMIC1_BUCK3, 336 STPMIC1_BUCK4, 337 STPMIC1_LDO1, 338 STPMIC1_LDO2, 339 STPMIC1_LDO3, 340 STPMIC1_LDO4, 341 STPMIC1_LDO5, 342 STPMIC1_LDO6, 343 STPMIC1_VREF_DDR, 344 STPMIC1_BOOST, 345 STPMIC1_VBUS_OTG, 346 STPMIC1_SW_OUT, 347 }; 348 349 static int pmic_set_state(const struct regul_description *desc, bool enable) 350 { 351 VERBOSE("%s: set state to %d\n", desc->node_name, enable); 352 353 if (enable == STATE_ENABLE) { 354 return stpmic1_regulator_enable(desc->node_name); 355 } else { 356 return stpmic1_regulator_disable(desc->node_name); 357 } 358 } 359 360 static int pmic_get_state(const struct regul_description *desc) 361 { 362 VERBOSE("%s: get state\n", desc->node_name); 363 364 return stpmic1_is_regulator_enabled(desc->node_name); 365 } 366 367 static int pmic_get_voltage(const struct regul_description *desc) 368 { 369 VERBOSE("%s: get volt\n", desc->node_name); 370 371 return stpmic1_regulator_voltage_get(desc->node_name); 372 } 373 374 static int pmic_set_voltage(const struct regul_description *desc, uint16_t mv) 375 { 376 VERBOSE("%s: get volt\n", desc->node_name); 377 378 return stpmic1_regulator_voltage_set(desc->node_name, mv); 379 } 380 381 static int pmic_list_voltages(const struct regul_description *desc, 382 const uint16_t **levels, size_t *count) 383 { 384 VERBOSE("%s: list volt\n", desc->node_name); 385 386 return stpmic1_regulator_levels_mv(desc->node_name, levels, count); 387 } 388 389 static int pmic_set_flag(const struct regul_description *desc, uint16_t flag) 390 { 391 VERBOSE("%s: set_flag 0x%x\n", desc->node_name, flag); 392 393 switch (flag) { 394 case REGUL_OCP: 395 return stpmic1_regulator_icc_set(desc->node_name); 396 397 case REGUL_ACTIVE_DISCHARGE: 398 return stpmic1_active_discharge_mode_set(desc->node_name); 399 400 case REGUL_PULL_DOWN: 401 return stpmic1_regulator_pull_down_set(desc->node_name); 402 403 case REGUL_MASK_RESET: 404 return stpmic1_regulator_mask_reset_set(desc->node_name); 405 406 case REGUL_SINK_SOURCE: 407 return stpmic1_regulator_sink_mode_set(desc->node_name); 408 409 case REGUL_ENABLE_BYPASS: 410 return stpmic1_regulator_bypass_mode_set(desc->node_name); 411 412 default: 413 return -EINVAL; 414 } 415 } 416 417 static const struct regul_ops pmic_ops = { 418 .set_state = pmic_set_state, 419 .get_state = pmic_get_state, 420 .set_voltage = pmic_set_voltage, 421 .get_voltage = pmic_get_voltage, 422 .list_voltages = pmic_list_voltages, 423 .set_flag = pmic_set_flag, 424 }; 425 426 #define DEFINE_REGU(name) { \ 427 .node_name = name, \ 428 .ops = &pmic_ops, \ 429 .driver_data = NULL, \ 430 .enable_ramp_delay = 1000, \ 431 } 432 433 static const struct regul_description pmic_regs[] = { 434 [STPMIC1_BUCK1] = DEFINE_REGU("buck1"), 435 [STPMIC1_BUCK2] = DEFINE_REGU("buck2"), 436 [STPMIC1_BUCK3] = DEFINE_REGU("buck3"), 437 [STPMIC1_BUCK4] = DEFINE_REGU("buck4"), 438 [STPMIC1_LDO1] = DEFINE_REGU("ldo1"), 439 [STPMIC1_LDO2] = DEFINE_REGU("ldo2"), 440 [STPMIC1_LDO3] = DEFINE_REGU("ldo3"), 441 [STPMIC1_LDO4] = DEFINE_REGU("ldo4"), 442 [STPMIC1_LDO5] = DEFINE_REGU("ldo5"), 443 [STPMIC1_LDO6] = DEFINE_REGU("ldo6"), 444 [STPMIC1_VREF_DDR] = DEFINE_REGU("vref_ddr"), 445 [STPMIC1_BOOST] = DEFINE_REGU("boost"), 446 [STPMIC1_VBUS_OTG] = DEFINE_REGU("pwr_sw1"), 447 [STPMIC1_SW_OUT] = DEFINE_REGU("pwr_sw2"), 448 }; 449 450 #define NB_REG ARRAY_SIZE(pmic_regs) 451 452 static int register_pmic(void) 453 { 454 void *fdt; 455 int pmic_node, regulators_node, subnode; 456 457 VERBOSE("Register pmic\n"); 458 459 if (fdt_get_address(&fdt) == 0) { 460 return -FDT_ERR_NOTFOUND; 461 } 462 463 pmic_node = dt_get_pmic_node(fdt); 464 if (pmic_node < 0) { 465 return pmic_node; 466 } 467 468 regulators_node = fdt_subnode_offset(fdt, pmic_node, "regulators"); 469 if (regulators_node < 0) { 470 return -ENOENT; 471 } 472 473 fdt_for_each_subnode(subnode, fdt, regulators_node) { 474 const char *reg_name = fdt_get_name(fdt, subnode, NULL); 475 const struct regul_description *desc; 476 unsigned int i; 477 int ret; 478 479 for (i = 0; i < NB_REG; i++) { 480 desc = &pmic_regs[i]; 481 if (strcmp(desc->node_name, reg_name) == 0) { 482 break; 483 } 484 } 485 assert(i < NB_REG); 486 487 ret = regulator_register(desc, subnode); 488 if (ret != 0) { 489 WARN("%s:%d failed to register %s\n", __func__, 490 __LINE__, reg_name); 491 return ret; 492 } 493 } 494 495 return 0; 496 } 497