aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/regulator
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/regulator')
-rw-r--r--drivers/regulator/ab8500.c86
-rw-r--r--drivers/regulator/max8998.c270
2 files changed, 295 insertions, 61 deletions
diff --git a/drivers/regulator/ab8500.c b/drivers/regulator/ab8500.c
index 28c7ae67cec9..db6b70f20511 100644
--- a/drivers/regulator/ab8500.c
+++ b/drivers/regulator/ab8500.c
@@ -21,6 +21,7 @@
21#include <linux/err.h> 21#include <linux/err.h>
22#include <linux/platform_device.h> 22#include <linux/platform_device.h>
23#include <linux/mfd/ab8500.h> 23#include <linux/mfd/ab8500.h>
24#include <linux/mfd/abx500.h>
24#include <linux/regulator/driver.h> 25#include <linux/regulator/driver.h>
25#include <linux/regulator/machine.h> 26#include <linux/regulator/machine.h>
26#include <linux/regulator/ab8500.h> 27#include <linux/regulator/ab8500.h>
@@ -33,9 +34,11 @@
33 * @max_uV: maximum voltage (for variable voltage supplies) 34 * @max_uV: maximum voltage (for variable voltage supplies)
34 * @min_uV: minimum voltage (for variable voltage supplies) 35 * @min_uV: minimum voltage (for variable voltage supplies)
35 * @fixed_uV: typical voltage (for fixed voltage supplies) 36 * @fixed_uV: typical voltage (for fixed voltage supplies)
37 * @update_bank: bank to control on/off
36 * @update_reg: register to control on/off 38 * @update_reg: register to control on/off
37 * @mask: mask to enable/disable regulator 39 * @mask: mask to enable/disable regulator
38 * @enable: bits to enable the regulator in normal(high power) mode 40 * @enable: bits to enable the regulator in normal(high power) mode
41 * @voltage_bank: bank to control regulator voltage
39 * @voltage_reg: register to control regulator voltage 42 * @voltage_reg: register to control regulator voltage
40 * @voltage_mask: mask to control regulator voltage 43 * @voltage_mask: mask to control regulator voltage
41 * @supported_voltages: supported voltage table 44 * @supported_voltages: supported voltage table
@@ -49,11 +52,13 @@ struct ab8500_regulator_info {
49 int max_uV; 52 int max_uV;
50 int min_uV; 53 int min_uV;
51 int fixed_uV; 54 int fixed_uV;
52 int update_reg; 55 u8 update_bank;
53 int mask; 56 u8 update_reg;
54 int enable; 57 u8 mask;
55 int voltage_reg; 58 u8 enable;
56 int voltage_mask; 59 u8 voltage_bank;
60 u8 voltage_reg;
61 u8 voltage_mask;
57 int const *supported_voltages; 62 int const *supported_voltages;
58 int voltages_len; 63 int voltages_len;
59}; 64};
@@ -97,8 +102,8 @@ static int ab8500_regulator_enable(struct regulator_dev *rdev)
97 if (regulator_id >= AB8500_NUM_REGULATORS) 102 if (regulator_id >= AB8500_NUM_REGULATORS)
98 return -EINVAL; 103 return -EINVAL;
99 104
100 ret = ab8500_set_bits(info->ab8500, info->update_reg, 105 ret = abx500_mask_and_set_register_interruptible(info->dev,
101 info->mask, info->enable); 106 info->update_bank, info->update_reg, info->mask, info->enable);
102 if (ret < 0) 107 if (ret < 0)
103 dev_err(rdev_get_dev(rdev), 108 dev_err(rdev_get_dev(rdev),
104 "couldn't set enable bits for regulator\n"); 109 "couldn't set enable bits for regulator\n");
@@ -114,8 +119,8 @@ static int ab8500_regulator_disable(struct regulator_dev *rdev)
114 if (regulator_id >= AB8500_NUM_REGULATORS) 119 if (regulator_id >= AB8500_NUM_REGULATORS)
115 return -EINVAL; 120 return -EINVAL;
116 121
117 ret = ab8500_set_bits(info->ab8500, info->update_reg, 122 ret = abx500_mask_and_set_register_interruptible(info->dev,
118 info->mask, 0x0); 123 info->update_bank, info->update_reg, info->mask, 0x0);
119 if (ret < 0) 124 if (ret < 0)
120 dev_err(rdev_get_dev(rdev), 125 dev_err(rdev_get_dev(rdev),
121 "couldn't set disable bits for regulator\n"); 126 "couldn't set disable bits for regulator\n");
@@ -126,19 +131,21 @@ static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
126{ 131{
127 int regulator_id, ret; 132 int regulator_id, ret;
128 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev); 133 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
134 u8 value;
129 135
130 regulator_id = rdev_get_id(rdev); 136 regulator_id = rdev_get_id(rdev);
131 if (regulator_id >= AB8500_NUM_REGULATORS) 137 if (regulator_id >= AB8500_NUM_REGULATORS)
132 return -EINVAL; 138 return -EINVAL;
133 139
134 ret = ab8500_read(info->ab8500, info->update_reg); 140 ret = abx500_get_register_interruptible(info->dev,
141 info->update_bank, info->update_reg, &value);
135 if (ret < 0) { 142 if (ret < 0) {
136 dev_err(rdev_get_dev(rdev), 143 dev_err(rdev_get_dev(rdev),
137 "couldn't read 0x%x register\n", info->update_reg); 144 "couldn't read 0x%x register\n", info->update_reg);
138 return ret; 145 return ret;
139 } 146 }
140 147
141 if (ret & info->mask) 148 if (value & info->mask)
142 return true; 149 return true;
143 else 150 else
144 return false; 151 return false;
@@ -165,14 +172,16 @@ static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
165 172
166static int ab8500_regulator_get_voltage(struct regulator_dev *rdev) 173static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
167{ 174{
168 int regulator_id, ret, val; 175 int regulator_id, ret;
169 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev); 176 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
177 u8 value;
170 178
171 regulator_id = rdev_get_id(rdev); 179 regulator_id = rdev_get_id(rdev);
172 if (regulator_id >= AB8500_NUM_REGULATORS) 180 if (regulator_id >= AB8500_NUM_REGULATORS)
173 return -EINVAL; 181 return -EINVAL;
174 182
175 ret = ab8500_read(info->ab8500, info->voltage_reg); 183 ret = abx500_get_register_interruptible(info->dev, info->voltage_bank,
184 info->voltage_reg, &value);
176 if (ret < 0) { 185 if (ret < 0) {
177 dev_err(rdev_get_dev(rdev), 186 dev_err(rdev_get_dev(rdev),
178 "couldn't read voltage reg for regulator\n"); 187 "couldn't read voltage reg for regulator\n");
@@ -180,11 +189,11 @@ static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
180 } 189 }
181 190
182 /* vintcore has a different layout */ 191 /* vintcore has a different layout */
183 val = ret & info->voltage_mask; 192 value &= info->voltage_mask;
184 if (regulator_id == AB8500_LDO_INTCORE) 193 if (regulator_id == AB8500_LDO_INTCORE)
185 ret = info->supported_voltages[val >> 0x3]; 194 ret = info->supported_voltages[value >> 0x3];
186 else 195 else
187 ret = info->supported_voltages[val]; 196 ret = info->supported_voltages[value];
188 197
189 return ret; 198 return ret;
190} 199}
@@ -224,8 +233,9 @@ static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
224 } 233 }
225 234
226 /* set the registers for the request */ 235 /* set the registers for the request */
227 ret = ab8500_set_bits(info->ab8500, info->voltage_reg, 236 ret = abx500_mask_and_set_register_interruptible(info->dev,
228 info->voltage_mask, ret); 237 info->voltage_bank, info->voltage_reg,
238 info->voltage_mask, (u8)ret);
229 if (ret < 0) 239 if (ret < 0)
230 dev_err(rdev_get_dev(rdev), 240 dev_err(rdev_get_dev(rdev),
231 "couldn't set voltage reg for regulator\n"); 241 "couldn't set voltage reg for regulator\n");
@@ -262,9 +272,9 @@ static struct regulator_ops ab8500_ldo_fixed_ops = {
262 .list_voltage = ab8500_list_voltage, 272 .list_voltage = ab8500_list_voltage,
263}; 273};
264 274
265#define AB8500_LDO(_id, min, max, reg, reg_mask, reg_enable, \ 275#define AB8500_LDO(_id, min, max, bank, reg, reg_mask, \
266 volt_reg, volt_mask, voltages, \ 276 reg_enable, volt_bank, volt_reg, volt_mask, \
267 len_volts) \ 277 voltages, len_volts) \
268{ \ 278{ \
269 .desc = { \ 279 .desc = { \
270 .name = "LDO-" #_id, \ 280 .name = "LDO-" #_id, \
@@ -275,9 +285,11 @@ static struct regulator_ops ab8500_ldo_fixed_ops = {
275 }, \ 285 }, \
276 .min_uV = (min) * 1000, \ 286 .min_uV = (min) * 1000, \
277 .max_uV = (max) * 1000, \ 287 .max_uV = (max) * 1000, \
288 .update_bank = bank, \
278 .update_reg = reg, \ 289 .update_reg = reg, \
279 .mask = reg_mask, \ 290 .mask = reg_mask, \
280 .enable = reg_enable, \ 291 .enable = reg_enable, \
292 .voltage_bank = volt_bank, \
281 .voltage_reg = volt_reg, \ 293 .voltage_reg = volt_reg, \
282 .voltage_mask = volt_mask, \ 294 .voltage_mask = volt_mask, \
283 .supported_voltages = voltages, \ 295 .supported_voltages = voltages, \
@@ -285,8 +297,8 @@ static struct regulator_ops ab8500_ldo_fixed_ops = {
285 .fixed_uV = 0, \ 297 .fixed_uV = 0, \
286} 298}
287 299
288#define AB8500_FIXED_LDO(_id, fixed, reg, reg_mask, \ 300#define AB8500_FIXED_LDO(_id, fixed, bank, reg, \
289 reg_enable) \ 301 reg_mask, reg_enable) \
290{ \ 302{ \
291 .desc = { \ 303 .desc = { \
292 .name = "LDO-" #_id, \ 304 .name = "LDO-" #_id, \
@@ -296,6 +308,7 @@ static struct regulator_ops ab8500_ldo_fixed_ops = {
296 .owner = THIS_MODULE, \ 308 .owner = THIS_MODULE, \
297 }, \ 309 }, \
298 .fixed_uV = fixed * 1000, \ 310 .fixed_uV = fixed * 1000, \
311 .update_bank = bank, \
299 .update_reg = reg, \ 312 .update_reg = reg, \
300 .mask = reg_mask, \ 313 .mask = reg_mask, \
301 .enable = reg_enable, \ 314 .enable = reg_enable, \
@@ -304,28 +317,29 @@ static struct regulator_ops ab8500_ldo_fixed_ops = {
304static struct ab8500_regulator_info ab8500_regulator_info[] = { 317static struct ab8500_regulator_info ab8500_regulator_info[] = {
305 /* 318 /*
306 * Variable Voltage LDOs 319 * Variable Voltage LDOs
307 * name, min uV, max uV, ctrl reg, reg mask, enable mask, 320 * name, min uV, max uV, ctrl bank, ctrl reg, reg mask, enable mask,
308 * volt ctrl reg, volt ctrl mask, volt table, num supported volts 321 * volt ctrl bank, volt ctrl reg, volt ctrl mask, volt table,
322 * num supported volts
309 */ 323 */
310 AB8500_LDO(AUX1, 1100, 3300, 0x0409, 0x3, 0x1, 0x041f, 0xf, 324 AB8500_LDO(AUX1, 1100, 3300, 0x04, 0x09, 0x3, 0x1, 0x04, 0x1f, 0xf,
311 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)), 325 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
312 AB8500_LDO(AUX2, 1100, 3300, 0x0409, 0xc, 0x4, 0x0420, 0xf, 326 AB8500_LDO(AUX2, 1100, 3300, 0x04, 0x09, 0xc, 0x4, 0x04, 0x20, 0xf,
313 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)), 327 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
314 AB8500_LDO(AUX3, 1100, 3300, 0x040a, 0x3, 0x1, 0x0421, 0xf, 328 AB8500_LDO(AUX3, 1100, 3300, 0x04, 0x0a, 0x3, 0x1, 0x04, 0x21, 0xf,
315 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)), 329 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
316 AB8500_LDO(INTCORE, 1100, 3300, 0x0380, 0x4, 0x4, 0x0380, 0x38, 330 AB8500_LDO(INTCORE, 1100, 3300, 0x03, 0x80, 0x4, 0x4, 0x03, 0x80, 0x38,
317 ldo_vintcore_voltages, ARRAY_SIZE(ldo_vintcore_voltages)), 331 ldo_vintcore_voltages, ARRAY_SIZE(ldo_vintcore_voltages)),
318 332
319 /* 333 /*
320 * Fixed Voltage LDOs 334 * Fixed Voltage LDOs
321 * name, o/p uV, ctrl reg, enable, disable 335 * name, o/p uV, ctrl bank, ctrl reg, enable, disable
322 */ 336 */
323 AB8500_FIXED_LDO(TVOUT, 2000, 0x0380, 0x2, 0x2), 337 AB8500_FIXED_LDO(TVOUT, 2000, 0x03, 0x80, 0x2, 0x2),
324 AB8500_FIXED_LDO(AUDIO, 2000, 0x0383, 0x2, 0x2), 338 AB8500_FIXED_LDO(AUDIO, 2000, 0x03, 0x83, 0x2, 0x2),
325 AB8500_FIXED_LDO(ANAMIC1, 2050, 0x0383, 0x4, 0x4), 339 AB8500_FIXED_LDO(ANAMIC1, 2050, 0x03, 0x83, 0x4, 0x4),
326 AB8500_FIXED_LDO(ANAMIC2, 2050, 0x0383, 0x8, 0x8), 340 AB8500_FIXED_LDO(ANAMIC2, 2050, 0x03, 0x83, 0x8, 0x8),
327 AB8500_FIXED_LDO(DMIC, 1800, 0x0383, 0x10, 0x10), 341 AB8500_FIXED_LDO(DMIC, 1800, 0x03, 0x83, 0x10, 0x10),
328 AB8500_FIXED_LDO(ANA, 1200, 0x0383, 0xc, 0x4), 342 AB8500_FIXED_LDO(ANA, 1200, 0x03, 0x83, 0xc, 0x4),
329}; 343};
330 344
331static inline struct ab8500_regulator_info *find_regulator_info(int id) 345static inline struct ab8500_regulator_info *find_regulator_info(int id)
diff --git a/drivers/regulator/max8998.c b/drivers/regulator/max8998.c
index a1baf1fbe004..5c20756db607 100644
--- a/drivers/regulator/max8998.c
+++ b/drivers/regulator/max8998.c
@@ -39,6 +39,11 @@ struct max8998_data {
39 struct max8998_dev *iodev; 39 struct max8998_dev *iodev;
40 int num_regulators; 40 int num_regulators;
41 struct regulator_dev **rdev; 41 struct regulator_dev **rdev;
42 u8 buck1_vol[4]; /* voltages for selection */
43 u8 buck2_vol[2];
44 unsigned int buck1_idx; /* index to last changed voltage */
45 /* value in a set */
46 unsigned int buck2_idx;
42}; 47};
43 48
44struct voltage_map_desc { 49struct voltage_map_desc {
@@ -173,6 +178,7 @@ static int max8998_get_enable_register(struct regulator_dev *rdev,
173static int max8998_ldo_is_enabled(struct regulator_dev *rdev) 178static int max8998_ldo_is_enabled(struct regulator_dev *rdev)
174{ 179{
175 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 180 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
181 struct i2c_client *i2c = max8998->iodev->i2c;
176 int ret, reg, shift = 8; 182 int ret, reg, shift = 8;
177 u8 val; 183 u8 val;
178 184
@@ -180,7 +186,7 @@ static int max8998_ldo_is_enabled(struct regulator_dev *rdev)
180 if (ret) 186 if (ret)
181 return ret; 187 return ret;
182 188
183 ret = max8998_read_reg(max8998->iodev, reg, &val); 189 ret = max8998_read_reg(i2c, reg, &val);
184 if (ret) 190 if (ret)
185 return ret; 191 return ret;
186 192
@@ -190,31 +196,34 @@ static int max8998_ldo_is_enabled(struct regulator_dev *rdev)
190static int max8998_ldo_enable(struct regulator_dev *rdev) 196static int max8998_ldo_enable(struct regulator_dev *rdev)
191{ 197{
192 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 198 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
199 struct i2c_client *i2c = max8998->iodev->i2c;
193 int reg, shift = 8, ret; 200 int reg, shift = 8, ret;
194 201
195 ret = max8998_get_enable_register(rdev, &reg, &shift); 202 ret = max8998_get_enable_register(rdev, &reg, &shift);
196 if (ret) 203 if (ret)
197 return ret; 204 return ret;
198 205
199 return max8998_update_reg(max8998->iodev, reg, 1<<shift, 1<<shift); 206 return max8998_update_reg(i2c, reg, 1<<shift, 1<<shift);
200} 207}
201 208
202static int max8998_ldo_disable(struct regulator_dev *rdev) 209static int max8998_ldo_disable(struct regulator_dev *rdev)
203{ 210{
204 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 211 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
212 struct i2c_client *i2c = max8998->iodev->i2c;
205 int reg, shift = 8, ret; 213 int reg, shift = 8, ret;
206 214
207 ret = max8998_get_enable_register(rdev, &reg, &shift); 215 ret = max8998_get_enable_register(rdev, &reg, &shift);
208 if (ret) 216 if (ret)
209 return ret; 217 return ret;
210 218
211 return max8998_update_reg(max8998->iodev, reg, 0, 1<<shift); 219 return max8998_update_reg(i2c, reg, 0, 1<<shift);
212} 220}
213 221
214static int max8998_get_voltage_register(struct regulator_dev *rdev, 222static int max8998_get_voltage_register(struct regulator_dev *rdev,
215 int *_reg, int *_shift, int *_mask) 223 int *_reg, int *_shift, int *_mask)
216{ 224{
217 int ldo = max8998_get_ldo(rdev); 225 int ldo = max8998_get_ldo(rdev);
226 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
218 int reg, shift = 0, mask = 0xff; 227 int reg, shift = 0, mask = 0xff;
219 228
220 switch (ldo) { 229 switch (ldo) {
@@ -251,10 +260,10 @@ static int max8998_get_voltage_register(struct regulator_dev *rdev,
251 reg = MAX8998_REG_LDO12 + (ldo - MAX8998_LDO12); 260 reg = MAX8998_REG_LDO12 + (ldo - MAX8998_LDO12);
252 break; 261 break;
253 case MAX8998_BUCK1: 262 case MAX8998_BUCK1:
254 reg = MAX8998_REG_BUCK1_DVSARM1; 263 reg = MAX8998_REG_BUCK1_VOLTAGE1 + max8998->buck1_idx;
255 break; 264 break;
256 case MAX8998_BUCK2: 265 case MAX8998_BUCK2:
257 reg = MAX8998_REG_BUCK2_DVSINT1; 266 reg = MAX8998_REG_BUCK2_VOLTAGE1 + max8998->buck2_idx;
258 break; 267 break;
259 case MAX8998_BUCK3: 268 case MAX8998_BUCK3:
260 reg = MAX8998_REG_BUCK3; 269 reg = MAX8998_REG_BUCK3;
@@ -276,6 +285,7 @@ static int max8998_get_voltage_register(struct regulator_dev *rdev,
276static int max8998_get_voltage(struct regulator_dev *rdev) 285static int max8998_get_voltage(struct regulator_dev *rdev)
277{ 286{
278 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 287 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
288 struct i2c_client *i2c = max8998->iodev->i2c;
279 int reg, shift = 0, mask, ret; 289 int reg, shift = 0, mask, ret;
280 u8 val; 290 u8 val;
281 291
@@ -283,7 +293,7 @@ static int max8998_get_voltage(struct regulator_dev *rdev)
283 if (ret) 293 if (ret)
284 return ret; 294 return ret;
285 295
286 ret = max8998_read_reg(max8998->iodev, reg, &val); 296 ret = max8998_read_reg(i2c, reg, &val);
287 if (ret) 297 if (ret)
288 return ret; 298 return ret;
289 299
@@ -293,18 +303,16 @@ static int max8998_get_voltage(struct regulator_dev *rdev)
293 return max8998_list_voltage(rdev, val); 303 return max8998_list_voltage(rdev, val);
294} 304}
295 305
296static int max8998_set_voltage(struct regulator_dev *rdev, 306static int max8998_set_voltage_ldo(struct regulator_dev *rdev,
297 int min_uV, int max_uV) 307 int min_uV, int max_uV)
298{ 308{
299 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 309 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
310 struct i2c_client *i2c = max8998->iodev->i2c;
300 int min_vol = min_uV / 1000, max_vol = max_uV / 1000; 311 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
301 int previous_vol = 0;
302 const struct voltage_map_desc *desc; 312 const struct voltage_map_desc *desc;
303 int ldo = max8998_get_ldo(rdev); 313 int ldo = max8998_get_ldo(rdev);
304 int reg, shift = 0, mask, ret; 314 int reg, shift = 0, mask, ret;
305 int i = 0; 315 int i = 0;
306 u8 val;
307 bool en_ramp = false;
308 316
309 if (ldo >= ARRAY_SIZE(ldo_voltage_map)) 317 if (ldo >= ARRAY_SIZE(ldo_voltage_map))
310 return -EINVAL; 318 return -EINVAL;
@@ -327,24 +335,155 @@ static int max8998_set_voltage(struct regulator_dev *rdev,
327 if (ret) 335 if (ret)
328 return ret; 336 return ret;
329 337
330 /* wait for RAMP_UP_DELAY if rdev is BUCK1/2 and 338 ret = max8998_update_reg(i2c, reg, i<<shift, mask<<shift);
331 * ENRAMP is ON */ 339
332 if (ldo == MAX8998_BUCK1 || ldo == MAX8998_BUCK2) { 340 return ret;
333 max8998_read_reg(max8998->iodev, MAX8998_REG_ONOFF4, &val); 341}
334 if (val & (1 << 4)) { 342
335 en_ramp = true; 343static inline void buck1_gpio_set(int gpio1, int gpio2, int v)
336 previous_vol = max8998_get_voltage(rdev); 344{
337 } 345 gpio_set_value(gpio1, v & 0x1);
346 gpio_set_value(gpio2, (v >> 1) & 0x1);
347}
348
349static inline void buck2_gpio_set(int gpio, int v)
350{
351 gpio_set_value(gpio, v & 0x1);
352}
353
354static int max8998_set_voltage_buck(struct regulator_dev *rdev,
355 int min_uV, int max_uV)
356{
357 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
358 struct max8998_platform_data *pdata =
359 dev_get_platdata(max8998->iodev->dev);
360 struct i2c_client *i2c = max8998->iodev->i2c;
361 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
362 const struct voltage_map_desc *desc;
363 int buck = max8998_get_ldo(rdev);
364 int reg, shift = 0, mask, ret;
365 int difference = 0, i = 0, j = 0, previous_vol = 0;
366 u8 val = 0;
367 static u8 buck1_last_val;
368
369 if (buck >= ARRAY_SIZE(ldo_voltage_map))
370 return -EINVAL;
371
372 desc = ldo_voltage_map[buck];
373
374 if (desc == NULL)
375 return -EINVAL;
376
377 if (max_vol < desc->min || min_vol > desc->max)
378 return -EINVAL;
379
380 while (desc->min + desc->step*i < min_vol &&
381 desc->min + desc->step*i < desc->max)
382 i++;
383
384 if (desc->min + desc->step*i > max_vol)
385 return -EINVAL;
386
387 ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
388 if (ret)
389 return ret;
390
391 previous_vol = max8998_get_voltage(rdev);
392
393 /* Check if voltage needs to be changed */
394 /* if previous_voltage equal new voltage, return */
395 if (previous_vol == max8998_list_voltage(rdev, i)) {
396 dev_dbg(max8998->dev, "No voltage change, old:%d, new:%d\n",
397 previous_vol, max8998_list_voltage(rdev, i));
398 return ret;
338 } 399 }
339 400
340 ret = max8998_update_reg(max8998->iodev, reg, i<<shift, mask<<shift); 401 switch (buck) {
402 case MAX8998_BUCK1:
403 dev_dbg(max8998->dev,
404 "BUCK1, i:%d, buck1_vol1:%d, buck1_vol2:%d\n\
405 buck1_vol3:%d, buck1_vol4:%d\n",
406 i, max8998->buck1_vol[0], max8998->buck1_vol[1],
407 max8998->buck1_vol[2], max8998->buck1_vol[3]);
408
409 if (gpio_is_valid(pdata->buck1_set1) &&
410 gpio_is_valid(pdata->buck1_set2)) {
411
412 /* check if requested voltage */
413 /* value is already defined */
414 for (j = 0; j < ARRAY_SIZE(max8998->buck1_vol); j++) {
415 if (max8998->buck1_vol[j] == i) {
416 max8998->buck1_idx = j;
417 buck1_gpio_set(pdata->buck1_set1,
418 pdata->buck1_set2, j);
419 goto buck1_exit;
420 }
421 }
422
423 /* no predefine regulator found */
424 max8998->buck1_idx = (buck1_last_val % 2) + 2;
425 dev_dbg(max8998->dev, "max8998->buck1_idx:%d\n",
426 max8998->buck1_idx);
427 max8998->buck1_vol[max8998->buck1_idx] = i;
428 ret = max8998_get_voltage_register(rdev, &reg,
429 &shift,
430 &mask);
431 ret = max8998_write_reg(i2c, reg, i);
432 buck1_gpio_set(pdata->buck1_set1,
433 pdata->buck1_set2, max8998->buck1_idx);
434 buck1_last_val++;
435buck1_exit:
436 dev_dbg(max8998->dev, "%s: SET1:%d, SET2:%d\n",
437 i2c->name, gpio_get_value(pdata->buck1_set1),
438 gpio_get_value(pdata->buck1_set2));
439 break;
440 } else {
441 ret = max8998_write_reg(i2c, reg, i);
442 }
443 break;
444
445 case MAX8998_BUCK2:
446 dev_dbg(max8998->dev,
447 "BUCK2, i:%d buck2_vol1:%d, buck2_vol2:%d\n"
448 , i, max8998->buck2_vol[0], max8998->buck2_vol[1]);
449 if (gpio_is_valid(pdata->buck2_set3)) {
450 if (max8998->buck2_vol[0] == i) {
451 max8998->buck1_idx = 0;
452 buck2_gpio_set(pdata->buck2_set3, 0);
453 } else {
454 max8998->buck1_idx = 1;
455 ret = max8998_get_voltage_register(rdev, &reg,
456 &shift,
457 &mask);
458 ret = max8998_write_reg(i2c, reg, i);
459 max8998->buck2_vol[1] = i;
460 buck2_gpio_set(pdata->buck2_set3, 1);
461 }
462 dev_dbg(max8998->dev, "%s: SET3:%d\n", i2c->name,
463 gpio_get_value(pdata->buck2_set3));
464 } else {
465 ret = max8998_write_reg(i2c, reg, i);
466 }
467 break;
341 468
342 if (en_ramp == true) { 469 case MAX8998_BUCK3:
343 int difference = desc->min + desc->step*i - previous_vol/1000; 470 case MAX8998_BUCK4:
344 if (difference > 0) 471 ret = max8998_update_reg(i2c, reg, i<<shift, mask<<shift);
345 udelay(difference / ((val & 0x0f) + 1)); 472 break;
346 } 473 }
347 474
475 /* Voltage stabilization */
476 max8998_read_reg(i2c, MAX8998_REG_ONOFF4, &val);
477
478 /* lp3974 hasn't got ENRAMP bit - ramp is assumed as true */
479 /* MAX8998 has ENRAMP bit implemented, so test it*/
480 if (max8998->iodev->type == TYPE_MAX8998 && !(val & MAX8998_ENRAMP))
481 return ret;
482
483 difference = desc->min + desc->step*i - previous_vol/1000;
484 if (difference > 0)
485 udelay(difference / ((val & 0x0f) + 1));
486
348 return ret; 487 return ret;
349} 488}
350 489
@@ -354,7 +493,7 @@ static struct regulator_ops max8998_ldo_ops = {
354 .enable = max8998_ldo_enable, 493 .enable = max8998_ldo_enable,
355 .disable = max8998_ldo_disable, 494 .disable = max8998_ldo_disable,
356 .get_voltage = max8998_get_voltage, 495 .get_voltage = max8998_get_voltage,
357 .set_voltage = max8998_set_voltage, 496 .set_voltage = max8998_set_voltage_ldo,
358 .set_suspend_enable = max8998_ldo_enable, 497 .set_suspend_enable = max8998_ldo_enable,
359 .set_suspend_disable = max8998_ldo_disable, 498 .set_suspend_disable = max8998_ldo_disable,
360}; 499};
@@ -365,7 +504,7 @@ static struct regulator_ops max8998_buck_ops = {
365 .enable = max8998_ldo_enable, 504 .enable = max8998_ldo_enable,
366 .disable = max8998_ldo_disable, 505 .disable = max8998_ldo_disable,
367 .get_voltage = max8998_get_voltage, 506 .get_voltage = max8998_get_voltage,
368 .set_voltage = max8998_set_voltage, 507 .set_voltage = max8998_set_voltage_buck,
369 .set_suspend_enable = max8998_ldo_enable, 508 .set_suspend_enable = max8998_ldo_enable,
370 .set_suspend_disable = max8998_ldo_disable, 509 .set_suspend_disable = max8998_ldo_disable,
371}; 510};
@@ -538,6 +677,7 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
538 struct max8998_platform_data *pdata = dev_get_platdata(iodev->dev); 677 struct max8998_platform_data *pdata = dev_get_platdata(iodev->dev);
539 struct regulator_dev **rdev; 678 struct regulator_dev **rdev;
540 struct max8998_data *max8998; 679 struct max8998_data *max8998;
680 struct i2c_client *i2c;
541 int i, ret, size; 681 int i, ret, size;
542 682
543 if (!pdata) { 683 if (!pdata) {
@@ -561,6 +701,86 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
561 max8998->iodev = iodev; 701 max8998->iodev = iodev;
562 max8998->num_regulators = pdata->num_regulators; 702 max8998->num_regulators = pdata->num_regulators;
563 platform_set_drvdata(pdev, max8998); 703 platform_set_drvdata(pdev, max8998);
704 i2c = max8998->iodev->i2c;
705
706 /* NOTE: */
707 /* For unused GPIO NOT marked as -1 (thereof equal to 0) WARN_ON */
708 /* will be displayed */
709
710 /* Check if MAX8998 voltage selection GPIOs are defined */
711 if (gpio_is_valid(pdata->buck1_set1) &&
712 gpio_is_valid(pdata->buck1_set2)) {
713 /* Check if SET1 is not equal to 0 */
714 if (!pdata->buck1_set1) {
715 printk(KERN_ERR "MAX8998 SET1 GPIO defined as 0 !\n");
716 WARN_ON(!pdata->buck1_set1);
717 return -EIO;
718 }
719 /* Check if SET2 is not equal to 0 */
720 if (!pdata->buck1_set2) {
721 printk(KERN_ERR "MAX8998 SET2 GPIO defined as 0 !\n");
722 WARN_ON(!pdata->buck1_set2);
723 return -EIO;
724 }
725
726 gpio_request(pdata->buck1_set1, "MAX8998 BUCK1_SET1");
727 gpio_direction_output(pdata->buck1_set1,
728 max8998->buck1_idx & 0x1);
729
730
731 gpio_request(pdata->buck1_set2, "MAX8998 BUCK1_SET2");
732 gpio_direction_output(pdata->buck1_set2,
733 (max8998->buck1_idx >> 1) & 0x1);
734 /* Set predefined value for BUCK1 register 1 */
735 i = 0;
736 while (buck12_voltage_map_desc.min +
737 buck12_voltage_map_desc.step*i
738 != (pdata->buck1_max_voltage1 / 1000))
739 i++;
740 printk(KERN_ERR "i:%d, buck1_idx:%d\n", i, max8998->buck1_idx);
741 max8998->buck1_vol[0] = i;
742 ret = max8998_write_reg(i2c, MAX8998_REG_BUCK1_VOLTAGE1, i);
743
744 /* Set predefined value for BUCK1 register 2 */
745 i = 0;
746 while (buck12_voltage_map_desc.min +
747 buck12_voltage_map_desc.step*i
748 != (pdata->buck1_max_voltage2 / 1000))
749 i++;
750
751 max8998->buck1_vol[1] = i;
752 printk(KERN_ERR "i:%d, buck1_idx:%d\n", i, max8998->buck1_idx);
753 ret = max8998_write_reg(i2c, MAX8998_REG_BUCK1_VOLTAGE2, i)
754 + ret;
755 if (ret)
756 return ret;
757
758 }
759
760 if (gpio_is_valid(pdata->buck2_set3)) {
761 /* Check if SET3 is not equal to 0 */
762 if (!pdata->buck2_set3) {
763 printk(KERN_ERR "MAX8998 SET3 GPIO defined as 0 !\n");
764 WARN_ON(!pdata->buck2_set3);
765 return -EIO;
766 }
767 gpio_request(pdata->buck2_set3, "MAX8998 BUCK2_SET3");
768 gpio_direction_output(pdata->buck2_set3,
769 max8998->buck2_idx & 0x1);
770
771 /* BUCK2 - set preset default voltage value to buck2_vol[0] */
772 i = 0;
773 while (buck12_voltage_map_desc.min +
774 buck12_voltage_map_desc.step*i
775 != (pdata->buck2_max_voltage / 1000))
776 i++;
777 printk(KERN_ERR "i:%d, buck2_idx:%d\n", i, max8998->buck2_idx);
778 max8998->buck2_vol[0] = i;
779 ret = max8998_write_reg(i2c, MAX8998_REG_BUCK2_VOLTAGE1, i);
780 if (ret)
781 return ret;
782
783 }
564 784
565 for (i = 0; i < pdata->num_regulators; i++) { 785 for (i = 0; i < pdata->num_regulators; i++) {
566 const struct voltage_map_desc *desc; 786 const struct voltage_map_desc *desc;
generated by cgit v1.2.2 (git 2.25.0) at 2025-10-13 06:51:34 -0400