projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
regulator: tps80031: Implement list_voltage and set n_voltages = 1 for fixed regulators
[deliverable/linux.git] / drivers / regulator / tps80031-regulator.c
CommitLineData
1a0bb679
LD		 1/*
2 * tps80031-regulator.c -- TI TPS80031 regulator driver.
3 *
1a7ae58e 4 * Regulator driver for TI TPS80031/TPS80032 Fully Integrated Power
1a0bb679
LD		 5 * Management with Power Path and Battery Charger.
6 *
7 * Copyright (c) 2012, NVIDIA Corporation.
8 *
9 * Author: Laxman Dewangan <ldewangan@nvidia.com>
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation version 2.
14 *
15 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
16 * whether express or implied; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
23 * 02111-1307, USA
24 */
25
26#include <linux/delay.h>
27#include <linux/err.h>
28#include <linux/init.h>
29#include <linux/kernel.h>
30#include <linux/mfd/tps80031.h>
31#include <linux/module.h>
32#include <linux/platform_device.h>
33#include <linux/regulator/driver.h>
34#include <linux/regulator/machine.h>
35#include <linux/slab.h>
36
37/* Flags for DCDC Voltage reading */
38#define DCDC_OFFSET_EN BIT(0)
39#define DCDC_EXTENDED_EN BIT(1)
40#define TRACK_MODE_ENABLE BIT(2)
41
42#define SMPS_MULTOFFSET_VIO BIT(1)
43#define SMPS_MULTOFFSET_SMPS1 BIT(3)
44#define SMPS_MULTOFFSET_SMPS2 BIT(4)
45#define SMPS_MULTOFFSET_SMPS3 BIT(6)
46#define SMPS_MULTOFFSET_SMPS4 BIT(0)
47
48#define SMPS_CMD_MASK 0xC0
49#define SMPS_VSEL_MASK 0x3F
50#define LDO_VSEL_MASK 0x1F
51#define LDO_TRACK_VSEL_MASK 0x3F
52
53#define MISC2_LDOUSB_IN_VSYS BIT(4)
54#define MISC2_LDOUSB_IN_PMID BIT(3)
55#define MISC2_LDOUSB_IN_MASK 0x18
56
57#define MISC2_LDO3_SEL_VIB_VAL BIT(0)
58#define MISC2_LDO3_SEL_VIB_MASK 0x1
59
60#define BOOST_HW_PWR_EN BIT(5)
61#define BOOST_HW_PWR_EN_MASK BIT(5)
62
63#define OPA_MODE_EN BIT(6)
64#define OPA_MODE_EN_MASK BIT(6)
65
66#define USB_VBUS_CTRL_SET 0x04
67#define USB_VBUS_CTRL_CLR 0x05
68#define VBUS_DISCHRG 0x20
69
70struct tps80031_regulator_info {
71 /* Regulator register address.*/
72 u8 trans_reg;
73 u8 state_reg;
74 u8 force_reg;
75 u8 volt_reg;
76 u8 volt_id;
77
78 /*Power request bits */
79 int preq_bit;
80
81 /* used by regulator core */
82 struct regulator_desc desc;
83
84};
85
86struct tps80031_regulator {
87 struct device *dev;
88 struct regulator_dev *rdev;
89 struct tps80031_regulator_info *rinfo;
90
91 u8 device_flags;
92 unsigned int config_flags;
93 unsigned int ext_ctrl_flag;
94};
95
96static inline struct device *to_tps80031_dev(struct regulator_dev *rdev)
97{
98 return rdev_get_dev(rdev)->parent->parent;
99}
100
101static int tps80031_reg_is_enabled(struct regulator_dev *rdev)
102{
103 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
104 struct device *parent = to_tps80031_dev(rdev);
105 u8 reg_val;
106 int ret;
107
b92f787d 108 if (ri->ext_ctrl_flag & TPS80031_EXT_PWR_REQ)
1a0bb679
LD		 109 return true;
110
b92f787d
LD		 111 ret = tps80031_read(parent, TPS80031_SLAVE_ID1, ri->rinfo->state_reg,
112 &reg_val);
1a0bb679
LD		 113 if (ret < 0) {
114 dev_err(&rdev->dev, "Reg 0x%02x read failed, err = %d\n",
115 ri->rinfo->state_reg, ret);
116 return ret;
117 }
b92f787d 118 return ((reg_val & TPS80031_STATE_MASK) == TPS80031_STATE_ON);
1a0bb679
LD		 119}
120
121static int tps80031_reg_enable(struct regulator_dev *rdev)
122{
123 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
124 struct device *parent = to_tps80031_dev(rdev);
125 int ret;
126
b92f787d 127 if (ri->ext_ctrl_flag & TPS80031_EXT_PWR_REQ)
1a0bb679
LD		 128 return 0;
129
b92f787d
LD		 130 ret = tps80031_update(parent, TPS80031_SLAVE_ID1, ri->rinfo->state_reg,
131 TPS80031_STATE_ON, TPS80031_STATE_MASK);
1a0bb679
LD		 132 if (ret < 0) {
133 dev_err(&rdev->dev, "Reg 0x%02x update failed, err = %d\n",
134 ri->rinfo->state_reg, ret);
135 return ret;
136 }
137 return ret;
138}
139
140static int tps80031_reg_disable(struct regulator_dev *rdev)
141{
142 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
143 struct device *parent = to_tps80031_dev(rdev);
144 int ret;
145
b92f787d 146 if (ri->ext_ctrl_flag & TPS80031_EXT_PWR_REQ)
1a0bb679
LD		 147 return 0;
148
b92f787d
LD		 149 ret = tps80031_update(parent, TPS80031_SLAVE_ID1, ri->rinfo->state_reg,
150 TPS80031_STATE_OFF, TPS80031_STATE_MASK);
1a0bb679
LD		 151 if (ret < 0)
152 dev_err(&rdev->dev, "Reg 0x%02x update failed, err = %d\n",
153 ri->rinfo->state_reg, ret);
154 return ret;
155}
156
157/* DCDC voltages for the selector of 58 to 63 */
158static int tps80031_dcdc_voltages[4][5] = {
159 { 1350, 1500, 1800, 1900, 2100},
160 { 1350, 1500, 1800, 1900, 2100},
161 { 2084, 2315, 2778, 2932, 3241},
162 { 4167, 2315, 2778, 2932, 3241},
163};
164
165static int tps80031_dcdc_list_voltage(struct regulator_dev *rdev, unsigned sel)
166{
167 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
168 int volt_index = ri->device_flags & 0x3;
169
170 if (sel == 0)
171 return 0;
172 else if (sel < 58)
173 return regulator_list_voltage_linear(rdev, sel - 1);
174 else
175 return tps80031_dcdc_voltages[volt_index][sel - 58] * 1000;
176}
177
178static int tps80031_dcdc_set_voltage_sel(struct regulator_dev *rdev,
179 unsigned vsel)
180{
181 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
182 struct device *parent = to_tps80031_dev(rdev);
183 int ret;
184 u8 reg_val;
185
186 if (ri->rinfo->force_reg) {
187 ret = tps80031_read(parent, ri->rinfo->volt_id,
188 ri->rinfo->force_reg, &reg_val);
189 if (ret < 0) {
190 dev_err(ri->dev, "reg 0x%02x read failed, e = %d\n",
191 ri->rinfo->force_reg, ret);
192 return ret;
193 }
194 if (!(reg_val & SMPS_CMD_MASK)) {
195 ret = tps80031_update(parent, ri->rinfo->volt_id,
196 ri->rinfo->force_reg, vsel, SMPS_VSEL_MASK);
197 if (ret < 0)
198 dev_err(ri->dev,
199 "reg 0x%02x update failed, e = %d\n",
200 ri->rinfo->force_reg, ret);
201 return ret;
202 }
203 }
204 ret = tps80031_update(parent, ri->rinfo->volt_id,
205 ri->rinfo->volt_reg, vsel, SMPS_VSEL_MASK);
206 if (ret < 0)
207 dev_err(ri->dev, "reg 0x%02x update failed, e = %d\n",
208 ri->rinfo->volt_reg, ret);
209 return ret;
210}
211
212static int tps80031_dcdc_get_voltage_sel(struct regulator_dev *rdev)
213{
214 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
215 struct device *parent = to_tps80031_dev(rdev);
216 uint8_t vsel = 0;
217 int ret;
218
219 if (ri->rinfo->force_reg) {
220 ret = tps80031_read(parent, ri->rinfo->volt_id,
221 ri->rinfo->force_reg, &vsel);
222 if (ret < 0) {
223 dev_err(ri->dev, "reg 0x%02x read failed, e = %d\n",
224 ri->rinfo->force_reg, ret);
225 return ret;
226 }
227
228 if (!(vsel & SMPS_CMD_MASK))
229 return vsel & SMPS_VSEL_MASK;
230 }
231 ret = tps80031_read(parent, ri->rinfo->volt_id,
232 ri->rinfo->volt_reg, &vsel);
233 if (ret < 0) {
234 dev_err(ri->dev, "reg 0x%02x read failed, e = %d\n",
235 ri->rinfo->volt_reg, ret);
236 return ret;
237 }
238 return vsel & SMPS_VSEL_MASK;
239}
240
241static int tps80031_ldo_set_voltage_sel(struct regulator_dev *rdev,
242 unsigned sel)
243{
244 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
245 struct device *parent = to_tps80031_dev(rdev);
246 int ret;
247
248 /* Check for valid setting for TPS80031 or TPS80032-ES1.0 */
249 if ((ri->rinfo->desc.id == TPS80031_REGULATOR_LDO2) &&
250 (ri->device_flags & TRACK_MODE_ENABLE)) {
251 unsigned nvsel = (sel) & 0x1F;
252 if (((tps80031_get_chip_info(parent) == TPS80031) ||
253 ((tps80031_get_chip_info(parent) == TPS80032) &&
254 (tps80031_get_pmu_version(parent) == 0x0))) &&
255 ((nvsel == 0x0) || (nvsel >= 0x19 && nvsel <= 0x1F))) {
256 dev_err(ri->dev,
257 "Invalid sel %d in track mode LDO2\n",
258 nvsel);
259 return -EINVAL;
260 }
261 }
262
263 ret = tps80031_write(parent, ri->rinfo->volt_id,
264 ri->rinfo->volt_reg, sel);
265 if (ret < 0)
266 dev_err(ri->dev, "Error in writing reg 0x%02x, e = %d\n",
267 ri->rinfo->volt_reg, ret);
268 return ret;
269}
270
271static int tps80031_ldo_get_voltage_sel(struct regulator_dev *rdev)
272{
273 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
274 struct device *parent = to_tps80031_dev(rdev);
275 uint8_t vsel;
276 int ret;
277
278 ret = tps80031_read(parent, ri->rinfo->volt_id,
279 ri->rinfo->volt_reg, &vsel);
280 if (ret < 0) {
281 dev_err(ri->dev, "Error in writing the Voltage register\n");
282 return ret;
283 }
284 return vsel & rdev->desc->vsel_mask;
285}
286
287static int tps80031_ldo_list_voltage(struct regulator_dev *rdev, unsigned sel)
288{
289 if (sel == 0)
290 return 0;
291 else
292 return regulator_list_voltage_linear(rdev, sel - 1);
293}
294
295static int tps80031_vbus_is_enabled(struct regulator_dev *rdev)
296{
297 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
298 struct device *parent = to_tps80031_dev(rdev);
299 int ret = -EIO;
300 uint8_t ctrl1 = 0;
301 uint8_t ctrl3 = 0;
302
b92f787d 303 ret = tps80031_read(parent, TPS80031_SLAVE_ID2,
1a0bb679
LD		 304 TPS80031_CHARGERUSB_CTRL1, &ctrl1);
305 if (ret < 0) {
306 dev_err(ri->dev, "reg 0x%02x read failed, e = %d\n",
307 TPS80031_CHARGERUSB_CTRL1, ret);
308 return ret;
309 }
b92f787d 310 ret = tps80031_read(parent, TPS80031_SLAVE_ID2,
1a0bb679
LD		 311 TPS80031_CHARGERUSB_CTRL3, &ctrl3);
312 if (ret < 0) {
313 dev_err(ri->dev, "reg 0x%02x read failed, e = %d\n",
1a7ae58e 314 TPS80031_CHARGERUSB_CTRL3, ret);
1a0bb679
LD		 315 return ret;
316 }
317 if ((ctrl1 & OPA_MODE_EN) && (ctrl3 & BOOST_HW_PWR_EN))
318 return 1;
319 return ret;
320}
321
322static int tps80031_vbus_enable(struct regulator_dev *rdev)
323{
324 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
325 struct device *parent = to_tps80031_dev(rdev);
326 int ret;
327
b92f787d 328 ret = tps80031_set_bits(parent, TPS80031_SLAVE_ID2,
1a0bb679
LD		 329 TPS80031_CHARGERUSB_CTRL1, OPA_MODE_EN);
330 if (ret < 0) {
331 dev_err(ri->dev, "reg 0x%02x read failed, e = %d\n",
332 TPS80031_CHARGERUSB_CTRL1, ret);
333 return ret;
334 }
335
b92f787d 336 ret = tps80031_set_bits(parent, TPS80031_SLAVE_ID2,
1a0bb679
LD		 337 TPS80031_CHARGERUSB_CTRL3, BOOST_HW_PWR_EN);
338 if (ret < 0) {
339 dev_err(ri->dev, "reg 0x%02x read failed, e = %d\n",
340 TPS80031_CHARGERUSB_CTRL3, ret);
341 return ret;
342 }
343 return ret;
344}
345
346static int tps80031_vbus_disable(struct regulator_dev *rdev)
347{
348 struct tps80031_regulator *ri = rdev_get_drvdata(rdev);
349 struct device *parent = to_tps80031_dev(rdev);
350 int ret = 0;
351
b92f787d
LD		 352 if (ri->config_flags & TPS80031_VBUS_DISCHRG_EN_PDN) {
353 ret = tps80031_write(parent, TPS80031_SLAVE_ID2,
1a0bb679
LD		 354 USB_VBUS_CTRL_SET, VBUS_DISCHRG);
355 if (ret < 0) {
356 dev_err(ri->dev, "reg 0x%02x write failed, e = %d\n",
357 USB_VBUS_CTRL_SET, ret);
358 return ret;
359 }
360 }
361
b92f787d 362 ret = tps80031_clr_bits(parent, TPS80031_SLAVE_ID2,
1a0bb679
LD		 363 TPS80031_CHARGERUSB_CTRL1, OPA_MODE_EN);
364 if (ret < 0) {
365 dev_err(ri->dev, "reg 0x%02x clearbit failed, e = %d\n",
366 TPS80031_CHARGERUSB_CTRL1, ret);
367 return ret;
368 }
369
b92f787d 370 ret = tps80031_clr_bits(parent, TPS80031_SLAVE_ID2,
1a0bb679
LD		 371 TPS80031_CHARGERUSB_CTRL3, BOOST_HW_PWR_EN);
372 if (ret < 0) {
373 dev_err(ri->dev, "reg 0x%02x clearbit failed, e = %d\n",
374 TPS80031_CHARGERUSB_CTRL3, ret);
375 return ret;
376 }
377
378 mdelay(DIV_ROUND_UP(ri->rinfo->desc.enable_time, 1000));
b92f787d
LD		 379 if (ri->config_flags & TPS80031_VBUS_DISCHRG_EN_PDN) {
380 ret = tps80031_write(parent, TPS80031_SLAVE_ID2,
1a0bb679
LD		 381 USB_VBUS_CTRL_CLR, VBUS_DISCHRG);
382 if (ret < 0) {
383 dev_err(ri->dev, "reg 0x%02x write failed, e = %d\n",
384 USB_VBUS_CTRL_CLR, ret);
385 return ret;
386 }
387 }
388 return ret;
389}
390
391static struct regulator_ops tps80031_dcdc_ops = {
392 .list_voltage = tps80031_dcdc_list_voltage,
393 .set_voltage_sel = tps80031_dcdc_set_voltage_sel,
394 .get_voltage_sel = tps80031_dcdc_get_voltage_sel,
395 .enable = tps80031_reg_enable,
396 .disable = tps80031_reg_disable,
397 .is_enabled = tps80031_reg_is_enabled,
398};
399
400static struct regulator_ops tps80031_ldo_ops = {
401 .list_voltage = tps80031_ldo_list_voltage,
402 .set_voltage_sel = tps80031_ldo_set_voltage_sel,
403 .get_voltage_sel = tps80031_ldo_get_voltage_sel,
404 .enable = tps80031_reg_enable,
405 .disable = tps80031_reg_disable,
406 .is_enabled = tps80031_reg_is_enabled,
407};
408
409static struct regulator_ops tps80031_vbus_sw_ops = {
bf0caae3 410 .list_voltage = regulator_list_voltage_linear,
1a0bb679
LD		 411 .enable = tps80031_vbus_enable,
412 .disable = tps80031_vbus_disable,
413 .is_enabled = tps80031_vbus_is_enabled,
414};
415
416static struct regulator_ops tps80031_vbus_hw_ops = {
bf0caae3 417 .list_voltage = regulator_list_voltage_linear,
1a0bb679
LD		 418};
419
420static struct regulator_ops tps80031_ext_reg_ops = {
bf0caae3 421 .list_voltage = regulator_list_voltage_linear,
1a0bb679
LD		 422 .enable = tps80031_reg_enable,
423 .disable = tps80031_reg_disable,
424 .is_enabled = tps80031_reg_is_enabled,
425};
426
427/* Non-exiting default definition for some register */
428#define TPS80031_SMPS3_CFG_FORCE 0
429#define TPS80031_SMPS4_CFG_FORCE 0
430
431#define TPS80031_VBUS_CFG_TRANS 0
432#define TPS80031_VBUS_CFG_STATE 0
433
434#define TPS80031_REG_SMPS(_id, _volt_id, _pbit) \
435{ \
436 .trans_reg = TPS80031_##_id##_CFG_TRANS, \
437 .state_reg = TPS80031_##_id##_CFG_STATE, \
438 .force_reg = TPS80031_##_id##_CFG_FORCE, \
439 .volt_reg = TPS80031_##_id##_CFG_VOLTAGE, \
b92f787d 440 .volt_id = TPS80031_SLAVE_##_volt_id, \
1a0bb679
LD		 441 .preq_bit = _pbit, \
442 .desc = { \
443 .name = "tps80031_"#_id, \
444 .id = TPS80031_REGULATOR_##_id, \
445 .n_voltages = 63, \
446 .ops = &tps80031_dcdc_ops, \
447 .type = REGULATOR_VOLTAGE, \
448 .owner = THIS_MODULE, \
449 .enable_time = 500, \
450 }, \
451}
452
453#define TPS80031_REG_LDO(_id, _preq_bit) \
454{ \
455 .trans_reg = TPS80031_##_id##_CFG_TRANS, \
456 .state_reg = TPS80031_##_id##_CFG_STATE, \
457 .volt_reg = TPS80031_##_id##_CFG_VOLTAGE, \
b92f787d 458 .volt_id = TPS80031_SLAVE_ID1, \
1a0bb679
LD		 459 .preq_bit = _preq_bit, \
460 .desc = { \
461 .owner = THIS_MODULE, \
462 .name = "tps80031_"#_id, \
463 .id = TPS80031_REGULATOR_##_id, \
464 .ops = &tps80031_ldo_ops, \
465 .type = REGULATOR_VOLTAGE, \
466 .min_uV = 1000000, \
467 .uV_step = 100000, \
468 .n_voltages = 25, \
469 .vsel_mask = LDO_VSEL_MASK, \
470 .enable_time = 500, \
471 }, \
472}
473
474#define TPS80031_REG_FIXED(_id, max_mV, _ops, _delay, _pbit) \
475{ \
476 .trans_reg = TPS80031_##_id##_CFG_TRANS, \
477 .state_reg = TPS80031_##_id##_CFG_STATE, \
b92f787d 478 .volt_id = TPS80031_SLAVE_ID1, \
1a0bb679
LD		 479 .preq_bit = _pbit, \
480 .desc = { \
481 .name = "tps80031_"#_id, \
482 .id = TPS80031_REGULATOR_##_id, \
bf0caae3
AL		 483 .min_uV = max_mV * 1000, \
484 .n_voltages = 1, \
1a0bb679
LD		 485 .ops = &_ops, \
486 .type = REGULATOR_VOLTAGE, \
487 .owner = THIS_MODULE, \
488 .enable_time = _delay, \
489 }, \
490}
491
492static struct tps80031_regulator_info tps80031_rinfo[TPS80031_REGULATOR_MAX] = {
493 TPS80031_REG_SMPS(VIO, ID0, 4),
494 TPS80031_REG_SMPS(SMPS1, ID0, 0),
495 TPS80031_REG_SMPS(SMPS2, ID0, 1),
496 TPS80031_REG_SMPS(SMPS3, ID1, 2),
497 TPS80031_REG_SMPS(SMPS4, ID1, 3),
498 TPS80031_REG_LDO(VANA, -1),
499 TPS80031_REG_LDO(LDO1, 8),
500 TPS80031_REG_LDO(LDO2, 9),
501 TPS80031_REG_LDO(LDO3, 10),
502 TPS80031_REG_LDO(LDO4, 11),
503 TPS80031_REG_LDO(LDO5, 12),
504 TPS80031_REG_LDO(LDO6, 13),
505 TPS80031_REG_LDO(LDO7, 14),
506 TPS80031_REG_LDO(LDOLN, 15),
507 TPS80031_REG_LDO(LDOUSB, 5),
508 TPS80031_REG_FIXED(VBUS, 5000, tps80031_vbus_hw_ops, 100000, -1),
509 TPS80031_REG_FIXED(REGEN1, 3300, tps80031_ext_reg_ops, 0, 16),
510 TPS80031_REG_FIXED(REGEN2, 3300, tps80031_ext_reg_ops, 0, 17),
511 TPS80031_REG_FIXED(SYSEN, 3300, tps80031_ext_reg_ops, 0, 18),
512};
513
514static int tps80031_power_req_config(struct device *parent,
515 struct tps80031_regulator *ri,
516 struct tps80031_regulator_platform_data *tps80031_pdata)
517{
518 int ret = 0;
519
520 if (ri->rinfo->preq_bit < 0)
521 goto skip_pwr_req_config;
522
523 ret = tps80031_ext_power_req_config(parent, ri->ext_ctrl_flag,
524 ri->rinfo->preq_bit, ri->rinfo->state_reg,
525 ri->rinfo->trans_reg);
526 if (ret < 0) {
527 dev_err(ri->dev, "ext powerreq config failed, err = %d\n", ret);
528 return ret;
529 }
530
531skip_pwr_req_config:
b92f787d
LD		 532 if (tps80031_pdata->ext_ctrl_flag & TPS80031_PWR_ON_ON_SLEEP) {
533 ret = tps80031_update(parent, TPS80031_SLAVE_ID1,
534 ri->rinfo->trans_reg, TPS80031_TRANS_SLEEP_ON,
535 TPS80031_TRANS_SLEEP_MASK);
1a0bb679
LD		 536 if (ret < 0) {
537 dev_err(ri->dev, "Reg 0x%02x update failed, e %d\n",
538 ri->rinfo->trans_reg, ret);
539 return ret;
540 }
541 }
542 return ret;
543}
544
545static int tps80031_regulator_config(struct device *parent,
546 struct tps80031_regulator *ri,
547 struct tps80031_regulator_platform_data *tps80031_pdata)
548{
549 int ret = 0;
550
551 switch (ri->rinfo->desc.id) {
552 case TPS80031_REGULATOR_LDOUSB:
b92f787d
LD		 553 if (ri->config_flags & (TPS80031_USBLDO_INPUT_VSYS |
554 TPS80031_USBLDO_INPUT_PMID)) {
1a0bb679 555 unsigned val = 0;
b92f787d 556 if (ri->config_flags & TPS80031_USBLDO_INPUT_VSYS)
1a0bb679
LD		 557 val = MISC2_LDOUSB_IN_VSYS;
558 else
559 val = MISC2_LDOUSB_IN_PMID;
560
b92f787d
LD		 561 ret = tps80031_update(parent, TPS80031_SLAVE_ID1,
562 TPS80031_MISC2, val,
563 MISC2_LDOUSB_IN_MASK);
1a0bb679
LD		 564 if (ret < 0) {
565 dev_err(ri->dev,
566 "LDOUSB config failed, e= %d\n", ret);
567 return ret;
568 }
569 }
570 break;
571
572 case TPS80031_REGULATOR_LDO3:
b92f787d
LD		 573 if (ri->config_flags & TPS80031_LDO3_OUTPUT_VIB) {
574 ret = tps80031_update(parent, TPS80031_SLAVE_ID1,
1a0bb679
LD		 575 TPS80031_MISC2, MISC2_LDO3_SEL_VIB_VAL,
576 MISC2_LDO3_SEL_VIB_MASK);
577 if (ret < 0) {
578 dev_err(ri->dev,
579 "LDO3 config failed, e = %d\n", ret);
580 return ret;
581 }
582 }
583 break;
584
585 case TPS80031_REGULATOR_VBUS:
586 /* Provide SW control Ops if VBUS is SW control */
b92f787d 587 if (!(ri->config_flags & TPS80031_VBUS_SW_ONLY))
1a0bb679
LD		 588 ri->rinfo->desc.ops = &tps80031_vbus_sw_ops;
589 break;
590 default:
591 break;
592 }
593
594 /* Configure Active state to ON, SLEEP to OFF and OFF_state to OFF */
b92f787d
LD		 595 ret = tps80031_update(parent, TPS80031_SLAVE_ID1, ri->rinfo->trans_reg,
596 TPS80031_TRANS_ACTIVE_ON | TPS80031_TRANS_SLEEP_OFF |
597 TPS80031_TRANS_OFF_OFF, TPS80031_TRANS_ACTIVE_MASK |
598 TPS80031_TRANS_SLEEP_MASK | TPS80031_TRANS_OFF_MASK);
1a0bb679
LD		 599 if (ret < 0) {
600 dev_err(ri->dev, "trans reg update failed, e %d\n", ret);
601 return ret;
602 }
603
604 return ret;
605}
606
607static int check_smps_mode_mult(struct device *parent,
608 struct tps80031_regulator *ri)
609{
610 int mult_offset;
611 int ret;
612 u8 smps_offset;
613 u8 smps_mult;
614
b92f787d 615 ret = tps80031_read(parent, TPS80031_SLAVE_ID1,
1a0bb679
LD		 616 TPS80031_SMPS_OFFSET, &smps_offset);
617 if (ret < 0) {
618 dev_err(parent, "Error in reading smps offset register\n");
619 return ret;
620 }
621
b92f787d 622 ret = tps80031_read(parent, TPS80031_SLAVE_ID1,
1a0bb679
LD		 623 TPS80031_SMPS_MULT, &smps_mult);
624 if (ret < 0) {
625 dev_err(parent, "Error in reading smps mult register\n");
626 return ret;
627 }
628
629 switch (ri->rinfo->desc.id) {
630 case TPS80031_REGULATOR_VIO:
631 mult_offset = SMPS_MULTOFFSET_VIO;
632 break;
633 case TPS80031_REGULATOR_SMPS1:
634 mult_offset = SMPS_MULTOFFSET_SMPS1;
635 break;
636 case TPS80031_REGULATOR_SMPS2:
637 mult_offset = SMPS_MULTOFFSET_SMPS2;
638 break;
639 case TPS80031_REGULATOR_SMPS3:
640 mult_offset = SMPS_MULTOFFSET_SMPS3;
641 break;
642 case TPS80031_REGULATOR_SMPS4:
643 mult_offset = SMPS_MULTOFFSET_SMPS4;
644 break;
645 case TPS80031_REGULATOR_LDO2:
646 ri->device_flags = smps_mult & BIT(5) ? TRACK_MODE_ENABLE : 0;
647 /* TRACK mode the ldo2 varies from 600mV to 1300mV */
648 if (ri->device_flags & TRACK_MODE_ENABLE) {
649 ri->rinfo->desc.min_uV = 600000;
650 ri->rinfo->desc.uV_step = 12500;
651 ri->rinfo->desc.n_voltages = 57;
652 ri->rinfo->desc.vsel_mask = LDO_TRACK_VSEL_MASK;
653 }
654 return 0;
655 default:
656 return 0;
657 }
658
659 ri->device_flags = (smps_offset & mult_offset) ? DCDC_OFFSET_EN : 0;
660 ri->device_flags |= (smps_mult & mult_offset) ? DCDC_EXTENDED_EN : 0;
661 switch (ri->device_flags) {
662 case 0:
663 ri->rinfo->desc.min_uV = 607700;
664 ri->rinfo->desc.uV_step = 12660;
665 break;
666 case DCDC_OFFSET_EN:
667 ri->rinfo->desc.min_uV = 700000;
668 ri->rinfo->desc.uV_step = 12500;
669 break;
670 case DCDC_EXTENDED_EN:
671 ri->rinfo->desc.min_uV = 1852000;
672 ri->rinfo->desc.uV_step = 38600;
673 break;
674 case DCDC_OFFSET_EN | DCDC_EXTENDED_EN:
675 ri->rinfo->desc.min_uV = 2161000;
676 ri->rinfo->desc.uV_step = 38600;
677 break;
678 }
679 return 0;
680}
681
682static int __devinit tps80031_regulator_probe(struct platform_device *pdev)
683{
684 struct tps80031_platform_data *pdata;
685 struct tps80031_regulator_platform_data *tps_pdata;
1a0bb679
LD		 686 struct tps80031_regulator *ri;
687 struct tps80031_regulator *pmic;
688 struct regulator_dev *rdev;
689 struct regulator_config config = { };
690 int ret;
691 int num;
692
693 pdata = dev_get_platdata(pdev->dev.parent);
694
695 if (!pdata) {
696 dev_err(&pdev->dev, "No platform data\n");
697 return -EINVAL;
698 }
699
700 pmic = devm_kzalloc(&pdev->dev,
701 TPS80031_REGULATOR_MAX * sizeof(*pmic), GFP_KERNEL);
702 if (!pmic) {
703 dev_err(&pdev->dev, "mem alloc for pmic failed\n");
704 return -ENOMEM;
705 }
706
707 for (num = 0; num < TPS80031_REGULATOR_MAX; ++num) {
708 tps_pdata = pdata->regulator_pdata[num];
1a0bb679 709 ri = &pmic[num];
1a7ae58e 710 ri->rinfo = &tps80031_rinfo[num];
1a0bb679
LD		 711 ri->dev = &pdev->dev;
712
713 check_smps_mode_mult(pdev->dev.parent, ri);
714 config.dev = &pdev->dev;
715 config.init_data = NULL;
716 config.driver_data = ri;
717 if (tps_pdata) {
718 config.init_data = tps_pdata->reg_init_data;
719 ri->config_flags = tps_pdata->config_flags;
720 ri->ext_ctrl_flag = tps_pdata->ext_ctrl_flag;
721 ret = tps80031_regulator_config(pdev->dev.parent,
722 ri, tps_pdata);
723 if (ret < 0) {
724 dev_err(&pdev->dev,
725 "regulator config failed, e %d\n", ret);
726 goto fail;
727 }
728
729 ret = tps80031_power_req_config(pdev->dev.parent,
730 ri, tps_pdata);
731 if (ret < 0) {
732 dev_err(&pdev->dev,
733 "pwr_req config failed, err %d\n", ret);
734 goto fail;
735 }
736 }
737 rdev = regulator_register(&ri->rinfo->desc, &config);
738 if (IS_ERR_OR_NULL(rdev)) {
739 dev_err(&pdev->dev,
740 "register regulator failed %s\n",
741 ri->rinfo->desc.name);
742 ret = PTR_ERR(rdev);
743 goto fail;
744 }
745 ri->rdev = rdev;
746 }
747
748 platform_set_drvdata(pdev, pmic);
749 return 0;
750fail:
751 while (--num >= 0) {
752 ri = &pmic[num];
753 regulator_unregister(ri->rdev);
754 }
755 return ret;
756}
757
758static int __devexit tps80031_regulator_remove(struct platform_device *pdev)
759{
760 struct tps80031_regulator *pmic = platform_get_drvdata(pdev);
761 struct tps80031_regulator *ri = NULL;
762 int num;
763
764 for (num = 0; num < TPS80031_REGULATOR_MAX; ++num) {
765 ri = &pmic[num];
766 regulator_unregister(ri->rdev);
767 }
768 return 0;
769}
770
771static struct platform_driver tps80031_regulator_driver = {
772 .driver = {
773 .name = "tps80031-pmic",
774 .owner = THIS_MODULE,
775 },
776 .probe = tps80031_regulator_probe,
777 .remove = __devexit_p(tps80031_regulator_remove),
778};
779
780static int __init tps80031_regulator_init(void)
781{
782 return platform_driver_register(&tps80031_regulator_driver);
783}
784subsys_initcall(tps80031_regulator_init);
785
786static void __exit tps80031_regulator_exit(void)
787{
788 platform_driver_unregister(&tps80031_regulator_driver);
789}
790module_exit(tps80031_regulator_exit);
791
792MODULE_ALIAS("platform:tps80031-regulator");
1a7ae58e 793MODULE_DESCRIPTION("Regulator Driver for TI TPS80031/TPS80032 PMIC");
1a0bb679
LD		 794MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
795MODULE_LICENSE("GPL v2");
Linux kernel - Deliverables
This page took 0.061394 seconds and 5 git commands to generate.