blob: 6a30dce4ac46a12f688ee3fa5100e20583de026f [file] [log] [blame]
Yann Gautierbb836ee2018-07-16 17:55:07 +02001/*
Benjamin Gaignard53ee7d32020-02-24 13:57:40 +01002 * Copyright (c) 2017-2021, STMicroelectronics - All Rights Reserved
Yann Gautierbb836ee2018-07-16 17:55:07 +02003 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
Yann Gautiere6f10322021-09-27 14:31:40 +02007#include <assert.h>
Yann Gautierbb836ee2018-07-16 17:55:07 +02008#include <errno.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +00009
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000010#include <common/debug.h>
11#include <drivers/delay_timer.h>
Yann Gautiere6f10322021-09-27 14:31:40 +020012#include <drivers/st/regulator.h>
Yann Gautierf3928f62019-02-14 11:15:03 +010013#include <drivers/st/stm32_i2c.h>
Yann Gautiera45433b2019-01-16 18:31:00 +010014#include <drivers/st/stm32mp_pmic.h>
Yann Gautiera45433b2019-01-16 18:31:00 +010015#include <drivers/st/stpmic1.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000016#include <lib/mmio.h>
17#include <lib/utils_def.h>
Nicolas Le Bayonf5188ee2019-09-19 11:24:50 +020018#include <libfdt.h>
19
20#include <platform_def.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000021
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010022#define PMIC_NODE_NOT_FOUND 1
Yann Gautierbb836ee2018-07-16 17:55:07 +020023
24static struct i2c_handle_s i2c_handle;
25static uint32_t pmic_i2c_addr;
26
Yann Gautiere6f10322021-09-27 14:31:40 +020027static int register_pmic(void);
28
Yann Gautierbb836ee2018-07-16 17:55:07 +020029static int dt_get_pmic_node(void *fdt)
30{
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010031 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;
Yann Gautierbb836ee2018-07-16 17:55:07 +020038}
39
Yann Gautierf3928f62019-02-14 11:15:03 +010040int dt_pmic_status(void)
Yann Gautierbb836ee2018-07-16 17:55:07 +020041{
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010042 static int status = -FDT_ERR_BADVALUE;
Yann Gautierbb836ee2018-07-16 17:55:07 +020043 int node;
44 void *fdt;
45
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010046 if (status != -FDT_ERR_BADVALUE) {
47 return status;
48 }
49
Yann Gautierbb836ee2018-07-16 17:55:07 +020050 if (fdt_get_address(&fdt) == 0) {
Yann Gautierf3928f62019-02-14 11:15:03 +010051 return -ENOENT;
Yann Gautierbb836ee2018-07-16 17:55:07 +020052 }
53
54 node = dt_get_pmic_node(fdt);
Yann Gautierf3928f62019-02-14 11:15:03 +010055 if (node <= 0) {
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010056 status = -FDT_ERR_NOTFOUND;
57
58 return status;
Yann Gautierbb836ee2018-07-16 17:55:07 +020059 }
60
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010061 status = (int)fdt_get_status(node);
62
63 return status;
Yann Gautierbb836ee2018-07-16 17:55:07 +020064}
65
Etienne Carriere67b106a2019-12-02 10:10:08 +010066static 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
Yann Gautierf3928f62019-02-14 11:15:03 +010075/*
76 * Get PMIC and its I2C bus configuration from the device tree.
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010077 * Return 0 on success, negative on error, 1 if no PMIC node is defined.
Yann Gautierf3928f62019-02-14 11:15:03 +010078 */
79static int dt_pmic_i2c_config(struct dt_node_info *i2c_info,
80 struct stm32_i2c_init_s *init)
Yann Gautierbb836ee2018-07-16 17:55:07 +020081{
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010082 static int i2c_node = -FDT_ERR_NOTFOUND;
Yann Gautierbb836ee2018-07-16 17:55:07 +020083 void *fdt;
Yann Gautierbb836ee2018-07-16 17:55:07 +020084
85 if (fdt_get_address(&fdt) == 0) {
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010086 return -FDT_ERR_NOTFOUND;
Yann Gautierbb836ee2018-07-16 17:55:07 +020087 }
88
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010089 if (i2c_node == -FDT_ERR_NOTFOUND) {
90 int pmic_node;
91 const fdt32_t *cuint;
Yann Gautierbb836ee2018-07-16 17:55:07 +020092
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010093 pmic_node = dt_get_pmic_node(fdt);
94 if (pmic_node < 0) {
95 return PMIC_NODE_NOT_FOUND;
96 }
Yann Gautierbb836ee2018-07-16 17:55:07 +020097
Nicolas Le Bayon342865a2019-11-15 15:56:06 +010098 cuint = fdt_getprop(fdt, pmic_node, "reg", NULL);
99 if (cuint == NULL) {
100 return -FDT_ERR_NOTFOUND;
101 }
Yann Gautierbb836ee2018-07-16 17:55:07 +0200102
Nicolas Le Bayon342865a2019-11-15 15:56:06 +0100103 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 }
Yann Gautierbb836ee2018-07-16 17:55:07 +0200112 }
113
114 dt_fill_device_info(i2c_info, i2c_node);
115 if (i2c_info->base == 0U) {
116 return -FDT_ERR_NOTFOUND;
117 }
118
Yann Gautierf3928f62019-02-14 11:15:03 +0100119 return stm32_i2c_get_setup_from_fdt(fdt, i2c_node, init);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200120}
121
Yann Gautierf3928f62019-02-14 11:15:03 +0100122bool initialize_pmic_i2c(void)
Yann Gautierbb836ee2018-07-16 17:55:07 +0200123{
124 int ret;
125 struct dt_node_info i2c_info;
Yann Gautierf3928f62019-02-14 11:15:03 +0100126 struct i2c_handle_s *i2c = &i2c_handle;
127 struct stm32_i2c_init_s i2c_init;
Yann Gautierbb836ee2018-07-16 17:55:07 +0200128
Yann Gautierf3928f62019-02-14 11:15:03 +0100129 ret = dt_pmic_i2c_config(&i2c_info, &i2c_init);
130 if (ret < 0) {
131 ERROR("I2C configuration failed %d\n", ret);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200132 panic();
133 }
134
Yann Gautierf3928f62019-02-14 11:15:03 +0100135 if (ret != 0) {
136 return false;
Yann Gautierbb836ee2018-07-16 17:55:07 +0200137 }
138
139 /* Initialize PMIC I2C */
Yann Gautierf3928f62019-02-14 11:15:03 +0100140 i2c->i2c_base_addr = i2c_info.base;
141 i2c->dt_status = i2c_info.status;
142 i2c->clock = i2c_info.clock;
Benjamin Gaignard53ee7d32020-02-24 13:57:40 +0100143 i2c->i2c_state = I2C_STATE_RESET;
Yann Gautierf3928f62019-02-14 11:15:03 +0100144 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;
Yann Gautierbb836ee2018-07-16 17:55:07 +0200153
Yann Gautierf3928f62019-02-14 11:15:03 +0100154 ret = stm32_i2c_init(i2c, &i2c_init);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200155 if (ret != 0) {
156 ERROR("Cannot initialize I2C %x (%d)\n",
Yann Gautierf3928f62019-02-14 11:15:03 +0100157 i2c->i2c_base_addr, ret);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200158 panic();
159 }
160
Yann Gautierf3928f62019-02-14 11:15:03 +0100161 if (!stm32_i2c_is_device_ready(i2c, pmic_i2c_addr, 1,
162 I2C_TIMEOUT_BUSY_MS)) {
163 ERROR("I2C device not ready\n");
Yann Gautierbb836ee2018-07-16 17:55:07 +0200164 panic();
165 }
166
Yann Gautierf3928f62019-02-14 11:15:03 +0100167 stpmic1_bind_i2c(i2c, (uint16_t)pmic_i2c_addr);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200168
Yann Gautierf3928f62019-02-14 11:15:03 +0100169 return true;
Yann Gautierbb836ee2018-07-16 17:55:07 +0200170}
171
Etienne Carriere67b106a2019-12-02 10:10:08 +0100172static 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
Yann Gautierbb836ee2018-07-16 17:55:07 +0200185void initialize_pmic(void)
186{
Yann Gautierf3928f62019-02-14 11:15:03 +0100187 if (!initialize_pmic_i2c()) {
188 VERBOSE("No PMIC\n");
189 return;
190 }
Yann Gautierbb836ee2018-07-16 17:55:07 +0200191
Etienne Carriere67b106a2019-12-02 10:10:08 +0100192 register_pmic_shared_peripherals();
193
Yann Gautiere6f10322021-09-27 14:31:40 +0200194 if (register_pmic() < 0) {
Nicolas Le Bayon0b10b652019-11-18 13:13:36 +0100195 panic();
Yann Gautiere6f10322021-09-27 14:31:40 +0200196 }
197
198 if (stpmic1_powerctrl_on() < 0) {
199 panic();
200 }
201
Nicolas Le Bayon0b10b652019-11-18 13:13:36 +0100202}
203
204#if DEBUG
205void print_pmic_info_and_debug(void)
206{
207 unsigned long pmic_version;
208
Yann Gautierf3928f62019-02-14 11:15:03 +0100209 if (stpmic1_get_version(&pmic_version) != 0) {
210 ERROR("Failed to access PMIC\n");
Yann Gautierbb836ee2018-07-16 17:55:07 +0200211 panic();
212 }
213
Yann Gautierf3928f62019-02-14 11:15:03 +0100214 INFO("PMIC version = 0x%02lx\n", pmic_version);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200215}
Nicolas Le Bayon0b10b652019-11-18 13:13:36 +0100216#endif
Yann Gautierbb836ee2018-07-16 17:55:07 +0200217
218int pmic_ddr_power_init(enum ddr_type ddr_type)
219{
Yann Gautierbb836ee2018-07-16 17:55:07 +0200220 int status;
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100221 uint16_t buck3_min_mv;
222 struct rdev *buck2, *buck3, *ldo3, *vref;
223
224 buck2 = regulator_get_by_name("buck2");
225 if (buck2 == NULL) {
226 return -ENOENT;
227 }
228
229 ldo3 = regulator_get_by_name("ldo3");
230 if (ldo3 == NULL) {
231 return -ENOENT;
232 }
233
234 vref = regulator_get_by_name("vref_ddr");
235 if (vref == NULL) {
236 return -ENOENT;
237 }
Yann Gautierbb836ee2018-07-16 17:55:07 +0200238
239 switch (ddr_type) {
240 case STM32MP_DDR3:
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100241 status = regulator_set_flag(ldo3, REGUL_SINK_SOURCE);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200242 if (status != 0) {
243 return status;
244 }
245
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100246 status = regulator_set_min_voltage(buck2);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200247 if (status != 0) {
248 return status;
249 }
250
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100251 status = regulator_enable(buck2);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200252 if (status != 0) {
253 return status;
254 }
255
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100256 status = regulator_enable(vref);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200257 if (status != 0) {
258 return status;
259 }
260
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100261 status = regulator_enable(ldo3);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200262 if (status != 0) {
263 return status;
264 }
Yann Gautierbb836ee2018-07-16 17:55:07 +0200265 break;
266
267 case STM32MP_LPDDR2:
Yann Gautier917a00c2019-04-16 16:20:58 +0200268 case STM32MP_LPDDR3:
Yann Gautierbb836ee2018-07-16 17:55:07 +0200269 /*
270 * Set LDO3 to 1.8V
271 * Set LDO3 to bypass mode if BUCK3 = 1.8V
272 * Set LDO3 to normal mode if BUCK3 != 1.8V
273 */
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100274 buck3 = regulator_get_by_name("buck3");
275 if (buck3 == NULL) {
276 return -ENOENT;
Yann Gautierbb836ee2018-07-16 17:55:07 +0200277 }
278
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100279 regulator_get_range(buck3, &buck3_min_mv, NULL);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200280
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100281 if (buck3_min_mv != 1800) {
282 status = regulator_set_min_voltage(ldo3);
283 if (status != 0) {
284 return status;
285 }
286 } else {
287 status = regulator_set_flag(ldo3, REGUL_ENABLE_BYPASS);
288 if (status != 0) {
289 return status;
290 }
Yann Gautierbb836ee2018-07-16 17:55:07 +0200291 }
292
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100293 status = regulator_set_min_voltage(buck2);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200294 if (status != 0) {
295 return status;
296 }
297
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100298 status = regulator_enable(ldo3);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200299 if (status != 0) {
300 return status;
301 }
302
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100303 status = regulator_enable(buck2);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200304 if (status != 0) {
305 return status;
306 }
307
Pascal Paillet5e36dbb2020-12-15 19:05:09 +0100308 status = regulator_enable(vref);
Yann Gautierbb836ee2018-07-16 17:55:07 +0200309 if (status != 0) {
310 return status;
311 }
Yann Gautierbb836ee2018-07-16 17:55:07 +0200312 break;
313
314 default:
315 break;
316 };
317
318 return 0;
319}
Yann Gautiere6f10322021-09-27 14:31:40 +0200320
321enum {
322 STPMIC1_BUCK1 = 0,
323 STPMIC1_BUCK2,
324 STPMIC1_BUCK3,
325 STPMIC1_BUCK4,
326 STPMIC1_LDO1,
327 STPMIC1_LDO2,
328 STPMIC1_LDO3,
329 STPMIC1_LDO4,
330 STPMIC1_LDO5,
331 STPMIC1_LDO6,
332 STPMIC1_VREF_DDR,
333 STPMIC1_BOOST,
334 STPMIC1_VBUS_OTG,
335 STPMIC1_SW_OUT,
336};
337
338static int pmic_set_state(const struct regul_description *desc, bool enable)
339{
340 VERBOSE("%s: set state to %u\n", desc->node_name, enable);
341
342 if (enable == STATE_ENABLE) {
343 return stpmic1_regulator_enable(desc->node_name);
344 } else {
345 return stpmic1_regulator_disable(desc->node_name);
346 }
347}
348
349static int pmic_get_state(const struct regul_description *desc)
350{
351 VERBOSE("%s: get state\n", desc->node_name);
352
353 return stpmic1_is_regulator_enabled(desc->node_name);
354}
355
356static int pmic_get_voltage(const struct regul_description *desc)
357{
358 VERBOSE("%s: get volt\n", desc->node_name);
359
360 return stpmic1_regulator_voltage_get(desc->node_name);
361}
362
363static int pmic_set_voltage(const struct regul_description *desc, uint16_t mv)
364{
365 VERBOSE("%s: get volt\n", desc->node_name);
366
367 return stpmic1_regulator_voltage_set(desc->node_name, mv);
368}
369
370static int pmic_list_voltages(const struct regul_description *desc,
371 const uint16_t **levels, size_t *count)
372{
373 VERBOSE("%s: list volt\n", desc->node_name);
374
375 return stpmic1_regulator_levels_mv(desc->node_name, levels, count);
376}
377
378static int pmic_set_flag(const struct regul_description *desc, uint16_t flag)
379{
380 VERBOSE("%s: set_flag 0x%x\n", desc->node_name, flag);
381
382 switch (flag) {
383 case REGUL_OCP:
384 return stpmic1_regulator_icc_set(desc->node_name);
385
386 case REGUL_ACTIVE_DISCHARGE:
387 return stpmic1_active_discharge_mode_set(desc->node_name);
388
389 case REGUL_PULL_DOWN:
390 return stpmic1_regulator_pull_down_set(desc->node_name);
391
392 case REGUL_MASK_RESET:
393 return stpmic1_regulator_mask_reset_set(desc->node_name);
394
395 case REGUL_SINK_SOURCE:
396 return stpmic1_regulator_sink_mode_set(desc->node_name);
397
398 case REGUL_ENABLE_BYPASS:
399 return stpmic1_regulator_bypass_mode_set(desc->node_name);
400
401 default:
402 return -EINVAL;
403 }
404}
405
406struct regul_ops pmic_ops = {
407 .set_state = pmic_set_state,
408 .get_state = pmic_get_state,
409 .set_voltage = pmic_set_voltage,
410 .get_voltage = pmic_get_voltage,
411 .list_voltages = pmic_list_voltages,
412 .set_flag = pmic_set_flag,
413};
414
415#define DEFINE_REGU(name) { \
416 .node_name = name, \
417 .ops = &pmic_ops, \
418 .driver_data = NULL, \
419 .enable_ramp_delay = 1000, \
420}
421
422static const struct regul_description pmic_regs[] = {
423 [STPMIC1_BUCK1] = DEFINE_REGU("buck1"),
424 [STPMIC1_BUCK2] = DEFINE_REGU("buck2"),
425 [STPMIC1_BUCK3] = DEFINE_REGU("buck3"),
426 [STPMIC1_BUCK4] = DEFINE_REGU("buck4"),
427 [STPMIC1_LDO1] = DEFINE_REGU("ldo1"),
428 [STPMIC1_LDO2] = DEFINE_REGU("ldo2"),
429 [STPMIC1_LDO3] = DEFINE_REGU("ldo3"),
430 [STPMIC1_LDO4] = DEFINE_REGU("ldo4"),
431 [STPMIC1_LDO5] = DEFINE_REGU("ldo5"),
432 [STPMIC1_LDO6] = DEFINE_REGU("ldo6"),
433 [STPMIC1_VREF_DDR] = DEFINE_REGU("vref_ddr"),
434 [STPMIC1_BOOST] = DEFINE_REGU("boost"),
435 [STPMIC1_VBUS_OTG] = DEFINE_REGU("pwr_sw1"),
436 [STPMIC1_SW_OUT] = DEFINE_REGU("pwr_sw2"),
437};
438
439#define NB_REG ARRAY_SIZE(pmic_regs)
440
441static int register_pmic(void)
442{
443 void *fdt;
444 int pmic_node, regulators_node, subnode;
445
446 VERBOSE("Register pmic\n");
447
448 if (fdt_get_address(&fdt) == 0) {
449 return -FDT_ERR_NOTFOUND;
450 }
451
452 pmic_node = dt_get_pmic_node(fdt);
453 if (pmic_node < 0) {
454 return pmic_node;
455 }
456
457 regulators_node = fdt_subnode_offset(fdt, pmic_node, "regulators");
458 if (regulators_node < 0) {
459 return -ENOENT;
460 }
461
462 fdt_for_each_subnode(subnode, fdt, regulators_node) {
463 const char *reg_name = fdt_get_name(fdt, subnode, NULL);
464 const struct regul_description *desc;
465 unsigned int i;
466 int ret;
467
468 for (i = 0; i < NB_REG; i++) {
469 desc = &pmic_regs[i];
470 if (strcmp(desc->node_name, reg_name) == 0) {
471 break;
472 }
473 }
474 assert(i < NB_REG);
475
476 ret = regulator_register(desc, subnode);
477 if (ret != 0) {
478 WARN("%s:%d failed to register %s\n", __func__,
479 __LINE__, reg_name);
480 return ret;
481 }
482 }
483
484 return 0;
485}