1 /* 2 * Copyright (c) 2017-2018, ARM Limited and Contributors. All rights reserved. 3 * Copyright (c) 2018, Icenowy Zheng <icenowy@aosc.io> 4 * 5 * SPDX-License-Identifier: BSD-3-Clause 6 */ 7 8 #include <errno.h> 9 10 #include <libfdt.h> 11 12 #include <platform_def.h> 13 14 #include <arch_helpers.h> 15 #include <common/debug.h> 16 #include <drivers/allwinner/sunxi_rsb.h> 17 #include <drivers/delay_timer.h> 18 #include <lib/mmio.h> 19 20 #include <sunxi_def.h> 21 #include <sunxi_mmap.h> 22 #include <sunxi_private.h> 23 24 static enum pmic_type { 25 GENERIC_H5, 26 GENERIC_A64, 27 REF_DESIGN_H5, /* regulators controlled by GPIO pins on port L */ 28 AXP803_RSB, /* PMIC connected via RSB on most A64 boards */ 29 } pmic; 30 31 #define AXP803_HW_ADDR 0x3a3 32 #define AXP803_RT_ADDR 0x2d 33 34 /* 35 * On boards without a proper PMIC we struggle to turn off the system properly. 36 * Try to turn off as much off the system as we can, to reduce power 37 * consumption. This should be entered with only one core running and SMP 38 * disabled. 39 * This function only cares about peripherals. 40 */ 41 void sunxi_turn_off_soc(uint16_t socid) 42 { 43 int i; 44 45 /** Turn off most peripherals, most importantly DRAM users. **/ 46 /* Keep DRAM controller running for now. */ 47 mmio_clrbits_32(SUNXI_CCU_BASE + 0x2c0, ~BIT_32(14)); 48 mmio_clrbits_32(SUNXI_CCU_BASE + 0x60, ~BIT_32(14)); 49 /* Contains msgbox (bit 21) and spinlock (bit 22) */ 50 mmio_write_32(SUNXI_CCU_BASE + 0x2c4, 0); 51 mmio_write_32(SUNXI_CCU_BASE + 0x64, 0); 52 mmio_write_32(SUNXI_CCU_BASE + 0x2c8, 0); 53 /* Keep PIO controller running for now. */ 54 mmio_clrbits_32(SUNXI_CCU_BASE + 0x68, ~(BIT_32(5))); 55 mmio_write_32(SUNXI_CCU_BASE + 0x2d0, 0); 56 /* Contains UART0 (bit 16) */ 57 mmio_write_32(SUNXI_CCU_BASE + 0x2d8, 0); 58 mmio_write_32(SUNXI_CCU_BASE + 0x6c, 0); 59 mmio_write_32(SUNXI_CCU_BASE + 0x70, 0); 60 61 /** Turn off DRAM controller. **/ 62 mmio_clrbits_32(SUNXI_CCU_BASE + 0x2c0, BIT_32(14)); 63 mmio_clrbits_32(SUNXI_CCU_BASE + 0x60, BIT_32(14)); 64 65 /** Migrate CPU and bus clocks away from the PLLs. **/ 66 /* AHB1: use OSC24M/1, APB1 = AHB1 / 2 */ 67 mmio_write_32(SUNXI_CCU_BASE + 0x54, 0x1000); 68 /* APB2: use OSC24M */ 69 mmio_write_32(SUNXI_CCU_BASE + 0x58, 0x1000000); 70 /* AHB2: use AHB1 clock */ 71 mmio_write_32(SUNXI_CCU_BASE + 0x5c, 0); 72 /* CPU: use OSC24M */ 73 mmio_write_32(SUNXI_CCU_BASE + 0x50, 0x10000); 74 75 /** Turn off PLLs. **/ 76 for (i = 0; i < 6; i++) 77 mmio_clrbits_32(SUNXI_CCU_BASE + i * 8, BIT(31)); 78 switch (socid) { 79 case SUNXI_SOC_H5: 80 mmio_clrbits_32(SUNXI_CCU_BASE + 0x44, BIT(31)); 81 break; 82 case SUNXI_SOC_A64: 83 mmio_clrbits_32(SUNXI_CCU_BASE + 0x2c, BIT(31)); 84 mmio_clrbits_32(SUNXI_CCU_BASE + 0x4c, BIT(31)); 85 break; 86 } 87 } 88 89 static int rsb_init(void) 90 { 91 int ret; 92 93 ret = rsb_init_controller(); 94 if (ret) 95 return ret; 96 97 /* Start with 400 KHz to issue the I2C->RSB switch command. */ 98 ret = rsb_set_bus_speed(SUNXI_OSC24M_CLK_IN_HZ, 400000); 99 if (ret) 100 return ret; 101 102 /* 103 * Initiate an I2C transaction to write 0x7c into register 0x3e, 104 * switching the PMIC to RSB mode. 105 */ 106 ret = rsb_set_device_mode(0x7c3e00); 107 if (ret) 108 return ret; 109 110 /* Now in RSB mode, switch to the recommended 3 MHz. */ 111 ret = rsb_set_bus_speed(SUNXI_OSC24M_CLK_IN_HZ, 3000000); 112 if (ret) 113 return ret; 114 115 /* Associate the 8-bit runtime address with the 12-bit bus address. */ 116 return rsb_assign_runtime_address(AXP803_HW_ADDR, 117 AXP803_RT_ADDR); 118 } 119 120 static int axp_write(uint8_t reg, uint8_t val) 121 { 122 return rsb_write(AXP803_RT_ADDR, reg, val); 123 } 124 125 static int axp_clrsetbits(uint8_t reg, uint8_t clr_mask, uint8_t set_mask) 126 { 127 uint8_t regval; 128 int ret; 129 130 ret = rsb_read(AXP803_RT_ADDR, reg); 131 if (ret < 0) 132 return ret; 133 134 regval = (ret & ~clr_mask) | set_mask; 135 136 return rsb_write(AXP803_RT_ADDR, reg, regval); 137 } 138 139 #define axp_clrbits(reg, clr_mask) axp_clrsetbits(reg, clr_mask, 0) 140 #define axp_setbits(reg, set_mask) axp_clrsetbits(reg, 0, set_mask) 141 142 static bool should_enable_regulator(const void *fdt, int node) 143 { 144 if (fdt_getprop(fdt, node, "phandle", NULL) != NULL) 145 return true; 146 if (fdt_getprop(fdt, node, "regulator-always-on", NULL) != NULL) 147 return true; 148 return false; 149 } 150 151 /* 152 * Retrieve the voltage from a given regulator DTB node. 153 * Both the regulator-{min,max}-microvolt properties must be present and 154 * have the same value. Return that value in millivolts. 155 */ 156 static int fdt_get_regulator_millivolt(const void *fdt, int node) 157 { 158 const fdt32_t *prop; 159 uint32_t min_volt; 160 161 prop = fdt_getprop(fdt, node, "regulator-min-microvolt", NULL); 162 if (prop == NULL) 163 return -EINVAL; 164 min_volt = fdt32_to_cpu(*prop); 165 166 prop = fdt_getprop(fdt, node, "regulator-max-microvolt", NULL); 167 if (prop == NULL) 168 return -EINVAL; 169 170 if (fdt32_to_cpu(*prop) != min_volt) 171 return -EINVAL; 172 173 return min_volt / 1000; 174 } 175 176 #define NO_SPLIT 0xff 177 178 static const struct axp_regulator { 179 char *dt_name; 180 uint16_t min_volt; 181 uint16_t max_volt; 182 uint16_t step; 183 unsigned char split; 184 unsigned char volt_reg; 185 unsigned char switch_reg; 186 unsigned char switch_bit; 187 } regulators[] = { 188 {"dcdc1", 1600, 3400, 100, NO_SPLIT, 0x20, 0x10, 0}, 189 {"dcdc5", 800, 1840, 10, 32, 0x24, 0x10, 4}, 190 {"dcdc6", 600, 1520, 10, 50, 0x25, 0x10, 5}, 191 {"dldo1", 700, 3300, 100, NO_SPLIT, 0x15, 0x12, 3}, 192 {"dldo2", 700, 4200, 100, 27, 0x16, 0x12, 4}, 193 {"dldo3", 700, 3300, 100, NO_SPLIT, 0x17, 0x12, 5}, 194 {"dldo4", 700, 3300, 100, NO_SPLIT, 0x18, 0x12, 6}, 195 {"fldo1", 700, 1450, 50, NO_SPLIT, 0x1c, 0x13, 2}, 196 {} 197 }; 198 199 static int setup_regulator(const void *fdt, int node, 200 const struct axp_regulator *reg) 201 { 202 int mvolt; 203 uint8_t regval; 204 205 if (!should_enable_regulator(fdt, node)) 206 return -ENOENT; 207 208 mvolt = fdt_get_regulator_millivolt(fdt, node); 209 if (mvolt < reg->min_volt || mvolt > reg->max_volt) 210 return -EINVAL; 211 212 regval = (mvolt / reg->step) - (reg->min_volt / reg->step); 213 if (regval > reg->split) 214 regval = ((regval - reg->split) / 2) + reg->split; 215 216 axp_write(reg->volt_reg, regval); 217 if (reg->switch_reg < 0xff) 218 axp_setbits(reg->switch_reg, BIT(reg->switch_bit)); 219 220 INFO("PMIC: AXP803: %s voltage: %d.%03dV\n", reg->dt_name, 221 mvolt / 1000, mvolt % 1000); 222 223 return 0; 224 } 225 226 static void setup_axp803_rails(const void *fdt) 227 { 228 int node; 229 bool dc1sw = false; 230 231 /* locate the PMIC DT node, bail out if not found */ 232 node = fdt_node_offset_by_compatible(fdt, -1, "x-powers,axp803"); 233 if (node < 0) { 234 WARN("BL31: PMIC: Cannot find AXP803 DT node, skipping initial setup.\n"); 235 return; 236 } 237 238 if (fdt_getprop(fdt, node, "x-powers,drive-vbus-en", NULL)) { 239 axp_clrbits(0x8f, BIT(4)); 240 axp_setbits(0x30, BIT(2)); 241 INFO("PMIC: AXP803: Enabling DRIVEVBUS\n"); 242 } 243 244 /* descend into the "regulators" subnode */ 245 node = fdt_subnode_offset(fdt, node, "regulators"); 246 if (node < 0) { 247 WARN("BL31: PMIC: Cannot find regulators subnode, skipping initial setup.\n"); 248 return; 249 } 250 251 /* iterate over all regulators to find used ones */ 252 for (node = fdt_first_subnode(fdt, node); 253 node >= 0; 254 node = fdt_next_subnode(fdt, node)) { 255 const struct axp_regulator *reg; 256 const char *name; 257 int length; 258 259 /* We only care if it's always on or referenced. */ 260 if (!should_enable_regulator(fdt, node)) 261 continue; 262 263 name = fdt_get_name(fdt, node, &length); 264 for (reg = regulators; reg->dt_name; reg++) { 265 if (!strncmp(name, reg->dt_name, length)) { 266 setup_regulator(fdt, node, reg); 267 break; 268 } 269 } 270 271 if (!strncmp(name, "dc1sw", length)) { 272 /* Delay DC1SW enablement to avoid overheating. */ 273 dc1sw = true; 274 continue; 275 } 276 } 277 /* 278 * If DLDO2 is enabled after DC1SW, the PMIC overheats and shuts 279 * down. So always enable DC1SW as the very last regulator. 280 */ 281 if (dc1sw) { 282 INFO("PMIC: AXP803: Enabling DC1SW\n"); 283 axp_setbits(0x12, BIT(7)); 284 } 285 } 286 287 int sunxi_pmic_setup(uint16_t socid, const void *fdt) 288 { 289 int ret; 290 291 switch (socid) { 292 case SUNXI_SOC_H5: 293 pmic = REF_DESIGN_H5; 294 NOTICE("BL31: PMIC: Defaulting to PortL GPIO according to H5 reference design.\n"); 295 break; 296 case SUNXI_SOC_A64: 297 pmic = GENERIC_A64; 298 ret = sunxi_init_platform_r_twi(socid, true); 299 if (ret) 300 return ret; 301 302 ret = rsb_init(); 303 if (ret) 304 return ret; 305 306 pmic = AXP803_RSB; 307 NOTICE("BL31: PMIC: Detected AXP803 on RSB.\n"); 308 309 if (fdt) 310 setup_axp803_rails(fdt); 311 312 break; 313 default: 314 NOTICE("BL31: PMIC: No support for Allwinner %x SoC.\n", socid); 315 return -ENODEV; 316 } 317 return 0; 318 } 319 320 void __dead2 sunxi_power_down(void) 321 { 322 switch (pmic) { 323 case GENERIC_H5: 324 /* Turn off as many peripherals and clocks as we can. */ 325 sunxi_turn_off_soc(SUNXI_SOC_H5); 326 /* Turn off the pin controller now. */ 327 mmio_write_32(SUNXI_CCU_BASE + 0x68, 0); 328 break; 329 case GENERIC_A64: 330 /* Turn off as many peripherals and clocks as we can. */ 331 sunxi_turn_off_soc(SUNXI_SOC_A64); 332 /* Turn off the pin controller now. */ 333 mmio_write_32(SUNXI_CCU_BASE + 0x68, 0); 334 break; 335 case REF_DESIGN_H5: 336 sunxi_turn_off_soc(SUNXI_SOC_H5); 337 338 /* 339 * Switch PL pins to power off the board: 340 * - PL5 (VCC_IO) -> high 341 * - PL8 (PWR-STB = CPU power supply) -> low 342 * - PL9 (PWR-DRAM) ->low 343 * - PL10 (power LED) -> low 344 * Note: Clearing PL8 will reset the board, so keep it up. 345 */ 346 sunxi_set_gpio_out('L', 5, 1); 347 sunxi_set_gpio_out('L', 9, 0); 348 sunxi_set_gpio_out('L', 10, 0); 349 350 /* Turn off pin controller now. */ 351 mmio_write_32(SUNXI_CCU_BASE + 0x68, 0); 352 353 break; 354 case AXP803_RSB: 355 /* (Re-)init RSB in case the rich OS has disabled it. */ 356 sunxi_init_platform_r_twi(SUNXI_SOC_A64, true); 357 rsb_init(); 358 359 /* Set "power disable control" bit */ 360 axp_setbits(0x32, BIT(7)); 361 break; 362 default: 363 break; 364 } 365 366 udelay(1000); 367 ERROR("PSCI: Cannot turn off system, halting.\n"); 368 wfi(); 369 panic(); 370 } 371