1 /* 2 * Copyright (c) 2011 The Chromium OS Authors. 3 * (C) Copyright 2010,2011 NVIDIA Corporation <www.nvidia.com> 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <tps6586x.h> 10 #include <asm/io.h> 11 #include <i2c.h> 12 13 static struct udevice *tps6586x_dev; 14 15 enum { 16 /* Registers that we access */ 17 SUPPLY_CONTROL1 = 0x20, 18 SUPPLY_CONTROL2, 19 SM1_VOLTAGE_V1 = 0x23, 20 SM1_VOLTAGE_V2, 21 SM0_VOLTAGE_V1 = 0x26, 22 SM0_VOLTAGE_V2, 23 PFM_MODE = 0x47, 24 25 /* Bits in the supply control registers */ 26 CTRL_SM1_RAMP = 0x01, 27 CTRL_SM1_SUPPLY2 = 0x02, 28 CTRL_SM0_RAMP = 0x04, 29 CTRL_SM0_SUPPLY2 = 0x08, 30 }; 31 32 #define MAX_I2C_RETRY 3 33 static int tps6586x_read(int reg) 34 { 35 int i; 36 uchar data; 37 int retval = -1; 38 39 for (i = 0; i < MAX_I2C_RETRY; ++i) { 40 if (!i2c_read(tps6586x_dev, reg, &data, 1)) { 41 retval = (int)data; 42 goto exit; 43 } 44 45 /* i2c access failed, retry */ 46 udelay(100); 47 } 48 49 exit: 50 debug("pmu_read %x=%x\n", reg, retval); 51 if (retval < 0) 52 debug("%s: failed to read register %#x: %d\n", __func__, reg, 53 retval); 54 return retval; 55 } 56 57 static int tps6586x_write(int reg, uchar *data, uint len) 58 { 59 int i; 60 int retval = -1; 61 62 for (i = 0; i < MAX_I2C_RETRY; ++i) { 63 if (!i2c_write(tps6586x_dev, reg, data, len)) { 64 retval = 0; 65 goto exit; 66 } 67 68 /* i2c access failed, retry */ 69 udelay(100); 70 } 71 72 exit: 73 debug("pmu_write %x=%x: ", reg, retval); 74 for (i = 0; i < len; i++) 75 debug("%x ", data[i]); 76 if (retval) 77 debug("%s: failed to write register %#x\n", __func__, reg); 78 return retval; 79 } 80 81 /* 82 * Get current voltage of SM0 and SM1 83 * 84 * @param sm0 Place to put SM0 voltage 85 * @param sm1 Place to put SM1 voltage 86 * @return 0 if ok, -1 on error 87 */ 88 static int read_voltages(int *sm0, int *sm1) 89 { 90 int ctrl1, ctrl2; 91 int is_v2; 92 93 /* 94 * Each vdd has two supply sources, ie, v1 and v2. 95 * The supply control reg1 and reg2 determine the current selection. 96 */ 97 ctrl1 = tps6586x_read(SUPPLY_CONTROL1); 98 ctrl2 = tps6586x_read(SUPPLY_CONTROL2); 99 if (ctrl1 == -1 || ctrl2 == -1) 100 return -1; 101 102 /* Figure out whether V1 or V2 is selected */ 103 is_v2 = (ctrl1 | ctrl2) & CTRL_SM0_SUPPLY2; 104 *sm0 = tps6586x_read(is_v2 ? SM0_VOLTAGE_V2 : SM0_VOLTAGE_V1); 105 *sm1 = tps6586x_read(is_v2 ? SM1_VOLTAGE_V2 : SM1_VOLTAGE_V1); 106 if (*sm0 == -1 || *sm1 == -1) 107 return -1; 108 109 return 0; 110 } 111 112 static int set_voltage(int reg, int data, int rate) 113 { 114 uchar control_bit; 115 uchar buff[3]; 116 117 control_bit = (reg == SM0_VOLTAGE_V1 ? CTRL_SM0_RAMP : CTRL_SM1_RAMP); 118 119 /* 120 * Only one supply is needed in u-boot. set both v1 and v2 to 121 * same value. 122 * 123 * When both v1 and v2 are set to same value, we just need to set 124 * control1 reg to trigger the supply selection. 125 */ 126 buff[0] = buff[1] = (uchar)data; 127 buff[2] = rate; 128 129 /* write v1, v2 and rate, then trigger */ 130 if (tps6586x_write(reg, buff, 3) || 131 tps6586x_write(SUPPLY_CONTROL1, &control_bit, 1)) 132 return -1; 133 134 return 0; 135 } 136 137 static int calculate_next_voltage(int voltage, int target, int step) 138 { 139 int diff = voltage < target ? step : -step; 140 141 if (abs(target - voltage) > step) 142 voltage += diff; 143 else 144 voltage = target; 145 146 return voltage; 147 } 148 149 int tps6586x_set_pwm_mode(int mask) 150 { 151 uchar val; 152 int ret; 153 154 assert(tps6586x_dev); 155 ret = tps6586x_read(PFM_MODE); 156 if (ret != -1) { 157 val = (uchar)ret; 158 val |= mask; 159 160 ret = tps6586x_write(PFM_MODE, &val, 1); 161 } 162 163 if (ret == -1) 164 debug("%s: Failed to read/write PWM mode reg\n", __func__); 165 166 return ret; 167 } 168 169 int tps6586x_adjust_sm0_sm1(int sm0_target, int sm1_target, int step, int rate, 170 int min_sm0_over_sm1) 171 { 172 int sm0, sm1; 173 int bad; 174 175 assert(tps6586x_dev); 176 177 /* get current voltage settings */ 178 if (read_voltages(&sm0, &sm1)) { 179 debug("%s: Cannot read voltage settings\n", __func__); 180 return -1; 181 } 182 183 /* 184 * if vdd_core < vdd_cpu + rel 185 * skip 186 * 187 * This condition may happen when system reboots due to kernel crash. 188 */ 189 if (min_sm0_over_sm1 != -1 && sm0 < sm1 + min_sm0_over_sm1) { 190 debug("%s: SM0 is %d, SM1 is %d, but min_sm0_over_sm1 is %d\n", 191 __func__, sm0, sm1, min_sm0_over_sm1); 192 return -1; 193 } 194 195 /* 196 * Since vdd_core and vdd_cpu may both stand at either greater or less 197 * than their nominal voltage, the adjustment may go either directions. 198 * 199 * Make sure vdd_core is always higher than vdd_cpu with certain margin. 200 * So, find out which vdd to adjust first in each step. 201 * 202 * case 1: both sm0 and sm1 need to move up 203 * adjust sm0 before sm1 204 * 205 * case 2: both sm0 and sm1 need to move down 206 * adjust sm1 before sm0 207 * 208 * case 3: sm0 moves down and sm1 moves up 209 * adjusting either one first is fine. 210 * 211 * Adjust vdd_core and vdd_cpu one step at a time until they reach 212 * their nominal values. 213 */ 214 bad = 0; 215 while (!bad && (sm0 != sm0_target || sm1 != sm1_target)) { 216 int adjust_sm0_late = 0; /* flag to adjust vdd_core later */ 217 218 debug("%d-%d %d-%d ", sm0, sm0_target, sm1, sm1_target); 219 220 if (sm0 != sm0_target) { 221 /* 222 * if case 1 and case 3, set new sm0 first. 223 * otherwise, hold down until new sm1 is set. 224 */ 225 sm0 = calculate_next_voltage(sm0, sm0_target, step); 226 if (sm1 < sm1_target) 227 bad |= set_voltage(SM0_VOLTAGE_V1, sm0, rate); 228 else 229 adjust_sm0_late = 1; 230 } 231 232 if (sm1 != sm1_target) { 233 sm1 = calculate_next_voltage(sm1, sm1_target, step); 234 bad |= set_voltage(SM1_VOLTAGE_V1, sm1, rate); 235 } 236 237 if (adjust_sm0_late) 238 bad |= set_voltage(SM0_VOLTAGE_V1, sm0, rate); 239 debug("%d\n", adjust_sm0_late); 240 } 241 debug("%d-%d %d-%d done\n", sm0, sm0_target, sm1, sm1_target); 242 243 return bad ? -1 : 0; 244 } 245 246 int tps6586x_init(struct udevice *dev) 247 { 248 tps6586x_dev = dev; 249 250 return 0; 251 } 252