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