1 /*
2 * Copyright (C) 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_pmic2.h>
15 #include <drivers/st/stpmic2.h>
16 #include <lib/mmio.h>
17 #include <lib/spinlock.h>
18 #include <lib/utils_def.h>
19 #include <libfdt.h>
20
21 #include <platform_def.h>
22
23 #define PMIC_NODE_NOT_FOUND 1
24
25 struct regul_handle_s {
26 const uint32_t id;
27 uint16_t bypass_mv;
28 };
29
30 static struct pmic_handle_s pmic2_handle;
31 static struct i2c_handle_s i2c_handle;
32
33 /* This driver is monoinstance */
34 static struct pmic_handle_s *pmic2;
35
dt_get_pmic_node(void * fdt)36 static int dt_get_pmic_node(void *fdt)
37 {
38 static int node = -FDT_ERR_BADOFFSET;
39
40 if (node == -FDT_ERR_BADOFFSET) {
41 node = fdt_node_offset_by_compatible(fdt, -1, "st,stpmic2");
42 }
43
44 return node;
45 }
46
dt_pmic_status(void)47 int dt_pmic_status(void)
48 {
49 static int status = -FDT_ERR_BADVALUE;
50 int node;
51 void *fdt;
52
53 if (status != -FDT_ERR_BADVALUE) {
54 return status;
55 }
56
57 if (fdt_get_address(&fdt) == 0) {
58 return -ENOENT;
59 }
60
61 node = dt_get_pmic_node(fdt);
62 if (node <= 0) {
63 status = -FDT_ERR_NOTFOUND;
64
65 return status;
66 }
67
68 status = DT_SECURE;
69
70 return status;
71 }
72
73 /*
74 * Get PMIC and its I2C bus configuration from the device tree.
75 * Return 0 on success, negative on error, 1 if no PMIC node is defined.
76 */
dt_pmic2_i2c_config(struct dt_node_info * i2c_info,struct stm32_i2c_init_s * init,uint32_t * i2c_addr)77 static int dt_pmic2_i2c_config(struct dt_node_info *i2c_info,
78 struct stm32_i2c_init_s *init,
79 uint32_t *i2c_addr)
80 {
81 static int i2c_node = -FDT_ERR_NOTFOUND;
82 void *fdt;
83
84 if (fdt_get_address(&fdt) == 0) {
85 return -FDT_ERR_NOTFOUND;
86 }
87
88 if (i2c_node == -FDT_ERR_NOTFOUND) {
89 int pmic_node;
90 const fdt32_t *cuint;
91
92 pmic_node = dt_get_pmic_node(fdt);
93 if (pmic_node < 0) {
94 return PMIC_NODE_NOT_FOUND;
95 }
96
97 cuint = fdt_getprop(fdt, pmic_node, "reg", NULL);
98 if (cuint == NULL) {
99 return -FDT_ERR_NOTFOUND;
100 }
101
102 *i2c_addr = fdt32_to_cpu(*cuint) << 1;
103 if (*i2c_addr > UINT16_MAX) {
104 return -FDT_ERR_BADVALUE;
105 }
106
107 i2c_node = fdt_parent_offset(fdt, pmic_node);
108 if (i2c_node < 0) {
109 return -FDT_ERR_NOTFOUND;
110 }
111 }
112
113 dt_fill_device_info(i2c_info, i2c_node);
114 if (i2c_info->base == 0U) {
115 return -FDT_ERR_NOTFOUND;
116 }
117
118 i2c_info->status = DT_SECURE;
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 uint32_t i2c_addr = 0U;
129 struct stm32_i2c_init_s i2c_init;
130
131 ret = dt_pmic2_i2c_config(&i2c_info, &i2c_init, &i2c_addr);
132 if (ret < 0) {
133 ERROR("I2C configuration failed %d\n", ret);
134 panic();
135 }
136
137 if (ret != 0) {
138 return false;
139 }
140
141 /* Initialize PMIC I2C */
142 i2c->i2c_base_addr = i2c_info.base;
143 i2c->dt_status = i2c_info.status;
144 i2c->clock = i2c_info.clock;
145 i2c->i2c_state = I2C_STATE_RESET;
146 i2c_init.own_address1 = i2c_addr;
147 i2c_init.addressing_mode = I2C_ADDRESSINGMODE_7BIT;
148 i2c_init.dual_address_mode = I2C_DUALADDRESS_DISABLE;
149 i2c_init.own_address2 = 0;
150 i2c_init.own_address2_masks = I2C_OAR2_OA2NOMASK;
151 i2c_init.general_call_mode = I2C_GENERALCALL_DISABLE;
152 i2c_init.no_stretch_mode = I2C_NOSTRETCH_DISABLE;
153 i2c_init.analog_filter = 1;
154 i2c_init.digital_filter_coef = 0;
155
156 ret = stm32_i2c_init(i2c, &i2c_init);
157 if (ret != 0) {
158 ERROR("Cannot initialize I2C %x (%d)\n",
159 i2c->i2c_base_addr, ret);
160 panic();
161 }
162
163 if (!stm32_i2c_is_device_ready(i2c, i2c_addr, 1,
164 I2C_TIMEOUT_BUSY_MS)) {
165 ERROR("I2C device not ready\n");
166 panic();
167 }
168
169 pmic2 = &pmic2_handle;
170 pmic2->i2c_handle = &i2c_handle;
171 pmic2->i2c_addr = i2c_addr;
172
173 return true;
174 }
175
pmic2_set_state(const struct regul_description * desc,bool enable)176 static int pmic2_set_state(const struct regul_description *desc, bool enable)
177 {
178 struct regul_handle_s *regul = (struct regul_handle_s *)desc->driver_data;
179
180 VERBOSE("%s: set state to %d\n", desc->node_name, enable);
181
182 return stpmic2_regulator_set_state(pmic2, regul->id, enable);
183 }
184
pmic2_get_state(const struct regul_description * desc)185 static int pmic2_get_state(const struct regul_description *desc)
186 {
187 struct regul_handle_s *regul = (struct regul_handle_s *)desc->driver_data;
188 bool enabled;
189
190 VERBOSE("%s: get state\n", desc->node_name);
191
192 if (stpmic2_regulator_get_state(pmic2, regul->id, &enabled) < 0) {
193 panic();
194 }
195
196 return enabled;
197 }
198
pmic2_get_voltage(const struct regul_description * desc)199 static int pmic2_get_voltage(const struct regul_description *desc)
200 {
201 struct regul_handle_s *regul = (struct regul_handle_s *)desc->driver_data;
202 uint16_t mv;
203
204 VERBOSE("%s: get volt\n", desc->node_name);
205
206 if (regul->bypass_mv != 0U) {
207 int ret;
208
209 /* If the regul is in bypass mode, return bypass value */
210 ret = stpmic2_regulator_get_prop(pmic2, regul->id, STPMIC2_BYPASS);
211 if (ret < 0) {
212 return ret;
213 }
214
215 if (ret == 1) {
216 return regul->bypass_mv;
217 }
218 };
219
220 if (stpmic2_regulator_get_voltage(pmic2, regul->id, &mv) < 0) {
221 panic();
222 }
223
224 return mv;
225 }
226
pmic2_set_voltage(const struct regul_description * desc,uint16_t mv)227 static int pmic2_set_voltage(const struct regul_description *desc, uint16_t mv)
228 {
229 struct regul_handle_s *regul = (struct regul_handle_s *)desc->driver_data;
230
231 VERBOSE("%s: set volt\n", desc->node_name);
232
233 if (regul->bypass_mv != 0U) {
234 int ret;
235
236 /* If the regul is in bypass mode, authorize bypass mV */
237 ret = stpmic2_regulator_get_prop(pmic2, regul->id, STPMIC2_BYPASS);
238 if (ret < 0) {
239 return ret;
240 }
241
242 if ((ret == 1) && (mv != regul->bypass_mv)) {
243 return -EPERM;
244 }
245 };
246
247 return stpmic2_regulator_set_voltage(pmic2, regul->id, mv);
248 }
249
pmic2_list_voltages(const struct regul_description * desc,const uint16_t ** levels,size_t * count)250 static int pmic2_list_voltages(const struct regul_description *desc,
251 const uint16_t **levels, size_t *count)
252 {
253 struct regul_handle_s *regul = (struct regul_handle_s *)desc->driver_data;
254
255 VERBOSE("%s: list volt\n", desc->node_name);
256
257 if (regul->bypass_mv != 0U) {
258 int ret;
259
260 ret = stpmic2_regulator_get_prop(pmic2, regul->id, STPMIC2_BYPASS);
261 if (ret < 0) {
262 return ret;
263 }
264
265 /* bypass is enabled, return a list with only bypass mV */
266 if (ret == 1) {
267 if (count != NULL) {
268 *count = 1U;
269 }
270 if (levels != NULL) {
271 *levels = ®ul->bypass_mv;
272 }
273 return 0;
274 }
275 };
276
277 return stpmic2_regulator_levels_mv(pmic2, regul->id, levels, count);
278 }
279
pmic2_set_flag(const struct regul_description * desc,uint16_t flag)280 static int pmic2_set_flag(const struct regul_description *desc, uint16_t flag)
281 {
282 struct regul_handle_s *regul = (struct regul_handle_s *)desc->driver_data;
283 uint32_t id = regul->id;
284 int ret = -EPERM;
285
286 VERBOSE("%s: set_flag 0x%x\n", desc->node_name, flag);
287
288 switch (flag) {
289 case REGUL_PULL_DOWN:
290 ret = stpmic2_regulator_set_prop(pmic2, id, STPMIC2_PULL_DOWN, 1U);
291 break;
292 case REGUL_OCP:
293 ret = stpmic2_regulator_set_prop(pmic2, id, STPMIC2_OCP, 1U);
294 break;
295 case REGUL_SINK_SOURCE:
296 ret = stpmic2_regulator_set_prop(pmic2, id, STPMIC2_SINK_SOURCE, 1U);
297 break;
298 case REGUL_ENABLE_BYPASS:
299 ret = stpmic2_regulator_set_prop(pmic2, id, STPMIC2_BYPASS, 1U);
300 break;
301 case REGUL_MASK_RESET:
302 ret = stpmic2_regulator_set_prop(pmic2, id, STPMIC2_MASK_RESET, 1U);
303 break;
304 default:
305 ERROR("Invalid flag %u", flag);
306 panic();
307 }
308
309 if (ret != 0) {
310 return -EPERM;
311 }
312
313 return 0;
314 }
315
stpmic2_set_prop(const struct regul_description * desc,uint16_t prop,uint32_t value)316 int stpmic2_set_prop(const struct regul_description *desc, uint16_t prop, uint32_t value)
317 {
318 struct regul_handle_s *regul = (struct regul_handle_s *)desc->driver_data;
319 int ret;
320
321 VERBOSE("%s: set_prop 0x%x val=%u\n", desc->node_name, prop, value);
322
323 ret = stpmic2_regulator_set_prop(pmic2, regul->id, prop, value);
324 if (ret != 0)
325 return -EPERM;
326
327 return 0;
328 }
329
330 static struct regul_ops pmic2_ops = {
331 .set_state = pmic2_set_state,
332 .get_state = pmic2_get_state,
333 .set_voltage = pmic2_set_voltage,
334 .get_voltage = pmic2_get_voltage,
335 .list_voltages = pmic2_list_voltages,
336 .set_flag = pmic2_set_flag,
337 };
338
339 #define DEFINE_PMIC_REGUL_HANDLE(rid) \
340 [(rid)] = { \
341 .id = (rid), \
342 }
343
344 static struct regul_handle_s pmic2_regul_handles[STPMIC2_NB_REG] = {
345 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_BUCK1),
346 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_BUCK2),
347 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_BUCK3),
348 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_BUCK4),
349 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_BUCK5),
350 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_BUCK6),
351 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_BUCK7),
352
353 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_LDO1),
354 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_LDO2),
355 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_LDO3),
356 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_LDO4),
357 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_LDO5),
358 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_LDO6),
359 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_LDO7),
360 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_LDO8),
361
362 DEFINE_PMIC_REGUL_HANDLE(STPMIC2_REFDDR),
363 };
364
365 #define DEFINE_REGUL(rid, name) \
366 [rid] = { \
367 .node_name = name, \
368 .ops = &pmic2_ops, \
369 .driver_data = &pmic2_regul_handles[rid], \
370 }
371
372 static const struct regul_description pmic2_descs[STPMIC2_NB_REG] = {
373 DEFINE_REGUL(STPMIC2_BUCK1, "buck1"),
374 DEFINE_REGUL(STPMIC2_BUCK2, "buck2"),
375 DEFINE_REGUL(STPMIC2_BUCK3, "buck3"),
376 DEFINE_REGUL(STPMIC2_BUCK4, "buck4"),
377 DEFINE_REGUL(STPMIC2_BUCK5, "buck5"),
378 DEFINE_REGUL(STPMIC2_BUCK6, "buck6"),
379 DEFINE_REGUL(STPMIC2_BUCK7, "buck7"),
380
381 DEFINE_REGUL(STPMIC2_LDO1, "ldo1"),
382 DEFINE_REGUL(STPMIC2_LDO2, "ldo2"),
383 DEFINE_REGUL(STPMIC2_LDO3, "ldo3"),
384 DEFINE_REGUL(STPMIC2_LDO4, "ldo4"),
385 DEFINE_REGUL(STPMIC2_LDO5, "ldo5"),
386 DEFINE_REGUL(STPMIC2_LDO6, "ldo6"),
387 DEFINE_REGUL(STPMIC2_LDO7, "ldo7"),
388 DEFINE_REGUL(STPMIC2_LDO8, "ldo8"),
389
390 DEFINE_REGUL(STPMIC2_REFDDR, "refddr"),
391 };
392
register_pmic2(void)393 static int register_pmic2(void)
394 {
395 void *fdt;
396 int pmic_node, regulators_node, subnode;
397
398 VERBOSE("Register pmic2\n");
399
400 if (fdt_get_address(&fdt) == 0) {
401 return -FDT_ERR_NOTFOUND;
402 }
403
404 pmic_node = dt_get_pmic_node(fdt);
405 if (pmic_node < 0) {
406 return pmic_node;
407 }
408
409 regulators_node = fdt_subnode_offset(fdt, pmic_node, "regulators");
410 if (regulators_node < 0) {
411 return -ENOENT;
412 }
413
414 fdt_for_each_subnode(subnode, fdt, regulators_node) {
415 const char *reg_name = fdt_get_name(fdt, subnode, NULL);
416 const struct regul_description *desc;
417 unsigned int i;
418 int ret;
419 const fdt32_t *cuint;
420
421 for (i = 0; i < STPMIC2_NB_REG; i++) {
422 desc = &pmic2_descs[i];
423 if (strcmp(desc->node_name, reg_name) == 0) {
424 break;
425 }
426 }
427 assert(i < STPMIC2_NB_REG);
428
429 ret = regulator_register(desc, subnode);
430 if (ret != 0) {
431 WARN("%s:%d failed to register %s\n", __func__,
432 __LINE__, reg_name);
433 return ret;
434 }
435
436 cuint = fdt_getprop(fdt, subnode, "st,regulator-bypass-microvolt", NULL);
437 if (cuint != NULL) {
438 struct regul_handle_s *regul = (struct regul_handle_s *)desc->driver_data;
439
440 regul->bypass_mv = (uint16_t)(fdt32_to_cpu(*cuint) / 1000U);
441 VERBOSE("%s: bypass voltage=%umV\n", desc->node_name,
442 regul->bypass_mv);
443 }
444
445 if (fdt_getprop(fdt, subnode, "st,mask-reset", NULL) != NULL) {
446 VERBOSE("%s: set mask-reset\n", desc->node_name);
447 ret = pmic2_set_flag(desc, REGUL_MASK_RESET);
448 if (ret != 0) {
449 ERROR("set mask-reset failed\n");
450 return ret;
451 }
452 }
453
454 if (fdt_getprop(fdt, subnode, "st,regulator-sink-source", NULL) != NULL) {
455 VERBOSE("%s: set regulator-sink-source\n", desc->node_name);
456 ret = pmic2_set_flag(desc, REGUL_SINK_SOURCE);
457 if (ret != 0) {
458 ERROR("set regulator-sink-source failed\n");
459 return ret;
460 }
461 }
462 }
463
464 return 0;
465 }
466
initialize_pmic(void)467 void initialize_pmic(void)
468 {
469 int ret;
470 uint8_t val;
471
472 ret = initialize_pmic_i2c();
473 if (!ret) {
474 VERBOSE("No PMIC2\n");
475 return;
476 }
477
478 if (stpmic2_get_version(pmic2, &val) != 0) {
479 ERROR("Failed to access PMIC\n");
480 panic();
481 }
482 INFO("PMIC2 version = 0x%02x\n", val);
483
484 if (stpmic2_get_product_id(pmic2, &val) != 0) {
485 ERROR("Failed to access PMIC\n");
486 panic();
487 }
488 INFO("PMIC2 product ID = 0x%02x\n", val);
489
490 ret = register_pmic2();
491 if (ret < 0) {
492 ERROR("Register pmic2 failed\n");
493 panic();
494 }
495
496 #if EVENT_LOG_LEVEL == LOG_LEVEL_VERBOSE
497 stpmic2_dump_regulators(pmic2);
498 #endif
499 }
500