Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 1 | /* |
Benjamin Gaignard | 53ee7d3 | 2020-02-24 13:57:40 +0100 | [diff] [blame] | 2 | * Copyright (c) 2017-2021, STMicroelectronics - All Rights Reserved |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 3 | * |
| 4 | * SPDX-License-Identifier: BSD-3-Clause |
| 5 | */ |
| 6 | |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 7 | #include <errno.h> |
Antonio Nino Diaz | e0f9063 | 2018-12-14 00:18:21 +0000 | [diff] [blame] | 8 | |
Antonio Nino Diaz | e0f9063 | 2018-12-14 00:18:21 +0000 | [diff] [blame] | 9 | #include <common/debug.h> |
| 10 | #include <drivers/delay_timer.h> |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 11 | #include <drivers/st/stm32_i2c.h> |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 12 | #include <drivers/st/stm32mp_pmic.h> |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 13 | #include <drivers/st/stpmic1.h> |
Antonio Nino Diaz | e0f9063 | 2018-12-14 00:18:21 +0000 | [diff] [blame] | 14 | #include <lib/mmio.h> |
| 15 | #include <lib/utils_def.h> |
Nicolas Le Bayon | f5188ee | 2019-09-19 11:24:50 +0200 | [diff] [blame] | 16 | #include <libfdt.h> |
| 17 | |
| 18 | #include <platform_def.h> |
Antonio Nino Diaz | e0f9063 | 2018-12-14 00:18:21 +0000 | [diff] [blame] | 19 | |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 20 | #define PMIC_NODE_NOT_FOUND 1 |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 21 | #define STPMIC1_LDO12356_OUTPUT_MASK (uint8_t)(GENMASK(6, 2)) |
| 22 | #define STPMIC1_LDO12356_OUTPUT_SHIFT 2 |
| 23 | #define STPMIC1_LDO3_MODE (uint8_t)(BIT(7)) |
| 24 | #define STPMIC1_LDO3_DDR_SEL 31U |
| 25 | #define STPMIC1_LDO3_1800000 (9U << STPMIC1_LDO12356_OUTPUT_SHIFT) |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 26 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 27 | #define STPMIC1_BUCK_OUTPUT_SHIFT 2 |
| 28 | #define STPMIC1_BUCK3_1V8 (39U << STPMIC1_BUCK_OUTPUT_SHIFT) |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 29 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 30 | #define STPMIC1_DEFAULT_START_UP_DELAY_MS 1 |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 31 | |
| 32 | static struct i2c_handle_s i2c_handle; |
| 33 | static uint32_t pmic_i2c_addr; |
| 34 | |
| 35 | static int dt_get_pmic_node(void *fdt) |
| 36 | { |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 37 | static int node = -FDT_ERR_BADOFFSET; |
| 38 | |
| 39 | if (node == -FDT_ERR_BADOFFSET) { |
| 40 | node = fdt_node_offset_by_compatible(fdt, -1, "st,stpmic1"); |
| 41 | } |
| 42 | |
| 43 | return node; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 44 | } |
| 45 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 46 | int dt_pmic_status(void) |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 47 | { |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 48 | static int status = -FDT_ERR_BADVALUE; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 49 | int node; |
| 50 | void *fdt; |
| 51 | |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 52 | if (status != -FDT_ERR_BADVALUE) { |
| 53 | return status; |
| 54 | } |
| 55 | |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 56 | if (fdt_get_address(&fdt) == 0) { |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 57 | return -ENOENT; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | node = dt_get_pmic_node(fdt); |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 61 | if (node <= 0) { |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 62 | status = -FDT_ERR_NOTFOUND; |
| 63 | |
| 64 | return status; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 65 | } |
| 66 | |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 67 | status = (int)fdt_get_status(node); |
| 68 | |
| 69 | return status; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 70 | } |
| 71 | |
Etienne Carriere | 67b106a | 2019-12-02 10:10:08 +0100 | [diff] [blame] | 72 | static bool dt_pmic_is_secure(void) |
| 73 | { |
| 74 | int status = dt_pmic_status(); |
| 75 | |
| 76 | return (status >= 0) && |
| 77 | (status == DT_SECURE) && |
| 78 | (i2c_handle.dt_status == DT_SECURE); |
| 79 | } |
| 80 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 81 | /* |
| 82 | * Get PMIC and its I2C bus configuration from the device tree. |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 83 | * Return 0 on success, negative on error, 1 if no PMIC node is defined. |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 84 | */ |
| 85 | static int dt_pmic_i2c_config(struct dt_node_info *i2c_info, |
| 86 | struct stm32_i2c_init_s *init) |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 87 | { |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 88 | static int i2c_node = -FDT_ERR_NOTFOUND; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 89 | void *fdt; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 90 | |
| 91 | if (fdt_get_address(&fdt) == 0) { |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 92 | return -FDT_ERR_NOTFOUND; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 93 | } |
| 94 | |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 95 | if (i2c_node == -FDT_ERR_NOTFOUND) { |
| 96 | int pmic_node; |
| 97 | const fdt32_t *cuint; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 98 | |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 99 | pmic_node = dt_get_pmic_node(fdt); |
| 100 | if (pmic_node < 0) { |
| 101 | return PMIC_NODE_NOT_FOUND; |
| 102 | } |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 103 | |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 104 | cuint = fdt_getprop(fdt, pmic_node, "reg", NULL); |
| 105 | if (cuint == NULL) { |
| 106 | return -FDT_ERR_NOTFOUND; |
| 107 | } |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 108 | |
Nicolas Le Bayon | 342865a | 2019-11-15 15:56:06 +0100 | [diff] [blame] | 109 | pmic_i2c_addr = fdt32_to_cpu(*cuint) << 1; |
| 110 | if (pmic_i2c_addr > UINT16_MAX) { |
| 111 | return -FDT_ERR_BADVALUE; |
| 112 | } |
| 113 | |
| 114 | i2c_node = fdt_parent_offset(fdt, pmic_node); |
| 115 | if (i2c_node < 0) { |
| 116 | return -FDT_ERR_NOTFOUND; |
| 117 | } |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | dt_fill_device_info(i2c_info, i2c_node); |
| 121 | if (i2c_info->base == 0U) { |
| 122 | return -FDT_ERR_NOTFOUND; |
| 123 | } |
| 124 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 125 | return stm32_i2c_get_setup_from_fdt(fdt, i2c_node, init); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 126 | } |
| 127 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 128 | int dt_pmic_configure_boot_on_regulators(void) |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 129 | { |
| 130 | int pmic_node, regulators_node, regulator_node; |
| 131 | void *fdt; |
| 132 | |
| 133 | if (fdt_get_address(&fdt) == 0) { |
| 134 | return -ENOENT; |
| 135 | } |
| 136 | |
| 137 | pmic_node = dt_get_pmic_node(fdt); |
| 138 | if (pmic_node < 0) { |
| 139 | return -FDT_ERR_NOTFOUND; |
| 140 | } |
| 141 | |
| 142 | regulators_node = fdt_subnode_offset(fdt, pmic_node, "regulators"); |
Nicolas Le Bayon | 72ceb35 | 2020-03-10 18:18:45 +0100 | [diff] [blame] | 143 | if (regulators_node < 0) { |
| 144 | return -ENOENT; |
| 145 | } |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 146 | |
| 147 | fdt_for_each_subnode(regulator_node, fdt, regulators_node) { |
| 148 | const fdt32_t *cuint; |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 149 | const char *node_name = fdt_get_name(fdt, regulator_node, NULL); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 150 | uint16_t voltage; |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 151 | int status; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 152 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 153 | #if defined(IMAGE_BL2) |
| 154 | if ((fdt_getprop(fdt, regulator_node, "regulator-boot-on", |
| 155 | NULL) == NULL) && |
| 156 | (fdt_getprop(fdt, regulator_node, "regulator-always-on", |
| 157 | NULL) == NULL)) { |
| 158 | #else |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 159 | if (fdt_getprop(fdt, regulator_node, "regulator-boot-on", |
| 160 | NULL) == NULL) { |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 161 | #endif |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 162 | continue; |
| 163 | } |
| 164 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 165 | if (fdt_getprop(fdt, regulator_node, "regulator-pull-down", |
| 166 | NULL) != NULL) { |
| 167 | |
| 168 | status = stpmic1_regulator_pull_down_set(node_name); |
| 169 | if (status != 0) { |
| 170 | return status; |
| 171 | } |
| 172 | } |
| 173 | |
| 174 | if (fdt_getprop(fdt, regulator_node, "st,mask-reset", |
| 175 | NULL) != NULL) { |
| 176 | |
| 177 | status = stpmic1_regulator_mask_reset_set(node_name); |
| 178 | if (status != 0) { |
| 179 | return status; |
| 180 | } |
| 181 | } |
| 182 | |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 183 | cuint = fdt_getprop(fdt, regulator_node, |
| 184 | "regulator-min-microvolt", NULL); |
| 185 | if (cuint == NULL) { |
| 186 | continue; |
| 187 | } |
| 188 | |
| 189 | /* DT uses microvolts, whereas driver awaits millivolts */ |
| 190 | voltage = (uint16_t)(fdt32_to_cpu(*cuint) / 1000U); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 191 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 192 | status = stpmic1_regulator_voltage_set(node_name, voltage); |
| 193 | if (status != 0) { |
| 194 | return status; |
| 195 | } |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 196 | |
Nicolas Le Bayon | f5188ee | 2019-09-19 11:24:50 +0200 | [diff] [blame] | 197 | if (!stpmic1_is_regulator_enabled(node_name)) { |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 198 | status = stpmic1_regulator_enable(node_name); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 199 | if (status != 0) { |
| 200 | return status; |
| 201 | } |
| 202 | } |
| 203 | } |
| 204 | |
| 205 | return 0; |
| 206 | } |
| 207 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 208 | bool initialize_pmic_i2c(void) |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 209 | { |
| 210 | int ret; |
| 211 | struct dt_node_info i2c_info; |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 212 | struct i2c_handle_s *i2c = &i2c_handle; |
| 213 | struct stm32_i2c_init_s i2c_init; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 214 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 215 | ret = dt_pmic_i2c_config(&i2c_info, &i2c_init); |
| 216 | if (ret < 0) { |
| 217 | ERROR("I2C configuration failed %d\n", ret); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 218 | panic(); |
| 219 | } |
| 220 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 221 | if (ret != 0) { |
| 222 | return false; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 223 | } |
| 224 | |
| 225 | /* Initialize PMIC I2C */ |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 226 | i2c->i2c_base_addr = i2c_info.base; |
| 227 | i2c->dt_status = i2c_info.status; |
| 228 | i2c->clock = i2c_info.clock; |
Benjamin Gaignard | 53ee7d3 | 2020-02-24 13:57:40 +0100 | [diff] [blame] | 229 | i2c->i2c_state = I2C_STATE_RESET; |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 230 | i2c_init.own_address1 = pmic_i2c_addr; |
| 231 | i2c_init.addressing_mode = I2C_ADDRESSINGMODE_7BIT; |
| 232 | i2c_init.dual_address_mode = I2C_DUALADDRESS_DISABLE; |
| 233 | i2c_init.own_address2 = 0; |
| 234 | i2c_init.own_address2_masks = I2C_OAR2_OA2NOMASK; |
| 235 | i2c_init.general_call_mode = I2C_GENERALCALL_DISABLE; |
| 236 | i2c_init.no_stretch_mode = I2C_NOSTRETCH_DISABLE; |
| 237 | i2c_init.analog_filter = 1; |
| 238 | i2c_init.digital_filter_coef = 0; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 239 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 240 | ret = stm32_i2c_init(i2c, &i2c_init); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 241 | if (ret != 0) { |
| 242 | ERROR("Cannot initialize I2C %x (%d)\n", |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 243 | i2c->i2c_base_addr, ret); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 244 | panic(); |
| 245 | } |
| 246 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 247 | if (!stm32_i2c_is_device_ready(i2c, pmic_i2c_addr, 1, |
| 248 | I2C_TIMEOUT_BUSY_MS)) { |
| 249 | ERROR("I2C device not ready\n"); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 250 | panic(); |
| 251 | } |
| 252 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 253 | stpmic1_bind_i2c(i2c, (uint16_t)pmic_i2c_addr); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 254 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 255 | return true; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 256 | } |
| 257 | |
Etienne Carriere | 67b106a | 2019-12-02 10:10:08 +0100 | [diff] [blame] | 258 | static void register_pmic_shared_peripherals(void) |
| 259 | { |
| 260 | uintptr_t i2c_base = i2c_handle.i2c_base_addr; |
| 261 | |
| 262 | if (dt_pmic_is_secure()) { |
| 263 | stm32mp_register_secure_periph_iomem(i2c_base); |
| 264 | } else { |
| 265 | if (i2c_base != 0U) { |
| 266 | stm32mp_register_non_secure_periph_iomem(i2c_base); |
| 267 | } |
| 268 | } |
| 269 | } |
| 270 | |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 271 | void initialize_pmic(void) |
| 272 | { |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 273 | if (!initialize_pmic_i2c()) { |
| 274 | VERBOSE("No PMIC\n"); |
| 275 | return; |
| 276 | } |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 277 | |
Etienne Carriere | 67b106a | 2019-12-02 10:10:08 +0100 | [diff] [blame] | 278 | register_pmic_shared_peripherals(); |
| 279 | |
Nicolas Le Bayon | 0b10b65 | 2019-11-18 13:13:36 +0100 | [diff] [blame^] | 280 | if (dt_pmic_configure_boot_on_regulators() < 0) { |
| 281 | panic(); |
| 282 | }; |
| 283 | } |
| 284 | |
| 285 | #if DEBUG |
| 286 | void print_pmic_info_and_debug(void) |
| 287 | { |
| 288 | unsigned long pmic_version; |
| 289 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 290 | if (stpmic1_get_version(&pmic_version) != 0) { |
| 291 | ERROR("Failed to access PMIC\n"); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 292 | panic(); |
| 293 | } |
| 294 | |
Yann Gautier | f3928f6 | 2019-02-14 11:15:03 +0100 | [diff] [blame] | 295 | INFO("PMIC version = 0x%02lx\n", pmic_version); |
| 296 | stpmic1_dump_regulators(); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 297 | } |
Nicolas Le Bayon | 0b10b65 | 2019-11-18 13:13:36 +0100 | [diff] [blame^] | 298 | #endif |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 299 | |
| 300 | int pmic_ddr_power_init(enum ddr_type ddr_type) |
| 301 | { |
| 302 | bool buck3_at_1v8 = false; |
| 303 | uint8_t read_val; |
| 304 | int status; |
| 305 | |
| 306 | switch (ddr_type) { |
| 307 | case STM32MP_DDR3: |
| 308 | /* Set LDO3 to sync mode */ |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 309 | status = stpmic1_register_read(LDO3_CONTROL_REG, &read_val); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 310 | if (status != 0) { |
| 311 | return status; |
| 312 | } |
| 313 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 314 | read_val &= ~STPMIC1_LDO3_MODE; |
| 315 | read_val &= ~STPMIC1_LDO12356_OUTPUT_MASK; |
| 316 | read_val |= STPMIC1_LDO3_DDR_SEL << |
| 317 | STPMIC1_LDO12356_OUTPUT_SHIFT; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 318 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 319 | status = stpmic1_register_write(LDO3_CONTROL_REG, read_val); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 320 | if (status != 0) { |
| 321 | return status; |
| 322 | } |
| 323 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 324 | status = stpmic1_regulator_voltage_set("buck2", 1350); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 325 | if (status != 0) { |
| 326 | return status; |
| 327 | } |
| 328 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 329 | status = stpmic1_regulator_enable("buck2"); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 330 | if (status != 0) { |
| 331 | return status; |
| 332 | } |
| 333 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 334 | mdelay(STPMIC1_DEFAULT_START_UP_DELAY_MS); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 335 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 336 | status = stpmic1_regulator_enable("vref_ddr"); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 337 | if (status != 0) { |
| 338 | return status; |
| 339 | } |
| 340 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 341 | mdelay(STPMIC1_DEFAULT_START_UP_DELAY_MS); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 342 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 343 | status = stpmic1_regulator_enable("ldo3"); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 344 | if (status != 0) { |
| 345 | return status; |
| 346 | } |
| 347 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 348 | mdelay(STPMIC1_DEFAULT_START_UP_DELAY_MS); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 349 | break; |
| 350 | |
| 351 | case STM32MP_LPDDR2: |
Yann Gautier | 917a00c | 2019-04-16 16:20:58 +0200 | [diff] [blame] | 352 | case STM32MP_LPDDR3: |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 353 | /* |
| 354 | * Set LDO3 to 1.8V |
| 355 | * Set LDO3 to bypass mode if BUCK3 = 1.8V |
| 356 | * Set LDO3 to normal mode if BUCK3 != 1.8V |
| 357 | */ |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 358 | status = stpmic1_register_read(BUCK3_CONTROL_REG, &read_val); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 359 | if (status != 0) { |
| 360 | return status; |
| 361 | } |
| 362 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 363 | if ((read_val & STPMIC1_BUCK3_1V8) == STPMIC1_BUCK3_1V8) { |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 364 | buck3_at_1v8 = true; |
| 365 | } |
| 366 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 367 | status = stpmic1_register_read(LDO3_CONTROL_REG, &read_val); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 368 | if (status != 0) { |
| 369 | return status; |
| 370 | } |
| 371 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 372 | read_val &= ~STPMIC1_LDO3_MODE; |
| 373 | read_val &= ~STPMIC1_LDO12356_OUTPUT_MASK; |
| 374 | read_val |= STPMIC1_LDO3_1800000; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 375 | if (buck3_at_1v8) { |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 376 | read_val |= STPMIC1_LDO3_MODE; |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 377 | } |
| 378 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 379 | status = stpmic1_register_write(LDO3_CONTROL_REG, read_val); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 380 | if (status != 0) { |
| 381 | return status; |
| 382 | } |
| 383 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 384 | status = stpmic1_regulator_voltage_set("buck2", 1200); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 385 | if (status != 0) { |
| 386 | return status; |
| 387 | } |
| 388 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 389 | status = stpmic1_regulator_enable("ldo3"); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 390 | if (status != 0) { |
| 391 | return status; |
| 392 | } |
| 393 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 394 | mdelay(STPMIC1_DEFAULT_START_UP_DELAY_MS); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 395 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 396 | status = stpmic1_regulator_enable("buck2"); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 397 | if (status != 0) { |
| 398 | return status; |
| 399 | } |
| 400 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 401 | mdelay(STPMIC1_DEFAULT_START_UP_DELAY_MS); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 402 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 403 | status = stpmic1_regulator_enable("vref_ddr"); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 404 | if (status != 0) { |
| 405 | return status; |
| 406 | } |
| 407 | |
Yann Gautier | a45433b | 2019-01-16 18:31:00 +0100 | [diff] [blame] | 408 | mdelay(STPMIC1_DEFAULT_START_UP_DELAY_MS); |
Yann Gautier | bb836ee | 2018-07-16 17:55:07 +0200 | [diff] [blame] | 409 | break; |
| 410 | |
| 411 | default: |
| 412 | break; |
| 413 | }; |
| 414 | |
| 415 | return 0; |
| 416 | } |