blob: 708f4b6a17dcb02ee45b26223db11fc78b3319e3 [file] [log] [blame]
Kim, Miloaf8b5fc2012-06-19 07:08:22 +00001/*
2 * Copyright 2012 Texas Instruments
3 *
4 * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 */
11
12#include <linux/module.h>
13#include <linux/slab.h>
14#include <linux/i2c.h>
15#include <linux/regmap.h>
16#include <linux/err.h>
17#include <linux/gpio.h>
18#include <linux/regulator/lp872x.h>
19#include <linux/regulator/driver.h>
20#include <linux/platform_device.h>
21
22/* Registers : LP8720/8725 shared */
23#define LP872X_GENERAL_CFG 0x00
24#define LP872X_LDO1_VOUT 0x01
25#define LP872X_LDO2_VOUT 0x02
26#define LP872X_LDO3_VOUT 0x03
27#define LP872X_LDO4_VOUT 0x04
28#define LP872X_LDO5_VOUT 0x05
29
30/* Registers : LP8720 */
31#define LP8720_BUCK_VOUT1 0x06
32#define LP8720_BUCK_VOUT2 0x07
33#define LP8720_ENABLE 0x08
34
35/* Registers : LP8725 */
36#define LP8725_LILO1_VOUT 0x06
37#define LP8725_LILO2_VOUT 0x07
38#define LP8725_BUCK1_VOUT1 0x08
39#define LP8725_BUCK1_VOUT2 0x09
40#define LP8725_BUCK2_VOUT1 0x0A
41#define LP8725_BUCK2_VOUT2 0x0B
42#define LP8725_BUCK_CTRL 0x0C
43#define LP8725_LDO_CTRL 0x0D
44
45/* Mask/shift : LP8720/LP8725 shared */
46#define LP872X_VOUT_M 0x1F
47#define LP872X_START_DELAY_M 0xE0
48#define LP872X_START_DELAY_S 5
49#define LP872X_EN_LDO1_M BIT(0)
50#define LP872X_EN_LDO2_M BIT(1)
51#define LP872X_EN_LDO3_M BIT(2)
52#define LP872X_EN_LDO4_M BIT(3)
53#define LP872X_EN_LDO5_M BIT(4)
54
55/* Mask/shift : LP8720 */
56#define LP8720_TIMESTEP_S 0 /* Addr 00h */
57#define LP8720_TIMESTEP_M BIT(0)
58#define LP8720_EXT_DVS_M BIT(2)
59#define LP8720_BUCK_FPWM_S 5 /* Addr 07h */
60#define LP8720_BUCK_FPWM_M BIT(5)
61#define LP8720_EN_BUCK_M BIT(5) /* Addr 08h */
62#define LP8720_DVS_SEL_M BIT(7)
63
64/* Mask/shift : LP8725 */
65#define LP8725_TIMESTEP_M 0xC0 /* Addr 00h */
66#define LP8725_TIMESTEP_S 6
67#define LP8725_BUCK1_EN_M BIT(0)
68#define LP8725_DVS1_M BIT(2)
69#define LP8725_DVS2_M BIT(3)
70#define LP8725_BUCK2_EN_M BIT(4)
71#define LP8725_BUCK_CL_M 0xC0 /* Addr 09h, 0Bh */
72#define LP8725_BUCK_CL_S 6
73#define LP8725_BUCK1_FPWM_S 1 /* Addr 0Ch */
74#define LP8725_BUCK1_FPWM_M BIT(1)
75#define LP8725_BUCK2_FPWM_S 5
76#define LP8725_BUCK2_FPWM_M BIT(5)
77#define LP8725_EN_LILO1_M BIT(5) /* Addr 0Dh */
78#define LP8725_EN_LILO2_M BIT(6)
79
80/* PWM mode */
81#define LP872X_FORCE_PWM 1
82#define LP872X_AUTO_PWM 0
83
84#define LP8720_NUM_REGULATORS 6
85#define LP8725_NUM_REGULATORS 9
86#define EXTERN_DVS_USED 0
87#define MAX_DELAY 6
88
Kim, Milob158fba2012-09-05 04:39:16 +000089/* Default DVS Mode */
90#define LP8720_DEFAULT_DVS 0
91#define LP8725_DEFAULT_DVS BIT(2)
92
Kim, Miloaf8b5fc2012-06-19 07:08:22 +000093/* dump registers in regmap-debugfs */
94#define MAX_REGISTERS 0x0F
95
96enum lp872x_id {
97 LP8720,
98 LP8725,
99};
100
101struct lp872x {
102 struct regmap *regmap;
103 struct device *dev;
104 enum lp872x_id chipid;
105 struct lp872x_platform_data *pdata;
106 struct regulator_dev **regulators;
107 int num_regulators;
108 enum lp872x_dvs_state dvs_pin;
109 int dvs_gpio;
110};
111
112/* LP8720/LP8725 shared voltage table for LDOs */
113static const unsigned int lp872x_ldo_vtbl[] = {
114 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000, 1550000,
115 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000, 2000000,
116 2100000, 2200000, 2300000, 2400000, 2500000, 2600000, 2650000, 2700000,
117 2750000, 2800000, 2850000, 2900000, 2950000, 3000000, 3100000, 3300000,
118};
119
120/* LP8720 LDO4 voltage table */
121static const unsigned int lp8720_ldo4_vtbl[] = {
122 800000, 850000, 900000, 1000000, 1100000, 1200000, 1250000, 1300000,
123 1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
124 1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
125 2400000, 2500000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000,
126};
127
128/* LP8725 LILO(Low Input Low Output) voltage table */
129static const unsigned int lp8725_lilo_vtbl[] = {
130 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000, 1150000,
131 1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
132 1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
133 2600000, 2700000, 2800000, 2850000, 2900000, 3000000, 3100000, 3300000,
134};
135
136/* LP8720 BUCK voltage table */
137#define EXT_R 0 /* external resistor divider */
138static const unsigned int lp8720_buck_vtbl[] = {
139 EXT_R, 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000,
140 1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
141 1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
142 1950000, 2000000, 2050000, 2100000, 2150000, 2200000, 2250000, 2300000,
143};
144
145/* LP8725 BUCK voltage table */
146static const unsigned int lp8725_buck_vtbl[] = {
147 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000, 1150000,
148 1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
149 1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
150 2400000, 2500000, 2600000, 2700000, 2800000, 2850000, 2900000, 3000000,
151};
152
153/* LP8725 BUCK current limit */
154static const unsigned int lp8725_buck_uA[] = {
155 460000, 780000, 1050000, 1370000,
156};
157
158static int lp872x_read_byte(struct lp872x *lp, u8 addr, u8 *data)
159{
160 int ret;
161 unsigned int val;
162
163 ret = regmap_read(lp->regmap, addr, &val);
164 if (ret < 0) {
165 dev_err(lp->dev, "failed to read 0x%.2x\n", addr);
166 return ret;
167 }
168
169 *data = (u8)val;
170 return 0;
171}
172
173static inline int lp872x_write_byte(struct lp872x *lp, u8 addr, u8 data)
174{
175 return regmap_write(lp->regmap, addr, data);
176}
177
178static inline int lp872x_update_bits(struct lp872x *lp, u8 addr,
179 unsigned int mask, u8 data)
180{
181 return regmap_update_bits(lp->regmap, addr, mask, data);
182}
183
184static int _rdev_to_offset(struct regulator_dev *rdev)
185{
186 enum lp872x_regulator_id id = rdev_get_id(rdev);
187
188 switch (id) {
189 case LP8720_ID_LDO1 ... LP8720_ID_BUCK:
190 return id;
191 case LP8725_ID_LDO1 ... LP8725_ID_BUCK2:
192 return id - LP8725_ID_BASE;
193 default:
194 return -EINVAL;
195 }
196}
197
198static int lp872x_get_timestep_usec(struct lp872x *lp)
199{
200 enum lp872x_id chip = lp->chipid;
201 u8 val, mask, shift;
202 int *time_usec, size, ret;
203 int lp8720_time_usec[] = { 25, 50 };
204 int lp8725_time_usec[] = { 32, 64, 128, 256 };
205
206 switch (chip) {
207 case LP8720:
208 mask = LP8720_TIMESTEP_M;
209 shift = LP8720_TIMESTEP_S;
210 time_usec = &lp8720_time_usec[0];
211 size = ARRAY_SIZE(lp8720_time_usec);
212 break;
213 case LP8725:
214 mask = LP8725_TIMESTEP_M;
215 shift = LP8725_TIMESTEP_S;
216 time_usec = &lp8725_time_usec[0];
217 size = ARRAY_SIZE(lp8725_time_usec);
218 break;
219 default:
220 return -EINVAL;
221 }
222
223 ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
224 if (ret)
225 return -EINVAL;
226
227 val = (val & mask) >> shift;
228 if (val >= size)
229 return -EINVAL;
230
231 return *(time_usec + val);
232}
233
234static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
235{
236 struct lp872x *lp = rdev_get_drvdata(rdev);
237 enum lp872x_regulator_id regulator = rdev_get_id(rdev);
238 int time_step_us = lp872x_get_timestep_usec(lp);
239 int ret, offset;
240 u8 addr, val;
241
242 if (time_step_us < 0)
243 return -EINVAL;
244
245 switch (regulator) {
246 case LP8720_ID_LDO1 ... LP8720_ID_LDO5:
247 case LP8725_ID_LDO1 ... LP8725_ID_LILO2:
248 offset = _rdev_to_offset(rdev);
249 if (offset < 0)
250 return -EINVAL;
251
252 addr = LP872X_LDO1_VOUT + offset;
253 break;
254 case LP8720_ID_BUCK:
255 addr = LP8720_BUCK_VOUT1;
256 break;
257 case LP8725_ID_BUCK1:
258 addr = LP8725_BUCK1_VOUT1;
259 break;
260 case LP8725_ID_BUCK2:
261 addr = LP8725_BUCK2_VOUT1;
262 break;
263 default:
264 return -EINVAL;
265 }
266
267 ret = lp872x_read_byte(lp, addr, &val);
268 if (ret)
269 return ret;
270
271 val = (val & LP872X_START_DELAY_M) >> LP872X_START_DELAY_S;
272
273 return val > MAX_DELAY ? 0 : val * time_step_us;
274}
275
Kim, Milo9d6da6f2012-09-05 04:39:33 +0000276static void lp872x_set_dvs(struct lp872x *lp, enum lp872x_dvs_sel dvs_sel,
277 int gpio)
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000278{
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000279 enum lp872x_dvs_state state;
280
281 state = dvs_sel == SEL_V1 ? DVS_HIGH : DVS_LOW;
282 gpio_set_value(gpio, state);
283 lp->dvs_pin = state;
284}
285
286static u8 lp872x_select_buck_vout_addr(struct lp872x *lp,
287 enum lp872x_regulator_id buck)
288{
289 u8 val, addr;
290
291 if (lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val))
292 return 0;
293
294 switch (buck) {
295 case LP8720_ID_BUCK:
296 if (val & LP8720_EXT_DVS_M) {
297 addr = (lp->dvs_pin == DVS_HIGH) ?
298 LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
299 } else {
300 if (lp872x_read_byte(lp, LP8720_ENABLE, &val))
301 return 0;
302
303 addr = val & LP8720_DVS_SEL_M ?
304 LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
305 }
306 break;
307 case LP8725_ID_BUCK1:
308 if (val & LP8725_DVS1_M)
309 addr = LP8725_BUCK1_VOUT1;
310 else
311 addr = (lp->dvs_pin == DVS_HIGH) ?
312 LP8725_BUCK1_VOUT1 : LP8725_BUCK1_VOUT2;
313 break;
314 case LP8725_ID_BUCK2:
315 addr = val & LP8725_DVS2_M ?
316 LP8725_BUCK2_VOUT1 : LP8725_BUCK2_VOUT2;
317 break;
318 default:
319 return 0;
320 }
321
322 return addr;
323}
324
325static bool lp872x_is_valid_buck_addr(u8 addr)
326{
327 switch (addr) {
328 case LP8720_BUCK_VOUT1:
329 case LP8720_BUCK_VOUT2:
330 case LP8725_BUCK1_VOUT1:
331 case LP8725_BUCK1_VOUT2:
332 case LP8725_BUCK2_VOUT1:
333 case LP8725_BUCK2_VOUT2:
334 return true;
335 default:
336 return false;
337 }
338}
339
340static int lp872x_buck_set_voltage_sel(struct regulator_dev *rdev,
341 unsigned selector)
342{
343 struct lp872x *lp = rdev_get_drvdata(rdev);
344 enum lp872x_regulator_id buck = rdev_get_id(rdev);
345 u8 addr, mask = LP872X_VOUT_M;
Kim, Milo9d6da6f2012-09-05 04:39:33 +0000346 struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000347
348 if (dvs && gpio_is_valid(dvs->gpio))
Kim, Milo9d6da6f2012-09-05 04:39:33 +0000349 lp872x_set_dvs(lp, dvs->vsel, dvs->gpio);
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000350
351 addr = lp872x_select_buck_vout_addr(lp, buck);
352 if (!lp872x_is_valid_buck_addr(addr))
353 return -EINVAL;
354
355 return lp872x_update_bits(lp, addr, mask, selector);
356}
357
358static int lp872x_buck_get_voltage_sel(struct regulator_dev *rdev)
359{
360 struct lp872x *lp = rdev_get_drvdata(rdev);
361 enum lp872x_regulator_id buck = rdev_get_id(rdev);
362 u8 addr, val;
363 int ret;
364
365 addr = lp872x_select_buck_vout_addr(lp, buck);
366 if (!lp872x_is_valid_buck_addr(addr))
367 return -EINVAL;
368
369 ret = lp872x_read_byte(lp, addr, &val);
370 if (ret)
371 return ret;
372
373 return val & LP872X_VOUT_M;
374}
375
376static int lp8725_buck_set_current_limit(struct regulator_dev *rdev,
377 int min_uA, int max_uA)
378{
379 struct lp872x *lp = rdev_get_drvdata(rdev);
380 enum lp872x_regulator_id buck = rdev_get_id(rdev);
Axel Lin4e1d67e2012-08-08 20:22:35 +0800381 int i;
382 u8 addr;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000383
384 switch (buck) {
385 case LP8725_ID_BUCK1:
386 addr = LP8725_BUCK1_VOUT2;
387 break;
388 case LP8725_ID_BUCK2:
389 addr = LP8725_BUCK2_VOUT2;
390 break;
391 default:
392 return -EINVAL;
393 }
394
Axel Lin4e1d67e2012-08-08 20:22:35 +0800395 for (i = ARRAY_SIZE(lp8725_buck_uA) - 1 ; i >= 0; i--) {
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000396 if (lp8725_buck_uA[i] >= min_uA &&
397 lp8725_buck_uA[i] <= max_uA)
Axel Lin4e1d67e2012-08-08 20:22:35 +0800398 return lp872x_update_bits(lp, addr,
399 LP8725_BUCK_CL_M,
400 i << LP8725_BUCK_CL_S);
401 }
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000402
Axel Lin4e1d67e2012-08-08 20:22:35 +0800403 return -EINVAL;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000404}
405
406static int lp8725_buck_get_current_limit(struct regulator_dev *rdev)
407{
408 struct lp872x *lp = rdev_get_drvdata(rdev);
409 enum lp872x_regulator_id buck = rdev_get_id(rdev);
410 u8 addr, val;
411 int ret;
412
413 switch (buck) {
414 case LP8725_ID_BUCK1:
415 addr = LP8725_BUCK1_VOUT2;
416 break;
417 case LP8725_ID_BUCK2:
418 addr = LP8725_BUCK2_VOUT2;
419 break;
420 default:
421 return -EINVAL;
422 }
423
424 ret = lp872x_read_byte(lp, addr, &val);
425 if (ret)
426 return ret;
427
428 val = (val & LP8725_BUCK_CL_M) >> LP8725_BUCK_CL_S;
429
430 return (val < ARRAY_SIZE(lp8725_buck_uA)) ?
431 lp8725_buck_uA[val] : -EINVAL;
432}
433
434static int lp872x_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
435{
436 struct lp872x *lp = rdev_get_drvdata(rdev);
437 enum lp872x_regulator_id buck = rdev_get_id(rdev);
438 u8 addr, mask, shift, val;
439
440 switch (buck) {
441 case LP8720_ID_BUCK:
442 addr = LP8720_BUCK_VOUT2;
443 mask = LP8720_BUCK_FPWM_M;
444 shift = LP8720_BUCK_FPWM_S;
445 break;
446 case LP8725_ID_BUCK1:
447 addr = LP8725_BUCK_CTRL;
448 mask = LP8725_BUCK1_FPWM_M;
449 shift = LP8725_BUCK1_FPWM_S;
450 break;
451 case LP8725_ID_BUCK2:
452 addr = LP8725_BUCK_CTRL;
453 mask = LP8725_BUCK2_FPWM_M;
454 shift = LP8725_BUCK2_FPWM_S;
455 break;
456 default:
457 return -EINVAL;
458 }
459
460 if (mode == REGULATOR_MODE_FAST)
461 val = LP872X_FORCE_PWM << shift;
462 else if (mode == REGULATOR_MODE_NORMAL)
463 val = LP872X_AUTO_PWM << shift;
464 else
465 return -EINVAL;
466
467 return lp872x_update_bits(lp, addr, mask, val);
468}
469
470static unsigned int lp872x_buck_get_mode(struct regulator_dev *rdev)
471{
472 struct lp872x *lp = rdev_get_drvdata(rdev);
473 enum lp872x_regulator_id buck = rdev_get_id(rdev);
474 u8 addr, mask, val;
475 int ret;
476
477 switch (buck) {
478 case LP8720_ID_BUCK:
479 addr = LP8720_BUCK_VOUT2;
480 mask = LP8720_BUCK_FPWM_M;
481 break;
482 case LP8725_ID_BUCK1:
483 addr = LP8725_BUCK_CTRL;
484 mask = LP8725_BUCK1_FPWM_M;
485 break;
486 case LP8725_ID_BUCK2:
487 addr = LP8725_BUCK_CTRL;
488 mask = LP8725_BUCK2_FPWM_M;
489 break;
490 default:
491 return -EINVAL;
492 }
493
494 ret = lp872x_read_byte(lp, addr, &val);
495 if (ret)
496 return ret;
497
498 return val & mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
499}
500
501static struct regulator_ops lp872x_ldo_ops = {
502 .list_voltage = regulator_list_voltage_table,
503 .set_voltage_sel = regulator_set_voltage_sel_regmap,
504 .get_voltage_sel = regulator_get_voltage_sel_regmap,
505 .enable = regulator_enable_regmap,
506 .disable = regulator_disable_regmap,
507 .is_enabled = regulator_is_enabled_regmap,
508 .enable_time = lp872x_regulator_enable_time,
509};
510
511static struct regulator_ops lp8720_buck_ops = {
512 .list_voltage = regulator_list_voltage_table,
513 .set_voltage_sel = lp872x_buck_set_voltage_sel,
514 .get_voltage_sel = lp872x_buck_get_voltage_sel,
515 .enable = regulator_enable_regmap,
516 .disable = regulator_disable_regmap,
517 .is_enabled = regulator_is_enabled_regmap,
518 .enable_time = lp872x_regulator_enable_time,
519 .set_mode = lp872x_buck_set_mode,
520 .get_mode = lp872x_buck_get_mode,
521};
522
523static struct regulator_ops lp8725_buck_ops = {
524 .list_voltage = regulator_list_voltage_table,
525 .set_voltage_sel = lp872x_buck_set_voltage_sel,
526 .get_voltage_sel = lp872x_buck_get_voltage_sel,
527 .enable = regulator_enable_regmap,
528 .disable = regulator_disable_regmap,
529 .is_enabled = regulator_is_enabled_regmap,
530 .enable_time = lp872x_regulator_enable_time,
531 .set_mode = lp872x_buck_set_mode,
532 .get_mode = lp872x_buck_get_mode,
533 .set_current_limit = lp8725_buck_set_current_limit,
534 .get_current_limit = lp8725_buck_get_current_limit,
535};
536
537static struct regulator_desc lp8720_regulator_desc[] = {
538 {
539 .name = "ldo1",
540 .id = LP8720_ID_LDO1,
541 .ops = &lp872x_ldo_ops,
542 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
543 .volt_table = lp872x_ldo_vtbl,
544 .type = REGULATOR_VOLTAGE,
545 .owner = THIS_MODULE,
546 .vsel_reg = LP872X_LDO1_VOUT,
547 .vsel_mask = LP872X_VOUT_M,
548 .enable_reg = LP8720_ENABLE,
549 .enable_mask = LP872X_EN_LDO1_M,
550 },
551 {
552 .name = "ldo2",
553 .id = LP8720_ID_LDO2,
554 .ops = &lp872x_ldo_ops,
555 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
556 .volt_table = lp872x_ldo_vtbl,
557 .type = REGULATOR_VOLTAGE,
558 .owner = THIS_MODULE,
559 .vsel_reg = LP872X_LDO2_VOUT,
560 .vsel_mask = LP872X_VOUT_M,
561 .enable_reg = LP8720_ENABLE,
562 .enable_mask = LP872X_EN_LDO2_M,
563 },
564 {
565 .name = "ldo3",
566 .id = LP8720_ID_LDO3,
567 .ops = &lp872x_ldo_ops,
568 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
569 .volt_table = lp872x_ldo_vtbl,
570 .type = REGULATOR_VOLTAGE,
571 .owner = THIS_MODULE,
572 .vsel_reg = LP872X_LDO3_VOUT,
573 .vsel_mask = LP872X_VOUT_M,
574 .enable_reg = LP8720_ENABLE,
575 .enable_mask = LP872X_EN_LDO3_M,
576 },
577 {
578 .name = "ldo4",
579 .id = LP8720_ID_LDO4,
580 .ops = &lp872x_ldo_ops,
581 .n_voltages = ARRAY_SIZE(lp8720_ldo4_vtbl),
582 .volt_table = lp8720_ldo4_vtbl,
583 .type = REGULATOR_VOLTAGE,
584 .owner = THIS_MODULE,
585 .vsel_reg = LP872X_LDO4_VOUT,
586 .vsel_mask = LP872X_VOUT_M,
587 .enable_reg = LP8720_ENABLE,
588 .enable_mask = LP872X_EN_LDO4_M,
589 },
590 {
591 .name = "ldo5",
592 .id = LP8720_ID_LDO5,
593 .ops = &lp872x_ldo_ops,
594 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
595 .volt_table = lp872x_ldo_vtbl,
596 .type = REGULATOR_VOLTAGE,
597 .owner = THIS_MODULE,
598 .vsel_reg = LP872X_LDO5_VOUT,
599 .vsel_mask = LP872X_VOUT_M,
600 .enable_reg = LP8720_ENABLE,
601 .enable_mask = LP872X_EN_LDO5_M,
602 },
603 {
604 .name = "buck",
605 .id = LP8720_ID_BUCK,
606 .ops = &lp8720_buck_ops,
607 .n_voltages = ARRAY_SIZE(lp8720_buck_vtbl),
608 .volt_table = lp8720_buck_vtbl,
609 .type = REGULATOR_VOLTAGE,
610 .owner = THIS_MODULE,
611 .enable_reg = LP8720_ENABLE,
612 .enable_mask = LP8720_EN_BUCK_M,
613 },
614};
615
616static struct regulator_desc lp8725_regulator_desc[] = {
617 {
618 .name = "ldo1",
619 .id = LP8725_ID_LDO1,
620 .ops = &lp872x_ldo_ops,
621 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
622 .volt_table = lp872x_ldo_vtbl,
623 .type = REGULATOR_VOLTAGE,
624 .owner = THIS_MODULE,
625 .vsel_reg = LP872X_LDO1_VOUT,
626 .vsel_mask = LP872X_VOUT_M,
627 .enable_reg = LP8725_LDO_CTRL,
628 .enable_mask = LP872X_EN_LDO1_M,
629 },
630 {
631 .name = "ldo2",
632 .id = LP8725_ID_LDO2,
633 .ops = &lp872x_ldo_ops,
634 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
635 .volt_table = lp872x_ldo_vtbl,
636 .type = REGULATOR_VOLTAGE,
637 .owner = THIS_MODULE,
638 .vsel_reg = LP872X_LDO2_VOUT,
639 .vsel_mask = LP872X_VOUT_M,
640 .enable_reg = LP8725_LDO_CTRL,
641 .enable_mask = LP872X_EN_LDO2_M,
642 },
643 {
644 .name = "ldo3",
645 .id = LP8725_ID_LDO3,
646 .ops = &lp872x_ldo_ops,
647 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
648 .volt_table = lp872x_ldo_vtbl,
649 .type = REGULATOR_VOLTAGE,
650 .owner = THIS_MODULE,
651 .vsel_reg = LP872X_LDO3_VOUT,
652 .vsel_mask = LP872X_VOUT_M,
653 .enable_reg = LP8725_LDO_CTRL,
654 .enable_mask = LP872X_EN_LDO3_M,
655 },
656 {
657 .name = "ldo4",
658 .id = LP8725_ID_LDO4,
659 .ops = &lp872x_ldo_ops,
660 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
661 .volt_table = lp872x_ldo_vtbl,
662 .type = REGULATOR_VOLTAGE,
663 .owner = THIS_MODULE,
664 .vsel_reg = LP872X_LDO4_VOUT,
665 .vsel_mask = LP872X_VOUT_M,
666 .enable_reg = LP8725_LDO_CTRL,
667 .enable_mask = LP872X_EN_LDO4_M,
668 },
669 {
670 .name = "ldo5",
671 .id = LP8725_ID_LDO5,
672 .ops = &lp872x_ldo_ops,
673 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
674 .volt_table = lp872x_ldo_vtbl,
675 .type = REGULATOR_VOLTAGE,
676 .owner = THIS_MODULE,
677 .vsel_reg = LP872X_LDO5_VOUT,
678 .vsel_mask = LP872X_VOUT_M,
679 .enable_reg = LP8725_LDO_CTRL,
680 .enable_mask = LP872X_EN_LDO5_M,
681 },
682 {
683 .name = "lilo1",
684 .id = LP8725_ID_LILO1,
685 .ops = &lp872x_ldo_ops,
686 .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
687 .volt_table = lp8725_lilo_vtbl,
688 .type = REGULATOR_VOLTAGE,
689 .owner = THIS_MODULE,
690 .vsel_reg = LP8725_LILO1_VOUT,
691 .vsel_mask = LP872X_VOUT_M,
692 .enable_reg = LP8725_LDO_CTRL,
693 .enable_mask = LP8725_EN_LILO1_M,
694 },
695 {
696 .name = "lilo2",
697 .id = LP8725_ID_LILO2,
698 .ops = &lp872x_ldo_ops,
699 .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
700 .volt_table = lp8725_lilo_vtbl,
701 .type = REGULATOR_VOLTAGE,
702 .owner = THIS_MODULE,
703 .vsel_reg = LP8725_LILO2_VOUT,
704 .vsel_mask = LP872X_VOUT_M,
705 .enable_reg = LP8725_LDO_CTRL,
706 .enable_mask = LP8725_EN_LILO2_M,
707 },
708 {
709 .name = "buck1",
710 .id = LP8725_ID_BUCK1,
711 .ops = &lp8725_buck_ops,
712 .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
713 .volt_table = lp8725_buck_vtbl,
714 .type = REGULATOR_VOLTAGE,
715 .owner = THIS_MODULE,
716 .enable_reg = LP872X_GENERAL_CFG,
717 .enable_mask = LP8725_BUCK1_EN_M,
718 },
719 {
720 .name = "buck2",
721 .id = LP8725_ID_BUCK2,
722 .ops = &lp8725_buck_ops,
723 .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
724 .volt_table = lp8725_buck_vtbl,
725 .type = REGULATOR_VOLTAGE,
726 .owner = THIS_MODULE,
727 .enable_reg = LP872X_GENERAL_CFG,
728 .enable_mask = LP8725_BUCK2_EN_M,
729 },
730};
731
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000732static int lp872x_init_dvs(struct lp872x *lp)
733{
734 int ret, gpio;
Kim, Milob158fba2012-09-05 04:39:16 +0000735 struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000736 enum lp872x_dvs_state pinstate;
Kim, Milob158fba2012-09-05 04:39:16 +0000737 u8 mask[] = { LP8720_EXT_DVS_M, LP8725_DVS1_M | LP8725_DVS2_M };
738 u8 default_dvs_mode[] = { LP8720_DEFAULT_DVS, LP8725_DEFAULT_DVS };
739
740 if (!dvs)
741 goto set_default_dvs_mode;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000742
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000743 gpio = dvs->gpio;
744 if (!gpio_is_valid(gpio)) {
745 dev_err(lp->dev, "invalid gpio: %d\n", gpio);
746 return -EINVAL;
747 }
748
749 pinstate = dvs->init_state;
750 ret = devm_gpio_request_one(lp->dev, gpio, pinstate, "LP872X DVS");
751 if (ret) {
752 dev_err(lp->dev, "gpio request err: %d\n", ret);
753 return ret;
754 }
755
756 lp->dvs_pin = pinstate;
757 lp->dvs_gpio = gpio;
758
759 return 0;
Kim, Milob158fba2012-09-05 04:39:16 +0000760
761set_default_dvs_mode:
762 return lp872x_update_bits(lp, LP872X_GENERAL_CFG, mask[lp->chipid],
763 default_dvs_mode[lp->chipid]);
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000764}
765
766static int lp872x_config(struct lp872x *lp)
767{
768 struct lp872x_platform_data *pdata = lp->pdata;
769 int ret;
770
Kim, Milo86b3fef2012-09-05 04:39:23 +0000771 if (!pdata || !pdata->update_config)
772 goto init_dvs;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000773
774 ret = lp872x_write_byte(lp, LP872X_GENERAL_CFG, pdata->general_config);
775 if (ret)
776 return ret;
777
Kim, Milo86b3fef2012-09-05 04:39:23 +0000778init_dvs:
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000779 return lp872x_init_dvs(lp);
780}
781
782static struct regulator_init_data
Axel Lin5bae0622012-07-15 16:57:12 +0800783*lp872x_find_regulator_init_data(int id, struct lp872x *lp)
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000784{
Kim, Milo9ffaa862012-09-05 04:39:11 +0000785 struct lp872x_platform_data *pdata = lp->pdata;
Axel Lin5bae0622012-07-15 16:57:12 +0800786 int i;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000787
Kim, Milo9ffaa862012-09-05 04:39:11 +0000788 if (!pdata)
789 return NULL;
790
Axel Lin5bae0622012-07-15 16:57:12 +0800791 for (i = 0; i < lp->num_regulators; i++) {
Kim, Milo9ffaa862012-09-05 04:39:11 +0000792 if (pdata->regulator_data[i].id == id)
793 return pdata->regulator_data[i].init_data;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000794 }
795
Axel Lin5bae0622012-07-15 16:57:12 +0800796 return NULL;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000797}
798
799static int lp872x_regulator_register(struct lp872x *lp)
800{
801 struct regulator_desc *desc;
802 struct regulator_config cfg = { };
803 struct regulator_dev *rdev;
804 int i, ret;
805
806 for (i = 0 ; i < lp->num_regulators ; i++) {
807 desc = (lp->chipid == LP8720) ? &lp8720_regulator_desc[i] :
808 &lp8725_regulator_desc[i];
809
810 cfg.dev = lp->dev;
Axel Lin5bae0622012-07-15 16:57:12 +0800811 cfg.init_data = lp872x_find_regulator_init_data(desc->id, lp);
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000812 cfg.driver_data = lp;
813 cfg.regmap = lp->regmap;
814
815 rdev = regulator_register(desc, &cfg);
816 if (IS_ERR(rdev)) {
817 dev_err(lp->dev, "regulator register err");
818 ret = PTR_ERR(rdev);
819 goto err;
820 }
821
822 *(lp->regulators + i) = rdev;
823 }
824
825 return 0;
826err:
827 while (--i >= 0) {
828 rdev = *(lp->regulators + i);
829 regulator_unregister(rdev);
830 }
831 return ret;
832}
833
834static void lp872x_regulator_unregister(struct lp872x *lp)
835{
836 struct regulator_dev *rdev;
837 int i;
838
839 for (i = 0 ; i < lp->num_regulators ; i++) {
840 rdev = *(lp->regulators + i);
841 regulator_unregister(rdev);
842 }
843}
844
845static const struct regmap_config lp872x_regmap_config = {
846 .reg_bits = 8,
847 .val_bits = 8,
848 .max_register = MAX_REGISTERS,
849};
850
851static int lp872x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
852{
853 struct lp872x *lp;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000854 int ret, size, num_regulators;
855 const int lp872x_num_regulators[] = {
856 [LP8720] = LP8720_NUM_REGULATORS,
857 [LP8725] = LP8725_NUM_REGULATORS,
858 };
859
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000860 lp = devm_kzalloc(&cl->dev, sizeof(struct lp872x), GFP_KERNEL);
861 if (!lp)
862 goto err_mem;
863
864 num_regulators = lp872x_num_regulators[id->driver_data];
865 size = sizeof(struct regulator_dev *) * num_regulators;
866
867 lp->regulators = devm_kzalloc(&cl->dev, size, GFP_KERNEL);
868 if (!lp->regulators)
869 goto err_mem;
870
871 lp->regmap = devm_regmap_init_i2c(cl, &lp872x_regmap_config);
872 if (IS_ERR(lp->regmap)) {
873 ret = PTR_ERR(lp->regmap);
874 dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);
875 goto err_dev;
876 }
877
878 lp->dev = &cl->dev;
Kim, Milo9ffaa862012-09-05 04:39:11 +0000879 lp->pdata = cl->dev.platform_data;
Kim, Miloaf8b5fc2012-06-19 07:08:22 +0000880 lp->chipid = id->driver_data;
881 lp->num_regulators = num_regulators;
882 i2c_set_clientdata(cl, lp);
883
884 ret = lp872x_config(lp);
885 if (ret)
886 goto err_dev;
887
888 return lp872x_regulator_register(lp);
889
890err_mem:
891 return -ENOMEM;
892err_dev:
893 return ret;
894}
895
896static int __devexit lp872x_remove(struct i2c_client *cl)
897{
898 struct lp872x *lp = i2c_get_clientdata(cl);
899
900 lp872x_regulator_unregister(lp);
901 return 0;
902}
903
904static const struct i2c_device_id lp872x_ids[] = {
905 {"lp8720", LP8720},
906 {"lp8725", LP8725},
907 { }
908};
909MODULE_DEVICE_TABLE(i2c, lp872x_ids);
910
911static struct i2c_driver lp872x_driver = {
912 .driver = {
913 .name = "lp872x",
914 .owner = THIS_MODULE,
915 },
916 .probe = lp872x_probe,
917 .remove = __devexit_p(lp872x_remove),
918 .id_table = lp872x_ids,
919};
920
921module_i2c_driver(lp872x_driver);
922
923MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
924MODULE_AUTHOR("Milo Kim");
925MODULE_LICENSE("GPL");