1 /*
2 * Copyright (c) 2017-2024, 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 #define NB_REG 14U
24
25 static struct i2c_handle_s i2c_handle;
26 static uint32_t pmic_i2c_addr;
27
28 static int register_pmic(void);
29
dt_get_pmic_node(void * fdt)30 static int dt_get_pmic_node(void *fdt)
31 {
32 static int node = -FDT_ERR_BADOFFSET;
33
34 if (node == -FDT_ERR_BADOFFSET) {
35 node = fdt_node_offset_by_compatible(fdt, -1, "st,stpmic1");
36 }
37
38 return node;
39 }
40
dt_pmic_status(void)41 int dt_pmic_status(void)
42 {
43 static int status = -FDT_ERR_BADVALUE;
44 int node;
45 void *fdt;
46
47 if (status != -FDT_ERR_BADVALUE) {
48 return status;
49 }
50
51 if (fdt_get_address(&fdt) == 0) {
52 return -ENOENT;
53 }
54
55 node = dt_get_pmic_node(fdt);
56 if (node <= 0) {
57 status = -FDT_ERR_NOTFOUND;
58
59 return status;
60 }
61
62 status = (int)fdt_get_status(node);
63
64 return status;
65 }
66
dt_pmic_is_secure(void)67 static bool dt_pmic_is_secure(void)
68 {
69 int status = dt_pmic_status();
70
71 return (status >= 0) &&
72 (status == DT_SECURE) &&
73 (i2c_handle.dt_status == DT_SECURE);
74 }
75
76 /*
77 * Get PMIC and its I2C bus configuration from the device tree.
78 * Return 0 on success, negative on error, 1 if no PMIC node is defined.
79 */
dt_pmic_i2c_config(struct dt_node_info * i2c_info,struct stm32_i2c_init_s * init)80 static int dt_pmic_i2c_config(struct dt_node_info *i2c_info,
81 struct stm32_i2c_init_s *init)
82 {
83 static int i2c_node = -FDT_ERR_NOTFOUND;
84 void *fdt;
85
86 if (fdt_get_address(&fdt) == 0) {
87 return -FDT_ERR_NOTFOUND;
88 }
89
90 if (i2c_node == -FDT_ERR_NOTFOUND) {
91 int pmic_node;
92 const fdt32_t *cuint;
93
94 pmic_node = dt_get_pmic_node(fdt);
95 if (pmic_node < 0) {
96 return PMIC_NODE_NOT_FOUND;
97 }
98
99 cuint = fdt_getprop(fdt, pmic_node, "reg", NULL);
100 if (cuint == NULL) {
101 return -FDT_ERR_NOTFOUND;
102 }
103
104 pmic_i2c_addr = fdt32_to_cpu(*cuint) << 1;
105 if (pmic_i2c_addr > UINT16_MAX) {
106 return -FDT_ERR_BADVALUE;
107 }
108
109 i2c_node = fdt_parent_offset(fdt, pmic_node);
110 if (i2c_node < 0) {
111 return -FDT_ERR_NOTFOUND;
112 }
113 }
114
115 dt_fill_device_info(i2c_info, i2c_node);
116 if (i2c_info->base == 0U) {
117 return -FDT_ERR_NOTFOUND;
118 }
119
120 return stm32_i2c_get_setup_from_fdt(fdt, i2c_node, init);
121 }
122
initialize_pmic_i2c(void)123 bool initialize_pmic_i2c(void)
124 {
125 int ret;
126 struct dt_node_info i2c_info;
127 struct i2c_handle_s *i2c = &i2c_handle;
128 struct stm32_i2c_init_s i2c_init;
129
130 ret = dt_pmic_i2c_config(&i2c_info, &i2c_init);
131 if (ret < 0) {
132 ERROR("I2C configuration failed %d\n", ret);
133 panic();
134 }
135
136 if (ret != 0) {
137 return false;
138 }
139
140 /* Initialize PMIC I2C */
141 i2c->i2c_base_addr = i2c_info.base;
142 i2c->dt_status = i2c_info.status;
143 i2c->clock = i2c_info.clock;
144 i2c->i2c_state = I2C_STATE_RESET;
145 i2c_init.own_address1 = pmic_i2c_addr;
146 i2c_init.addressing_mode = I2C_ADDRESSINGMODE_7BIT;
147 i2c_init.dual_address_mode = I2C_DUALADDRESS_DISABLE;
148 i2c_init.own_address2 = 0;
149 i2c_init.own_address2_masks = I2C_OAR2_OA2NOMASK;
150 i2c_init.general_call_mode = I2C_GENERALCALL_DISABLE;
151 i2c_init.no_stretch_mode = I2C_NOSTRETCH_DISABLE;
152 i2c_init.analog_filter = 1;
153 i2c_init.digital_filter_coef = 0;
154
155 ret = stm32_i2c_init(i2c, &i2c_init);
156 if (ret != 0) {
157 ERROR("Cannot initialize I2C %x (%d)\n",
158 i2c->i2c_base_addr, ret);
159 panic();
160 }
161
162 if (!stm32_i2c_is_device_ready(i2c, pmic_i2c_addr, 1,
163 I2C_TIMEOUT_BUSY_MS)) {
164 ERROR("I2C device not ready\n");
165 panic();
166 }
167
168 stpmic1_bind_i2c(i2c, (uint16_t)pmic_i2c_addr);
169
170 return true;
171 }
172
register_pmic_shared_peripherals(void)173 static void register_pmic_shared_peripherals(void)
174 {
175 uintptr_t i2c_base = i2c_handle.i2c_base_addr;
176
177 if (dt_pmic_is_secure()) {
178 stm32mp_register_secure_periph_iomem(i2c_base);
179 } else {
180 if (i2c_base != 0U) {
181 stm32mp_register_non_secure_periph_iomem(i2c_base);
182 }
183 }
184 }
185
initialize_pmic(void)186 void initialize_pmic(void)
187 {
188 if (!initialize_pmic_i2c()) {
189 VERBOSE("No PMIC\n");
190 return;
191 }
192
193 register_pmic_shared_peripherals();
194
195 if (register_pmic() < 0) {
196 panic();
197 }
198
199 if (stpmic1_powerctrl_on() < 0) {
200 panic();
201 }
202
203 }
204
205 #if DEBUG
print_pmic_info_and_debug(void)206 void print_pmic_info_and_debug(void)
207 {
208 unsigned long pmic_version;
209
210 if (stpmic1_get_version(&pmic_version) != 0) {
211 ERROR("Failed to access PMIC\n");
212 panic();
213 }
214
215 INFO("PMIC version = 0x%02lx\n", pmic_version);
216 }
217 #endif
218
pmic_voltages_init(void)219 int pmic_voltages_init(void)
220 {
221 #if STM32MP13
222 struct rdev *buck1, *buck4;
223 int status;
224
225 buck1 = regulator_get_by_name("buck1");
226 if (buck1 == NULL) {
227 return -ENOENT;
228 }
229
230 buck4 = regulator_get_by_name("buck4");
231 if (buck4 == NULL) {
232 return -ENOENT;
233 }
234
235 status = regulator_set_min_voltage(buck1);
236 if (status != 0) {
237 return status;
238 }
239
240 status = regulator_set_min_voltage(buck4);
241 if (status != 0) {
242 return status;
243 }
244 #endif
245
246 return 0;
247 }
248
249 enum {
250 STPMIC1_BUCK1 = 0,
251 STPMIC1_BUCK2,
252 STPMIC1_BUCK3,
253 STPMIC1_BUCK4,
254 STPMIC1_LDO1,
255 STPMIC1_LDO2,
256 STPMIC1_LDO3,
257 STPMIC1_LDO4,
258 STPMIC1_LDO5,
259 STPMIC1_LDO6,
260 STPMIC1_VREF_DDR,
261 STPMIC1_BOOST,
262 STPMIC1_VBUS_OTG,
263 STPMIC1_SW_OUT,
264 };
265
pmic_set_state(const struct regul_description * desc,bool enable)266 static int pmic_set_state(const struct regul_description *desc, bool enable)
267 {
268 VERBOSE("%s: set state to %d\n", desc->node_name, enable);
269
270 if (enable == STATE_ENABLE) {
271 return stpmic1_regulator_enable(desc->node_name);
272 } else {
273 return stpmic1_regulator_disable(desc->node_name);
274 }
275 }
276
pmic_get_state(const struct regul_description * desc)277 static int pmic_get_state(const struct regul_description *desc)
278 {
279 VERBOSE("%s: get state\n", desc->node_name);
280
281 return stpmic1_is_regulator_enabled(desc->node_name);
282 }
283
pmic_get_voltage(const struct regul_description * desc)284 static int pmic_get_voltage(const struct regul_description *desc)
285 {
286 VERBOSE("%s: get volt\n", desc->node_name);
287
288 return stpmic1_regulator_voltage_get(desc->node_name);
289 }
290
pmic_set_voltage(const struct regul_description * desc,uint16_t mv)291 static int pmic_set_voltage(const struct regul_description *desc, uint16_t mv)
292 {
293 VERBOSE("%s: get volt\n", desc->node_name);
294
295 return stpmic1_regulator_voltage_set(desc->node_name, mv);
296 }
297
pmic_list_voltages(const struct regul_description * desc,const uint16_t ** levels,size_t * count)298 static int pmic_list_voltages(const struct regul_description *desc,
299 const uint16_t **levels, size_t *count)
300 {
301 VERBOSE("%s: list volt\n", desc->node_name);
302
303 return stpmic1_regulator_levels_mv(desc->node_name, levels, count);
304 }
305
pmic_set_flag(const struct regul_description * desc,uint16_t flag)306 static int pmic_set_flag(const struct regul_description *desc, uint16_t flag)
307 {
308 VERBOSE("%s: set_flag 0x%x\n", desc->node_name, flag);
309
310 switch (flag) {
311 case REGUL_OCP:
312 return stpmic1_regulator_icc_set(desc->node_name);
313
314 case REGUL_ACTIVE_DISCHARGE:
315 return stpmic1_active_discharge_mode_set(desc->node_name);
316
317 case REGUL_PULL_DOWN:
318 return stpmic1_regulator_pull_down_set(desc->node_name);
319
320 case REGUL_MASK_RESET:
321 return stpmic1_regulator_mask_reset_set(desc->node_name);
322
323 case REGUL_SINK_SOURCE:
324 return stpmic1_regulator_sink_mode_set(desc->node_name);
325
326 case REGUL_ENABLE_BYPASS:
327 return stpmic1_regulator_bypass_mode_set(desc->node_name);
328
329 default:
330 return -EINVAL;
331 }
332 }
333
334 static const struct regul_ops pmic_ops = {
335 .set_state = pmic_set_state,
336 .get_state = pmic_get_state,
337 .set_voltage = pmic_set_voltage,
338 .get_voltage = pmic_get_voltage,
339 .list_voltages = pmic_list_voltages,
340 .set_flag = pmic_set_flag,
341 };
342
343 #define DEFINE_REGU(name) { \
344 .node_name = (name), \
345 .ops = &pmic_ops, \
346 .driver_data = NULL, \
347 .enable_ramp_delay = 1000, \
348 }
349
350 static const struct regul_description pmic_regs[NB_REG] = {
351 [STPMIC1_BUCK1] = DEFINE_REGU("buck1"),
352 [STPMIC1_BUCK2] = DEFINE_REGU("buck2"),
353 [STPMIC1_BUCK3] = DEFINE_REGU("buck3"),
354 [STPMIC1_BUCK4] = DEFINE_REGU("buck4"),
355 [STPMIC1_LDO1] = DEFINE_REGU("ldo1"),
356 [STPMIC1_LDO2] = DEFINE_REGU("ldo2"),
357 [STPMIC1_LDO3] = DEFINE_REGU("ldo3"),
358 [STPMIC1_LDO4] = DEFINE_REGU("ldo4"),
359 [STPMIC1_LDO5] = DEFINE_REGU("ldo5"),
360 [STPMIC1_LDO6] = DEFINE_REGU("ldo6"),
361 [STPMIC1_VREF_DDR] = DEFINE_REGU("vref_ddr"),
362 [STPMIC1_BOOST] = DEFINE_REGU("boost"),
363 [STPMIC1_VBUS_OTG] = DEFINE_REGU("pwr_sw1"),
364 [STPMIC1_SW_OUT] = DEFINE_REGU("pwr_sw2"),
365 };
366
register_pmic(void)367 static int register_pmic(void)
368 {
369 void *fdt;
370 int pmic_node, regulators_node, subnode;
371
372 VERBOSE("Register pmic\n");
373
374 if (fdt_get_address(&fdt) == 0) {
375 return -FDT_ERR_NOTFOUND;
376 }
377
378 pmic_node = dt_get_pmic_node(fdt);
379 if (pmic_node < 0) {
380 return pmic_node;
381 }
382
383 regulators_node = fdt_subnode_offset(fdt, pmic_node, "regulators");
384 if (regulators_node < 0) {
385 return -ENOENT;
386 }
387
388 fdt_for_each_subnode(subnode, fdt, regulators_node) {
389 const char *reg_name = fdt_get_name(fdt, subnode, NULL);
390 const struct regul_description *desc;
391 unsigned int i;
392 int ret;
393
394 for (i = 0U; i < NB_REG; i++) {
395 desc = &pmic_regs[i];
396 if (strcmp(desc->node_name, reg_name) == 0) {
397 break;
398 }
399 }
400 assert(i < NB_REG);
401
402 ret = regulator_register(desc, subnode);
403 if (ret != 0) {
404 WARN("%s:%d failed to register %s\n", __func__,
405 __LINE__, reg_name);
406 return ret;
407 }
408 }
409
410 return 0;
411 }
412